cognite-neat 0.123.29__tar.gz → 0.123.31__tar.gz

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/.github/workflows/code-quality.yaml

@@ -148,3 +148,29 @@ jobs:
             fs.writeFileSync('last_git_message.txt', description);
       - name: Validate Changelog section in PR description
         run: uv run python dev.py changelog
+
+  build_and_test_jupyter_pyodide:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ env.MAIN_PYTHON_VERSION }}
+
+      - name: Build package using uv
+        run: uv build
+      - name: Set up Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: "22"
+      - name: Install dependencies
+        run: npm install pyodide@0.27.6 # JupyterLite currently using pyodide 0.26.2
+      - name: Install neat in pyodide environment
+        run: |
+          whl_file=$(find dist -name "*.whl" | sed 's|^dist/||') # Find the built wheel file, remove dist/ prefix
+          echo "Found built wheel file: $whl_file"
+          NEAT_FILE_PATH=$whl_file \
+          PACKAGES="[\"pyodide-http\", \"pandas\", \"typing-extensions>=4.14.0\", \"http://localhost:3000/dist/$whl_file\"]" \
+          node test-pyodide.js

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
   - hooks:
     - id: mypy
       name: mypy
-      entry: dmypy run -- cognite/neat/
+      entry: dmypy run -- cognite/neat/ tests/tests_unit_v1/
       files: ^.*.(py|pyi)$
       language: system
       pass_filenames: false

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.29
+Version: 0.123.31
 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.31/cognite/neat/_data_model/models/dms/__init__.py

@@ -0,0 +1,10 @@
+from ._base import Resource, WriteableResource
+from ._space import Space, SpaceRequest, SpaceResponse
+
+__all__ = [
+    "Resource",
+    "Space",
+    "SpaceRequest",
+    "SpaceResponse",
+    "WriteableResource",
+]

cognite_neat-0.123.31/cognite/neat/_data_model/models/dms/_base.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+
+class BaseModelObject(BaseModel, alias_generator=to_camel, extra="ignore"):
+    """Base class for all object. This includes resources and nested objects."""
+
+    ...
+
+
+class Resource(BaseModelObject):
+    """Base class for all data modeling resources."""
+
+    ...
+
+
+T_Resource = TypeVar("T_Resource", bound=Resource)
+
+
+class WriteableResource(Generic[T_Resource], Resource, ABC):
+    @abstractmethod
+    def as_request(self) -> T_Resource:
+        """Convert the response model to a request model by removing read-only fields."""
+        raise NotImplementedError()

cognite_neat-0.123.31/cognite/neat/_data_model/models/dms/_constants.py

@@ -0,0 +1,2 @@
+SPACE_FORMAT_PATTERN = r"[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
+FORBIDDEN_SPACES = frozenset(["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"])

cognite_neat-0.123.31/cognite/neat/_data_model/models/dms/_space.py

