naas-abi 1.0.0__py3-none-any.whl

naas_abi/pipelines/UpdateCommercialOrganizationPipeline.py

@@ -0,0 +1,198 @@
+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_core.pipeline import Pipeline, PipelineConfiguration, PipelineParameters
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from naas_abi_core.utils.Graph import ABI, URI_REGEX
+from pydantic import Field
+from rdflib import Graph, Literal, URIRef
+
+
+@dataclass
+class UpdateCommercialOrganizationPipelineConfiguration(PipelineConfiguration):
+    """Configuration for UpdateCommercialOrganizationPipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The triple store service to use
+    """
+
+    triple_store: ITripleStoreService
+
+
+class UpdateCommercialOrganizationPipelineParameters(PipelineParameters):
+    individual_uri: Annotated[
+        str,
+        Field(
+            description="URI of the commercial organization extracted from class: https://www.commercoreontologies.org/ont00000443",
+            pattern=URI_REGEX,
+        ),
+    ]
+    legal_uri: Annotated[
+        Optional[str],
+        Field(
+            description="Individual URI from class: https://www.commoncoreontologies.org/ont00001331",
+            pattern=URI_REGEX,
+        ),
+    ] = None
+    ticker_uri: Annotated[
+        Optional[str],
+        Field(
+            description="Individual URI from class: http://ontology.naas.ai/abi/Ticker",
+            pattern=URI_REGEX,
+        ),
+    ] = None
+    website_uri: Annotated[
+        Optional[str],
+        Field(
+            description="Individual URI from class: http://ontology.naas.ai/abi/Website",
+            pattern=URI_REGEX,
+        ),
+    ] = None
+    linkedin_page_uri: Annotated[
+        Optional[str],
+        Field(
+            description="Individual URI from class: http://ontology.naas.ai/abi/LinkedInOrganizationPage",
+            pattern=URI_REGEX,
+        ),
+    ] = None
+    logo_url: Annotated[
+        Optional[str],
+        Field(
+            description="Logo URL of the commercial organization.",
+            pattern=r"https?://.*",
+        ),
+    ] = None
+
+
+class UpdateCommercialOrganizationPipeline(Pipeline):
+    """Pipeline for updating a commercial organization in the ontology."""
+
+    __configuration: UpdateCommercialOrganizationPipelineConfiguration
+
+    def __init__(
+        self, configuration: UpdateCommercialOrganizationPipelineConfiguration
+    ):
+        super().__init__(configuration)
+        self.__configuration = configuration
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        if not isinstance(parameters, UpdateCommercialOrganizationPipelineParameters):
+            raise ValueError(
+                "Parameters must be of type UpdateCommercialOrganizationPipelineParameters"
+            )
+
+        # Initialize graphs
+        graph_insert = Graph()
+
+        # Get subject URI & graph
+        individual_uri = URIRef(parameters.individual_uri)
+        graph = self.__configuration.triple_store.get_subject_graph(individual_uri)
+
+        # Update properties
+        if parameters.legal_uri:
+            check_legal = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        URIRef("http://ontology.naas.ai/abi/hasLegalName"),
+                        URIRef(parameters.legal_uri),
+                    )
+                )
+            )
+            if len(check_legal) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.hasLegalName, URIRef(parameters.legal_uri))
+                )
+        if parameters.ticker_uri:
+            check_ticker = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        URIRef("http://ontology.naas.ai/abi/hasTickerSymbol"),
+                        URIRef(parameters.ticker_uri),
+                    )
+                )
+            )
+            if len(check_ticker) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.hasTickerSymbol, URIRef(parameters.ticker_uri))
+                )
+        if parameters.website_uri:
+            check_website = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        URIRef("http://ontology.naas.ai/abi/hasWebsite"),
+                        URIRef(parameters.website_uri),
+                    )
+                )
+            )
+            if len(check_website) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.hasWebsite, URIRef(parameters.website_uri))
+                )
+        if parameters.linkedin_page_uri:
+            check_linkedin_page = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        URIRef("http://ontology.naas.ai/abi/hasLinkedInPage"),
+                        URIRef(parameters.linkedin_page_uri),
+                    )
+                )
+            )
+            if len(check_linkedin_page) == 0:
+                graph_insert.add(
+                    (
+                        individual_uri,
+                        ABI.hasLinkedInPage,
+                        URIRef(parameters.linkedin_page_uri),
+                    )
+                )
+        if parameters.logo_url:
+            check_logo = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        URIRef("http://ontology.naas.ai/abi/logo"),
+                        Literal(parameters.logo_url),
+                    )
+                )
+            )
+            if len(check_logo) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.logo, Literal(parameters.logo_url))
+                )
+
+        # Save graphs to triple store
+        self.__configuration.triple_store.insert(graph_insert)
+        graph += graph_insert
+        return graph
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name="update_commercial_organization",
+                description="Update a commercial organization properties",
+                func=lambda **kwargs: self.run(
+                    UpdateCommercialOrganizationPipelineParameters(**kwargs)
+                ),
+                args_schema=UpdateCommercialOrganizationPipelineParameters,
+            )
+        ]
+
+    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/UpdateDataPropertyPipeline.py

