thds.atacama 0.0.1__py3-none-any.whl → 1.0.20250123022552__py3-none-any.whl

thds/atacama/__init__.py

@@ -0,0 +1,5 @@
+from ._config import config  # noqa: F401
+from ._meta import meta  # noqa: F401
+from .generators import neo, ordered  # noqa: F401
+from .leaf import AtacamaBaseLeafTypeMapping, DynamicLeafTypeMapping  # noqa: F401
+from .schemas import SchemaGenerator  # noqa: F401

thds/atacama/_attrs.py

@@ -0,0 +1,55 @@
+import typing as ty
+
+import attrs
+import marshmallow
+
+T = ty.TypeVar("T")
+
+
+def generate_attrs_post_load(attrs_class: ty.Type[T]):
+    @marshmallow.post_load
+    def post_load(self, data: dict, **_kw) -> T:
+        return attrs_class(**data)
+
+    return post_load
+
+
+def _get_attrs_field_default(
+    field: "attrs.Attribute[object]",
+) -> object:
+    # copyright Desert contributors - see LICENSE_desert.md
+    if field.default == attrs.NOTHING:
+        return marshmallow.missing
+    if isinstance(field.default, attrs.Factory):  # type: ignore[arg-type]
+        # attrs specifically doesn't support this so as to support the
+        # primary use case.
+        # https://github.com/python-attrs/attrs/blob/38580632ceac1cd6e477db71e1d190a4130beed4/src/attr/__init__.pyi#L63-L65
+        if field.default.takes_self:  # type: ignore[attr-defined]
+            return attrs.NOTHING
+        return field.default.factory  # type: ignore[attr-defined]
+    return field.default
+
+
+class Attribute(ty.NamedTuple):
+    name: str
+    type: type
+    init: bool
+    default: object
+
+
+def yield_attributes(attrs_class: type) -> ty.Iterator[Attribute]:
+    hints = ty.get_type_hints(attrs_class)
+    for attribute in attrs.fields(attrs_class):
+        yield Attribute(
+            attribute.name,
+            hints.get(attribute.name, attribute.type),
+            attribute.init,
+            _get_attrs_field_default(attribute),
+        )
+
+
+def is_attrs_class(cls: type) -> bool:
+    try:
+        return bool(attrs.fields(cls))
+    except TypeError:
+        return False

thds/atacama/_cache.py

@@ -0,0 +1,37 @@
+"""A simple equality-based cache for schema generation."""
+import typing as ty
+from collections import defaultdict
+from functools import wraps
+
+import marshmallow
+
+GenSchema = ty.TypeVar("GenSchema", bound=ty.Callable[..., ty.Type[marshmallow.Schema]])
+GenSchemaCachingDeco = ty.Callable[[GenSchema], GenSchema]
+
+
+def attrs_schema_cache() -> GenSchemaCachingDeco:
+    """Allows sharing an attrs schema cache across multiple schema generators."""
+    schema_name_onto_arguments_and_schema: ty.Dict[
+        str, ty.List[ty.Tuple[ty.Tuple[tuple, dict], ty.Type[marshmallow.Schema]]]
+    ] = defaultdict(list)
+
+    def attrs_schema_cache_deco(gen_schema: GenSchema) -> GenSchema:
+        @wraps(gen_schema)
+        def caching_gen_schema(*args, **kwargs):
+            # the following two lines are purely an optimization,
+            # so we don't have to search through all possible schemas generated.
+            schema_typename = str(args[0])
+            args_and_schemas = schema_name_onto_arguments_and_schema[schema_typename]
+
+            arguments = (args, kwargs)
+            for schema_arguments, schema in args_and_schemas:
+                if schema_arguments == arguments:
+                    return schema
+
+            schema = gen_schema(*args, **kwargs)
+            schema_name_onto_arguments_and_schema[schema_typename].append((arguments, schema))
+            return schema
+
+        return ty.cast(GenSchema, caching_gen_schema)
+
+    return attrs_schema_cache_deco

thds/atacama/_config.py

@@ -0,0 +1,42 @@
+"""Allow recursive control of Schema generation.
+
+If you're looking for Schema load/dump behavior, that belongs to
+Marshmallow itself and can consequently be configured via _meta.py.
+
+"""
+import typing as ty
+
+from thds.core.stack_context import StackContext  # this is our only 'dependency' on core.
+
+
+class _GenConfig(ty.NamedTuple):
+    """Do not construct these directly; they are an implementation detail and subject to change."""
+
+    require_all: bool
+    schema_name_suffix: str
+
+
+def config(require_all: bool = False, schema_name_suffix: str = "") -> _GenConfig:
+    """Create a Schema Generation Config.
+
+    :param require_all: The Schema will enforce `required` for all
+      attributes on load. This can also be used to generate a
+      dump-only schema that accurately describes the way that all
+      attributes are 'require_all' to be present upon dump, since
+      OpenAPI and JSON schema do not provide a way to distinguish
+      between the semantics of "input required" and "output
+      require_all".
+
+    :param schema_name_suffix: does what it says on the tin. Sometimes
+      you want to generate a different Schema from the same class and
+      you don't want the generated suffixes that Marshmallow gives
+      you.
+
+    """
+    return _GenConfig(require_all=require_all, schema_name_suffix=schema_name_suffix)
+
+
+PerGenerationConfigContext = StackContext(
+    "atacama-per-generation-config-context",
+    config(),
+)

thds/atacama/_generic_dispatch.py

@@ -0,0 +1,64 @@
+# portions copyright Desert contributors - see LICENSE_desert.md
+import collections
+import typing as ty
+
+import typing_inspect
+
+NoneType = type(None)
+
+
+def generic_types_dispatch(
+    sequence_handler,
+    set_handler,
+    tuple_handler,
+    mapping_handler,
+    optional_handler,
+    union_handler,
+    newtype_handler,
+    fallthrough_handler,
+):
+    def type_discriminator(typ: ty.Type):
+        if origin := typing_inspect.get_origin(typ) or ty.get_origin(
+            typ
+        ):  # in case typing_inspect fails
+            # each of these internal calls to field_for_schema for a Generic is recursive
+            arguments = typing_inspect.get_args(typ, True)
+
+            if origin in (
+                list,
+                ty.List,
+                ty.Sequence,
+                ty.MutableSequence,
+                collections.abc.Sequence,
+                collections.abc.MutableSequence,
+            ):
+                return sequence_handler(arguments[0])
+            if origin in (set, ty.Set, ty.MutableSet):
+                return set_handler(arguments[0])
+            if origin in (tuple, ty.Tuple) and Ellipsis not in arguments:
+                return tuple_handler(arguments, variadic=False)
+            if origin in (tuple, ty.Tuple) and Ellipsis in arguments:
+                return tuple_handler([arguments[0]], variadic=True)
+            if origin in (
+                dict,
+                ty.Dict,
+                ty.Mapping,
+                ty.MutableMapping,
+                collections.abc.Mapping,
+                collections.abc.MutableMapping,
+            ):
+                return mapping_handler(arguments[0], arguments[1])
+            if typing_inspect.is_optional_type(typ):
+                non_none_subtypes = tuple(t for t in arguments if t is not NoneType)
+                return optional_handler(non_none_subtypes)
+            if typing_inspect.is_union_type(typ):
+                return union_handler(arguments)
+
+        newtype_supertype = getattr(typ, "__supertype__", None)
+        if newtype_supertype and typing_inspect.is_new_type(typ):
+            # this is just an unwrapping step.
+            return newtype_handler(newtype_supertype)
+
+        return fallthrough_handler(typ)
+
+    return type_discriminator

