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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.5
+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.7.5 → ducktools_classbuilder-0.8.0}/README.md

@@ -32,10 +32,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.
@@ -65,8 +67,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__`:
@@ -110,7 +113,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 
@@ -125,7 +128,7 @@ functions.
 ```python
 import json
 from dataclasses import dataclass
-from ducktools.classbuilder import AnnotationClass, Field
+from ducktools.classbuilder.prefab import Prefab, attribute
 
 
 class _RegisterDescriptor:
@@ -168,10 +171,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):
@@ -235,9 +238,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.7.5 → ducktools_classbuilder-0.8.0}/docs/api.md

@@ -40,7 +40,3 @@
 ```{eval-rst}
 .. autofunction:: ducktools.classbuilder.annotations::make_annotation_gatherer
 ```
-
-```{eval-rst}
-.. autoclass:: ducktools.classbuilder.annotations::AnnotationClass
-```

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

@@ -469,7 +469,8 @@ To implement this you need to create a new annotated_gatherer function.
 >       If you need to change the value of a field use Field.from_field(...) to make a new instance.
 
 ```python
-from __future__ import annotations
+# Don't use __future__ annotations with get_ns_annotations in this case 
+# as it doesn't evaluate string annotations.
 
 import types
 from typing import Annotated, Any, ClassVar, get_origin

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/docs/generated_code.md

@@ -7,11 +7,14 @@ There is a helper function `get_methods` that can be used to obtain the names an
 methods that have been attached to the class by the builder.
 
 ```python
-from ducktools.classbuilder import AnnotationClass, get_methods
+from ducktools.classbuilder import SlotFields, get_methods, slotclass
 
-class Example(AnnotationClass):
-    a: str = "a"
-    b: str = "b"
+@slotclass
+class Example:
+    __slots__ = SlotFields(
+        a='a',
+        b='b'
+    )
 
 print(get_methods(Example))
 ```
@@ -28,12 +31,15 @@ These can then be used to examine the generated source code and global variables
 to the `exec` function. This can be useful for debugging code generators.
 
 ```python
-from ducktools.classbuilder import AnnotationClass, get_methods
-
-class Example(AnnotationClass):
-    a: str = "a"
-    b: str = "b"
-
+from ducktools.classbuilder import SlotFields, get_methods, slotclass
+
+@slotclass
+class Example:
+    __slots__ = SlotFields(
+        a='a',
+        b='b',
+    )
+    
 methods = get_methods(Example)
 
 for method in methods.values():

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

@@ -65,15 +65,44 @@ ex = SlottedDC()
 print(ex)
 ```
 
-## Annotation Class Usage ##
+## Using Annotations ##
 
-There is an additional AnnotationClass base class that allows creating slotted classes
-using annotations. This has to be a base class with a specific metaclass in order to 
-create the `__slots__` field *before* the class has been generated in order to work
-correctly.
+It is possible to create slotted classes using Annotations.
+There is a `Prefab` base class in the `prefab` submodule that does this,
+but it also easy to implement using the provided tools.
+
+In order to correctly implement `__slots__` this needs to be done
+using a metaclass as `__slots__` must be defined before the **class**
+is created.
 
 ```python
-from ducktools.classbuilder import AnnotationClass
+from ducktools.classbuilder import (
+    SlotMakerMeta, 
+    annotation_gatherer,
+    builder,
+    check_argument_order,
+    default_methods,
+)
+
+
+class AnnotationClass(metaclass=SlotMakerMeta):
+    __slots__ = {}
+
+    def __init_subclass__(
+            cls,
+            methods=default_methods,
+            gatherer=annotation_gatherer,
+            **kwargs
+    ):
+        # Check class dict otherwise this will always be True as this base
+        # class uses slots.
+        slots = "__slots__" in cls.__dict__
+
+        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
+        check_argument_order(cls)
+        super().__init_subclass__(**kwargs)
+
+
 
 class AnnotatedDC(AnnotationClass):
     the_answer: int = 42

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/docs/tutorial.md

