ducktools-classbuilder 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -19,18 +19,39 @@
 # 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.
+
+# In this module there are some internal bits of circular logic.
+#
+# 'Field' needs to exist in order to be used in gatherers, but is itself a
+# partially constructed class. These constructed attributes are placed on
+# 'Field' post construction.
+#
+# The 'SlotMakerMeta' metaclass generates 'Field' instances to go in __slots__
+# but is also the metaclass used to construct 'Field'.
+# Field itself sidesteps this by defining __slots__ to avoid that branch.
+
 import sys
 
-__version__ = "v0.5.1"
+from .annotations import get_ns_annotations, is_classvar
+
+__version__ = "v0.6.1"
 
 # Change this name if you make heavy modifications
 INTERNALS_DICT = "__classbuilder_internals__"
+META_GATHERER_NAME = "_meta_gatherer"
 
 
 # If testing, make Field classes frozen to make sure attributes are not
 # overwritten. When running this is a performance penalty so it is not required.
 _UNDER_TESTING = "pytest" in sys.modules
 
+# Obtain types the same way types.py does in pypy
+# See: https://github.com/pypy/pypy/blob/19d9fa6be11165116dd0839b9144d969ab426ae7/lib-python/3/types.py#L61-L73
+class _C: __slots__ = 's'  # noqa
+_MemberDescriptorType = type(_C.s)  # noqa
+_MappingProxyType = type(type.__dict__)
+del _C
+
 
 def get_fields(cls, *, local=False):
     """
@@ -56,6 +77,17 @@ def get_flags(cls):
     return getattr(cls, INTERNALS_DICT)["flags"]
 
 
+def get_methods(cls):
+    """
+    Utility function to gather the set of methods
+    from the class internals.
+
+    :param cls: generated class
+    :return: dict of generated methods attached to the class by name
+    """
+    return getattr(cls, INTERNALS_DICT)["methods"]
+
+
 def _get_inst_fields(inst):
     # This is an internal helper for constructing new
     # 'Field' instances from existing ones.
@@ -75,6 +107,38 @@ class _NothingType:
 NOTHING = _NothingType()
 
 
+# KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
+# keyword only
+# noinspection PyPep8Naming
+class _KW_ONLY_TYPE:
+    def __repr__(self):
+        return "<KW_ONLY Sentinel Object>"
+
+
+KW_ONLY = _KW_ONLY_TYPE()
+
+
+class GeneratedCode:
+    """
+    This class provides a return value for the generated output from source code
+    generators.
+    """
+    __slots__ = ("source_code", "globs")
+
+    def __init__(self, source_code, globs):
+        self.source_code = source_code
+        self.globs = globs
+
+    def __repr__(self):
+        first_source_line = self.source_code.split("\n")[0]
+        return f"GeneratorOutput(source_code='{first_source_line} ...', globs={self.globs!r})"
+
+    def __eq__(self, other):
+        if self.__class__ is other.__class__:
+            return (self.source_code, self.globs) == (other.source_code, other.globs)
+        return NotImplemented
+
+
 class MethodMaker:
     """
     The descriptor class to place where methods should be generated.
@@ -94,53 +158,88 @@ class MethodMaker:
     def __repr__(self):
         return f"<MethodMaker for {self.funcname!r} method>"
 
-    def __get__(self, instance, cls):
+    def __get__(self, obj, objtype=None):
+        if objtype is None or issubclass(objtype, type):
+            # Called with get(ourclass, type(ourclass))
+            cls = obj
+        else:
+            # Called with get(inst | None, ourclass)
+            cls = objtype
+
         local_vars = {}
-        code, globs = self.code_generator(cls)
-        exec(code, globs, local_vars)
+        gen = self.code_generator(cls, self.funcname)
+        exec(gen.source_code, gen.globs, local_vars)
         method = local_vars.get(self.funcname)
-        method.__qualname__ = f"{cls.__qualname__}.{self.funcname}"
+
+        try:
+            method.__qualname__ = f"{cls.__qualname__}.{self.funcname}"
+        except AttributeError:
+            # This might be a property or some other special
+            # descriptor. Don't try to rename.
+            pass
 
         # Replace this descriptor on the class with the generated function
         setattr(cls, self.funcname, method)
 
         # Use 'get' to return the generated function as a bound method
         # instead of as a regular function for first usage.
