cognite-neat 1.0.27__tar.gz → 1.0.29__tar.gz

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.27
+Version: 1.0.29
 Summary: Knowledge graph transformation
 Author: Nikola Vasiljevic, Anders Albert
 Author-email: Nikola Vasiljevic <nikola.vasiljevic@cognite.com>, Anders Albert <anders.albert@cognite.com>
@@ -17,22 +17,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
-Requires-Dist: pandas>=1.5.3,<3.0.0
 Requires-Dist: cognite-sdk>=7.83.0,<8.0.0
-Requires-Dist: rdflib>=7.0.0,<8.0.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.0.0,<3.0.0
 Requires-Dist: pyyaml>=6.0.1,<7.0.0
-Requires-Dist: requests>=2.28.1,<3.0.0
 Requires-Dist: urllib3>=1.26.15,<3.0.0
 Requires-Dist: openpyxl>=3.0.10,<4.0.0
 Requires-Dist: networkx>=3.4.2,<4.0.0
 Requires-Dist: mixpanel>=4.10.1,<5.0.0
-Requires-Dist: packaging>=22.0
-Requires-Dist: jsonpath-python>=1.0.6,<2.0.0
-Requires-Dist: elementpath>=4.0.0,<5.0.0
-Requires-Dist: pyvis>=0.3.2,<1.0.0
-Requires-Dist: rich[jupyter]>=13.7.1,<14.0.0
 Requires-Dist: exceptiongroup>=1.1.3,<2.0.0 ; python_full_version < '3.11'
 Requires-Dist: backports-strenum>=1.2,<2.0.0 ; python_full_version < '3.11'
 Requires-Dist: typing-extensions>=4.8.0,<5.0.0 ; python_full_version < '3.11'
@@ -51,6 +43,14 @@ Requires-Dist: mkdocs-autorefs>=0.5.0,<1.0.0 ; extra == 'docs'
 Requires-Dist: gspread>=5.0.0,<6.0.0 ; extra == 'google'
 Requires-Dist: google-api-python-client>=2.70.0,<3.0.0 ; extra == 'google'
 Requires-Dist: google-auth-oauthlib>=1.0.0,<2.0.0 ; extra == 'google'
+Requires-Dist: rdflib>=7.0.0,<8.0.0 ; extra == 'legacy'
+Requires-Dist: pandas>=1.5.3,<3.0.0 ; extra == 'legacy'
+Requires-Dist: requests>=2.28.1,<3.0.0 ; extra == 'legacy'
+Requires-Dist: packaging>=22.0 ; extra == 'legacy'
+Requires-Dist: jsonpath-python>=1.0.6,<2.0.0 ; extra == 'legacy'
+Requires-Dist: elementpath>=4.0.0,<5.0.0 ; extra == 'legacy'
+Requires-Dist: pyvis>=0.3.2,<1.0.0 ; extra == 'legacy'
+Requires-Dist: rich[jupyter]>=13.7.1,<14.0.0 ; extra == 'legacy'
 Requires-Dist: lxml>=5.3.0,<6.0.0 ; extra == 'lxml'
 Requires-Dist: oxrdflib>=0.4.0,<0.5.0 ; extra == 'oxi'
 Requires-Dist: pyoxigraph>=0.4.3,<0.5.0 ; extra == 'oxi'
@@ -61,6 +61,7 @@ Project-URL: GitHub, https://github.com/cognitedata/neat
 Project-URL: Changelog, https://github.com/cognitedata/neat/releases
 Provides-Extra: docs
 Provides-Extra: google
+Provides-Extra: legacy
 Provides-Extra: lxml
 Provides-Extra: oxi
 Description-Content-Type: text/markdown

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_config.py

@@ -105,6 +105,9 @@ class AlphaFlagConfig(ConfigModel):
         default=False,
         description="If enabled, Neat will run experimental validators that are still in alpha stage.",
     )
+    enable_solution_model_creation: bool = Field(
+        default=False, description="If enabled, neat.physical_data_model.create() will be available"
+    )
     enable_cdf_analysis: bool = Field(default=False, description="If enabled, neat.cdf endpoint will be available.")
 
     def __setattr__(self, key: str, value: Any) -> None:

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_data_model/_analysis.py

