osbot-utils 1.92.0__tar.gz → 1.94.0__tar.gz

{osbot_utils-1.92.0 → osbot_utils-1.94.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.92.0
+Version: 1.94.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.92.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.94.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.92.0 → osbot_utils-1.94.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.92.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.94.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.92.0 → osbot_utils-1.94.0}/osbot_utils/base_classes/Type_Safe.py

@@ -3,7 +3,7 @@
 
 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)
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -95,8 +95,12 @@ class Type_Safe:
         if value is not None:
             if type(value) is dict:
                 value = convert_dict_to_value_from_obj_annotation(self, name, value)
-            if type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
+            elif type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
                 value = convert_to_value_from_obj_annotation (self, name, value)
+            else:
+                origin = get_origin(value)
+                if origin is not None:
+                    value = origin
             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
@@ -169,7 +173,7 @@ class Type_Safe:
                                 #todo: fix type safety bug that I believe is caused here
                                 if obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                # if var_type is not something like Optional[Union[int, str]]
                                     if type(var_type) not in IMMUTABLE_TYPES:
-                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Kwargs_To_Self, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
+                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
                                         raise ValueError(exception_message)
             if include_base_classes is False:
                 break
@@ -304,6 +308,19 @@ class Type_Safe:
                 setattr(self, key, value)
         return self
 
+    def deserialize_type__using_value(self, value):
+        if value:
+            try:
+                module_name, type_name = value.rsplit('.', 1)
+                if module_name == 'builtins' and type_name == 'NoneType':                       # Special case for NoneType (which serialises as builtins.* , but it actually in types.* )
+                    value = types.NoneType
+                else:
+                    module = __import__(module_name, fromlist=[type_name])
+                    value = getattr(module, type_name)
+            except (ValueError, ImportError, AttributeError) as e:
+                raise ValueError(f"Could not reconstruct type from '{value}': {str(e)}")
+        return value
+
     def deserialize_dict__using_key_value_annotations(self, key, value):
         from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
 
@@ -353,7 +370,9 @@ class Type_Safe:
                             raise ValueError(f"Attribute '{key}' not found in '{self.__class__.__name__}'")
                         else:
                             continue
-                    if obj_is_attribute_annotation_of_type(self, key, dict):                                # handle the case when the value is a dict
+                    if obj_attribute_annotation(self, key) == type:                                         # Handle type objects
+                        value = self.deserialize_type__using_value(value)
+                    elif obj_is_attribute_annotation_of_type(self, key, dict):                                # handle the case when the value is a dict
                         value = self.deserialize_dict__using_key_value_annotations(key, value)
                     elif obj_is_attribute_annotation_of_type(self, key, list):                              # handle the case when the value is a list
                         attribute_annotation = obj_attribute_annotation(self, key)                          # get the annotation for this variable
@@ -423,15 +442,17 @@ def serialize_to_dict(obj):
         return obj
     elif isinstance(obj, Enum):
         return obj.name
+    elif isinstance(obj, type):
+        return f"{obj.__module__}.{obj.__name__}"                                   # save the full type name
     elif isinstance(obj, list) or isinstance(obj, List):
         return [serialize_to_dict(item) for item in obj]
     elif isinstance(obj, dict):
         return {key: serialize_to_dict(value) for key, value in obj.items()}
     elif hasattr(obj, "__dict__"):
-        data = {}                                           # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
+        data = {}                                                                   # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
         for key, value in obj.__dict__.items():
-            if key.startswith('__') is False:               # don't process internal variables (for example the ones set by @cache_on_self)
-                data[key] = serialize_to_dict(value)        # Recursive call for complex types
+            if key.startswith('__') is False:                                       # don't process internal variables (for example the ones set by @cache_on_self)
+                data[key] = serialize_to_dict(value)                                # Recursive call for complex types
         return data
     else:
         raise TypeError(f"Type {type(obj)} not serializable")

{osbot_utils-1.92.0 → osbot_utils-1.94.0}/osbot_utils/helpers/Safe_Id.py

@@ -1,8 +1,10 @@
 from osbot_utils.utils.Misc import random_id_short
 from osbot_utils.utils.Str  import safe_id
 
+SAFE_ID__MAX_LENGTH = 512
+
 class Safe_Id(str):
-    def __new__(cls, value=None, max_length=36):
+    def __new__(cls, value=None, max_length=SAFE_ID__MAX_LENGTH):
         if value is None:
             value = safe_id(random_id_short('safe-id'))
         sanitized_value = safe_id(value, max_length=max_length)

{osbot_utils-1.92.0 → osbot_utils-1.94.0}/osbot_utils/utils/Json.py