thds/atacama/_meta.py

@@ -0,0 +1,17 @@
+"""Meta is a Marshmallow-specific concept and is a way of
+configuring Schema load/dump behavior recursively.
+
+We have an additional layer of configuration for Schema _generation_,
+and that lives in _config.py.
+"""
+import typing as ty
+
+SchemaMeta = ty.NewType("SchemaMeta", type)
+
+
+_META_DEFAULTS = dict(ordered=True)
+# We see no reason to ever throw away the order defined by the programmer.
+
+
+def meta(**meta) -> SchemaMeta:
+    return type("Meta", (), {**_META_DEFAULTS, **meta})  # type: ignore

thds/atacama/custom_fields.py

@@ -0,0 +1,25 @@
+"""Support custom fields that seem necessary to us."""
+import typing as ty
+
+import marshmallow as ma
+
+
+class Set(ma.fields.List):
+    """Marshmallow is dragging their feet on implementing a Set Field.
+
+    https://github.com/marshmallow-code/marshmallow/issues/1549
+
+    But we can implement a simple version that basically works.
+    """
+
+    def _serialize(self, value, attr, obj, **kwargs) -> ty.Union[ty.List[ty.Any], None]:
+        if value is None:
+            return None
+        # we run a sort because even though roundtrip doesn't
+        # guarantee the same value that was deserialized, we'd like
+        # for the serialized output to be stable/deterministic.
+        return [self.inner._serialize(each, attr, obj, **kwargs) for each in sorted(value)]
+
+    def _deserialize(self, value, attr, data, **kwargs) -> ty.Set[ty.Any]:  # type: ignore
+        val = super()._deserialize(value, attr, data, **kwargs)
+        return set(val)

thds/atacama/field_transforms.py

@@ -0,0 +1,17 @@
+import typing as ty
+from copy import deepcopy
+
+import marshmallow  # type: ignore
+
+FieldTransform = ty.Callable[[marshmallow.fields.Field], marshmallow.fields.Field]
+
+
+def apply_field_xfs(
+    field_transforms: ty.Sequence[FieldTransform], fields: ty.Dict[str, marshmallow.fields.Field]
+) -> ty.Dict[str, marshmallow.fields.Field]:
+    def apply_all(field):
+        for fxf in field_transforms:
+            field = fxf(deepcopy(field))
+        return field
+
+    return {name: apply_all(field) for name, field in fields.items()}

thds/atacama/fields.py

@@ -0,0 +1,120 @@
+# portions copyright Desert contributors - see LICENSE_desert.md
+import enum
+import typing as ty
+from functools import partial
+
+import marshmallow  # type: ignore
+import typing_inspect  # type: ignore
+
+from . import custom_fields
+from ._generic_dispatch import generic_types_dispatch
+from .leaf import LeafTypeMapping
+
+
+class VariadicTuple(marshmallow.fields.List):
+    """Homogenous tuple with variable number of entries."""
+
+    def _deserialize(self, *args: object, **kwargs: object) -> ty.Tuple[object, ...]:  # type: ignore[override]
+        return tuple(super()._deserialize(*args, **kwargs))
+
+
+T = ty.TypeVar("T")
+NoneType = type(None)
+
+
+# most kwargs for a field belong to the surrounding context,
+# e.g. the name and the aggregation that this field lives in.
+# Therefore, each can be consumed separately from the recursion that happens here.
+# One exception is for an Optional field, which is a 'discovery' of allow_none
+# that we could not previously have derived.
+# The other two exceptions are 'validate', which is applied according to business requirements
+# that cannot be derived from the context of the schema, and 'error_messages', which is the same.
+
+
+def generate_field(
+    leaf_types: LeafTypeMapping,
+    schema_generator: ty.Callable[[type], ty.Type[marshmallow.Schema]],
+    typ: type,
+    field_kwargs: ty.Mapping[str, ty.Any] = dict(),  # noqa: [B006]
+) -> marshmallow.fields.Field:
+    """Return a Marshmallow Field or Schema.
+
+    Return a Field if a leaf type can be resolved.or if a leaf type
+    can be 'unwrapped' from a Generic or other wrapper type.
+
+    If no leaf type can be resolved, attempts to construct a Nested Schema.
+
+    Derives certain Field keyword arguments from the unwrapping process.
+    """
+    # this is the base case recursively - a known leaf type.
+    if typ in leaf_types:
+        return leaf_types[typ](**field_kwargs)
+
+    gen_field = partial(generate_field, leaf_types, schema_generator)
+    # all recursive calls from here on out
+
+    def prefer_field_kwargs(**kwargs):
+        """In a couple of cases, we generate some Field kwargs, but we
+        also want to prefer whatever may have been manually specified.
+        """
+        return {**kwargs, **field_kwargs}
+
+    def tuple_handler(types: ty.Type, variadic: bool):
+        if not variadic:
+            return marshmallow.fields.Tuple(  # type: ignore[no-untyped-call]
+                tuple(gen_field(typ) for typ in types),
+                **field_kwargs,
+            )
+        return VariadicTuple(gen_field(types[0]), **field_kwargs)
+
+    def union_handler(types, **field_kwargs):
+        import marshmallow_union  # type: ignore
+
+        return marshmallow_union.Union([gen_field(subtyp) for subtyp in types], **field_kwargs)
+
+    def optional_handler(non_none_subtypes):
+        # Optionals are a special case of Union. _if_ the union is
+        # fully coalesced, we can treat it as a simple field.
+        if len(non_none_subtypes) == 1:
+            # Treat single-argument optional types as a field with a None default
+            return gen_field(non_none_subtypes[0], prefer_field_kwargs(allow_none=True))
+        # Otherwise, we must fall back to handling it as a Union.
+        return union_handler(non_none_subtypes, **prefer_field_kwargs(allow_none=True))
+
+    def fallthrough_handler(typ: ty.Type):
+        if type(typ) is enum.EnumMeta:
+            import marshmallow_enum  # type: ignore
+
+            return marshmallow_enum.EnumField(typ, **field_kwargs)
+
+        # Nested dataclasses
+        forward_reference = typing_inspect.get_forward_arg(typ)
+        if forward_reference:
+            # TODO this is not getting hit - I think because typing_inspect.get_args
+            # resolves all ForwardRefs that live inside any kind of Generic type, including Unions,
+            # turning them into _not_ ForwardRefs anymore.a
+            return marshmallow.fields.Nested(forward_reference, **field_kwargs)
+        # by using a lambda here, we can provide full support for self-recursive schemas
+        # the same way Marshmallow itself does:
+        # https://marshmallow.readthedocs.io/en/stable/nesting.html#nesting-a-schema-within-itself
+        #
+        # One disadvantage is that we defer errors until runtime, so it may be worth considering
+        # whether we should find a different way of 'discovering' mutually-recursive types
+        try:
+            nested_schema = schema_generator(typ)
+        except RecursionError:
+            nested_schema = lambda: schema_generator(typ)  # type: ignore # noqa: E731
+        return marshmallow.fields.Nested(nested_schema, **field_kwargs)
+
+    return generic_types_dispatch(
+        sequence_handler=lambda typ: marshmallow.fields.List(gen_field(typ), **field_kwargs),
+        set_handler=lambda typ: custom_fields.Set(gen_field(typ), **field_kwargs),
+        tuple_handler=tuple_handler,
+        mapping_handler=lambda keytype, valtype: marshmallow.fields.Dict(
+            **prefer_field_kwargs(keys=gen_field(keytype), values=gen_field(valtype))
+        ),
+        optional_handler=optional_handler,
+        union_handler=union_handler,
+        newtype_handler=lambda newtype_supertype: gen_field(newtype_supertype, field_kwargs),
+        fallthrough_handler=fallthrough_handler,
+    )(typ)

