encode_keys(mapping): apply with .pipe to a struct or class.
Functions#
__init__#
__init__(mapping) -> None| Parameter | Type | Description |
|---|---|---|
mapping | Mapping[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]| Parameter | Type | Description |
|---|---|---|
schema | Codec[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))