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

naas_abi_core/services/secret/adaptors/secondary/Base64Secret.py

@@ -0,0 +1,57 @@
+import base64
+from io import StringIO
+from typing import Any, Dict
+
+from dotenv import dotenv_values
+from naas_abi_core.services.secret.SecretPorts import ISecretAdapter
+
+
+class Base64Secret(ISecretAdapter):
+    def __init__(self, secret_adapter: ISecretAdapter, base64_secret_key: str):
+        self.secret_adapter = secret_adapter
+        self.base64_secret_key = base64_secret_key
+
+    def __get_base64_secret(self) -> str:
+        return str(self.secret_adapter.get(self.base64_secret_key, ""))
+
+    def __get_decoded_secrets(self) -> Dict[str, str | None]:
+        base64_secret = self.__get_base64_secret()
+
+        if base64_secret == "":
+            return {}
+
+        base64_secret_content = base64.b64decode(base64_secret).decode("utf-8")
+        decoded_secrets = dotenv_values(stream=StringIO(base64_secret_content))
+
+        for key, value in decoded_secrets.items():
+            decoded_secrets[key] = str(value)
+
+        return decoded_secrets
+
+    def __encode_secrets(self, secrets: Dict[str, str | None]) -> str:
+        secret_string = ""
+        for key, value in secrets.items():
+            secret_string += f'{key}="{value}"\n'
+        return base64.b64encode(secret_string.encode("utf-8")).decode("utf-8")
+
+    def get(self, key: str, default: Any = None) -> str | Any | None:
+        return self.__get_decoded_secrets().get(key, default)
+
+    def set(self, key: str, value: str):
+        decoded_secrets = self.__get_decoded_secrets()
+
+        decoded_secrets[str(key)] = str(value)
+
+        self.secret_adapter.set(
+            self.base64_secret_key, self.__encode_secrets(decoded_secrets)
+        )
+
+    def remove(self, key: str):
+        decoded_secrets = self.__get_decoded_secrets()
+        decoded_secrets.pop(str(key), None)
+        self.secret_adapter.set(
+            self.base64_secret_key, self.__encode_secrets(decoded_secrets)
+        )
+
+    def list(self) -> Dict[str, str | None]:
+        return self.__get_decoded_secrets()

naas_abi_core/services/secret/adaptors/secondary/Base64Secret_test.py

@@ -0,0 +1,39 @@
+import os
+import uuid
+
+import pytest
+from dotenv import load_dotenv
+
+
+@pytest.fixture
+def base64_secret_naas():
+    from naas_abi_core.services.secret.adaptors.secondary.Base64Secret import (
+        Base64Secret,
+    )
+    from naas_abi_core.services.secret.adaptors.secondary.NaasSecret import NaasSecret
+
+    load_dotenv()
+
+    naas_api_key = os.getenv("NAAS_API_KEY")
+    if naas_api_key is None:
+        pytest.skip("NAAS_API_KEY is not set")
+
+    naas_secret = NaasSecret(naas_api_key, os.getenv("NAAS_API_URL"))
+    base64_secret_key = str(uuid.uuid4())
+    return Base64Secret(naas_secret, base64_secret_key), naas_secret, base64_secret_key
+
+
+def test_base64_secret(base64_secret_naas):
+    base64_secret_naas, naas_secret, base64_secret_key = base64_secret_naas
+    base64_secret_naas.set("test", "test")
+    assert base64_secret_naas.get("test") == "test"
+    assert base64_secret_naas.list() == {"test": "test"}
+    base64_secret_naas.remove("test")
+    assert base64_secret_naas.get("test") is None
+    assert base64_secret_naas.list() == {}
+    base64_secret_naas.set("test", "test")
+    assert base64_secret_naas.get("test") == "test"
+    assert base64_secret_naas.list() == {"test": "test"}
+    base64_secret_naas.remove("test")
+
+    naas_secret.remove(base64_secret_key)

