naas-abi 1.0.0__py3-none-any.whl

naas_abi/pipelines/AIAgentOntologyGenerationPipeline_test.py

@@ -0,0 +1,133 @@
+import json
+
+import pytest
+from naas_abi.pipelines.AIAgentOntologyGenerationPipeline import (
+    AIAgentOntologyGenerationConfiguration,
+    AIAgentOntologyGenerationParameters,
+    AIAgentOntologyGenerationPipeline,
+)
+
+
+@pytest.fixture
+def pipeline() -> AIAgentOntologyGenerationPipeline:
+    from naas_abi import services
+
+    pipeline_configuration = AIAgentOntologyGenerationConfiguration(
+        triple_store=services.triple_store,
+        datastore_path="storage/datastore/test/ai_agent_ontology_generation",
+        source_datastore_path="storage/datastore/test/artificial_analysis_workflow",
+    )
+
+    return AIAgentOntologyGenerationPipeline(pipeline_configuration)
+
+
+@pytest.fixture
+def mock_aa_data():
+    """Mock Artificial Analysis data for testing."""
+    return {
+        "llms": [
+            {
+                "name": "GPT-4o",
+                "slug": "gpt-4o",
+                "model_creator": {"name": "OpenAI", "slug": "openai"},
+                "pricing": {
+                    "input_cost": 5.0,
+                    "output_cost": 15.0,
+                    "blended_cost": 10.0,
+                },
+                "performance": {
+                    "output_speed": 25.5,
+                    "time_to_first_token": 0.5,
+                    "time_to_first_answer_token": 1.2,
+                },
+                "evaluations": {"index": 85, "coding_index": 90, "math_index": 80},
+            },
+            {
+                "name": "Claude 3.5 Sonnet",
+                "slug": "claude-35-sonnet",
+                "model_creator": {"name": "Anthropic", "slug": "anthropic"},
+                "pricing": {
+                    "input_cost": 3.0,
+                    "output_cost": 15.0,
+                    "blended_cost": 9.0,
+                },
+                "performance": {
+                    "output_speed": 22.1,
+                    "time_to_first_token": 0.8,
+                    "time_to_first_answer_token": 1.5,
+                },
+                "evaluations": {"index": 88, "coding_index": 85, "math_index": 82},
+            },
+        ]
+    }
+
+
+def test_pipeline_basic_functionality(
+    pipeline: AIAgentOntologyGenerationPipeline, mock_aa_data, tmp_path
+):
+    """Test basic pipeline functionality with mock data."""
+
+    # Setup test paths
+    source_path = tmp_path / "source"
+    source_path.mkdir()
+    output_path = tmp_path / "output"
+
+    # Create mock data file
+    mock_file = source_path / "20250811T120000_llms_data.json"
+    with open(mock_file, "w") as f:
+        json.dump(mock_aa_data, f)
+
+    # Update configuration paths
+    config = pipeline.get_configuration()
+    config.source_datastore_path = str(source_path)
+    config.datastore_path = str(output_path)
+
+    # Run pipeline
+    parameters = AIAgentOntologyGenerationParameters(force_regenerate=True)
+    graph = pipeline.run(parameters)
+
+    assert graph is not None
+
+    # Verify triples were added
+    triples = list(graph)
+    assert len(triples) > 0
+
+    for s, p, o in triples:
+        assert s is not None
+        assert p is not None
+        assert o is not None
+
+
+def test_model_mapping_logic(pipeline: AIAgentOntologyGenerationPipeline):
+    """Test the model to agent mapping logic."""
+
+    # Test GPT model mapping
+    gpt_model = {
+        "name": "GPT-4o",
+        "slug": "gpt-4o",
+        "model_creator": {"name": "OpenAI"},
+    }
+    assert pipeline._determine_ai_agent_module(gpt_model) == "chatgpt"
+
+    # Test Claude model mapping
+    claude_model = {
+        "name": "Claude 3.5 Sonnet",
+        "slug": "claude-35-sonnet",
+        "model_creator": {"name": "Anthropic"},
+    }
+    assert pipeline._determine_ai_agent_module(claude_model) == "claude"
+
+    # Test Gemini vs Gemma mapping
+    gemini_model = {
+        "name": "Gemini 2.0",
+        "slug": "gemini-2-0",
+        "model_creator": {"name": "Google"},
+    }
+    assert pipeline._determine_ai_agent_module(gemini_model) == "gemini"
+
+    gemma_model = {
+        "name": "Gemma 3 27B",
+        "slug": "gemma-3-27b",
+        "model_creator": {"name": "Google"},
+    }
+    assert pipeline._determine_ai_agent_module(gemma_model) == "gemma"