thds/atacama/generators.py

@@ -0,0 +1,11 @@
+"""Built-in generators recommended for use."""
+from ._cache import attrs_schema_cache
+from ._meta import meta
+from .nonempty import nonempty_validator_xf
+from .schemas import SchemaGenerator
+
+neo = SchemaGenerator(meta(), [nonempty_validator_xf], cache=attrs_schema_cache())
+"""Non-Empty, Ordered - the preferred default API."""
+
+ordered = SchemaGenerator(meta(), list(), cache=attrs_schema_cache())
+"""Ordered, but allows empty values for required fields. Prefer neo for new usage."""

thds/atacama/leaf.py

@@ -0,0 +1,127 @@
+# portions copyright Desert contributors - see LICENSE_desert.md
+import datetime
+import decimal
+import typing as ty
+import uuid
+
+import marshmallow
+import typing_inspect
+from typing_extensions import Protocol
+
+# Default leaf types used by `generate_fields`.
+# It is possible to swap in your own definitions via a SchemaGenerator.
+LeafType = ty.Union[type, ty.Any]
+
+
+class LeafTypeMapping(Protocol):
+    def __contains__(self, __key: LeafType) -> bool:
+        ...  # pragma: nocover
+
+    def __getitem__(self, __key: LeafType) -> ty.Type[marshmallow.fields.Field]:
+        ...  # pragma: nocover
+
+
+FieldType = ty.Type[marshmallow.fields.Field]
+FieldT = ty.TypeVar("FieldT", bound=FieldType)
+
+
+def _field_with_default_kwargs(field: FieldT, **default_kwargs) -> FieldT:
+    def fake_field(**kwargs):
+        combined = {**default_kwargs, **kwargs}
+        return field(**combined)
+
+    return ty.cast(FieldT, fake_field)
+
+
+def allow_already_parsed(typ: ty.Type, mm_field: FieldT) -> FieldT:
+    """For certain types, it's quite common to want to be able to pass
+    an already-deserialized version of that item without error,
+    especially if you want to be able to use a Schema against both a
+    database abstraction (e.g. SQLAlchemy) and an API.
+
+    E.g., there's no need to throw an error if you're expecting a
+    datetime string so you can turn it into a datetime, but you get a
+    datetime itself.
+    """
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        if isinstance(value, typ):
+            return value
+        return mm_field._deserialize(self, value, attr, data, **kwargs)
+
+    return ty.cast(
+        FieldT,
+        type(
+            mm_field.__name__ + "AllowsAlreadyDeserialized",
+            (mm_field,),  # inherits from this field type
+            dict(_deserialize=_deserialize),
+        ),
+    )
+
+
+NATIVE_TO_MARSHMALLOW: LeafTypeMapping = {
+    float: marshmallow.fields.Float,
+    int: marshmallow.fields.Integer,
+    str: marshmallow.fields.String,
+    bool: marshmallow.fields.Boolean,
+    datetime.datetime: allow_already_parsed(datetime.datetime, marshmallow.fields.DateTime),
+    datetime.time: marshmallow.fields.Time,
+    datetime.timedelta: allow_already_parsed(datetime.timedelta, marshmallow.fields.TimeDelta),
+    datetime.date: allow_already_parsed(datetime.date, marshmallow.fields.Date),
+    decimal.Decimal: allow_already_parsed(decimal.Decimal, marshmallow.fields.Decimal),
+    uuid.UUID: marshmallow.fields.UUID,
+    ty.Union[int, float]: marshmallow.fields.Number,
+    ty.Any: _field_with_default_kwargs(marshmallow.fields.Raw, allow_none=True),
+}
+
+
+OptFieldType = ty.Optional[FieldType]
+TypeHandler = ty.Callable[[LeafType], OptFieldType]
+
+
+class DynamicLeafTypeMapping(LeafTypeMapping):
+    """May be nested infinitely inside one another, with the outer one taking priority."""
+
+    def __init__(self, base_map: LeafTypeMapping, inorder_type_handlers: ty.Sequence[TypeHandler]):
+        self.base_map = base_map
+        self.inorder_type_handlers = inorder_type_handlers
+
+    def _try_handlers(self, obj: LeafType) -> OptFieldType:
+        for handler in self.inorder_type_handlers:
+            field_constructor = handler(obj)
+            if field_constructor is not None:
+                return field_constructor
+        return None
+
+    def __contains__(self, obj: LeafType) -> bool:
+        if self._try_handlers(obj):
+            return True
+        return obj in self.base_map
+
+    def __getitem__(self, obj: object) -> FieldType:
+        field = self._try_handlers(obj)
+        if field is not None:
+            return field
+        return self.base_map[obj]
+
+
+def handle_literals(lt: LeafType) -> OptFieldType:
+    if typing_inspect.is_literal_type(lt):
+        values = typing_inspect.get_args(lt)
+        validator = marshmallow.validate.OneOf(values)
+        # the validator is the same no matter what - set membership/equality
+
+        types = [type(val) for val in values]
+        if all(typ == types[0] for typ in types):
+            # if we can narrow down to a single shared leaf type, use it:
+            underlying_type = types[0]
+            if underlying_type in NATIVE_TO_MARSHMALLOW:
+                return _field_with_default_kwargs(
+                    NATIVE_TO_MARSHMALLOW[underlying_type], validate=validator
+                )
+        # otherwise use the Raw type with the OneOf validator
+        return _field_with_default_kwargs(marshmallow.fields.Raw, validate=validator)
+    return None
+
+
+AtacamaBaseLeafTypeMapping = DynamicLeafTypeMapping(NATIVE_TO_MARSHMALLOW, [handle_literals])