-        return method.__get__(instance, cls)
+        return method.__get__(obj, objtype)
 
 
 def get_init_generator(null=NOTHING, extra_code=None):
-    def cls_init_maker(cls):
+    def cls_init_maker(cls, funcname="__init__"):
         fields = get_fields(cls)
         flags = get_flags(cls)
 
         arglist = []
+        kw_only_arglist = []
         assignments = []
         globs = {}
 
-        if flags.get("kw_only", False):
-            arglist.append("*")
+        kw_only_flag = flags.get("kw_only", False)
 
         for k, v in fields.items():
-            if v.default is not null:
-                globs[f"_{k}_default"] = v.default
-                arg = f"{k}=_{k}_default"
-                assignment = f"self.{k} = {k}"
-            elif v.default_factory is not null:
-                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 v.init:
+                if v.default is not null:
+                    globs[f"_{k}_default"] = v.default
+                    arg = f"{k}=_{k}_default"
+                    assignment = f"self.{k} = {k}"
+                elif v.default_factory is not null:
+                    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 kw_only_flag or v.kw_only:
+                    kw_only_arglist.append(arg)
+                else:
+                    arglist.append(arg)
 
-            arglist.append(arg)
-            assignments.append(assignment)
+                assignments.append(assignment)
+            else:
+                if v.default is not null:
+                    globs[f"_{k}_default"] = v.default
+                    assignment = f"self.{k} = _{k}_default"
+                    assignments.append(assignment)
+                elif v.default_factory is not null:
+                    globs[f"_{k}_factory"] = v.default_factory
+                    assignment = f"self.{k} = _{k}_factory()"
+                    assignments.append(assignment)
+
+        pos_args = ", ".join(arglist)
+        kw_args = ", ".join(kw_only_arglist)
+        if pos_args and kw_args:
+            args = f"{pos_args}, *, {kw_args}"
+        elif kw_args:
+            args = f"*, {kw_args}"
+        else:
+            args = pos_args
 
-        args = ", ".join(arglist)
         assigns = "\n    ".join(assignments) if assignments else "pass\n"
         code = (
-            f"def __init__(self, {args}):\n" 
+            f"def {funcname}(self, {args}):\n" 
             f"    {assigns}\n"
         )
         # Handle additional function calls
@@ -149,7 +248,7 @@ def get_init_generator(null=NOTHING, extra_code=None):
             for line in extra_code:
                 code += f"    {line}\n"
 
-        return code, globs
+        return GeneratedCode(code, globs)
 
     return cls_init_maker
 
@@ -157,23 +256,75 @@ def get_init_generator(null=NOTHING, extra_code=None):
 init_generator = get_init_generator()
 
 
-def repr_generator(cls):
-    fields = get_fields(cls)
-    content = ", ".join(
-        f"{name}={{self.{name}!r}}"
-        for name, attrib in fields.items()
-    )
-    code = (
-        f"def __repr__(self):\n"
-        f"    return f'{{type(self).__qualname__}}({content})'\n"
-    )
-    globs = {}
-    return code, globs
+def get_repr_generator(recursion_safe=False, eval_safe=False):
+    """
+
+    :param recursion_safe: use reprlib.recursive_repr
+    :param eval_safe: if the repr is known not to eval correctly,
+                      generate a repr which will intentionally
+                      not evaluate.
+    :return:
+    """
+    def cls_repr_generator(cls, funcname="__repr__"):
+        fields = get_fields(cls)
+
+        globs = {}
+        will_eval = True
+        valid_names = []
+
+        for name, fld in fields.items():
+            if fld.repr:
+                valid_names.append(name)
+
+            if will_eval and (fld.init ^ fld.repr):
+                will_eval = False
+
+        content = ", ".join(
+            f"{name}={{self.{name}!r}}"
+            for name in valid_names
+        )
+
+        if recursion_safe:
+            import reprlib
+            globs["_recursive_repr"] = reprlib.recursive_repr()
+            recursion_func = "@_recursive_repr\n"
+        else:
+            recursion_func = ""
+
+        if eval_safe and will_eval is False:
+            if content:
+                code = (
+                    f"{recursion_func}"
+                    f"def {funcname}(self):\n"
+                    f"    return f'<generated class {{type(self).__qualname__}}; {content}>'\n"
+                )
+            else:
+                code = (
+                    f"{recursion_func}"
+                    f"def {funcname}(self):\n"
+                    f"    return f'<generated class {{type(self).__qualname__}}>'\n"
+                )
+        else:
+            code = (
+                f"{recursion_func}"
+                f"def {funcname}(self):\n"
+                f"    return f'{{type(self).__qualname__}}({content})'\n"
+            )
+
+        return GeneratedCode(code, globs)
+    return cls_repr_generator
+
 