@@ -193,6 +193,7 @@ json_save_file_gz            = Json.save_file_gz
 json_save_file_pretty_gz     = Json.save_file_pretty_gz
 json_save_tmp_file           = Json.json_save_tmp_file
 str_to_json                  = Json.loads
+str_from_json                = json_dumps
 
 load_file_json               = json_load_file
 load_file_json_gz            = json_load_file_gz

{osbot_utils-1.92.0 → osbot_utils-1.94.0}/osbot_utils/utils/Objects.py

@@ -359,8 +359,6 @@ def obj_attribute_annotation(target, attr_name):
 
 def obj_is_attribute_annotation_of_type(target, attr_name, expected_type):
     attribute_annotation = obj_attribute_annotation(target, attr_name)
-    #attribute_type       = type(attribute_annotation)
-    #return attribute_type is expected_type
     if expected_type is attribute_annotation:
         return True
     if expected_type is type(attribute_annotation):

{osbot_utils-1.92.0 → osbot_utils-1.94.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 []
 
@@ -42,7 +42,7 @@ def safe_id(value, max_length=36):
         value = str(value)
 
     if len(value) > max_length:
-        raise ValueError(f"Invalid ID: The ID must not exceed 36 characters (was {len(value)}).")
+        raise ValueError(f"Invalid ID: The ID must not exceed {max_length} characters (was {len(value)}).")
 
     sanitized_value = REGEX__SAFE_ID_REGEX.sub('_', value)
 
@@ -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.94.0/osbot_utils/version

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

{osbot_utils-1.92.0 → osbot_utils-1.94.0}/pyproject.toml

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

osbot_utils-1.92.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.92.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.92.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.92.0/osbot_utils/graphs/mermaid/Mermaid__Node.py

@@ -1,69 +0,0 @@
-from enum import Enum
-
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-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
-from osbot_utils.utils.Str import safe_str
-
-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.92.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.92.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.92.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.92.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

osbot_utils-1.92.0/osbot_utils/graphs/mermaid/examples/Mermaid_Examples__FlowChart.py

@@ -1,98 +0,0 @@
-# from https://mermaid.js.org/syntax/flowchart.html
-class Mermain_Examples__FlowChart:
-    example_1__a_node_default = """
-flowchart LR
-    id
-    """
-    example_2__a_node_with_text = """
-flowchart LR
-    id1[This is the text in the box]    
-    """
-
-    example_3__a_node_with_unicode_text = """
-flowchart LR
-    id["This ❤ Unicode"]    
-    """
-    example_4__a_node_with_markdown_formatting = """
-%%{init: {"flowchart": {"htmlLabels": false}} }%%
-flowchart LR
-    markdown["`This **is** _Markdown_`"]
-    newLines["`Line1
-    Line 2
-    Line 3`"]
-    markdown --> newLines 
-    """
-
-    example_5__direction__from_top_to_bottom  = """
-flowchart TD
-    Start --> Stop    
-    """
-
-    example_6__direction__from_left_to_right  = """
-flowchart LR
-    Start --> Stop    
-    """
-    example_7__node_shapes_a_node_with_round_edges  = """
-flowchart LR
-    id1(This is the text in the box)
-    """
-
-    example_8__node_shapes_a_stadium_shaped_node  = """
-flowchart LR
-    id1([This is the text in the box])
-    """
-
-    example_9__node_shapes_a_node_in_a_subroutine ="""
-flowchart LR
-    id1[[This is the text in the box]]
-    """
-
-    example_10__node_shapes_a_node_in_a_cylindrical_shape ="""
-flowchart LR
-    id1[(Database)]
-    """
-
-    example_11__node_shapes_a_node_in_the_form_of_a_circle = """
-flowchart LR
-    id1((This is the text in the circle))
-    """
-
-    example_12__node_shapes_a_node_in_an_asymmetric_shape = """
-flowchart LR
-    id1>This is the text in the box]
-    """
-
-    example_13__node_shapes_a_node_rhombus = """
-flowchart LR
-    id1{This is the text in the box}
-    """
-
-    example_14__node_shapes_a_hexagon_node = """
-flowchart LR
-    id1{{This is the text in the box}}
-    """
-
-    example_15__node_shapes_parallelogram = """
-flowchart TD
-    id1[/This is the text in the box/]
-    """
-
-    example_16__node_shapes_parallelogram_alt = r"""
-flowchart TD
-    id1[\This is the text in the box\]
-    """
-
-    example_17__node_shapes_trapezoid = r"""
-flowchart TD
-    A[/Christmas\]
-    """
-
-    example_18__node_shapes_trapezoid_alt = r"""
-flowchart TD
-    B[\Go shopping/]
-    """
-
-    example_19__node_shapes_double_circle = """
-flowchart TD
-    id1(((This is the text in the circle)))
-    """