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

naas_abi_core/engine/engine_configuration/EngineConfiguration_TripleStoreService.py

@@ -0,0 +1,224 @@
+from typing import TYPE_CHECKING, Literal, Union
+
+from naas_abi_core.engine.engine_configuration.EngineConfiguration_GenericLoader import (
+    GenericLoader,
+)
+from naas_abi_core.engine.engine_configuration.EngineConfiguration_ObjectStorageService import (
+    ObjectStorageServiceConfiguration,
+)
+from naas_abi_core.engine.engine_configuration.utils.PydanticModelValidator import (
+    pydantic_model_validator,
+)
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStorePort
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+from pydantic import BaseModel, model_validator
+from typing_extensions import Self
+
+# Only import for type checking, not at runtime
+if TYPE_CHECKING:
+    pass
+
+
+class OxigraphAdapterConfiguration(BaseModel):
+    """Oxigraph adapter configuration.
+
+    triple_store_adapter:
+      adapter: "oxigraph"
+      config:
+        oxigraph_url: "http://localhost:7878"
+        timeout: 60
+    """
+
+    oxigraph_url: str = "http://localhost:7878"
+    timeout: int = 60
+
+
+class AWSNeptuneAdapterConfiguration(BaseModel):
+    """AWS Neptune adapter configuration.
+
+    triple_store_adapter:
+      adapter: "aws_neptune"
+      config:
+        aws_region_name: "{{ secret.AWS_REGION }}"
+        aws_access_key_id: "{{ secret.AWS_ACCESS_KEY_ID }}"
+        aws_secret_access_key: "{{ secret.AWS_SECRET_ACCESS_KEY }}"
+        db_instance_identifier: "{{ secret.AWS_NEPTUNE_DB_INSTANCE_IDENTIFIER }}"
+    """
+
+    aws_region_name: str
+    aws_access_key_id: str
+    aws_secret_access_key: str
+    db_instance_identifier: str
+
+
+class AWSNeptuneSSHTunnelAdapterConfiguration(AWSNeptuneAdapterConfiguration):
+    """AWS Neptune SSH tunnel adapter configuration.
+
+    triple_store_adapter:
+      adapter: "aws_neptune_sshtunnel"
+      config:
+        aws_region_name: "{{ secret.AWS_REGION }}"
+        aws_access_key_id: "{{ secret.AWS_ACCESS_KEY_ID }}"
+        aws_secret_access_key: "{{ secret.AWS_SECRET_ACCESS_KEY }}"
+        db_instance_identifier: "{{ secret.AWS_NEPTUNE_DB_INSTANCE_IDENTIFIER }}"
+        bastion_host: "{{ secret.AWS_BASTION_HOST }}"
+        bastion_port: "{{ secret.AWS_BASTION_PORT }}"
+        bastion_user: "{{ secret.AWS_BASTION_USER }}"
+        bastion_private_key: "{{ secret.AWS_BASTION_PRIVATE_KEY }}"
+    """
+
+    bastion_host: str
+    bastion_port: int
+    bastion_user: str
+    bastion_private_key: str
+
+
+class TripleStoreAdapterFilesystemConfiguration(BaseModel):
+    """Filesystem adapter configuration.
+
+    triple_store_adapter:
+      adapter: "fs"
+      config:
+        store_path: "storage/triplestore"
+        triples_path: "triples"
+    """
+
+    store_path: str
+    triples_path: str = "triples"
+
+
+class TripleStoreAdapterObjectStorageConfiguration(BaseModel):
+    """Object storage adapter configuration.
+
+    triple_store_adapter:
+      adapter: "object_storage"
+      config:
+        object_storage_service: *object_storage_service
+        triples_prefix: "triples"
+    """
+
+    object_storage_service: ObjectStorageServiceConfiguration
+    triples_prefix: str = "triples"
+
+
+class TripleStoreAdapterConfiguration(GenericLoader):
+    adapter: Literal[
+        "oxigraph",
+        "aws_neptune_sshtunnel",
+        "aws_neptune",
+        "fs",
+        "object_storage",
+        "custom",
+    ]
+    config: (
+        Union[
+            OxigraphAdapterConfiguration,
+            AWSNeptuneAdapterConfiguration,
+            AWSNeptuneSSHTunnelAdapterConfiguration,
+            TripleStoreAdapterFilesystemConfiguration,
+            TripleStoreAdapterObjectStorageConfiguration,
+            dict,
+        ]
+        | None
+    ) = None
+
+    @model_validator(mode="after")
+    def validate_adapter(self) -> Self:
+        if self.adapter != "custom":
+            assert self.config is not None, (
+                "config is required if adapter is not custom"
+            )
+
+        if self.adapter == "fs":
+            pydantic_model_validator(
+                TripleStoreAdapterFilesystemConfiguration,
+                self.config,
+                "Invalid configuration for services.triple_store.triple_store_adapter 'fs' adapter",
+            )
+        if self.adapter == "object_storage":
+            pydantic_model_validator(
+                TripleStoreAdapterObjectStorageConfiguration,
+                self.config,
+                "Invalid configuration for services.triple_store.triple_store_adapter 'object_storage' adapter",
+            )
+        if self.adapter == "oxigraph":
+            pydantic_model_validator(
+                OxigraphAdapterConfiguration,
+                self.config,
+                "Invalid configuration for services.triple_store.triple_store_adapter 'oxigraph' adapter",
+            )
+        if self.adapter == "aws_neptune":
+            pydantic_model_validator(
+                AWSNeptuneAdapterConfiguration,
+                self.config,
+                "Invalid configuration for services.triple_store.triple_store_adapter 'aws_neptune' adapter",
+            )
+        if self.adapter == "aws_neptune_sshtunnel":
+            pydantic_model_validator(
+                AWSNeptuneSSHTunnelAdapterConfiguration,
+                self.config,
+                "Invalid configuration for services.triple_store.triple_store_adapter 'aws_neptune_sshtunnel' adapter",
+            )
+
+        return self
+
+    def load(self) -> ITripleStorePort:
+        if self.adapter != "custom":
+            assert self.config is not None, "config is required"
+
+            arguments = (
+                self.config.model_dump()
+                if not isinstance(self.config, dict)
+                else self.config
+            )
+
+            # Lazy import: only import the adapter that's actually configured
+            if self.adapter == "oxigraph":
+                from naas_abi_core.services.triple_store.adaptors.secondary.Oxigraph import (
+                    Oxigraph,
+                )
+
+                OxigraphAdapterConfiguration.model_validate(arguments)
+
+                return Oxigraph(**arguments)
+            elif self.adapter == "aws_neptune":
+                from naas_abi_core.services.triple_store.adaptors.secondary.AWSNeptune import (
+                    AWSNeptune,
+                )
+
+                AWSNeptuneAdapterConfiguration.model_validate(arguments)
+
+                return AWSNeptune(**arguments)
+            elif self.adapter == "aws_neptune_sshtunnel":
+                from naas_abi_core.services.triple_store.adaptors.secondary.AWSNeptune import (
+                    AWSNeptuneSSHTunnel,
+                )
+
+                AWSNeptuneSSHTunnelAdapterConfiguration.model_validate(arguments)
+
+                return AWSNeptuneSSHTunnel(**arguments)
+            elif self.adapter == "fs":
+                from naas_abi_core.services.triple_store.adaptors.secondary.TripleStoreService__SecondaryAdaptor__Filesystem import (
+                    TripleStoreService__SecondaryAdaptor__Filesystem,
+                )
+
+                TripleStoreAdapterFilesystemConfiguration.model_validate(arguments)
+
+                return TripleStoreService__SecondaryAdaptor__Filesystem(**arguments)
+            elif self.adapter == "object_storage":
+                from naas_abi_core.services.triple_store.adaptors.secondary.TripleStoreService__SecondaryAdaptor__ObjectStorage import (
+                    TripleStoreService__SecondaryAdaptor__ObjectStorage,
+                )
+
+                return TripleStoreService__SecondaryAdaptor__ObjectStorage(**arguments)
+            else:
+                raise ValueError(f"Adapter {self.adapter} not supported")
+        else:
+            return super().load()
+
+
+class TripleStoreServiceConfiguration(BaseModel):
+    triple_store_adapter: TripleStoreAdapterConfiguration
+
+    def load(self) -> TripleStoreService:
+        return TripleStoreService(triple_store_adapter=self.triple_store_adapter.load())

