graph-seeder 1.0.0.dev5__tar.gz → 1.0.0.dev8__tar.gz

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-seeder
-Version: 1.0.0.dev5
+Version: 1.0.0.dev8
 Summary: A powerful tool to extract and densify subgraphs from Knowledge Graphs via SPARQL or LMDB, with different extraction strategies.
 Requires-Python: >=3.9
 Requires-Dist: lmdb>=2.2.0

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/graph_seeder"]
 
 [project]
 name = "graph-seeder"
-version = "1.0.0.dev5"
+version = "1.0.0.dev8"
 description = "A powerful tool to extract and densify subgraphs from Knowledge Graphs via SPARQL or LMDB, with different extraction strategies."
 readme = "README.md"
 requires-python = ">=3.9"

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/SubgraphExtractor.py

@@ -8,6 +8,7 @@ from rich.logging import RichHandler
 from rich.prompt import Confirm
 from graph_seeder.extraction.ExtractionStrategy import ExtractionStrategy
 from graph_seeder.densification.GraphConnector import GraphConnector
+from graph_seeder.models.RDFNode import ExtractionResult
 from graph_seeder.utils.Factory import ComponentFactory
 from graph_seeder.utils.ConsoleUI import ConsoleUI
 from graph_seeder.utils.GraphExporter import GraphExporter
@@ -242,8 +243,10 @@ class SubgraphExtractor:
 
             return []
 
-    def extract_subgraph(self, seeds: list[str]) -> tuple[list[dict], set[str]]:
-        all_paths: list[dict] = []
+    def extract_subgraph(
+        self, seeds: list[str]
+    ) -> tuple[list[ExtractionResult], set[str]]:
+        all_results: list[ExtractionResult] = []
         seeds_found: set[str] = set()
 
         with self.ui.create_progress_bar() as progress:
@@ -264,7 +267,7 @@ class SubgraphExtractor:
                 if not triplets:
                     self.stats["not_found"] += 1
                 else:
-                    all_paths.append(
+                    all_results.append(
                         {
                             "seed": clean_nodes[0],
                             "target": clean_nodes[1] if len(clean_nodes) > 1 else None,
@@ -274,18 +277,18 @@ class SubgraphExtractor:
                     seeds_found.update(clean_nodes)
                     self.stats["found"] += 1
 
-        self.exporter.save_results(all_paths, self.uri_manager)
+        self.exporter.save_results(all_results, self.uri_manager)
         self.exporter.save_graph(self.extractor_strategy.graph)
 
         logger.info("Computing final graph statistics...")
 
         self.print_final_summary(
-            all_paths, self.extractor_strategy.graph, "Extraction summary"
+            all_results, self.extractor_strategy.graph, "Extraction summary"
         )
 
-        return all_paths, seeds_found
+        return all_results, seeds_found
 
-    def densify_graph(self, all_paths: list[dict], seeds_found: set[str]):
+    def densify_graph(self, all_results: list[ExtractionResult], seeds_found: set[str]):
         explored_nodes = self.extractor_strategy.explored_nodes
 
         graph_connector: GraphConnector = GraphConnector(
@@ -296,13 +299,13 @@ class SubgraphExtractor:
             self.ui,
             self.cfg,
         )
-        nb_components = get_connected_components(all_paths)
+        nb_components = get_connected_components(all_results)
         if len(nb_components) > 1:
             logger.warning(
                 f"The extracted graph has {len(nb_components)} disconnected components. Starting densification to connect them...\n"
             )
 
-            densified_paths = graph_connector.connect(all_paths, seeds_found)
+            densified_paths = graph_connector.connect(all_results, seeds_found)
 
             self.save(
                 densified_paths, graph_connector.bfs.graph, name_suffix="_densified"
@@ -321,7 +324,7 @@ class SubgraphExtractor:
 
     def print_final_summary(
         self,
-        paths: list[dict],
+        paths: list[ExtractionResult],
         graph: nx.MultiGraph,
         table_title: str,
         name_suffix: str = "",
@@ -333,7 +336,7 @@ class SubgraphExtractor:
 
     def save(
         self,
-        paths: list[dict],
+        paths: list[ExtractionResult],
         graph: nx.MultiGraph,
         name_suffix: str = "",
     ) -> None:
@@ -391,13 +394,13 @@ class SubgraphExtractor:
                 seeds = [list(pair) for pair in itertools.combinations(unique_seeds, 2)]
                 logger.info(f"Created {len(seeds)} pairs to explore.\n")
 
-        all_paths, seeds_found = self.extract_subgraph(seeds)
+        all_results, seeds_found = self.extract_subgraph(seeds)
 
-        if not all_paths:
+        if not all_results:
             logger.error("No paths were extracted. Exiting without saving.")
             return
 
         if self.skip_densification:
             return
 
-        self.densify_graph(all_paths, seeds_found)
+        self.densify_graph(all_results, seeds_found)

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/densification/GraphConnector.py

@@ -8,6 +8,7 @@ from graph_seeder.utils.URIManager import URIManager
 from graph_seeder.utils.utils import get_connected_components
 from graph_seeder.utils.Factory import ComponentFactory
 from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
+from graph_seeder.models.RDFNode import ExtractionResult
 
 logger = logging.getLogger("subgraph")
 
@@ -50,20 +51,20 @@ class GraphConnector:
 
     def connect(
         self,
-        initial_paths: list[dict],
+        initial_results: list[ExtractionResult],
         found_seeds: set[str],
-    ) -> list[dict]:
+    ) -> list[ExtractionResult]:
 
-        current_paths: list[dict] = list(initial_paths)
+        current_results: list[ExtractionResult] = list(initial_results)
         failed_component_pairs = set()
 
-        initial_triplets_count = sum(len(p.get("triples", [])) for p in current_paths)
+        initial_triplets_count = sum(len(p.get("triples", [])) for p in current_results)
 
         with self.ui.create_progress_bar() as progress:
             task = progress.add_task("Components densification", total=None)
 
             while True:
-                components = get_connected_components(current_paths)
+                components = get_connected_components(current_results)
 
                 if len(components) <= 1:
                     current_completed = progress.tasks[0].completed
@@ -110,23 +111,19 @@ class GraphConnector:
                 )
 
                 if path_triplets:
-                    new_path = {
-                        "seed": source,
-                        "target": target,
-                        "triples": path_triplets,
-                    }
-                    current_paths.append(new_path)
+                    new_result = ExtractionResult(
+                        seed=source, target=target, triples=path_triplets
+                    )
+                    current_results.append(new_result)
 
                     for s, p, o in path_triplets:
-                        self.graph.add_edge(s, o)
+                        self.graph.add_edge(s.value, o.value)
                 else:
-                    failed_component_pairs.add(
-                        tuple(sorted([tuple(seeds_a), tuple(seeds_b)]))
-                    )
+                    failed_component_pairs.add(pair_id)
 
-        final_triplets_count = sum(len(p.get("triples", [])) for p in current_paths)
+        final_triplets_count = sum(len(p.get("triples", [])) for p in current_results)
         logger.info(
             f"Found {final_triplets_count - initial_triplets_count} new triplets during densification."
         )
 
-        return current_paths
+        return current_results

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/extraction/BFS/BFS.py

@@ -1,4 +1,5 @@
 import logging
+from graph_seeder.models.RDFNode import RDFNode
 from graph_seeder.utils.URIManager import URIManager
 from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 from graph_seeder.extraction.ExtractionStrategy import ExtractionStrategy
@@ -46,7 +47,9 @@ class BidirectionalBFS(ExtractionStrategy):
     ) -> str:
         return f"Extracting path for {self.format_progress_description(nodes)}"
 
-    def extract(self, nodes: list[str]) -> tuple[list[tuple[str, str, str]], str]:
+    def extract(
+        self, nodes: list[str]
+    ) -> tuple[list[tuple[RDFNode, RDFNode, RDFNode]], str]:
         """Extract a subgraph connecting the given seed nodes using bidirectional BFS.
         Returns:
              Tuple of (list of path triplets, result message)"""
@@ -60,7 +63,7 @@ class BidirectionalBFS(ExtractionStrategy):
 
     def _find_path(
         self, source: str, target: str
-    ) -> tuple[list[tuple[str, str, str]], str]:
+    ) -> tuple[list[tuple[RDFNode, RDFNode, RDFNode]], str]:
         """Find a path between two nodes within the configured hop limit.
         Returns:
              Tuple of (path_triplets, result message)
@@ -160,19 +163,28 @@ class BidirectionalBFS(ExtractionStrategy):
             self.graph.add_node(node)
 
         for triplets in self.wrapper.get_neighborhood(nodes_to_query):
-            for subj, predicate, obj in triplets:
+            for subj_node, pred_node, obj_node in triplets:
+                subj_val = subj_node.value
+                obj_val = obj_node.value
+                pred_val = pred_node.value
+
                 if (
-                    subj in self._excluded_nodes
-                    or obj in self._excluded_nodes
-                    or predicate in self._excluded_properties
+                    subj_val in self._excluded_nodes
+                    or obj_val in self._excluded_nodes
+                    or pred_val in self._excluded_properties
                 ):
                     continue
 
                 self.graph.add_edge(
-                    subj, obj, predicate=predicate, original_subj=subj, original_obj=obj
+                    subj_val,
+                    obj_val,
+                    predicate=pred_val,
+                    subj_node=subj_node,
+                    pred_node=pred_node,
+                    obj_node=obj_node,
                 )
 
-                for n in (subj, obj):
+                for n in (subj_val, obj_val):
                     if n not in nodes_visited:
                         next_level.add(n)
 
@@ -184,19 +196,23 @@ class BidirectionalBFS(ExtractionStrategy):
 
     def _extract_path_triplets(
         self, source: str, target: str
-    ) -> list[tuple[str, str, str]]:
+    ) -> list[tuple[RDFNode, RDFNode, RDFNode]]:
         """Build a triple sequence for the shortest path currently in the graph."""
         path_nodes: list[str] = nx.shortest_path(
             self.graph, source=source, target=target
         )
-        triplets: list[tuple[str, str, str]] = []
+        triplets: list[tuple[RDFNode, RDFNode, RDFNode]] = []
 
         for u, v in zip(path_nodes, path_nodes[1:]):
             edges = self.graph[u][v]
             edge_data = edges[next(iter(edges))]
-            predicate = edge_data.get("predicate", "unknown_property")
-            subj = edge_data.get("original_subj", u)
-            obj = edge_data.get("original_obj", v)
-            triplets.append((subj, predicate, obj))
+
+            subj_node = edge_data.get("subj_node", RDFNode(u, "uri"))
+            pred_node = edge_data.get(
+                "pred_node", RDFNode(edge_data.get("predicate", "unknown"), "uri")
+            )
+            obj_node = edge_data.get("obj_node", RDFNode(v, "uri"))
+
+            triplets.append((subj_node, pred_node, obj_node))
 
         return triplets

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/extraction/ExtractionStrategy.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from networkx import MultiGraph
+from graph_seeder.models.RDFNode import RDFNode
 from graph_seeder.utils.URIManager import URIManager
 from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 from rich.progress import (
@@ -28,7 +29,9 @@ class ExtractionStrategy(ABC):
         self.explored_nodes = set() if explored_nodes is None else explored_nodes
 
     @abstractmethod
-    def extract(self, nodes: list[str]) -> tuple[list[tuple[str, str, str]], str]:
+    def extract(
+        self, nodes: list[str]
+    ) -> tuple[list[tuple[RDFNode, RDFNode, RDFNode]], str]:
         """Extract a subgraph given a list of seed nodes.
         Returns:
             Tuple of (list of triplets, result message)"""
@@ -46,7 +49,7 @@ class ExtractionStrategy(ABC):
 
     def execute_task(
         self, nodes: list[str], progress: Progress, task: TaskID
-    ) -> list[tuple[str, str, str]]:
+    ) -> list[tuple[RDFNode, RDFNode, RDFNode]]:
         """Execute the extraction task with progress bar updates and error handling."""
         task_description = self.format_progress_description(nodes)
         start_message = self.format_start_message(nodes)

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/extraction/Hop/HopExpansion.py

@@ -1,6 +1,7 @@
 import logging
 from graph_seeder.extraction.ExtractionStrategy import ExtractionStrategy
 
+from graph_seeder.models.RDFNode import RDFNode
 from graph_seeder.utils.URIManager import URIManager
 from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 
@@ -34,7 +35,9 @@ class HopExpansion(ExtractionStrategy):
     ) -> str:
         return f"Expanding {self.max_hops} hops for {self.format_progress_description(nodes)}"
 
-    def extract(self, nodes: list[str]) -> tuple[list[tuple[str, str, str]], str]:
+    def extract(
+        self, nodes: list[str]
+    ) -> tuple[list[tuple[RDFNode, RDFNode, RDFNode]], str]:
         """
         Extract a subgraph by expanding from the given seed nodes up to max_hops.
         Returns:
@@ -50,7 +53,9 @@ class HopExpansion(ExtractionStrategy):
             f"[green]✓[/] Extracted {len(triplets)} triplets within {self.max_hops} hops.",
         )
 