@@ -43,10 +43,14 @@ _NodeT = TypeVar("_NodeT", ContainerReference, ViewReference)
 
 class ValidationResources:
     def __init__(
-        self, modus_operandi: ModusOperandi, local: SchemaSnapshot, cdf: SchemaSnapshot, limits: SchemaLimits
+        self,
+        modus_operandi: ModusOperandi,
+        local: SchemaSnapshot,
+        cdf: SchemaSnapshot,
+        limits: SchemaLimits | None = None,
     ) -> None:
         self._modus_operandi = modus_operandi
-        self.limits = limits
+        self.limits = limits or SchemaLimits()
 
         self.local = local
         self.cdf = cdf
@@ -385,6 +389,18 @@ class ValidationResources:
 
         return connection_end_node_types
 
+    @staticmethod
+    def is_explicit_connection(property_: ViewRequestProperty) -> bool:
+        """Check if a property is an explicit connection property, meaning end node type is explicitly defined.
+
+        Args:
+            property_: The property to check.
+
+        Returns:
+            True if the property is a connection property, False otherwise.
+        """
+        return True if property_.source else False
+
     @cached_property
     def views_by_container(self) -> dict[ContainerReference, set[ViewReference]]:
         """Get a mapping from containers to the views that use them.

cognite_neat-1.0.29/cognite/neat/_data_model/importers/__init__.py

@@ -0,0 +1,5 @@
+from ._api_importer import DMSAPICreator, DMSAPIImporter
+from ._base import DMSImporter
+from ._table_importer.importer import DMSTableImporter
+
+__all__ = ["DMSAPICreator", "DMSAPIImporter", "DMSImporter", "DMSTableImporter"]

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_data_model/importers/_api_importer.py

@@ -1,19 +1,30 @@
 import difflib
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
 from pydantic import ValidationError
 
 from cognite.neat._client import NeatClient
+from cognite.neat._data_model._analysis import ValidationResources
+from cognite.neat._data_model._snapshot import SchemaSnapshot
 from cognite.neat._data_model.importers._base import DMSImporter
 from cognite.neat._data_model.models.dms import (
     DataModelReference,
     RequestSchema,
     SpaceReference,
 )
-from cognite.neat._exceptions import CDFAPIException, DataModelImportException, FileReadException
-from cognite.neat._issues import ModelSyntaxError
+from cognite.neat._data_model.models.dms._data_model import DataModelRequest
+from cognite.neat._data_model.models.dms._references import ViewReference
+from cognite.neat._data_model.models.dms._views import ViewRequest
+from cognite.neat._data_model.models.entities._parser import parse_entities
+from cognite.neat._exceptions import (
+    CDFAPIException,
+    DataModelCreateException,
+    DataModelImportException,
+    FileReadException,
+)
+from cognite.neat._issues import ConsistencyError, ModelSyntaxError
 from cognite.neat._utils.http_client import FailedRequestMessage
 from cognite.neat._utils.text import humanize_collection
 from cognite.neat._utils.validation import ValidationContext, humanize_validation_error
@@ -164,3 +175,157 @@ class DMSAPIImporter(DMSImporter):
             )
         schema_data["dataModel"] = data_model
         return schema_data
+
+
+class DMSAPICreator(DMSImporter):
+    """Creates data model from the existing schema components in CDF"""
+
+    def __init__(
+        self,
+        cdf_snapshot: SchemaSnapshot,
+        space: str,
+        external_id: str,
+        version: str,
+        views: list[str],
+        name: str | None = None,
+        description: str | None = None,
+        kind: Literal["solution"] = "solution",
+    ) -> None:
+        self._resources = ValidationResources("rebuild", local=cdf_snapshot, cdf=cdf_snapshot)
+        self._space = space
+        self._external_id = external_id
+        self._version = version
+        self._name = name
+        self._description = description
+        self._kind = kind
+        self._views = views
+
+    def to_data_model(self) -> RequestSchema:
+        if self._kind == "solution":
+            return self._to_solution_model()
+        else:
+            raise NotImplementedError(f"Data model kind '{self._kind}' is not supported yet.")
+
+    def _to_solution_model(self) -> RequestSchema:
+        """Creates solution data model from provided views"""
+
+        errors, view_refs = self._parse_view_references(self._views)
+
+        if not view_refs:
+            errors.append(ModelSyntaxError(message="No valid views provided to create the data model."))
+
+        # Check if all views exist in the cdf snapshot:
+        for view in view_refs:
+            if not self._resources.select_view(view):
+                errors.append(
+                    ConsistencyError(
+                        message=f"View '{view}' not found in the provided CDF snapshot. Cannot create data model."
+                    )
+                )
+
+        if errors:
+            raise DataModelCreateException(errors)
+
+        # now we iterate over the views, expand them and add them to the data model
+        expanded_views: list[ViewRequest] = []
+
+        for view in view_refs:
+            expanded_view = self._resources.expand_view_properties(view)
+            if not expanded_view:
+                raise RuntimeError(f"Failed to expand view '{view}' despite earlier checks. This is a bug.")
+
+            # make a deep copy to avoid modifying the cached view in resources
+            expanded_view = expanded_view.model_copy(deep=True)
+
+            # remove implements after expansion
+            expanded_view.implements = None
+
+            # set space and version to data model values
+            expanded_view.space = self._space
+            expanded_view.version = self._version
+
+            # Connections should be dropped if their source are not part of the expanded view
+            properties_to_remove = []
+            for id, property_ in expanded_view.properties.items():
+                # Currently only supporting explicit connections where source is defined
+                if self._resources.is_explicit_connection(property_):
+                    source = property_.source
+                    if source not in view_refs:
+                        properties_to_remove.append(id)
+
+                    # Update source to point to view of solution data model
+                    else:
+                        property_.source = ViewReference(
+                            space=self._space, external_id=source.external_id, version=self._version
+                        )
+
+            # Dropping connections which sources will not be part of the data model
+            for property_id in properties_to_remove:
+                expanded_view.properties.pop(property_id)
+
+            expanded_views.append(expanded_view)
+
+        data_model = DataModelRequest(
+            space=self._space,
+            externalId=self._external_id,
+            version=self._version,
+            name=self._name,
+            description=self._description,
+            views=[view.as_reference() for view in expanded_views],
+        )
+
+        return RequestSchema(dataModel=data_model, views=expanded_views)
+
+    @classmethod
+    def _parse_view_references(
+        cls, views: list[str]
+    ) -> tuple[list[ModelSyntaxError | ConsistencyError], list[ViewReference]]:
+        """Parses list of view strings in to list of view references
+
+        Args:
+            views : list of view references in a short string format
+
+        Returns:
+            Tuple of errors and view references
+        """
+        view_references: list[ViewReference] = []
+        errors: list[ModelSyntaxError | ConsistencyError] = []
+
+        for view in views:
+            try:
+                entity = parse_entities(view)
+                if not entity:
+                    errors.append(ModelSyntaxError(message=f"Invalid view reference '{view}': Could not parse entity."))
+                    continue
+
+                if len(entity) != 1:
+                    errors.append(
+                        ModelSyntaxError(message=f"Invalid view reference '{view}': Expected a single view definition.")
+                    )
+                    continue
+
+                if "version" not in entity[0].properties:
+                    errors.append(
+                        ModelSyntaxError(message=f"Invalid view reference '{view}': Missing 'version' property.")
+                    )
+                    continue
+
+                try:
+                    view_ref = ViewReference(
+                        space=entity[0].prefix,
+                        external_id=entity[0].suffix,
+                        version=str(entity[0].properties["version"]),
+                    )
+                    view_references.append(view_ref)
+                except ValidationError as e:
+                    humanized = [humanize_validation_error(error) for error in e.errors()]
+                    errors.append(
+                        ModelSyntaxError(
+                            message=f"Invalid view reference '{view}', cannot parse it: " + ", ".join(humanized)
+                        )
+                    )
+
+            except ValueError as e:
+                errors.append(ModelSyntaxError(message=f"Invalid view reference '{view}', cannot parse it: {e}"))
+
+        return errors, view_references

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_data_model/importers/_table_importer/data_classes.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Annotated, Literal, cast, get_args
+from typing import Annotated, Any, Literal, cast, get_args
 
 from pydantic import (
     AliasGenerator,
@@ -12,7 +12,6 @@ from pydantic import (
 )
 from pydantic.alias_generators import to_camel
 from pydantic.fields import FieldInfo
-from traitlets import Any
 
 from cognite.neat._data_model.models.entities import ParsedEntity, parse_entities, parse_entity
 from cognite.neat._utils.text import title_case

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_data_model/validation/dms/_limits.py

@@ -11,7 +11,7 @@ from cognite.neat._data_model.models.dms._view_property import (
 from cognite.neat._data_model.validation.dms._base import (
     DataModelValidator,
 )
-from cognite.neat._issues import ConsistencyError
+from cognite.neat._issues import ConsistencyError, Recommendation
 
 BASE_CODE = "NEAT-DMS-LIMITS"
 
@@ -124,19 +124,19 @@ class ViewContainerCountIsOutOfLimits(DataModelValidator):
     Checks that the view references no more containers than the CDF limit allows.
 
     ## Why is this bad?
-    CDF enforces limits on the number of containers per view to prevent overly complex view definitions, leading
-    to too many joins and performance degradation.
+    Mapping too many containers to a single view can lead to performance issues to increasing number of joins
+    that need to be performed when querying data through the view.
 
     ## Example
     If a view references 20 containers and the CDF limit is 10 containers per view,
-    this validator will raise a ConsistencyError issue.
+    this validator will raise a Recommendation.
     """
 
     code = f"{BASE_CODE}-VIEW-002"