+repr_generator = get_repr_generator()
 
-def eq_generator(cls):
+
+def eq_generator(cls, funcname="__eq__"):
     class_comparison = "self.__class__ is other.__class__"
-    field_names = get_fields(cls)
+    field_names = [
+        name
+        for name, attrib in get_fields(cls).items()
+        if attrib.compare
+    ]
 
     if field_names:
         selfvals = ",".join(f"self.{name}" for name in field_names)
@@ -183,15 +334,15 @@ def eq_generator(cls):
         instance_comparison = "True"
 
     code = (
-        f"def __eq__(self, other):\n"
+        f"def {funcname}(self, other):\n"
         f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
     )
     globs = {}
 
-    return code, globs
+    return GeneratedCode(code, globs)
 
 
-def frozen_setattr_generator(cls):
+def frozen_setattr_generator(cls, funcname="__setattr__"):
     globs = {}
     field_names = set(get_fields(cls))
     flags = get_flags(cls)
@@ -215,21 +366,21 @@ def frozen_setattr_generator(cls):
         f"    else:\n"
         f"        {setattr_method}\n"
     )
-    code = f"def __setattr__(self, name, value):\n{body}"
+    code = f"def {funcname}(self, name, value):\n{body}"
 
-    return code, globs
+    return GeneratedCode(code, globs)
 
 
-def frozen_delattr_generator(cls):
+def frozen_delattr_generator(cls, funcname="__delattr__"):
     body = (
         '    raise TypeError(\n'
         '        f"{type(self).__name__!r} object "\n'
         '        f"does not support attribute deletion"\n'
         '    )\n'
     )
-    code = f"def __delattr__(self, name):\n{body}"
+    code = f"def {funcname}(self, name):\n{body}"
     globs = {}
-    return code, globs
+    return GeneratedCode(code, globs)
 
 
 # As only the __get__ method refers to the class we can use the same
@@ -241,6 +392,15 @@ frozen_setattr_maker = MethodMaker("__setattr__", frozen_setattr_generator)
 frozen_delattr_maker = MethodMaker("__delattr__", frozen_delattr_generator)
 default_methods = frozenset({init_maker, repr_maker, eq_maker})
 
+# Special `__init__` maker for 'Field' subclasses
+_field_init_maker = MethodMaker(
+    funcname="__init__",
+    code_generator=get_init_generator(
+        null=_NothingType(),
+        extra_code=["self.validate_field()"],
+    )
+)
+
 
 def builder(cls=None, /, *, gatherer, methods, flags=None):
     """
@@ -292,16 +452,77 @@ def builder(cls=None, /, *, gatherer, methods, flags=None):
     internals["flags"] = flags if flags is not None else {}
 
     # Assign all of the method generators
+    internal_methods = {}
     for method in methods:
         setattr(cls, method.funcname, method)
+        internal_methods[method.funcname] = method
+
+    internals["methods"] = _MappingProxyType(internal_methods)
 
     return cls
 
 
+# Slot gathering tools
+# Subclass of dict to be identifiable by isinstance checks
+# For anything more complicated this could be made into a Mapping
+class SlotFields(dict):
+    """
+    A plain dict subclass.
+
+    For declaring slotfields there are no additional features required
+    other than recognising that this is intended to be used as a class
+    generating dict and isn't a regular dictionary that ended up in
+    `__slots__`.
+
+    This should be replaced on `__slots__` after fields have been gathered.
+    """
+    def __repr__(self):
+        return f"SlotFields({super().__repr__()})"
+
+
+# Tool to convert annotations to slots as a metaclass
+class SlotMakerMeta(type):
+    """
+    Metaclass to convert annotations or Field(...) attributes to slots.
+
+    Will not convert `ClassVar` hinted values.
+    """
+    def __new__(cls, name, bases, ns, slots=True, **kwargs):
+        # This should only run if slots=True is declared
+        # and __slots__ have not already been defined
+        if slots and "__slots__" not in ns:
+            # Check if a different gatherer has been set in any base classes
+            # Default to unified gatherer
+            gatherer = ns.get(META_GATHERER_NAME, None)
+            if not gatherer:
+                for base in bases:
+                    if g := getattr(base, META_GATHERER_NAME, None):
+                        gatherer = g
+                        break
+
+            if not gatherer:
+                gatherer = unified_gatherer
+
+            # Obtain slots from annotations or attributes
+            cls_fields, cls_modifications = gatherer(ns)
+            for k, v in cls_modifications.items():
+                if v is NOTHING:
+                    ns.pop(k)
+                else:
+                    ns[k] = v
+
+            # Place slots *after* everything else to be safe
+            ns["__slots__"] = SlotFields(cls_fields)
+
+        new_cls = super().__new__(cls, name, bases, ns, **kwargs)
+
+        return new_cls
+
+
 # The Field class can finally be defined.
 # The __init__ method has to be written manually so Fields can be created
 # However after this, the other methods can be generated.
-class Field:
+class Field(metaclass=SlotMakerMeta):
     """
     A basic class to handle the assignment of defaults/factories with
     some metadata.
