bagofholding.content module

Content controls the decomposition of python objects into their component parts, along with a record of what type of object they are, and gathering any relevant metadata.

Content is not, of itself, concerned with what you _do_ with this decompositon. That is handled via the “packer” protocol (for us, the relevant implementation of this is “bags”).

class bagofholding.content.BespokeItem

Bases: ReflexiveItem[ItemType, PackerType], Generic[ItemType, PackerType], ABC

class bagofholding.content.Bool

Bases: BuiltinItem[bool]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → bool

class bagofholding.content.BuiltinGroup

Bases: ReflexiveGroup[BuiltinGroupType], Generic[BuiltinGroupType], ABC

classmethod pack(obj: PackingType, packer: Packer, path: str, packing: PackingArguments) → None

class bagofholding.content.BuiltinItem

Bases: ReflexiveItem[BuiltinItemType, Packer], Generic[BuiltinItemType], ABC

class bagofholding.content.Bytearray

Bases: BuiltinItem[bytearray]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → bytearray

class bagofholding.content.Bytes

Bases: BuiltinItem[bytes]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → bytes

class bagofholding.content.Complex

Bases: BuiltinItem[complex]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → complex

class bagofholding.content.Content

Bases: Generic[PackingType, UnpackingType, PackerType], ABC

classmethod full_name() → str

abstractmethod classmethod pack(obj: PackingType, packer: PackerType, path: str, packing: PackingArguments) → None

abstractmethod classmethod unpack(packer: PackerType, path: str, unpacking: UnpackingArguments) → UnpackingType

class bagofholding.content.Dict

Bases: BuiltinGroup[dict[Any, Any]]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → dict[Any, Any]

class bagofholding.content.Float

Bases: BuiltinItem[float]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → float

class bagofholding.content.FrozenSet

Bases: Indexable[frozenset[Any]]

recast

alias of frozenset

class bagofholding.content.Global

Bases: Item[type[type] | LambdaType | str, Any, Packer]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → Any

class bagofholding.content.Group

Bases: Content[PackingType, UnpackingType, Packer], Generic[PackingType, UnpackingType], ABC

class bagofholding.content.HasContents(*args, **kwargs)

Bases: Sized, Iterable[str], Protocol

class bagofholding.content.Indexable

Bases: BuiltinGroup[IndexableType], Generic[IndexableType], ABC

recast: type[IndexableType]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → IndexableType

class bagofholding.content.Item

Bases: Content[PackingType, UnpackingType, PackerType], Generic[PackingType, UnpackingType, PackerType], ABC

classmethod pack(obj: PackingType, packer: PackerType, path: str, packing: PackingArguments) → None

class bagofholding.content.List

Bases: Indexable[list[Any]]

recast

alias of list

class bagofholding.content.Long

Bases: BuiltinItem[int]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → int

class bagofholding.content.NoneItem

Bases: Item[type[None], None, Packer]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → None

class bagofholding.content.NotData

Bases: object

class bagofholding.content.Packer(*args, **kwargs)

Bases: Protocol

create_group(path: str) → None

get_bespoke_content_class(obj: object) → type[BespokeItem[Any, Self]] | None

join(*paths: str) → str

open_group(path: str) → HasContents

pack_bool(obj: bool, path: str) → None

pack_bytearray(obj: bytearray, path: str) → None

pack_bytes(obj: bytes, path: str) → None

pack_complex(obj: complex, path: str) → None

pack_empty(path: str) → None

pack_float(obj: float, path: str) → None

pack_long(obj: int, path: str) → None

pack_metadata(metadata: Metadata, path: str) → None

pack_string(obj: str, path: str) → None

unpack_bool(path: str) → bool

unpack_bytearray(path: str) → bytearray

unpack_bytes(path: str) → bytes

unpack_complex(path: str) → complex

unpack_float(path: str) → float

unpack_long(path: str) → int

unpack_metadata(path: str) → Metadata

unpack_string(path: str) → str

class bagofholding.content.PackingArguments(memo: 'PackingMemoAlias', references: 'ReferencesAlias', require_versions: 'bool', forbidden_modules: 'list[str] | tuple[str, ...]', version_scraping: 'VersionScrapingMap | None', _pickle_protocol: 'SupportsIndex')

Bases: object

forbidden_modules: list[str] | tuple[str, ...]

memo: bidict[int, str]

references: list[object]

require_versions: bool

version_scraping: dict[str, Callable[[str], str | None]] | None

class bagofholding.content.Reducible

Bases: ReflexiveGroup[object]

classmethod pack(obj: object, packer: Packer, path: str, packing: PackingArguments, rv: tuple[Callable[[...], object], tuple[object, ...]] | tuple[Callable[[...], object], tuple[object, ...], object | None] | tuple[Callable[[...], object], tuple[object, ...], object | None, Iterator[object] | None] | tuple[Callable[[...], object], tuple[object, ...], object | None, Iterator[object] | None, Iterator[tuple[object, object]] | None] | tuple[Callable[[...], object] | None, tuple[object, ...] | None, object | None, Iterator[object] | None, Iterator[tuple[object, object]] | None, Callable[[object, object], None] | None] | None = None) → None

reduction_fields: ClassVar[tuple[str, str, str, str, str, str]] = ('constructor', 'args', 'state', 'item_iterator', 'kv_iterator', 'setter')

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → object

class bagofholding.content.Reference

Bases: Item[str, Any, Packer]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → Any

class bagofholding.content.ReflexiveGroup

Bases: Group[GroupType, GroupType], Generic[GroupType], ABC

class bagofholding.content.ReflexiveItem

Bases: Item[ItemType, ItemType, PackerType], Generic[ItemType, PackerType], ABC

class bagofholding.content.Set

Bases: Indexable[set[Any]]

recast

alias of set

class bagofholding.content.Str

Bases: BuiltinItem[str]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → str

class bagofholding.content.StrKeyDict

Bases: BuiltinGroup[dict[str, Any]]

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → dict[str, Any]

class bagofholding.content.Tuple

Bases: Indexable[tuple[Any, …]]

recast

alias of tuple

class bagofholding.content.Union

Bases: BuiltinGroup[Union]

types.UnionType has no __reduce__() method. Pickle actually gets around this with bespoke logic, and so we need to too.

classmethod unpack(packer: Packer, path: str, unpacking: UnpackingArguments) → Union

class bagofholding.content.UnpackingArguments(memo: 'UnpackingMemoAlias', version_validator: 'VersionValidatorType', version_scraping: 'VersionScrapingMap | None')

Bases: object

memo: dict[str, Any]

version_scraping: dict[str, Callable[[str], str | None]] | None

version_validator: Literal['exact', 'semantic-minor', 'semantic-major', 'none'] | Callable[[str, str], bool]

bagofholding.content.get_group_content_class(obj: object) → type[Group[Any, Any]] | None

bagofholding.content.has_surrogates(s: str) → bool

bagofholding.content.is_simple_string(string: str) → bool

bagofholding.content.pack(obj: object, packer: Packer, path: str, memo: bidict[int, str], references: list[object], require_versions: bool, forbidden_modules: list[str] | tuple[str, ...], version_scraping: dict[str, Callable[[str], str | None]] | None, _pickle_protocol: SupportsIndex = 4) → None

bagofholding.content.unpack(packer: Packer, path: str, memo: dict[str, Any], version_validator: Literal['exact', 'semantic-minor', 'semantic-major', 'none'] | Callable[[str, str], bool], version_scraping: dict[str, Callable[[str], str | None]] | None) → object