Fix generic stuff

Author: davidhozic

tkclasswiz/object_frame/frame_base.py

@@ -101,19 +101,20 @@ def get_cls_name(cls: Any, args: bool = False) -> str:
         the original class when the name cannot be obtained.
         If alias exists, alias is returned instead.
         """
-        if (alias := get_aliased_name(cls)) is not None:
+        normal_cls = get_origin(cls) or cls
+        if (alias := get_aliased_name(normal_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
+        elif hasattr(normal_cls, "__name__"):
+            name = normal_cls.__name__
+        elif hasattr(normal_cls, "_name") and normal_cls._name:
+            name = normal_cls._name
         else:
-            name = str(cls)
+            name = str(normal_cls)
 
         if args and (type_args := get_args(cls)):
             name = (
                 name + 
-                f"[{ ', '.join([NewObjectFrameBase.get_cls_name(x) for x in type_args]) }]"
+                f"[{ ', '.join([NewObjectFrameBase.get_cls_name(x, True) for x in type_args]) }]"
             )
 
         return name
@@ -209,21 +210,29 @@ def remove_classes(types: list):
             )
 
         origin = get_origin(input_type)
+        if issubclass_noexcept(origin, Generic):
+            # Patch for Python versions < 3.10
+            input_type.__name__ = origin.__name__
+
         # Unpack Union items into a tuple
-        if origin is Union or issubclass_noexcept(origin, Iterable):
-            new_types = dict()
+        if origin is Union or issubclass_noexcept(origin, (Iterable, Generic)):
+            new_types = []
             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
+                new_types.append(type_)
 
             new_types = tuple(new_types)
             if origin is Union:
-                return new_types
+                return new_types  # Just expand unions
 
-            return (origin[new_types],)
+            # Process abstract classes and polymorphism
+            new_origins = []
+            for origin in cls.convert_types(origin):
+                if issubclass_noexcept(origin, (Generic, Iterable)):
+                    new_origins.append(origin[new_types])
+                else:
+                    new_origins.append(origin)
 
-        if issubclass_noexcept(origin, Generic):
-            # Patch for Python versions < 3.10
-            input_type.__name__ = origin.__name__
+            return tuple(new_origins)
 
         if input_type.__module__ == "builtins":
             # Don't consider built-int types for polymorphism
@@ -259,7 +268,7 @@ def modified(self) -> bool:
 
     def update_window_title(self):
         "Set's the window title according to edit context."
-        self.origin_window.title(f"{'New' if self.old_gui_data is None else 'Edit'} {self.get_cls_name(self.class_)} object")
+        self.origin_window.title(f"{'New' if self.old_gui_data is None else 'Edit'} {self.get_cls_name(self.class_, True)} object")
 
     def close_frame(self):
         if self.allow_save and self.modified:

tkclasswiz/object_frame/frame_iterable.py

@@ -68,7 +68,6 @@ def __init__(
         allow_save = True
     ):
         dpi_5 = dpi_scaled(5)
-
         super().__init__(class_, return_widget, parent, old_data, check_parameters, allow_save)
         self.storage_widget = w = ListBoxScrolled(self.frame_main, height=20)
         ListboxTooltip(self.storage_widget, 0)
@@ -127,7 +126,7 @@ def _create_add_menu(self, args: list, menu: tk.Menu):
             elif get_origin(arg) is Literal:
                 insert_items.append(...)
                 insert_items.extend(get_args(arg))
-            elif isclass(arg) or isfunction(arg):
+            else:
                 menu.add_command(
                     label=f"New {self.get_cls_name(arg, True)}",
                     command=partial(self.new_object_frame, arg, widget)
@@ -157,8 +156,8 @@ def to_object(self):
             if isinstance(d, str) and str not in self._list_args:
                 self.check_literals(d, self.filter_literals(self._list_args))
 
-        return data
-    
+        return get_origin(self.class_)(data)
+
     def _edit_selected(self):
         selection = self.storage_widget.curselection()
         if len(selection) == 1:

tkclasswiz/object_frame/frame_struct.py

@@ -139,8 +139,8 @@ def load_template():
 
         self._create_fields(annotations, additional_values, self.frame_main)
         if annotations_depr:
-            ttk.Separator(self.frame_main).pack(fill=tk.X)
-            ttk.Label(self.frame_main, text="Deprecated").pack(anchor=tk.W)
+            ttk.Separator(self.frame_main).pack(fill=tk.X, pady=dpi_5)
+            ttk.Label(self.frame_main, text="Deprecated", font=("TkDefaultFont", 10)).pack(anchor=tk.W)
             self._create_fields(annotations_depr, additional_values, self.frame_main)
 
         if old_data is not None:  # Edit
@@ -297,12 +297,13 @@ def to_object(self, *, ignore_checks = False) -> ObjectInfo:
 
             map_[attr] = value
 
+        class_ = get_origin(self.class_) or self.class_
         nickname = self.entry_nick.get() or None
-        object_ = ObjectInfo(self.class_, map_, nickname)  # Abstraction of the underlaying object
+        object_ = ObjectInfo(class_, map_, nickname)  # Abstraction of the underlying object
         if (
             not ignore_checks and
             self.check_parameters and
-            (inspect.isclass(self.class_) or inspect.isclass(get_origin(self.class_)))  # Only check objects
+            (inspect.isclass(class_))  # Only check objects
         ):
             # Cache the object created for faster
             _convert_to_objects_cached(object_)  # Tries to create instances to check for errors
@@ -334,20 +335,18 @@ def _edit_selected(self, key: str, combo: ComboBoxObjects):
         if isinstance(selection, str):
             selection = self.cast_type(selection, self._map[key][1])
 
-        if isinstance(selection, list):
-            types = self.convert_types(get_annotations(self.class_)[key])
-            for type_ in types:
-                if get_origin(type_) in {list, tuple, set, Iterable, ABCIterable}:
-                    list_type = type_
-                    break
-            else:
-                list_type = None
-
-            return self.new_object_frame(list_type, combo, old_data=selection)
         if isinstance(selection, ObjectInfo):
             return self.new_object_frame(selection.class_, combo, old_data=selection)
         else:
-            return self.new_object_frame(type(selection), combo, old_data=selection)
+            type_sel = type(selection)
+            for t in self.convert_types(get_annotations(self.class_)[key]):
+                if (get_origin(t) or t) == type_sel:
+                    type_ = t
+                    break
+            else:
+                type_ = None
+
+            return self.new_object_frame(type_, combo, old_data=selection)
 
 
 class NewObjectFrameStructView(NewObjectFrameStruct):