ducktools-classbuilder 0.8.0__tar.gz → 0.8.2__tar.gz

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/MANIFEST.in

@@ -5,5 +5,6 @@ graft docs
 prune */build
 prune */dist
 prune */.pytest_cache
+prune perf
 
 global-exclude *~ *.py[cod] *.so

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/PKG-INFO

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.0
+Version: 0.8.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: MIT License
-        
-        Copyright (c) 2024 David C Ellis
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/docs/extension_examples.md

@@ -116,6 +116,25 @@ You could also choose to yield tuples of `name, value` pairs in your implementat
 
 ### Extending Field ###
 
+The `Field` class can also be extended as if it is a slotclass, with annotations or
+with `Field` declarations.
+
+One notable caveat - if you want to use a `default_factory` in extending `Field` you
+need to declare `default=FIELD_NOTHING` also in order for default to be ignored. This
+is a special case for `Field` and is not needed in general.
+
+```python
+from ducktools.classbuilder import Field, FIELD_NOTHING
+
+class MetadataField(Field):
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
+```
+
+In regular classes the `__init__` function generator considers `NOTHING` to be an 
+ignored value, but for `Field` subclasses it is a valid value so `FIELD_NOTHING` is
+the ignored term. This is all because `None` *is* a valid value and can't be used
+as a sentinel for Fields (otherwise `Field(default=None)` couldn't work).
+
 #### Positional Only Arguments? ####
 
 This is possible, but a little longer as we also need to modify multiple methods

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/docs/index.md

@@ -77,11 +77,11 @@ is created.
 
 ```python
 from ducktools.classbuilder import (
-    SlotMakerMeta, 
-    annotation_gatherer,
+    SlotMakerMeta,
     builder,
     check_argument_order,
     default_methods,
+    unified_gatherer,
 )
 
 
@@ -91,7 +91,7 @@ class AnnotationClass(metaclass=SlotMakerMeta):
     def __init_subclass__(
             cls,
             methods=default_methods,
-            gatherer=annotation_gatherer,
+            gatherer=unified_gatherer,
             **kwargs
     ):
         # Check class dict otherwise this will always be True as this base
@@ -103,12 +103,11 @@ class AnnotationClass(metaclass=SlotMakerMeta):
         super().__init_subclass__(**kwargs)
 
 
-
 class AnnotatedDC(AnnotationClass):
     the_answer: int = 42
     the_question: str = "What do you get if you multiply six by nine?"
 
-    
+
 ex = AnnotatedDC()
 print(ex)
 ```

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/pyproject.toml

@@ -25,7 +25,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dynamic = ['version']
-license = {file = "LICENSE.md"}
 
 [project.optional-dependencies]
 testing = ["pytest>=8.2", "pytest-cov", "typing_extensions"]

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools/classbuilder/__init__.py

@@ -99,11 +99,16 @@ def _get_inst_fields(inst):
 # As 'None' can be a meaningful value we need a sentinel value
 # to use to show no value has been provided.
 class _NothingType:
+    def __init__(self, custom=None):
+        self.custom = custom
     def __repr__(self):
+        if self.custom:
+            return f"<{self.custom} NOTHING OBJECT>"
         return "<NOTHING OBJECT>"
 
 
 NOTHING = _NothingType()
+FIELD_NOTHING = _NothingType("FIELD")
 
 
 # KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
@@ -432,11 +437,11 @@ 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
+# Special `__init__` maker for 'Field' subclasses - needs its own NOTHING option
 _field_init_maker = MethodMaker(
     funcname="__init__",
     code_generator=get_init_generator(
-        null=_NothingType(),
+        null=FIELD_NOTHING,
         extra_code=["self.validate_field()"],
     )
 )
@@ -649,7 +654,7 @@ class Field(metaclass=SlotMakerMeta):
 
     def validate_field(self):
         cls_name = self.__class__.__name__
-        if self.default is not NOTHING and self.default_factory is not NOTHING:
+        if type(self.default) is not _NothingType and type(self.default_factory) is not _NothingType:
             raise AttributeError(
                 f"{cls_name} cannot define both a default value and a default factory."
             )
@@ -807,6 +812,7 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type=Field,
     leave_default_values=False,
+    assign_types=True,
 ):
     def field_attribute_gatherer(cls_or_ns):
         if isinstance(cls_or_ns, (_MappingProxyType, dict)):