naas_abi_core/engine/engine_configuration/EngineConfiguration_TripleStoreService_test.py

@@ -0,0 +1,109 @@
+from naas_abi_core.engine.engine_configuration.EngineConfiguration_TripleStoreService import (
+    AWSNeptuneSSHTunnelAdapterConfiguration,
+    OxigraphAdapterConfiguration,
+    TripleStoreAdapterConfiguration,
+    TripleStoreAdapterFilesystemConfiguration,
+    TripleStoreServiceConfiguration,
+)
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStorePort
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+
+
+def test_triple_store_service_configuration():
+    from naas_abi_core.services.triple_store.adaptors.secondary.TripleStoreService__SecondaryAdaptor__Filesystem import (
+        TripleStoreService__SecondaryAdaptor__Filesystem,
+    )
+
+    configuration = TripleStoreServiceConfiguration(
+        triple_store_adapter=TripleStoreAdapterConfiguration(
+            adapter="fs",
+            config=TripleStoreAdapterFilesystemConfiguration(
+                store_path="storage/triplestore/test", triples_path="triples"
+            ),
+        )
+    )
+    assert configuration.triple_store_adapter is not None
+
+    triple_store_adapter = configuration.triple_store_adapter.load()
+
+    assert triple_store_adapter is not None
+    assert isinstance(triple_store_adapter, ITripleStorePort)
+    assert isinstance(
+        triple_store_adapter, TripleStoreService__SecondaryAdaptor__Filesystem
+    )
+
+    triple_store_service = configuration.load()
+
+    assert triple_store_service is not None
+    assert isinstance(triple_store_service, TripleStoreService)
+
+
+def test_triple_store_service_configuration_naas():
+    from naas_abi_core.services.triple_store.adaptors.secondary.Oxigraph import (
+        Oxigraph,
+    )
+
+    configuration = TripleStoreServiceConfiguration(
+        triple_store_adapter=TripleStoreAdapterConfiguration(
+            adapter="oxigraph",
+            config=OxigraphAdapterConfiguration(
+                oxigraph_url="http://localhost:7878",
+                timeout=120,
+            ),
+        )
+    )
+    assert configuration.triple_store_adapter is not None
+
+    triple_store_adapter = configuration.triple_store_adapter.load()
+
+    assert triple_store_adapter is not None
+    assert isinstance(triple_store_adapter, ITripleStorePort)
+    assert isinstance(triple_store_adapter, Oxigraph)
+
+    triple_store_service = configuration.load()
+
+    assert triple_store_service is not None
+    assert isinstance(triple_store_service, TripleStoreService)
+
+
+def test_triple_store_service_configuration_aws_neptune_sshtunnel():
+    import os
+
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    from naas_abi_core.services.triple_store.adaptors.secondary.AWSNeptune import (
+        AWSNeptuneSSHTunnel,
+    )
+
+    configuration = TripleStoreServiceConfiguration(
+        triple_store_adapter=TripleStoreAdapterConfiguration(
+            adapter="aws_neptune_sshtunnel",
+            config=AWSNeptuneSSHTunnelAdapterConfiguration(
+                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")),
+                bastion_user=os.environ.get("AWS_BASTION_USER"),
+                bastion_private_key=os.environ.get("AWS_BASTION_PRIVATE_KEY"),
+            ),
+        ),
+    )
+
+    assert configuration.triple_store_adapter is not None
+
+    triple_store_adapter = configuration.triple_store_adapter.load()
+
+    assert triple_store_adapter is not None
+    assert isinstance(triple_store_adapter, ITripleStorePort)
+    assert isinstance(triple_store_adapter, AWSNeptuneSSHTunnel)
+
+    triple_store_service = configuration.load()
+
+    assert triple_store_service is not None
+    assert isinstance(triple_store_service, TripleStoreService)