naas_abi_core/services/secret/adaptors/secondary/NaasSecret.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict
+
+import requests
+from naas_abi_core import logger
+from naas_abi_core.services.secret.SecretPorts import (
+    ISecretAdapter,
+    SecretAuthenticationError,
+)
+
+NAAS_API_URL = "https://api.naas.ai"
+
+
+class NaasSecret(ISecretAdapter):
+    def __init__(self, naas_api_key: str, naas_api_url: str | None = None):
+        self.naas_api_key = naas_api_key
+
+        if naas_api_url is None:
+            self.naas_api_url = NAAS_API_URL
+        else:
+            self.naas_api_url = naas_api_url
+
+    def get(self, key: str, default: Any = None) -> str | Any | None:
+        response = requests.get(
+            f"{self.naas_api_url}/secret/{key}",
+            headers={"Authorization": f"Bearer {self.naas_api_key}"},
+        )
+        try:
+            response.raise_for_status()
+            return str(response.json()["secret"]["value"])
+        except requests.exceptions.HTTPError as _:
+            if response.status_code == 404:
+                logger.debug(f"Secret {key} not found")
+            elif response.status_code == 401:
+                error_message = f"Authentication error on '{NAAS_API_URL}' with NAAS_API_KEY '{self.naas_api_key}'"
+                logger.error(error_message)
+                raise SecretAuthenticationError(error_message)
+            else:
+                logger.error(f"Error getting secret {key}: {response.status_code}")
+            return default
+
+    def set(self, key: str, value: str):
+        response = requests.post(
+            f"{self.naas_api_url}/secret/",
+            headers={"Authorization": f"Bearer {self.naas_api_key}"},
+            json={"secret": {"name": key, "value": value}},
+        )
+
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as _:
+            logger.error(f"Error setting secret {key}: {response.status_code}")
+            return
+
+    def remove(self, key: str):
+        response = requests.delete(
+            f"{self.naas_api_url}/secret/{key}",
+            headers={"Authorization": f"Bearer {self.naas_api_key}"},
+        )
+
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as _:
+            logger.error(f"Error removing secret {key}: {response.status_code}")
+            return
+
+    def list(self) -> Dict[str, str | None]:
+        response = requests.get(
+            f"{self.naas_api_url}/secret/",
+            headers={"Authorization": f"Bearer {self.naas_api_key}"},
+            json={
+                "page_size": 1000,
+                "page_number": 1,
+            },
+        )
+
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as _:
+            if response.status_code == 404:
+                logger.debug("No secrets found or workspace not accessible")
+            else:
+                logger.error(f"Error listing secrets: {response.status_code}")
+            return {}
+
+        return {
+            str(secret["name"]): str(secret["value"])
+            for secret in response.json()["secrets"]
+        }

naas_abi_core/services/secret/adaptors/secondary/NaasSecret_test.py

@@ -0,0 +1,25 @@
+import pytest
+
+
+@pytest.fixture
+def naas_secret():
+    import os
+
+    from dotenv import load_dotenv
+    from naas_abi_core.services.secret.adaptors.secondary.NaasSecret import NaasSecret
+
+    load_dotenv()
+
+    naas_api_key = os.getenv("NAAS_API_KEY")
+    if naas_api_key is None:
+        pytest.skip("NAAS_API_KEY is not set")
+
+    return NaasSecret(naas_api_key, os.getenv("NAAS_API_URL"))
+
+
+def test_naas_secret(naas_secret):
+    naas_secret.set("test", "test")
+    assert naas_secret.get("test") == "test"
+    assert "test" in naas_secret.list()
+    naas_secret.remove("test")
+    assert naas_secret.get("test") is None

naas_abi_core/services/secret/adaptors/secondary/dotenv_secret_secondaryadaptor.py