naas_abi/pipelines/AddIndividualPipeline.py

@@ -0,0 +1,215 @@
+import uuid
+from dataclasses import dataclass
+from enum import Enum
+from typing import Annotated, Optional
+
+from fastapi import APIRouter
+from langchain_core.tools import BaseTool, StructuredTool
+from naas_abi.workflows.SearchIndividualWorkflow import (
+    SearchIndividualWorkflow,
+    SearchIndividualWorkflowConfiguration,
+    SearchIndividualWorkflowParameters,
+)
+from naas_abi_core import logger
+from naas_abi_core.pipeline import Pipeline, PipelineConfiguration, PipelineParameters
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from pydantic import Field
+from rdflib import DCTERMS, OWL, RDF, RDFS, Graph, Literal, Namespace, URIRef
+
+BFO = Namespace("http://purl.obolibrary.org/obo/")
+CCO = Namespace("https://www.commoncoreontologies.org/")
+ABI = Namespace("http://ontology.naas.ai/abi/")
+URI_REGEX = r"http:\/\/ontology\.naas\.ai\/abi\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+
+
+@dataclass
+class AddIndividualPipelineConfiguration(PipelineConfiguration):
+    """Configuration for AddIndividualPipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The ontology store service to use
+        search_individual_workflow (SearchIndividualWorkflow): The search individual workflow to use
+    """
+
+    triple_store: ITripleStoreService
+    search_individual_configuration: SearchIndividualWorkflowConfiguration
+
+
+class AddIndividualPipelineParameters(PipelineParameters):
+    individual_label: Annotated[
+        str,
+        Field(
+            description="Individual label to add to the ontology.", example="Naas.ai"
+        ),
+    ]
+    class_uri: Annotated[
+        str,
+        Field(
+            description="Class URI to add the individual to. Use tool `search_class` to search for a class URI in the ontology.",
+            example="https://www.commoncoreontologies.org/ont00000443",
+        ),
+    ]
+    threshold: Annotated[
+        Optional[int],
+        Field(
+            description="Threshold to use for the search individual workflow.",
+            ge=0,
+            le=100,
+        ),
+    ] = 80
+
+
+class AddIndividualPipeline(Pipeline):
+    """Pipeline for adding a named individual."""
+
+    __configuration: AddIndividualPipelineConfiguration
+
+    def __init__(self, configuration: AddIndividualPipelineConfiguration):
+        super().__init__(configuration)
+        self.__configuration = configuration
+        self.__search_individual_workflow = SearchIndividualWorkflow(
+            configuration.search_individual_configuration
+        )
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        if not isinstance(parameters, AddIndividualPipelineParameters):
+            raise ValueError(
+                "Parameters must be of type AddIndividualPipelineParameters"
+            )
+
+        # Search for individual
+        search_individual_result = self.__search_individual_workflow.search_individual(
+            SearchIndividualWorkflowParameters(
+                class_uri=parameters.class_uri,
+                search_label=parameters.individual_label,
+            )
+        )
+        filtered_results = [
+            result
+            for result in search_individual_result
+            if parameters.threshold is not None
+            and int(result["score"]) >= parameters.threshold
+        ]
+        if len(filtered_results) > 0:
+            individual_uri = filtered_results[0]["individual_uri"]
+            logger.debug(
+                f"🔍 Found individual '{parameters.individual_label}' in the ontology: {individual_uri} from class: {parameters.class_uri}"
+            )
+            return self.__configuration.triple_store.get_subject_graph(individual_uri)
+
+        # Init graph
+        graph = Graph()
+        graph.bind("bfo", BFO)
+        graph.bind("cco", CCO)
+        graph.bind("abi", ABI)
+        graph.bind("dcterms", DCTERMS)
+
+        # Add individual
+        individual_uri = ABI[str(uuid.uuid4())]
+        graph.add((individual_uri, RDF.type, OWL.NamedIndividual))
+        graph.add((individual_uri, RDF.type, URIRef(parameters.class_uri)))
+        graph.add((individual_uri, RDFS.label, Literal(parameters.individual_label)))
+        self.__configuration.triple_store.insert(graph)
+        return graph
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name="add_individual_to_triple_store",
+                description="Add a new individual/instance to triple store.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(**kwargs)
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_commercial_organization",
+                description="Add a new commercial organization to ontology.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri="https://www.commoncoreontologies.org/ont00000443",
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_person",
+                description="Add a new person to ontology.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri="https://www.commoncoreontologies.org/ont00001262",
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_website",
+                description="Add a new website to ontology.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri=ABI.Website,
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_skill",
+                description="Add a new skill to ontology.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri=CCO.ont00000089,
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_legal_name",
+                description="Add a new legal name of a commercial organization.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri=CCO.ont00001331,
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_ticker_symbol",
+                description="Add a new ticker symbol to triple store.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri=ABI.Ticker,
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+            StructuredTool(
+                name="add_linkedin_page",
+                description="Add a new LinkedIn page represented by a profile or organization to triple store.",
+                func=lambda **kwargs: self.run(
+                    AddIndividualPipelineParameters(
+                        class_uri=ABI.LinkedInProfilePage,
+                        individual_label=kwargs["individual_label"],
+                    )
+                ),
+                args_schema=AddIndividualPipelineParameters,
+            ),
+        ]
+
+    def as_api(
+        self,
+        router: APIRouter,
+        route_name: str = "",
+        name: str = "",
+        description: str = "",
+        description_stream: str = "",
+        tags: list[str | Enum] | None = None,
+    ) -> None:
+        if tags is None:
+            tags = []
+        return None

