naas-abi-core 1.4.1__py3-none-any.whl

naas_abi_core/utils/SPARQL.py

@@ -0,0 +1,256 @@
+from typing import Dict, List, Optional
+
+import rdflib
+from rdflib import DCTERMS, OWL, RDF, RDFS, XSD, Graph, URIRef, query
+
+from naas_abi_core import logger
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from naas_abi_core.utils.Graph import ABI, BFO, CCO, TEST
+
+
+class SPARQLUtils:
+    __triple_store_service: ITripleStoreService
+
+    def __init__(self, triple_store_service: ITripleStoreService):
+        self.__triple_store_service = triple_store_service
+
+    @property
+    def triple_store_service(self) -> ITripleStoreService:
+        return self.__triple_store_service
+
+    def results_to_list(self, results: rdflib.query.Result) -> Optional[List[Dict]]:
+        """
+        Transform SPARQL query results to a list of dictionaries using the labels as keys.
+
+        Args:
+            results (query.Result): The SPARQL query results to transform
+
+        Returns:
+            Optional[List[Dict]]: List of dictionaries with query results, or None if no results
+        """
+        data = []
+        for row in results:
+            assert isinstance(row, query.ResultRow)
+            logger.debug(f"==> Row: {row}")
+            data_dict = {}
+            for key in row.labels:
+                data_dict[key] = str(row[key]) if row[key] else None
+            data.append(data_dict)
+        return data if len(data) > 0 else None
+
+    def get_class_uri_from_individual_uri(
+        self,
+        uri: str | URIRef,
+    ) -> Optional[str]:
+        """
+        Get the class URI for a given individual URI from the triple store.
+
+        Args:
+            uri (str | URIRef): The individual URI to look up
+
+        Returns:
+            Optional[str]: The class URI if found, None otherwise
+        """
+        sparql_query = f"""
+            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX owl: <http://www.w3.org/2002/07/owl#>
+            SELECT ?type
+            WHERE {{
+                <{uri}> rdf:type ?type .
+                FILTER(?type != owl:NamedIndividual)
+            }}
+            LIMIT 1
+        """
+
+        try:
+            results = self.triple_store_service.query(sparql_query)
+            for row in results:
+                assert isinstance(row, query.ResultRow)
+                return URIRef(str(row.type))
+            return None
+        except Exception as e:
+            logger.error(f"Error getting class URI for {uri}: {e}")
+            return None
+
+    def get_rdfs_label_from_individual_uri(
+        self,
+        uri: str | URIRef,
+    ) -> Optional[str]:
+        """
+        Get the RDFS label for a given individual URI from the triple store.
+
+        Args:
+            uri (str | URIRef): The individual URI to look up
+
+        Returns:
+            Optional[str]: The RDFS label if found, None otherwise
+        """
+        sparql_query = f"""
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            SELECT ?label
+            WHERE {{
+                <{uri}> rdfs:label ?label .
+            }}
+            LIMIT 1
+        """
+
+        try:
+            results = self.triple_store_service.query(sparql_query)
+            for row in results:
+                assert isinstance(row, query.ResultRow)
+                return str(row.label)
+            return None
+        except Exception as e:
+            logger.error(f"Error getting label for {uri}: {e}")
+            return None
+
+    def get_identifier(
+        self,
+        identifier: str,
+        type: URIRef = URIRef("http://ontology.naas.ai/abi/unique_id"),
+        graph: Graph = Graph(),
+    ) -> Optional[URIRef]:
+        """
+        Get the URI for a given identifier from the triple store or provided graph.
+
+        Args:
+            identifier (str): The identifier string to look up
+            type (URIRef, optional): The predicate type to use for the lookup.
+                                    Defaults to "http://ontology.naas.ai/abi/unique_id"
+            graph (Graph, optional): Optional RDFlib Graph to query instead of triple store.
+                                Defaults to empty Graph.
+
+        Returns:
+            Optional[URIRef]: The URI if found, None otherwise
+        """
+        sparql_query = f"""
+            SELECT ?s
+            WHERE {{
+                ?s <{str(type)}> "{identifier}" .
+            }}
+            LIMIT 1
+        """
+        try:
+            if len(graph) > 0:
+                results = graph.query(sparql_query)
+            else:
+                results = self.query(sparql_query)  # type: ignore
+
+            for row in results:
+                assert isinstance(row, query.ResultRow)
+                # Use existing URI if found
+                return URIRef(str(row.s))
+        except Exception as e:
+            logger.error(f"Error getting identifier for {identifier}: {e}")
+            return None
+        return None
+
+    def get_identifiers(
+        self,
+        property_uri: URIRef = URIRef("http://ontology.naas.ai/abi/unique_id"),
+        class_uri: Optional[URIRef] = None,
+    ) -> dict[str, URIRef]:
+        """
+        Get a mapping of all identifiers to their URIs from the triple store.
+
+        Args:
+            property_uri (URIRef, optional): The predicate URI to use for the lookup.
+                                        Defaults to "http://ontology.naas.ai/abi/unique_id"
+            class_uri (URIRef, optional): Optional class URI to filter results.
+                                        Only return identifiers for instances of this class.
+                                        Defaults to None.
+
+        Returns:
+            dict[str, URIRef]: Dictionary mapping identifiers to their URIs
+        """
+        sparql_query = f"""
+            SELECT ?s ?id
+            WHERE {{
+                ?s <{str(property_uri)}> ?id .
+                {f"?s a <{str(class_uri)}> ." if class_uri else ""}
+            }}
+        """
+        try:
+            results = self.query(sparql_query)  # type: ignore
+
+            id_map = {}
+            for row in results:
+                assert isinstance(row, query.ResultRow)
+                id_map[str(row.id)] = URIRef(str(row.s))
+            return id_map
+        except Exception as e:
+            logger.error(f"Error getting identifiers map: {e}")
+            return {}
+
+    def get_subject_graph(self, uri: str | URIRef, depth: int = 1) -> Graph:
+        """
+        Get a graph for a given URI with a specified depth of relationships.
+        This recursively follows relationships to build a more detailed subgraph.
+        The resulting graph includes all triples where the given URI is the subject,
+        and optionally follows object URIs to include their relationships up to the specified depth.
+
+        Args:
+            uri (str | URIRef): The URI to build the graph around
+            depth (int): How many levels deep to traverse relationships. A depth of 0 returns an empty graph,
+                        1 returns direct relationships, 2 includes relationships of related objects, etc.
+                        Defaults to 1.
+
+        Returns:
+            Graph: RDFlib Graph containing all triples within the specified depth, with standard namespace
+                prefixes bound (rdfs, rdf, owl, xsd, dcterms, abi, bfo, cco, test)
+        """
+        if depth <= 0:
+            return Graph()
+
+        # Build the CONSTRUCT query dynamically based on depth
+        construct_clauses = []
+        where_clauses = []
+
+        # Add patterns for each depth level
+        for i in range(depth):
+            if i == 0:
+                construct_clauses.append(f"<{str(uri)}> ?p{i} ?o{i} .")
+                where_clauses.append(f"<{str(uri)}> ?p{i} ?o{i} .")
+            else:
+                construct_clauses.append(f"?o{i - 1} ?p{i} ?o{i} .")
+                where_clauses.append(
+                    f"OPTIONAL {{ ?o{i - 1} ?p{i} ?o{i} . FILTER(isURI(?o{i - 1})) }}"
+                )
+
+        sparql_query = f"""
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX owl: <http://www.w3.org/2002/07/owl#>
+            PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+            PREFIX dcterms: <http://purl.org/dc/terms/>
+            PREFIX abi: <http://ontology.naas.ai/abi/>
+            PREFIX bfo: <http://purl.obolibrary.org/obo/>
+            PREFIX cco: <https://www.commoncoreontologies.org/>
+            CONSTRUCT {{ 
+                {" ".join(construct_clauses)}
+            }}
+            WHERE {{
+                {" ".join(where_clauses)}
+            }}
+        """
+        try:
+            results = self.triple_store_service.query(sparql_query)
+        except Exception as e:
+            logger.error(f"Error getting subject graph for {uri}: {e}")
+            return Graph()
+
+        graph = Graph()
+        graph.bind("rdfs", RDFS)
+        graph.bind("rdf", RDF)
+        graph.bind("owl", OWL)
+        graph.bind("xsd", XSD)
+        graph.bind("dcterms", DCTERMS)
+        graph.bind("abi", ABI)
+        graph.bind("bfo", BFO)
+        graph.bind("cco", CCO)
+        graph.bind("test", TEST)
+        for triple in results:
+            # CONSTRUCT queries return triples directly, no need for ResultRow handling
+            graph.add(triple)  # type: ignore
+
+        return graph