@@ -0,0 +1,175 @@
+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 import ABIModule
+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 naas_abi_core.utils.Graph import URI_REGEX
+from naas_abi_core.utils.SPARQL import SPARQLUtils
+from pydantic import Field
+from rdflib import RDFS, SKOS, XSD, Graph, Literal, URIRef
+
+
+@dataclass
+class UpdateDataPropertyPipelineConfiguration(PipelineConfiguration):
+    """Configuration for UpdateDataPropertyPipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The triple store service to use
+    """
+
+    triple_store: ITripleStoreService
+
+
+class UpdateDataPropertyPipelineParameters(PipelineParameters):
+    subject_uri: Annotated[str, Field(description="Subject URI", pattern=URI_REGEX)]
+    predicate_uri: Annotated[
+        str, Field(description="Predicate URI", pattern=r"^http.+$")
+    ]
+    object_new_value: Annotated[
+        str,
+        Field(
+            description="New value for the object",
+        ),
+    ]
+    language: Optional[
+        Annotated[
+            Optional[str],
+            Field(
+                description="Language of the object",
+            ),
+        ]
+    ] = None
+
+
+class UpdateDataPropertyPipeline(Pipeline):
+    """Pipeline for updating a data property in the ontology."""
+
+    __configuration: UpdateDataPropertyPipelineConfiguration
+
+    def __init__(self, configuration: UpdateDataPropertyPipelineConfiguration):
+        super().__init__(configuration)
+        self.__configuration = configuration
+        self.__sparql_utils = SPARQLUtils(
+            ABIModule.get_instance().engine.services.triple_store
+        )
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        if not isinstance(parameters, UpdateDataPropertyPipelineParameters):
+            raise ValueError(
+                "Parameters must be of type UpdateDataPropertyPipelineParameters"
+            )
+
+        graph_insert = Graph()
+        graph_remove = Graph()
+        subject_uri = URIRef(parameters.subject_uri)
+        predicate_uri = URIRef(parameters.predicate_uri)
+        logger.info(
+            f"Updating subject '{subject_uri}' with predicate '{predicate_uri}' and value '{parameters.object_new_value}'"
+        )
+
+        if isinstance(parameters.object_new_value, str):
+            if parameters.language is not None:
+                object_new_value = Literal(
+                    parameters.object_new_value, lang=parameters.language
+                )
+            else:
+                object_new_value = Literal(parameters.object_new_value)
+        elif isinstance(parameters.object_new_value, float):
+            object_new_value = Literal(parameters.object_new_value, datatype=XSD.float)
+        elif isinstance(parameters.object_new_value, int):
+            object_new_value = Literal(
+                parameters.object_new_value, datatype=XSD.integer
+            )
+        else:
+            logger.error(f"Invalid object new value: {parameters.object_new_value}")
+            return Graph()
+
+        graph = self.__sparql_utils.get_subject_graph(parameters.subject_uri)
+        check_object_property = list(graph.triples((subject_uri, predicate_uri, None)))
+        logger.info(f"Check object property: {len(check_object_property)}")
+        if len(check_object_property) == 0:
+            logger.error(
+                f"Property {parameters.predicate_uri} not found for subject {parameters.subject_uri}"
+            )
+            return Graph()
+        elif len(check_object_property) == 1 and predicate_uri != RDFS.label:
+            property_value = graph.value(subject_uri, predicate_uri)
+            if property_value:
+                graph_remove.add((subject_uri, predicate_uri, property_value))
+            graph_insert.add((subject_uri, predicate_uri, object_new_value))
+        elif len(check_object_property) == 1 and predicate_uri == RDFS.label:
+            property_value = graph.value(subject_uri, predicate_uri)
+            if property_value:
+                graph_remove.add((subject_uri, predicate_uri, property_value))
+            graph_insert.add((subject_uri, predicate_uri, object_new_value))
+            graph_insert.add((subject_uri, SKOS.altLabel, object_new_value))
+        else:
+            logger.error(
+                f"Multiple values found for property {parameters.predicate_uri} for subject {parameters.subject_uri}"
+            )
+            return Graph()
+
+        # Save to triplestore
+        if len(graph_insert) > 0:
+            logger.info("✅ Inserting data to triplestore:")
+            logger.info(graph_insert.serialize(format="turtle"))
+            self.__configuration.triple_store.insert(graph_insert)
+        if len(graph_remove) > 0:
+            logger.info("✅ Removing data from triplestore:")
+            logger.info(graph_remove.serialize(format="turtle"))
+            self.__configuration.triple_store.remove(graph_remove)
+        return self.__sparql_utils.get_subject_graph(parameters.subject_uri)
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name="update_data_property",
+                description="Update a data property in the ontology",
+                func=lambda **kwargs: self.run(
+                    UpdateDataPropertyPipelineParameters(**kwargs)
+                ),
+                args_schema=UpdateDataPropertyPipelineParameters,
+            )
+        ]
+
+    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
+
+
+if __name__ == "__main__":
+    from naas_abi import services
+
+    subject_uri = "http://ontology.naas.ai/abi/1b765700-9fa1-4e1d-9496-108445aafb34"
+    predicate_uri = str(RDFS.label)
+    object_new_value = "Ford Motor Company"
+    language = "en"
+
+    configuration = UpdateDataPropertyPipelineConfiguration(
+        triple_store=services.triple_store_service
+    )
+
+    pipeline = UpdateDataPropertyPipeline(configuration)
+    graph = pipeline.run(
+        UpdateDataPropertyPipelineParameters(
+            subject_uri=subject_uri,
+            predicate_uri=predicate_uri,
+            object_new_value=object_new_value,
+            language=language,
+        )
+    )
+    logger.info(graph.serialize(format="turtle"))