naas_abi/pipelines/AddIndividualPipeline_test.py

@@ -0,0 +1,66 @@
+import pytest
+from naas_abi import services
+from naas_abi.pipelines.AddIndividualPipeline import (
+    AddIndividualPipeline,
+    AddIndividualPipelineConfiguration,
+    AddIndividualPipelineParameters,
+)
+from naas_abi.workflows.SearchIndividualWorkflow import (
+    SearchIndividualWorkflowConfiguration,
+)
+
+
+@pytest.fixture
+def pipeline() -> AddIndividualPipeline:
+    search_individual_workflow_configuration = SearchIndividualWorkflowConfiguration(
+        triple_store=services.triple_store_service
+    )
+    pipeline = AddIndividualPipeline(
+        configuration=AddIndividualPipelineConfiguration(
+            triple_store=services.triple_store_service,
+            search_individual_configuration=search_individual_workflow_configuration,
+        )
+    )
+    return pipeline
+
+
+def test_add_individual_pipeline(pipeline: AddIndividualPipeline):
+    from naas_abi.utils.SPARQL import results_to_list
+    from rdflib import OWL, RDF, RDFS, Literal, URIRef
+
+    label = "Naas.ai"
+    class_uri = "https://www.commoncoreontologies.org/ont00000443"
+    graph = pipeline.run(
+        AddIndividualPipelineParameters(individual_label=label, class_uri=class_uri)
+    )
+
+    individual_uri = list(graph.triples((None, RDF.type, OWL.NamedIndividual)))[0][0]
+
+    assert graph is not None, graph.serialize(format="turtle")
+    assert len(list(graph.triples((None, RDFS.label, Literal(label))))) == 1, (
+        graph.serialize(format="turtle")
+    )
+    assert len(list(graph.triples((None, RDF.type, URIRef(class_uri))))) == 1, (
+        graph.serialize(format="turtle")
+    )
+
+    # Remove graph
+    services.triple_store_service.remove(graph)
+
+    # Check triples are removed from the triple store
+    sparql_query = """
+    PREFIX abi: <http://ontology.naas.ai/abi/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    PREFIX cco: <https://www.commoncoreontologies.org/>
+    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+
+    SELECT ?s ?p ?o
+    WHERE {
+        ?s ?p ?o .
+        FILTER(?s = <{{individual_uri}}>)
+    }
+    """
+    sparql_query = sparql_query.replace("{{individual_uri}}", str(individual_uri))
+    results = services.triple_store_service.query(sparql_query)
+    results_list = results_to_list(results)
+    assert results_list is None, results_list

