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

naas_abi_core/modules/templatablesparqlquery/workflows/GenericWorkflow.py

@@ -0,0 +1,48 @@
+from typing import Generic, Type, TypeVar
+
+from langchain_core.tools import BaseTool, StructuredTool
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+from naas_abi_core.utils.SPARQL import SPARQLUtils
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class GenericWorkflow(Generic[T]):
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        sparql_template: str,
+        arguments_model: Type[T],
+        triple_store_service: TripleStoreService,
+    ):
+        self.name = name
+        self.description = description
+        self.sparql_template = sparql_template
+        self.arguments_model = arguments_model
+        self.triple_store_service = triple_store_service
+
+    def run(self, parameters: T):
+        try:
+            # Template the sparql template with the parameters using jinja2
+            from jinja2 import Template
+
+            template = Template(self.sparql_template)
+            sparql_query = template.render(parameters.model_dump())
+            # print(sparql_query)
+            results = self.triple_store_service.query(sparql_query)
+
+            return SPARQLUtils(self.triple_store_service).results_to_list(results)
+        except Exception as e:
+            return [{"error": str(e)}]
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name=self.name,
+                description=self.description,
+                func=lambda **kwargs: self.run(self.arguments_model(**kwargs)),
+                args_schema=self.arguments_model,
+            )
+        ]

naas_abi_core/modules/templatablesparqlquery/workflows/TemplatableSparqlQueryLoader.py

@@ -0,0 +1,192 @@
+import asyncio
+
+from naas_abi_core import logger
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+from pydantic import Field, create_model
+from rdflib import RDF, Graph, URIRef
+
+from .GenericWorkflow import GenericWorkflow
+
+
+async def async_asyncio_thread_jobs(jobs):
+    tasks = []
+    for job in jobs:
+        task = asyncio.create_task(asyncio.to_thread(*job))
+        tasks.append(task)
+    return await asyncio.gather(*tasks)
+
+
+def asyncio_thread_job(jobs):
+    return asyncio.run(async_asyncio_thread_jobs(jobs))
+
+
+class TemplatableSparqlQueryLoader:
+    triple_store_service: TripleStoreService
+
+    def __init__(self, triple_store_service: TripleStoreService):
+        self.triple_store_service = triple_store_service
+
+    def templatable_queries(self):
+        results = self.triple_store_service.query("""
+            PREFIX intentMapping: <http://ontology.naas.ai/intentMapping/>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            SELECT ?query ?label ?description ?sparqlTemplate ?hasArgument
+            WHERE {
+                ?query a intentMapping:TemplatableSparqlQuery ;
+                    intentMapping:intentDescription ?description ;
+                    intentMapping:sparqlTemplate ?sparqlTemplate ;
+                    intentMapping:hasArgument ?hasArgument ;
+                    rdfs:label ?label .
+            }
+        """)
+
+        queries = {}
+
+        for result in results:
+            query, label, description, sparqlTemplate, hasArgument = result
+            queries[query] = {
+                "label": label,
+                "description": description,
+                "sparqlTemplate": sparqlTemplate,
+                "hasArgument": [hasArgument]
+                if (query not in queries or queries[query].get("hasArgument") is None)
+                else queries[query].get("hasArgument") + [hasArgument],
+            }
+
+        arguments = {}
+
+        argument_graph = Graph()
+        argument_graph.bind(
+            "intentMapping", URIRef("http://ontology.naas.ai/intentMapping/")
+        )
+        results = self.triple_store_service.query("""
+                    PREFIX intentMapping: <http://ontology.naas.ai/intentMapping/>
+                    
+                    SELECT ?argument ?name ?description ?validationPattern ?validationFormat
+                    WHERE {
+                        ?argument a intentMapping:QueryArgument ;
+                            intentMapping:argumentName ?name ;
+                            intentMapping:argumentDescription ?description ;
+                            intentMapping:validationPattern ?validationPattern ;
+                            intentMapping:validationFormat ?validationFormat .
+                    }
+                """)
+
+        for argument, name, description, validationPattern, validationFormat in results:
+            argument_graph.add(
+                (
+                    argument,
+                    RDF.type,
+                    URIRef("http://ontology.naas.ai/intentMapping/QueryArgument"),
+                )
+            )
+            argument_graph.add(
+                (
+                    argument,
+                    URIRef("http://ontology.naas.ai/intentMapping/argumentName"),
+                    name,
+                )
+            )
+            argument_graph.add(
+                (
+                    argument,
+                    URIRef("http://ontology.naas.ai/intentMapping/argumentDescription"),
+                    description,
+                )
+            )
+            argument_graph.add(
+                (
+                    argument,
+                    URIRef("http://ontology.naas.ai/intentMapping/validationPattern"),
+                    validationPattern,
+                )
+            )
+            argument_graph.add(
+                (
+                    argument,
+                    URIRef("http://ontology.naas.ai/intentMapping/validationFormat"),
+                    validationFormat,
+                )
+            )
+
+        arguments = {}
+        for templatableQuery in queries:
+            for argument in queries[templatableQuery].get("hasArgument"):
+                q = (
+                    """
+                    PREFIX intentMapping: <http://ontology.naas.ai/intentMapping/>
+                    
+                    SELECT ?argument ?name ?description ?validationPattern ?validationFormat
+                    WHERE {
+                        BIND(<"""
+                    + str(argument)
+                    + """> AS ?argument)
+                        ?argument a intentMapping:QueryArgument ;
+                            intentMapping:argumentName ?name ;
+                            intentMapping:argumentDescription ?description ;
+                            intentMapping:validationPattern ?validationPattern ;
+                            intentMapping:validationFormat ?validationFormat .
+                    }
+                """
+                )
+                # logger.debug(f"Query: {q}")
+                results = argument_graph.query(q)
+
+                for result in results:
+                    argument, name, description, validationPattern, validationFormat = (
+                        result
+                    )
+
+                    arguments[argument] = {
+                        "name": name,
+                        "description": description,
+                        "validationPattern": validationPattern,
+                        "validationFormat": validationFormat,
+                    }
+
+        return queries, arguments
+
+    def load_workflows(self):
+        workflows = []
+
+        queries, arguments = self.templatable_queries()
+
+        # workflows = asyncio.run(__load_queries(queries, arguments))
+
+        # Now for each query, we need to create a Pydantic BaseModel based on the arguments
+        for _query in queries:
+            try:
+                query = queries[_query]
+
+                # Arguments Model with validation patterns
+                arguments_model = create_model(
+                    f"{str(query['label']).capitalize()}Arguments",
+                    **{
+                        str(arguments[argument]["name"]): (
+                            str,
+                            Field(
+                                ...,
+                                description=str(arguments[argument]["description"]),
+                                pattern=str(arguments[argument]["validationPattern"]),
+                                # You could also add additional metadata from validationFormat if needed
+                                example=str(arguments[argument]["validationFormat"]),
+                            ),
+                        )
+                        for argument in query.get("hasArgument")
+                    },
+                )
+
+                p = GenericWorkflow[arguments_model](
+                    str(query["label"]),
+                    str(query["description"]),
+                    str(query["sparqlTemplate"]),
+                    arguments_model,
+                    self.triple_store_service,
+                )
+                workflows.append(p)
+            except Exception as e:
+                logger.warning(
+                    f"Error loading workflow for query {query['label']}\nMessage: {e}"
+                )
+
+        return workflows