naas_abi/pipelines/UpdateLegalNamePipeline.py

@@ -0,0 +1,107 @@
+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_core.pipeline import Pipeline, PipelineConfiguration, PipelineParameters
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from naas_abi_core.utils.Graph import ABI, URI_REGEX
+from pydantic import Field
+from rdflib import Graph, URIRef
+
+
+@dataclass
+class UpdateLegalNamePipelineConfiguration(PipelineConfiguration):
+    """Configuration for UpdateLegalNamePipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The triple store service to use
+    """
+
+    triple_store: ITripleStoreService
+
+
+class UpdateLegalNamePipelineParameters(PipelineParameters):
+    individual_uri: Annotated[
+        str, Field(description="URI of the legal name.", pattern=URI_REGEX)
+    ]
+    organization_uri: Annotated[
+        Optional[str],
+        Field(
+            None,
+            description="Organization URI from class: https://www.commoncoreontologies.org/ont00000443.",
+            pattern=URI_REGEX,
+        ),
+    ]
+
+
+class UpdateLegalNamePipeline(Pipeline):
+    __configuration: UpdateLegalNamePipelineConfiguration
+
+    def __init__(self, configuration: UpdateLegalNamePipelineConfiguration):
+        super().__init__(configuration)
+        self.__configuration = configuration
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        if not isinstance(parameters, UpdateLegalNamePipelineParameters):
+            raise ValueError(
+                "Parameters must be of type UpdateLegalNamePipelineParameters"
+            )
+
+        # Init graph
+        graph_insert = Graph()
+
+        # Get subject URI & graph
+        individual_uri = URIRef(parameters.individual_uri)
+        graph = self.__configuration.triple_store.get_subject_graph(individual_uri)
+
+        # Update properties
+        if parameters.organization_uri:
+            check_organization = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        ABI.isLegalNameOf,
+                        URIRef(parameters.organization_uri),
+                    )
+                )
+            )
+            if len(check_organization) == 0:
+                graph_insert.add(
+                    (
+                        individual_uri,
+                        ABI.isLegalNameOf,
+                        URIRef(parameters.organization_uri),
+                    )
+                )
+
+        # Save graph to triple store
+        self.__configuration.triple_store.insert(graph_insert)
+        graph += graph_insert
+        return graph
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name="update_legal_name",
+                description="Update a legal name in the ontology.",
+                func=lambda **kwargs: self.run(
+                    UpdateLegalNamePipelineParameters(**kwargs)
+                ),
+                args_schema=UpdateLegalNamePipelineParameters,
+            )
+        ]
+
+    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/UpdateLinkedInPagePipeline.py