@@ -309,16 +530,32 @@ class Field:
     Intended to be extendable by subclasses for additional features.
 
     Note: When run under `pytest`, Field instances are Frozen.
+
+    When subclassing, passing `frozen=True` will make your subclass frozen.
+
+    :param default: Standard default value to be used for attributes with this field.
+    :param default_factory: A zero-argument function to be called to generate a
+                            default value, useful for mutable obects like lists.
+    :param type: The type of the attribute to be assigned by this field.
+    :param doc: The documentation for the attribute that appears when calling
+                help(...) on the class. (Only in slotted classes).
+    :param init: Include in the class __init__ parameters.
+    :param repr: Include in the class __repr__.
+    :param compare: Include in the class __eq__.
+    :param kw_only: Make this a keyword only parameter in __init__.
     """
-    __slots__ = {
-        "default": "Standard default value to be used for attributes with"
-                   "this field.",
-        "default_factory": "A 0 argument function to be called to generate "
-                           "a default value, useful for mutable objects like "
-                           "lists.",
-        "type": "The type of the attribute to be assigned by this field.",
-        "doc": "The documentation that appears when calling help(...) on the class."
-    }
+    # If this base class did not define __slots__ the metaclass would break it.
+    # This will be replaced by the builder.
+    __slots__ = SlotFields(
+        default=NOTHING,
+        default_factory=NOTHING,
+        type=NOTHING,
+        doc=None,
+        init=True,
+        repr=True,
+        compare=True,
+        kw_only=False,
+    )
 
     # noinspection PyShadowingBuiltins
     def __init__(
@@ -328,18 +565,50 @@ class Field:
         default_factory=NOTHING,
         type=NOTHING,
         doc=None,
+        init=True,
+        repr=True,
+        compare=True,
+        kw_only=False,
     ):
+        # The init function for 'Field' cannot be generated
+        # as 'Field' needs to exist first.
+        # repr and comparison functions are generated as these
+        # do not need to exist to create initial Fields.
+
         self.default = default
         self.default_factory = default_factory
         self.type = type
         self.doc = doc
 
+        self.init = init
+        self.repr = repr
+        self.compare = compare
+        self.kw_only = kw_only
+
         self.validate_field()
 
+    def __init_subclass__(cls, frozen=False):
+        field_methods = {_field_init_maker, repr_maker, eq_maker}
+        if frozen or _UNDER_TESTING:
+            field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
+
+        builder(
+            cls,
+            gatherer=unified_gatherer,
+            methods=field_methods,
+            flags={"slotted": True, "kw_only": True}
+        )
+
     def validate_field(self):
+        cls_name = self.__class__.__name__
         if self.default is not NOTHING and self.default_factory is not NOTHING:
             raise AttributeError(
-                "Cannot define both a default value and a default factory."
+                f"{cls_name} cannot define both a default value and a default factory."
+            )
+
+        if self.kw_only and not self.init:
+            raise AttributeError(
+                f"{cls_name} cannot be keyword only if it is not in init."
             )
 
     @classmethod
@@ -359,66 +628,6 @@ class Field:
         return cls(**argument_dict)
 
 
-class GatheredFields:
-    __slots__ = ("fields", "modifications")
-
-    def __init__(self, fields, modifications):
-        self.fields = fields
-        self.modifications = modifications
-
-    def __call__(self, cls):
-        return self.fields, self.modifications
-
-
-# Use the builder to generate __repr__ and __eq__ methods
-# for both Field and GatheredFields
-_field_internal = {
-    "default": Field(default=NOTHING),
-    "default_factory": Field(default=NOTHING),
-    "type": Field(default=NOTHING),
-    "doc": Field(default=None),
-}
-
-_gathered_field_internal = {
-    "fields": Field(default=NOTHING),
-    "modifications": Field(default=NOTHING),
-}
-
-_field_methods = {repr_maker, eq_maker}
-if _UNDER_TESTING:
-    _field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
-
-builder(
-    Field,
-    gatherer=GatheredFields(_field_internal, {}),
-    methods=_field_methods,
-    flags={"slotted": True, "kw_only": True},
-)
-
-builder(
-    GatheredFields,
-    gatherer=GatheredFields(_gathered_field_internal, {}),
-    methods={repr_maker, eq_maker},
-    flags={"slotted": True, "kw_only": False},
-)
-
-
-# Slot gathering tools
-# Subclass of dict to be identifiable by isinstance checks
-# For anything more complicated this could be made into a Mapping
-class SlotFields(dict):
-    """
-    A plain dict subclass.
-
-    For declaring slotfields there are no additional features required
-    other than recognising that this is intended to be used as a class
-    generating dict and isn't a regular dictionary that ended up in
-    `__slots__`.
-
-    This should be replaced on `__slots__` after fields have been gathered.
-    """
-
-
 def make_slot_gatherer(field_type=Field):
     """
     Create a new annotation gatherer that will work with `Field` instances
