custom repr (#28)

Author: davidhozic

docs/source/changelog.rst

@@ -24,9 +24,11 @@ Glossary
 Releases
 ---------------------
 
-v1.2.4
+v1.3.0
 ================
-- Fixed typing system. (names of types)
+- 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

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,7 +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
@@ -124,6 +125,7 @@ class ObjectInfo(Generic[TClass]):
         recognition.
     """
     CHARACTER_LIMIT = 150
+    custom_display_map: dict[type, Callable] = {}
 
     def __init__(
         self,
@@ -157,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):
@@ -188,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")