@@ -0,0 +1,179 @@
+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_core.pipeline import Pipeline, PipelineConfiguration, PipelineParameters
+from naas_abi_core.services.triple_store.TripleStorePorts import ITripleStoreService
+from naas_abi_core.utils.Graph import ABI, URI_REGEX
+from pydantic import Field
+from rdflib import Graph, Literal, URIRef
+
+
+@dataclass
+class UpdateLinkedInPagePipelineConfiguration(PipelineConfiguration):
+    """Configuration for UpdateLinkedInPagePipeline.
+
+    Attributes:
+        triple_store (ITripleStoreService): The triple store service to use
+    """
+
+    triple_store: ITripleStoreService
+
+
+class UpdateLinkedInPagePipelineParameters(PipelineParameters):
+    individual_uri: Annotated[
+        str, Field(description="URI of the LinkedIn page.", pattern=URI_REGEX)
+    ]
+    linkedin_id: Annotated[
+        Optional[str], Field(None, description="LinkedIn unique ID of the individual.")
+    ]
+    linkedin_url: Annotated[
+        Optional[str],
+        Field(None, description="LinkedIn URL with the LinkedIn ID as identifier."),
+    ]
+    linkedin_public_id: Annotated[
+        Optional[str], Field(None, description="LinkedIn Public ID of the individual.")
+    ]
+    linkedin_public_url: Annotated[
+        Optional[str],
+        Field(
+            None,
+            description="LinkedIn Public URL of the individual with the LinkedIn Public ID as identifier.",
+            pattern=r"https?://.+\.linkedin\.com/(in|company|school|showcase)/[^?]+",
+        ),
+    ]
+    owner_uri: Annotated[
+        Optional[str],
+        Field(
+            None,
+            description="URI of the owner from class: https://www.commoncoreontologies.org/ont00001262 or https://www.commoncoreontologies.org/ont00000443",
+            pattern=URI_REGEX,
+        ),
+    ]
+
+
+class UpdateLinkedInPagePipeline(Pipeline):
+    """Pipeline for updating a LinkedIn page in the ontology."""
+
+    __configuration: UpdateLinkedInPagePipelineConfiguration
+
+    def __init__(self, configuration: UpdateLinkedInPagePipelineConfiguration):
+        super().__init__(configuration)
+        self.__configuration = configuration
+
+    def run(self, parameters: PipelineParameters) -> Graph:
+        if not isinstance(parameters, UpdateLinkedInPagePipelineParameters):
+            raise ValueError(
+                "Parameters must be of type UpdateLinkedInPagePipelineParameters"
+            )
+
+        # Initialize graphs
+        graph_insert = Graph()
+
+        # Get existing graph
+        graph = self.__configuration.triple_store.get_subject_graph(
+            parameters.individual_uri
+        )
+        individual_uri = URIRef(parameters.individual_uri)
+
+        # Update properties
+        if parameters.linkedin_id:
+            check_id = list(
+                graph.triples(
+                    (individual_uri, ABI.linkedin_id, Literal(parameters.linkedin_id))
+                )
+            )
+            if len(check_id) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.linkedin_id, Literal(parameters.linkedin_id))
+                )
+
+        if parameters.linkedin_url:
+            check_url = list(
+                graph.triples(
+                    (individual_uri, ABI.linkedin_url, Literal(parameters.linkedin_url))
+                )
+            )
+            if len(check_url) == 0:
+                graph_insert.add(
+                    (individual_uri, ABI.linkedin_url, Literal(parameters.linkedin_url))
+                )
+
+        if parameters.linkedin_public_id:
+            check_public_id = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        ABI.linkedin_public_id,
+                        Literal(parameters.linkedin_public_id),
+                    )
+                )
+            )
+            if len(check_public_id) == 0:
+                graph_insert.add(
+                    (
+                        individual_uri,
+                        ABI.linkedin_public_id,
+                        Literal(parameters.linkedin_public_id),
+                    )
+                )
+
+        if parameters.linkedin_public_url:
+            check_public_url = list(
+                graph.triples(
+                    (
+                        individual_uri,
+                        ABI.linkedin_public_url,
+                        Literal(parameters.linkedin_public_url),
+                    )
+                )
+            )
+            if len(check_public_url) == 0:
+                graph_insert.add(
+                    (
+                        individual_uri,
+                        ABI.linkedin_public_url,
+                        Literal(parameters.linkedin_public_url),
+                    )
+                )
+
+        if parameters.owner_uri:
+            owner_uri = URIRef(parameters.owner_uri)
+            check_owner = list(
+                graph.triples((individual_uri, ABI.isLinkedInPageOf, owner_uri))
+            )
+            if len(check_owner) == 0:
+                graph_insert.add((individual_uri, ABI.isLinkedInPageOf, owner_uri))
+                graph_insert.add((owner_uri, ABI.hasLinkedInPage, individual_uri))
+
+        # Save the graph
+        self.__configuration.triple_store.insert(graph_insert)
+        graph += graph_insert
+        return graph
+
+    def as_tools(self) -> list[BaseTool]:
+        return [
+            StructuredTool(
+                name="update_linkedin_page",
+                description="Update a LinkedIn page in the ontology.",
+                func=lambda **kwargs: self.run(
+                    UpdateLinkedInPagePipelineParameters(**kwargs)
+                ),
+                args_schema=UpdateLinkedInPagePipelineParameters,
+            )
+        ]
+
+    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