@@ -428,14 +637,25 @@ def make_slot_gatherer(field_type=Field):
     :return: A slot gatherer that will check for and generate Fields of
              the type field_type.
     """
-    def field_slot_gatherer(cls):
+    def field_slot_gatherer(cls_or_ns):
         """
         Gather field information for class generation based on __slots__
 
-        :param cls: Class to gather field information from
+        :param cls_or_ns: Class to gather field information from (or class namespace)
         :return: dict of field_name: Field(...)
         """
-        cls_slots = cls.__dict__.get("__slots__", None)
+        if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+            cls_dict = cls_or_ns
+        else:
+            cls_dict = cls_or_ns.__dict__
+
+        try:
+            cls_slots = cls_dict["__slots__"]
+        except KeyError:
+            raise AttributeError(
+                "__slots__ must be defined as an instance of SlotFields "
+                "in order to generate a slotclass"
+            )
 
         if not isinstance(cls_slots, SlotFields):
             raise TypeError(
@@ -445,9 +665,7 @@ def make_slot_gatherer(field_type=Field):
 
         # Don't want to mutate original annotations so make a copy if it exists
         # Looking at the dict is a Python3.9 or earlier requirement
-        cls_annotations = {
-            **cls.__dict__.get("__annotations__", {})
-        }
+        cls_annotations = get_ns_annotations(cls_dict)
 
         cls_fields = {}
         slot_replacement = {}
@@ -484,43 +702,10 @@ def make_slot_gatherer(field_type=Field):
     return field_slot_gatherer
 
 
-slot_gatherer = make_slot_gatherer()
-
-
-# Annotation gathering tools
-def is_classvar(hint):
-    _typing = sys.modules.get("typing")
-
-    if _typing:
-        # Annotated is a nightmare I'm never waking up from
-        # 3.8 and 3.9 need Annotated from typing_extensions
-        # 3.8 also needs get_origin from typing_extensions
-        if sys.version_info < (3, 10):
-            _typing_extensions = sys.modules.get("typing_extensions")
-            if _typing_extensions:
-                _Annotated = _typing_extensions.Annotated
-                _get_origin = _typing_extensions.get_origin
-            else:
-                _Annotated, _get_origin = None, None
-        else:
-            _Annotated = _typing.Annotated
-            _get_origin = _typing.get_origin
-
-        if _Annotated and _get_origin(hint) is _Annotated:
-            hint = getattr(hint, "__origin__", None)
-
-        if (
-            hint is _typing.ClassVar
-            or getattr(hint, "__origin__", None) is _typing.ClassVar
-        ):
-            return True
-        # String used as annotation
-        elif isinstance(hint, str) and "ClassVar" in hint:
-            return True
-    return False
-
-
-def make_annotation_gatherer(field_type=Field, leave_default_values=True):
+def make_annotation_gatherer(
+    field_type=Field,
+    leave_default_values=True,
+):
     """
     Create a new annotation gatherer that will work with `Field` instances
     of the creators definition.