@@ -819,7 +825,11 @@ def make_field_gatherer(
             for k, v in cls_dict.items()
             if isinstance(v, field_type)
         }
-        cls_annotations = get_ns_annotations(cls_dict)
+
+        if assign_types:
+            cls_annotations = get_ns_annotations(cls_dict)
+        else:
+            cls_annotations = {}
 
         cls_modifications = {}
 
@@ -830,7 +840,7 @@ def make_field_gatherer(
             else:
                 cls_modifications[name] = NOTHING
 
-            if (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
+            if assign_types and (anno := cls_annotations.get(name, NOTHING)) is not NOTHING:
                 cls_attributes[name] = field_type.from_field(attrib, type=anno)
 
         return cls_attributes, cls_modifications

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools/classbuilder/__init__.pyi

@@ -24,8 +24,10 @@ def get_methods(cls: type) -> types.MappingProxyType[str, MethodMaker]: ...
 def _get_inst_fields(inst: typing.Any) -> dict[str, typing.Any]: ...
 
 class _NothingType:
+    def __init__(self, custom: str | None = ...) -> None: ...
     def __repr__(self) -> str: ...
 NOTHING: _NothingType
+FIELD_NOTHING: _NothingType
 
 # noinspection PyPep8Naming
 class _KW_ONLY_TYPE:
@@ -191,6 +193,7 @@ def make_annotation_gatherer(
 def make_field_gatherer(
     field_type: type[_FieldType],
     leave_default_values: bool = False,
+    assign_types: bool = True,
 ) -> Callable[[type | _CopiableMappings], tuple[dict[str, _FieldType], dict[str, typing.Any]]]: ...
 
 @typing.overload

ducktools_classbuilder-0.8.2/src/ducktools/classbuilder/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.8.2"
+__version_tuple__ = (0, 8, 2)

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools/classbuilder/annotations.py

@@ -22,6 +22,44 @@
 import sys
 
 
+class _LazyAnnotationLib:
+    def __init__(self):
+        if sys.version_info < (3, 14):
+            self.annotationlib_unavailable = True
+        else:
+            self.annotationlib_unavailable = None
+
+    def __getattr__(self, item):
+        if self.annotationlib_unavailable:
+            raise ImportError("'annotationlib' is not available")
+
+        try:
+            import annotationlib
+        except ImportError:
+            self.annotationlib_unavailable = True
+            raise ImportError("'annotationlib' is not available")
+        else:
+            self.Format = annotationlib.Format
+            self.call_annotate_function = annotationlib.call_annotate_function
+
+            # This function keeps getting changed and renamed
+            get_ns_annotate = getattr(annotationlib, "get_annotate_from_class_namespace", None)
+            if get_ns_annotate is None:
+                get_ns_annotate = getattr(annotationlib, "get_annotate_function")
+            self.get_ns_annotate = get_ns_annotate
+
+            if item == "Format":
+                return self.Format
+            elif item == "call_annotate_function":
+                return self.call_annotate_function
+            elif item == "get_ns_annotate":
+                return get_ns_annotate
+
+        raise AttributeError(f"{item!r} is not available from this lazy importer")
+
+_lazy_annotationlib = _LazyAnnotationLib()
+
+
 def get_ns_annotations(ns):
     """
     Given a class namespace, attempt to retrieve the
@@ -35,19 +73,18 @@ def get_ns_annotations(ns):
     if annotations is not None:
         annotations = annotations.copy()
     else:
-        # See if we're using PEP-649 annotations
-        # Guarding this with a try/except instead of a version check
-        # In case there's a change and PEP-649 somehow doesn't make 3.14
         try:
-            from annotationlib import Format, call_annotate_function, get_annotate_function
-        except ImportError:
-            pass
-        else:
-            annotate = ns.get("__annotate__")  # Works in the alphas, but may break
+            # See if we're using PEP-649 annotations
+            annotate = ns.get("__annotate__")  # Works in the early alphas
             if not annotate:
-                annotate = get_annotate_function(ns)
+                annotate = _lazy_annotationlib.get_ns_annotate(ns)
             if annotate:
-                annotations = call_annotate_function(annotate, format=Format.FORWARDREF)
+                annotations = _lazy_annotationlib.call_annotate_function(
+                    annotate,
+                    format=_lazy_annotationlib.Format.FORWARDREF
+                )
+        except ImportError:
+            pass
 
     if annotations is None:
         annotations = {}

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools/classbuilder/prefab.py

@@ -26,7 +26,7 @@ A 'prebuilt' implementation of class generation.
 Includes pre and post init functions along with other methods.
 """
 from . import (
-    INTERNALS_DICT, NOTHING,
+    INTERNALS_DICT, NOTHING, FIELD_NOTHING,
     Field, MethodMaker, GatheredFields, GeneratedCode, SlotMakerMeta,
     builder, get_flags, get_fields,
     make_unified_gatherer,
@@ -289,10 +289,12 @@ class Attribute(Field):
     :param kw_only: Make this argument keyword only in init
     :param serialize: Include this attribute in methods that serialize to dict
     :param doc: Parameter documentation for slotted classes
+    :param metadata: Additional non-construction related metadata
     :param type: Type of this attribute (for slotted classes)
     """
     iter: bool = True
     serialize: bool = True
+    metadata: dict = Field(default=FIELD_NOTHING, default_factory=dict)
 
 
 # noinspection PyShadowingBuiltins
@@ -309,6 +311,7 @@ def attribute(
     exclude_field=False,
     private=False,
     doc=None,
+    metadata=None,
     type=NOTHING,
 ):
     """
@@ -326,6 +329,7 @@ def attribute(
     :param exclude_field: Shorthand for setting repr, compare, iter and serialize to False
     :param private: Short for init, repr, compare, iter, serialize = False, must have default or factory
     :param doc: Parameter documentation for slotted classes
+    :param metadata: Dictionary for additional non-construction metadata
     :param type: Type of this attribute (for slotted classes)
 
     :return: Attribute generated with these parameters.
@@ -356,6 +360,7 @@ def attribute(
         serialize=serialize,
         doc=doc,
         type=type,
+        metadata=metadata,
     )
 
 

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools/classbuilder/prefab.pyi

@@ -50,6 +50,7 @@ class Attribute(Field):
 
     iter: bool
     serialize: bool
+    metadata: dict
 
     def __init__(
         self,
@@ -64,6 +65,7 @@ class Attribute(Field):
         iter: bool = True,
         kw_only: bool = False,
         serialize: bool = True,
+        metadata: dict | None = None,
     ) -> None: ...
 
     def __repr__(self) -> str: ...
@@ -74,8 +76,6 @@ def attribute(
     *,
     default: typing.Any | _NothingType = NOTHING,
     default_factory: typing.Any | _NothingType = NOTHING,
-    type: type | _NothingType = NOTHING,
-    doc: str | None = None,
     init: bool = True,
     repr: bool = True,
     compare: bool = True,
@@ -84,6 +84,9 @@ def attribute(
     serialize: bool = True,
     exclude_field: bool = False,
     private: bool = False,
+    doc: str | None = None,
+    metadata: dict | None = None,
+    type: type | _NothingType = NOTHING,
 ) -> Attribute: ...
 
 def prefab_gatherer(cls_or_ns: type | MappingProxyType) -> tuple[dict[str, Attribute], dict[str, typing.Any]]: ...

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools_classbuilder.egg-info/PKG-INFO

@@ -1,30 +1,8 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.8.0
+Version: 0.8.2
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
-License: MIT License
-        
-        Copyright (c) 2024 David C Ellis
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        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.
-        
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-classbuilder
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.8
@@ -37,7 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
+License-File: LICENSE
 Provides-Extra: testing
 Requires-Dist: pytest>=8.2; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"

{ducktools_classbuilder-0.8.0 → ducktools_classbuilder-0.8.2}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 .gitignore
 .readthedocs.yaml
-LICENSE.md
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
@@ -29,10 +29,6 @@ docs_code/docs_ex8_converters.py
 docs_code/docs_ex9_annotated.py
 docs_code/index_example.py
 docs_code/tutorial_code.py
-perf/cluegen.py
-perf/dataklasses.py
-perf/hyperfine_testmaker.py
-perf/perf_profile.py
 src/ducktools/classbuilder/__init__.py
 src/ducktools/classbuilder/__init__.pyi
 src/ducktools/classbuilder/_version.py

ducktools_classbuilder-0.8.0/perf/cluegen.py

@@ -1,127 +0,0 @@
-# cluegen.py
-#
-# Classes generated from type clues.
-#
-#     https://github.com/dabeaz/cluegen
-#
-# Author: David Beazley (@dabeaz).
-#         http://www.dabeaz.com
-#
-# Copyright (C) 2018-2021.
-#
-# Permission is granted to use, copy, and modify this code in any
-# manner as long as this copyright message and disclaimer remain in
-# the source code.  There is no warranty.  Try to use the code for the
-# greater good.
-
-import types
-
-
-# Collect all type clues from a class and base classes.
-def all_clues(cls):
-    clues = {}
-    for c in reversed(cls.__mro__):
-        clues.update(getattr(c, '__annotations__', {}))
-    return clues
-
-
-# Decorator to define methods of a class as a code generator.
-def cluegen(func):
-    def __get__(self, instance, cls):
-        locs = {}
-        code = func(cls)
-        exec(code, locs)
-        meth = locs[func.__name__]
-        setattr(cls, func.__name__, meth)
-        return meth.__get__(instance, cls)
-
-    def __set_name__(self, cls, name):
-        methods = cls.__dict__.get('_methods', list(cls._methods))
-        if '_methods' not in cls.__dict__:
-            cls._methods = methods
-        cls._methods.append((name, self))
-
-    return type(f'ClueGen_{func.__name__}', (), dict(__get__=__get__,
-                                                     __set_name__=__set_name__))()
-
-
-# Base class for defining data structures
-class DatumBase:
-    __slots__ = ()
-    _methods = []
-
-    @classmethod
-    def __init_subclass__(cls):
-        submethods = []
-        for name, val in cls._methods:
-            if name not in cls.__dict__:
-                setattr(cls, name, val)
-                submethods.append((name, val))
-            elif val is cls.__dict__[name]:
-                submethods.append((name, val))
-
-        if submethods != cls._methods:
-            cls._methods = submethods
-
-
-class Datum(DatumBase):
-    __slots__ = ()
-
-    @classmethod
-    def __init_subclass__(cls):
-        super().__init_subclass__()
-        cls.__match_args__ = tuple(all_clues(cls))
-
-    @cluegen
-    def __init__(cls):
-        clues = all_clues(cls)
-        args = ', '.join(f'{name}={getattr(cls, name)!r}'
-                         if hasattr(cls, name) and not isinstance(getattr(cls, name),
-                                                                  types.MemberDescriptorType) else name
-                         for name in clues)
-        body = '\n'.join(f'   self.{name} = {name}'
-                         for name in clues)
-        return f'def __init__(self, {args}):\n{body}\n'
-
-    @cluegen
-    def __repr__(cls):
-        clues = all_clues(cls)
-        fmt = ', '.join('%s={self.%s!r}' % (name, name) for name in clues)
-        return 'def __repr__(self):\n' \
-               '    return f"{type(self).__name__}(%s)"' % fmt
-
-    @cluegen
-    def __iter__(cls):
-        clues = all_clues(cls)
-        values = '\n'.join(f'   yield self.{name}' for name in clues)
-        return 'def __iter__(self):\n' + values
-
-    @cluegen
-    def __eq__(cls):
-        clues = all_clues(cls)
-        selfvals = ','.join(f'self.{name}' for name in clues)
-        othervals = ','.join(f'other.{name}' for name in clues)
-        return 'def __eq__(self, other):\n' \
-               '    if self.__class__ is other.__class__:\n' \
-               f'        return ({selfvals},) == ({othervals},)\n' \
-               '    else:\n' \
-               '        return NotImplemented\n'
-
-    @cluegen
-    def __hash__(cls):
-        clues = all_clues(cls)
-        if clues:
-            self_tuple = '(' + ','.join(f'self.{name}' for name in clues) + ',)'
-        else:
-            self_tuple = '()'
-        return 'def __hash__(self):\n' \
-               f'    return hash({self_tuple})\n'
-
-
-# Example use
-if __name__ == '__main__':
-    # Start defining classes
-    class Coordinates(Datum):
-        x: int
-        y: int
-

ducktools_classbuilder-0.8.0/perf/dataklasses.py

@@ -1,102 +0,0 @@
-# dataklasses.py
-#
-#     https://github.com/dabeaz/dataklasses
-#
-# Author: David Beazley (@dabeaz).
-#         http://www.dabeaz.com
-#
-# Copyright (C) 2021-2022.
-#
-# Permission is granted to use, copy, and modify this code in any
-# manner as long as this copyright message and disclaimer remain in
-# the source code.  There is no warranty.  Try to use the code for the
-# greater good.
-
-__all__ = ['dataklass']
-
-from functools import lru_cache, reduce
-
-
-def codegen(func):
-    @lru_cache
-    def make_func_code(numfields):
-        names = [f'_{n}' for n in range(numfields)]
-        exec(func(names), globals(), d := {})
-        return d.popitem()[1]
-
-    return make_func_code
-
-
-def patch_args_and_attributes(func, fields, start=0):
-    return type(func)(func.__code__.replace(
-        co_names=(*func.__code__.co_names[:start], *fields),
-        co_varnames=('self', *fields),
-    ), func.__globals__)
-
-
-def patch_attributes(func, fields, start=0):
-    return type(func)(func.__code__.replace(
-        co_names=(*func.__code__.co_names[:start], *fields)
-    ), func.__globals__)
-
-
-def all_hints(cls):
-    return reduce(lambda x, y: getattr(y, '__annotations__', {}) | x, cls.__mro__, {})
-
-
-@codegen
-def make__init__(fields):
-    code = 'def __init__(self, ' + ','.join(fields) + '):\n'
-    return code + '\n'.join(f' self.{name} = {name}\n' for name in fields)
-
-
-@codegen
-def make__repr__(fields):
-    return 'def __repr__(self):\n' \
-           ' return f"{type(self).__name__}(' + \
-           ', '.join('{self.' + name + '!r}' for name in fields) + ')"\n'
-
-
-@codegen
-def make__eq__(fields):
-    selfvals = ','.join(f'self.{name}' for name in fields)
-    othervals = ','.join(f'other.{name}' for name in fields)
-    return 'def __eq__(self, other):\n' \
-           '  if self.__class__ is other.__class__:\n' \
-           f'    return ({selfvals},) == ({othervals},)\n' \
-           '  else:\n' \
-           '    return NotImplemented\n'
-
-
-@codegen
-def make__iter__(fields):
-    return 'def __iter__(self):\n' + '\n'.join(f'   yield self.{name}' for name in fields)
-
-
-@codegen
-def make__hash__(fields):
-    self_tuple = '(' + ','.join(f'self.{name}' for name in fields) + ',)'
-    return 'def __hash__(self):\n' \
-           f'    return hash({self_tuple})\n'
-
-
-def dataklass(cls):
-    fields = all_hints(cls)
-    nfields = len(fields)
-    clsdict = vars(cls)
-    if not '__init__' in clsdict: cls.__init__ = patch_args_and_attributes(make__init__(nfields), fields)
-    if not '__repr__' in clsdict: cls.__repr__ = patch_attributes(make__repr__(nfields), fields, 2)
-    if not '__eq__' in clsdict: cls.__eq__ = patch_attributes(make__eq__(nfields), fields, 1)
-    # if not '__iter__' in clsdict:  cls.__iter__ = patch_attributes(make__iter__(nfields), fields)
-    # if not '__hash__' in clsdict:  cls.__hash__ = patch_attributes(make__hash__(nfields), fields, 1)
-    cls.__match_args__ = tuple(fields)
-    return cls
-
-
-# Example use
-if __name__ == '__main__':
-    @dataklass
-    class Coordinates:
-        x: int
-        y: int
-