-    def _expand(self, nodes: list[str]) -> list[tuple[str, str, str]] | None:
+    def _expand(
+        self, nodes: list[str]
+    ) -> list[tuple[RDFNode, RDFNode, RDFNode]] | None:
         """
         Expand a list of nodes radially up to max_hops.
         Returns a list of all discovered unique triplets.
@@ -62,7 +67,7 @@ class HopExpansion(ExtractionStrategy):
         visited_nodes: set[str] = set(valid_nodes)
         current_level_nodes: set[str] = set(valid_nodes)
         self.graph.add_nodes_from(valid_nodes)
-        all_triplets: set[tuple[str, str, str]] = set()
+        all_triplets: set[tuple[RDFNode, RDFNode, RDFNode]] = set()
 
         for hop in range(self.max_hops):
             logger.info(
@@ -76,11 +81,14 @@ class HopExpansion(ExtractionStrategy):
                 if node in self.explored_nodes:
                     if node in self.graph:
                         for u, v, data in self.graph.edges(node, data=True):
-                            pred = data.get("key")
                             neighbor = v if u == node else u
 
                             if neighbor not in self._excluded_nodes:
-                                all_triplets.add((u, pred, v))
+                                subj_node = data.get("subj_node")
+                                pred_node = data.get("pred_node")
+                                obj_node = data.get("obj_node")
+
+                                all_triplets.add((subj_node, pred_node, obj_node))
                                 if neighbor not in visited_nodes:
                                     next_level_nodes.add(neighbor)
                 else:
@@ -88,23 +96,33 @@ class HopExpansion(ExtractionStrategy):
 
             if nodes_to_query:
                 for triplets in self.wrapper.get_neighborhood(nodes_to_query):
-                    for subj, pred, obj in triplets:
+                    for subj_node, pred_node, obj_node in triplets:
+                        subj_val = subj_node.value
+                        obj_val = obj_node.value
+                        pred_val = pred_node.value
+
                         if (
-                            subj in self._excluded_nodes
-                            or obj in self._excluded_nodes
-                            or pred in self._excluded_properties
+                            subj_val in self._excluded_nodes
+                            or obj_val in self._excluded_nodes
+                            or pred_val in self._excluded_properties
                         ):
                             continue
+
                         self.graph.add_edge(
-                            subj, obj, key=pred, original_subj=subj, original_obj=obj
+                            subj_val,
+                            obj_val,
+                            key=pred_val,
+                            subj_node=subj_node,
+                            pred_node=pred_node,
+                            obj_node=obj_node,
                         )
 
-                        all_triplets.add((subj, pred, obj))
+                        all_triplets.add((subj_node, pred_node, obj_node))
 
-                        if subj not in visited_nodes:
-                            next_level_nodes.add(subj)
-                        if obj not in visited_nodes:
-                            next_level_nodes.add(obj)
+                        if subj_val not in visited_nodes:
+                            next_level_nodes.add(subj_val)
+                        if obj_val not in visited_nodes:
+                            next_level_nodes.add(obj_val)
 
                 self.explored_nodes.update(nodes_to_query)
 

graph_seeder-1.0.0.dev8/src/graph_seeder/models/RDFNode.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import Optional, TypedDict
+from rdflib import URIRef, Literal
+from graph_seeder.utils.URIManager import URIManager
+
+
+@dataclass(frozen=True)
+class RDFNode:
+    """Represents a node in an RDF graph, which can be a URI or a literal value."""
+
+    value: str
+    node_type: str
+    datatype: Optional[str] = None
+    language: Optional[str] = None
+
+    @property
+    def is_uri(self) -> bool:
+        return self.node_type == "uri"
+
+    @property
+    def is_literal(self) -> bool:
+        return self.node_type in ("literal", "typed-literal")
+
+    def __str__(self) -> str:
+        return self.value
+
+    def to_rdflib(self, uri_manager: URIManager):
+        """Convert internal string representation to proper rdflib Nodes."""
+        if self.is_uri:
+            if ":" in self.value and not self.value.startswith("http"):
+                prefix, local_name = self.value.split(":", 1)
+                if prefix in uri_manager.namespaces:
+                    return URIRef(f"{uri_manager.namespaces[prefix]}{local_name}")
+            return URIRef(self.value)
+
+        else:
+            return Literal(self.value, lang=self.language, datatype=self.datatype)
+
+
+class ExtractionResult(TypedDict):
+    """Type hinting for dictionaries of extracted paths."""
+
+    seed: str
+    target: Optional[str]
+    triples: list[tuple[RDFNode, RDFNode, RDFNode]]

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/utils/GraphExporter.py

@@ -3,7 +3,8 @@ import logging
 import pickle
 from pathlib import Path
 import networkx as nx
-from rdflib import Graph, Namespace, URIRef, Literal
+from rdflib import Graph, Namespace
+from graph_seeder.models.RDFNode import ExtractionResult
 from graph_seeder.utils.URIManager import URIManager
 
 logger = logging.getLogger("subgraph")
@@ -24,7 +25,7 @@ class GraphExporter:
 
     def save_results(
         self,
-        extracted_paths: list[dict],
+        extraction_results: list[ExtractionResult],
         uri_manager: URIManager,
         name_suffix: str = "",
     ) -> None:
@@ -35,45 +36,54 @@ class GraphExporter:
         fmt = self.output_format
 
         if fmt == "json":
-            compressed_paths = []
-            for path_data in extracted_paths:
-                compressed_paths.append(
-                    {
-                        "seed": uri_manager.compress_uri(path_data["seed"]),
-                        "target": uri_manager.compress_uri(path_data["target"]),
-                        "triples": [
-                            [
-                                uri_manager.compress_uri(s),
-                                uri_manager.compress_uri(p),
-                                uri_manager.compress_uri(o),
-                            ]
-                            for s, p, o in path_data.get("triples", [])
-                        ],
-                    }
-                )
-
-            final_json = {"@context": uri_manager.namespaces, "paths": compressed_paths}
+            results_list = []
+            for result_data in extraction_results:
+                extracted_item = {"seed": uri_manager.compress_uri(result_data["seed"])}
+
+                if result_data.get("target"):
+                    extracted_item["target"] = uri_manager.compress_uri(
+                        result_data["target"]
+                    )
+
+                extracted_item["triples"] = [
+                    [
+                        uri_manager.compress_uri(s.value),
+                        uri_manager.compress_uri(p.value),
+                        uri_manager.compress_uri(o.value) if o.is_uri else o.value,
+                    ]
+                    for s, p, o in result_data.get("triples", [])
+                ]
+
+                results_list.append(extracted_item)
+
+            final_json = {"@context": uri_manager.namespaces, "results": results_list}
 
             with open(path, "w", encoding="utf-8") as f:
                 json.dump(final_json, f, indent=2)
 
         elif fmt == "ttl":
             rdf = Graph()
-
-            for prefix, uri in uri_manager.namespaces.items():
-                rdf.bind(prefix, Namespace(uri))
-
             added_triples = set()
 
-            for path_data in extracted_paths:
-                for s, p, o in path_data.get("triples", []):
-                    if (s, p, o) not in added_triples:
-                        obj_node = (
-                            URIRef(o) if str(o).startswith("http") else Literal(o)
+            for result_data in extraction_results:
+                for s, p, o in result_data.get("triples", []):
+                    if (s.value, p.value, o.value) not in added_triples:
+                        uri_manager.compress_uri(s.value)
+                        uri_manager.compress_uri(p.value)
+                        if o.is_uri:
+                            uri_manager.compress_uri(o.value)
+
+                        rdf.add(
+                            (
+                                s.to_rdflib(uri_manager),
+                                p.to_rdflib(uri_manager),
+                                o.to_rdflib(uri_manager),
+                            )
                         )
+                        added_triples.add((s.value, p.value, o.value))
 
-                        rdf.add((URIRef(s), URIRef(p), obj_node))
-                        added_triples.add((s, p, o))
+            for prefix, uri in uri_manager.namespaces.items():
+                rdf.bind(prefix, Namespace(uri))
 
             rdf.serialize(destination=str(path), format="turtle")
 

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/utils/GraphStatistics.py

@@ -1,4 +1,5 @@
 import statistics
+from graph_seeder.models.RDFNode import ExtractionResult
 from graph_seeder.utils.utils import get_connected_components
 
 
@@ -6,23 +7,23 @@ class GraphStatistics:
     """Utility class for computing statistics on a graph."""
 
     @staticmethod
-    def compute(paths: list[dict]) -> dict:
-        """Compute statistics on the graph given the extracted paths."""
+    def compute(results: list[ExtractionResult]) -> dict:
+        """Compute statistics on the graph given the extracted results."""
         subjects = set()
         predicates = set()
         objects = set()
         triplets = []
 
-        for path_data in paths:
+        for path_data in results:
             for s, p, o in path_data.get("triples", []):
-                triplets.append((s, p, o))
-                subjects.add(s)
-                predicates.add(p)
-                objects.add(o)
+                triplets.append((s.value, p.value, o.value))
+                subjects.add(s.value)
+                predicates.add(p.value)
+                objects.add(o.value)
 
         unique_entities = len(subjects | objects)
 
-        components = get_connected_components(paths)
+        components = get_connected_components(results)
 
         comp_sizes = [len(comp) for comp in components]
         mean_size = statistics.mean(comp_sizes) if comp_sizes else 0

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/utils/utils.py

@@ -2,6 +2,7 @@ import networkx as nx
 import json
 from importlib import resources
 from pathlib import Path
+from graph_seeder.models.RDFNode import ExtractionResult, RDFNode
 
 BUILTIN_CONFIGS = [
     "dbpedia_default",
@@ -285,9 +286,20 @@ def generate_config_template(output_path: str = "config_template.json") -> None:
     print(f"Configuration template successfully generated at: {path}")
 
 
-def get_connected_components(paths: list[dict]) -> list[set[str]]:
+def get_connected_components(paths: list[ExtractionResult]) -> list[set[str]]:
     """Get the connected components from a list of structured paths."""
     graph: nx.Graph = nx.Graph()
     for path_data in paths:
-        graph.add_edges_from((s, o) for s, p, o in path_data.get("triples", []))
+        graph.add_edges_from(
+            (s.value, o.value) for s, p, o in path_data.get("triples", [])
+        )
     return list(nx.connected_components(graph))
+
+
+def parse_node(binding: dict) -> RDFNode:
+    return RDFNode(
+        value=binding["value"],
+        node_type=binding["type"],
+        datatype=binding.get("datatype"),
+        language=binding.get("xml:lang"),
+    )

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/wrapper/NeighborhoodWrapper.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Generator
+from graph_seeder.models.RDFNode import RDFNode
 from graph_seeder.utils.URIManager import URIManager
 
 
@@ -40,7 +41,7 @@ class NeighborhoodWrapper(ABC):
     @abstractmethod
     def get_neighborhood(
         self, nodes: list[str]
-    ) -> Generator[list[tuple[str, str, str]], None, None]:
+    ) -> Generator[list[tuple[RDFNode, RDFNode, RDFNode]], None, None]:
         """
         Yields the neighborhood of a list of nodes in batches.
         Allows the consumer to break the loop to stop early.

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/wrapper/hashmap/HashMapWrapper.py