@@ -0,0 +1,44 @@
+from abc import ABC
+
+from pydantic import Field, field_validator
+
+from cognite.neat.core._utils.text import humanize_collection
+
+from ._base import WriteableResource
+from ._constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN
+
+
+class Space(WriteableResource["SpaceRequest"], ABC):
+    space: str = Field(
+        description="The Space identifier (id).",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    name: str | None = Field(None, description="Name of the space.", max_length=1024)
+    description: str | None = Field(None, description="The description of the space.", max_length=255)
+
+    @field_validator("space")
+    def check_forbidden_space_value(cls, val: str) -> str:
+        """Check the space name not present in forbidden set"""
+        if val in FORBIDDEN_SPACES:
+            raise ValueError(f"{val!r} is a reserved space. Reserved Spaces: {humanize_collection(FORBIDDEN_SPACES)}")
+        return val
+
+    def as_request(self) -> "SpaceRequest":
+        return SpaceRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class SpaceResponse(Space):
+    created_time: int = Field(
+        description="When the space was created. The number of milliseconds since 00:00:00 Thursday, 1 January 1970, "
+        "Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    last_updated_time: int = Field(
+        description="When the space was last updated. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    is_global: bool = Field(description="Whether the space is a global space.")
+
+
+class SpaceRequest(Space): ...

cognite_neat-0.123.31/cognite/neat/_utils/auxiliary.py

@@ -0,0 +1,32 @@
+import inspect
+from abc import ABC
+from typing import TypeVar
+
+T_Cls = TypeVar("T_Cls")
+
+
+def get_concrete_subclasses(base_cls: type[T_Cls], exclude_direct_abc_inheritance: bool = True) -> list[type[T_Cls]]:
+    """
+    Returns a list of all concrete subclasses of the given base class.
+    Args:
+        base_cls (type[T_Cls]): The base class to find subclasses for.
+        exclude_direct_abc_inheritance (bool): If True, excludes classes that directly inherit from `abc.ABC`.
+            This is used as a marker to filter out intermediate base classes. Defaults to True.
+    Returns:
+        list[type[T_Cls]]: A list of concrete subclasses of the base class.
+    """
+    to_check = [base_cls]
+    subclasses: list[type[T_Cls]] = []
+    seen: set[type[T_Cls]] = {base_cls}
+    while to_check:
+        current_cls = to_check.pop()
+        for subclass in current_cls.__subclasses__():
+            if subclass in seen:
+                continue
+            if (not inspect.isabstract(subclass)) and (
+                not exclude_direct_abc_inheritance or ABC not in subclass.__bases__
+            ):
+                subclasses.append(subclass)
+            seen.add(subclass)
+            to_check.append(subclass)
+    return subclasses

cognite_neat-0.123.31/cognite/neat/_version.py

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

cognite_neat-0.123.31/cognite/neat/data_model/models/entities/__init__.py

@@ -0,0 +1,9 @@
+from ._constants import Undefined, Unknown
+from ._identifiers import URI, NameSpace
+
+__all__ = [
+    "URI",
+    "NameSpace",
+    "Undefined",
+    "Unknown",
+]

cognite_neat-0.123.31/cognite/neat/data_model/models/entities/_constants.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+
+class _UndefinedType(BaseModel): ...
+
+
+class _UnknownType(BaseModel):
+    def __str__(self) -> str:
+        return "#N/A"
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+
+# This is a trick to make Undefined and Unknown singletons
+Undefined = _UndefinedType()
+Unknown = _UnknownType()

cognite_neat-0.123.31/cognite/neat/data_model/models/entities/_identifiers.py

@@ -0,0 +1,61 @@
+from pydantic import HttpUrl, RootModel, ValidationError
+
+from cognite.neat.core._utils.auxiliary import local_import
+
+
+class URI(RootModel[str]):
+    def __init__(self, value: str):
+        try:
+            # Use Pydantic's HttpUrl to validate the URI
+            _ = HttpUrl(value)
+        except ValidationError as e:
+            raise ValueError(f"Invalid URI: {value}") from e
+        super().__init__(value)
+
+    def __str__(self) -> str:
+        return self.root
+
+    def __repr__(self) -> str:
+        return f"URI({self.root!r})"
+
+    def as_rdflib_uriref(self):  # type: ignore[no-untyped-def]
+        # rdflib is an optional dependency, so import here
+        local_import("rdflib", "rdflib")
+        from rdflib import URIRef
+
+        return URIRef(self.root)
+
+
+class NameSpace(RootModel[str]):
+    def __init__(self, value: str):
+        try:
+            # Use Pydantic's HttpUrl to validate the URI
+            _ = HttpUrl(value)
+        except ValidationError as e:
+            raise ValueError(f"Invalid Namespace: {value}") from e
+        super().__init__(value)
+
+    def __str__(self) -> str:
+        return self.root
+
+    def __repr__(self) -> str:
+        return f"NameSpace({self.root!r})"
+
+    def term(self, name: str) -> URI:
+        # need to handle slices explicitly because of __getitem__ override
+        return URI(self.root + (name if isinstance(name, str) else ""))
+
+    def __getitem__(self, key: str) -> URI:  # type: ignore[override]
+        return self.term(key)
+
+    def __getattr__(self, name: str) -> URI:
+        if name.startswith("__"):  # ignore any special Python names!
+            raise AttributeError
+        return self.term(name)
+
+    def as_rdflib_namespace(self):  # type: ignore[no-untyped-def]
+        # rdflib is an optional dependency, so import here
+        local_import("rdflib", "rdflib")
+        from rdflib import Namespace
+
+        return Namespace(self.root)

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/cognite/neat/session/_base.py

@@ -33,7 +33,6 @@ from ._mapping import MappingAPI
 from ._plugin import PluginAPI
 from ._prepare import PrepareAPI
 from ._read import ReadAPI
-from ._session._data_model import DataModelAPI
 from ._set import SetAPI
 from ._show import ShowAPI
 from ._state import SessionState
@@ -116,9 +115,6 @@ class NeatSession:
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 
-        # new API for data model operations
-        self.data_model = DataModelAPI(self._state)
-
     def _select_most_performant_store(self) -> Literal["memory", "oxigraph"]:
         """Select the most performant store based on the current environment."""
 

cognite_neat-0.123.31/last_changelog_entry.md

@@ -0,0 +1,3 @@
+
+### Removed
+- Object oriented session endpoints

cognite_neat-0.123.31/last_git_message.txt

@@ -0,0 +1,16 @@
+Removing object oriented Neat session endpoints (#1288)
+
+# Description
+
+New object oriented session endpoints are removed due to agreed strategy
+for neat version 1, which will be based on this new approach.
+
+## Bump
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## Changelog
+### Removed
+- Object oriented session endpoints

cognite_neat-0.123.31/last_version.txt

@@ -0,0 +1 @@
+0.123.30

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.123.29"
+version = "0.123.31"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -95,6 +95,7 @@ dev = [
     "tqdm>=4.67.1, <5",
     "deepdiff>=8.2.0, <9.0.0",
     "hypothesis>=6.135.0, <7.0.0",
+    "polyfactory>=2.22.2",
 ]
 
 [tool.uv]
@@ -126,12 +127,17 @@ allow_redefinition = true
 namespace_packages = true
 show_error_codes = true
 plugins = ["pydantic.mypy"]
-exclude = ["tests/*"]
+# We use reflection a lot in this codebace, and mypy does not understand that
+# finding all subclasses of an abstract class gives you concrete implementations.
+# Thus, we disable the type-abstract error.
+disable_error_code = ["type-abstract"]
 
 [tool.pydantic-mypy]
 init_forbid_extra = true
 init_typed = true
-warn_required_dynamic_aliases = true
+# We use dynamic alias creation as much as possible. This is to ensure
+# all aliases are consistentenly camelCase.
+warn_required_dynamic_aliases = false
 
 [build-system]
 requires = ["hatchling >= 1.26"]

cognite_neat-0.123.31/test-pyodide.js

@@ -0,0 +1,55 @@
+// Description: This script is used to test the Pygen installation in a Pyodide environment.
+// We are using JupyterLite and stlite, both pyodide based Python runtimes. To ensure that pygen works
+// in these runtimes, we need to test the installation of the pygen in a Pyodide environment.
+// This script will start an HTTP server to serve the pygen wheel file and then try to install the pygen in Python.
+// If the installation is successful, it will run a simple Python script to test pygen.
+const { loadPyodide } = require("pyodide");
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = 3000;
+
+// The Neat wheel filename will be sent in as environment variable
+const wheelFilePath = path.join(__dirname, 'dist', process.env.NEAT_FILE_PATH);
+
+// Create an HTTP server to serve the wheel file
+const server = http.createServer((req, res) => {
+  fs.readFile(wheelFilePath, (err, data) => {
+    if (err) {
+      // Handle file read errors
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+      res.end('500 - Internal Server Error');
+    } else {
+      // Serve the file content
+      res.writeHead(200, { 'Content-Type': 'application/octet-stream' });
+      res.end(data);
+    }
+  });
+});
+
+// Start the server and listen on the defined port. Then try to install Neat in Python
+server.listen(PORT, () => {
+  console.log(`Server is running at http://localhost:${PORT}. Now trying to install neat.`);
+
+  async function test_cognite_neat() {
+    let pyodide = await loadPyodide();
+    await pyodide.loadPackage("micropip");
+    const micropip = pyodide.pyimport("micropip");
+    // Read packages to install from environment variable as JSON
+
+    const packages = JSON.parse(process.env.PACKAGES);
+    for (const pkg of packages) {
+      await micropip.install(pkg);
+    }
+    await pyodide.runPythonAsync("from cognite.neat import NeatSession");
+
+    return pyodide.runPythonAsync('"Neat successfully installed and imported!"');
+  }
+
+  test_cognite_neat().then((result) => {
+    console.log("Response from Python =", result);
+    server.close();
+  });
+});

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/tests/tests_end_to_end/test_rules_flow.py

@@ -28,21 +28,6 @@ class TestImportersToYAMLExporter:
         exported_rules = yaml.safe_load(exported_yaml_str)
         data_regression.check(exported_rules)
 
-    def test_excel_importer_to_yaml_new_endpoint(self, data_regression: DataRegressionFixture) -> None:
-        neat = NeatSession(verbose=False)
-
-        neat.data_model.read.excel(DOC_RULES / "information-architect-david.xlsx")
-
-        neat.convert()
-
-        exported_yaml_str = neat.to.yaml()
-
-        exported_rules = yaml.safe_load(exported_yaml_str)
-        data_regression.check(exported_rules)
-
-        exported_rules = yaml.safe_load(exported_yaml_str)
-        data_regression.check(exported_rules)
-
     def test_prohibiting_conversion_with_nice_message(self) -> None:
         neat = NeatSession()
 
@@ -57,20 +42,6 @@ class TestImportersToYAMLExporter:
             "[ERROR] Cannot convert: Convert to physical expects conceptual data model"
         )
 
-    def test_prohibiting_conversion_with_nice_message_new_endpoint(self) -> None:
-        neat = NeatSession()
-
-        neat.data_model.read.ontology(SchemaData.Conceptual.ontology_with_regex_warnings)
-
-        output = io.StringIO()
-        with contextlib.redirect_stdout(output):
-            neat.convert()
-
-        printed_statements = output.getvalue()
-        assert printed_statements.startswith(
-            "[ERROR] Cannot convert: Convert to physical expects conceptual data model"
-        )
-
     @pytest.mark.freeze_time("2017-05-21")
     @pytest.mark.skip("Needs NEAT-608 to be completed")
     def test_ontology_importer_to_yaml(self, data_regression: DataRegressionFixture, tmp_path: Path) -> None:

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/tests/tests_integration/test_session/test_read.py

@@ -41,7 +41,7 @@ class TestRead:
         neat = NeatSession(client=cognite_client)
         # The CogniteDescribable view is referenced in the REFERENCING_CORE model read below.
         # The data product should lookup the describable properties and include them.
-        neat.data_model.read.cdf(("cdf_cdm", "CogniteCore", "v1"))
+        neat.read.cdf.data_model(("cdf_cdm", "CogniteCore", "v1"))
 
         exported_yaml_str = neat.to.yaml()
         exported_rules = yaml.safe_load(exported_yaml_str)

{cognite_neat-0.123.29 → cognite_neat-0.123.31}/tests/tests_unit/test_plugins.py

@@ -147,16 +147,6 @@ def test_plugin_error_handling():
         "[ERROR] PluginError: No plugin of type 'DataModelImporterPlugin' registered \nunder name 'csv'\n"
     )
 
-    # Alternative access point to the plugins via read
-    output = io.StringIO()
-    with contextlib.redirect_stdout(output):
-        neat.data_model.read("csv", "./test.txt")
-
-    printed_statements = output.getvalue()
-    assert printed_statements == (
-        "[ERROR] PluginError: No plugin of type 'DataModelImporterPlugin' registered \nunder name 'csv'\n"
-    )
-
 
 def test_plugin_read(mock_external_plugin):
     neat = NeatSession()
@@ -166,12 +156,3 @@ def test_plugin_read(mock_external_plugin):
         neat._state.data_model_store.last_verified_conceptual_data_model,
         ConceptualDataModel,
     )
