cognite-neat 0.105.1__tar.gz → 0.105.2__tar.gz

{cognite_neat-0.105.1 → cognite_neat-0.105.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.105.1
+Version: 0.105.2
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

{cognite_neat-0.105.1 → cognite_neat-0.105.2}/cognite/neat/_graph/transformers/_classic_cdf.py

@@ -1,4 +1,3 @@
-import textwrap
 import warnings
 from abc import ABC
 from collections.abc import Callable, Iterable
@@ -15,6 +14,7 @@ from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import (
     Triple,
     add_triples_in_batch,
+    get_namespace,
     remove_instance_ids_in_batch,
     remove_namespace_from_uri,
 )
@@ -72,87 +72,161 @@ class AddAssetDepth(BaseTransformerStandardised):
         return row_output
 
 
-# TODO: standardise
-class BaseAssetConnector(BaseTransformer, ABC):
-    _asset_type: URIRef = DEFAULT_NAMESPACE.Asset
-    _item_type: URIRef
-    _default_attribute: URIRef
-    _connection_type: URIRef
+class BaseAssetConnector(BaseTransformerStandardised, ABC):
+    description: str = "Connects assets to other cognite resources, thus forming bi-directional connection"
+    _use_only_once: bool = True
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?asset) as ?count)
+                   WHERE {{
+                        ?resource a <{resource_type}> .
+                        ?resource <{connection}> ?asset .
+                        ?asset a <{asset_type}> .
+                        }}"""
 
-    _select_item_ids = "SELECT DISTINCT ?item_id WHERE {{?item_id a <{item_type}>}}"
-    _select_connected_assets: str = textwrap.dedent("""SELECT ?asset_id WHERE {{
-                              <{item_id}> <{attribute}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}""")
+        return query.format(
+            asset_type=self.asset_type,
+            resource_type=self.resource_type,
+            connection=self.resource_to_asset_connection,
+        )
 
-    def __init__(self, attribute: URIRef | None = None) -> None:
-        self._attribute = attribute or self._default_attribute
+    def _iterate_query(self) -> str:
+        query = """SELECT ?asset ?resource
+                   WHERE {{
+                        ?resource a <{resource_type}> .
+                        ?resource <{connection}> ?asset .
+                        ?asset a <{asset_type}> .
+                        }}"""
 
-    def transform(self, graph: Graph) -> None:
-        for item_id, *_ in graph.query(self._select_item_ids.format(item_type=self._item_type)):  # type: ignore[misc]
-            triples: list[Triple] = []
-            for asset_id, *_ in graph.query(  # type: ignore[misc]
-                self._select_connected_assets.format(
-                    item_id=item_id, attribute=self._attribute, asset_type=self._asset_type
-                )
-            ):
-                triples.append((asset_id, self._connection_type, item_id))  # type: ignore[arg-type]
-            add_triples_in_batch(graph, triples)
+        return query.format(
+            asset_type=self.asset_type,
+            resource_type=self.resource_type,
+            connection=self.resource_to_asset_connection,
+        )
+
+    def __init__(
+        self,
+        resource_to_asset_connection: URIRef,
+        resource_type: URIRef,
+        asset_to_resource_connection: URIRef | None = None,
+        asset_type: URIRef | None = None,
+    ) -> None:
+        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
+        self.resource_to_asset_connection = resource_to_asset_connection
+        self.resource_type = resource_type
+
+        if asset_to_resource_connection:
+            self.asset_to_resource_connection = asset_to_resource_connection
+        else:
+            namespace = Namespace(get_namespace(resource_type))
+            type_ = remove_namespace_from_uri(resource_type)
+            self.asset_to_resource_connection = namespace[type_[0].lower() + type_[1:]]
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        subject, object = query_result_row
+
+        row_output.add_triples.append(cast(Triple, (subject, self.asset_to_resource_connection, object)))
+
+        row_output.instances_modified_count += 1
+
+        return row_output
 
 
 class AssetTimeSeriesConnector(BaseAssetConnector):
     description: str = "Connects assets to timeseries, thus forming bi-directional connection"
-    _use_only_once: bool = True
     _need_changes = frozenset(
         {
             str(extractors.AssetsExtractor.__name__),
             str(extractors.TimeSeriesExtractor.__name__),
         }
     )
-    _item_type = DEFAULT_NAMESPACE.TimeSeries
-    _default_attribute = DEFAULT_NAMESPACE.assetId
-    _connection_type = DEFAULT_NAMESPACE.timeSeries
+
+    def __init__(
+        self,
+        resource_to_asset_connection: URIRef | None = None,
+        resource_type: URIRef | None = None,
+        asset_to_resource_connection: URIRef | None = None,
+        asset_type: URIRef | None = None,
+    ):
+        super().__init__(
+            resource_to_asset_connection=resource_to_asset_connection or DEFAULT_NAMESPACE.assetId,
+            resource_type=resource_type or DEFAULT_NAMESPACE.TimeSeries,
+            asset_to_resource_connection=asset_to_resource_connection or DEFAULT_NAMESPACE.timeSeries,
+            asset_type=asset_type or DEFAULT_NAMESPACE.Asset,
+        )
 
 
 class AssetSequenceConnector(BaseAssetConnector):
     description: str = "Connects assets to sequences, thus forming bi-directional connection"
-    _use_only_once: bool = True
     _need_changes = frozenset(
         {
             str(extractors.AssetsExtractor.__name__),
             str(extractors.SequencesExtractor.__name__),
         }
     )
-    _item_type = DEFAULT_NAMESPACE.Sequence
-    _default_attribute = DEFAULT_NAMESPACE.assetId
-    _connection_type = DEFAULT_NAMESPACE.sequence
+
+    def __init__(
+        self,
+        resource_to_asset_connection: URIRef | None = None,
+        resource_type: URIRef | None = None,
+        asset_to_resource_connection: URIRef | None = None,
+        asset_type: URIRef | None = None,
+    ):
+        super().__init__(
+            resource_to_asset_connection=resource_to_asset_connection or DEFAULT_NAMESPACE.assetId,
+            resource_type=resource_type or DEFAULT_NAMESPACE.Sequence,
+            asset_to_resource_connection=asset_to_resource_connection or DEFAULT_NAMESPACE.sequence,
+            asset_type=asset_type or DEFAULT_NAMESPACE.Asset,
+        )
 
 
 class AssetFileConnector(BaseAssetConnector):
     description: str = "Connects assets to files, thus forming bi-directional connection"
-    _use_only_once: bool = True
     _need_changes = frozenset(
         {
             str(extractors.AssetsExtractor.__name__),
             str(extractors.FilesExtractor.__name__),
         }
     )
-    _item_type = DEFAULT_NAMESPACE.File
-    _default_attribute = DEFAULT_NAMESPACE.assetIds
-    _connection_type = DEFAULT_NAMESPACE.file
+
+    def __init__(
+        self,
+        resource_to_asset_connection: URIRef | None = None,
+        resource_type: URIRef | None = None,
+        asset_to_resource_connection: URIRef | None = None,
+        asset_type: URIRef | None = None,
+    ):
+        super().__init__(
+            resource_to_asset_connection=resource_to_asset_connection or DEFAULT_NAMESPACE.assetIds,
+            resource_type=resource_type or DEFAULT_NAMESPACE.File,
+            asset_to_resource_connection=asset_to_resource_connection or DEFAULT_NAMESPACE.file,
+            asset_type=asset_type or DEFAULT_NAMESPACE.Asset,
+        )
 
 
 class AssetEventConnector(BaseAssetConnector):
     description: str = "Connects assets to events, thus forming bi-directional connection"
-    _use_only_once: bool = True
     _need_changes = frozenset(
         {
             str(extractors.AssetsExtractor.__name__),
             str(extractors.EventsExtractor.__name__),
         }
     )
-    _item_type = DEFAULT_NAMESPACE.Event
-    _default_attribute = DEFAULT_NAMESPACE.assetIds
-    _connection_type = DEFAULT_NAMESPACE.event
+
+    def __init__(
+        self,
+        resource_to_asset_connection: URIRef | None = None,
+        resource_type: URIRef | None = None,
+        asset_to_resource_connection: URIRef | None = None,
+        asset_type: URIRef | None = None,
+    ):
+        super().__init__(
+            resource_to_asset_connection=resource_to_asset_connection or DEFAULT_NAMESPACE.assetIds,
+            resource_type=resource_type or DEFAULT_NAMESPACE.Event,
+            asset_to_resource_connection=asset_to_resource_connection or DEFAULT_NAMESPACE.event,
+            asset_type=asset_type or DEFAULT_NAMESPACE.Asset,
+        )
 
 
 # TODO: standardise

{cognite_neat-0.105.1 → cognite_neat-0.105.2}/cognite/neat/_utils/auth.py

@@ -23,8 +23,9 @@ def get_cognite_client(env_file_name: str) -> CogniteClient:
     be prompted to enter them.
 
     Args:
-        env_file_name: The name of the .env file to look for in the repository root. If the file is found, the variables
-            will be loaded from the file. If the file is not found, the user will be prompted to enter the variables.
+        env_file_name: The name of the .env file to look for in the repository root / current working directory. If
+        the file is found, the variables will be loaded from the file. If the file is not found, the user will
+        be prompted to enter the variables and the file will be created.
 
     Returns:
         CogniteClient: A CogniteClient instance.
@@ -40,26 +41,44 @@ def get_cognite_client(env_file_name: str) -> CogniteClient:
             client = variables.get_client()
             print(f"Found {env_file_name} file in repository root. Loaded variables from {env_file_name} file.")
             return client
+    elif (Path.cwd() / env_file_name).exists():
+        with suppress(KeyError, FileNotFoundError, TypeError):
+            variables = _from_dotenv(Path.cwd() / env_file_name)
+            client = variables.get_client()
+            print(
+                f"Found {env_file_name} file in current working directory. Loaded variables from {env_file_name} file."
+            )
+            return client
     # Then try to load from environment variables
     with suppress(KeyError):
         variables = EnvironmentVariables.create_from_environ()
+        print("Loaded variables from environment variables.")
         return variables.get_client()
     # If not found, prompt the user
     variables = _prompt_user()
     if repo_root and _env_in_gitignore(repo_root, env_file_name):
-        local_import("rich", "jupyter")
-        from rich.prompt import Prompt
-
         env_file = repo_root / env_file_name
-        answer = Prompt.ask(
-            f"Do you store the variables in an {env_file_name} file in the repository root for easy reuse?",
-            choices=["y", "n"],
-        )
-        if env_file.exists():
-            answer = Prompt.ask(f"{env_file} already exists. Overwrite?", choices=["y", "n"])
-        if answer == "y":
-            env_file.write_text(variables.create_env_file())
-            print(f"Created {env_file_name} file in repository root.")
+        location = "repository root"
+    elif repo_root:
+        # We do not offer to create the file in the repository root if it is in .gitignore
+        # as an inexperienced user might accidentally commit it.
+        print("Cannot create .env file in repository root as there is no .env entry in the .gitignore.")
+        return variables.get_client()
+    else:
+        env_file = Path.cwd() / env_file_name
+        location = "current working directory"
+    local_import("rich", "jupyter")
+    from rich.prompt import Prompt
+
+    answer = Prompt.ask(
+        f"Do you store the variables in an {env_file_name} file in the {location} for easy reuse?",
+        choices=["y", "n"],
+    )
+    if env_file.exists():
+        answer = Prompt.ask(f"{env_file} already exists. Overwrite?", choices=["y", "n"])
+    if answer == "y":
+        env_file.write_text(variables.create_env_file())
+        print(f"Created {env_file_name} file in {location}.")
 
     return variables.get_client()
 
@@ -320,7 +339,8 @@ def _prompt_cluster_and_project() -> EnvironmentVariables:
 def _repo_root() -> Path | None:
     with suppress(Exception):
         result = subprocess.run("git rev-parse --show-toplevel".split(), stdout=subprocess.PIPE)
-        return Path(result.stdout.decode().strip())
+        if (output := result.stdout.decode().strip()) != "":
+            return Path(output)
     return None
 
 

cognite_neat-0.105.2/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.105.2"
+__engine__ = "^2.0.3"

{cognite_neat-0.105.1 → cognite_neat-0.105.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.105.1"
+version = "0.105.2"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.105.1/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.105.1"
-__engine__ = "^2.0.3"