@@ -530,35 +715,51 @@ def make_annotation_gatherer(field_type=Field, leave_default_values=True):
                                  default values in place as class variables.
     :return: An annotation gatherer with these settings.
     """
-    def field_annotation_gatherer(cls):
-        cls_annotations = cls.__dict__.get("__annotations__", {})
+    def field_annotation_gatherer(cls_or_ns):
+        if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+            cls_dict = cls_or_ns
+        else:
+            cls_dict = cls_or_ns.__dict__
 
         cls_fields: dict[str, field_type] = {}
-
         modifications = {}
 
+        cls_annotations = get_ns_annotations(cls_dict)
+
+        kw_flag = False
+
         for k, v in cls_annotations.items():
             # Ignore ClassVar
             if is_classvar(v):
                 continue
 
-            attrib = getattr(cls, k, NOTHING)
+            if v is KW_ONLY:
+                if kw_flag:
+                    raise SyntaxError("KW_ONLY sentinel may only appear once.")
+                kw_flag = True
+                continue
+
+            attrib = cls_dict.get(k, NOTHING)
 
             if attrib is not NOTHING:
                 if isinstance(attrib, field_type):
-                    attrib = field_type.from_field(attrib, type=v)
+                    kw_only = attrib.kw_only or kw_flag
+
+                    attrib = field_type.from_field(attrib, type=v, kw_only=kw_only)
+
                     if attrib.default is not NOTHING and leave_default_values:
                         modifications[k] = attrib.default
                     else:
                         # NOTHING sentinel indicates a value should be removed
                         modifications[k] = NOTHING
-                else:
-                    attrib = field_type(default=attrib, type=v)
+                elif not isinstance(attrib, _MemberDescriptorType):
+                    attrib = field_type(default=attrib, type=v, kw_only=kw_flag)
                     if not leave_default_values:
                         modifications[k] = NOTHING
-
+                else:
+                    attrib = field_type(type=v, kw_only=kw_flag)
             else:
-                attrib = field_type(type=v)
+                attrib = field_type(type=v, kw_only=kw_flag)
 
             cls_fields[k] = attrib
 
@@ -567,8 +768,106 @@ def make_annotation_gatherer(field_type=Field, leave_default_values=True):
     return field_annotation_gatherer
 
 
+def make_field_gatherer(
+    field_type=Field,
+    leave_default_values=True,
+):
+    def field_attribute_gatherer(cls_or_ns):
+        if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+            cls_dict = cls_or_ns
+        else:
+            cls_dict = cls_or_ns.__dict__
+
+        cls_attributes = {
+            k: v
+            for k, v in cls_dict.items()
+            if isinstance(v, field_type)
+        }
+        cls_annotations = get_ns_annotations(cls_dict)
+
+        cls_modifications = {}
+
+        for name in cls_attributes.keys():
+            attrib = cls_attributes[name]
+            if leave_default_values:
+                cls_modifications[name] = attrib.default
+            else:
+                cls_modifications[name] = NOTHING
+
+            if (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
+                cls_attributes[name] = field_type.from_field(attrib, type=anno)
+
+        return cls_attributes, cls_modifications
+    return field_attribute_gatherer
+
+
+def make_unified_gatherer(
+    field_type=Field,
+    leave_default_values=True,
+):
+    """
+    Create a gatherer that will work via first slots, then
+    Field(...) class attributes and finally annotations if
+    no unannotated Field(...) attributes are present.
+
+    :param field_type: The field class to use for gathering
+    :param leave_default_values: leave default values in place
+    :return: gatherer function
+    """
+    slot_g = make_slot_gatherer(field_type)
+    anno_g = make_annotation_gatherer(field_type, leave_default_values)
+    attrib_g = make_field_gatherer(field_type, leave_default_values)
+
+    def field_unified_gatherer(cls_or_ns):
+        if isinstance(cls_or_ns, (_MappingProxyType, dict)):
+            cls_dict = cls_or_ns
+        else:
+            cls_dict = cls_or_ns.__dict__
+
+        cls_slots = cls_dict.get("__slots__")
+
+        if isinstance(cls_slots, SlotFields):
+            return slot_g(cls_dict)
+
+        # To choose between annotation and attribute gatherers
+        # compare sets of names.
+        # Don't bother evaluating string annotations, as we only need names
+        cls_annotations = get_ns_annotations(cls_dict, eval_str=False)
+        cls_attributes = {
+            k: v for k, v in cls_dict.items() if isinstance(v, field_type)
+        }
+
+        cls_annotation_names = cls_annotations.keys()
+        cls_attribute_names = cls_attributes.keys()
+
+        if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
+            # All `Field` values have annotations, so use annotation gatherer
+            return anno_g(cls_dict)
+
+        return attrib_g(cls_dict)
+    return field_unified_gatherer
+
+
+slot_gatherer = make_slot_gatherer()
 annotation_gatherer = make_annotation_gatherer()
 
+# The unified gatherer used for slot classes must remove default
+# values for slots to work correctly.
+unified_gatherer = make_unified_gatherer(leave_default_values=False)
+
+
+# Now the gatherers have been defined, add __repr__ and __eq__ to Field.
+_field_methods = {repr_maker, eq_maker}
+if _UNDER_TESTING:
+    _field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
+
+builder(
+    Field,
+    gatherer=slot_gatherer,
+    methods=_field_methods,
+    flags={"slotted": True, "kw_only": True},
+)
+
 
 def check_argument_order(cls):
     """