@@ -146,9 +146,15 @@ def report_generator(cls, funcname="report"):
 report_maker = dtbuild.MethodMaker("report", report_generator)
 ```
 
-We can take a quick look at what this generates by applying it to an `AnnotationClass`:
+We can take a quick look at what this generates by applying it to a `slotclass`:
 ```python
-class CodegenDemo(dtbuild.AnnotationClass):
+@dtbuild.slotclass
+class CodegenDemo:
+    __slots__ = dtbuild.SlotFields(
+        field_1="Field one",
+        field_2="Field two",
+        field_3="Field three",       
+    )
     field_1: str = "Field one"
     field_2: str = "Field two"
     field_3: str = "Field three"

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/docs_code/docs_ex9_annotated.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import types
 from typing import Annotated, Any, ClassVar, get_origin
 

ducktools_classbuilder-0.8.0/docs_code/index_example.py

@@ -0,0 +1,34 @@
+from ducktools.classbuilder import (
+    SlotMakerMeta,
+    builder,
+    check_argument_order,
+    default_methods,
+    unified_gatherer,
+)
+
+
+class AnnotationClass(metaclass=SlotMakerMeta):
+    __slots__ = {}
+
+    def __init_subclass__(
+            cls,
+            methods=default_methods,
+            gatherer=unified_gatherer,
+            **kwargs
+    ):
+        # Check class dict otherwise this will always be True as this base
+        # class uses slots.
+        slots = "__slots__" in cls.__dict__
+
+        builder(cls, gatherer=gatherer, methods=methods, flags={"slotted": slots})
+        check_argument_order(cls)
+        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.7.5 → ducktools_classbuilder-0.8.0}/docs_code/tutorial_code.py

@@ -81,10 +81,13 @@ report_maker = dtbuild.MethodMaker("report", report_generator)
 
 
 # View the generated code by testing on a demo class
-class CodegenDemo(dtbuild.AnnotationClass):
-    field_1: str = "Field one"
-    field_2: str = "Field two"
-    field_3: str = "Field three"
+@dtbuild.slotclass
+class CodegenDemo:
+    __slots__ = dtbuild.SlotFields(
+        field_1="Field one",
+        field_2="Field two",
+        field_3="Field three",
+    )
 
 
 print(report_generator(CodegenDemo).source_code)

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/src/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-0.8.0/src/ducktools/classbuilder/_version.py

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

ducktools_classbuilder-0.8.0/src/ducktools/classbuilder/annotations.py

@@ -0,0 +1,91 @@
+# 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.
+import sys
+
+
+def get_ns_annotations(ns):
+    """
+    Given a class namespace, attempt to retrieve the
+    annotations dictionary.
+
+    :param ns: Class namespace (eg cls.__dict__)
+    :return: dictionary of annotations
+    """
+
+    annotations = ns.get("__annotations__")
+    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
+            if not annotate:
+                annotate = get_annotate_function(ns)
+            if annotate:
+                annotations = call_annotate_function(annotate, format=Format.FORWARDREF)
+
+    if annotations is None:
+        annotations = {}
+
+    return annotations
+
+
+def is_classvar(hint):
+    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 = _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
+    return False
+

ducktools_classbuilder-0.8.0/src/ducktools/classbuilder/annotations.pyi

@@ -0,0 +1,12 @@
+import typing
+import types
+
+_CopiableMappings = dict[str, typing.Any] | types.MappingProxyType[str, typing.Any]
+
+def get_ns_annotations(
+    ns: _CopiableMappings,
+) -> dict[str, typing.Any]: ...
+
+def is_classvar(
+    hint: object,
+) -> bool: ...

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-classbuilder
-Version: 0.7.5
+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.7.5 → ducktools_classbuilder-0.8.0}/src/ducktools_classbuilder.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ docs_code/docs_ex5_frozen.py
 docs_code/docs_ex7_posonly.py
 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

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/tests/annotations/test_annotated.py

