added method add_outgoing_edges__with_field

mgraph_ai/providers/json/actions/MGraph__Json__Export.py

@@ -1,4 +1,5 @@
 from typing                                                                     import Union, Dict, List, Optional, Any
+from osbot_utils.utils.Dev                                                      import pprint
 from mgraph_ai.providers.json.actions.exporters.MGraph__Export__Json__Dot       import MGraph__Export__Json__Dot
 from mgraph_ai.providers.json.actions.exporters.MGraph__Export__Json__Mermaid   import MGraph__Export__Json__Mermaid
 from mgraph_ai.providers.json.models.Model__MGraph__Json__Node__Dict            import Model__MGraph__Json__Node__Dict
@@ -80,4 +81,7 @@ def to_dot(self):
         return MGraph__Export__Json__Dot(graph=self.graph)
 
     def to_mermaid(self) -> MGraph__Export__Json__Mermaid:
-        return MGraph__Export__Json__Mermaid(graph=self.graph)
+        return MGraph__Export__Json__Mermaid(graph=self.graph)
+
+    def print__dict(self):
+        pprint(self.to_dict())

mgraph_ai/query/MGraph__Query.py

@@ -247,6 +247,44 @@ def add_outgoing_edges__with_depth(self, depth:int)  -> 'MGraph__Query':
             self.add_outgoing_edges()
         return self
 
+    def add_outgoing_edges__with_field(self, field_name: str) -> 'MGraph__Query':           # Add outgoing edges, but only for nodes with a specific field name
+        current_nodes, current_edges = self.get_current_ids()                               # Get current state
+        new_nodes = set()                                                                   # Initialize new sets
+        new_edges = set()
+
+        matching_nodes = self.mgraph_index.get_nodes_by_field('name', field_name)          # Get nodes with matching field
+
+        for node_id in current_nodes:                                                       # For each current node
+            node = self.mgraph_data.node(node_id)
+            if node:
+                outgoing_edges = self.mgraph_index.get_node_outgoing_edges(node)           # Get its outgoing edges
+
+                for edge_id in outgoing_edges:                                             # For each edge
+                    edge = self.mgraph_data.edge(edge_id)
+                    if edge:
+                        target_node_id = edge.to_node_id()                                 # Get target node
+                        if target_node_id in matching_nodes:                               # If target has matching field
+                            new_edges.add(edge_id)                                         # Add the edge
+                            new_nodes.add(target_node_id)                                  # Add the target node
+
+                            # Add value node connections
+                            property_node = self.mgraph_data.node(target_node_id)
+                            if property_node:
+                                value_edges = self.mgraph_index.get_node_outgoing_edges(property_node)
+                                for value_edge_id in value_edges:
+                                    value_edge = self.mgraph_data.edge(value_edge_id)
+                                    if value_edge:
+                                        new_edges.add(value_edge_id)                       # Add the value edge
+                                        new_nodes.add(value_edge.to_node_id())
+
+        combined_nodes = current_nodes | new_nodes                                         # Combine sets
+        combined_edges = current_edges | new_edges
+
+        self.create_view(nodes_ids = combined_nodes,                                       # Create new view
+                        edges_ids = combined_edges,
+                        operation = 'add_outgoing_edges_with_field',
+                        params    = {'field_name': field_name})
+        return self
     def add_node_id(self, node_id: Obj_Id) -> 'MGraph__Query':                                      # Add specific node to view
 
         current_nodes, current_edges = self.get_current_ids()                                       # Get current nodes and edges

tests/unit/providers/rss/test_MGraph__RSS.py

@@ -2,6 +2,7 @@
 from typing                                                 import Dict, Any
 from datetime                                               import datetime, timezone
 from mgraph_ai.providers.json.actions.MGraph__Json__Query   import MGraph__Json__Query
+from mgraph_ai.providers.json.actions.MGraph__Json__Query__Export__View import MGraph__Json__Query__Export__View
 from osbot_utils.utils.Files                                import file_exists, file_delete
 from osbot_utils.utils.Env                                  import load_dotenv
 from osbot_utils.helpers.xml.rss.RSS__Feed                  import RSS__Feed
@@ -23,7 +24,7 @@ def setUp(self):
         self.test_data  = MGraph__RSS__Test_Data().test_rss_data()
         self.rss_feed   = RSS__Feed__Parser().from_dict(self.test_data)
         self.mgraph_json = MGraph__Json()
-        self.mgraph_rss  = MGraph__RSS()
+        self.mgraph_rss  = MGraph__RSS(graph=self.mgraph_json)
         self.mgraph_rss.load_rss(self.rss_feed)
 
     def test__setUp(self):
@@ -33,7 +34,7 @@ def test__setUp(self):
             _.graph.query().print_stats()
 
     def test__render_as_dot(self):
-        load_dotenv()
+        #load_dotenv()
         with self.mgraph_rss as _:
             target_file = './dot.png'
             _.graph.screenshot().save_to(target_file).dot()                 # this is working quite well
@@ -45,10 +46,18 @@ def test__render_as_dot(self):
     def test__experiments(self):
         with self.mgraph_rss.graph.query() as _:
             assert type(_) is MGraph__Json__Query
-            _.field('description')
-            _.print_stats()
+            _.field('items')
+            _.add_outgoing_edges__with_depth(2)
+            _.add_outgoing_edges__with_field ('title')
 
 
+            export_view = MGraph__Json__Query__Export__View(mgraph_query=_)
+            domain_graph_exported = export_view.export()
+            mgraph_json__exported = MGraph__Json(graph=domain_graph_exported)
+            mgraph_json__exported.screenshot().save().dot()
+            mgraph_json__exported.export().print__dict()
+        #self.mgraph_json.screenshot().save().dot()
+
 
     def test_init(self):                                                  # Test initialization
         self.assertIsInstance(self.mgraph_rss         , MGraph__RSS  )