thds/atacama/meta.json

@@ -0,0 +1,8 @@
+{
+  "git_commit": "b374dd32673467abb1c76990d4aaade7f6562eba",
+  "git_branch": "main",
+  "git_is_clean": true,
+  "pyproject_version": "1.0.20250123022552",
+  "thds_user": "runner",
+  "misc": {}
+}

thds/atacama/nonempty.py

@@ -0,0 +1,38 @@
+import typing as ty
+
+import marshmallow as ma
+import marshmallow.validate as mav
+
+
+def _append_validator(validator: ty.Callable, field: ma.fields.Field) -> ma.fields.Field:
+    """Marshmallow builds in arrays of validators, so this modifies the array"""
+    if not field.validate:
+        field.validate = validator
+    field.validators.append(validator)
+    return field
+
+
+def nonempty_validator_xf(field: ma.fields.Field) -> ma.fields.Field:
+    """Objects which have a length also have a known, meaningful default, e.g. empty string, empty list, empty dict.
+
+    If you are requiring that an attribute have a value provided,
+    then you're also stating that there is no meaningful default
+    value for that attribute.
+
+    If there is a meaningful default for the type, but no meaningful default for the attribute,
+    then you should never be accepting the default value for that attribute.
+
+    """
+
+    def nonempty_validator(value: ty.Any) -> bool:
+        try:
+            if not len(value):
+                raise mav.ValidationError("The length for a non-defaulting field must not be zero")
+        except TypeError:
+            pass
+        return True
+
+    if field.load_default == ma.missing:
+        # this field should disallow 'empty'/falsy values, such as empty strings, empty lists, etc.
+        return _append_validator(nonempty_validator, field)
+    return field

thds/atacama/schemas.py