@@ -0,0 +1,29 @@
+import os
+from typing import Any, Dict
+
+from dotenv import dotenv_values, find_dotenv, set_key
+from naas_abi_core.services.secret.SecretPorts import ISecretAdapter
+from naas_abi_core.utils.Logger import logger
+
+
+class DotenvSecretSecondaryAdaptor(ISecretAdapter):
+    def __init__(self):
+        logger.debug(f"dotenv is using the file: {find_dotenv()}")
+
+        self.secrets = dotenv_values()
+
+    def get(self, key: str, default: Any = None) -> str:
+        return self.secrets.get(key, os.environ.get(key, default))
+
+    def set(self, key: str, value: str):
+        os.environ[key] = value
+        set_key(".env", key, value)
+
+    def remove(self, key: str):
+        os.environ.pop(key, None)
+
+    def list(self) -> Dict[str, str | None]:
+        secrets: Dict[str, str | None] = {}
+        for key in self.secrets.keys():
+            secrets[str(key)] = str(self.secrets.get(key))
+        return secrets

naas_abi_core/services/triple_store/TripleStoreFactory.py

@@ -0,0 +1,116 @@
+import os
+
+from naas_abi_core.services.object_storage.ObjectStorageFactory import (
+    ObjectStorageFactory,
+)
+from naas_abi_core.services.triple_store.adaptors.secondary.AWSNeptune import (
+    AWSNeptuneSSHTunnel,
+)
+from naas_abi_core.services.triple_store.adaptors.secondary.Oxigraph import Oxigraph
+from naas_abi_core.services.triple_store.adaptors.secondary.TripleStoreService__SecondaryAdaptor__Filesystem import (
+    TripleStoreService__SecondaryAdaptor__Filesystem,
+)
+from naas_abi_core.services.triple_store.adaptors.secondary.TripleStoreService__SecondaryAdaptor__ObjectStorage import (
+    TripleStoreService__SecondaryAdaptor__ObjectStorage,
+)
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+
+
+class TripleStoreFactory:
+    @staticmethod
+    def TripleStoreServiceNaas(
+        naas_api_key: str,
+        workspace_id: str,
+        storage_name: str,
+        base_prefix: str = "ontologies",
+    ) -> TripleStoreService:
+        """Creates an TripleStoreService using Naas object storage.
+
+        Args:
+            naas_api_key (str): API key for Naas service
+            workspace_id (str): Workspace ID for Naas storage
+            storage_name (str): Name of storage to use
+            base_prefix (str): Base prefix for object paths. Defaults to "ontologies"
+
+        Returns:
+            TripleStoreService: Configured ontology store service using Naas storage
+        """
+        object_service = ObjectStorageFactory.ObjectStorageServiceNaas(
+            naas_api_key=naas_api_key,
+            workspace_id=workspace_id,
+            storage_name=storage_name,
+            base_prefix=base_prefix,
+        )
+        return TripleStoreService(
+            TripleStoreService__SecondaryAdaptor__ObjectStorage(object_service)
+        )
+
+    @staticmethod
+    def TripleStoreServiceFilesystem(path: str) -> TripleStoreService:
+        return TripleStoreService(
+            TripleStoreService__SecondaryAdaptor__Filesystem(path)
+        )
+
+    @staticmethod
+    def TripleStoreServiceAWSNeptuneSSHTunnel(
+        aws_region_name: str | None = None,
+        aws_access_key_id: str | None = None,
+        aws_secret_access_key: str | None = None,
+        db_instance_identifier: str | None = None,
+        bastion_host: str | None = None,
+        bastion_port: int | None = None,
+        bastion_user: str | None = None,
+        bastion_private_key: str | None = None,
+    ) -> TripleStoreService:
+        aws_region_name = os.environ.get("AWS_REGION")
+        aws_access_key_id = os.environ.get("AWS_ACCESS_KEY_ID")
+        aws_secret_access_key = os.environ.get("AWS_SECRET_ACCESS_KEY")
+        db_instance_identifier = os.environ.get("AWS_NEPTUNE_DB_INSTANCE_IDENTIFIER")
+        bastion_host = os.environ.get("AWS_BASTION_HOST")
+        bastion_port = int(os.environ.get("AWS_BASTION_PORT", -42))
+        bastion_user = os.environ.get("AWS_BASTION_USER")
+        bastion_private_key = os.environ.get("AWS_BASTION_PRIVATE_KEY")
+
+        assert aws_region_name is not None
+        assert aws_access_key_id is not None
+        assert aws_secret_access_key is not None
+        assert db_instance_identifier is not None
+        assert bastion_host is not None
+        assert bastion_port is not None and bastion_port != -42
+        assert bastion_user is not None
+        assert bastion_private_key is not None
+
+        return TripleStoreService(
+            AWSNeptuneSSHTunnel(
+                aws_region_name=aws_region_name,
+                aws_access_key_id=aws_access_key_id,
+                aws_secret_access_key=aws_secret_access_key,
+                db_instance_identifier=db_instance_identifier,
+                bastion_host=bastion_host,
+                bastion_port=bastion_port,
+                bastion_user=bastion_user,
+                bastion_private_key=bastion_private_key,
+            )
+        )
+
+    @staticmethod
+    def TripleStoreServiceOxigraph(
+        oxigraph_url: str | None = None,
+    ) -> TripleStoreService:
+        """Creates a TripleStoreService using Oxigraph.
+
+        Args:
+            oxigraph_url (str, optional): URL of the Oxigraph instance.
+                Defaults to OXIGRAPH_URL env var or http://localhost:7878
+
+        Returns:
+            TripleStoreService: Configured triple store service using Oxigraph
+        """
+        if oxigraph_url is None:
+            oxigraph_url = os.environ.get("OXIGRAPH_URL", "http://localhost:7878")
+
+        return TripleStoreService(
+            Oxigraph(
+                oxigraph_url=oxigraph_url,
+            )
+        )