naas_abi_core/utils/Storage.py

@@ -0,0 +1,33 @@
+import os
+
+class NoStorageFolderFound(Exception):
+    pass
+
+# Look for a "storage" folder until we reach /
+def find_storage_folder(base_path: str, needle: str = "storage") -> str:
+    if os.path.exists(os.path.join(base_path, needle)):
+        return os.path.join(base_path, needle)
+
+    if base_path == "/":
+        raise NoStorageFolderFound("No storage folder found")
+
+    return find_storage_folder(os.path.dirname(base_path))
+
+def ensure_data_directory(module_name: str, component: str) -> str:
+    """
+    Ensures the data directory exists for a module component following Code-Data Symmetry.
+    
+    Args:
+        module_name: Name of the module (e.g., "__demo__", "your_module")
+        component: Component type (e.g., "orchestration", "pipelines", "workflows")
+    
+    Returns:
+        str: The absolute path to the created directory
+    
+    Example:
+        data_dir = ensure_data_directory("__demo__", "orchestration")
+        # Returns: /path/to/project/storage/datastore/core/modules/__demo__/orchestration
+    """
+    data_dir = os.path.join("storage", "datastore", "core", "modules", module_name, component)
+    os.makedirs(data_dir, exist_ok=True)
+    return os.path.abspath(data_dir)

