osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/graphs/mermaid/Mermaid__Edge.py

@@ -0,0 +1,49 @@
+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/graphs/mermaid/Mermaid__Graph.py

@@ -0,0 +1,93 @@
+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/graphs/mermaid/Mermaid__Node.py

@@ -0,0 +1,69 @@
+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/graphs/mermaid/Mermaid__Renderer.py

@@ -0,0 +1,54 @@
+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/graphs/mermaid/configs/Mermaid__Edge__Config.py

@@ -0,0 +1,7 @@
+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/graphs/mermaid/configs/Mermaid__Node__Config.py

@@ -0,0 +1,9 @@
+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/graphs/mermaid/configs/Mermaid__Render__Config.py

@@ -0,0 +1,7 @@
+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/graphs/mermaid/examples/Mermaid_Examples__FlowChart.py

@@ -0,0 +1,98 @@
+# 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/graphs/mermaid/models/Mermaid__Diagram_Direction.py

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

osbot_utils/graphs/mermaid/models/Mermaid__Diagram__Type.py

@@ -0,0 +1,17 @@
+from enum import auto, Enum
+
+
+class Diagram__Type(Enum):
+    class_diagram                = auto()
+    entity_relationship_diagram  = auto()
+    flowchart                    = auto()
+    gantt                        = auto()
+    git_graph                    = auto()
+    graph                        = auto()
+    mermaid_map                  = auto()
+    mindmap                      = auto()
+    pie_chart                    = auto()
+    requirement_diagram          = auto()
+    sequence_diagram             = "sequenceDiagram"
+    state_diagram                = 'stateDiagram-v2'
+    user_journey                 = auto()

osbot_utils/graphs/mermaid/models/Mermaid__Node__Shape.py

@@ -0,0 +1,30 @@
+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/graphs/mgraph/MGraph.py

@@ -0,0 +1,53 @@
+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/graphs/mgraph/MGraph__Config.py

@@ -0,0 +1,7 @@
+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

osbot_utils/graphs/mgraph/MGraph__Data.py

@@ -0,0 +1,139 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.graphs.mgraph.MGraph        import MGraph
+from osbot_utils.helpers.Print_Table         import Print_Table
+
+
+class MGraph__Data(Kwargs_To_Self):
+
+    mgraph : MGraph
+
+    def graph_data(self):
+        nodes_data = self.nodes_data()
+        edges_data = self.edges_data()
+        graph_data = {'nodes': nodes_data, 'edges': edges_data}
+        return graph_data
+
+    def edges(self):
+        return self.mgraph.edges
+
+    def edges_data(self):
+        edges_data = []
+        for edge in self.edges():
+            edges_data.append(edge.data())
+        return edges_data
+
+    def nodes(self):
+        return self.mgraph.nodes
+
+    def nodes_data(self):
+        nodes_data = []
+        for node in self.nodes():
+            nodes_data.append(node.data())
+        return nodes_data
+
+
+    def nodes__by_key(self):
+        by_key = {}
+        for node in self.nodes():
+            by_key[node.key] = node
+        return by_key
+
+    def nodes__keys(self):
+        return [node.key for node in self.nodes()]
+
+    def nodes_edges(self):
+        nodes__edges = {}
+        for node in self.nodes():
+            nodes__edges[node.key] = []
+        for edge in self.edges():
+            from_key = edge.from_node.key
+            if from_key in nodes__edges:                                        # todo: add a better way to handle this, which is a weird situation, look also at a better way to do this assigment
+                nodes__edges[from_key].append(edge.to_node.key)
+        for node_key, edges_keys in nodes__edges.items():
+            nodes__edges[node_key] = sorted(edges_keys)
+        return nodes__edges
+
+    # def map_paths(self, key, paths, all_paths, nodes_edges):
+    #     key_edges = nodes_edges[key]
+    #     new_paths = []
+    #
+    #     for edge_key in key_edges:
+    #         for path in paths:
+    #             if edge_key in path:
+    #                 if path not in all_paths:
+    #                     all_paths.append(path)
+    #             else:
+    #                 new_path = [*path, edge_key]
+    #                 new_paths.append(new_path)
+    #                 self.map_paths(edge_key, new_paths, all_paths, nodes_edges)
+    #                 if new_path not in all_paths:
+    #                     all_paths.append(new_path)
+        # if new_paths:
+        #     return new_paths
+
+            # for edge_key in key_edges:
+            #     self.map_paths(edge_key, paths, nodes_edges)
+        return paths
+
+    # def nodes__find_all_paths(self):
+    #     key         = self.nodes__keys()[0]
+    #     nodes_edges = self.nodes_edges()
+    #     #for key in self.nodes__keys():
+    #     all_paths = []
+    #     paths = [[key]]
+    #     self.map_paths(key, paths,all_paths,  nodes_edges)
+    #     pprint(all_paths)
+
+    def print(self):
+        with Print_Table() as _:
+            _.set_title(self.mgraph.config.graph_title)
+            for node_key, edges_keys in self.nodes_edges().items():
+                row = {'key': node_key,  'edges': edges_keys}
+                _.add_data(row)
+            _.set_order('key', 'edges')
+            _.print()
+
+    def print_adjacency_matrix(self):
+        adjacency_matrix = self.nodes_edges__adjacency_matrix()
+        node_keys        = sorted(self.nodes__keys())
+        with Print_Table() as _:
+            for row in adjacency_matrix:
+                _.add_data(row)
+            _.set_order('key', *node_keys)
+            _.print()
+
+
+    def node_edges__to_from(self):
+        # Initialize a dictionary to hold the edges to and from for each node
+        node_connections = { node_key: {'edges_to': [], 'edges_from': []} for node_key in self.nodes_edges().keys() }
+
+
+        for node_key, edges_keys in self.nodes_edges().items():                 # Fill 'edges_to' and 'edges_from' for each node
+            node_connections[node_key]['edges_from'].extend(edges_keys)         # 'edges_from' are the outgoing edges from 'node_key'
+
+            for edge_key in edges_keys:                                         # 'edges_to' are the incoming edges to the nodes in 'edges_keys'
+                if edge_key in node_connections:                                # Check if the edge_key represents a valid node
+                    node_connections[edge_key]['edges_to'].append(node_key)
+
+        return node_connections
+
+    def nodes_edges__adjacency_matrix(self):
+        nodes_edges = self.nodes_edges()                                                    # Retrieve the nodes and their edges
+        node_keys = sorted(nodes_edges.keys())                                              # Get a sorted list of unique node keys
+        node_indices = {node_key: index for index, node_key in enumerate(node_keys)}        # Create a mapping of node keys to their respective indices
+        size = len(node_keys)                                                               # Initialize a square matrix with empty strings
+        matrix = [['' for _ in range(size)] for _ in range(size)]
+
+        for node_key, edges_keys in nodes_edges.items():                                    # Fill the matrix with 'X' if there is an edge between two nodes
+            for edge_key in edges_keys:                                                     # Find the matrix positions based on node indices
+                row_index = node_indices[node_key]
+                col_index = node_indices[edge_key]
+                matrix[row_index][col_index] = 'X'
+
+        table_data = []
+        for i, row in enumerate(matrix):
+            row_data = {'key': node_keys[i]}
+            row_data.update({node_keys[j]: row[j] for j in range(size)})
+            table_data.append(row_data)
+        return table_data
+