GitHub

EncodeKeys

API reference for EncodeKeys.

encode_keys(mapping): apply with .pipe to a struct or class.

Functions

__init__

__init__(mapping) -> None
ParameterTypeDescription
mappingMapping[str, str]
def __init__(self, mapping: Mapping[str, str]) -> None:
    self._mapping = dict(mapping)

__call__

__call__[T, RD, RE](schema) -> Bottom[T, Mapping[str, object], RD, RE]
ParameterTypeDescription
schemaCodec[T, Mapping[str, object], RD, RE]

Returns Bottom[T, Mapping[str, object], RD, RE]

def __call__[T, RD, RE](
    self, schema: Codec[T, Mapping[str, object], RD, RE], /
) -> Bottom[T, Mapping[str, object], RD, RE]:
    node = schema.__codec__().ast
    encoded = ast.to_encoded(node)
    if isinstance(encoded, ast.Class):
        encoded = encoded.shape.encoded
    if not isinstance(encoded, ast.Objects):
        msg = f"encode_keys needs a struct or class, got {encoded.tag}"
        raise TypeError(msg)
    unknown = [key for key in self._mapping if all(p.name != key for p in encoded.properties)]
    if unknown:
        msg = f"Unknown keys in encode_keys mapping: {stringify(unknown)}"
        raise ValueError(msg)
    names = [self._mapping.get(str(p.name), p.name) for p in encoded.properties]
    if len(dedupe(names)) != len(names):
        msg = f"Duplicate encoded keys in {stringify(self._mapping)}"
        raise ValueError(msg)
    source = replace(
        encoded,
        properties=tuple(
            replace(p, name=name) for p, name in zip(encoded.properties, names, strict=True)
        ),
    )
    back = {encoded_name: name for name, encoded_name in self._mapping.items()}
    renaming = transform(
        decode=lambda value: _renamed(back, value),
        encode=lambda value: _renamed(self._mapping, value),
    )
    return Bottom(ast.decode_to(source, node, renaming))