cognite-neat 0.123.23__tar.gz → 0.123.25__tar.gz

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.23
+Version: 0.123.25
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

cognite_neat-0.123.25/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.123.25"
+__engine__ = "^2.0.4"

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/cognite/neat/core/_constants.py

@@ -250,6 +250,11 @@ def is_hierarchy_property(container: dm.ContainerId, property_: str) -> bool:
     )
 
 
+def cognite_prefixes() -> dict[str, Namespace]:
+    """Returns the Cognite prefixes and namespaces."""
+    return {space: Namespace(CDF_NAMESPACE[space] + "/") for space in COGNITE_SPACES}
+
+
 DMS_RESERVED_PROPERTIES = frozenset(
     {
         "createdTime",

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/cognite/neat/core/_data_model/importers/_rdf/_shared.py

@@ -1,17 +1,21 @@
-from typing import cast
+from typing import Any, Literal, cast
 from urllib.parse import quote
 
-from rdflib import BNode, Graph
+from rdflib import BNode, Graph, Namespace, URIRef
+from rdflib import Literal as RdfLiteral
 from rdflib.plugins.sparql import prepareQuery
 from rdflib.query import ResultRow
 
+from cognite.neat.core._constants import cognite_prefixes
+from cognite.neat.core._data_model.models.entities._constants import Unknown
+from cognite.neat.core._data_model.models.entities._single_value import ConceptEntity
 from cognite.neat.core._issues._base import IssueList
 from cognite.neat.core._issues.errors._general import NeatValueError
 from cognite.neat.core._issues.warnings._resources import (
     ResourceRedefinedWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._utils.rdf_ import convert_rdflib_content
+from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_to_entity_components
 
 
 def parse_concepts(
@@ -33,27 +37,31 @@ def parse_concepts(
     concepts: dict[str, dict] = {}
 
     query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
+    prefixes = cognite_prefixes()
 
     for raw in graph.query(query):
-        res: dict = convert_rdflib_content(cast(ResultRow, raw).asdict(), True)
+        res: dict = convert_rdflib_content(
+            cast(ResultRow, raw).asdict(), uri_handling="as-concept-entity", prefixes=prefixes
+        )
         res = {key: res.get(key, None) for key in parameters}
 
-        # Quote the concept id to ensure it is web-safe
-        res["concept"] = quote(res["concept"], safe="")
-
-        concept_id = res["concept"]
-
         # Safeguarding against incomplete semantic definitions
         if res["implements"] and isinstance(res["implements"], BNode):
             issue_list.append(
                 ResourceRetrievalWarning(
-                    concept_id,
+                    res["concept"],
                     "implements",
                     error=("Unable to determine concept that is being implemented"),
                 )
             )
             continue
 
+        # sanitize the concept and implements
+        res["concept"] = sanitize_entity(res["concept"])
+        res["implements"] = sanitize_entity(res["implements"]) if res["implements"] else None
+
+        concept_id = res["concept"]
+
         if concept_id not in concepts:
             concepts[concept_id] = res
         else:
@@ -72,7 +80,6 @@ def parse_concepts(
 
             handle_meta("concept", concepts, concept_id, res, "name", issue_list)
             handle_meta("concept", concepts, concept_id, res, "description", issue_list)
-
     if not concepts:
         issue_list.append(NeatValueError("Unable to parse concepts"))
 
@@ -98,9 +105,12 @@ def parse_properties(
     properties: dict[str, dict] = {}
 
     query = prepareQuery(query.format(language=language), initNs={k: v for k, v in graph.namespaces()})
+    prefixes = cognite_prefixes()
 
     for raw in graph.query(query):
-        res: dict = convert_rdflib_content(cast(ResultRow, raw).asdict(), True)
+        res: dict = convert_rdflib_content(
+            cast(ResultRow, raw).asdict(), uri_handling="as-concept-entity", prefixes=prefixes
+        )
         res = {key: res.get(key, None) for key in parameters}
 
         # Quote the concept id to ensure it is web-safe
@@ -129,9 +139,9 @@ def parse_properties(
             )
             continue
 
-        # Quote the concept and value_type to ensure they are web-safe
-        res["concept"] = quote(res["concept"], safe="") if res["concept"] else "#N/A"
-        res["value_type"] = quote(res["value_type"], safe="") if res["value_type"] else "#N/A"
+        # Quote the concept and value_type if they exist if not signal neat that they are not available
+        res["concept"] = sanitize_entity(res["concept"]) if res["concept"] else str(Unknown)
+        res["value_type"] = sanitize_entity(res["value_type"]) if res["value_type"] else str(Unknown)
 
         id_ = f"{res['concept']}.{res['property_']}"
 
@@ -173,14 +183,73 @@ def handle_meta(
     if not resources[resource_id][feature] and res[feature]:
         resources[resource_id][feature] = res[feature]
 
-    # RAISE warning only if the feature is being redefined
-    elif resources[resource_id][feature] and res[feature]:
+    current_value = resources[resource_id][feature]
+    new_value = res[feature]
+
+    if not current_value and new_value:
+        resources[resource_id][feature] = new_value
+    elif current_value and new_value and current_value != new_value:
         issue_list.append(
             ResourceRedefinedWarning(
                 identifier=resource_id,
                 resource_type=resource_type,
                 feature=feature,
-                current_value=resources[resource_id][feature],
-                new_value=res[feature],
+                current_value=current_value,
+                new_value=new_value,
             )
         )
+
+
+def convert_rdflib_content(
+    content: RdfLiteral | URIRef | dict | list,
+    uri_handling: Literal["skip", "remove-namespace", "as-concept-entity"] = "skip",
+    prefixes: dict[str, Namespace] | None = None,
+) -> Any:
+    """Converts rdflib content to a more Python-friendly format.
+
+    Args:
+        content: The content to convert, can be a RdfLiteral, URIRef, dict, or list.
+        uri_handling: How to handle URIs. Options are:
+            - "skip": Leave URIs as is.
+            - "remove-namespace": Remove the namespace from URIs.
+            - "short-form": Convert URIs to a short form using prefixes.
+
+    """
+    if isinstance(content, RdfLiteral):
+        return content.toPython()
+    elif isinstance(content, URIRef):
+        if uri_handling == "remove-namespace":
+            return remove_namespace_from_uri(content)
+        elif uri_handling == "as-concept-entity":
+            if components := uri_to_entity_components(content, prefixes or {}):
+                return ConceptEntity(prefix=components[0], suffix=components[3], version=components[2])
+            # fallback to "remove-namespace"
+            else:
+                return convert_rdflib_content(content, uri_handling="remove-namespace", prefixes=prefixes)
+        else:
+            return content.toPython()
+    elif isinstance(content, dict):
+        return {key: convert_rdflib_content(value, uri_handling, prefixes) for key, value in content.items()}
+    elif isinstance(content, list):
+        return [convert_rdflib_content(item, uri_handling, prefixes) for item in content]
+    else:
+        return content
+
+
+def sanitize_entity(entity: str | ConceptEntity, safe: str = "") -> str:
+    """Sanitize an entity to ensure it yields entity form that will pass downstream validation.
+
+    Args:
+        entity: The entity to sanitize. Can be a string or a ConceptEntity.
+        safe: Characters that should not be quoted during sanitization.
+
+    Returns:
+        A web-safe string representation of the entity
+    """
+    if isinstance(entity, str):
+        return quote(entity, safe=safe)
+    # if it already we dont need to quote it so we return its string representation
+    elif isinstance(entity, ConceptEntity):
+        return str(entity)
+    else:
+        raise ValueError(f"Invalid entity type: {type(entity)}. Expected str, ConceptEntity.")

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/cognite/neat/core/_utils/rdf_.py

@@ -147,19 +147,6 @@ def as_neat_compliant_uri(uri: URIRef) -> URIRef:
     return URIRef(f"{namespace}{compliant_uri}")
 
 
-def convert_rdflib_content(content: RdfLiteral | URIRef | dict | list, remove_namespace: bool = False) -> Any:
-    if isinstance(content, RdfLiteral):
-        return content.toPython()
-    elif isinstance(content, URIRef):
-        return remove_namespace_from_uri(content) if remove_namespace else content.toPython()
-    elif isinstance(content, dict):
-        return {key: convert_rdflib_content(value, remove_namespace) for key, value in content.items()}
-    elif isinstance(content, list):
-        return [convert_rdflib_content(item, remove_namespace) for item in content]
-    else:
-        return content
-
-
 def uri_to_short_form(URI: URIRef, prefixes: dict[str, Namespace]) -> str | URIRef:
     """Returns the short form of a URI if its namespace is present in the prefixes dict,
     otherwise returns the URI itself
@@ -179,6 +166,43 @@ def uri_to_short_form(URI: URIRef, prefixes: dict[str, Namespace]) -> str | URIR
     return min(uris, key=len)
 
 
+def uri_to_entity_components(uri: URIRef, prefixes: dict[str, Namespace]) -> tuple[str, str, str, str] | None:
+    """Converts a URI to its components: space, data_model_id, version, and entity_id.
+    Args:
+        uri: URI to be converted
+        prefixes: dict of prefixes
+
+    Returns:
+        tuple of space, data_model_id, version, and entity_id if found,
+        otherwise None
+
+    !!! note "URI Format"
+        The URI is expected to be in the form of `.../<space>/<data_model_id>/<version>/<entity_id>` to
+        be able to extract the components correctly.
+
+        An example of a valid entity URI is:
+
+        `https://cognitedata.com/cdf_cdm/CogniteCore/v1/CogniteAsset` , where:
+
+        - space is `cdf_cdm`
+        - data_model_id is `CogniteCore`
+        - version is `v1`
+        - entity_id is `CogniteAsset`
+
+        to be able to parse the URI correctly, the prefixes dict must have
+        the corresponding prefix registered:
+        {'cdf_cdm': Namespace('https://cognitedata.com/cdf_cdm/CogniteCore/v1/')}
+
+        for this method to return the correct components.
+    """
+    for prefix, namespace in prefixes.items():
+        if uri.startswith(namespace):
+            remainder = str(uri)[len(str(namespace)) :]
+            if (components := remainder.split("/")) and len(components) == 3 and all(components):
+                return prefix, components[0], components[1], components[2]
+    return None
+
+
 def _traverse(hierarchy: dict, graph: dict, names: list[str]) -> dict:
     """traverse the graph and return the hierarchy"""
     for name in names:

cognite_neat-0.123.25/last_changelog_entry.md

@@ -0,0 +1,3 @@
+### Improved
+
+- Redefinition warning only occurs when redefinition actually take place

cognite_neat-0.123.25/last_git_message.txt

@@ -0,0 +1,21 @@
+trigger warning when redefinition occurs (#1265)
+
+# Description
+
+We were triggering redefinition warning irrespect if the redefinition
+took change or not.
+
+## Bump
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## Changelog
+### Improved
+
+- Redefinition warning only occurs when redefinition actually take place
+
+---------
+
+Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

cognite_neat-0.123.25/last_version.txt

@@ -0,0 +1 @@
+0.123.24

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.123.23"
+version = "0.123.25"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/tests/data/_schema/conceptual/ontology.ttl

@@ -5,6 +5,7 @@
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 @base <http://example.com/industrial#> .
+@prefix cdf_cdm: <https://cognitedata.com/cdf_cdm/CogniteCore/v1/> .
 
 <http://example.com/industrial> rdf:type owl:Ontology .
 
@@ -85,5 +86,10 @@
 <http://example.com/industrial/Sensor.Unit_01(Temp)~?@!$&'*+,;=%[]> rdf:type owl:Class ;
                                                                     rdfs:label "Temperature Sensor Unit" .
 
+###  http://example.com/industrial/Sensor
+<http://example.com/industrial/Sensor> rdf:type owl:Class ;
+                                       rdfs:subClassOf cdf_cdm:CogniteAsset ;
+                                       rdfs:label "Temperature Sensor Unit" .
+
 
 ###  Generated by the OWL API (version 4.5.29.2024-05-13T12:11:03Z) https://github.com/owlcs/owlapi

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/tests/tests_unit/test_rules/test_importers/test_owl_importer.py

@@ -61,6 +61,7 @@ def test_owl_enitity_quoting():
         ConceptEntity(
             prefix="neat_space", suffix="Sensor.Unit_01%28Temp%29~%3F%40%21%24%26%27%2A%2B%2C%3B%3D%25%5B%5D"
         ),
+        ConceptEntity(prefix="neat_space", suffix="Sensor"),
     }
 
     expected_properties = {
@@ -75,5 +76,10 @@ def test_owl_enitity_quoting():
         "reports.Status-Flag%28OK%29%3A1~%3F%40%21%24%26%27%2A%2B%2C%3B%3D%25%5B%5D",
     }
 
-    assert {concept.concept for concept in conceptual_data_model.concepts} == expected_concepts
-    assert {prop.property_ for prop in conceptual_data_model.properties} == expected_properties
+    actual_concepts = {concept.concept: concept for concept in conceptual_data_model.concepts}
+    actual_properties = {prop.property_ for prop in conceptual_data_model.properties}
+    assert set(actual_concepts) == expected_concepts
+    assert actual_properties == expected_properties
+    assert actual_concepts[ConceptEntity(prefix="neat_space", suffix="Sensor")].implements == [
+        ConceptEntity(prefix="cdf_cdm", suffix="CogniteAsset", version="v1")
+    ]

cognite_neat-0.123.25/tests/tests_unit/test_utils/test_rdf.py

@@ -0,0 +1,92 @@
+import pytest
+from rdflib import Namespace, URIRef
+
+from cognite.neat.core._constants import DEFAULT_SPACE_URI
+from cognite.neat.core._utils.rdf_ import uri_to_cdf_id, uri_to_entity_components
+
+
+class TestURIInstanceToDisplayName:
+    @pytest.mark.parametrize(
+        "uri, expected",
+        [
+            (URIRef("http://example.com/namespace#instance"), "instance"),
+            (URIRef("http://example.com/namespace#"), ""),
+            (Namespace(DEFAULT_SPACE_URI.format(space="my_space"))["myInstance"], "my_space:myInstance"),
+            (URIRef("http://example.com/namespace#instance"), "instance"),
+            (URIRef(" http://example.com/namespace#"), ""),
+            (URIRef("http://example.com/namespace"), "namespace"),
+            (URIRef("http://example.com/namespace#instance/subinstance"), "instance/subinstance"),
+            (URIRef("http://example.com/namespace#instance?query=param"), "instance?query=param"),
+            (URIRef("http://example.com/namespace#instance#fragment"), "instance#fragment"),
+            (URIRef("http://example.com/namespace#instance%20with%20spaces"), "instance with spaces"),
+            (
+                URIRef("http://example.com/namespace#instance_with_special_chars!@#$%^&*()"),
+                "instance_with_special_chars!@#$%^&*()",
+            ),
+            (URIRef("http://example.com/namespace#instance_with_unicode_✓"), "instance_with_unicode_✓"),
+        ],
+    )
+    def test_uri_to_cdf_id(self, uri: URIRef, expected: str) -> None:
+        assert uri_to_cdf_id(uri) == expected
+
+
+class TestURIToEntityComponents:
+    @pytest.mark.parametrize(
+        "uri, prefixes, expected",
+        [
+            # Valid URI with matching format
+            (
+                URIRef("https://cognitedata.com/cdf_cdm/CogniteCore/v1/CogniteAsset"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                ("cdf_cdm", "CogniteCore", "v1", "CogniteAsset"),
+            ),
+            # No matching prefix
+            (
+                URIRef("https://example.com/space/model/v1/entity"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                None,
+            ),
+            # Incomplete components (fewer than 3)
+            (
+                URIRef("https://cognitedata.com/cdf_cdm/CogniteCore/v1"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                None,
+            ),
+            # Empty components
+            (
+                URIRef("https://cognitedata.com/cdf_cdm//v1/"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                None,
+            ),
+            # Multiple prefixes - should return first match
+            (
+                URIRef("https://cognitedata.com/space/model/v1/entity"),
+                {
+                    "prefix1": Namespace("https://cognitedata.com/"),
+                    "prefix2": Namespace("https://cognitedata.com/space/"),
+                },
+                ("prefix2", "model", "v1", "entity"),
+            ),
+            # Empty prefixes dictionary
+            (
+                URIRef("https://cognitedata.com/cdf_cdm/CogniteCore/v1/CogniteAsset"),
+                {},
+                None,
+            ),
+            # Exact namespace match
+            (
+                URIRef("https://cognitedata.com/cdf_cdm/"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                None,
+            ),
+            # Too many components (more than 3)
+            (
+                URIRef("https://cognitedata.com/cdf_cdm/CogniteCore/v1/CogniteAsset/extra"),
+                {"cdf_cdm": Namespace("https://cognitedata.com/cdf_cdm/")},
+                None,
+            ),
+        ],
+    )
+    def test_uri_to_entity_components(self, uri: URIRef, prefixes: dict, expected: tuple | None) -> None:
+        result = uri_to_entity_components(uri, prefixes)
+        assert result == expected

{cognite_neat-0.123.23 → cognite_neat-0.123.25}/uv.lock

@@ -346,7 +346,7 @@ wheels = [
 
 [[package]]
 name = "cognite-neat"
-version = "0.123.23"
+version = "0.123.25"
 source = { editable = "." }
 dependencies = [
     { name = "backports-strenum", marker = "python_full_version < '3.11'" },

cognite_neat-0.123.23/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.123.23"
-__engine__ = "^2.0.4"

cognite_neat-0.123.23/last_changelog_entry.md

@@ -1,4 +0,0 @@
-### Added
-
-- Data model write endpoints accessible via `neat.data_model.write[yaml,
-ontology, shacl, cdf, excel]`

cognite_neat-0.123.23/last_git_message.txt

@@ -1,29 +0,0 @@
-Adding write endpoints for neat.data_model (#1262)
-
-# Description
-
-This PR adds (copy) endpoint for writing data model from NeatSession to
-targeted format (ontology, shacl) or CDF.
-
-Risk reviewing: This PR does not bring any new functionalities. Methods
-already exist but are accessible via functional approach in interaction
-with NeatSession. They are copied to be "object oriented" accessible.
-There are already existing tests, so no tests are added.
-
-This is stacked PR on top of #1261 
-
-## Bump
-
-- [x] Patch
-- [ ] Minor
-- [ ] Skip
-
-## Changelog
-### Added
-
-- Data model write endpoints accessible via `neat.data_model.write[yaml,
-ontology, shacl, cdf, excel]`
-
----------
-
-Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

cognite_neat-0.123.23/last_version.txt

@@ -1 +0,0 @@
-0.123.22

cognite_neat-0.123.23/tests/tests_unit/test_utils/test_rdf.py

@@ -1,30 +0,0 @@
-import pytest
-from rdflib import Namespace, URIRef
-
-from cognite.neat.core._constants import DEFAULT_SPACE_URI
-from cognite.neat.core._utils.rdf_ import uri_to_cdf_id
-
-
-class TestURIInstanceToDisplayName:
-    @pytest.mark.parametrize(
-        "uri, expected",
-        [
-            (URIRef("http://example.com/namespace#instance"), "instance"),
-            (URIRef("http://example.com/namespace#"), ""),
-            (Namespace(DEFAULT_SPACE_URI.format(space="my_space"))["myInstance"], "my_space:myInstance"),
-            (URIRef("http://example.com/namespace#instance"), "instance"),
-            (URIRef(" http://example.com/namespace#"), ""),
-            (URIRef("http://example.com/namespace"), "namespace"),
-            (URIRef("http://example.com/namespace#instance/subinstance"), "instance/subinstance"),
-            (URIRef("http://example.com/namespace#instance?query=param"), "instance?query=param"),
-            (URIRef("http://example.com/namespace#instance#fragment"), "instance#fragment"),
-            (URIRef("http://example.com/namespace#instance%20with%20spaces"), "instance with spaces"),
-            (
-                URIRef("http://example.com/namespace#instance_with_special_chars!@#$%^&*()"),
-                "instance_with_special_chars!@#$%^&*()",
-            ),
-            (URIRef("http://example.com/namespace#instance_with_unicode_✓"), "instance_with_unicode_✓"),
-        ],
-    )
-    def test_uri_to_cdf_id(self, uri: URIRef, expected: str) -> None:
-        assert uri_to_cdf_id(uri) == expected