osbot-utils 1.93.0__tar.gz → 1.95.0__tar.gz

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.93.0
+Version: 1.95.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.93.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.95.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/README.md

@@ -2,7 +2,7 @@
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.93.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.95.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/base_classes/Type_Safe.py

@@ -3,7 +3,8 @@
 
 import sys
 import types
-from osbot_utils.utils.Objects import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
+from osbot_utils.utils.Objects import default_value                     # todo: remove test mocking requirement for this to be here (instead of on the respective method)
+from osbot_utils.utils.Objects import all_annotations
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -89,7 +90,8 @@ class Type_Safe:
         from osbot_utils.utils.Objects                          import value_type_matches_obj_annotation_for_union_and_annotated
         from osbot_utils.helpers.type_safe.Type_Safe__Validator import Type_Safe__Validator
 
-        if not hasattr(self, '__annotations__'):                    # can't do type safety checks if the class does not have annotations
+        annotations = all_annotations(self)
+        if not annotations:                                             # can't do type safety checks if the class does not have annotations
             return super().__setattr__(name, value)
 
         if value is not None:
@@ -101,20 +103,20 @@ class Type_Safe:
                 origin = get_origin(value)
                 if origin is not None:
                     value = origin
-            check_1 = value_type_matches_obj_annotation_for_attr      (self, name, value)
+            check_1 = value_type_matches_obj_annotation_for_attr              (self, name, value)
             check_2 = value_type_matches_obj_annotation_for_union_and_annotated(self, name, value)
             if (check_1 is False and check_2 is None  or
                 check_1 is None  and check_2 is False or
                 check_1 is False and check_2 is False   ):          # fix for type safety assigment on Union vars
-                raise ValueError(f"Invalid type for attribute '{name}'. Expected '{self.__annotations__.get(name)}' but got '{type(value)}'")
+                raise ValueError(f"Invalid type for attribute '{name}'. Expected '{annotations.get(name)}' but got '{type(value)}'")
         else:
-            if hasattr(self, name) and self.__annotations__.get(name) :     # don't allow previously set variables to be set to None
+            if hasattr(self, name) and annotations.get(name) :     # don't allow previously set variables to be set to None
                 if getattr(self, name) is not None:                         # unless it is already set to None
                     raise ValueError(f"Can't set None, to a variable that is already set. Invalid type for attribute '{name}'. Expected '{self.__annotations__.get(name)}' but got '{type(value)}'")
 
         # todo: refactor this to separate method
-        if hasattr(self.__annotations__, 'get'):
-            annotation = self.__annotations__.get(name)
+        if hasattr(annotations, 'get'):
+            annotation = annotations.get(name)
             if annotation and get_origin(annotation) is Annotated:
                 annotation_args = get_args(annotation)
                 target_type = annotation_args[0]

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/base_classes/Type_Safe__Dict.py

@@ -19,4 +19,4 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
     def __repr__(self):
         key_type_name   = type_str(self.expected_key_type)
         value_type_name = type_str(self.expected_value_type)
-        return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"
+        return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/helpers/Guid.py

@@ -11,7 +11,7 @@ class Guid(str):
         if is_guid(value):
             guid = value
         else:
-            guid = uuid.uuid5(GUID__NAMESPACE, value)                                       # Generate a UUID5 using the namespace and value
+            guid = uuid.uuid5(GUID__NAMESPACE, value)                                   # Generate a UUID5 using the namespace and value
         return super().__new__(cls, str(guid))                                          # Return a new instance of Guid initialized with the string version of the UUID
 
     def __str__(self):

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/helpers/trace/Trace_Call__Handler.py

