ducktools-classbuilder 0.1.1__tar.gz → 0.2.1__tar.gz

{ducktools_classbuilder-0.1.1/src/ducktools_classbuilder.egg-info → ducktools_classbuilder-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.1.1
+Version: 0.2.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/docs/api.md

@@ -25,7 +25,7 @@
 ```
 
 ```{eval-rst}
-.. autofunction:: ducktools.classbuilder::get_internals
+.. autofunction:: ducktools.classbuilder::get_flags
 ```
 
 ```{eval-rst}

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/docs/extension_examples.md

@@ -33,16 +33,31 @@ create `__init__` and other magic methods are added to the class.
 This function is the core class generator which takes your decorated class and
 analyses and collects valid fields and then attaches the method makers.
 
-The field information is stored in the `INTERNALS_DICT` attribute and can be
-accessed using the `get_internals` function provided. This returns a dictionary
-with 2 keys: `local_fields` and `fields`. 
+The field information is stored in the `INTERNALS_DICT` attribute which should generally
+not need to be accessed directly. `get_fields` and `get_flags` functions are to be
+used to access the important keys.
 
-`"local_fields"` contains the field information obtained from **this class only**.
+`get_fields(cls)` will return the resolved information obtained from this class and subclasses.
 
-`"fields"` contains the resolved information obtained from this class and subclasses.
-This can be obtained directly using the `get_fields` function.
+`get_fields(cls, local=True)` will return the field information obtained from **this class only**.
 
-Now let's look at what the two keyword arguments need to be.
+Now let's look at what the keyword arguments to `builder` need to be.
+
+#### Flags ####
+
+Flags are information that defines how the entire class should be generated, for use by
+method generators when operating on the class.
+
+The default makers in `ducktools.classbuilder` make use of one flag - `"kw_only"` - 
+which indicates that a class `__init__` function should only take keyword arguments.
+
+Prefabs also make use of a `"slotted"` flag to indicate if the class has been generated
+with `__slots__` (checking for the existence of `__slots__` could find that a user has
+manually placed slots in the class).
+
+Flags are set using a dictionary with these keys and boolean values, for example:
+
+`cls = builder(cls, gatherer=..., methods=..., flags={"kw_only": True, "slotted": True})` 
 
 #### Gatherers ####
 
@@ -672,62 +687,233 @@ if __name__ == "__main__":
     print(H2G2.the_author)
 ```
 
-#### No attributes! Only Annotations! ####
+#### What about using annotations instead of `Field(init=False, ...)` ####
 
-If you don't like your code to run quickly, but you do love type annotations.
-
-This does everything using `Annotated` and so requires Python 3.10 for both 
-this and get_annotations.
+This seems to be a feature people keep requesting for `dataclasses`.
+This is also doable.
 
 ```python
 import inspect
+from pprint import pp
 from typing import Annotated, Any, ClassVar, get_origin
 
-from ducktools.classbuilder import builder, default_methods, Field
+from ducktools.classbuilder import (
+    builder,
+    fieldclass,
+    get_fields,
+    get_flags,
+    Field,
+    MethodMaker,
+    SlotFields,
+    NOTHING,
+)
+
+
+# New equivalent to dataclasses "Field", these still need to be created
+# in order to generate the magic methods correctly.
+@fieldclass
+class AnnoField(Field):
+    __slots__ = SlotFields(
+        init=True,
+        repr=True,
+        compare=True,
+        kw_only=False,
+    )
+
+
+# Modifying objects
+class FieldModifier:
+    __slots__ = ("modifiers", )
+    modifiers: dict[str, Any]
+
+    def __init__(self, **modifiers):
+        self.modifiers = modifiers
+
+    def __repr__(self):
+        mod_args = ", ".join(f"{k}={v!r}" for k, v in self.modifiers.items())
+        return (
+            f"{type(self).__name__}({mod_args})"
+        )
+
+    def __eq__(self, other):
+        if self.__class__ == other.__class__:
+            return self.modifiers == other.modifiers
+        return NotImplemented
+
+
+KW_ONLY = FieldModifier(kw_only=True)
+NO_INIT = FieldModifier(init=False)
+NO_REPR = FieldModifier(repr=False)
+NO_COMPARE = FieldModifier(compare=False)
+IGNORE_ALL = FieldModifier(init=False, repr=False, compare=False)
 
 
 def annotated_gatherer(cls: type) -> dict[str, Any]:
+    # String annotations *MUST* be evaluated for this to work
+    # dataclasses currently does not require this
     cls_annotations = inspect.get_annotations(cls, eval_str=True)
     cls_fields = {}
 
     for key, anno in cls_annotations.items():
-        # Is there another way to do this?
+        modifiers = {}
+        typ = NOTHING
+
         if get_origin(anno) is Annotated:
             typ = anno.__args__[0]
             meta = anno.__metadata__
             for v in meta:
-                if isinstance(v, Field):
-                    fld = Field.from_field(v, type=typ)
-                    break
-            else:
-                fld = Field(type=typ)
-        elif anno is ClassVar or get_origin(anno) is ClassVar:
-            fld = None
-        else:
+                if isinstance(v, FieldModifier):
+                    modifiers.update(v.modifiers)
+
+        elif not (anno is ClassVar or get_origin(anno) is ClassVar):
             typ = anno
-            fld = Field(type=typ)
 
-        if fld:
-            cls_fields[key] = fld
+        if typ is not NOTHING:
             if key in cls.__dict__ and "__slots__" not in cls.__dict__:
-                raise AttributeError("No attributes! Only Annotations!")
+                val = cls.__dict__[key]
+                if isinstance(val, Field):
+                    fld = AnnoField.from_field(val, type=typ, **modifiers)
+                else:
+                    fld = AnnoField(default=val, type=typ, **modifiers)
+            else:
+                fld = AnnoField(type=typ, **modifiers)
+
+            cls_fields[key] = fld
 
     return cls_fields
 
 
-def annotationsclass(cls):
-    return builder(cls, gatherer=annotated_gatherer, methods=default_methods)
+def init_maker(cls):
+
+    fields = get_fields(cls)
+    flags = get_flags(cls)
+
+    arglist = []
+    kw_only_arglist = []
+
+    assignments = []
+    globs = {}
+
+    # Whole class kw_only
+    kw_only = flags.get("kw_only", False)
+
+    for k, v in fields.items():
+        if getattr(v, "init", True):
+            if v.default is not NOTHING:
+                globs[f"_{k}_default"] = v.default
+                arg = f"{k}=_{k}_default"
+                assignment = f"self.{k} = {k}"
+            elif v.default_factory is not NOTHING:
+                globs[f"_{k}_factory"] = v.default_factory
+                arg = f"{k}=None"
+                assignment = f"self.{k} = _{k}_factory() if {k} is None else {k}"
+            else:
+                arg = f"{k}"
+                assignment = f"self.{k} = {k}"
+
+            if getattr(v, "kw_only", False) or kw_only:
+                kw_only_arglist.append(arg)
+            else:
+                arglist.append(arg)
+
+            assignments.append(assignment)
+        else:
+            if v.default is not NOTHING:
+                globs[f"_{k}_default"] = v.default
+                assignment = f"self.{k} = _{k}_default"
+                assignments.append(assignment)
+            elif v.default_factory is not NOTHING:
+                globs[f"_{k}_factory"] = v.default_factory
+                assignment = f"self.{k} = _{k}_factory()"
+                assignments.append(assignment)
+
+    if kw_only_arglist:
+        arglist.append("*")
+        arglist.extend(kw_only_arglist)
+
+    args = ", ".join(arglist)
+    assigns = "\n    ".join(assignments)
+    code = f"def __init__(self, {args}):\n" f"    {assigns}\n"
+
+    return code, globs
+
+
+def repr_maker(cls):
+    fields = get_fields(cls)
+    content = ", ".join(
+        f"{name}={{self.{name}!r}}"
+        for name, fld in fields.items()
+        if getattr(fld, "repr", True)
+    )
+    code = (
+        f"def __repr__(self):\n"
+        f"    return f'{{type(self).__qualname__}}({content})'\n"
+    )
+    globs = {}
+    return code, globs
+
+
+def eq_maker(cls):
+    class_comparison = "self.__class__ is other.__class__"
+    field_names = [
+        name
+        for name, fld in get_fields(cls).items()
+        if getattr(fld, "compare", True)
+    ]
+
+    if field_names:
+        selfvals = ",".join(f"self.{name}" for name in field_names)
+        othervals = ",".join(f"other.{name}" for name in field_names)
+        instance_comparison = f"({selfvals},) == ({othervals},)"
+    else:
+        instance_comparison = "True"
+
+    code = (
+        f"def __eq__(self, other):\n"
+        f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
+    )
+    globs = {}
+
+    return code, globs
+
+
+init_method = MethodMaker("__init__", init_maker)
+repr_method = MethodMaker("__repr__", repr_maker)
+eq_method = MethodMaker("__eq__", eq_maker)
+
+methods = {init_method, repr_method, eq_method}
+
+
+def annotationsclass(cls=None, *, kw_only=False):
+    if not cls:
+        return lambda cls_: annotationsclass(cls_, kw_only=kw_only)
+
+    return builder(
+        cls,
+        gatherer=annotated_gatherer,
+        methods=methods,
+        flags={"slotted": False, "kw_only": kw_only}
+    )
 
 
 @annotationsclass
 class X:
     x: str
     y: ClassVar[str] = "This is okay"
-    a: Annotated[int, Field(default=1)]
-    b: Annotated[str, Field(default="example")]
-    c: Annotated[list[str], Field(default_factory=list)]
+    a: Annotated[int, NO_INIT] = "Not In __init__ signature"
+    b: Annotated[str, NO_REPR] = "Not In Repr"
+    c: Annotated[list[str], NO_COMPARE] = AnnoField(default_factory=list)
+    d: Annotated[str, IGNORE_ALL] = "Not Anywhere"
+    e: Annotated[str, KW_ONLY, NO_COMPARE]
+
+
+ex = X("Value of x", e="Value of e")
 
+print(ex, "\n")
 
-print(X("Testing"))
-print(X.y)
+pp(get_fields(X))
+print("\nSource:")
+print(init_maker(X)[0])
+print(eq_maker(X)[0])
+print(repr_maker(X)[0])
 ```

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/src/ducktools/classbuilder/__init__.py

@@ -19,7 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-__version__ = "v0.1.1"
+__version__ = "v0.2.1"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
@@ -34,6 +34,9 @@ def get_internals(cls):
     and 'local_fields' attributes this will always
     evaluate as 'truthy' if this is a generated class.
 
+    Generally you should use the helper get_flags and
+    get_fields methods.
+
     Usage:
        if internals := get_internals(cls):
            ...
@@ -44,15 +47,28 @@ def get_internals(cls):
     return getattr(cls, INTERNALS_DICT, None)
 
 
-def get_fields(cls):
+def get_fields(cls, *, local=False):
     """
     Utility function to gather the fields dictionary
     from the class internals.
 
     :param cls: generated class
+    :param local: get only fields that were not inherited
     :return: dictionary of keys and Field attribute info
     """
-    return getattr(cls, INTERNALS_DICT)["fields"]
+    key = "local_fields" if local else "fields"
+    return getattr(cls, INTERNALS_DICT)[key]
+
+
+def get_flags(cls):
+    """
+    Utility function to gather the flags dictionary
+    from the class internals.
+
+    :param cls: generated class
+    :return: dictionary of keys and flag values
+    """
+    return getattr(cls, INTERNALS_DICT)["flags"]
 
 
 def get_inst_fields(inst):
@@ -106,14 +122,15 @@ class MethodMaker:
         return method.__get__(instance, cls)
 
 
-def init_maker(cls, *, null=NOTHING, kw_only=False):
+def init_maker(cls, *, null=NOTHING):
     fields = get_fields(cls)
+    flags = get_flags(cls)
 
     arglist = []
     assignments = []
     globs = {}
 
-    if kw_only:
+    if flags.get("kw_only", False):
         arglist.append("*")
 
     for k, v in fields.items():
@@ -180,7 +197,7 @@ eq_desc = MethodMaker("__eq__", eq_maker)
 default_methods = frozenset({init_desc, repr_desc, eq_desc})
 
 
-def builder(cls=None, /, *, gatherer, methods):
+def builder(cls=None, /, *, gatherer, methods, flags=None):
     """
     The main builder for class generation
 
@@ -189,6 +206,8 @@ def builder(cls=None, /, *, gatherer, methods):
     :type gatherer: Callable[[type], dict[str, Field]]
     :param methods: MethodMakers to add to the class
     :type methods: set[MethodMaker]
+    :param flags: additional flags to store in the internals dictionary
+                  for use by method generators.
     :return: The modified class (the class itself is modified, but this is expected).
     """
     # Handle `None` to make wrapping with a decorator easier.
@@ -197,6 +216,7 @@ def builder(cls=None, /, *, gatherer, methods):
             cls_,
             gatherer=gatherer,
             methods=methods,
+            flags=flags,
         )
 
     internals = {}
@@ -212,11 +232,12 @@ def builder(cls=None, /, *, gatherer, methods):
         fields = {}
         for c in reversed(mro):
             try:
-                fields.update(get_internals(c)["local_fields"])
+                fields.update(get_fields(c, local=True))
             except AttributeError:
                 pass
 
     internals["fields"] = fields
+    internals["flags"] = flags if flags is not None else {}
 
     # Assign all of the method generators
     for method in methods:
@@ -296,7 +317,8 @@ _field_internal = {
 builder(
     Field,
     gatherer=lambda cls_: _field_internal,
-    methods=frozenset({repr_desc, eq_desc})
+    methods=frozenset({repr_desc, eq_desc}),
+    flags={"slotted": True, "kw_only": True},
 )
 
 
@@ -368,7 +390,7 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     if not cls:
         return lambda cls_: slotclass(cls_, methods=methods, syntax_check=syntax_check)
 
-    cls = builder(cls, gatherer=slot_gatherer, methods=methods)
+    cls = builder(cls, gatherer=slot_gatherer, methods=methods, flags={"slotted": True})
 
     if syntax_check:
         fields = get_fields(cls)
@@ -398,7 +420,7 @@ def fieldclass(cls):
     # Fields need a way to call their validate method
     # So append it to the code from __init__.
     def field_init_func(cls_):
-        code, globs = init_maker(cls_, null=field_nothing, kw_only=True)
+        code, globs = init_maker(cls_, null=field_nothing)
         code += "    self.validate_field()\n"
         return code, globs
 
@@ -412,7 +434,8 @@ def fieldclass(cls):
     cls = builder(
         cls,
         gatherer=slot_gatherer,
-        methods=field_methods
+        methods=field_methods,
+        flags={"slotted": True, "kw_only": True}
     )
 
     return cls

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/src/ducktools/classbuilder/__init__.pyi

@@ -8,7 +8,9 @@ INTERNALS_DICT: str
 
 def get_internals(cls) -> dict[str, typing.Any] | None: ...
 
-def get_fields(cls: type) -> dict[str, Field]: ...
+def get_fields(cls: type, *, local: bool = False) -> dict[str, Field]: ...
+
+def get_flags(cls:type) -> dict[str, bool]: ...
 
 def get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
@@ -30,7 +32,6 @@ def init_maker(
     cls: type,
     *,
     null: _NothingType = NOTHING,
-    kw_only: bool = False
 ) -> tuple[str, dict[str, typing.Any]]: ...
 def repr_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
 def eq_maker(cls: type) -> tuple[str, dict[str, typing.Any]]: ...
@@ -48,7 +49,8 @@ def builder(
     /,
     *,
     gatherer: Callable[[type], dict[str, Field]],
-    methods: frozenset[MethodMaker] | set[MethodMaker]
+    methods: frozenset[MethodMaker] | set[MethodMaker],
+    flags: dict[str, bool] | None = None,
 ) -> type[_T]: ...
 
 @typing.overload
@@ -57,7 +59,8 @@ def builder(
     /,
     *,
     gatherer: Callable[[type], dict[str, Field]],
-    methods: frozenset[MethodMaker] | set[MethodMaker]
+    methods: frozenset[MethodMaker] | set[MethodMaker],
+    flags: dict[str, bool] | None = None,
 ) -> Callable[[type[_T]], type[_T]]: ...
 
 

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/src/ducktools/classbuilder/prefab.py

@@ -31,7 +31,7 @@ import sys
 from . import (
     INTERNALS_DICT, NOTHING,
     Field, MethodMaker, SlotFields,
-    builder, fieldclass, get_internals, slot_gatherer
+    builder, fieldclass, get_flags, get_fields, slot_gatherer
 )
 
 PREFAB_FIELDS = "PREFAB_FIELDS"
@@ -84,10 +84,11 @@ def get_attributes(cls):
 def get_init_maker(*, init_name="__init__"):
     def __init__(cls: "type") -> "tuple[str, dict]":
         globs = {}
-        internals = get_internals(cls)
         # Get the internals dictionary and prepare attributes
-        attributes = internals["fields"]
-        kw_only = internals["kw_only"]
+        attributes = get_attributes(cls)
+        flags = get_flags(cls)
+
+        kw_only = flags.get("kw_only", False)
 
         # Handle pre/post init first - post_init can change types for __init__
         # Get pre and post init arguments
@@ -342,14 +343,16 @@ def get_iter_maker():
 def get_frozen_setattr_maker():
     def __setattr__(cls: "type") -> "tuple[str, dict]":
         globs = {}
-        internals = get_internals(cls)
-        field_names = internals["fields"].keys()
+        attributes = get_attributes(cls)
+        flags = get_flags(cls)
 
         # Make the fields set literal
-        fields_delimited = ", ".join(f"{field!r}" for field in field_names)
+        fields_delimited = ", ".join(f"{field!r}" for field in attributes)
         field_set = f"{{ {fields_delimited} }}"
 
-        if internals["slotted"]:
+        # Better to be safe and use the method that works in both cases
+        # if somehow slotted has not been set.
+        if flags.get("slotted", True):
             globs["__prefab_setattr_func"] = object.__setattr__
             setattr_method = "__prefab_setattr_func(self, name, value)"
         else:
@@ -395,7 +398,7 @@ def get_asdict_maker():
         vals = ", ".join(
             f"'{name}': self.{name}"
             for name, attrib in fields.items()
-            if attrib.in_dict and not attrib.exclude_field
+            if attrib.serialize and not attrib.exclude_field
         )
         out_dict = f"{{{vals}}}"
         code = f"def as_dict(self): return {out_dict}"
@@ -425,7 +428,7 @@ class Attribute(Field):
         compare=True,
         iter=True,
         kw_only=False,
-        in_dict=True,
+        serialize=True,
         exclude_field=False,
     )
 
@@ -447,7 +450,7 @@ def attribute(
     compare=True,
     iter=True,
     kw_only=False,
-    in_dict=True,
+    serialize=True,
     exclude_field=False,
     doc=None,
     type=NOTHING,
@@ -463,7 +466,7 @@ def attribute(
     :param compare: Include this attribute in the class __eq__
     :param iter: Include this attribute in the class __iter__ if generated
     :param kw_only: Make this argument keyword only in init
-    :param in_dict: Include this attribute in methods that serialise to dict
+    :param serialize: Include this attribute in methods that serialize to dict
     :param exclude_field: Exclude this field from all magic method generation
                           apart from __init__ signature
                           and do not include it in PREFAB_FIELDS
@@ -481,13 +484,21 @@ def attribute(
         compare=compare,
         iter=iter,
         kw_only=kw_only,
-        in_dict=in_dict,
+        serialize=serialize,
         exclude_field=exclude_field,
         doc=doc,
         type=type,
     )
 
 
+def slot_prefab_gatherer(cls):
+    # For prefabs it's easier if everything is an attribute
+    return {
+        name: Attribute.from_field(fld)
+        for name, fld in slot_gatherer(cls).items()
+    }
+
+
 # Gatherer for classes built on attributes or annotations
 def attribute_gatherer(cls):
     cls_annotations = cls.__dict__.get("__annotations__", {})
@@ -599,7 +610,7 @@ def _make_prefab(
 
     slots = cls_dict.get("__slots__")
     if isinstance(slots, SlotFields):
-        gatherer = slot_gatherer
+        gatherer = slot_prefab_gatherer
         slotted = True
     else:
         gatherer = attribute_gatherer
@@ -627,18 +638,20 @@ def _make_prefab(
     if dict_method:
         methods.add(asdict_desc)
 
+    flags = {
+        "kw_only": kw_only,
+        "slotted": slotted,
+    }
+
     cls = builder(
         cls,
         gatherer=gatherer,
         methods=methods,
+        flags=flags,
     )
 
-    # Add fields not covered by builder
-    internals = get_internals(cls)
-    internals["slotted"] = slotted
-    internals["kw_only"] = kw_only
-    fields = internals["fields"]
-    local_fields = internals["local_fields"]
+    # Get fields now the class has been built
+    fields = get_fields(cls)
 
     # Check pre_init and post_init functions if they exist
     try:
@@ -710,8 +723,6 @@ def _make_prefab(
         if not isinstance(attrib, Attribute):
             attrib = Attribute.from_field(attrib)
             fields[name] = attrib
-            if name in local_fields:
-                local_fields[name] = attrib
 
         # Excluded fields *MUST* be forwarded to post_init
         if attrib.exclude_field:
@@ -895,7 +906,7 @@ def is_prefab_instance(o):
 
 def as_dict(o):
     """
-    Get the valid fields from a prefab respecting the in_dict
+    Get the valid fields from a prefab respecting the serialize
     values of attributes
 
     :param o: instance of a prefab class
@@ -916,5 +927,5 @@ def as_dict(o):
     return {
         name: getattr(o, name)
         for name, attrib in flds.items()
-        if attrib.in_dict and not attrib.exclude_field
+        if attrib.serialize and not attrib.exclude_field
     }

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/src/ducktools/classbuilder/prefab.pyi

@@ -63,7 +63,7 @@ class Attribute(Field):
     compare: bool
     iter: bool
     kw_only: bool
-    in_dict: bool
+    serialize: bool
     exclude_field: bool
 
     def __init__(
@@ -78,7 +78,7 @@ class Attribute(Field):
         compare: bool = True,
         iter: bool = True,
         kw_only: bool = False,
-        in_dict: bool = True,
+        serialize: bool = True,
         exclude_field: bool = False,
     ) -> None: ...
 
@@ -97,10 +97,12 @@ def attribute(
     compare: bool = True,
     iter: bool = True,
     kw_only: bool = False,
-    in_dict: bool = True,
+    serialize: bool = True,
     exclude_field: bool = False,
 ) -> Attribute: ...
 
+def slot_prefab_gatherer(cls: type) -> dict[str, Attribute]: ...
+
 def attribute_gatherer(cls: type) -> dict[str, Attribute]: ...
 
 def _make_prefab(

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1/src/ducktools_classbuilder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.1.1
+Version: 0.2.1
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License

{ducktools_classbuilder-0.1.1 → ducktools_classbuilder-0.2.1}/tests/prefab/shared/test_funcs.py

@@ -45,18 +45,18 @@ def test_as_dict_excludes():
     @prefab
     class ExcludesUncached:
         name: str
-        password: str = attribute(in_dict=False)
+        password: str = attribute(serialize=False)
 
     @prefab(dict_method=True)
     class ExcludesCached:
         name: str
-        password: str = attribute(in_dict=False)
+        password: str = attribute(serialize=False)
 
     @prefab(dict_method=True)
     class ExcludesSlots:
         __slots__ = SlotFields(
             name=attribute(type=str),
-            password=attribute(in_dict=False, type=str)
+            password=attribute(serialize=False, type=str)
         )
 
     @prefab(dict_method=True)