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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.93.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.93.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.93.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.93.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.93.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 []
 
@@ -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.93.0 → osbot_utils-1.94.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v1.93.0"
+version     = "v1.94.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

osbot_utils-1.93.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)))
-    """

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/models/Mermaid__Diagram_Direction.py

@@ -1,9 +0,0 @@
-from enum import Enum, auto
-
-
-class Diagram__Direction(Enum):
-    BT = auto()
-    LR = auto()
-    TB = auto()
-    TD = auto()
-    RL = auto()

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/models/Mermaid__Diagram__Type.py

@@ -1,16 +0,0 @@
-from enum import Enum
-
-class Diagram__Type(Enum):
-    class_diagram                = "class_diagram"
-    entity_relationship_diagram  = "entity_relationship_diagram"
-    flowchart                    = "flowchart"
-    gantt                        = "gantt"
-    git_graph                    = "git_graph"
-    graph                        = "graph"
-    mermaid_map                  = "mermaid_map"
-    mindmap                      = "mindmap"
-    pie_chart                    = "pie_chart"
-    requirement_diagram          = "requirement_diagram"
-    sequence_diagram             = "sequenceDiagram"             # these are different from the others
-    state_diagram                = "stateDiagram-v2"             # these are different from the others
-    user_journey                 = "user_journey"

osbot_utils-1.93.0/osbot_utils/graphs/mermaid/models/Mermaid__Node__Shape.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-from enum import Enum
-
-
-class Mermaid__Node__Shape(Enum):
-    asymmetric          = ('>'  ,  ']'  )        # Asymmetric
-    circle              = ('((' ,  '))' )        # Circle, used for endpoints or start/end points
-    cylindrical         = ('[(' ,  ')]' )        # Cylindrical
-    default             = ('['  ,  ']'  )        # Rectangle
-    double_circle       = ('(((',  ')))')        # Double Circle
-    round_edges         = ('('  ,  ')'  )        # Stadium shape, used for processes or operations
-    rhombus             = ('{'  ,  '}'  )        # Rhombus, often synonymous with diamond in diagramming contexts
-    hexagon             = ('{{' ,  '}}' )        # Hexagon, used for preparation or complex processing
-    parallelogram       = ('[/' ,  '/]' )        # Parallelogram, used for input/output
-    parallelogram_alt   = ('[\\',  '\\]')        # Alternative parallelogram, also used for input/output
-    rectangle           = ('['  ,  ']'  )        # Rectangle, used for process
-    stadium             = ('([' ,  '])' )        # Stadium
-    subroutine          = ('[[',   ']]' )        # Subroutine
-    trapezoid           = ('[/' , r'\]' )        # Trapezoid, used for manual operations             # todo: figure out why this line is throwing the compile error of: SyntaxWarning: invalid escape sequence '\]'
-    trapezoid_alt       = ('[\\',  '/]' )        # Inverted trapezoid, also used for manual operations
-
-    @staticmethod
-    def get_shape(value = None) -> Mermaid__Node__Shape:
-        if isinstance(value, Mermaid__Node__Shape):
-            return value
-        if type(value) is str:
-            for shape in Mermaid__Node__Shape:
-                if value == shape.name:
-                    return shape
-        return Mermaid__Node__Shape.default

osbot_utils-1.93.0/osbot_utils/graphs/mgraph/MGraph.py

@@ -1,55 +0,0 @@
-from typing import List
-
-from osbot_utils.utils.Misc import random_text, lower
-from osbot_utils.base_classes.Kwargs_To_Self   import Kwargs_To_Self
-from osbot_utils.graphs.mgraph.MGraph__Config  import MGraph__Config
-from osbot_utils.graphs.mgraph.MGraph__Edge    import MGraph__Edge
-from osbot_utils.graphs.mgraph.MGraph__Node    import MGraph__Node
-
-
-# todo add support for storing the data in sqlite so that we get the ability to search nodes and edges
-class MGraph(Kwargs_To_Self):
-    config : MGraph__Config
-    edges  : List[MGraph__Edge]
-    key    : str
-    nodes  : List[MGraph__Node]
-
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        if not self.key:
-            self.key = random_text("mgraph", lowercase=True)                 # make sure there is always a key
-
-    def add_edge(self, from_node, to_node, label=None,attributes=None):
-        if self.config.allow_circle_edges is False:
-            if from_node == to_node:
-                return None
-        if self.config.allow_duplicate_edges is False:                          # todo: figure out if there is a more efficient way to do this
-            for edge in self.edges:
-                if edge.from_node == from_node and edge.to_node == to_node:
-                    return None
-        new_edge = MGraph__Edge(from_node=from_node, to_node=to_node, label=label, attributes=attributes)
-        self.edges.append(new_edge)
-        return new_edge
-
-    def add_node(self, key=None, label=None, attributes=None):
-        new_node = MGraph__Node(key=key, label=label, attributes=attributes)
-        self.nodes.append(new_node)
-        return new_node
-
-    def data(self):
-        from osbot_utils.graphs.mgraph.MGraph__Data import MGraph__Data
-        return MGraph__Data(mgraph=self)
-
-    # def save(self, format='pickle'):
-    #     if format == 'pickle':
-    #         return pickle_save_to_file(self)
-
-    #todo: add save that return saved object
-    # def save(self):
-    #     from osbot_utils.graphs.mgraph.MGraph__Serializer import MGraph__Serializer        # due to circular dependency
-    #     return MGraph__Serializer(mgraph=self).save()
-
-    def print(self):
-        print()
-        return self.data().print()

osbot_utils-1.93.0/osbot_utils/graphs/mgraph/MGraph__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-class MGraph__Config(Kwargs_To_Self):
-
-    allow_circle_edges    : bool
-    allow_duplicate_edges : bool
-    graph_title           : str