Fixed typing system

Author: davidhozic

docs/source/changelog.rst

@@ -24,6 +24,11 @@ Glossary
 Releases
 ---------------------
 
+v1.2.4
+================
+- Fixed typing system. (names of types)
+
+
 v1.2.3
 ================
 - Fixed annotations not getting obtained for function definitions.

tkclasswiz/__init__.py

@@ -1,9 +1,33 @@
 """
 TkClassWizard - Library for graphically defining objects based on class annotations.
 Works with Tkinter / TTKBootstrap.
+
+-------------------
+
+MIT License
+
+Copyright (c) 2023 David Hozic
+
+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.
 """
 
-__version__ = "1.2.3"
+__version__ = "1.2.4"
 
 from .object_frame import *
 from .annotations import *

tkclasswiz/convert.py

@@ -1,7 +1,6 @@
 """
 Modules contains definitions related to GUI object transformations.
 """
-
 from typing import Any, Union, List, Generic, TypeVar, Mapping, Optional
 from contextlib import suppress
 from inspect import signature

tkclasswiz/object_frame/frame_base.py

@@ -1,7 +1,8 @@
-from typing import get_args, get_origin, Iterable, Union, Literal, Any, TYPE_CHECKING, TypeVar
-from abc import ABC
+from typing import get_args, get_origin, Iterable, Union, Literal, Any, TYPE_CHECKING, TypeVar, Generic
 from inspect import isabstract
 from contextlib import suppress
+from itertools import chain
+from functools import cache
 
 from ..convert import *
 from ..aliasing import *
@@ -92,31 +93,30 @@ def __init__(
         self.init_main_frame()
 
     @staticmethod
-    def get_cls_name(cls: T) -> Union[str, T]:
+    @cache
+    def get_cls_name(cls: Any, args: bool = False) -> str:
         """
         Returns the name of the class ``cls`` or
         the original class when the name cannot be obtained.
         If alias exists, alias is returned instead.
         """
-        name = NewObjectFrameBase._get_cls_unaliased_name(cls)
         if (alias := get_aliased_name(cls)) is not None:
             return alias + f" ({name})"
+        elif hasattr(cls, "__name__"):
+            name = cls.__name__
+        elif hasattr(cls, "_name") and cls._name:
+            name = cls._name
+        else:
+            name = str(cls)
+
+        if args and (type_args := get_args(cls)):
+            name = (
+                name + 
+                f"[{ ', '.join([NewObjectFrameBase.get_cls_name(x) for x in type_args]) }]"
+            )
 
         return name
 
-    @staticmethod
-    def _get_cls_unaliased_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
-
-        return cls
-
     @classmethod
     def set_origin_window(cls, window: "ObjectEditWindow"):
         cls.origin_window = window
@@ -143,7 +143,7 @@ def cast_type(cls, value: Any, types: Iterable):
 
             return value
 
-        for type_ in filter(lambda t: cls._get_cls_unaliased_name(t) in __builtins__, types):
+        for type_ in filter(lambda t: t.__module__ == "builtins", types):
             with suppress(Exception):
                 cast_funct = CAST_FUNTIONS.get(type_)
                 if cast_funct is None:
@@ -157,7 +157,7 @@ def cast_type(cls, value: Any, types: Iterable):
         return value
 
     @classmethod
-    def convert_types(cls, types_in):
+    def convert_types(cls, input_type: type):
         """
         Type preprocessing method, that extends the list of types with inherited members (polymorphism)
         and removes classes that are wrapped by some other class, if the wrapper class also appears in
@@ -177,33 +177,36 @@ def remove_classes(types: list):
 
             return tuple(r)
 
-        if get_origin(types_in) is Union:
-            types_in = cls.convert_types(get_args(types_in))
+        origin = get_origin(input_type)
+        # Unpack Union items into a tuple
+        if origin is Union or issubclass_noexcept(origin, Iterable):
+            new_types = dict()
+            for type_ in chain.from_iterable([cls.convert_types(r) for r in get_args(input_type)]):
+                new_types[type_] = 0  # Use dictionary's keys as OrderedSet, with dummy value 0
 
-        elif issubclass_noexcept(origin := get_origin(types_in), Iterable) and types_in is not str:
-            types_in = origin[cls.convert_types(get_args(types_in))]
+            new_types = tuple(new_types)
+            if origin is Union:
+                return new_types
 
-        if isinstance(types_in, tuple):
-            new_types = []
-            for t in types_in:
-                new_types.extend(cls.convert_types(t))
+            return (origin[new_types],)
 
-            types_in = new_types
-        else:
-            types_in = (types_in,)
+        if issubclass_noexcept(origin, Generic):
+            # Patch for Python versions < 3.10
+            input_type.__name__ = origin.__name__
 
-        # Also include inherited objects
-        subtypes = []
-        for t in types_in:
-            if cls.get_cls_name(t) in __builtins__:
-                continue  # Don't consider built-int types for polymorphism
+        if input_type.__module__ == "builtins":
+            # Don't consider built-int types for polymorphism
+            # No removal of abstract classes is needed either as builtins types aren't abstract
+            return (input_type,)
 
-            if hasattr(t, "__subclasses__"):
-                for st in t.__subclasses__():
-                    subtypes.extend(cls.convert_types(st))
+        # Extend subclasses
+        subtypes = []
+        if hasattr(input_type, "__subclasses__"):
+            for st in input_type.__subclasses__():
+                subtypes.extend(cls.convert_types(st))
 
         # Remove wrapped classes (eg. wrapped by decorator) + ABC classes
-        return remove_classes([*types_in, *subtypes])
+        return remove_classes([input_type, *subtypes])
 
     def init_main_frame(self):
         frame_main = ttk.Frame(self)

tkclasswiz/object_frame/frame_iterable.py

@@ -88,8 +88,8 @@ def __init__(
         ttk.Button(frame_up_down, text="Up", command=lambda: w.move_selection(-1)).pack(side="left", fill=tk.X, expand=True)
         ttk.Button(frame_up_down, text="Down", command=lambda: w.move_selection(1)).pack(side="left", fill=tk.X, expand=True)
 
-        for arg in get_args(self.class_):
-            menu.add_command(label=self.get_cls_name(arg), command=partial(self.new_object_frame, arg, w))
+        for arg in get_args(self.convert_types(class_)[0]):
+            menu.add_command(label=self.get_cls_name(arg, True), command=partial(self.new_object_frame, arg, w))
 
         w.pack(side="left", fill=tk.BOTH, expand=True)
 

tkclasswiz/object_frame/frame_struct.py

@@ -155,7 +155,7 @@ def fill_values(k: str, entry_types: list, menu: tk.Menu, combo: ComboBoxObjects
                     any_filled = True
                     if self.allow_save:
                         menu.add_command(
-                            label=f"New {self.get_cls_name(entry_type)}",
+                            label=f"New {self.get_cls_name(entry_type, args=True)}",
                             command=partial(self.new_object_frame, entry_type, combo)
                         )