Generic type classes (#18)

* Generic typing

* simplify

* docs

Author: davidhozic

docs/source/changelog.rst

@@ -24,6 +24,9 @@ Glossary
 Releases
 ---------------------
 
+v1.2
+================
+- Generic types support (Parametric types)
 
 v1.1.1
 ================

docs/source/guide/generics.rst

@@ -0,0 +1,78 @@
+=========================
+Generic types (classes)
+=========================
+
+A generic type in Python is a class, that inherits the :class:`typing.Generic` class.
+It can be used to define arbitrary type parameters, which can be given a value using a subscription operator ``[]``.
+
+Arbitrary types / type variables can be created using the :class:`typing.TypeVar` class.
+
+.. note::
+    
+    Since Python 3.12, the :class:`typing.TypeVar` no longer requires manual definition
+    and can be omitted.
+
+
+.. code-block:: python
+    :linenos:
+
+    from typing import Generic, TypeVar
+
+
+    T = TypeVar('T')  # From Python 3.12 forward this is optional
+
+    class MyClass(Generic[T]):
+        def __init__(self, a: int, b: T):
+            ...
+
+
+    my_instance1: MyClass[float] = MyClass(5, 5.5)
+    my_instance2: MyClass[str] = MyClass(5, "Some text")
+    my_instance3: MyClass[int] = MyClass(5, 0)
+
+
+In the above example, the ``T`` is a type variable. It is also a type parameter inside ``MyClass``.
+When instances are created, the variables are annotated with a type subscription (e. g., ``MyClass[int]``).
+
+While Python itself doesn't care about the types given in the subscription, and just ignores incorrect types,
+TkClassWizard resolves these subscripted types into the ``__init__`` function of a class, allowing the definition
+of arbitrary types with the use of type generics.
+
+If we take the above example and pop it into TkClassWizard with ``MyClass`` having a :class:`float` annotation,
+we would get the following types in the ``New <type>`` options:
+
+.. image:: ./images/new_define_frame_struct_generics.png
+    :width: 15cm
+
+
+.. code-block:: python
+    :caption: Generic type, given :class:`float` as type parameter
+    :linenos:
+    :emphasize-lines: 21
+
+    from typing import Generic, TypeVar
+
+    import tkclasswiz as wiz
+    import tkinter as tk
+    import tkinter.ttk as ttk
+
+    T = TypeVar('T')  # From Python 3.12 forward this is optional
+
+    class MyClass(Generic[T]):
+        def __init__(self, a: int, b: T):
+            ...
+
+    root = tk.Tk("Test")
+
+    combo = wiz.ComboBoxObjects(root)
+    combo.pack(fill=tk.X, padx=5)
+
+    def open():
+        window = wiz.ObjectEditWindow()  # The object definition window / wizard
+        window.open_object_edit_frame(
+            MyClass[float],
+            combo
+        )  # Open the actual frame
+
+    ttk.Button(text="Define", command=open).pack()
+    root.mainloop()

docs/source/guide/images/new_define_frame_struct_generics.png

@@ -14,4 +14,5 @@ Index:
     annotations
     conversion
     polymorphism
-    abstractclasses
+    abstractclasses
+    generics

docs/source/guide/index.rst

@@ -2,7 +2,7 @@
 Module used for managing annotations.
 """
 from datetime import datetime, timedelta, timezone
-from typing import Union, Optional
+from typing import Union, Optional, get_args, Generic, get_origin
 from contextlib import suppress
 from inspect import isclass
 from .doc import doc_category
@@ -88,13 +88,25 @@ def get_annotations(class_) -> dict:
     """
     Returns class / function annotations including the ones extended with ``register_annotations``.
     It does not return the return annotation.
+
+    Additionally, this function resolves any generic types to their parameterized types, but
+    only for classes, functions don't support this yet as support for generics on functions was added
+    in Python 3.12.
     """
     annotations = {}
     with suppress(AttributeError):
         if isclass(class_):
-            annotations = class_.__init__.__annotations__
+            annotations = class_.__init__.__annotations__.copy()
+        elif isclass(origin_class := get_origin(class_)) and issubclass(origin_class, Generic):
+            # Resolve generics
+            annotations = origin_class.__init__.__annotations__.copy()
+            generic_types = get_args(origin_class.__orig_bases__[0])
+            generic_values = get_args(class_)
+            generic_name_value = {generic_types[i]: generic_values[i] for i in range(len(generic_types))}
+            for k, v in annotations.items():
+                annotations[k] = generic_name_value.get(v, v)
         else:
-            annotations = class_.__annotations__
+            annotations = class_.__annotations__.copy()
 
     additional_annotations = ADDITIONAL_ANNOTATIONS.get(class_, {})
     annotations = {**annotations, **additional_annotations}

tkclasswiz/annotations.py

@@ -96,10 +96,10 @@ def get_cls_name(cls: T) -> Union[str, T]:
         Returns the name of the class ``cls`` or
         the original class when the name cannot be obtained.
         """
-        if hasattr(cls, "_name"):
-            return cls._name
         if hasattr(cls, "__name__"):
             return cls.__name__
+        if hasattr(cls, "_name"):
+            return cls._name
         else:
             return cls
 

tkclasswiz/object_frame/frame_base.py

@@ -245,7 +245,11 @@ def to_object(self, *, ignore_checks = False) -> ObjectInfo:
             map_[attr] = value
 
         object_ = ObjectInfo(self.class_, map_)  # Abstraction of the underlaying object
-        if not ignore_checks and self.check_parameters and inspect.isclass(self.class_):  # Only check objects
+        if (
+            not ignore_checks and
+            self.check_parameters and
+            (inspect.isclass(self.class_) or inspect.isclass(get_origin(self.class_)))  # Only check objects
+        ):
             # Cache the object created for faster
             _convert_to_objects_cached(object_)  # Tries to create instances to check for errors