cognite-neat 0.97.3__py3-none-any.whl → 0.99.0__py3-none-any.whl

cognite/neat/_session/_to.py

@@ -1,9 +1,9 @@
 from pathlib import Path
 from typing import Any, Literal, overload
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import SpaceApply
 
+from cognite.neat._client import NeatClient
 from cognite.neat._graph import loaders
 from cognite.neat._issues import IssueList, catch_warnings
 from cognite.neat._rules import exporters
@@ -12,12 +12,12 @@ from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._utils.upload import UploadResultCore, UploadResultList
 
 from ._state import SessionState
-from .exceptions import NeatSessionError, intercept_session_exceptions
+from .exceptions import NeatSessionError, session_class_wrapper
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class ToAPI:
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._state = state
         self._verbose = verbose
         self.cdf = CDFToAPI(state, client, verbose)
@@ -46,23 +46,36 @@ class ToAPI:
         return None
 
     @overload
-    def yaml(self, io: None) -> str: ...
+    def yaml(self, io: None, format: Literal["neat"] = "neat") -> str: ...
 
     @overload
-    def yaml(self, io: Any) -> None: ...
-
-    def yaml(self, io: Any | None = None) -> str | None:
-        exporter = exporters.YAMLExporter()
-        if io is None:
-            return exporter.export(self._state.data_model.last_verified_rule[1])
+    def yaml(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> None: ...
+
+    def yaml(self, io: Any | None = None, format: Literal["neat", "toolkit"] = "neat") -> str | None:
+        if format == "neat":
+            exporter = exporters.YAMLExporter()
+            last_verified = self._state.data_model.last_verified_rule[1]
+            if io is None:
+                return exporter.export(last_verified)
+
+            exporter.export_to_file(last_verified, Path(io))
+        elif format == "toolkit":
+            if io is None or not isinstance(io, str | Path):
+                raise NeatSessionError(
+                    "Please provide a zip file or directory path to write the YAML files to."
+                    "This is required for the 'toolkit' format."
+                )
+            dms_rule = self._state.data_model.last_verified_dms_rules[1]
+            exporters.DMSExporter().export_to_file(dms_rule, Path(io))
+        else:
+            raise NeatSessionError("Please provide a valid format. {['neat', 'toolkit']}")
 
-        exporter.export_to_file(self._state.data_model.last_verified_rule[1], Path(io))
         return None
 
 
-@intercept_session_exceptions
+@session_class_wrapper
 class CDFToAPI:
-    def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
+    def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:
         self._client = client
         self._state = state
         self._verbose = verbose

cognite/neat/_session/exceptions.py

@@ -2,6 +2,8 @@ import functools
 from collections.abc import Callable
 from typing import Any
 
+from ._collector import _COLLECTOR
+
 try:
     from rich import print
 
@@ -16,9 +18,10 @@ class NeatSessionError(Exception):
     ...
 
 
-def _intercept_session_exceptions(func: Callable):
+def _session_method_wrapper(func: Callable, cls_name: str):
     @functools.wraps(func)
     def wrapper(*args: Any, **kwargs: Any):
+        _COLLECTOR.track_session_command(f"{cls_name}.{func.__name__}", *args, **kwargs)
         try:
             return func(*args, **kwargs)
         except NeatSessionError as e:
@@ -40,7 +43,21 @@ def _intercept_session_exceptions(func: Callable):
     return wrapper
 
 
-def intercept_session_exceptions(cls: type):
+def session_class_wrapper(cls: type):
+    """This decorator wraps all methods of a class.
+
+    It should be used with all composition classes used with the NeatSession class.
+
+    It does the following:
+        * Intercepts all NeatSession exceptions and prints them in a user-friendly way.
+        * Collects user metrics.
+
+    Args:
+        cls: NeatSession composition class
+
+    Returns:
+        cls: NeatSession composition class with all methods wrapped
+    """
     to_check = [cls]
     while to_check:
         cls = to_check.pop()
@@ -49,7 +66,7 @@ def intercept_session_exceptions(cls: type):
                 continue
             attr = getattr(cls, attr_name)
             if callable(attr):
-                setattr(cls, attr_name, _intercept_session_exceptions(attr))
+                setattr(cls, attr_name, _session_method_wrapper(attr, cls.__name__))
             elif isinstance(attr, type):
                 to_check.append(attr)
     return cls

cognite/neat/_store/_base.py

@@ -7,10 +7,11 @@ from typing import cast
 
 import pandas as pd
 from pandas import Index
-from rdflib import Graph, Namespace, URIRef
+from rdflib import Dataset, Namespace, URIRef
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._graph._shared import rdflib_to_oxi_type
 from cognite.neat._graph.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat._graph.queries import Queries
 from cognite.neat._graph.transformers import Transformers
@@ -42,7 +43,7 @@ class NeatGraphStore:
 
     def __init__(
         self,
-        graph: Graph,
+        graph: Dataset,
         rules: InformationRules | None = None,
     ):
         self.rules: InformationRules | None = None
@@ -109,7 +110,7 @@ class NeatGraphStore:
 
     @classmethod
     def from_memory_store(cls, rules: InformationRules | None = None) -> "Self":
-        return cls(Graph(identifier=DEFAULT_NAMESPACE), rules)
+        return cls(Dataset(), rules)
 
     @classmethod
     def from_sparql_store(
@@ -127,7 +128,7 @@ class NeatGraphStore:
             postAsEncoded=False,
             autocommit=False,
         )
-        graph = Graph(store=store, identifier=DEFAULT_NAMESPACE)
+        graph = Dataset(store=store)
         return cls(graph, rules)
 
     @classmethod
@@ -150,9 +151,8 @@ class NeatGraphStore:
         else:
             raise Exception("Error initializing Oxigraph store")
 
-        graph = Graph(
+        graph = Dataset(
             store=oxrdflib.OxigraphStore(store=oxi_store),
-            identifier=DEFAULT_NAMESPACE,
         )
 
         return cls(graph, rules)
@@ -162,7 +162,7 @@ class NeatGraphStore:
         success = True
 
         if isinstance(extractor, RdfFileExtractor) and not extractor.issue_list.has_errors:
-            self._parse_file(extractor.filepath, cast(str, extractor.mime_type), extractor.base_uri)
+            self._parse_file(extractor.filepath, cast(str, extractor.format), extractor.base_uri)
         elif isinstance(extractor, RdfFileExtractor):
             success = False
             issue_text = "\n".join([issue.as_message() for issue in extractor.issue_list])
@@ -244,33 +244,36 @@ class NeatGraphStore:
     def _parse_file(
         self,
         filepath: Path,
-        mime_type: str = "application/rdf+xml",
+        format: str = "turtle",
         base_uri: URIRef | None = None,
     ) -> None:
         """Imports graph data from file.
 
         Args:
             filepath : File path to file containing graph data, by default None
-            mime_type : MIME type of graph data, by default "application/rdf+xml"
-            base_uri : Add base IRI to graph, by default True
+            format : rdflib format file containing RDF graph, by default "turtle"
+            base_uri : base URI to add to graph in case of relative URIs, by default None
+
+        !!! note "Oxigraph store"
+            By default we are using non-transactional mode for parsing RDF files.
+            This gives us a significant performance boost when importing large RDF files.
+            Underhood of rdflib we are triggering oxrdflib plugin which in respect
+            calls `bulk_load` method from oxigraph store. See more at:
+            https://pyoxigraph.readthedocs.io/en/stable/store.html#pyoxigraph.Store.bulk_load
         """
 
         # Oxigraph store, do not want to type hint this as it is an optional dependency
         if type(self.graph.store).__name__ == "OxigraphStore":
-
-            def parse_to_oxi_store():
-                local_import("pyoxigraph", "oxi")
-                import pyoxigraph
-
-                cast(pyoxigraph.Store, self.graph.store._store).bulk_load(
-                    str(filepath),
-                    mime_type,
-                    base_iri=base_uri,
-                    to_graph=pyoxigraph.NamedNode(self.graph.identifier),
-                )
-                cast(pyoxigraph.Store, self.graph.store._store).optimize()
-
-            parse_to_oxi_store()
+            local_import("pyoxigraph", "oxi")
+
+            # this is necessary to trigger rdflib oxigraph plugin
+            self.graph.parse(
+                filepath,
+                format=rdflib_to_oxi_type(format),
+                transactional=False,
+                publicID=base_uri,
+            )
+            self.graph.store._store.optimize()  # type: ignore[attr-defined]
 
         # All other stores
         else:

cognite/neat/_store/_provenance.py

@@ -93,14 +93,14 @@ class Entity:
             return cls(
                 was_attributed_to=agent,
                 was_generated_by=activity,
-                id_=rules.id_,
+                id_=rules.metadata.identifier,
             )
 
         elif isinstance(rules, ReadRules | JustRules) and rules.rules is not None:
             return cls(
                 was_attributed_to=agent,
                 was_generated_by=activity,
-                id_=rules.rules.id_,
+                id_=rules.rules.metadata.identifier,
             )
         else:
             return cls(

cognite/neat/_utils/auxiliary.py

@@ -140,3 +140,22 @@ def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | s
                 except ValueError:
                     # Return the input string if no conversion is possible
                     return input_string
+
+
+def get_parameters_by_method(obj: object, prefix: str = "") -> dict[str, dict[str, type]]:
+    annotation_by_method = {}
+    namespace_dict = {**dict(obj.__class__.__dict__.items()), **vars(obj)}
+    for name, value in namespace_dict.items():
+        if name != "__call__" and (name.startswith("_") or isinstance(value, property)):
+            continue
+        if callable(value) and type(value).__name__ == "function":
+            annotation_by_method[f"{prefix}{name}"] = get_parameters(value)
+        elif isinstance(value, object) and type(value).__module__ != "builtins":
+            sub_prefix = f"{prefix}{name}." if prefix else f"{name}."
+            annotation_by_method.update(get_parameters_by_method(value, sub_prefix))
+    return annotation_by_method
+
+
+def get_parameters(obj: Callable) -> dict[str, type]:
+    annotations = inspect.get_annotations(obj)
+    return {name: annotations[name] for name in annotations if name != "return"}

cognite/neat/_utils/rdf_.py

@@ -173,7 +173,7 @@ def get_inheritance_path(child: Any, child_parent: dict[Any, list[Any]]) -> list
     return path
 
 
-def add_triples_in_batch(graph: Graph, triples: Iterable[Triple], batch_size: int = 10_000):
+def add_triples_in_batch(graph: Graph, triples: Iterable[Triple], batch_size: int = 10_000) -> None:
     """Adds triples to the graph store in batches.
 
     Args:
@@ -204,3 +204,30 @@ def add_triples_in_batch(graph: Graph, triples: Iterable[Triple], batch_size: in
         check_commit()
 
     check_commit(force_commit=True)
+
+
+def remove_instance_ids_in_batch(graph: Graph, instance_ids: Iterable[URIRef], batch_size: int = 1_000) -> None:
+    """Removes all triples related to the given instances in the graph store in batches.
+
+    Args:
+        graph: The graph store to remove triples from
+        instance_ids:  list of instances to remove triples from
+        batch_size:  Batch size of triples per commit, by default 10_000
+
+    """
+    batch_count = 0
+
+    def check_commit(force_commit: bool = False):
+        """Commit nodes to the graph if batch counter is reached or if force_commit is True"""
+        nonlocal batch_count
+        batch_count += 1
+        if force_commit or batch_count >= batch_size:
+            graph.commit()
+            batch_count = 0
+            return
+
+    for instance_id in instance_ids:
+        graph.remove((instance_id, None, None))
+        check_commit()
+
+    check_commit(force_commit=True)

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.97.3"
+__version__ = "0.99.0"
 __engine__ = "^1.0.3"

cognite/neat/_workflows/steps/data_contracts.py

@@ -10,9 +10,7 @@ from cognite.client.data_classes import (
 from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 
 from cognite.neat._rules.models import (
-    AssetRules,
     DMSRules,
-    DomainRules,
     InformationRules,
 )
 from cognite.neat._store import NeatGraphStore
@@ -20,19 +18,13 @@ from cognite.neat._workflows.steps.step_model import DataContract
 
 
 class MultiRuleData(DataContract):
-    domain: DomainRules | None = None
     information: InformationRules | None = None
-    asset: AssetRules | None = None
     dms: DMSRules | None = None
 
     @classmethod
-    def from_rules(cls, rules: DomainRules | InformationRules | AssetRules | DMSRules):
-        if isinstance(rules, DomainRules):
-            return cls(domain=rules)
-        elif isinstance(rules, InformationRules):
+    def from_rules(cls, rules: InformationRules | DMSRules):
+        if isinstance(rules, InformationRules):
             return cls(information=rules)
-        elif isinstance(rules, AssetRules):
-            return cls(asset=rules)
         elif isinstance(rules, DMSRules):
             return cls(dms=rules)
         else:

cognite/neat/_workflows/steps/lib/current/rules_exporter.py

@@ -2,16 +2,14 @@ import time
 from pathlib import Path
 from typing import ClassVar, Literal, cast
 
+from cognite.neat._client import NeatClient
 from cognite.neat._issues.errors import WorkflowStepNotInitializedError
 from cognite.neat._rules import exporters
 from cognite.neat._rules._shared import DMSRules, InformationRules, VerifiedRules
-from cognite.neat._rules.models import AssetRules, RoleTypes
+from cognite.neat._rules.models import RoleTypes
 from cognite.neat._rules.transformers import (
-    AssetToInformation,
     DMSToInformation,
-    InformationToAsset,
     InformationToDMS,
-    RulesPipeline,
 )
 from cognite.neat._workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat._workflows.steps.data_contracts import CogniteClient, MultiRuleData
@@ -82,7 +80,7 @@ class DeleteDataModelFromCDF(Step):
                 error_text="No DMS Schema components selected for removal! Please select minimum one!",
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
-        input_rules = rules.dms or rules.information or rules.asset
+        input_rules = rules.dms or rules.information
         if input_rules is None:
             return FlowMessage(
                 error_text="Missing DMS or Information rules in the input data! "
@@ -93,8 +91,6 @@ class DeleteDataModelFromCDF(Step):
             dms_rules = input_rules
         elif isinstance(input_rules, InformationRules):
             dms_rules = InformationToDMS().transform(input_rules).rules
-        elif isinstance(input_rules, AssetRules):
-            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
         else:
             raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
 
@@ -105,7 +101,7 @@ class DeleteDataModelFromCDF(Step):
 
         report_lines = ["# Data Model Deletion from CDF\n\n"]
         errors = []
-        for result in dms_exporter.delete_from_cdf(rules=dms_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.delete_from_cdf(rules=dms_rules, client=NeatClient(cdf_client), dry_run=dry_run):
             report_lines.append(str(result))
             errors.extend(result.error_messages)
 
@@ -207,8 +203,6 @@ class RulesToDMS(Step):
             dms_rules = input_rules
         elif isinstance(input_rules, InformationRules):
             dms_rules = InformationToDMS().transform(input_rules).rules
-        elif isinstance(input_rules, AssetRules):
-            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
         else:
             raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
 
@@ -220,18 +214,16 @@ class RulesToDMS(Step):
 
         output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
-        file_name = (
-            input_rules.metadata.external_id
-            if isinstance(input_rules, DMSRules)
-            else input_rules.metadata.name.replace(" ", "_").lower()
-        )
+        file_name = input_rules.metadata.external_id
         schema_zip = f"{file_name}.zip"
         schema_full_path = output_dir / schema_zip
         dms_exporter.export_to_file(dms_rules, schema_full_path)
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf_iterable(rules=dms_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.export_to_cdf_iterable(
+            rules=dms_rules, client=NeatClient(cdf_client), dry_run=dry_run
+        ):
             report_lines.append(str(result))
             errors.extend(result.error_messages)
 
@@ -283,14 +275,6 @@ class RulesToExcel(Step):
             "rules will be used.",
             options=["input", *RoleTypes.__members__.keys()],
         ),
-        Configurable(
-            name="Dump Format",
-            value="user",
-            label="How to dump the rules to the Excel file.\n"
-            "'user' - just as is.\n'reference' - enterprise model used as basis for a solution model\n"
-            "'last' - used when updating a data model.",
-            options=list(exporters.ExcelExporter.dump_options),
-        ),
         Configurable(
             name="New Data Model ID",
             value="",
@@ -308,7 +292,6 @@ class RulesToExcel(Step):
         if self.configs is None or self.data_store_path is None:
             raise WorkflowStepNotInitializedError(type(self).__name__)
 
-        dump_format = self.configs.get("Dump Format", "user")
         styling = cast(exporters.ExcelExporter.Style, self.configs.get("Styling", "default"))
         role = self.configs.get("Output role format")
         output_role: RoleTypes | None = None
@@ -325,18 +308,15 @@ class RulesToExcel(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        excel_exporter = exporters.ExcelExporter(styling=styling, dump_as=dump_format, new_model_id=new_model_id)  # type: ignore[arg-type]
+        excel_exporter = exporters.ExcelExporter(styling=styling, new_model_id=new_model_id)  # type: ignore[arg-type]
 
         # Todo - Move the conversion to a separate workflow step.
         rule_instance: VerifiedRules
-        if rules.domain:
-            rule_instance = rules.domain
-        elif rules.information:
+
+        if rules.information:
             rule_instance = rules.information
         elif rules.dms:
             rule_instance = rules.dms
-        elif rules.asset:
-            rule_instance = rules.asset
         else:
             output_errors = "No rules provided for export!"
             return FlowMessage(error_text=output_errors, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
@@ -346,26 +326,11 @@ class RulesToExcel(Step):
         elif output_role is RoleTypes.dms:
             if isinstance(rule_instance, InformationRules):
                 rule_instance = InformationToDMS().transform(rule_instance).rules
-            elif isinstance(rule_instance, AssetRules):
-                rule_instance = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(
-                    rule_instance
-                )
             else:
                 raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
         elif output_role is RoleTypes.information:
             if isinstance(rule_instance, DMSRules):
                 rule_instance = DMSToInformation().transform(rule_instance).rules
-            elif isinstance(rule_instance, AssetRules):
-                rule_instance = AssetToInformation().transform(rule_instance).rules
-            else:
-                raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
-        elif output_role is RoleTypes.asset:
-            if isinstance(rule_instance, InformationRules):
-                rule_instance = InformationToAsset().transform(rule_instance).rules
-            elif isinstance(rule_instance, DMSRules):
-                rule_instance = RulesPipeline[DMSRules, AssetRules]([DMSToInformation(), InformationToAsset()]).run(
-                    rule_instance
-                )
             else:
                 raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
         else:
@@ -604,8 +569,6 @@ class RulesToCDFTransformations(Step):
             dms_rules = input_rules
         elif isinstance(input_rules, InformationRules):
             dms_rules = InformationToDMS().transform(input_rules).rules
-        elif isinstance(input_rules, AssetRules):
-            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
         else:
             raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
 
@@ -624,7 +587,9 @@ class RulesToCDFTransformations(Step):
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf_iterable(rules=dms_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.export_to_cdf_iterable(
+            rules=dms_rules, client=NeatClient(cdf_client), dry_run=dry_run
+        ):
             report_lines.append(str(result))
             errors.extend(result.error_messages)
 

cognite/neat/_workflows/steps/lib/current/rules_importer.py

@@ -5,6 +5,7 @@ from typing import ClassVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import DataModelId
 
+from cognite.neat._client import NeatClient
 from cognite.neat._issues.errors import WorkflowStepNotInitializedError
 from cognite.neat._issues.formatters import FORMATTER_BY_NAME
 from cognite.neat._rules import importers
@@ -299,7 +300,9 @@ class DMSToRules(Step):
                 return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
             ref_model_id = ref_model.as_id()
 
-        dms_importer = importers.DMSImporter.from_data_model_id(cdf_client, datamodel_entity.as_id(), ref_model_id)
+        dms_importer = importers.DMSImporter.from_data_model_id(
+            NeatClient(cdf_client), datamodel_entity.as_id(), ref_model_id
+        )
 
         # if role is None, it will be inferred from the rules file
         role = self.configs.get("Role")

cognite/neat/_workflows/steps/lib/current/rules_validator.py

@@ -5,11 +5,12 @@ from typing import ClassVar
 
 from cognite.client import CogniteClient
 
+from cognite.neat._client import NeatClient
+from cognite.neat._client._api.data_modeling_loaders import ViewLoader
 from cognite.neat._issues import NeatIssueList
 from cognite.neat._issues.errors import ResourceNotFoundError, WorkflowStepNotInitializedError
 from cognite.neat._issues.formatters import FORMATTER_BY_NAME
-from cognite.neat._rules.models import DMSRules, SchemaCompleteness
-from cognite.neat._utils.cdf.loaders import ViewLoader
+from cognite.neat._rules.models import DMSRules
 from cognite.neat._workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat._workflows.steps.data_contracts import MultiRuleData
 from cognite.neat._workflows.steps.step_model import Configurable, Step
@@ -49,12 +50,7 @@ class ValidateRulesAgainstCDF(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
         dms_rules = rules.dms
-        if dms_rules.metadata.schema_ is not SchemaCompleteness.partial:
-            return FlowMessage(
-                error_text="DMS rules are not partial. This step expects DMS rules to be a partial definition "
-                "with the rest of the definition being fetched from CDF.",
-                step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
-            )
+
         schema = dms_rules.as_schema()
         errors = schema.validate()
         if not errors:
@@ -80,7 +76,7 @@ class ValidateRulesAgainstCDF(Step):
         retrieved_containers = cdf_client.data_modeling.containers.retrieve(missing_containers).as_write()
         # Converting read format of views to write format requires to account for parents (implements)
         # Thus we use the loader to convert the views to write format.
-        view_loader = ViewLoader(cdf_client)
+        view_loader = ViewLoader(NeatClient(cdf_client))
         retrieved_views = [
             view_loader.as_write(view) for view in cdf_client.data_modeling.views.retrieve(missing_views)
         ]

{cognite_neat-0.97.3.dist-info → cognite_neat-0.99.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.97.3
+Version: 0.99.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -29,6 +29,7 @@ Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
 Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
 Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
+Requires-Dist: mixpanel (>=4.10.1,<5.0.0)
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
 Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"
@@ -40,13 +41,13 @@ Requires-Dist: mkdocs-material-extensions ; extra == "docs"
 Requires-Dist: mkdocstrings[python] ; extra == "docs"
 Requires-Dist: networkx (>=3.4.2,<4.0.0)
 Requires-Dist: openpyxl
-Requires-Dist: oxrdflib[oxigraph] (>=0.3.3,<0.4.0) ; extra == "oxi" or extra == "all"
+Requires-Dist: oxrdflib[oxigraph] (>=0.4.0,<0.5.0) ; extra == "oxi" or extra == "all"
 Requires-Dist: packaging (>=22.0,<25.0)
 Requires-Dist: pandas
 Requires-Dist: prometheus-client (>=0,<1) ; extra == "service" or extra == "all"
 Requires-Dist: pydantic (>=2,<3)
 Requires-Dist: pymdown-extensions ; extra == "docs"
-Requires-Dist: pyoxigraph (==0.3.19) ; extra == "oxi" or extra == "all"
+Requires-Dist: pyoxigraph (==0.4.3) ; extra == "oxi" or extra == "all"
 Requires-Dist: python-multipart (==0.0.9) ; extra == "service" or extra == "all"
 Requires-Dist: pyvis (>=0.3.2,<0.4.0)
 Requires-Dist: rdflib