@@ -1,6 +1,7 @@
 from collections.abc import Generator
 import lmdb
 import logging
+from graph_seeder.models.RDFNode import RDFNode
 from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 from graph_seeder.utils.URIManager import URIManager
 import json
@@ -48,8 +49,8 @@ class HashMapWrapper(NeighborhoodWrapper):
 
     def get_neighborhood(
         self, nodes: list[str]
-    ) -> Generator[list[tuple[str, str, str]], None, None]:
-        triplets: list[tuple[str, str, str]] = []
+    ) -> Generator[list[tuple[RDFNode, RDFNode, RDFNode]], None, None]:
+        triplets: list[tuple[RDFNode, RDFNode, RDFNode]] = []
         skipped_nodes: set[str] = set()
 
         with self.env.begin() as txn:
@@ -109,10 +110,21 @@ class HashMapWrapper(NeighborhoodWrapper):
                         ):
                             continue
 
+                        subj_node = RDFNode(original_node, "uri")
+                        pred_node = RDFNode(clean_prop, "uri")
+
+                        is_uri = neighbor.startswith("http") or (
+                            ":" in neighbor and " " not in neighbor
+                        )
+                        obj_type = "uri" if is_uri else "literal"
+                        obj_node = RDFNode(neighbor, obj_type)
+
                         if is_inverse:
