Super Collections

0.6.2 · active · verified Fri Apr 10

Super Collections is a Python library (current version 0.6.2) that provides enhanced data structures, `SuperList` and `SuperDict`, which are designed for deeply nested data, similar to JSON or YAML structures. It offers features like recursive conversion of Python data structures, convenient dot-based access to nested elements, and a `super_collect()` factory function for easy instantiation. The library aims to simplify working with complex, nested collections and is actively maintained.

Warnings

gotcha The `SuperCollection` class is an abstract base class and cannot be instantiated directly. `SuperList` and `SuperDict` are the concrete, instantiable collection types that are instances of `SuperCollection`.
Fix: Always use `SuperList()`, `SuperDict()`, or the `super_collect()` factory function to create collection instances.
gotcha The `super_collect()` factory function performs recursive conversion of Python lists and dictionaries into `SuperList` and `SuperDict` instances. This might implicitly change the type of nested standard Python collections, which could be unexpected if strict preservation of original container types (e.g., `list` instead of `SuperList`) is critical for certain custom objects or behaviors.
Fix: Be aware that inputs passed to `super_collect()` will be deeply converted. If specific nested types must be preserved, consider manual construction or shallow copying where appropriate.
gotcha When using dot notation (e.g., `my_superdict.non_existent_key`) for accessing elements, attempting to access a non-existent key will raise an `AttributeError`, not a `KeyError` as with standard Python dictionaries. This distinction is important for error handling.
Fix: Use `try-except AttributeError` for gracefully handling missing keys when using dot notation, or check for key existence (e.g., `if 'key' in my_superdict:`) before access.

Install

pip install super-collections Install stable version

Imports

super_collect
```
from super_collections import super_collect
```
Use the factory function to create SuperList or SuperDict instances from existing data.
SuperList
```
from super_collections import SuperList
```
Represents an enhanced list supporting nested SuperCollections and dot access.
SuperDict
```
from super_collections import SuperDict
```
Represents an enhanced dictionary supporting nested SuperCollections and dot access.
SuperCollection
```
from super_collections import SuperCollection
```
SuperCollection is an abstract base class; it cannot be directly instantiated. SuperList and SuperDict are concrete implementations.

Quickstart

This quickstart demonstrates how to create `SuperDict` and `SuperList` instances using the `super_collect` factory function and access nested data using convenient dot notation.

from super_collections import super_collect, SuperList, SuperDict

# Create a SuperDict from a regular Python dictionary
data = {'user': {'name': 'Alice', 'details': {'age': 30, 'city': 'NY'}} }
sd = super_collect(data)

# Access nested elements using dot notation
print(f"User name: {sd.user.name}")
print(f"User city: {sd.user.details.city}")

# Create a SuperList from a regular Python list
items = [1, {'product': 'Laptop', 'price': 1200}, 3]
sl = super_collect(items)

# Access elements in a SuperList
print(f"First item: {sl[0]}")
print(f"Product name: {sl[1].product}")

# Modify elements
sd.user.details.age = 31
print(f"Updated age: {sd.user.details.age}")

view raw JSON →