naas_abi_core/engine/engine_configuration/EngineConfiguration_VectorStoreService.py

@@ -0,0 +1,76 @@
+from typing import Literal
+
+from naas_abi_core.engine.engine_configuration.EngineConfiguration_GenericLoader import (
+    GenericLoader,
+)
+from naas_abi_core.engine.engine_configuration.utils.PydanticModelValidator import (
+    pydantic_model_validator,
+)
+from naas_abi_core.services.vector_store.IVectorStorePort import IVectorStorePort
+from naas_abi_core.services.vector_store.VectorStoreService import VectorStoreService
+from pydantic import BaseModel, model_validator
+
+
+class VectorStoreAdapterQdrantConfiguration(BaseModel):
+    """Qdrant vector store adapter configuration.
+
+    vector_store_adapter:
+      adapter: "qdrant"
+      config:
+        host: "{{ secret.QDRANT_HOST }}"
+        port: "{{ secret.QDRANT_PORT }}"
+        api_key: "{{ secret.QDRANT_API_KEY }}"
+        https: "{{ secret.QDRANT_HTTPS }}"
+        timeout: "{{ secret.QDRANT_TIMEOUT }}"
+    """
+    host: str = "localhost"
+    port: int = 6333
+    api_key: str | None = None
+    https: bool = False
+    timeout: int = 30
+
+
+class VectorStoreAdapterConfiguration(GenericLoader):
+    adapter: Literal["qdrant", "custom"]
+    config: dict | None = None
+
+    @model_validator(mode="after")
+    def validate_adapter(self) -> "VectorStoreAdapterConfiguration":
+        if self.adapter != "custom":
+            assert self.config is not None, (
+                "config is required if adapter is not custom"
+            )
+
+        if self.adapter == "qdrant":
+            pydantic_model_validator(
+                VectorStoreAdapterQdrantConfiguration,
+                self.config,
+                "Invalid configuration for services.vector_store.vector_store_adapter 'qdrant' adapter",
+            )
+
+        return self
+
+    def load(self) -> IVectorStorePort:
+        if self.adapter != "custom":
+            assert self.config is not None, (
+                "config is required if adapter is not custom"
+            )
+
+            # Lazy import: only import when actually loading
+            if self.adapter == "qdrant":
+                from naas_abi_core.services.vector_store.adapters.QdrantAdapter import (
+                    QdrantAdapter,
+                )
+
+                return QdrantAdapter(**self.config)
+            else:
+                raise ValueError(f"Unknown adapter: {self.adapter}")
+        else:
+            return super().load()
+
+
+class VectorStoreServiceConfiguration(BaseModel):
+    vector_store_adapter: VectorStoreAdapterConfiguration
+
+    def load(self) -> VectorStoreService:
+        return VectorStoreService(adapter=self.vector_store_adapter.load())