-                            triplets.append((neighbor, clean_prop, original_node))
+                            inv_subj = RDFNode(neighbor, "uri")
+                            inv_obj = RDFNode(original_node, "uri")
+                            triplets.append((inv_subj, pred_node, inv_obj))
                         else:
-                            triplets.append((original_node, clean_prop, neighbor))
+                            triplets.append((subj_node, pred_node, obj_node))
 
         if triplets:
             yield triplets

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/wrapper/sparql/GraphWrapper.py

@@ -1,10 +1,11 @@
 from collections.abc import Generator
-
-from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 import logging
+from graph_seeder.models.RDFNode import RDFNode
+from graph_seeder.wrapper.NeighborhoodWrapper import NeighborhoodWrapper
 from graph_seeder.wrapper.sparql.SparqlQueryBuilder import SparqlQueryBuilder
-from graph_seeder.utils.URIManager import URIManager
 from graph_seeder.wrapper.sparql.BaseClient import BaseClient
+from graph_seeder.utils.URIManager import URIManager
+from graph_seeder.utils.utils import parse_node
 
 logger = logging.getLogger("subgraph")
 
@@ -135,7 +136,7 @@ class GraphWrapper(NeighborhoodWrapper):
 
     def get_neighborhood(
         self, nodes: list[str]
-    ) -> Generator[list[tuple[str, str, str]], None, None]:
+    ) -> Generator[list[tuple[RDFNode, RDFNode, RDFNode]], None, None]:
         """Fetch one-hop neighbors using property occurrence to decide strategy."""
         if not nodes:
             return None
