thds.attrs-utils 1.6.20251124154148__py3-none-any.whl → 1.7.20251204022717__py3-none-any.whl

thds/attrs_utils/cattrs/converter.py

@@ -15,7 +15,7 @@ UnStruct = Callable[[Any], T]
 StructFactory = Callable[[Any], Struct[T]]
 
 
-PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES = {
+PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES: ty.Mapping[Type, Callable[[], ty.Collection]] = {
     ty.Set: list,
     ty.FrozenSet: list,
     ty.AbstractSet: list,
@@ -173,7 +173,7 @@ def default_converter(
     prefer_attrib_converters: bool = True,
     unstruct_collection_overrides: ty.Mapping[
         Type, Callable[[], ty.Collection]
-    ] = PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES,  # type: ignore [assignment]
+    ] = PREJSON_UNSTRUCTURE_COLLECTION_OVERRIDES,
 ) -> Converter:
     return GenConverter(
         unstruct_collection_overrides=unstruct_collection_overrides,

thds/attrs_utils/docs.py

@@ -7,7 +7,7 @@ from typing import Callable, Dict, List, Literal, Optional, Set, Type
 
 from docstring_parser import Docstring, DocstringMeta, DocstringParam, Style, parse
 
-from .type_utils import bases
+from .type_utils import bases, get_origin
 
 DocCombineSpec = Literal["first", "join"]
 
@@ -29,6 +29,7 @@ def record_class_docs(
     join_sep: str = "\n\n",
     require_complete: bool = False,
 ) -> Docstring:
+    cls = get_origin(cls) or cls  # unwrap parameterized generics
     base_clss = [c for c in bases(cls, filter_bases) if c is not object]
 
     docs = [parse(c.__doc__, style=style) for c in base_clss if c.__doc__]

thds/attrs_utils/empty.py

@@ -6,9 +6,10 @@ import uuid
 import warnings
 from functools import partial
 
-import attr
+import attrs
 
 from . import recursion, type_recursion, type_utils
+from .params import attrs_fields_parameterized
 from .registry import Registry
 from .type_recursion import Constructor
 
@@ -67,9 +68,9 @@ def _record_constructor(
     return f
 
 
-def empty_attrs(empty_gen, type_: ty.Type[attr.AttrsInstance]) -> Constructor[attr.AttrsInstance]:
-    fields = attr.fields(type_)
-    defaults = {f.name: empty_gen(f.type) for f in fields if f.default is attr.NOTHING}
+def empty_attrs(empty_gen, type_: ty.Type[attrs.AttrsInstance]) -> Constructor[attrs.AttrsInstance]:
+    fields = attrs_fields_parameterized(type_)
+    defaults = {f.name: empty_gen(f.type) for f in fields if f.default is attrs.NOTHING}
     # keep the original defaults and default factories
     return _record_constructor(type_, defaults)
 

thds/attrs_utils/isinstance/check.py

@@ -3,6 +3,7 @@ from typing import Any, NamedTuple, Type, cast, get_args, get_origin
 import attrs
 
 from .. import recursion, type_utils
+from ..params import attrs_fields_parameterized
 from ..type_recursion import TypeRecursion
 from . import util
 from .registry import ISINSTANCE_REGISTRY
@@ -26,7 +27,7 @@ def check_literal(instancecheck, type_: Type):
 
 def check_attrs(instancecheck, type_: Type[attrs.AttrsInstance]):
     # this _should_ typecheck according to my understanding of attrs.AttrsInstance but it is not
-    fields = attrs.fields(type_)  # type: ignore [misc]
+    fields = attrs_fields_parameterized(type_)
     names = tuple(f.name for f in fields)
     types = (f.type for f in fields)
     return util.check_attrs(

thds/attrs_utils/jsonschema/jsonschema.py

@@ -13,6 +13,7 @@ from thds.core import scope
 from thds.core.stack_context import StackContext
 
 from ..cattrs import DEFAULT_JSON_CONVERTER
+from ..params import attrs_fields_parameterized
 from ..recursion import RecF, value_error
 from ..registry import Registry
 from ..type_recursion import TypeRecursion
@@ -181,7 +182,7 @@ def gen_jsonschema_attrs(
     all_attributes_required = AllAttributesRequired()
 
     type_ = attr.resolve_types(type_)
-    attrs = attr.fields(type_)
+    attrs = attrs_fields_parameterized(type_)
     properties: Dict[str, Any] = {}
     required: List[str] = []
 
@@ -213,7 +214,7 @@ def gen_jsonschema_attrs(
                 default = None if null_default else at.default
                 attr_schema[DEFAULT] = serializer(default)
 
-        properties[at.name] = attr_schema  # type: ignore
+        properties[at.name] = attr_schema
 
     return object_(properties=properties, required=required, additionalProperties=False)
 

thds/attrs_utils/params/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "attrs_fields_parameterized",
+    "dataclass_fields_parameterized",
+    "field_origins",
+    "parameterize",
+    "parameterized_mro",
+]
+
+from .parameterize import parameterize, parameterized_mro
+from .records import attrs_fields_parameterized, dataclass_fields_parameterized, field_origins

thds/attrs_utils/params/parameterize.py

@@ -0,0 +1,90 @@
+"""Utilities for parameterizing generic types and analyzing parameterized generic types."""
+
+import inspect
+import itertools
+import typing as ty
+
+import typing_inspect as ti
+
+from ..utils import signature_preserving_cache
+from .utils import TypeOrVar, origin_params_and_args
+
+
+@ty.overload
+def parameterize(
+    type_: ty.TypeVar,
+    params: ty.Union[ty.Mapping[ty.TypeVar, TypeOrVar], ty.Type],
+) -> TypeOrVar: ...
+
+
+@ty.overload
+def parameterize(
+    type_: ty.Type,
+    params: ty.Union[ty.Mapping[ty.TypeVar, TypeOrVar], ty.Type],
+) -> ty.Type: ...
+
+
+def parameterize(
+    type_: TypeOrVar,
+    params: ty.Union[ty.Mapping[ty.TypeVar, TypeOrVar], ty.Type],
+) -> TypeOrVar:
+    """Given a generic type (or type variable) `type_` and a mapping from type variables to concrete types, return a new
+    type where the type variables have been substituted according to the mapping. If `params` is itself a parameterized
+    generic type, extract its type parameters and arguments and use those to build the mapping. If `type_` is not
+    generic, return it unchanged.
+
+    Examples:
+        >>> from typing import Generic, TypeVar, List, Dict
+        >>> T = TypeVar('T')
+        >>> U = TypeVar('U')
+        >>> V = TypeVar('V')
+        >>> parameterize(int, {T: str}) == int
+        True
+        >>> parameterize(T, {T: int}) == int
+        True
+        >>> parameterize(List[T], {T: str}) == List[str]
+        True
+        >>> parameterize(Dict[T, U], {T: int, U: str, V: float}) == Dict[int, str]
+        True
+        >>> class MyGeneric(Generic[T, U]): ...
+        >>> parameterize(MyGeneric, MyGeneric[int, str]) == MyGeneric[int, str]
+        True
+        >>> parameterize(List[T], MyGeneric[int, str]) == List[int]
+        True
+    """
+    if not isinstance(params, ty.Mapping):
+        _, params_, args, _ = origin_params_and_args(params)
+        return parameterize(type_, dict(zip(params_, args)))
+    elif isinstance(type_, ty.TypeVar):
+        return params.get(type_, type_)
+    elif tparams := ti.get_parameters(type_):
+        new_args = tuple(params.get(t, t) for t in tparams)
+        return type_[new_args]
+    else:
+        return type_
+
+
+@signature_preserving_cache
+def parameterized_mro(type_: ty.Type) -> ty.Tuple[ty.Type, ...]:
+    """All generic bases of a generic type, with type parameters substituted according to their specification in `type_`,
+    in python method resolution order. In case `type_` is not generic, just return the standard MRO.
+    """
+    # property-based test idea:
+    #   map(partial(parameterize, args), parameterized_bases(t)) == parameterized_bases(t[args])
+
+    def inner(type_: ty.Type, visited: ty.Set[ty.Type]) -> ty.Iterator[ty.Type]:
+        origin, params, args, parameterized = origin_params_and_args(type_)
+        if origin not in visited and origin is not ty.Generic:
+            mapping = dict(zip(params, args))
+            yield type_ if parameterized else parameterize(origin, mapping)
+            visited.add(origin)
+            for base in ti.get_generic_bases(origin):
+                if ti.get_origin(base) is not ty.Generic:
+                    yield from inner(parameterize(base, mapping), visited)
+
+    if not ti.is_generic_type(type_):
+        return inspect.getmro(type_)
+    else:
+        mro = dict(zip(inspect.getmro(ti.get_origin(type_) or type_), itertools.count()))
+        pmro = sorted(inner(type_, set()), key=lambda type_: mro[ti.get_origin(type_) or type_])
+        return tuple(pmro)

thds/attrs_utils/params/records.py

@@ -0,0 +1,98 @@
+"""Special handling of typevar resolution for `attrs` and `dataclasses` record types."""
+
+import copy
+import dataclasses
+import typing as ty
+
+import attrs
+import typing_inspect as ti
+
+from ..utils import signature_preserving_cache
+from .parameterize import parameterize, parameterized_mro
+from .utils import TypeOrVar
+
+
+def field_origins(
+    cls: ty.Type,
+) -> ty.Dict[str, ty.Type]:
+    """Map field names of a record type (e.g. `dataclasses` or `attrs`) to the parameterized base class where the field
+    is first defined."""
+
+    # find first class in MRO where each field is defined
+    field_origins: ty.Dict[str, ty.Type] = dict()
+    for base in parameterized_mro(cls):
+        origin = ti.get_origin(base) or base
+        for name in getattr(origin, "__annotations__", {}).keys():
+            if name not in field_origins:
+                field_origins[name] = base
+
+    return field_origins
+
+
+def _replace_dataclass_field_type(
+    dataclass_field: dataclasses.Field, new_type: TypeOrVar
+) -> dataclasses.Field:
+    new_field = copy.copy(dataclass_field)
+    new_field.type = new_type  # type: ignore[assignment]
+    # ^ NOTE: mypy thinks dataclasses.Field.type is always 'type', but it can be any type hint
+    return new_field
+
+
+_FT = ty.TypeVar("_FT", attrs.Attribute, dataclasses.Field)
+
+
+def _parameterize_attrs_or_dataclass_field(
+    field_origins: ty.Mapping[str, ty.Type],
+    field: _FT,
+) -> _FT:
+    if (parameterized_origin := field_origins.get(field.name)) is not None:
+        field_type = type(None) if field.type is None else field.type
+        # shouldn't happen in pracice after type resolution, but we keep it here to make mypy happy
+        concrete_type = parameterize(field_type, parameterized_origin)
+        if concrete_type == field.type:
+            return field
+        elif isinstance(field, attrs.Attribute):
+            return field.evolve(type=concrete_type)
+        else:
+            # dataclasses.Field
+            return _replace_dataclass_field_type(field, concrete_type)
+    else:
+        return field
+
+
+@signature_preserving_cache
+def attrs_fields_parameterized(
+    attrs_cls: ty.Type[attrs.AttrsInstance],
+) -> ty.Sequence[attrs.Attribute]:
+    """`attrs.fields` does not resolve typevars in the field types when base classes provide type parameters.
+    This appears to be true even for classes decorated with `attrs.resolve_types`, which may only resolve ForwardRefs.
+    This function has the same signature as `attrs.fields` but returns `Attribute`s with fully resolved `type` attributes.
+    """
+    attrs.resolve_types(
+        ti.get_origin(attrs_cls) or attrs_cls, include_extras=True
+    )  # this mutates in place
+    origins = field_origins(attrs_cls)
+    return [_parameterize_attrs_or_dataclass_field(origins, field) for field in attrs.fields(attrs_cls)]
+
+
+def _resolve_dataclass_fields(
+    dataclass_cls: ty.Type,
+) -> ty.Tuple[dataclasses.Field, ...]:
+    resolved_annotations = ty.get_type_hints(dataclass_cls, include_extras=True)
+    fields = dataclasses.fields(dataclass_cls)
+    return tuple(_replace_dataclass_field_type(f, resolved_annotations[f.name]) for f in fields)
+
+
+@signature_preserving_cache
+def dataclass_fields_parameterized(
+    dataclass_cls: ty.Type,
+) -> ty.Sequence[dataclasses.Field]:
+    """`dataclasses.fields` does not resolve typevars in the field types when base classes provide type parameters.
+    This function has the same signature as `dataclasses.fields` but returns `Field`s with fully resolved `type` attributes.
+    """
+
+    origins = field_origins(dataclass_cls)
+    return [
+        _parameterize_attrs_or_dataclass_field(origins, field)
+        for field in _resolve_dataclass_fields(ti.get_origin(dataclass_cls) or dataclass_cls)
+    ]

thds/attrs_utils/params/utils.py

@@ -0,0 +1,27 @@
+import typing as ty
+
+import typing_inspect as ti
+
+TypeOrVar = ty.Union[ty.Type, ty.TypeVar]
+
+
+def origin_params_and_args(
+    type_: ty.Type,
+) -> ty.Tuple[ty.Type, ty.Tuple[ty.TypeVar, ...], ty.Tuple[TypeOrVar, ...], bool]:
+    """Get the origin, parameters, and arguments of a generic type.
+    When a generic type has not been parameterized, the arguments will be the same as the parameters.
+    Examples:
+        - For `List[int]`, returns `(list, (T,), (int,))`
+        - For `Dict[str, U]`, returns `(dict, (K, V), (str, U))`
+        - For just `List`, returns `(list, (T,), (T,))`
+    """
+    if args := ti.get_args(type_):
+        origin = ti.get_origin(type_)
+        params = ti.get_parameters(origin)
+        parameterized = True
+    else:
+        origin = type_
+        params = ti.get_parameters(origin)
+        args = params
+        parameterized = False
+    return origin, params, args, parameterized

thds/attrs_utils/random/attrs.py

@@ -2,6 +2,7 @@ from typing import Callable, Dict, Sequence, Type, TypeVar
 
 import attrs
 
+from ..params import attrs_fields_parameterized
 from ..registry import Registry
 from ..type_utils import is_namedtuple_type
 from .util import Gen, T
@@ -25,10 +26,10 @@ def random_attrs(
 
 def _register_random_gen_by_field(type_: Type[T], **gens: Gen):
     if attrs.has(type_):
-        fields = attrs.fields(type_)  # type: ignore
-        names = [f.name for f in fields]
+        fields = attrs_fields_parameterized(type_)
+        names: Sequence[str] = [f.name for f in fields]
     elif is_namedtuple_type(type_):
-        names = type_._fields  # type: ignore [attr-defined]
+        names = type_._fields
     else:
         raise TypeError(f"Don't know how to interpret {type_} as a record type")
 

thds/attrs_utils/random/gen.py

@@ -1,11 +1,12 @@
 import collections
 import enum
 from functools import partial
-from typing import DefaultDict, Iterable, Tuple, Type, cast, get_args
+from typing import DefaultDict, Iterable, NamedTuple, Tuple, Type, TypeVar, cast, get_args
 
 import attr
 
 from .. import recursion, type_recursion, type_utils
+from ..params import attrs_fields_parameterized
 from . import attrs, collection, optional, tuple, union
 from .registry import GEN_REGISTRY
 from .util import Gen, T, U, choice_gen, juxtapose_gen, repeat_gen
@@ -29,7 +30,7 @@ def gen_enum(random_gen, type_: Type[T]) -> Gen[T]:
 
 
 def gen_attrs(random_gen, type_: Type[attr.AttrsInstance]) -> Gen[attr.AttrsInstance]:
-    fields = attr.fields(type_)  # type: ignore [arg-type,misc]
+    fields = attrs_fields_parameterized(type_)
     kw_only_fields = [f for f in fields if f.kw_only]
     overrides = attrs.CUSTOM_ATTRS_BY_FIELD_REGISTRY.get(type_)
 
@@ -48,9 +49,12 @@ def gen_attrs(random_gen, type_: Type[attr.AttrsInstance]) -> Gen[attr.AttrsInst
         return tuple.random_namedtuple_gen(type_, *field_gens)
 
 
-def gen_namedtuple(random_gen, type_: Type[T]) -> Gen[T]:
-    field_names = type_._fields  # type: ignore [attr-defined]
-    field_types = (type_.__annotations__[name] for name in field_names)  # type: ignore [attr-defined]
+NT = TypeVar("NT", bound=NamedTuple)
+
+
+def gen_namedtuple(random_gen, type_: Type[NT]) -> Gen[NT]:
+    field_names = type_._fields
+    field_types = (type_.__annotations__[name] for name in field_names)
     overrides = attrs.CUSTOM_ATTRS_BY_FIELD_REGISTRY.get(type_)
     if overrides:
         return tuple.random_namedtuple_gen(

thds/attrs_utils/registry.py

@@ -30,7 +30,7 @@ class Registry(Dict[T, U]):
 
     def cache(self, func: Callable[[T], U]) -> Callable[[T], U]:
         cached = partial(_check_cache, self, func)
-        return wraps(func)(cached)  # type: ignore [return-value]
+        return wraps(func)(cached)
 
 
 def _check_cache(cache: Dict[T, U], func: Callable[[T], U], key: T) -> U:

thds/attrs_utils/type_recursion.py

@@ -1,3 +1,4 @@
+import dataclasses
 import typing
 from functools import partial
 from typing import List, Optional, Tuple, Type, TypeVar
@@ -70,6 +71,7 @@ class TypeRecursion(StructuredRecursion[Type, Params, U]):
         *,
         first: Optional[Tuple[Predicate[Type], RecF[Type, Params, U]]] = None,
         attrs: Optional[RecF[Type, Params, U]] = None,
+        dataclass: Optional[RecF[Type, Params, U]] = None,
         namedtuple: Optional[RecF[Type, Params, U]] = None,
         optional: Optional[RecF[Type, Params, U]] = None,
         union: Optional[RecF[Type, Params, U]] = None,
@@ -96,6 +98,7 @@ class TypeRecursion(StructuredRecursion[Type, Params, U]):
                 (type_utils.is_literal_type, literal),
                 (type_utils.is_enum_type, enum),
                 (attr.has, attrs),
+                (dataclasses.is_dataclass, dataclass),
                 (type_utils.is_optional_type, optional),
                 (is_union_type, union),
                 (type_utils.is_set_type, set),

thds/attrs_utils/type_utils.py

@@ -2,13 +2,13 @@ import collections
 import enum
 import inspect
 import typing
-from typing import Callable, List, Mapping, Optional, Tuple, Type, TypeVar, Union
+from typing import Callable, List, Optional, Tuple, Type, TypeVar, Union
 
 import attr
+from typing_extensions import TypeIs
 from typing_inspect import (
     get_args,
     get_origin,
-    get_parameters,
     is_literal_type,
     is_new_type,
     is_optional_type,
@@ -97,7 +97,7 @@ def enum_base(type_: Type) -> Type:
 def unwrap_optional(type_: Type) -> Type:
     if is_optional_type(type_):
         args = get_args(type_)
-        return Union[tuple(a for a in args if a is not type(None))]  # type: ignore  # noqa:E721
+        return Union[tuple(a for a in args if a is not type(None))]  # type: ignore[return-value]  # noqa:E721
     else:
         return type_
 
@@ -116,30 +116,30 @@ def unwrap_annotated(type_: Type) -> Type:
     return type_
 
 
-def is_enum_type(type_: Type) -> bool:
+def is_enum_type(type_: Type) -> TypeIs[Type[enum.Enum]]:
     return isinstance(type_, type) and issubclass(type_, enum.Enum)
 
 
-def is_collection_type(type_: Type) -> bool:
+def is_collection_type(type_: Type) -> TypeIs[Type[typing.Collection]]:
     origin = get_origin(type_)
     return (type_ in COLLECTION_TYPES) if origin is None else (origin in COLLECTION_TYPES)
 
 
-def is_mapping_type(type_: Type) -> bool:
+def is_mapping_type(type_: Type) -> TypeIs[Type[typing.Mapping]]:
     origin = get_origin(type_)
     return (type_ in MAPPING_TYPES) if origin is None else (origin in MAPPING_TYPES)
 
 
-def is_set_type(type_: Type) -> bool:
+def is_set_type(type_: Type) -> TypeIs[Type[typing.AbstractSet]]:
     origin = get_origin(type_)
     return (type_ in UNIQUE_COLLECTION_TYPES) if origin is None else (origin in UNIQUE_COLLECTION_TYPES)
 
 
-def is_namedtuple_type(type_: Type) -> bool:
+def is_namedtuple_type(type_: Type) -> TypeIs[Type[typing.NamedTuple]]:
     return getattr(type_, "__bases__", None) == (tuple,) and hasattr(type_, "_fields")
 
 
-def is_variadic_tuple_type(type_: Type) -> bool:
+def is_variadic_tuple_type(type_: Type) -> TypeIs[Type[typing.Tuple[typing.Any, ...]]]:
     if is_tuple_type(type_):
         args = get_args(type_)
         return len(args) == 2 and args[-1] is Ellipsis
@@ -153,23 +153,14 @@ def is_builtin_type(type_: Type) -> bool:
 
 def concrete_constructor(type_: Type[T]) -> Callable[..., T]:
     if is_namedtuple_type(type_):
-        return type_
+        return type_  # type: ignore[return-value]
     origin = get_origin(type_)
     return ORIGIN_TO_CONSTRUCTOR[type_] if origin is None else ORIGIN_TO_CONSTRUCTOR[origin]
 
 
-def parameterize(
-    type_: Union[Type, TypeVar], params: Mapping[TypeVar, Union[TypeVar, Type]]
-) -> Union[Type, TypeVar]:
-    if isinstance(type_, TypeVar):
-        return params.get(type_, type_)
-    else:
-        tparams = get_parameters(type_)
-        new_args = tuple(params.get(t, t) for t in tparams)
-        return type_[new_args]
-
-
 def bases(type_: Type, predicate: Optional[Callable[[Type], bool]] = None) -> List[Type]:
+    if get_args(type_):
+        type_ = get_origin(type_)
     if not inspect.isclass(type_):
         raise TypeError(
             f"{bases.__module__}.{bases.__name__} can be called only on concrete classes; got {type_}"

thds/attrs_utils/utils.py

@@ -0,0 +1,12 @@
+import functools
+import typing as ty
+
+F = ty.TypeVar("F", bound=ty.Callable)
+
+
+def signature_preserving_cache(func: F, size: ty.Optional[int] = None) -> F:
+    """Decorator to apply `functools.lru_cache` while preserving the decorated function's signature
+    (which is otherwise lost when using `lru_cache` directly)"""
+
+    cached_func = functools.lru_cache(size)(func)
+    return ty.cast(F, cached_func)

{thds_attrs_utils-1.6.20251124154148.dist-info → thds_attrs_utils-1.7.20251204022717.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thds.attrs-utils
-Version: 1.6.20251124154148
+Version: 1.7.20251204022717
 Summary: Utilities for attrs record classes.
 Author-email: Trillianth Health <info@trillianthealth.com>
 Project-URL: Repository, https://github.com/TrilliantHealth/ds-monorepo
@@ -31,7 +31,8 @@ transforming, checking, generating, or anything else you'd want to do with types
 - Heterogeneous tuple types, e.g. `typing.Tuple[A, B, C]`
 - Variadic tuple types, e.g. `Tuple[T, ...]`
 - `typing.NamedTuple` record types
-- `attrs`-defined record types
+- `attrs`-defined record types, including generics with type variables
+- `dataclasses`-defined record types, including generics with type variables
 - Union types using `typing.Union`
 - `typing.Literal`
 - `typing.Annotated`
@@ -92,7 +93,7 @@ You can create a callable to generate instances of a given type as follows:
 
 ```python
 import itertools
-from typing import Dict, Literal, NewType, Optional, Tuple
+from typing import Dict, Generic, Literal, NewType, Optional, Tuple, TypeVar
 import attr
 from thds.attrs_utils.random.builtin import random_bool_gen, random_int_gen, random_str_gen
 from thds.attrs_utils.random.tuple import random_tuple_gen
@@ -108,18 +109,20 @@ class Record1:
     a: Optional[str]
     b: Tuple[int, bool]
 
-ID = NewType("ID", int)
+ID = TypeVar("ID")
 Key = Literal["foo", "bar", "baz"]
 
 @attr.define
-class Record2:
+class Record2(Generic[ID]):
     id: ID
     records: Dict[Key, Record1]
 
+MyID = NewType("MyID", int)
+
 ids = itertools.count(1)
-random_gen.register(ID, lambda: next(ids))
+random_gen.register(MyID, lambda: next(ids))
 
-random_record = random_gen(Record2)
+random_record = random_gen(Record2[MyID])
 
 print(random_record())
 print(random_record())

{thds_attrs_utils-1.6.20251124154148.dist-info → thds_attrs_utils-1.7.20251204022717.dist-info}/RECORD

@@ -1,36 +1,41 @@
 thds/attrs_utils/__init__.py,sha256=7hP-VWe-nq56jMk4jqsDanussQDzTUgOG94zUn7GgwA,122
 thds/attrs_utils/defaults.py,sha256=SjxB44PsArwJmtqDZ70iShdYZ1BxSlW8kQ2DnFCkeEg,1019
-thds/attrs_utils/docs.py,sha256=ill0gCf2EWe7Lx9vz5xSqotmj6jh3vIt7wB3stwPI7o,2852
-thds/attrs_utils/empty.py,sha256=96oeOFfovDmQgOHLqcwvNmd9c8-MTwAzZ_lP8XVIZc4,4633
+thds/attrs_utils/docs.py,sha256=Ul-0o9uQPl8sm7XOMpsmTsu43CfzTOta2n7WavjbvRs,2930
+thds/attrs_utils/empty.py,sha256=qNbKrs7bljPd7aVS6D7bodWFIRJ-NUnzcNZ5rw8h7qI,4699
 thds/attrs_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 thds/attrs_utils/recursion.py,sha256=qQjygpMnFtR2oNmTn6S24YojsJzc7lPzHBh0_DJsdKs,1607
-thds/attrs_utils/registry.py,sha256=XVdz9MAlsSYPxHub1jcgMhns8Z_kNcsstI76OHwZV_k,1051
+thds/attrs_utils/registry.py,sha256=1ez9XCYgN842anLLm98qruCllzgJfhLuBDxuOc5Eee4,1020
 thds/attrs_utils/type_cache.py,sha256=t--FCqzJcwKhy-WJHqOxYr0dhaMOLvgViU13WZHGPzk,4008
-thds/attrs_utils/type_recursion.py,sha256=Lr9BXO4VpNQMMFa--8ruQplsmP1YieAxizxl3O0LFp4,7400
-thds/attrs_utils/type_utils.py,sha256=368WqiE0ojWFevt1iTVehsEQ8Jtyp68wbSAQiPQmXbQ,4924
+thds/attrs_utils/type_recursion.py,sha256=f0-5ANqfI9tTv0vgSX_0Oqph1cQ1XsBPaIWhsYBHfIw,7533
+thds/attrs_utils/type_utils.py,sha256=v1N0oGNCICjS6S0nfVnW-RNZGDWMHyTRMTwoNiSoPLA,4855
+thds/attrs_utils/utils.py,sha256=o5suGo9L0i4i77QUjjglW9QnklR-jbA1pQQIaEYgsR8,407
 thds/attrs_utils/cattrs/__init__.py,sha256=635CMqhH1Bzd-p1-c6l0MJrxKgmlk45EmA-IbGGbfC8,822
-thds/attrs_utils/cattrs/converter.py,sha256=CIpHTf3GTtAmUcxU-FncsmYVe_9eoPqpFK7wSqgHCu4,7560
+thds/attrs_utils/cattrs/converter.py,sha256=jPRsBJehZtgsjWLYH5XvA_AW-w7pkyCrKkTAmFNXAWI,7578
 thds/attrs_utils/cattrs/errors.py,sha256=w7O7hRr8LcI17av1MTEnu-Im4jESECnpK30QqNVUqE8,1899
 thds/attrs_utils/isinstance/__init__.py,sha256=EAGULDzlI85Mgedsy7FY8lbTpMa-qJHsh_dL-adrv3E,248
-thds/attrs_utils/isinstance/check.py,sha256=zfyfT8Wm0wbfodxgUAbAZTYmxdmapRXiw-DA2I8pIys,3455
+thds/attrs_utils/isinstance/check.py,sha256=cncosTpHKlmo4WacpUHgFQQsbiyt1rxxv3Uir1UedcM,3494
 thds/attrs_utils/isinstance/registry.py,sha256=WumuN5F156fv3K39nbdvEVnDilKxD-UwKLla5GqghDs,251
 thds/attrs_utils/isinstance/util.py,sha256=iAK7_eFKDBUclX-UTYk4XGNB-T4cfX8c6A9xHMcka8U,2956
 thds/attrs_utils/jsonschema/__init__.py,sha256=UV5P8-Dnw4LlC6-xRbhmxPdqqeORnWT8Pjp3RqwSCxo,221
 thds/attrs_utils/jsonschema/constructors.py,sha256=reSbWiHYgWqVL6iWB_XSWB5nLPesq1joa-dfSLtFzj0,1839
-thds/attrs_utils/jsonschema/jsonschema.py,sha256=GZPm-RkcC-F5FFTN7btUnCMVN4DDvF02xfnvI4J8WAA,12895
+thds/attrs_utils/jsonschema/jsonschema.py,sha256=MA2WX2UkyiJZS9cz27_iddj7eEiChuTjJqE_JSers0Q,12942
 thds/attrs_utils/jsonschema/str_formats.py,sha256=P_7IbvEvsJ5hEMfkwmiI85n4pBBfCNH5uv6nklG4O9A,3361
 thds/attrs_utils/jsonschema/util.py,sha256=oa-cbIqplkriTIFTiW2OsVNyYpgFoK8sYMG8OJEIK3c,3400
+thds/attrs_utils/params/__init__.py,sha256=sdBdSHBD47qo7DWZNG0taewzqhfxtwL0hxaMcmdA3LM,306
+thds/attrs_utils/params/parameterize.py,sha256=MxLBcQREeYQcFUwFpV2_8F_0Rrtcj6-WX4wfFWMFQVI,3473
+thds/attrs_utils/params/records.py,sha256=jsZNr9B3eNs3u2h66TOxrbEh7SeJiRvlx8VZeTxDgOY,3744
+thds/attrs_utils/params/utils.py,sha256=Oz72dwXMEjLWFFMqilj6DlCiSa7SR3b9rvkFL-GnWIw,916
 thds/attrs_utils/random/__init__.py,sha256=A1n-9fispK5EkZFpwOhNJpO1kY_7xDZ5zec5ckflpmY,160
-thds/attrs_utils/random/attrs.py,sha256=fLed-aLcCqZ2gLhHQogY5sn32A4HE_LlpobHuj8qvL8,1695
+thds/attrs_utils/random/attrs.py,sha256=N-qGxtQhb6wr_ML3aFb4Gh3beQsZxgFa7Y_gpACfCPQ,1725
 thds/attrs_utils/random/builtin.py,sha256=p16zK3CJJITfCpe2gg4f1TkRXi25y4m97o5CvZKmfWA,2854
 thds/attrs_utils/random/collection.py,sha256=gSa_-478_KUcqzYt-01OREB3nJ7bcfGxwnFjSB7JJ30,1116
-thds/attrs_utils/random/gen.py,sha256=kp0XZoFHL4lkzZvxWZJ9bMGLDHAaNqTTioAk31-mKF4,4737
+thds/attrs_utils/random/gen.py,sha256=tqF-c5WRqfze87gOsBV-0CtOY55XeqNUYZETjD9rsV4,4768
 thds/attrs_utils/random/optional.py,sha256=Mm0WnJ6VeUUUhYelrOK7ZAYRJePlBalHc0wQECyO9uM,386
 thds/attrs_utils/random/registry.py,sha256=IcC2ucJtrnOG0RH43VK8lrMha1uhYflz8_pZJZj7jJ4,1056
 thds/attrs_utils/random/tuple.py,sha256=YI_wzYFzprUG9iuxwloWz9OqQDmVJuhp9epu_pnUI2w,783
 thds/attrs_utils/random/union.py,sha256=FEWB4SByQFVr0vCGeWUor4W3bTB3sj0MEdavGxrBc98,1242
 thds/attrs_utils/random/util.py,sha256=tQKjJFP58NEhX5UNYuHeAUOiyf1SE39EQeZgj2O1uKk,1557
-thds_attrs_utils-1.6.20251124154148.dist-info/METADATA,sha256=QG-3u3NKwagAPjV9QpinZZOfrSGYpLPYQ5rRtjMKcAw,8685
-thds_attrs_utils-1.6.20251124154148.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thds_attrs_utils-1.6.20251124154148.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
-thds_attrs_utils-1.6.20251124154148.dist-info/RECORD,,
+thds_attrs_utils-1.7.20251204022717.dist-info/METADATA,sha256=vN81Ow2jIo_5j1wvBq2CBt-UxKySX14TSCli1scgzKc,8865
+thds_attrs_utils-1.7.20251204022717.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+thds_attrs_utils-1.7.20251204022717.dist-info/top_level.txt,sha256=LTZaE5SkWJwv9bwOlMbIhiS-JWQEEIcjVYnJrt-CriY,5
+thds_attrs_utils-1.7.20251204022717.dist-info/RECORD,,