naas_abi_core/pipeline/__init__.py

@@ -0,0 +1,6 @@
+from naas_abi_core.pipeline.pipeline import Graph as Graph
+from naas_abi_core.pipeline.pipeline import Pipeline as Pipeline
+from naas_abi_core.pipeline.pipeline import (
+    PipelineConfiguration as PipelineConfiguration,
+)
+from naas_abi_core.pipeline.pipeline import PipelineParameters as PipelineParameters

naas_abi_core/pipeline/pipeline.py

@@ -0,0 +1,70 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel
+from rdflib import Graph
+
+from naas_abi_core.services.triple_store.TripleStorePorts import OntologyEvent
+from naas_abi_core.utils.Expose import Expose
+
+
+@dataclass
+class PipelineConfiguration:
+    """Base configuration class for pipelines.
+
+    This class serves as the base configuration for all pipeline classes.
+    Concrete pipeline implementations should extend this class and add their
+    specific configuration attributes.
+    """
+
+    pass
+
+
+class PipelineParameters(BaseModel):
+    """Base parameters class for pipeline execution.
+
+    This class serves as the base parameters for all pipeline executions.
+    Concrete pipeline implementations should extend this class and add their
+    specific runtime parameters.
+    """
+
+    pass
+
+
+class Pipeline(Expose):
+    __configuration: PipelineConfiguration
+
+    def __init__(self, configuration: PipelineConfiguration):
+        self.__configuration = configuration
+
+    # TODO: Make this an abstract method
+    # @abstractmethod
+    def trigger(
+        self, event: OntologyEvent, ontology_name: str, triple: tuple[Any, Any, Any]
+    ) -> Graph:
+        """Trigger the pipeline with the given event and triple.
+
+        This method should be implemented by concrete pipeline classes to process data
+        according to their specific logic and configuration.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def run(self, parameters: PipelineParameters) -> Graph:
+        """Execute the pipeline with the given parameters.
+
+        This method should be implemented by concrete pipeline classes to process data
+        according to their specific logic and configuration.
+
+        Args:
+            parameters (PipelineParameters): Runtime parameters for pipeline execution
+                that control how the pipeline processes data
+
+        Returns:
+            Graph: An RDF graph containing the processed data and relationships
+
+        Raises:
+            NotImplementedError: If the concrete class does not implement this method
+        """
+        raise NotImplementedError()