@@ -178,9 +179,9 @@ class GraphWrapper(NeighborhoodWrapper):
                 ):
                     yield [
                         (
-                            r["subject"]["value"],
-                            r["property"]["value"],
-                            r["object"]["value"],
+                            parse_node(r["subject"]),
+                            parse_node(r["property"]),
+                            parse_node(r["object"]),
                         )
                         for r in raw_rows
                     ]
@@ -192,9 +193,9 @@ class GraphWrapper(NeighborhoodWrapper):
                     ):
                         yield [
                             (
-                                r["subject"]["value"],
-                                r["property"]["value"],
-                                r["object"]["value"],
+                                parse_node(r["subject"]),
+                                parse_node(r["property"]),
+                                parse_node(r["object"]),
                             )
                             for r in raw_rows
                         ]
@@ -212,16 +213,17 @@ class GraphWrapper(NeighborhoodWrapper):
         for raw_rows in self._execute_with_dichotomy(
             nodes, self.query_builder.build_prop_occurrence_query
         ):
-            all_stats.extend(
-                [
+            for r in raw_rows:
+                if not r or "entity" not in r:
+                    continue
+
+                all_stats.append(
                     (
                         r["entity"]["value"],
                         r["property"]["value"],
                         int(r["count"]["value"]),
                     )
-                    for r in raw_rows
-                ]
-            )
+                )
         return all_stats
 
     def _chunk_hub_properties(

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/src/graph_seeder/wrapper/sparql/client/TurtleClient.py

@@ -1,6 +1,7 @@
 import logging
 import rdflib
 from graph_seeder.wrapper.sparql.BaseClient import BaseClient
+import json
 
 logger = logging.getLogger("subgraph")
 
@@ -23,25 +24,19 @@ class TurtleClient(BaseClient):
         self.graph.parse(self.file_path, format="turtle")
         logger.info(f"Successfully loaded {len(self.graph)} triples.")
 
-        self.optimal_batch_size = 500
-
     def query(
         self, sparql_query: str, silent: bool = False, retries: int = None
     ) -> list[dict]:
         """Execute the SPARQL query on the local rdflib graph and format the output."""
         try:
             results = self.graph.query(sparql_query)
-            bindings = []
 
-            for row in results:
-                binding = {}
-                for var in results.vars:
-                    val = row[var]
-                    if val is not None:
-                        binding[str(var)] = {"value": str(val)}
-                bindings.append(binding)
+            json_bytes = results.serialize(format="json")
+
+            json_dict = json.loads(json_bytes)
+
+            return json_dict["results"]["bindings"]
 
-            return bindings
         except Exception as e:
             logger.error(f"Failed to execute local Turtle query: {e}")
             raise RuntimeError(f"Turtle query failed: {e}") from e

{graph_seeder-1.0.0.dev5 → graph_seeder-1.0.0.dev8}/uv.lock

@@ -147,7 +147,7 @@ wheels = [
 
 [[package]]
 name = "graph-seeder"
-version = "1.0.0.dev5"
+version = "1.0.0.dev8"
 source = { editable = "." }
 dependencies = [
     { name = "lmdb" },