naas_abi/pipelines/InsertDataSPARQLPipeline.py

@@ -0,0 +1,197 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Annotated
+
+from fastapi import APIRouter
+from langchain_core.tools import BaseTool, StructuredTool
+from naas_abi_core import logger
+from naas_abi_core.pipeline import Pipeline, PipelineConfiguration, PipelineParameters
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from pydantic import Field
+from rdflib import Graph, Namespace
+
+BFO = Namespace("http://purl.obolibrary.org/obo/")
+CCO = Namespace("https://www.commoncoreontologies.org/")
+ABI = Namespace("http://ontology.naas.ai/abi/")
+
+
+@dataclass
+class InsertDataSPARQLPipelineConfiguration(PipelineConfiguration):
+    """Configuration for InsertDataSPARQLPipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The triple store service to use
+    """
+
+    triple_store: ITripleStoreService
+
+
+class InsertDataSPARQLPipelineParameters(PipelineParameters):
+    """Parameters for InsertDataSPARQLPipeline execution.
+
+    Attributes:
+        sparql_statement (str): The SPARQL INSERT DATA statement to execute
+    """
+
+    sparql_statement: Annotated[
+        str,
+        Field(
+            description="SPARQL INSERT DATA statement to execute. Must be a valid SPARQL INSERT DATA query."
+        ),
+    ]
+
+
+class InsertDataSPARQLPipeline(Pipeline):
+    """Pipeline for executing SPARQL INSERT DATA statements on the ontology."""
+
+    __configuration: InsertDataSPARQLPipelineConfiguration
+
+    def __init__(self, configuration: InsertDataSPARQLPipelineConfiguration):
+        super().__init__(configuration)
+        self.__configuration = configuration
+
+    def get_sparql_from_text(
+        self, parameters: InsertDataSPARQLPipelineParameters
+    ) -> str:
+        """Get the SPARQL INSERT DATA statement from the text.
+
+        Args:
+            text (str): The text to extract the SPARQL INSERT DATA statement from
+
+        Returns:
+            str: The SPARQL INSERT DATA statement
+        """
+        text = parameters.sparql_statement
+
+        # Clean the statement from the ```sparql and ```
+        text = text.split("```sparql")[-1].split("```")[0].strip()
+        if "INSERT DATA" in text:
+            logger.info(f"✅ SPARQL INSERT DATA statement found: {text}")
+            return text
+        return f"No SPARQL INSERT DATA statement found in statement: {parameters.sparql_statement}"
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        """Execute the SPARQL INSERT DATA statement.
+
+        Args:
+            parameters (PipelineParameters): Must be InsertDataSPARQLPipelineParameters
+
+        Returns:
+            Graph: The graph with the inserted data
+
+        Raises:
+            ValueError: If parameters are not of the correct type
+        """
+        if not isinstance(parameters, InsertDataSPARQLPipelineParameters):
+            raise ValueError(
+                "Parameters must be of type InsertDataSPARQLPipelineParameters"
+            )
+
+        logger.info("Executing SPARQL INSERT DATA statement...")
+
+        # Initialize a new graph with common namespace bindings
+        graph = Graph()
+        graph.bind("bfo", BFO)
+        graph.bind("cco", CCO)
+        graph.bind("abi", ABI)
+
+        # Execute the SPARQL INSERT DATA statement
+        try:
+            sparql_statement = self.get_sparql_from_text(parameters)
+            graph.update(sparql_statement)
+            logger.info("✅ SPARQL INSERT DATA is valid.")
+        except Exception as e:
+            logger.error(f"❌ Failed to execute SPARQL INSERT DATA: {e}")
+            return Graph()
+
+        # Insert the graph into the triple store
+        if len(graph) > 0:
+            logger.info("✅ Inserting data to triplestore:")
+            logger.info(graph.serialize(format="turtle"))
+            self.__configuration.triple_store.insert(graph)
+        else:
+            logger.info("❌ No data to insert")
+        return graph
+
+    def as_tools(self) -> list[BaseTool]:
+        """Returns a list of LangChain tools for this pipeline.
+
+        Returns:
+            list[BaseTool]: List containing the pipeline tool
+        """
+        return [
+            StructuredTool(
+                name="insert_data_sparql",
+                description="Execute a SPARQL INSERT DATA statement to add triples to the triple store",
+                func=lambda **kwargs: self.run(
+                    InsertDataSPARQLPipelineParameters(**kwargs)
+                ),
+                args_schema=InsertDataSPARQLPipelineParameters,
+            ),
+            StructuredTool(
+                name="extract_sparql_from_text",
+                description="Extract a SPARQL INSERT DATA statement from the text",
+                func=lambda **kwargs: self.get_sparql_from_text(
+                    InsertDataSPARQLPipelineParameters(**kwargs)
+                ),
+                args_schema=InsertDataSPARQLPipelineParameters,
+            ),
+        ]
+
+    def as_api(
+        self,
+        router: APIRouter,
+        route_name: str = "",
+        name: str = "",
+        description: str = "",
+        description_stream: str = "",
+        tags: list[str | Enum] | None = None,
+    ) -> None:
+        """Register API endpoints for this pipeline.
+
+        Args:
+            router: FastAPI router to register endpoints on
+            route_name: Name for the route
+            name: Display name for the endpoint
+            description: Description for the endpoint
+            description_stream: Description for streaming endpoint
+            tags: Tags for the endpoint
+        """
+        if tags is None:
+            tags = []
+        return None
+
+
+if __name__ == "__main__":
+    from naas_abi import services
+
+    sparql_statement = """
+    PREFIX abi: <http://ontology.naas.ai/abi/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    PREFIX cco: <https://www.commoncoreontologies.org/>
+    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+
+    INSERT DATA {
+        abi:john a cco:ont00001262, owl:NamedIndividual ;
+                    abi:name "John Doe" ;
+                    abi:age 30 ;
+                    abi:email "john.doe@example.com" .
+        
+        abi:jane a cco:ont00001262, owl:NamedIndividual ;
+                    abi:name "Jane Smith" ;
+                    abi:age 28 ;
+                    abi:email "jane.smith@example.com" .
+    }
+    """
+    pipeline = InsertDataSPARQLPipeline(
+        InsertDataSPARQLPipelineConfiguration(
+            triple_store=services.triple_store_service
+        )
+    )
+    # result = pipeline.get_sparql_from_text(InsertDataSPARQLPipelineParameters(sparql_statement=sparql_statement))
+    # logger.info(result)
+
+    result = pipeline.run(
+        InsertDataSPARQLPipelineParameters(sparql_statement=sparql_statement)
+    )
+    logger.info(result)