@@ -0,0 +1,228 @@
+import typing as ty
+
+import marshmallow  # type: ignore
+from typing_extensions import Protocol
+
+from ._attrs import generate_attrs_post_load, is_attrs_class, yield_attributes
+from ._cache import GenSchemaCachingDeco
+from ._config import PerGenerationConfigContext, _GenConfig
+from ._meta import SchemaMeta
+from .field_transforms import FieldTransform, apply_field_xfs
+from .fields import generate_field
+from .leaf import AtacamaBaseLeafTypeMapping, LeafTypeMapping
+
+
+def _set_default(default: object = marshmallow.missing) -> ty.Dict[str, ty.Any]:
+    """Generate the appropriate Marshmallow keyword arguments depending on whether the default is missing or not"""
+    config = PerGenerationConfigContext()
+    if default is not marshmallow.missing:
+        # we have a default
+        field_kwargs = dict(dump_default=default, load_default=default)
+        if config.require_all:
+            field_kwargs.pop("load_default")  # can't combine load_default with required
+            field_kwargs["required"] = True
+        return field_kwargs
+    return dict(required=True)
+
+
+def _is_schema(a: ty.Any):
+    return isinstance(a, marshmallow.Schema) or (
+        isinstance(a, type) and issubclass(a, marshmallow.Schema)
+    )
+
+
+class NamedFieldsSchemaGenerator(Protocol):
+    def __call__(self, __attrs_class: type, **__fields: "NamedField") -> ty.Type[marshmallow.Schema]:
+        ...  # pragma: nocover
+
+
+class _NestedSchemaGenerator:
+    def __init__(
+        self,
+        sg: NamedFieldsSchemaGenerator,
+        field_kwargs: ty.Mapping[str, ty.Any],
+        fields: "ty.Mapping[str, NamedField]",
+    ):
+        self._schema_generator = sg
+        self.field_kwargs = field_kwargs
+        self._fields = fields
+        # to be used by the discriminator
+
+    def __call__(self, typ: type) -> ty.Type[marshmallow.Schema]:
+        return self._schema_generator(typ, **self._fields)
+
+
+class _PartialField(ty.NamedTuple):
+    field_kwargs: ty.Mapping[str, ty.Any]
+
+
+NamedField = ty.Union[
+    marshmallow.fields.Field,
+    _NestedSchemaGenerator,
+    _PartialField,
+    ty.Type[marshmallow.Schema],
+    marshmallow.Schema,
+]
+
+
+class SchemaGenerator:
+    """A Marshmallow Schema Generator.
+
+    Recursively generates Schemas and their Fields from attrs classes
+    and their attributes, allowing selective overrides at every level
+    of the recursive type.
+
+    When we generate a Marshmallow Field, about half of the 'work' is
+    something that can logically be derived from the context (e.g.,
+    does the field have a default, is it required, is it a list, etc)
+    and the other half is specific to the use case (do I want
+    additional validators, is it load_only, etc).
+
+    We aim to make it easy to layer in the 'specific' stuff while
+    keeping the 'given' stuff from the context, to reduce accidents
+    and having to repeat yourself.
+    """
+
+    def __init__(
+        self,
+        meta: SchemaMeta,
+        field_transforms: ty.Sequence[FieldTransform],
+        *,
+        leaf_types: LeafTypeMapping = AtacamaBaseLeafTypeMapping,
+        cache: ty.Optional[GenSchemaCachingDeco] = None,
+    ):
+        self._meta = meta
+        self._field_transforms = field_transforms
+        self._leaf_types = leaf_types
+        if cache:
+            self.generate = cache(self.generate)  # type: ignore
+
+    def __call__(
+        self,
+        __attrs_class: type,
+        __config: ty.Optional[_GenConfig] = None,
+        **named_fields: NamedField,
+    ) -> ty.Type[marshmallow.Schema]:
+        """Generate a Schema class from an attrs class.
+
+        High-level convenience API that allows for using keyword arguments.
+        """
+        return self.generate(__attrs_class, config=__config, fields=named_fields)
+
+    def generate(
+        self,
+        attrs_class: type,
+        *,
+        fields: ty.Mapping[str, NamedField] = dict(),  # noqa: B006
+        config: ty.Optional[_GenConfig] = None,
+        schema_base_classes: ty.Tuple[ty.Type[marshmallow.Schema], ...] = (marshmallow.Schema,),
+    ) -> ty.Type[marshmallow.Schema]:
+        """Low-level API allowing for future keyword arguments that do not overlap with NamedFields.
+
+        May include caching if the SchemaGenerator is so-equipped.
+        """
+        assert is_attrs_class(attrs_class), (
+            f"Object {attrs_class} (of type {type(attrs_class)}) is not an attrs class. "
+            "If this has been entered recursively, it's likely that you need a custom leaf type definition."
+        )
+        config = config or PerGenerationConfigContext()
+        with PerGenerationConfigContext.set(config):
+            return type(
+                ".".join((attrs_class.__module__, attrs_class.__name__))
+                + f"{config.schema_name_suffix}Schema",
+                schema_base_classes,
+                dict(
+                    apply_field_xfs(
+                        self._field_transforms,
+                        self._gen_fields(attrs_class, **fields),
+                    ),
+                    Meta=self._meta,
+                    __atacama_post_load=generate_attrs_post_load(attrs_class),
+                    __generated_by_atacama=True,  # not used for anything currently
+                ),
+            )
+
+    def _named_field_discriminator(self, attribute, named_field: NamedField) -> marshmallow.fields.Field:
+        """When we are given a field name with a provided value, there are 4 possibilities."""
+        # 1. A Field. This should be plugged directly into the Schema
+        # without being touched.  Recursion ends here.
+        if isinstance(named_field, marshmallow.fields.Field):
+            return named_field
+        # 2. A Schema. You may already have generated (or defined) a
+        # Schema for your type. In this case, we simply want to create
+        # a Nested field for you with the appropriate outer keyword
+        # arguments for the field, since we know whether this is
+        # optional, required, etc. Recursion will end as soon as the
+        # parts of the type that affect the field keyword arguments
+        # for Nested have been stripped and then applied to the NestedField.
+        if _is_schema(named_field):
+            return generate_field(
+                self._leaf_types,
+                lambda _s: ty.cast(ty.Type[marshmallow.Schema], named_field),
+                attribute.type,
+                _set_default(attribute.default),
+            )
+        # 3. A nested Schema Generator, with inner keyword
+        # arguments. This would be used in the case where you want the
+        # outer keyword arguments for Nested to be generated by the
+        # current generator, and the nested Schema itself generated
+        # from the type, but you want to change the SchemaGenerator
+        # context (either the Meta or the field_transforms). Recursion
+        # will continue inside the new Schema Generator
+        # provided. These are created by passing a SchemaGenerator to
+        # .nested on the current SchemaGenerator.
+        if isinstance(named_field, _NestedSchemaGenerator):
+            return generate_field(
+                self._leaf_types, named_field, attribute.type, named_field.field_kwargs
+            )
+        # 4. A partial Field with some 'inner' keyword arguments for
+        # the Field only. Recursion continues - simply adds keyword
+        # arguments to the Field being generated.
+        assert isinstance(named_field, _PartialField), (
+            "Named fields must be a Field or Schema, "
+            "or must be created with `.field` or `.nested` on a SchemaGenerator. Got: "
+            + str(named_field)
+        )
+        return generate_field(
+            self._leaf_types,
+            self,
+            attribute.type,
+            dict(_set_default(attribute.default), **named_field.field_kwargs),
+        )
+
+    def _gen_fields(
+        self, __attrs_class: type, **named_fields: NamedField
+    ) -> ty.Dict[str, marshmallow.fields.Field]:
+        """Internal helper for iterating over attrs fields and generating Marshmallow fields for each"""
+        names_onto_fields = {
+            attribute.name: (
+                generate_field(
+                    self._leaf_types,
+                    self,
+                    attribute.type,
+                    _set_default(attribute.default),
+                )
+                if attribute.name not in named_fields
+                else self._named_field_discriminator(attribute, named_fields.pop(attribute.name))
+            )
+            for attribute in yield_attributes(__attrs_class)
+            if attribute.init
+        }
+        if named_fields:
+            # This is just here to avoid people debugging mysterious issues
+            raise KeyError(
+                f"Named attribute(s) {named_fields.keys()} not found "
+                f"in the `attrs` class {__attrs_class.__class__.__name__} "
+                " - this indicates incorrect (possibly misspelled?) keyword argument(s)."
+            )
+        return names_onto_fields
+
+    def field(self, **inner_field_kwargs) -> _PartialField:
+        """Defines a field within the context of an existing Schema and attrs type."""
+        return _PartialField(inner_field_kwargs)
+
+    def nested(self, **outer_field_kwargs) -> ty.Callable[..., _NestedSchemaGenerator]:
+        def make_nsg(**fields) -> _NestedSchemaGenerator:
+            return _NestedSchemaGenerator(self, outer_field_kwargs, fields)
+
+        return make_nsg

thds.atacama-1.0.20250123022552.dist-info/METADATA

