Merge pull request #29 from davidhozic/develop

Develop

Author: davidhozic

docs/source/changelog.rst

@@ -24,6 +24,12 @@ Glossary
 Releases
 ---------------------
 
+v1.3.0
+================
+- The types will now have their subscripted type displayed alongside them.
+- Custom repr display of structured objects via
+  :py:meth:`tkclasswiz.convert.ObjectInfo.register_repr` method.
+
 v1.2.3
 ================
 - Fixed annotations not getting obtained for function definitions.

docs/source/guide/customrepr.rst

@@ -0,0 +1,97 @@
+============================
+Custom object display (repr)
+============================
+
+The default way of displaying objects is as follows: ``ClassName(param1=..., param2=..., param3=..., ...)``.
+This printout / repr can b overridden with the use of :py:meth:`tkclasswiz.convert.ObjectInfo.register_repr` method.
+
+
+.. automethod:: tkclasswiz.convert.ObjectInfo.register_repr
+    :no-index:
+
+
+For example, let's say I want to define some logical operators and want them to be displayed differently.
+The example shows how a custom repr display can be made. It may look a bit much, but the only thing that matters
+is the emphasized :py:meth:`~tkclasswiz.convert.ObjectInfo.register_repr` method call.
+Inside the call, a lambda function is provided. The lambda accepts
+the :class:`~tkclasswiz.convert.ObjectInfo` object and outputs a string.
+That string is made up of the name of a logical operator and the operants in the following format:
+``<op1> <operator name> <op2> <operator name> <op3> ...``. If the operator's name is ``or_op``, it will be displayed
+as ``<op1> or <op2> or <op3> ...``. If the operator's name is ``and_op``, it will be displayed as 
+``<op1> and <op2> and <op3> ...``.
+
+
+.. image:: ./images/object_info_custom_repr.png
+    :width: 20cm
+
+
+.. code-block:: python
+    :linenos:
+    :emphasize-lines: 38-45
+
+    from typing import List
+    from abc import ABC, abstractmethod
+
+    import tkinter as tk
+    import tkinter.ttk as ttk
+    import tkclasswiz as wiz
+
+    class base_op(ABC):
+        @abstractmethod
+        def evaluate(self):
+            pass
+
+    class bool_op(base_op):
+        def __init__(self, operants: List["base_op"]) -> None:
+            self.operants = operants
+
+    class and_op(bool_op):
+        def evaluate(self):
+            return all(op.evaluate() for op in self.operants)
+
+    class or_op(bool_op):
+        def evaluate(self):
+            return any(op.evaluate() for op in self.operants)
+
+    class contains(base_op):
+        def __init__(self, op: str) -> None:
+            pass
+
+        def evaluate(self):
+            # For demonstration purposes. Otherwise, we would usually check if op is contained within string
+            return True
+
+    class MyLogicResult:
+        def __init__(self, expression: base_op) -> None:
+            self.expression = expression
+
+
+    wiz.ObjectInfo.register_repr(
+        bool_op,
+        lambda oi: "(" +
+                f' {oi.class_.__name__.removesuffix("_op")} '
+                .join(map(repr, oi.data["operants"])) +
+                ")",
+        True
+    )
+
+    # Tkinter main window
+    root = tk.Tk("Test")
+
+    # Modified tkinter Combobox that will store actual objects instead of strings
+    combo = wiz.ComboBoxObjects(root)
+    combo.pack(fill=tk.X, padx=5)
+
+    def define(old = None):
+        """
+        Function for opening a window either in new definition mode (old = None) or
+        edit mode (old != None)
+        """
+        assert old is None or isinstance(old, wiz.ObjectInfo)
+        window = wiz.ObjectEditWindow()
+        window.open_object_edit_frame(MyLogicResult, combo)
+
+    # Main GUI structure
+    ttk.Button(text="Open", command=define).pack()
+    root.mainloop()
+

docs/source/guide/defining.rst

@@ -171,6 +171,10 @@ This is how our frame looks after defining 4 ``Wheel`` objects:
 .. image:: ./images/new_define_frame_list_defined.png
   :width: 15cm
 
+
+Final definition
+=================
+
 If we click "Save", we go back to our ``Car`` definition frame, that has all the parameters defined.
 Clicking on "Save" once again will save the ``Car`` object to our original GUI Combobox.
 