-
-    # alternative access point to the plugins via read
-    neat = NeatSession()
-    neat.data_model.read("excel", SchemaData.Conceptual.info_arch_car_rules_xlsx)
-
-    assert isinstance(
-        neat._state.data_model_store.last_verified_conceptual_data_model,
-        ConceptualDataModel,
-    )

cognite_neat-0.123.31/tests/tests_unit/test_rules/test_models/test_identifiers.py

@@ -0,0 +1,179 @@
+import pytest
+from rdflib import Namespace, URIRef
+
+from cognite.neat.data_model.models.entities import URI, NameSpace
+
+
+class TestNameSpace:
+    def test_valid_namespace_creation(self):
+        """Test creating a NameSpace with valid URIs."""
+        valid_namespaces = [
+            "http://example.com/",
+            "https://example.org/vocab#",
+            "http://www.w3.org/2000/01/rdf-schema#",
+            "https://schema.org/",
+        ]
+
+        for namespace_str in valid_namespaces:
+            ns = NameSpace(namespace_str)
+            assert str(ns) == namespace_str
+            assert ns.root == namespace_str
+
+    def test_invalid_namespace_creation(self):
+        """Test that invalid URIs raise ValueError."""
+        invalid_namespaces = [
+            "not-a-uri",
+            "",
+            "://invalid",
+            "http://",
+            "just-text",
+            "ftp://files.example.com/",
+        ]
+
+        for invalid_ns in invalid_namespaces:
+            with pytest.raises(ValueError, match="Invalid Namespace"):
+                NameSpace(invalid_ns)
+
+    def test_namespace_repr(self):
+        """Test string representation of NameSpace."""
+        ns = NameSpace("http://example.com/")
+        assert repr(ns) == "NameSpace('http://example.com/')"
+
+    def test_term_method(self):
+        """Test creating terms using the term method."""
+        ns = NameSpace("http://example.com/vocab#")
+
+        term = ns.term("Person")
+        assert isinstance(term, URI)
+        assert str(term) == "http://example.com/vocab#Person"
+
+        term = ns.term("hasName")
+        assert str(term) == "http://example.com/vocab#hasName"
+
+    def test_getitem_method(self):
+        """Test creating terms using bracket notation."""
+        ns = NameSpace("http://example.com/vocab#")
+
+        term = ns["Person"]
+        assert isinstance(term, URI)
+        assert str(term) == "http://example.com/vocab#Person"
+
+        term = ns["hasAge"]
+        assert str(term) == "http://example.com/vocab#hasAge"
+
+    def test_getattr_method(self):
+        """Test creating terms using attribute access."""
+        ns = NameSpace("http://example.com/vocab#")
+
+        term = ns.Person
+        assert isinstance(term, URI)
+        assert str(term) == "http://example.com/vocab#Person"
+
+        term = ns.hasName
+        assert str(term) == "http://example.com/vocab#hasName"
+
+    def test_getattr_special_names(self):
+        """Test that special Python names raise AttributeError."""
+        ns = NameSpace("http://example.com/vocab#")
+
+        with pytest.raises(AttributeError):
+            _ = ns.__special__
+
+    def test_as_rdflib_namespace(self):
+        """Test conversion to rdflib Namespace."""
+        pytest.importorskip("rdflib")
+
+        ns = NameSpace("http://example.com/vocab#")
+        rdflib_ns = ns.as_rdflib_namespace()
+
+        assert isinstance(rdflib_ns, Namespace)
+        assert str(rdflib_ns) == "http://example.com/vocab#"
+
+    @pytest.mark.parametrize(
+        "term_name",
+        [
+            "Person",
+            "hasName",
+            "Organization",
+            "member_of",
+            "CamelCase",
+            "snake_case",
+            "kebab-case",
+        ],
+    )
+    def test_various_term_names(self, term_name: str):
+        """Test creating terms with various naming conventions."""
+        ns = NameSpace("http://example.com/vocab#")
+
+        # Test all three ways of creating terms
+        term1 = ns.term(term_name)
+        term2 = ns[term_name]
+        term3 = getattr(ns, term_name)
+
+        expected = f"http://example.com/vocab#{term_name}"
+        assert str(term1) == expected
+        assert str(term2) == expected
+        assert str(term3) == expected
+
+
+class TestURI:
+    def test_valid_uri_creation(self):
+        """Test creating URI with valid URIs."""
+        valid_uris = [
+            "http://example.com",
+            "https://example.org/path",
+            "http://www.w3.org/2000/01/rdf-schema#Class",
+            "https://schema.org/Person",
+        ]
+
+        for uri_str in valid_uris:
+            uri = URI(uri_str)
+            assert str(uri) == uri_str
+            assert uri.root == uri_str
+
+    def test_invalid_uri_creation(self):
+        """Test that invalid URIs raise ValueError."""
+        invalid_uris = [
+            "not-a-uri",
+            "",
+            "://invalid",
+            "http://",
+            "just-text",
+            "file:///path/to/file",
+            "mailto:user@example.com",
+            "ftp://files.example.com/file.txt",
+        ]
+
+        for invalid_uri in invalid_uris:
+            with pytest.raises(ValueError, match="Invalid URI"):
+                URI(invalid_uri)
+
+    def test_uri_repr(self):
+        """Test string representation of URI."""
+        uri = URI("http://example.com/Person")
+        assert repr(uri) == "URI('http://example.com/Person')"
+
+    def test_as_rdflib_uriref(self):
+        """Test conversion to rdflib URIRef."""
+        pytest.importorskip("rdflib")
+
+        uri = URI("http://example.com/Person")
+        uriref = uri.as_rdflib_uriref()
+
+        assert isinstance(uriref, URIRef)
+        assert str(uriref) == "http://example.com/Person"
+
+    @pytest.mark.parametrize(
+        "uri_str",
+        [
+            "http://example.com",
+            "https://www.w3.org/2000/01/rdf-schema#Class",
+            "https://schema.org/Person",
+            "http://xmlns.com/foaf/0.1/name",
+        ],
+    )
+    def test_various_uri_formats(self, uri_str: str):
+        """Test creating URIs with various formats."""
+        uri = URI(uri_str)
+        assert str(uri) == uri_str
+        assert uri.root == uri_str