@@ -0,0 +1,381 @@
+Metadata-Version: 2.2
+Name: thds.atacama
+Version: 1.0.20250123022552
+Summary: A Marshmallow schema generator for `attrs` classes. Inspired by `desert`.
+Author: Trilliant Health
+Description-Content-Type: text/markdown
+Requires-Dist: marshmallow>=3.1
+Requires-Dist: marshmallow-enum
+Requires-Dist: marshmallow-union
+Requires-Dist: thds.core>=1.31
+Requires-Dist: typing-inspect>=0.9.0
+
+# atacama
+
+A Marshmallow schema generator for `attrs` classes.
+
+Inspired by `desert`.
+
+## Why
+
+`desert` seems mostly unmaintained. It is also surprisingly small (kudos to the authors), which makes it
+a reasonable target for forking and maintaining.
+
+However, we think the (widespread) practice of complecting the data class definition with its
+serialization schema is unwise. While this is certainly DRY-er than having to rewrite the entire Schema,
+it's (critically) not DRY at all if you ever want to have different de/serialization patterns depending
+on the data source.
+
+In particular, `atacama` is attempting to optimize for the space of Python application that serve APIs
+from a database. These are common situations where serialization and deserialization may need to act
+differently, and there's value in being able to cleanly separate those without redefining the `attrs`
+class itself.
+
+`cattrs` is the prior art here, which mostly dynamically defines all of its structure and unstructure
+operations, and allows for different Converters to be used on the same `attrs` classes. However `cattrs`
+does not bring the same level of usability as Marshmallow when it comes to various things that are
+important for APIs. In particular, we prefer Marshmallow for its:
+
+- validation, which we find to be more ergonomic in the Marshmallow-verse.
+- ecosystem utilities such as OpenAPI spec generation from Marshmallow Schemas.
+
+As of this writing, we are unaware of anything that `cattrs` can do that we cannot accomplish in
+Marshmallow, although for performance and other reasons, there may be cases where `cattrs` remains a
+better fit!
+
+Thus `atacama`. It aims to provide fully dynamic Schema generation, while retaining 100% of the
+generality offered by Marshmallow, in a form that avoids introducing complex shim APIs that no longer
+look and feel like Marshmallow itself.
+
+## What
+
+`atacama` takes advantage of Python keyword arguments to provide as low-boilerplate an interface as
+possible. Given:
+
+```
+from datetime import datetime, date
+import attrs
+
+
+@attrs.define
+class Todo:
+    id: str
+    owner_id: str
+    created_at: datetime
+    priority: float = 0.0
+    due_on: None | date = None
+```
+
+For such a simple example, let's assume the following Schema validation rules, but only for when the data
+comes in via the API:
+
+- `created_at` must be before the current moment
+- `priority` must be in the range \[0.0, 10.0\]
+- `due_on`, if present, must be before 2038, when the Unix epoch will roll over and all computers will
+  die a fiery death.
+
+```
+from typing import Type
+from atacama import neo  # neo is the recommended default SchemaGenerator
+import marshmallow as ma
+
+
+def before_now(dt: datetime) -> bool:
+    return dt <= datetime.now()
+
+
+def before_unix_death(date: date):
+    return date < date(2038, 1, 19)
+
+
+TodoFromApi: Type[ma.Schema] = neo(
+    Todo,
+    created_at=neo.field(validate=before_now),
+    priority=neo.field(validate=ma.validate.Range(min=0.0, max=10.0),
+    due_on=neo.field(validate=before_unix_death),
+)
+TodoFromDb: Type[ma.Schema] = neo(
+    Todo,
+    created_at=neo.field(data_key='created_ts'),
+)
+# both of the generated Schemas are actually Schema _classes_,
+# just like a statically defined Marshmallow class.
+# In most cases, you'll want to instantiate an object of the class
+# before use, e.g. `TodoFromDb().load(...)`
+```
+
+Note that nothing that we have done here requires
+
+- modifying the `Todo` class in any way.
+- repeating any information that can be derived _from_ the `Todo` class (e.g. that `due_on` is a `date`,
+  or that it is `Optional` with a default of `None`).
+- complecting the data source and validation/transformation for that source with the core data type
+  itself, which can easily be shared across both the database and the API.
+
+### Recursive Schema and Field generation
+
+The first example demonstrates what we want and why we want it, but does not prove generality for our
+approach. Classes are by nature recursively defined, and Schemas must also be.
+
+Happily, `atacama` supports recursive generation and recursive customization at each layer of the
+class+`Schema`.
+
+There are five fundamental cases for every attribute in a class which is desired to be a `Field` in a
+Schema. Two of these have already been demonstrated. The 5 cases are the following:
+
+1. Completely dynamic `Field` and recursive `Schema` generation.
+
+- This is demonstrated by `id` and `owner_id` in our `Todo` example. We told `atacama` nothing about
+  them, and reasonable Marshmallow Fields with correct defaults were generated for both.
+
+2. A customized `Field`, with recursive `Schema` generation as needed.
+
+- This is demonstrated by `created_at`, `priority`, and `due_on` in our `Todo` example. Much information
+  can be dynamically derived from the annotations in the `Todo` class, and `atacama` will do so. However,
+  we also wished to _add_ information to the generated `Field`, and we can trivially do so by supplying
+  keyword arguments normally accepted by `Field` directly to the `field` method of our `SchemaGenerator`.
+  These keyword arguments can even technically override the keyword arguments for `Field` derived by
+  `atacama` itself, though that would in most cases be a violation of your contract with the readers of
+  your class definition and is therefore not recommended. The `Field` _type_ will still be chosen by
+  `atacama`, so if for some reason you want more control than is being offered by `atacama`, that takes
+  you to option #3:
+
+3. Completely static `Field` definition.
+
+- In some cases, you may wish to opt out of `atacama` entirely, starting at a given attribute. In this
+  case, simply provide a Marshmallow `Field` (which is by definition fully defined recursively), and
+  `atacama` will respect your intention by placing the `Field` directly into the `Schema` at the
+  specified point.
+
+4. A statically defined `Schema`.
+
+- This is similar to case 2, except that, by providing a Marshmallow `Schema` for a nested attribute, you
+  are confirming that you want `atacama` to infer the "outer" information about that attribute, including
+  that is is a `Nested` `Field`, to perform all the standard unwrapping of Generic and Union types, and
+  to assign the correct default based on your `attrs` class definition. For instance, an attribute that
+  exhibits the definition `Optional[List[YourClass]] = None` would allow you to provide a nested `Schema`
+  defining only how to handle `YourClass`, while still generating the functionality around the default
+  value None and expecting a `List` of `YourClass`.
+- In particular, this would be an expected case when you have a need to generate a `Schema` for direct
+  deserialization of a class that is also used in a parent class and `Schema`, but where both the parent
+  and child Schema share all the same custom validation, etc. By generating the nested `Schema` and then
+  assigning it at the proper location within the parent `Schema`, you can easily reuse all of the
+  customization from the child generation.
+
+5. A nested `Schema` _generator_.
+
+- The most common use case for this will be when it is desirable to customize the generated `Field` of a
+  nested class. In order to provide an API that continues to privilege keyword arguments as a way of
+  'pathing' to the various parts of the `Schema`, we must first capture any keyword arguments specific to
+  the `Nested` `Field` that will be generated, and from there on we can allow you to provide names
+  pointing to attributes in the nested class.
+- SchemaGenerators are objects created by users who wish to customize `Schema` generation in particular
+  ways. The `Meta` class within a Marshmallow `Schema` changes certain behaviors across all its fields.
+  While `atacama` provides several default generators, you may wish to create your own. Regardless, the
+  use case for providing a nested `SchemaGenerator` is more specifically where you wish to make Schemas
+  with nested Schemas that follow different rules than their parents. This is no issue with `atacama` -
+  if it finds a nested `SchemaGenerator`, it will defer nested generation from that point onward to the
+  new `SchemaGenerator` as expected. Note that, of course, the `Field` being generated for that attribute
+  will follow the rules of the _current_ SchemaGenerator, just as would happen with nested `Meta` classes
+  in nested Schemas.
+
+What does this look like in practice? See the annotated example below, which demonstrates all 5 of these
+possible interactions between an `attrs` class and the specific `Schema` desired by our (potentially
+somewhat sugar-high) imaginary user:
+
+```python 3.7
+@attrs.define
+class Mallow:
+    gooeyness: GooeyEnum
+    color: str = "light-brown"
+
+
+@attrs.define
+class Milk:
+    """Just a percentage"""
+
+    fat_pct: float
+
+
+@attrs.define
+class ChocolateIngredients:
+    cacao_src: str
+    sugar_grams: float
+    milk: ty.Optional[Milk] = None
+
+
+@attrs.define
+class Chocolate:
+    brand: str
+    cacao_pct: float
+    ingredients: ty.Optional[ChocolateIngredients] = None
+
+
+@attrs.define
+class GrahamCracker:
+    brand: str
+
+
+@attrs.define
+class Smore:
+    graham_cracker: GrahamCracker
+    marshmallows: ty.List[Mallow]
+    chocolate: ty.Optional[Chocolate] = None
+
+
+ChocolateIngredientsFromApiSchema = atacama.neo(
+    ChocolateIngredients,
+    # 1. milk and sugar_grams are fully dynamically generated
+    # 2. a partially-customized Field inheriting its Field type, default, etc from the attrs class definition
+    cacao_src=atacama.neo.field(
+        validate=ma.validate.OneOf(["Ivory Coast", "Nigeria", "Ghana", "Cameroon"])
+    ),
+)
+
+
+class MallowSchema(ma.Schema):
+    """Why are you doing this by hand?"""
+
+    gooeyness = EnumField(GooeyEnum, by_value=True)
+    color = ma.fields.Raw()
+
+    @ma.post_load
+    def pl(self, data: dict, **_kw):
+        return Mallow(**data)
+
+
+SmoreFromApiSchema = atacama.ordered(
+    Smore,
+    # 1. graham_cracker, by being omitted, will have a nested schema generated with no customizations
+    # 5. In order to name/path the fields of nested elements, we plug in a nested
+    # SchemaGenerator.
+    #
+    # Note that keyword arguments applicable to the Field surrounding the nested Schema,
+    # e.g. load_only, are supplied to the `nested` method, whereas 'paths' to attributes within the nested class
+    # are supplied to the returned NestedSchemaGenerator function.
+    #
+    # Note also that we use a different SchemaGenerator (neo) than the parent (ordered),
+    # and this is perfectly fine and works as you'd expect.
+    chocolate=atacama.neo.nested(load_only=True)(
+        # 2. Both pct_cacao and brand have customizations but are otherwise dynamically generated.
+        # Note in particular that we do not need to specify the `attrs` class itself, as that
+        # is known from the type of the `chocolate` attribute.
+        cacao_pct=atacama.neo.field(validate=ma.validate.Range(min=0, max=100)),
+        brand=atacama.neo.field(validate=ma.validate.OneOf(["nestle", "hershey"])),
+        # 4. we reuse the previously defined ChocolateIngredientsFromApi Schema
+        ingredients=ChocolateIngredientsFromApiSchema,
+    ),
+    # 3. Here, the list of Mallows is represented by a statically defined NestedField
+    # containing a statically defined Schema.
+    # Why? Who knows, but if you want to do it yourself, it's possible!
+    marshmallows=ma.fields.Nested(MallowSchema(many=True)),
+)
+```
+
+## How
+
+### SchemaGenerators
+
+All interaction with `atacama` is done via a top-level `SchemaGenerator` object. It contains some
+contextual information which will be reused recursively throughout a generated `Schema`, including a way
+to define the `Meta` class that is a core part of Marshmallow's configurability.
+
+`atacama` currently provides two 'default' schema generators, `neo` and `ordered`.
+
+- `ordered` provides no configuration other than the common specification that the generated Schema
+  should preserve the order of the attributes as they appear in the class - while this may not matter for
+  most runtime use cases, it is infinitely valuable for debuggability and for further ecosystem usage
+  such as OpenAPI spec generation, which ought to follow the order defined by the `attrs` class.
+
+- `neo` stands for "non-empty, ordered", and is the preferred generator for new Schemas, because it
+  builds in a very opinionated but nonetheless generally useful concept of non-emptiness. For attributes
+  of types that properly have lengths, it is in general the case that one and only one of the following
+  should be true:
+
+  1. Your attribute has a default defined, such that it is not required to be present in input data for
+     successful deserialization.
+  1. It is illegal to provide an empty, zero-length value.
+
+  The intuition here is that a given attribute type either _may_ have an 'essentially empty' value, or it
+  may not. Examples of things which may never be empty include database ids (empty string would be
+  inappropriate), lists of object 'owners' (an empty list would orphan the object, and therefore must not
+  be permitted), etc. Whereas in many cases, an empty string or list is perfectly normal, and in those
+  cases it is preferred that the class itself define the common-sense default value in order to make
+  things work as expected without boilerplate.
+
+### FieldTransforms
+
+The `neo` `SchemaGenerator` performs the additional 'non-empty' validation to non-defaulted Fields via
+something called a `FieldTransform`. Any `FieldTransform` attached to a `SchemaGenerator` will be run on
+_every_ `Field` attached to the Schema, _recursively_. This includes statically-provided Fields.
+
+The `FieldTransform` must accept an actual `Field` object and returns a (presumably modified) `Field`
+object. This is only run at the time of `Schema` generation, so if you wish to add validators or perform
+customization to the Field that happens at load/dump time, you must compose your logic with the existing
+`Field`. A Schema generator can have multiple FieldTransforms, and they will be run _in order_ on every
+`Field`. A `FieldTransform` is, in essence, a higher-order function over `Field`, which are themselves
+functions for the incoming attribute data.
+
+The two default generators are provided as a convenience to the user and nothing more - it is perfectly
+acceptable and indeed expected that you might define your own 'sorts' of schema generators, with your own
+`FieldTransforms` and basic `Meta` definitions, depending on your needs.
+
+### Leaf type->Field mapping
+
+As a recursive generator, there must be known base cases where a concrete Marshmallow `Field` can be
+automatically generated based on the type of an attribute.
+
+#### Built-in mappings
+
+The default base cases are defined in `atacama/leaf.py`. They are relatively comprehensive as far as
+Python builtins go, covering various date/time concepts and UUID. We also specifically map
+`Union[int, float]` to the Marshmallow `Number` `Field`. Further, we support `typing_extensions.Literal`
+using the built-in Marshmallow validator `OneOf`, and we have introduced a simple `Set` `Field` that
+serializes `set`s to sorted `list`s.
+
+#### Custom static mappings
+
+Nevertheless, you may find that you wish to configure a more comprehensive (or different) set of leaf
+types for your `SchemaGenerator`. This may be configured by passing the keyword argument `leaf_types` to
+the `SchemaGenerator` constructor with a mapping of those leaf types. A `dict` is sufficient to provide a
+static `LeafTypeMapping`.
+
+#### Custom dynamic mappings
+
+You may also provide a more dynamic implementation of the `Protocol` defined in `atacama/leaf.py`. This
+would provide functionality similar to `cattrs.register_structure_hook`, except that a Marshmallow
+`Field` handles both serialization and deserialization. The included `DynamicLeafTypeMapping` class can
+help accomplish this, though you may provide your own custom implementation of the Protocol as well.
+`DynamicLeafTypeMapping` is recursively nestable, so you may overlay your own handlers on top of our base
+handlers via:
+
+```
+from atacama import DynamicLeafTypeMapping, AtacamaBaseLeafTypeMapping
+
+your_mapping = DynamicLeafTypeMapping(AtacamaBaseLeafTypeMapping, [handler_1, handler_2])
+```
+
+## Minor Features
+
+### `require_all`
+
+You may specify at generation time that you wish to make all fields (recursively) `required` at the time
+of load. This may be useful on its own, but is also the only way of accurately describing an 'output'
+type in a JSON/OpenAPI schema, because `required` in that context is the only way to indicate that your
+attribute will never be `undefined`. When dumping an `attrs` class to Python dictionary, all attributes
+are always guaranteed to be present in the output, so `undefined` will never happen even for attributes
+with defaults.
+
+Example:
+
+`atacama.neo(Foo, config(require_all=True))`
+
+### Schema name suffix
+
+You may specify a suffix for the name of the Schema generated. This may be useful when you are trying to
+generate an output JSON schema and have multiple Schemas derived from the same `attrs` class.
+
+Example:
+
+`atacama.neo(Foo, config(schema_name_suffix='Input'))` results in the schema having the name
+`your_module.FooInput` rather than `your_module.Foo`.