naas_abi_core/services/triple_store/TripleStorePorts.py

@@ -0,0 +1,223 @@
+from abc import ABC, abstractmethod
+from rdflib import Graph, URIRef
+import rdflib
+from typing import List, Callable, Dict, Tuple
+from enum import Enum
+
+
+class Exceptions:
+    class SubjectNotFoundError(Exception):
+        pass
+
+    class SubscriptionNotFoundError(Exception):
+        pass
+
+    class ViewNotFoundError(Exception):
+        pass
+
+
+class OntologyEvent(Enum):
+    INSERT = "INSERT"
+    DELETE = "DELETE"
+
+
+class ITripleStorePort(ABC):
+    @abstractmethod
+    def insert(self, triples: Graph):
+        pass
+
+    @abstractmethod
+    def remove(self, triples: Graph):
+        pass
+
+    @abstractmethod
+    def get(self) -> Graph:
+        pass
+
+    @abstractmethod
+    def handle_view_event(
+        self,
+        view: Tuple[URIRef | None, URIRef | None, URIRef | None],
+        event: OntologyEvent,
+        triple: Tuple[URIRef | None, URIRef | None, URIRef | None],
+    ):
+        pass
+
+    @abstractmethod
+    def query(self, query: str) -> rdflib.query.Result:
+        pass
+
+    @abstractmethod
+    def query_view(self, view: str, query: str) -> rdflib.query.Result:
+        pass
+
+    @abstractmethod
+    def get_subject_graph(self, subject: URIRef) -> Graph:
+        pass
+
+
+class ITripleStoreService(ABC):
+    __ontology_adaptor: ITripleStorePort
+
+    __event_listeners: Dict[
+        tuple, Dict[OntologyEvent, List[tuple[str, Callable, bool]]]
+    ]
+
+    __views: List[Tuple[URIRef | None, URIRef | None, URIRef | None]]
+
+    @abstractmethod
+    def subscribe(
+        self, topic: tuple, event_type: OntologyEvent, callback: Callable
+    ) -> str:
+        """Subscribe to events for a specific topic pattern.
+
+        This method allows subscribing to INSERT or DELETE events that match a specific subject-predicate-object
+        pattern. When matching triples are inserted or deleted, the provided callback will be executed.
+
+        Args:
+            topic (tuple): A (subject, predicate, object) tuple specifying the pattern to match.
+                Each element can be None to match any value in that position.
+            event_type (OntologyEvent): The type of event to subscribe to (INSERT or DELETE)
+            callback (Callable): Function to call when matching events occur. Will be called with:
+                - event_type: The OntologyEvent that occurred
+                - triple: The (subject, predicate, object) triple that matched
+
+        Returns:
+            str: A unique subscription ID that can be used to unsubscribe later
+        """
+        pass
+
+    @abstractmethod
+    def unsubscribe(self, subscription_id: str):
+        """Unsubscribe from events using a subscription ID.
+
+        This method removes a subscription based on its ID, stopping any further callbacks
+        for that subscription.
+
+        Args:
+            subscription_id (str): The subscription ID returned from a previous subscribe() call
+
+        Raises:
+            SubscriptionNotFoundError: If no subscription exists with the provided ID
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def insert(self, triples: Graph):
+        """Insert triples from the provided graph into the store.
+
+        This method takes a graph of triples and inserts them into the triple store. The triples
+        are partitioned and stored by subject to enable efficient subject-based querying.
+
+        Args:
+            triples (Graph): The RDF graph containing triples to insert
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def remove(self, triples: Graph):
+        """Remove triples from the provided graph from the store.
+
+        This method takes a graph of triples and removes them from the triple store. The triples
+        are matched against existing triples and removed where matches are found.
+
+        Args:
+            triples (Graph): The RDF graph containing triples to remove
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def get(self) -> Graph:
+        """Get the complete RDF graph from the triple store.
+
+        This method retrieves and returns the full RDF graph containing all triples
+        stored in the triple store.
+
+        Returns:
+            Graph: The complete RDF graph containing all stored triples
+        """
+        pass
+
+    @abstractmethod
+    def query(self, query: str) -> rdflib.query.Result:
+        """Execute a SPARQL query against the triple store.
+
+        This method executes the provided SPARQL query string against all triples in the store
+        and returns the results as a new RDF graph.
+
+        Args:
+            query (str): The SPARQL query string to execute against the triple store
+
+        Returns:
+            Graph: A new RDF graph containing the query results
+
+        Example:
+            >>> store.query("SELECT ?s WHERE { ?s a owl:Class }")
+        """
+        pass
+
+    @abstractmethod
+    def query_view(self, view: str, query: str) -> rdflib.query.Result:
+        pass
+
+    @abstractmethod
+    def get_subject_graph(self, subject: str) -> Graph:
+        """Get the RDF graph containing all triples for a specific subject.
+
+        This method retrieves and returns an RDFlib Graph containing all triples
+        that have the specified subject.
+
+        Args:
+            subject (str): The subject to retrieve triples for
+
+        Returns:
+            Graph: An RDFlib Graph containing all triples for the specified subject
+
+        Raises:
+            SubjectNotFoundError: If no triples exist with the specified subject
+        """
+        pass
+
+    @abstractmethod
+    def load_schema(self, filepath: str):
+        """Load an RDF/OWL schema file into the triple store.
+
+        This method takes a file path string pointing to an RDF/OWL schema file,
+        loads it into an RDFlib Graph, and inserts all schema triples into the triple store.
+        The schema defines the ontology structure including classes, properties and restrictions.
+
+        Args:
+            filepath (str): Path to the RDF/OWL schema file to load
+
+        Returns:
+            None
+
+        Example:
+            >>> store.load_schema("path/to/schema.ttl")
+        """
+        pass
+
+    @abstractmethod
+    def get_schema_graph(self) -> Graph:
+        """Get the RDF graph containing just the schema/ontology triples.
+
+        This method returns an RDFlib Graph containing only the schema/ontology triples
+        that define classes, properties, and other structural elements. It excludes
+        instance data triples.
+
+        Returns:
+            Graph: An RDF graph containing only the schema/ontology triples
+
+        Example:
+            >>> schema = store.get_schema_graph()
+        """
+        pass