-    issue_type = ConsistencyError
+    issue_type = Recommendation
 
-    def run(self) -> list[ConsistencyError]:
-        errors: list[ConsistencyError] = []
+    def run(self) -> list[Recommendation]:
+        recommendations: list[Recommendation] = []
 
         # Single loop over all views
         for view_ref in self.validation_resources.merged_data_model.views or []:
@@ -152,18 +152,18 @@ class ViewContainerCountIsOutOfLimits(DataModelValidator):
                     }
                 )
                 if count > self.validation_resources.limits.views.containers:
-                    errors.append(
-                        ConsistencyError(
+                    recommendations.append(
+                        Recommendation(
                             message=(
                                 f"View {view_ref!s} references "
-                                f"{count} containers, which exceeds the limit of "
+                                f"{count} containers, which exceeds a common sense limit of "
                                 f"{self.validation_resources.limits.views.containers} containers per view."
                             ),
                             code=self.code,
                         )
                     )
 
-        return errors
+        return recommendations
 
 
 class ViewImplementsCountIsOutOfLimits(DataModelValidator):

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_exceptions.py

@@ -1,6 +1,8 @@
 from abc import ABC
 from typing import TYPE_CHECKING
 
+from cognite.neat._issues import ConsistencyError
+
 if TYPE_CHECKING:
     from cognite.neat._issues import ModelSyntaxError
     from cognite.neat._utils.http_client import HTTPMessage
@@ -23,6 +25,17 @@ class DataModelImportException(NeatException):
         return f"Model import failed with {len(self.errors)} errors: " + "; ".join(map(str, self.errors))
 
 
+class DataModelCreateException(NeatException):
+    """Raised when there is an error creating a data model."""
+
+    def __init__(self, errors: "list[ModelSyntaxError | ConsistencyError]") -> None:
+        super().__init__(errors)
+        self.errors = errors
+
+    def __str__(self) -> str:
+        return f"Model creation failed with {len(self.errors)} errors: " + "; ".join(map(str, self.errors))
+
+
 class CDFAPIException(NeatException):
     """Raised when there is an error in an API call."""
 

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_session/_physical.py

@@ -1,3 +1,4 @@
+from types import MethodType
 from typing import Any, Literal
 
 from cognite.neat._client import NeatClient
@@ -13,7 +14,7 @@ from cognite.neat._data_model.exporters import (
     DMSTableYamlExporter,
 )
 from cognite.neat._data_model.exporters._table_exporter.workbook import WorkbookOptions
-from cognite.neat._data_model.importers import DMSAPIImporter, DMSImporter, DMSTableImporter
+from cognite.neat._data_model.importers import DMSAPICreator, DMSAPIImporter, DMSImporter, DMSTableImporter
 from cognite.neat._data_model.models.dms import DataModelReference
 from cognite.neat._data_model.validation.dms import DmsDataModelValidation
 from cognite.neat._exceptions import UserInputError
@@ -24,6 +25,7 @@ from cognite.neat._utils._reader import NeatReader
 from ._wrappers import session_wrapper
 
 
+@session_wrapper
 class PhysicalDataModel:
     """Read from a data source into NeatSession graph store."""
 
@@ -34,6 +36,10 @@ class PhysicalDataModel:
         self.read = ReadPhysicalDataModel(self._store, self._client, self._config)
         self.write = WritePhysicalDataModel(self._store, self._client, self._config)
 
+        # attach alpha methods
+        if self._config.alpha.enable_solution_model_creation:
+            self.create = MethodType(create, self)  # type: ignore[attr-defined]
+
     def _repr_html_(self) -> str:
         if not isinstance(self._store.state, PhysicalState):
             return "No physical data model. Get started by reading physical data model <em>.physica_data_mode.read</em>"
@@ -292,3 +298,51 @@ class WritePhysicalDataModel:
         )
         on_success = SchemaDeployer(self._client, options)
         return self._store.write_physical(writer, on_success)
+
+
+def create(
+    self: PhysicalDataModel,
+    space: str,
+    external_id: str,
+    version: str,
+    views: list[str],
+    name: str | None = None,
+    description: str | None = None,
+    kind: Literal["solution"] = "solution",
+) -> None:
+    """Create a solution data model in Neat from CDF views.
+
+    Args:
+        space (str): The schema space of the data model.
+        external_id (str): The external id of the data model.
+        version (str): The version of the data model.
+        views (list[str]): List of view external ids to include in the data model in the short string format
+            space:external_id(version=version)
+        name (str | None): The name of the data model. If None, the name will be fetched from CDF.
+        description (str | None): The description of the data model. If None, the description will be fetched from CDF.
+        kind (Literal["solution"]): The kind of the data model. Currently, only "solution" is supported.
+    """
+
+    if not self._store.cdf_snapshot.data_model:
+        raise ValueError("There are no data models in CDF. Cannot create solution model.")
+
+    creator = DMSAPICreator(
+        space=space,
+        external_id=external_id,
+        version=version,
+        views=views,
+        name=name,
+        description=description,
+        kind=kind,
+        cdf_snapshot=self._store.cdf_snapshot,
+    )
+
+    on_success = DmsDataModelValidation(
+        modus_operandi=self._config.modeling.mode,
+        cdf_snapshot=self._store.cdf_snapshot,
+        limits=self._store.cdf_limits,
+        can_run_validator=self._config.validation.can_run_validator,
+        enable_alpha_validators=self._config.alpha.enable_experimental_validators,
+    )
+
+    return self._store.read_physical(creator, on_success)

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_session/_wrappers.py

@@ -96,6 +96,24 @@ def session_wrapper(cls: type[T_Class]) -> type[T_Class]:
             if callable(attr):
                 # Replace the original method with wrapped version
                 setattr(cls, attr_name, _handle_method_call(attr))
-
-    # Return the modified class
+    # Intercept __init__ to wrap any methods added via setattr
+    original_init = cls.__init__
+
+    @wraps(original_init)
+    def pick_alpha_methods(self: HasStore, *args: Any, **kwargs: Any) -> Any:
+        """This method wraps any instance methods added during __init__. which is the case for alpha methods"""
+        original_init(self, *args, **kwargs)
+        # Wrap any instance methods added during init
+        for attr_name in dir(self):
+            if not attr_name.startswith("_"):
+                attr = getattr(self, attr_name, None)
+                # Check if it's an instance method (not from the class)
+                if callable(attr) and attr_name not in vars(self.__class__):
+                    # Wrap and set on the instance
+                    wrapped = (
+                        _handle_method_call(attr.__func__) if hasattr(attr, "__func__") else _handle_method_call(attr)
+                    )
+                    setattr(self, attr_name, wrapped.__get__(self, type(self)))
+
+    cls.__init__ = pick_alpha_methods  # type: ignore[assignment]
     return cls

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/_store/_store.py

@@ -15,7 +15,7 @@ from cognite.neat._data_model.exporters._table_exporter.exporter import DMSTable
 from cognite.neat._data_model.importers import DMSImporter, DMSTableImporter
 from cognite.neat._data_model.models.dms import RequestSchema as PhysicalDataModel
 from cognite.neat._data_model.models.dms._limits import SchemaLimits
-from cognite.neat._exceptions import DataModelImportException
+from cognite.neat._exceptions import DataModelCreateException, DataModelImportException
 from cognite.neat._issues import IssueList
 from cognite.neat._state_machine._states import EmptyState, PhysicalState, State
 from cognite.neat._utils.text import NEWLINE
@@ -179,6 +179,9 @@ class NeatStore:
         except DataModelImportException as e:
             errors.extend(e.errors)
 
+        except DataModelCreateException as e:
+            errors.extend(e.errors)
+
         # these are all other errors, such as missing file, wrong format, etc.
         except Exception as e:
             raise e

cognite_neat-1.0.29/cognite/neat/_version.py

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

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/cognite/neat/legacy.py

@@ -1,3 +1,13 @@
+import importlib
+
+from cognite.neat._exceptions import NeatImportError
+
+try:
+    importlib.import_module("rdflib")
+except ImportError as e:
+    raise NeatImportError("legacy module", "legacy") from e
+
+
 from cognite.neat._v0.core._utils.auth import get_cognite_client
 from cognite.neat._v0.session._base import NeatSession
 

{cognite_neat-1.0.27 → cognite_neat-1.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "1.0.27"
+version = "1.0.29"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -24,17 +24,25 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "pandas>=1.5.3, <3.0.0",
     "cognite-sdk>=7.83.0, <8.0.0",
-    "rdflib>=7.0.0, <8.0.0",
     "httpx>=0.28.1",
     "pydantic>=2.0.0, <3.0.0",
     "PyYAML>=6.0.1, <7.0.0",
-    "requests>=2.28.1, <3.0.0",
     "urllib3>=1.26.15, <3.0.0",
     "openpyxl>=3.0.10, <4.0.0",
     "networkx>=3.4.2, <4.0.0",
     "mixpanel>=4.10.1, <5.0.0",
+    # Backport from Python 3.11
+    "exceptiongroup>=1.1.3, <2.0.0; python_version < '3.11'",
+    "backports.strenum >=1.2, <2.0.0; python_version < '3.11'",
+    "typing_extensions>=4.8.0, <5.0.0; python_version < '3.11'",
+    "tomli>=2.0.1, <3.0.0; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+legacy = [    "rdflib>=7.0.0, <8.0.0",
+    "pandas>=1.5.3, <3.0.0",
+    "requests>=2.28.1, <3.0.0",
     # Used for loading neat engine
     "packaging>=22.0",
     # NeatEngine dependencies
@@ -43,13 +51,8 @@ dependencies = [
     "pyvis>=0.3.2, <1.0.0",
     # Notebook
     "rich[jupyter]>=13.7.1, <14.0.0",
-    # Backport from Python 3.11
-    "exceptiongroup>=1.1.3, <2.0.0; python_version < '3.11'",
-    "backports.strenum >=1.2, <2.0.0; python_version < '3.11'",
-    "typing_extensions>=4.8.0, <5.0.0; python_version < '3.11'",
-    "tomli>=2.0.1, <3.0.0; python_version < '3.11'",
 ]
-[project.optional-dependencies]
+
 lxml = [
     "lxml>=5.3.0, <6.0.0",
 ]
@@ -120,6 +123,7 @@ dev = [
 markers = [
     "serial: mark test to run serially (not in parallel)",
 ]
+norecursedirs = ["tests/v0"]
 
 [tool.uv]
 package = true
@@ -181,7 +185,7 @@ disable_error_code = ["type-abstract"]
 # The _v0 module is legacy code that is not fully typed. We are not planning
 # to update it, so we exclude it from mypy checks. Once v1 is released with all features
 # from _v0, we will remove this folder.
-exclude = ["tests/v0"]
+exclude = ["tests/v0", "cognite/neat/_v0"]
 
 [tool.pydantic-mypy]
 init_forbid_extra = true

cognite_neat-1.0.27/cognite/neat/_data_model/importers/__init__.py

@@ -1,5 +0,0 @@
-from ._api_importer import DMSAPIImporter
-from ._base import DMSImporter
-from ._table_importer.importer import DMSTableImporter
-
-__all__ = ["DMSAPIImporter", "DMSImporter", "DMSTableImporter"]

cognite_neat-1.0.27/cognite/neat/_version.py

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