thds.atacama-1.0.20250123022552.dist-info/RECORD

@@ -0,0 +1,19 @@
+thds/atacama/__init__.py,sha256=GYDLPjg7E91sPlOKZ8UyhSDCRvhUSbg9hbL-fK2hzZY,265
+thds/atacama/_attrs.py,sha256=3g3mXdUJRsaKgGnzDWZ8AoqM8pgLL9GMeY1cF7-sN6o,1556
+thds/atacama/_cache.py,sha256=fYZ6iYKvQClCRtuGIQAMdJHyVHJ9Ffyr0dW1eyaMnwA,1477
+thds/atacama/_config.py,sha256=Z2gqxnBJvk9plS-3vgNchfq3Z7wBsuyu0SqAmnKFg2o,1442
+thds/atacama/_generic_dispatch.py,sha256=N5gZGTLMDVCwbf3OAx1EIA-wG3_T6CICiy65D-A_RKI,2256
+thds/atacama/_meta.py,sha256=sOjP0Y0KiNZUAXrxg2JWwolSWlxgU_OUqniUR_2Iv8g,498
+thds/atacama/custom_fields.py,sha256=leIsn40R5TexbAgTj1X-HUtkopfEMp5Hwb-0PYQGQ2U,945
+thds/atacama/field_transforms.py,sha256=9Y1HO0U7oZZhmpYegTM1ruZX0hZMgdWS6b4gARb_Yo8,528
+thds/atacama/fields.py,sha256=zIfFCyUO1YcbKiLsl3OX-xhx3JxnyRBkP6kf-nOezsA,5281
+thds/atacama/generators.py,sha256=O6LvFaFpsfvAD4l_cCa82usF1RQ4aBHhv8bLikJ5rL0,486
+thds/atacama/leaf.py,sha256=C7HDGBS_Evds35qWeBLQAw1ZahERJONh-WrguZzIMvs,4575
+thds/atacama/meta.json,sha256=Ng3G3l0SnGsdEsovlwUcoJAW2DOqN_Ncqn5_4CP6zAU,195
+thds/atacama/nonempty.py,sha256=bL1cqNpUzATosiqGdEPEn6zlYcliySKH0tj__2UnijU,1384
+thds/atacama/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+thds/atacama/schemas.py,sha256=CqSaj1KJGPuXzHkjdSVrZUhhd3dagmEUtYuBEiJGJ_g,9418
+thds.atacama-1.0.20250123022552.dist-info/METADATA,sha256=__aN0JIk5fIE29jvMzPJak9lf7pS1LTj7BaRdJqmUfc,17643
+thds.atacama-1.0.20250123022552.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+thds.atacama-1.0.20250123022552.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds.atacama-1.0.20250123022552.dist-info/RECORD,,

{thds.atacama-0.0.1.dist-info → thds.atacama-1.0.20250123022552.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

thds.atacama-1.0.20250123022552.dist-info/top_level.txt

@@ -0,0 +1 @@
+thds

thds.atacama-0.0.1.dist-info/METADATA

@@ -1,8 +0,0 @@
-Metadata-Version: 2.1
-Name: thds.atacama
-Version: 0.0.1
-Home-page: https://www.trillianthealth.com
-Author: Trilliant Health Data Science
-Author-email: datascience@trillianthealth.com
-Classifier: Development Status :: 1 - Planning
-

thds.atacama-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-thds.atacama-0.0.1.dist-info/METADATA,sha256=vQEhS2GDeMIOvQ_e1uUbtYRtZbd-p72F1J4CjZepjhg,231
-thds.atacama-0.0.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-thds.atacama-0.0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-thds.atacama-0.0.1.dist-info/RECORD,,

thds.atacama-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-