@@ -12,6 +12,7 @@ GLOBAL_FUNCTIONS_TO_IGNORE   = ['value_type_matches_obj_annotation_for_attr'
                                 'value_type_matches_obj_annotation_for_union_and_annotated' ,            # todo: map out and document why exactly these methods are ignore (and what is the side effect)
                                 'are_types_compatible_for_assigment'                        ,
                                 'obj_attribute_annotation'                                  ,
+                                'all_annotations'                                           ,
                                 'get_origin'                                                ,
                                 'getmro'                                                    ,
                                 'default_value'                                             ,

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/utils/Objects.py

@@ -1,6 +1,8 @@
 # todo add tests
 import sys
-from types                              import SimpleNamespace
+from types                                               import SimpleNamespace
+from osbot_utils.helpers.python_compatibility.python_3_8 import Annotated
+
 
 class __(SimpleNamespace):
     pass
@@ -439,29 +441,38 @@ def pickle_load_from_bytes(pickled_data: bytes):
         except Exception:
             return {}
 
+def all_annotations(target):
+    annotations = {}
+    if hasattr(target.__class__, '__mro__'):
+        for base in reversed(target.__class__.__mro__):
+            if hasattr(base, '__annotations__'):
+                annotations.update(base.__annotations__)
+    return annotations
+
 def value_type_matches_obj_annotation_for_attr(target, attr_name, value):
     import typing
-
-    if hasattr(target, '__annotations__'):
-        obj_annotations  = target.__annotations__
-        if hasattr(obj_annotations,'get'):
-            attr_type        = obj_annotations.get(attr_name)
-            if attr_type:
-                origin_attr_type = get_origin(attr_type)                # to handle when type definion contains an generic
-                if origin_attr_type is typing.Union:
-                    args = get_args(attr_type)
-                    if len(args)==2 and args[1] is type(None):          # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (which is an shorthand for Union[X, None] )
-                        attr_type = args[0]
-                        origin_attr_type = get_origin(attr_type)
-
-                if origin_attr_type:
-                    attr_type = origin_attr_type
-                value_type = type(value)
-                if are_types_compatible_for_assigment(source_type=value_type, target_type=attr_type):
-                    return True
-                if are_types_magic_mock(source_type=value_type, target_type=attr_type):
-                    return True
-                return value_type is attr_type
+    annotations = all_annotations(target)
+    attr_type   = annotations.get(attr_name)
+    if attr_type:
+        origin_attr_type = get_origin(attr_type)                # to handle when type definition contains a generic
+        if origin_attr_type is Annotated:                # if the type is Annotated
+            args             = get_args(attr_type)
+            origin_attr_type = args[0]
+
+        elif origin_attr_type is typing.Union:
+            args = get_args(attr_type)
+            if len(args)==2 and args[1] is type(None):          # todo: find a better way to do this, since this is handling an edge case when origin_attr_type is Optional (which is an shorthand for Union[X, None] )
+                attr_type = args[0]
+                origin_attr_type = get_origin(attr_type)
+
+        if origin_attr_type:
+            attr_type = origin_attr_type
+        value_type = type(value)
+        if are_types_compatible_for_assigment(source_type=value_type, target_type=attr_type):
+            return True
+        if are_types_magic_mock(source_type=value_type, target_type=attr_type):
+            return True
+        return value_type is attr_type
     return None
 
 

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/osbot_utils/utils/Str.py

@@ -9,17 +9,17 @@ REGEX__ANSI_ESCAPE_PATTERN = re.compile(r'\x1b\[[0-9;]*m')
 REGEX__SAFE_ID_REGEX       = re.compile(r'[^a-zA-Z0-9_-]')
 
 def ansi_text_visible_length(ansi_text):
-    if type(ansi_text) is str:
+    if isinstance(ansi_text, str):
         ansi_escape = re.compile(REGEX__ANSI_ESCAPE_PATTERN)           # This regex matches the escape sequences used for text formatting
         visible_text = ansi_escape.sub('', ansi_text)       # Remove the escape sequences
         return len(visible_text)                                # Return the length of the remaining text
 
 def ansi_to_text(ansi_text: str):
-    if type(ansi_text) is str:
+    if isinstance(ansi_text, str):
         return REGEX__ANSI_ESCAPE_PATTERN.sub('', ansi_text)
 
 def ansis_to_texts(ansis_texts: list):                          # todo: find a better name for this method :)
-    if type(ansis_texts) is list:
+    if isinstance(ansis_texts, list):
         return [ansi_to_text(ansi_text) for ansi_text in ansis_texts]
     return []
 
@@ -98,7 +98,7 @@ def str_cap_snake_case(snake_str):
 
 
 def trim(target):
-    if type(target) is str:
+    if isinstance(target, str):
         return target.strip()
     return ""
 

osbot_utils-1.95.0/osbot_utils/version

@@ -0,0 +1 @@
+v1.95.0

{osbot_utils-1.93.0 → osbot_utils-1.95.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v1.93.0"
+version     = "v1.95.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/Mermaid.py

@@ -1,75 +0,0 @@
-from osbot_utils.graphs.mermaid.Mermaid__Renderer                   import Mermaid__Renderer
-from osbot_utils.graphs.mermaid.Mermaid__Edge                       import Mermaid__Edge
-from osbot_utils.graphs.mermaid.Mermaid__Graph                      import Mermaid__Graph
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram_Direction   import Diagram__Direction
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram__Type       import Diagram__Type
-from osbot_utils.utils.Python_Logger                                import Python_Logger
-from osbot_utils.base_classes.Kwargs_To_Self                        import Kwargs_To_Self
-
-class Mermaid(Kwargs_To_Self):
-    graph             : Mermaid__Graph
-    renderer          : Mermaid__Renderer
-    logger            : Python_Logger
-
-    # todo add support for storing the data in sqlite so that the search for existing nodes is efficient
-    def add_edge(self, from_node_key, to_node_key, label=None,attributes=None):
-        nodes_by_id = self.graph.data().nodes__by_key()
-        from_node   = nodes_by_id.get(from_node_key)
-        to_node     = nodes_by_id.get(to_node_key)
-        if not from_node:
-            from_node = self.add_node(key=from_node_key)
-        if not to_node:
-            to_node = self.add_node(key=to_node_key)
-
-        # todo: add back the protection/detection that we get from MGraph class of allow_circle_edges and allow_duplicate_edges
-        mermaid_edge = Mermaid__Edge(from_node=from_node, to_node=to_node, label=label, attributes=attributes)
-        self.graph.edges.append(mermaid_edge)
-        return mermaid_edge
-
-    def add_directive(self, directive):
-        self.renderer.config.directives.append(directive)
-        return self
-
-    def add_node(self, **kwargs):
-        return self.graph.add_node(**kwargs)
-
-    def code(self):
-        return self.renderer.code(self.nodes(), self.edges())
-
-    def code_markdown(self):
-        #self.code_create()
-        self.code()
-        rendered_lines = self.renderer.mermaid_code
-        markdown = ['#### Mermaid Graph',
-                    "```mermaid"        ,
-                    *rendered_lines     ,
-                    "```"               ]
-
-        return '\n'.join(markdown)
-
-    def edges(self):
-        return self.graph.edges
-
-    def print_code(self):
-        print(self.code())
-
-    def nodes(self):
-        return self.graph.nodes
-
-    def set_direction(self, direction):
-        if isinstance(direction, Diagram__Direction):
-            self.renderer.diagram_direction = direction
-        elif isinstance(direction, str) and direction in Diagram__Direction.__members__:
-            self.renderer.diagram_direction = Diagram__Direction[direction]
-        return self                             # If the value can't be set (not a valid name), do nothing
-
-    def set_diagram_type(self, diagram_type):
-        if isinstance(diagram_type, Diagram__Type):
-            self.renderer.diagram_type = diagram_type
-
-    def save(self, target_file=None):
-        file_path = target_file or '/tmp/mermaid.md'
-
-        with open(file_path, 'w') as file:
-            file.write(self.code_markdown())
-        return file_path

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/Mermaid__Edge.py

@@ -1,49 +0,0 @@
-from osbot_utils.graphs.mermaid.Mermaid__Node import LINE_PADDING, Mermaid__Node
-from osbot_utils.graphs.mermaid.configs.Mermaid__Edge__Config import Mermaid__Edge__Config
-from osbot_utils.graphs.mgraph.MGraph__Edge import MGraph__Edge
-#from osbot_utils.graphs.mgraph.views.mermaid.Mermaid__Node import Mermaid__Node
-from osbot_utils.utils.Str import safe_str
-
-
-class Mermaid__Edge(MGraph__Edge):
-    config    : Mermaid__Edge__Config
-    from_node : Mermaid__Node
-    to_node   : Mermaid__Node
-
-    # def __init__(self, **kwargs):
-    #     super().__init__(**kwargs)
-
-    # def __init__(self, **kwargs):
-    #     super().__init__(**kwargs)
-    #     self.convert_nodes()
-    #
-    def edge_mode(self, edge_mode):
-        self.config.edge_mode = edge_mode
-        return self
-
-    def edge_mode__lr_using_pipe(self):
-        return self.edge_mode('lr_using_pipe')
-
-    def output_node_from(self, value=True):
-        self.config.output_node_from = value
-        return self
-
-    def output_node_to(self, value=True):
-        self.config.output_node_to = value
-        return self
-
-    def render_edge(self):
-        from_node_key = safe_str(self.from_node.key)
-        to_node_key   = safe_str(self.to_node  .key)
-        if self.config.output_node_from:
-            from_node_key =  self.from_node.render_node(include_padding=False) #f'{edge.from_node.key}["{edge.from_node.label}"]'
-        if self.config.output_node_to:
-            to_node_key   = self.to_node.render_node(include_padding=False   ) #f'{edge.to_node  .key}["{edge.to_node  .label}"]'
-        if self.config.edge_mode == 'lr_using_pipe':
-            link_code      = f'-->|{self.label}|'
-        elif self.label:
-            link_code      = f'--"{self.label}"-->'
-        else:
-            link_code      = '-->'
-        edge_code      = f'{LINE_PADDING}{from_node_key} {link_code} {to_node_key}'
-        return edge_code

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/Mermaid__Graph.py

@@ -1,95 +0,0 @@
-from typing import List
-
-from osbot_utils.graphs.mgraph.MGraph__Edge import MGraph__Edge
-from osbot_utils.graphs.mgraph.MGraph__Node import MGraph__Node
-from osbot_utils.graphs.mermaid.Mermaid__Edge import Mermaid__Edge
-from osbot_utils.graphs.mermaid.Mermaid__Node import Mermaid__Node
-from osbot_utils.graphs.mgraph.MGraph import MGraph
-
-
-class Mermaid__Graph(MGraph):
-    edges        : List[Mermaid__Edge]
-    mermaid_code : List
-    nodes        : List[Mermaid__Node]
-
-    # def __init__(self, mgraph=None):
-    #     super().__init__()
-    #     if mgraph is None:
-    #         mgraph = MGraph()
-    #     self.__dict__ = mgraph.__dict__
-    #     self.convert_nodes().convert_edges()
-
-    # def cast(self, source):
-    #     self.__dict__ = source.__dict__
-    #     return self
-
-    # def add_edge(self, **kwargs):
-    #     #new_edge = super().add_edge(*args, **kwargs)
-    #     mermaid_edge = Mermaid__Edge(**kwargs)
-    #     self.edges.append(mermaid_edge)
-    #     return mermaid_edge
-    #
-    def add_node(self, **kwargs):
-        new_node    = MGraph__Node(**kwargs)
-        mermaid_node = Mermaid__Node().merge_with(new_node)
-        self.nodes.append(mermaid_node)
-        return mermaid_node
-
-    #
-    #
-    # def add_line(self, line):
-    #     self.mermaid_code.append(line)
-    #     return line
-    #
-    # def code(self):
-    #     self.code_create()
-    #     return '\n'.join(self.mermaid_code)
-    #
-    # def code_create(self):
-    #     with self as _:
-    #         _.reset_code()
-    #         _.add_line('graph LR')
-    #         for node in _.nodes:
-    #             _.add_line(node.code())
-    #         _.add_line('')
-    #         for edge in _.edges:
-    #             _.add_line(edge.code())
-    #     return self
-    #
-    # def code_markdown(self):
-    #     self.code_create()
-    #     markdown = ['# Mermaid Graph',
-    #                 "```mermaid" ,
-    #                 *self.mermaid_code,
-    #                 "```"]
-    #
-    #     return '\n'.join(markdown)
-    #
-    # def convert_edges(self):
-    #     new_edges = []
-    #     for edge in self.edges:
-    #         new_edges.append(Mermaid__Edge().cast(edge))
-    #     self.edges = new_edges
-    #     return self
-    #
-    # def convert_nodes(self):
-    #     new_nodes = []
-    #     for node in self.nodes:
-    #         mermaid_node = Mermaid__Node().cast(node)
-    #         new_nodes.append(mermaid_node)
-    #     self.nodes = new_nodes
-    #     return self
-    #
-    # def reset_code(self):
-    #     self.mermaid_code = []
-    #     return self
-    #
-    # def save(self, target_file=None):
-    #     file_path = target_file or '/tmp/mermaid.md'
-    #
-    #     with open(file_path, 'w') as file:
-    #         file.write(self.code_markdown())
-    #     return file_path
-    #
-    # def print_code(self):
-    #     print(self.code())

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/Mermaid__Node.py

@@ -1,65 +0,0 @@
-from osbot_utils.graphs.mermaid.configs.Mermaid__Node__Config   import Mermaid__Node__Config
-from osbot_utils.graphs.mermaid.models.Mermaid__Node__Shape     import Mermaid__Node__Shape
-from osbot_utils.graphs.mgraph.MGraph__Node                     import MGraph__Node
-
-LINE_PADDING = '    '
-
-class Mermaid__Node(MGraph__Node):
-
-    config : Mermaid__Node__Config
-
-    def render_node(self, include_padding=True):
-        left_char, right_char = self.config.node_shape.value
-
-        if self.config.markdown:
-            label = f'`{self.label}`'
-        else:
-            label = self.label
-
-
-        if self.config.show_label is False:
-            node_code = f'{self.key}'
-        else:
-            if self.config.wrap_with_quotes is False:
-                node_code = f'{self.key}{left_char}{label}{right_char}'
-            else:
-                node_code = f'{self.key}{left_char}"{label}"{right_char}'
-
-        if include_padding:
-            node_code = f'{LINE_PADDING}{node_code}'
-        return node_code
-
-    def markdown(self, value=True):
-        self.config.markdown = value
-        return self
-
-    def shape(self, shape=None):
-        self.config.node_shape = Mermaid__Node__Shape.get_shape(shape)
-        return self
-
-
-    def shape_asymmetric        (self): self.config.node_shape = Mermaid__Node__Shape.asymmetric        ; return self
-    def shape_circle            (self): self.config.node_shape = Mermaid__Node__Shape.circle            ; return self
-    def shape_cylindrical       (self): self.config.node_shape = Mermaid__Node__Shape.cylindrical       ; return self
-    def shape_default           (self): self.config.node_shape = Mermaid__Node__Shape.default           ; return self
-    def shape_double_circle     (self): self.config.node_shape = Mermaid__Node__Shape.double_circle     ; return self
-    def shape_hexagon           (self): self.config.node_shape = Mermaid__Node__Shape.hexagon           ; return self
-    def shape_parallelogram     (self): self.config.node_shape = Mermaid__Node__Shape.parallelogram     ; return self
-    def shape_parallelogram_alt (self): self.config.node_shape = Mermaid__Node__Shape.parallelogram_alt ; return self
-    def shape_stadium           (self): self.config.node_shape = Mermaid__Node__Shape.stadium           ; return self
-    def shape_subroutine        (self): self.config.node_shape = Mermaid__Node__Shape.subroutine        ; return self
-    def shape_rectangle         (self): self.config.node_shape = Mermaid__Node__Shape.rectangle         ; return self
-    def shape_rhombus           (self): self.config.node_shape = Mermaid__Node__Shape.rhombus           ; return self
-    def shape_round_edges       (self): self.config.node_shape = Mermaid__Node__Shape.round_edges       ; return self
-    def shape_trapezoid         (self): self.config.node_shape = Mermaid__Node__Shape.trapezoid         ; return self
-    def shape_trapezoid_alt     (self): self.config.node_shape = Mermaid__Node__Shape.trapezoid_alt     ; return self
-
-
-
-    def wrap_with_quotes(self, value=True):
-        self.config.wrap_with_quotes = value
-        return self
-
-    def show_label(self, value=True):
-        self.config.show_label = value
-        return self

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/Mermaid__Renderer.py

@@ -1,56 +0,0 @@
-from typing import List
-
-from osbot_utils.base_classes.Kwargs_To_Self                        import Kwargs_To_Self
-from osbot_utils.graphs.mermaid.configs.Mermaid__Render__Config     import Mermaid__Render__Config
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram_Direction   import Diagram__Direction
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram__Type       import Diagram__Type
-
-
-class Mermaid__Renderer(Kwargs_To_Self):
-    config            : Mermaid__Render__Config
-    mermaid_code      : List
-    diagram_direction : Diagram__Direction = Diagram__Direction.LR
-    diagram_type      : Diagram__Type      = Diagram__Type.graph
-
-
-    def add_line(self, line):
-        self.mermaid_code.append(line)
-        return line
-
-    def code(self, nodes, edges):
-        self.code_create(nodes, edges)
-        return '\n'.join(self.mermaid_code)
-
-    def code_create(self, nodes, edges, recreate=False):
-        with self as _:
-            if recreate:                            # if recreate is True, reset the code
-                _.reset_code()
-            elif self.mermaid_code:                 # if the code has already been created, don't create it
-                return self                         #   todo: find a better way to do this, namely around the concept of auto detecting (on change) when the recreation needs to be done (vs being able to use the previously calculated data)
-            for directive in _.config.directives:
-                _.add_line(f'%%{{{directive}}}%%')
-            _.add_line(self.graph_header())
-            if self.config.add_nodes:
-                for node in nodes:
-                    node_code = node.render_node()
-                    _.add_line(node_code)
-            if self.config.line_before_edges:
-                _.add_line('')
-            for edge in edges:
-                edge_code = edge.render_edge()
-                _.add_line(edge_code)
-        return self
-
-
-
-    def graph_header(self):
-        # if type(self.diagram_type.value) is str:
-        #     value = self.diagram_type.value
-        # else:
-        #     value = self.diagram_type.name
-        value = self.diagram_type.name
-        return f'{value} {self.diagram_direction.name}'
-
-    def reset_code(self):
-        self.mermaid_code = []
-        return self

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/configs/Mermaid__Edge__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-
-class Mermaid__Edge__Config(Kwargs_To_Self):
-    edge_mode        : str
-    output_node_from : bool = False
-    output_node_to   : bool = False

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/configs/Mermaid__Node__Config.py

@@ -1,9 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self                       import Kwargs_To_Self
-from osbot_utils.graphs.mermaid.models.Mermaid__Node__Shape import Mermaid__Node__Shape
-
-
-class Mermaid__Node__Config(Kwargs_To_Self):
-    markdown         : bool
-    node_shape       : Mermaid__Node__Shape = Mermaid__Node__Shape.default
-    show_label       : bool = True
-    wrap_with_quotes : bool = True               # todo: add support for only using quotes when needed

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/configs/Mermaid__Render__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-
-class Mermaid__Render__Config(Kwargs_To_Self):
-    add_nodes         : bool = True
-    directives        : list
-    line_before_edges : bool = True