docs/source/guide/images/object_info_custom_repr.png

@@ -15,5 +15,6 @@ Index:
     conversion
     polymorphism
     abstractclasses
+    customrepr
     aliasing
     generics

docs/source/guide/index.rst

@@ -1,9 +1,32 @@
 """
 TkClassWizard - Library for graphically defining objects based on class annotations.
 Works with Tkinter / TTKBootstrap.
-"""
 
-__version__ = "1.2.3"
+-------------------
+
+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.3.0"
 
 from .object_frame import *
 from .annotations import *

tkclasswiz/__init__.py

@@ -1,8 +1,8 @@
 """
 Modules contains definitions related to GUI object transformations.
 """
-
-from typing import Any, Union, List, Generic, TypeVar, Mapping, Optional
+from __future__ import annotations
+from typing import Any, Union, List, Generic, TypeVar, Mapping, Optional, Callable
 from contextlib import suppress
 from inspect import signature
 from enum import Enum
@@ -125,6 +125,7 @@ class ObjectInfo(Generic[TClass]):
         recognition.
     """
     CHARACTER_LIMIT = 150
+    custom_display_map: dict[type, Callable] = {}
 
     def __init__(
         self,
@@ -158,23 +159,31 @@ def __repr__(self) -> str:
         if self._repr is not None:
             return self._repr
 
+        repr_get = ObjectInfo.custom_display_map.get(self.class_, self._repr_default)
+        _ret = repr_get(self)
+
+        self._repr = _ret
+        return _ret
+    
+    @staticmethod
+    def _repr_default(object_info: ObjectInfo) -> str:
         _ret: List[str] = []
-        if self.nickname:
-            _ret += f"({self.nickname}) "
+        if object_info.nickname:
+            _ret += f"({object_info.nickname}) "
 
-        name = get_aliased_name(self.class_)
+        name = get_aliased_name(object_info.class_)
         if name is not None:
-            name += f'({self.class_.__name__})'
+            name += f'({object_info.class_.__name__})'
         else:
-            name = self.class_.__name__
+            name = object_info.class_.__name__
 
         _ret +=  name + "("
         private_params = set()
-        if hasattr(self.class_, "__passwords__"):
-            private_params = private_params.union(self.class_.__passwords__)
+        if hasattr(object_info.class_, "__passwords__"):
+            private_params = private_params.union(object_info.class_.__passwords__)
 
-        for k, v in self.data.items():
-            if len(_ret) > self.CHARACTER_LIMIT:
+        for k, v in object_info.data.items():
+            if len(_ret) > object_info.CHARACTER_LIMIT:
                 break
 
             if isinstance(v, str):
@@ -189,12 +198,34 @@ def __repr__(self) -> str:
 
         _ret: str = ''.join(_ret)
         _ret = _ret.rstrip(", ") + ")"
-        if len(_ret) > self.CHARACTER_LIMIT:
-            _ret = _ret[:self.CHARACTER_LIMIT] + "...)"
+        if len(_ret) > object_info.CHARACTER_LIMIT:
+            _ret = _ret[:object_info.CHARACTER_LIMIT] + "...)"
 
-        self._repr = _ret
         return _ret
 
+    @classmethod
+    def register_repr(cls, class_: type, repr: Callable[[ObjectInfo], str], inherited: bool = False):
+        """
+        Registers a custom __repr__ (string representation of object) function.
+        The function must as a single parameter accept the ``ObjectInfo`` instance
+        being represented as a string.
+
+        Parameters
+        ------------
+        class_: type
+            The class for which this custom ``repr`` is being register.
+        repr: Callable[[ObjectInfo], str]
+            The function that will provide custom ``__repr__``.
+            As a parameter it accepts the ``ObjectInfo`` object.
+            It returns a :class:`str` (string).
+        inherited: bool
+            Boolean flag. Setting it to True will register repr for inherited members as well.
+            Defaults to False.
+        """
+        cls.custom_display_map[class_] = repr
+        if inherited:
+            for type_ in class_.__subclasses__():
+                cls.register_repr(type_, repr, True)
 
 @cache_result(max=1024)
 @doc_category("Conversion")

tkclasswiz/convert.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)