ducktools-classbuilder 0.7.4__py3-none-any.whl → 0.8.0__py3-none-any.whl

ducktools/classbuilder/__init__.py

@@ -769,7 +769,7 @@ def make_annotation_gatherer(
             if is_classvar(v):
                 continue
 
-            if v is KW_ONLY:
+            if v is KW_ONLY or (isinstance(v, str) and v == "KW_ONLY"):
                 if kw_flag:
                     raise SyntaxError("KW_ONLY sentinel may only appear once.")
                 kw_flag = True
@@ -868,7 +868,7 @@ def make_unified_gatherer(
         # 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_annotations = get_ns_annotations(cls_dict)
         cls_attributes = {
             k: v for k, v in cls_dict.items() if isinstance(v, field_type)
         }

ducktools/classbuilder/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.7.4"
-__version_tuple__ = (0, 7, 4)
+__version__ = "0.8.0"
+__version_tuple__ = (0, 8, 0)

ducktools/classbuilder/annotations.py

@@ -19,275 +19,73 @@
 # 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.
-
 import sys
-import builtins
-
-
-# Evil stuff from types.py
-def _cell_factory():
-    a = 1
-
-    def f():
-        nonlocal a
-    return f.__closure__[0]
-_FunctionType = type(_cell_factory)
-_CellType = type(_cell_factory())
-del _cell_factory
-# End evil stuff from types.py
-
 
-class _Stringlike(str):
-    # There are typing operators that are not supported by strings
-    # This adds the 'or' operator '|'
 
-    def __or__(self, other):
-        if isinstance(other, str):
-            other_r = other
-        elif name := getattr(other, "__name__", None):
-            other_r = name
-        else:
-            other_r = str(other)
-
-        return type(self)(f"{self} | {other_r}")
-
-    def __ror__(self, other):
-        if isinstance(other, str):
-            other_r = other
-        elif name := getattr(other, "__name__", None):
-            other_r = name
-        else:
-            other_r = str(other)
-
-        return type(self)(f"{other_r} | {self}")
-
-    def __repr__(self):
-        base = super().__repr__()
-        clsname = type(self).__name__
-        return f"{clsname}({base})"
-
-
-class _StringGlobs(dict):
-    """
-    Based on the fake globals dictionary used for annotations
-    from 3.14. This allows us to evaluate containers which
-    include forward references.
-
-    It's just a dictionary that returns the key if the key
-    is not found.
-    """
-    def __missing__(self, key):
-        return _Stringlike(key)
-
-    def __repr__(self):
-        cls_name = self.__class__.__name__
-        dict_repr = super().__repr__()
-        return f"{cls_name}({dict_repr})"
-
-
-def eval_hint(hint, context=None, *, recursion_limit=2):
-    """
-    Attempt to evaluate a string type hint in the given
-    context.
-
-    If this raises an exception, return the last string.
-
-    If the recursion limit is hit or a previous value returns
-    on evaluation, return the original hint string.
-
-    Example::
-        import builtins
-        from typing import ClassVar
-
-        from ducktools.classbuilder.annotations import eval_hint
-
-        foo = "foo"
-
-        context = {**vars(builtins), **globals(), **locals()}
-        eval_hint("foo", context)  # returns 'foo'
-
-        eval_hint("ClassVar[str]", context)  # returns typing.ClassVar[str]
-        eval_hint("ClassVar[forwardref]", context)  # returns typing.ClassVar[ForwardRef('forwardref')]
-
-    :param hint: The existing type hint
-    :param context: merged context
-    :param recursion_limit: maximum number of evaluation loops before
-                            returning the original string.
-    :return: evaluated hint, or string if it could not evaluate
-    """
-    if context is not None:
-        context = _StringGlobs(context)
-
-    original_hint = hint
-
-    # Using a set would require the hint always be hashable
-    # This is only going to be 2 items at most usually
-    seen = []
-    i = 0
-    while isinstance(hint, str):
-        seen.append(hint)
-
-        # noinspection PyBroadException
-        try:
-            hint = eval(hint, context)
-        except Exception:
-            break
-
-        if hint in seen or i >= recursion_limit:
-            hint = original_hint
-            break
-
-        i += 1
-
-    return hint
-
-
-def call_annotate_func(annotate):
-    # Python 3.14 breaks the old methods of getting annotations
-    # The new annotationlib currently relies on 'ast' and 'functools'
-    # that this project tries to avoid importing.
-
-    # The basic logic is copied from there, however, replacing ForwardRef
-    # with a more basic class.
-    # While `annotationlib` is trying to return ForwardRef objects that can
-    # be evaluated later, this module only cares about annotations that can
-    # be evaluated at the point this function is called.
-    # As such we throw away the other information and just return strings
-    # instead of forwardrefs.
-
-    try:
-        raw_annotations = annotate(1)
-    except NameError:
-        pass
-    else:
-        return raw_annotations
-
-    # The annotate func may support forwardref natively
-    try:
-        raw_annotations = annotate(2)
-    except NotImplementedError:
-        pass
-    else:
-        return raw_annotations
-
-    # Not supported so we have to implement our own deferred handling
-    # Some modified logic from annotationlib
-    namespace = {**annotate.__builtins__, **annotate.__globals__}
-    globs = _StringGlobs(namespace)
-
-    # This handles closures where the variable is defined after get annotations is called.
-    if annotate.__closure__:
-        freevars = annotate.__code__.co_freevars
-        new_closure = []
-        for i, cell in enumerate(annotate.__closure__):
-            try:
-                cell.cell_contents
-            except ValueError:
-                if i < len(freevars):
-                    name = freevars[i]
-                else:
-                    name = "__cell__"
-                new_closure.append(_CellType(name))
-            else:
-                new_closure.append(cell)
-        closure = tuple(new_closure)
-    else:
-        closure = None
-
-    new_annotate = _FunctionType(annotate.__code__, globs, closure=closure)
-
-    # Convert _Stringlike back to str
-    annos = {
-        k: str(v) if isinstance(v, _Stringlike) else v
-        for k, v in new_annotate(1).items()
-    }
-
-    return annos
-
-
-def get_ns_annotations(ns, eval_str=True):
+def get_ns_annotations(ns):
     """
     Given a class namespace, attempt to retrieve the
-    annotations dictionary and evaluate strings.
-
-    Note: This only evaluates in the context of module level globals
-    and values in the class namespace. Non-local variables will not
-    be evaluated.
+    annotations dictionary.
 
     :param ns: Class namespace (eg cls.__dict__)
-    :param eval_str: Attempt to evaluate string annotations (default to True)
-    :return: dictionary of evaluated annotations
+    :return: dictionary of annotations
     """
 
-    # In 3.14 the 'canonical' method of getting annotations is to use __annotate__
-    # If this doesn't exist, check __annotations__ and treat as 3.13 or earlier.
-    annotate = ns.get("__annotate__")
-
-    if annotate is not None:
-        raw_annotations = call_annotate_func(annotate)
+    annotations = ns.get("__annotations__")
+    if annotations is not None:
+        annotations = annotations.copy()
     else:
-        raw_annotations = ns.get("__annotations__", {})
-
-    # Unlike annotationlib we still try to evaluate string annotations
-    # This will catch cases where someone has used a literal string for a
-    # single attribute.
-    if eval_str:
+        # 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:
-            obj_modulename = ns["__module__"]
-        except KeyError:
-            obj_module = None
-        else:
-            obj_module = sys.modules.get(obj_modulename, None)
-
-        if obj_module:
-            obj_globals = vars(obj_module)
+            from annotationlib import Format, call_annotate_function, get_annotate_function
+        except ImportError:
+            pass
         else:
-            obj_globals = {}
-
-        # Type parameters should be usable in hints without breaking
-        # This is for Python 3.12+
-        type_params = {
-            repr(param): param
-            for param in ns.get("__type_params__", ())
-        }
-
-        context = {**vars(builtins), **obj_globals, **type_params, **ns}
-
-        annotations = {
-            k: eval_hint(v, context)
-            for k, v in raw_annotations.items()
-        }
+            annotate = ns.get("__annotate__")  # Works in the alphas, but may break
+            if not annotate:
+                annotate = get_annotate_function(ns)
+            if annotate:
+                annotations = call_annotate_function(annotate, format=Format.FORWARDREF)
 
-    else:
-        annotations = raw_annotations.copy()
+    if annotations is None:
+        annotations = {}
 
     return annotations
 
 
 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
+    if isinstance(hint, str):
+        # String annotations, just check if the string 'ClassVar' is in there
+        # This is overly broad and could be smarter.
+        return "ClassVar" in hint
+    elif (annotationlib := sys.modules.get("annotationlib")) and isinstance(hint, annotationlib.ForwardRef):
+        return "ClassVar" in hint.__arg__
+    else:
+        _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, _get_origin = None, None
-        else:
-            _Annotated = _typing.Annotated
-            _get_origin = _typing.get_origin
+                _Annotated = _typing.Annotated
+                _get_origin = _typing.get_origin
 
-        if _Annotated and _get_origin(hint) is _Annotated:
-            hint = getattr(hint, "__origin__", None)
+            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
+            if (
+                hint is _typing.ClassVar
+                or getattr(hint, "__origin__", None) is _typing.ClassVar
+            ):
+                return True
     return False
 

ducktools/classbuilder/annotations.pyi

@@ -1,30 +1,10 @@
-from collections.abc import Callable
 import typing
 import types
 
-_T = typing.TypeVar("_T")
 _CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
 
-class _StringGlobs(dict):
-    def __missing__(self, key: _T) -> _T: ...
-
-
-def call_annotate_func(
-        annotate: Callable[[int], dict[str, type | typing.ForwardRef]]
-) -> dict[str, type | str]: ...
-
-
-def eval_hint(
-    hint: type | str,
-    context: None | dict[str, typing.Any] = None,
-    *,
-    recursion_limit: int = 2
-) -> type | str: ...
-
-
 def get_ns_annotations(
     ns: _CopiableMappings,
-    eval_str: bool = True,
 ) -> dict[str, typing.Any]: ...
 
 def is_classvar(

{ducktools_classbuilder-0.7.4.dist-info → ducktools_classbuilder-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.4
+Version: 0.8.0
 Summary: Toolkit for creating class boilerplate generators
 Author: David C Ellis
 License: MIT License
@@ -86,10 +86,12 @@ These tools are available from the main `ducktools.classbuilder` module.
 * `@slotclass`
   * A decorator based implementation that uses a special dict subclass assigned
      to `__slots__` to describe the fields for method generation.
-* `AnnotationClass`
-  * A subclass based implementation that works with `__slots__`, type annotations
-    or `Field(...)` attributes to describe the fields for method generation.
-  * If `__slots__` isn't used to declare fields, it will be generated by a metaclass.
+* `SlotMakerMeta`
+  * A metaclass for creating other implementations using annotations, fields or slots.
+  * This metaclass will allow for creating `__slots__` correctly in subclasses.
+* `builder`
+  * This is the main tool used for constructing decorators and base classes to provide
+    generated methods.
 
 Each of these forms of class generation will result in the same methods being 
 attached to the class after the field information has been obtained.
@@ -119,8 +121,9 @@ This includes more customization including `__prefab_pre_init__` and `__prefab_p
 functions for subclass customization.
 
 A `@prefab` decorator and `Prefab` base class are provided. 
-Similar to `AnnotationClass`, `Prefab` will generate `__slots__` by default.
-However decorated classes with `@prefab` that do not declare fields using `__slots__`
+
+`Prefab` will generate `__slots__` by default.
+decorated classes with `@prefab` that do not declare fields using `__slots__`
 will **not** be slotted and there is no `slots` argument to apply this.
 
 Here is an example of applying a conversion in `__post_init__`:
@@ -164,7 +167,7 @@ the fields can be set *before* the class is constructed, so the class
 will work correctly without needing to be rebuilt.
 
 For example these two classes would be roughly equivalent, except that
-`@dataclass` has had to recreate the class from scratch while `AnnotationClass`
+`@dataclass` has had to recreate the class from scratch while `Prefab`
 has created `__slots__` and added the methods on to the original class. 
 This means that any references stored to the original class *before*
 `@dataclass` has rebuilt the class will not be pointing towards the 
@@ -179,7 +182,7 @@ functions.
 ```python
 import json
 from dataclasses import dataclass
-from ducktools.classbuilder import AnnotationClass, Field
+from ducktools.classbuilder.prefab import Prefab, attribute
 
 
 class _RegisterDescriptor:
@@ -222,10 +225,10 @@ class DataCoords:
         return {"x": self.x, "y": self.y}
 
 
-# slots=True is the default for AnnotationClass
-class BuilderCoords(AnnotationClass, slots=True):
+# slots=True is the default for Prefab
+class BuilderCoords(Prefab):
     x: float = 0.0
-    y: float = Field(default=0.0, doc="y coordinate")
+    y: float = attribute(default=0.0, doc="y coordinate")
 
     @register.register_method
     def to_json(self):
@@ -289,9 +292,6 @@ It will copy values provided as the `type` to `Field` into the
 Values provided to `doc` will be placed in the final `__slots__` 
 field so they are present on the class if `help(...)` is called.
 
-`AnnotationClass` offers the same features with additional methods of gathering
-fields.
-
 If you want something with more features you can look at the `prefab`
 submodule which provides more specific features that differ further from the 
 behaviour of `dataclasses`.

ducktools_classbuilder-0.8.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+ducktools/classbuilder/__init__.py,sha256=LfPJ6WgDye3juzSovwicQpFKrEmBbl6dPmhxbVLwRaQ,32381
+ducktools/classbuilder/__init__.pyi,sha256=t2KrEsEhKFbLpl0QeX0CiCy_VTRFRZO_2ABdfndRfZY,7939
+ducktools/classbuilder/_version.py,sha256=kiXGlQhMHQWiHk12ZeZ9CjneqMQ_CbyHdpnt8oCSThg,52
+ducktools/classbuilder/annotations.py,sha256=BJRZnGbsXeoXCpXIgjfEDNVNvtoz65LH2VKZsasj_kw,3601
+ducktools/classbuilder/annotations.pyi,sha256=c5vYtULdDgMYWtkzeYMsHIbmnEuT2Ru-nNZieWvYuQ4,247
+ducktools/classbuilder/prefab.py,sha256=6YOVVYYeuMF5gv9DnK-sCvNKxBaBoqDXNLUQ22-xINk,24097
+ducktools/classbuilder/prefab.pyi,sha256=x2ioTpkhNjQXFeKABFOzE0xNeZ8f_W5vusmuAzE19mc,4491
+ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+ducktools_classbuilder-0.8.0.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
+ducktools_classbuilder-0.8.0.dist-info/METADATA,sha256=glZbRUQ85WZJvhCxWMr0tqfxFc60eGx78dkzLi6_VXQ,10887
+ducktools_classbuilder-0.8.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+ducktools_classbuilder-0.8.0.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
+ducktools_classbuilder-0.8.0.dist-info/RECORD,,

{ducktools_classbuilder-0.7.4.dist-info → ducktools_classbuilder-0.8.0.dist-info}/WHEEL

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

ducktools_classbuilder-0.7.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-ducktools/classbuilder/__init__.py,sha256=DA5ZisvBEQGK3Mx2Y_SS43ZkIOHd1WZs2JF2g9n1URs,32354
-ducktools/classbuilder/__init__.pyi,sha256=t2KrEsEhKFbLpl0QeX0CiCy_VTRFRZO_2ABdfndRfZY,7939
-ducktools/classbuilder/_version.py,sha256=Z7KmGeeyyT2ppHJrXQg4HcQhc0Y9QqZpNm00ZQT7MuY,52
-ducktools/classbuilder/annotations.py,sha256=cgFlMmEXIhBUZ3DWbPQgFVqPx56s1vR3KROaiypDroo,9174
-ducktools/classbuilder/annotations.pyi,sha256=vW3YQIiKYYQJll9_B4oTkBwIh4nOy1AnU9Ny8_a0dRY,686
-ducktools/classbuilder/prefab.py,sha256=6YOVVYYeuMF5gv9DnK-sCvNKxBaBoqDXNLUQ22-xINk,24097
-ducktools/classbuilder/prefab.pyi,sha256=x2ioTpkhNjQXFeKABFOzE0xNeZ8f_W5vusmuAzE19mc,4491
-ducktools/classbuilder/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-ducktools_classbuilder-0.7.4.dist-info/LICENSE.md,sha256=6Thz9Dbw8R4fWInl6sGl8Rj3UnKnRbDwrc6jZerpugQ,1070
-ducktools_classbuilder-0.7.4.dist-info/METADATA,sha256=ToPo40dXDorKyD_bL_pJwIZbDsiptuJJ4QpqoBdrSBc,11004
-ducktools_classbuilder-0.7.4.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-ducktools_classbuilder-0.7.4.dist-info/top_level.txt,sha256=uSDLtio3ZFqdwcsMJ2O5yhjB4Q3ytbBWbA8rJREganc,10
-ducktools_classbuilder-0.7.4.dist-info/RECORD,,