@@ -580,6 +879,9 @@ def check_argument_order(cls):
     fields = get_fields(cls)
     used_default = False
     for k, v in fields.items():
+        if v.kw_only or (not v.init):
+            continue
+
         if v.default is NOTHING and v.default_factory is NOTHING:
             if used_default:
                 raise SyntaxError(
@@ -611,51 +913,33 @@ def slotclass(cls=None, /, *, methods=default_methods, syntax_check=True):
     return cls
 
 
-def annotationclass(cls=None, /, *, methods=default_methods):
-    if not cls:
-        return lambda cls_: annotationclass(cls_, methods=methods)
-
-    cls = builder(cls, gatherer=annotation_gatherer, methods=methods, flags={"slotted": False})
-
-    check_argument_order(cls)
-
-    return cls
+class AnnotationClass(metaclass=SlotMakerMeta):
+    __slots__ = {}
 
+    def __init_subclass__(
+            cls,
+            methods=default_methods,
+            gatherer=make_unified_gatherer(leave_default_values=True),
+            **kwargs
+    ):
+        # Check class dict otherwise this will always be True as this base
+        # class uses slots.
+        slots = "__slots__" in cls.__dict__
 
-_field_init_desc = MethodMaker(
-    funcname="__init__",
-    code_generator=get_init_generator(
-        null=_NothingType(),
-        extra_code=["self.validate_field()"],
-    )
-)
+        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
+        check_argument_order(cls)
+        super().__init_subclass__(**kwargs)
 
 
-def fieldclass(cls=None, /, *, frozen=False):
+@slotclass
+class GatheredFields:
     """
-    This is a special decorator for making Field subclasses using __slots__.
-    This works by forcing the __init__ method to treat NOTHING as a regular
-    value. This means *all* instance attributes always have defaults.
-
-    :param cls: Field subclass
-    :param frozen: Make the field class a frozen class.
-                   Field classes are always frozen when running under `pytest`
-    :return: Modified subclass
+    A helper gatherer for fields that have been gathered externally.
     """
-    if not cls:
-        return lambda cls_: fieldclass(cls_, frozen=frozen)
-
-    field_methods = {_field_init_desc, repr_maker, eq_maker}
-
-    # Always freeze when running tests
-    if frozen or _UNDER_TESTING:
-        field_methods.update({frozen_setattr_maker, frozen_delattr_maker})
-
-    cls = builder(
-        cls,
-        gatherer=slot_gatherer,
-        methods=field_methods,
-        flags={"slotted": True, "kw_only": True}
+    __slots__ = SlotFields(
+        fields=Field(),
+        modifications=Field(),
     )
 
-    return cls
+    def __call__(self, cls):
+        return self.fields, self.modifications