naas_abi_core/utils/StorageUtils.py

@@ -0,0 +1,398 @@
+import json
+from datetime import datetime
+from io import BytesIO
+from typing import Dict, Tuple
+
+import pandas as pd
+import yaml
+from rdflib import Graph
+
+from naas_abi_core import logger
+from naas_abi_core.services.object_storage.ObjectStoragePort import IObjectStorageDomain
+
+
+class StorageUtils:
+    __storage_service: IObjectStorageDomain
+
+    def __init__(self, storage_service: IObjectStorageDomain):
+        self.__storage_service = storage_service
+
+    def __make_copy(
+        self, dir_path: str, file_name: str, content: bytes
+    ) -> Tuple[str, str]:
+        """
+        Make a copy of a file in storage with timestamp in the name.
+        """
+        try:
+            file_name = f"{datetime.now().strftime('%Y%m%dT%H%M%S')}_{file_name}"
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=content
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error making copy in {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_text(
+        self, dir_path: str, file_name: str, encoding: str = "utf-8"
+    ) -> str | None:
+        """
+        Get a text file from storage.
+        """
+        try:
+            content = self.__storage_service.get_object(dir_path, file_name)
+            return content.decode(encoding)
+        except Exception as e:
+            logger.warning(f"Error getting text from {dir_path}: {e}")
+            return None
+
+    def save_text(
+        self,
+        text: str,
+        dir_path: str,
+        file_name: str,
+        encoding: str = "utf-8",
+        copy: bool = True,
+    ) -> Tuple[str, str]:
+        """
+        Save a text file to storage.
+        """
+        try:
+            content = text.encode(encoding)
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=content
+            )
+            if copy:
+                self.__make_copy(dir_path, file_name, content)
+            logger.debug(
+                f"[save_text] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving text to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_image(self, dir_path: str, file_name: str) -> bytes | None:
+        """
+        Get an image from storage.
+        """
+        try:
+            return self.__storage_service.get_object(dir_path, file_name)
+        except Exception as e:
+            logger.warning(f"Error getting image from {dir_path}: {e}")
+            return None
+
+    def save_image(
+        self, image: bytes, dir_path: str, file_name: str, copy: bool = True
+    ) -> Tuple[str, str]:
+        """
+        Save an image to storage.
+        """
+        try:
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=image
+            )
+            if copy:
+                self.__make_copy(dir_path, file_name, image)
+            logger.debug(
+                f"[save_image] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving image to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_csv(
+        self,
+        dir_path: str,
+        file_name: str,
+        sep: str = ";",
+        decimal: str = ",",
+        encoding: str = "utf-8",
+    ) -> pd.DataFrame:
+        """
+        Get a CSV file from storage.
+        """
+        try:
+            file_content = self.__storage_service.get_object(dir_path, file_name)
+            # Create a BytesIO object to avoid file name length issues
+            from io import BytesIO
+
+            csv_buffer = BytesIO(file_content)
+            return pd.read_csv(csv_buffer, sep=sep, decimal=decimal, encoding=encoding)
+        except Exception as e:
+            logger.warning(f"Error getting CSV file from {dir_path}: {e}")
+            return pd.DataFrame()
+
+    def save_csv(
+        self,
+        data: pd.DataFrame,
+        dir_path: str,
+        file_name: str,
+        sep: str = ";",
+        decimal: str = ",",
+        encoding: str = "utf-8",
+        copy: bool = True,
+    ) -> Tuple[str, str]:
+        """
+        Save a CSV file to storage.
+        """
+        try:
+            self.__storage_service.put_object(
+                prefix=dir_path,
+                key=file_name,
+                content=data.to_csv(
+                    index=False, encoding=encoding, sep=sep, decimal=decimal
+                ).encode(encoding),
+            )
+            if copy:
+                self.__make_copy(
+                    dir_path,
+                    file_name,
+                    data.to_csv(
+                        index=False, encoding=encoding, sep=sep, decimal=decimal
+                    ).encode(encoding),
+                )
+            logger.debug(
+                f"[save_csv] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving CSV file to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_excel(
+        self,
+        dir_path: str,
+        file_name: str,
+        sheet_name: str,
+        skiprows: int = 0,
+        usecols: list | None = None,
+    ) -> pd.DataFrame:
+        """
+        Get an Excel file from storage.
+        """
+        try:
+            file_content = BytesIO(
+                self.__storage_service.get_object(dir_path, file_name)
+            )
+            return pd.read_excel(
+                file_content, sheet_name=sheet_name, skiprows=skiprows, usecols=usecols
+            )
+        except Exception as e:
+            logger.warning(f"Error getting Excel file from {dir_path}: {e}")
+            return pd.DataFrame()
+
+    def save_excel(
+        self,
+        data: pd.DataFrame,
+        dir_path: str,
+        file_name: str,
+        sheet_name: str,
+        copy: bool = True,
+    ) -> Tuple[str, str]:
+        """
+        Save an Excel file to storage.
+        """
+        try:
+            excel_buffer = BytesIO()
+            data.to_excel(excel_buffer, index=False, sheet_name=sheet_name)
+            excel_buffer.seek(0)
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=excel_buffer.getvalue()
+            )
+            if copy:
+                self.__make_copy(dir_path, file_name, excel_buffer.getvalue())
+            logger.debug(
+                f"[save_excel] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving Excel file to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_json(self, dir_path: str, file_name: str) -> Dict:
+        """
+        Get JSON data from storage.
+        """
+        try:
+            file_content = self.__storage_service.get_object(
+                dir_path, file_name
+            ).decode("utf-8")
+            data = json.loads(file_content)
+            return data
+        except Exception as e:
+            logger.warning(f"Error getting JSON data from {dir_path}: {e}")
+            return {}
+
+    def save_json(
+        self, data: dict | list, dir_path: str, file_name: str, copy: bool = True
+    ) -> Tuple[str, str]:
+        """
+        Save JSON data to storage.
+        """
+        try:
+            self.__storage_service.put_object(
+                prefix=dir_path,
+                key=file_name,
+                content=json.dumps(data, indent=4, ensure_ascii=False).encode("utf-8"),
+            )
+            if copy:
+                # Only create a timestamped copy in storage, not local filesystem
+                self.__make_copy(
+                    dir_path,
+                    file_name,
+                    json.dumps(data, indent=4, ensure_ascii=False).encode("utf-8"),
+                )
+            logger.debug(
+                f"[save_json] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving JSON data to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_yaml(self, dir_path: str, file_name: str) -> Dict:
+        """
+        Get YAML data from storage.
+        """
+        try:
+            file_content = self.__storage_service.get_object(
+                dir_path, file_name
+            ).decode("utf-8")
+            data = yaml.safe_load(file_content)
+            return data if data is not None else {}
+        except Exception as e:
+            logger.debug(f"Error getting YAML data from {dir_path}: {e}")
+            return {}
+
+    def save_yaml(
+        self, data: dict | list, dir_path: str, file_name: str, copy: bool = True
+    ) -> Tuple[str, str]:
+        """
+        Save YAML data to storage.
+        """
+        try:
+            self.__storage_service.put_object(
+                prefix=dir_path,
+                key=file_name,
+                content=yaml.dump(
+                    data, default_flow_style=False, allow_unicode=True, sort_keys=False
+                ).encode("utf-8"),
+            )
+            if copy:
+                self.__make_copy(
+                    dir_path,
+                    file_name,
+                    yaml.dump(
+                        data,
+                        default_flow_style=False,
+                        allow_unicode=True,
+                        sort_keys=False,
+                    ).encode("utf-8"),
+                )
+            logger.debug(
+                f"[save_yaml] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving YAML data to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_triples(
+        self, dir_path: str, file_name: str, format: str = "turtle"
+    ) -> Graph:
+        """
+        Get Turtle data from storage and return as RDFlib Graph.
+        """
+        try:
+            file_content = self.__storage_service.get_object(
+                dir_path, file_name
+            ).decode("utf-8")
+            graph = Graph()
+            graph.parse(data=file_content, format=format)
+            return graph
+        except Exception as e:
+            logger.warning(f"Error getting triples from {dir_path}: {e}")
+            return Graph()
+
+    def save_triples(
+        self,
+        graph: Graph,
+        dir_path: str,
+        file_name: str,
+        format: str = "turtle",
+        copy: bool = True,
+    ) -> Tuple[str, str]:
+        """
+        Save RDFlib Graph data to storage in Turtle format.
+        """
+        try:
+            turtle_content = graph.serialize(format=format, sort=False)
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=turtle_content.encode("utf-8")
+            )
+            if copy:
+                self.__make_copy(dir_path, file_name, turtle_content.encode("utf-8"))
+            logger.debug(
+                f"[save_triples] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving triples to {dir_path}: {e}")
+            return dir_path, file_name
+
+    def get_powerpoint_presentation(self, dir_path: str, file_name: str) -> BytesIO:
+        """
+        Get a PowerPoint presentation from storage.
+
+        Args:
+            output_dir: The directory where the presentation is stored.
+            file_name: The name of the presentation file.
+
+        Returns:
+            BytesIO: A BytesIO object containing the presentation data.
+        """
+        try:
+            data = self.__storage_service.get_object(dir_path, file_name)
+            byte_stream = BytesIO(data)
+            byte_stream.seek(0)
+            return byte_stream
+        except Exception as e:
+            logger.warning(
+                f"Error getting PowerPoint presentation from {dir_path}: {e}"
+            )
+            return BytesIO()
+
+    def save_powerpoint_presentation(
+        self, presentation, dir_path: str, file_name: str, copy: bool = True
+    ) -> Tuple[str, str]:
+        """
+        Save a PowerPoint presentation to a file and create an asset in Naas.
+
+        Args:
+            presentation: The presentation to save.
+            output_dir: The directory to save the presentation to.
+            file_name: The name of the file to save the presentation to.
+            naas_integration: The Naas integration to use to create the asset.
+
+        Returns:
+            str: The URL of the asset.
+        """
+        try:
+            # Create byte stream
+            byte_stream = BytesIO()
+            presentation.save(byte_stream)
+            byte_stream.seek(0)
+            self.__storage_service.put_object(
+                prefix=dir_path, key=file_name, content=byte_stream.getvalue()
+            )
+            if copy:
+                self.__make_copy(dir_path, file_name, byte_stream.getvalue())
+            logger.debug(
+                f"[save_powerpoint_presentation] File successfully written to storage: {dir_path}/{file_name}"
+            )
+            return dir_path, file_name
+        except Exception as e:
+            logger.error(f"Error saving PowerPoint presentation to {dir_path}: {e}")
+            return dir_path, file_name