@@ -139,6 +139,6 @@ def test_annotationclass():
 def test_annotated_syntax_error():
     with pytest.raises(SyntaxError):
         class ExampleAnnotated(AnnotationClass):
-            a: str = "a"
+            a: str = "a"  # noqa: the error being highlighted is the error we are testing.
             b: "list[str]"
             c: Annotated[str, ""] = Field(default="c")

ducktools_classbuilder-0.8.0/tests/annotations/test_annotations_module.py

@@ -0,0 +1,58 @@
+import builtins
+
+from ducktools.classbuilder.annotations import (
+    get_ns_annotations,
+    is_classvar,
+)
+from typing import List, ClassVar
+from typing_extensions import Annotated
+
+
+def test_ns_annotations():
+    CV = ClassVar
+
+    class AnnotatedClass:
+        a: str
+        b: "str"
+        c: List[str]
+        d: "List[str]"
+        e: ClassVar[str]
+        f: "ClassVar[str]"
+        g: "ClassVar[forwardref]"
+        h: "Annotated[ClassVar[str], '']"
+        i: "Annotated[ClassVar[forwardref], '']"
+        j: "CV[str]"
+
+    annos = get_ns_annotations(vars(AnnotatedClass))
+
+    assert annos == {
+        'a': str,
+        'b': "str",
+        'c': List[str],
+        'd': "List[str]",
+        'e': ClassVar[str],
+        'f': "ClassVar[str]",
+        'g': "ClassVar[forwardref]",
+        'h': "Annotated[ClassVar[str], '']",
+        'i': "Annotated[ClassVar[forwardref], '']",
+        'j': "CV[str]",
+    }
+
+
+def test_is_classvar():
+    assert is_classvar(ClassVar)
+    assert is_classvar(ClassVar[str])
+    assert is_classvar(ClassVar['forwardref'])
+
+    assert is_classvar(Annotated[ClassVar[str], ''])
+    assert is_classvar(Annotated[ClassVar['forwardref'], ''])
+
+    assert is_classvar("ClassVar")
+    assert is_classvar("ClassVar[str]")
+    assert is_classvar("ClassVar['forwardref']")
+
+    assert is_classvar("Annotated[ClassVar[str], '']")
+    assert is_classvar("Annotated[ClassVar['forwardref'], '']")
+
+    assert not is_classvar(str)
+    assert not is_classvar(Annotated[str, ''])

{ducktools_classbuilder-0.7.5 → ducktools_classbuilder-0.8.0}/tests/annotations/test_future_annotations.py

@@ -14,7 +14,7 @@ def test_bare_forwardref():
 
     annos = get_ns_annotations(Ex.__dict__)
 
-    assert annos == {'a': str, 'b': Path, 'c': "plain_forwardref"}
+    assert annos == {'a': "str", 'b': "Path", 'c': "plain_forwardref"}
 
 
 def test_inner_outer_ref():
@@ -37,9 +37,23 @@ def test_inner_outer_ref():
     cls, annos = make_func()
 
     # Only global types can be evaluated
-    assert annos == {"a_val": "inner_type", "b_val": int, "c_val": "hyper_type"}
+    assert annos == {"a_val": "inner_type", "b_val": "global_type", "c_val": "hyper_type"}
 
     # No extra evaluation
     assert get_ns_annotations(cls.__dict__) == {
-        "a_val": "inner_type", "b_val": int, "c_val": "hyper_type"
+        "a_val": "inner_type", "b_val": "global_type", "c_val": "hyper_type"
     }
+
+
+def test_not_evaluated():
+    class EvalCheck:
+        def __class_getitem__(cls, item):
+            raise KeyError("This should not be raised")
+        def __getattr__(self, key):
+            raise AttributeError("This should also not be raised")
+
+    class DontEval:
+        a: EvalCheck['str']  # The test is that the exception does not occur as this is not evaluated
+        b: EvalCheck.missing_attribute
+
+    get_ns_annotations(DontEval.__dict__)