naas_abi_core/engine/engine_configuration/EngineConfiguration_VectorStoreService_test.py

@@ -0,0 +1,33 @@
+from naas_abi_core.engine.engine_configuration.EngineConfiguration_VectorStoreService import (
+    VectorStoreAdapterConfiguration,
+    VectorStoreAdapterQdrantConfiguration,
+    VectorStoreServiceConfiguration,
+)
+from naas_abi_core.services.vector_store.IVectorStorePort import IVectorStorePort
+from naas_abi_core.services.vector_store.VectorStoreService import VectorStoreService
+
+
+def test_vector_store_service_configuration():
+    from naas_abi_core.services.vector_store.adapters.QdrantAdapter import (
+        QdrantAdapter,
+    )
+
+    qdrant_config = VectorStoreAdapterQdrantConfiguration()
+    configuration = VectorStoreServiceConfiguration(
+        vector_store_adapter=VectorStoreAdapterConfiguration(
+            adapter="qdrant",
+            config=qdrant_config.model_dump(),
+        )
+    )
+    assert configuration.vector_store_adapter is not None
+
+    vector_store_adapter = configuration.vector_store_adapter.load()
+
+    assert vector_store_adapter is not None
+    assert isinstance(vector_store_adapter, IVectorStorePort)
+    assert isinstance(vector_store_adapter, QdrantAdapter)
+
+    vector_store_service = configuration.load()
+
+    assert vector_store_service is not None
+    assert isinstance(vector_store_service, VectorStoreService)

naas_abi_core/engine/engine_configuration/EngineConfiguration_test.py

@@ -0,0 +1,9 @@
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+
+
+def test_configuration_load(test_configuration: str):
+    config = EngineConfiguration.load_configuration(test_configuration)
+    assert config is not None
+    assert False is True

naas_abi_core/engine/engine_configuration/utils/PydanticModelValidator.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+from naas_abi_core.utils.Logger import logger
+from pydantic import BaseModel, ValidationError
+
+
+def pydantic_model_validator(model: Any, payload: Any, message: str):
+    if not isinstance(model, type) or not issubclass(model, BaseModel):
+        raise TypeError(
+            "The model argument must be a class that inherits from pydantic.BaseModel"
+        )
+    try:
+        model.model_validate(payload)
+    except ValidationError as e:
+        logger.error(f"{message}: {e}")