cognite-neat 0.123.28__tar.gz → 0.123.30__tar.gz

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/.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.28 → cognite_neat-0.123.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.28
+Version: 0.123.30
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/
@@ -11,7 +11,7 @@ License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: backports-strenum<2.0.0,>=1.2; python_version < '3.11'
-Requires-Dist: cognite-sdk<8.0.0,>=7.73.4
+Requires-Dist: cognite-sdk<8.0.0,>=7.83.0
 Requires-Dist: elementpath<5.0.0,>=4.0.0
 Requires-Dist: exceptiongroup<2.0.0,>=1.1.3; python_version < '3.11'
 Requires-Dist: jsonpath-python<2.0.0,>=1.0.6

cognite_neat-0.123.30/cognite/neat/_version.py

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

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/cognite/neat/core/_client/_api/data_modeling_loaders.py

@@ -1,3 +1,4 @@
+import itertools
 import re
 import warnings
 from abc import ABC, abstractmethod
@@ -238,7 +239,7 @@ class ResourceLoader(
         try:
             return self._update(items)
         except CogniteAPIError as e:
-            failed_ids = {self.get_id(failed) for failed in e.failed + e.unknown}
+            failed_ids = {self.get_id(failed) for failed in itertools.chain(e.failed, e.unknown)}
             success_ids = [self.get_id(success) for success in e.successful]
             success_ = self.retrieve(success_ids)
             if success is None:

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/cognite/neat/core/_data_model/importers/_dms2data_model.py

@@ -446,6 +446,8 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
                     return ViewEntity.from_id(prop.source)
             elif isinstance(prop_type, PropertyTypeWithUnit) and prop_type.unit:
                 return DataType.load(f"{prop_type._type}(unit={prop_type.unit.external_id})")
+            elif isinstance(prop_type, dm.Text) and prop_type.max_text_size is not None:
+                return DataType.load(f"{prop_type._type}(maxTextSize={prop_type.max_text_size})")
             elif isinstance(prop_type, DMSEnum):
                 if enum_collection_by_container_property is None:
                     return String()

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/cognite/neat/core/_data_model/models/data_types.py

@@ -246,6 +246,11 @@ class String(DataType):
     sql = "STRING"
 
     name: typing.Literal["string"] = "string"
+    max_text_size: int | None = Field(
+        None,
+        alias="maxTextSize",
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
 
 
 class LangString(DataType):
@@ -256,6 +261,11 @@ class LangString(DataType):
     sql = "STRING"
 
     name: typing.Literal["langString"] = "langString"
+    max_text_size: int | None = Field(
+        None,
+        alias="maxTextSize",
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
 
 
 class AnyURI(DataType):

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/cognite/neat/core/_data_model/models/physical/_exporter.py

@@ -25,7 +25,7 @@ from cognite.neat.core._constants import (
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float
+from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float, LangString, String
 from cognite.neat.core._data_model.models.entities import (
     ConceptEntity,
     ContainerEntity,
@@ -347,6 +347,8 @@ class _DMSExporter:
                             args["max_list_size"] = prop.max_count
                 if isinstance(prop.value_type, Double | Float) and isinstance(prop.value_type.unit, UnitEntity):
                     args["unit"] = prop.value_type.unit.as_reference()
+                if isinstance(prop.value_type, String | LangString) and prop.value_type.max_text_size is not None:
+                    args["max_text_size"] = prop.value_type.max_text_size
                 if isinstance(prop.value_type, Enum):
                     if prop.value_type.collection not in enum_values_by_collection:
                         raise ResourceNotFoundError(

cognite_neat-0.123.30/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.30/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.30/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.30/last_changelog_entry.md

@@ -0,0 +1,4 @@
+### Added
+
+- Added neat native `URI` and `NameSpace` classes that behave same as
+those provided by `rdflib` package

cognite_neat-0.123.30/last_git_message.txt

@@ -0,0 +1,26 @@
+Refactoring Data Model: Adding neat specific URI and NameSpace classes (#1280)
+
+# Description
+
+This is first of a number of PR that are focused on refactoring neat
+data model features to be exposed as Toolkit plugin. In this specific PR
+previously neat own `Uri` and `NameSpace` class is defined, such that
+`rdflib` package can be made into an optional dependency. Notice that
+`_constants.py` is copied from
+`cognite/neat/core/_data_model/models/entities`.
+
+## Bump
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## Changelog
+### Added
+
+- Added neat native `URI` and `NameSpace` classes that behave same as
+those provided by `rdflib` package
+
+---------
+
+Co-authored-by: Anders Albert <60234212+doctrino@users.noreply.github.com>

cognite_neat-0.123.30/last_version.txt

@@ -0,0 +1 @@
+0.123.29

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.123.28"
+version = "0.123.30"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -12,7 +12,7 @@ license = "Apache-2.0"
 requires-python = ">=3.10"
 dependencies = [
     "pandas>=1.5.3, <3.0.0",
-    "cognite-sdk>=7.73.4, <8.0.0",
+    "cognite-sdk>=7.83.0, <8.0.0",
     "rdflib>=7.0.0, <8.0.0",
     "pydantic>=2.0.0, <3.0.0",
     "PyYAML>=6.0.1, <7.0.0",

cognite_neat-0.123.30/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.28 → cognite_neat-0.123.30}/tests/tests_unit/test_rules/test_exporters/test_rules2dms.py

@@ -7,6 +7,8 @@ import pytest
 from cognite.client import data_modeling as dm
 
 from cognite.neat import NeatSession
+from cognite.neat.core._client.data_classes.data_modeling import ContainerApplyDict, SpaceApplyDict, ViewApplyDict
+from cognite.neat.core._client.data_classes.schema import DMSSchema
 from cognite.neat.core._client.testing import monkeypatch_neat_client
 from cognite.neat.core._data_model import importers
 from cognite.neat.core._data_model.exporters import DMSExporter
@@ -110,3 +112,32 @@ class TestImportExportDMS:
         prop = container.properties["geoLocation"]
         assert isinstance(prop, dm.ContainerProperty)
         assert prop.type == dm.DirectRelation()
+
+    def test_import_export_dms_with_text_property(self) -> None:
+        space = "schema_space"
+        my_container = dm.ContainerApply(
+            space, "Container1", properties={"textProp": dm.ContainerProperty(type=dm.Text(max_text_size=42))}
+        )
+        my_view = dm.ViewApply(
+            space, "View1", "v1", properties={"textProp": dm.MappedPropertyApply(my_container.as_id(), "textProp")}
+        )
+        schema = DMSSchema(
+            data_model=dm.DataModelApply(
+                space=space, external_id="MyModel", version="0.1.0", views=[my_view.as_id()], description="Creator: me"
+            ),
+            spaces=SpaceApplyDict([dm.SpaceApply(space=space)]),
+            views=ViewApplyDict([my_view]),
+            containers=ContainerApplyDict([my_container]),
+        )
+
+        with catch_issues() as issues:
+            importer = importers.DMSImporter(schema)
+            rules = VerifyAnyDataModel().transform(importer.to_data_model())
+            if isinstance(rules, PhysicalDataModel):
+                dms_rules = rules
+            else:
+                pytest.fail(f"Unexpected rules type: {type(rules)}")
+        assert not issues.has_errors, f"Import failed with issues: {issues}"
+        exported = DMSExporter().export(dms_rules)
+        assert len(exported.views) == 1
+        assert exported.dump() == schema.dump(), "Exported schema should match the original schema"

cognite_neat-0.123.30/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

{cognite_neat-0.123.28 → cognite_neat-0.123.30}/uv.lock

@@ -346,7 +346,7 @@ wheels = [
 
 [[package]]
 name = "cognite-neat"
-version = "0.123.28"
+version = "0.123.30"
 source = { editable = "." }
 dependencies = [
     { name = "backports-strenum", marker = "python_full_version < '3.11'" },
@@ -428,7 +428,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "backports-strenum", marker = "python_full_version < '3.11'", specifier = ">=1.2,<2.0.0" },
-    { name = "cognite-sdk", specifier = ">=7.73.4,<8.0.0" },
+    { name = "cognite-sdk", specifier = ">=7.83.0,<8.0.0" },
     { name = "elementpath", specifier = ">=4.0.0,<5.0.0" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'", specifier = ">=1.1.3,<2.0.0" },
     { name = "google-api-python-client", marker = "extra == 'google'", specifier = ">=2.70.0,<3.0.0" },
@@ -496,7 +496,7 @@ dev = [
 
 [[package]]
 name = "cognite-sdk"
-version = "7.75.1"
+version = "7.83.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "msal" },
@@ -506,9 +506,9 @@ dependencies = [
     { name = "requests-oauthlib" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/a3/c613ba3d4ea34c7591a4d648b23a9c5d6d05a654b77391e2613752965dc6/cognite_sdk-7.75.1.tar.gz", hash = "sha256:f026a621c737bbaf9be8bc503f9946c83333fa09769fa2c5dbc324783c4d9f1a", size = 500308, upload-time = "2025-05-15T19:10:35.36Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/98/efaf3b8b082fae038000674f01aebcd85437280c889da036a0d1a1d88a2b/cognite_sdk-7.83.1.tar.gz", hash = "sha256:bd7b81936c94ce58b3e07aa31f1e0b88dc8027c07457171c81ca0d82f5ad3e9f", size = 516805, upload-time = "2025-08-30T19:30:17.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/ff/db712d28ddfdf9584636338df89be8f4837e712cf4bb4f75093a0f2c513e/cognite_sdk-7.75.1-py3-none-any.whl", hash = "sha256:6ff7200e0e4a55e208ce82c86b76f2002943e9a42b51f62e91bc34998ae8e592", size = 623264, upload-time = "2025-05-15T19:10:32.763Z" },
+    { url = "https://files.pythonhosted.org/packages/82/8b/81c0d6da28f98ee3b4aba873e3115085b51fb16fd3a2af42db5ea3a300bd/cognite_sdk-7.83.1-py3-none-any.whl", hash = "sha256:301c30686f8f2f945ef6239db799f62f7520e2f20b9346bd53a144cdf3a7c477", size = 644785, upload-time = "2025-08-30T19:30:14.985Z" },
 ]
 
 [package.optional-dependencies]

cognite_neat-0.123.28/cognite/neat/_version.py

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

cognite_neat-0.123.28/last_changelog_entry.md

@@ -1,6 +0,0 @@
-
-
-### Fixed
-
-- Removed upper bound on third-party dependency `packaging`. This makes
-Neat compatible with toolkit.

cognite_neat-0.123.28/last_git_message.txt

@@ -1,27 +0,0 @@
-Remove upper bound on packaging (#1272)
-
-# Description
-
-This third-party dependency had an upper bound that caused compatibility
-issues with `cognite-toolkit` due to differing upper and lower bounds.
-The upper bound was recently removed with this change in
-`cognite-toolkit`:
-https://github.com/cognitedata/toolkit/commit/2d0ef1383325e2a074e607b9fbaf06fc24a0e1de
-
-This commit removes the upper bound in Neat as well, ensuring both
-packages can now be installed in the same repo. Verified locally with an
-install with `cognite-toolkit=0.6.26` and using this branch as target
-for `cognite-neat`.
-
-## Bump
-
-- [x] Patch
-- [ ] Minor
-- [ ] Skip
-
-## Changelog
-
-### Fixed
-
-- Removed upper bound on third-party dependency `packaging`. This makes
-Neat compatible with toolkit.

cognite_neat-0.123.28/last_version.txt

@@ -1 +0,0 @@
-0.123.27