cognite-neat 0.123.2__py3-none-any.whl → 0.127.30__py3-none-any.whl

cognite/neat/v0/core/_data_model/transformers/_union_conceptual.py

@@ -0,0 +1,208 @@
+from collections.abc import Iterable, Set
+from typing import Literal
+
+from cognite.neat.v0.core._data_model.models import ConceptualDataModel, SheetList
+from cognite.neat.v0.core._data_model.models.conceptual import Concept, ConceptualProperty
+from cognite.neat.v0.core._data_model.models.data_types import DataType
+from cognite.neat.v0.core._data_model.models.entities import (
+    ConceptEntity,
+    MultiValueTypeInfo,
+    UnknownEntity,
+)
+from cognite.neat.v0.core._data_model.transformers import VerifiedDataModelTransformer
+
+
+class UnionConceptualDataModel(VerifiedDataModelTransformer[ConceptualDataModel, ConceptualDataModel]):
+    """Takes the union two conceptual models.
+    Args:
+        primary: The primary model to merge with the secondary model given in the transform method.
+    """
+
+    def __init__(self, primary: ConceptualDataModel) -> None:
+        self.primary = primary
+
+    def transform(self, data_model: ConceptualDataModel) -> ConceptualDataModel:
+        primary_model = self.primary
+        secondary_model = data_model
+
+        output = primary_model.model_copy(deep=True)
+        secondary_concepts = {cls.concept: cls for cls in secondary_model.concepts}
+        secondary_properties = {(prop.concept, prop.property_): prop for prop in secondary_model.properties}
+
+        union_concepts_by_id = self._union_concepts(output.concepts, secondary_concepts)
+        output.concepts = SheetList[Concept](union_concepts_by_id.values())
+
+        union_properties = self._union_properties(
+            output.properties, secondary_properties, set(union_concepts_by_id.keys())
+        )
+        output.properties = SheetList[ConceptualProperty](union_properties.values())
+
+        return output
+
+    def _union_concepts(
+        self, primary_concepts: Iterable[Concept], new_concepts: dict[ConceptEntity, Concept]
+    ) -> dict[ConceptEntity, Concept]:
+        union_concepts = {cls.concept: cls for cls in primary_concepts}
+        for concept, primary_concept in union_concepts.items():
+            if concept not in new_concepts:
+                continue
+            secondary_concept = new_concepts[concept]
+            union_concepts[concept] = self.union_concepts(
+                primary=primary_concept,
+                secondary=secondary_concept,
+                conflict_resolution="combined",
+            )
+
+        for concept, secondary_concept in new_concepts.items():
+            if concept not in union_concepts:
+                union_concepts[concept] = secondary_concept
+        return union_concepts
+
+    def _union_properties(
+        self,
+        primary_properties: Iterable[ConceptualProperty],
+        secondary_properties: dict[tuple[ConceptEntity, str], ConceptualProperty],
+        used_concepts: Set[ConceptEntity],
+    ) -> dict[tuple[ConceptEntity, str], ConceptualProperty]:
+        union_properties = {(prop.concept, prop.property_): prop for prop in primary_properties}
+        for (concept, prop_id), primary_property in union_properties.items():
+            if (concept not in used_concepts) or (concept, prop_id) not in secondary_properties:
+                continue
+            secondary_property = secondary_properties[(concept, prop_id)]
+            union_properties[(concept, prop_id)] = self.union_properties(
+                primary=primary_property,
+                secondary=secondary_property,
+                conflict_resolution="combined",
+            )
+
+        for (concept, prop_id), prop in secondary_properties.items():
+            if (concept, prop_id) not in union_properties and concept in used_concepts:
+                union_properties[(concept, prop_id)] = prop
+        return union_properties
+
+    @classmethod
+    def union_concepts(
+        cls,
+        primary: Concept,
+        secondary: Concept,
+        conflict_resolution: Literal["priority", "combined"] = "priority",
+    ) -> Concept:
+        """Union two concepts.
+
+        Args:
+            primary (Concept): The primary concept.
+            secondary (Concept): The secondary concept.
+            conflict_resolution (Literal["priority", "combined"]): How to resolve conflicts:
+                - "priority": Keep the primary concept with fallback to the secondary.
+                - "combined": Merge implements from both concepts. (only applies to implements)
+        Returns:
+            Concept: The union of the two concepts.
+
+        """
+        if conflict_resolution == "combined":
+            all_implements = (primary.implements or []) + (secondary.implements or [])
+            implements = list(dict.fromkeys(all_implements))
+        else:
+            implements = (primary.implements or secondary.implements or []).copy()
+
+        return Concept(
+            neatId=primary.neatId,
+            concept=primary.concept,
+            name=primary.name or secondary.name,
+            description=primary.description or secondary.description,
+            implements=implements,
+            instance_source=primary.instance_source or secondary.instance_source,
+            physical=primary.physical,
+        )
+
+    @classmethod
+    def union_properties(
+        cls,
+        primary: ConceptualProperty,
+        secondary: ConceptualProperty,
+        conflict_resolution: Literal["priority", "combined"] = "priority",
+    ) -> ConceptualProperty:
+        """Union two conceptual properties.
+
+        Args:
+            primary (ConceptualProperty): The primary property.
+            secondary (ConceptualProperty): The secondary property.
+            conflict_resolution (Literal["priority", "combined"]): How to resolve conflicts:
+                - "priority": Keep the primary property with fallback to the secondary.
+                - "combined": Merge value types and instance sources.
+        Returns:
+            ConceptualProperty: The union of the two properties.
+
+        """
+        if conflict_resolution == "combined":
+            all_sources = (primary.instance_source or []) + (secondary.instance_source or [])
+            instance_source = list(dict.fromkeys(all_sources))
+        else:
+            instance_source = (primary.instance_source or secondary.instance_source or []).copy()
+
+        use_primary = conflict_resolution == "priority"
+        return ConceptualProperty(
+            neatId=primary.neatId,
+            concept=primary.concept,
+            property_=primary.property_,
+            name=primary.name or secondary.name,
+            description=primary.description or secondary.description,
+            min_count=primary.min_count
+            if use_primary
+            else cls._union_min_count(primary.min_count, secondary.min_count),
+            max_count=primary.max_count
+            if use_primary
+            else cls._union_max_count(primary.max_count, secondary.max_count),
+            default=primary.default or secondary.default,
+            value_type=primary.value_type
+            if use_primary
+            else cls.union_value_type(primary.value_type, secondary.value_type),
+            instance_source=instance_source,
+            inherited=primary.inherited,
+            physical=primary.physical,
+        )
+
+    @staticmethod
+    def _union_min_count(primary: int | None, secondary: int | None) -> int | None:
+        if primary is None:
+            return secondary
+        if secondary is None:
+            return primary
+        return min(primary, secondary)
+
+    @staticmethod
+    def _union_max_count(primary: int | float | None, secondary: int | float | None) -> int | float | None:
+        if primary is None:
+            return secondary
+        if secondary is None:
+            return primary
+        output = max(primary, secondary)
+        try:
+            return int(output)
+        except (OverflowError, ValueError):
+            # The value is float('inf') or float('-inf')
+            return output
+
+    @staticmethod
+    def union_value_type(
+        primary: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity,
+        secondary: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity,
+    ) -> DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity:
+        all_types: list[DataType | ConceptEntity] = []
+        for type_ in (primary, secondary):
+            if isinstance(type_, MultiValueTypeInfo):
+                all_types.extend(type_.types)
+            elif isinstance(type_, UnknownEntity):
+                continue
+            elif isinstance(type_, DataType | ConceptEntity):
+                all_types.append(type_)
+            else:
+                raise NotImplementedError(f"Unsupported type: {type_}")
+
+        ordered_types = list(dict.fromkeys(all_types))
+        if len(ordered_types) == 0:
+            return UnknownEntity()
+        if len(ordered_types) == 1:
+            return ordered_types[0]
+        else:  # len(ordered_types) > 1:
+            return MultiValueTypeInfo(types=ordered_types)

cognite/neat/{core → v0/core}/_data_model/transformers/_verification.py

@@ -1,23 +1,23 @@
 from abc import ABC
 from typing import cast
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._data_model._shared import (
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._data_model._shared import (
     ImportedDataModel,
     T_ImportedUnverifiedDataModel,
     T_VerifiedDataModel,
     VerifiedDataModel,
 )
-from cognite.neat.core._data_model.models import (
+from cognite.neat.v0.core._data_model.models import (
     ConceptualDataModel,
     PhysicalDataModel,
     UnverifiedConceptualDataModel,
     UnverifiedPhysicalDataModel,
 )
-from cognite.neat.core._data_model.models.conceptual import ConceptualValidation
-from cognite.neat.core._data_model.models.physical import PhysicalValidation
-from cognite.neat.core._issues import MultiValueError, catch_issues
-from cognite.neat.core._issues.errors import NeatTypeError, NeatValueError
+from cognite.neat.v0.core._data_model.models.conceptual import ConceptualValidation
+from cognite.neat.v0.core._data_model.models.physical import PhysicalValidation
+from cognite.neat.v0.core._issues import MultiValueError, catch_issues
+from cognite.neat.v0.core._issues.errors import NeatTypeError, NeatValueError
 
 from ._base import DataModelTransformer
 

cognite/neat/{core → v0/core}/_instances/_tracking/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 
-from cognite.neat.core._issues import NeatIssue
+from cognite.neat.v0.core._issues import NeatIssue
 
 
 class Tracker(ABC):

cognite/neat/{core → v0/core}/_instances/_tracking/log.py

@@ -1,6 +1,6 @@
 from logging import getLogger
 
-from cognite.neat.core._issues import NeatError, NeatIssue, NeatWarning
+from cognite.neat.v0.core._issues import NeatError, NeatIssue, NeatWarning
 
 from .base import Tracker
 

cognite/neat/{core → v0/core}/_instances/extractors/__init__.py

@@ -1,4 +1,4 @@
-from cognite.neat.session.engine._interface import Extractor as EngineExtractor
+from cognite.neat.v0.session.engine._interface import Extractor as EngineExtractor
 
 from ._base import BaseExtractor, KnowledgeGraphExtractor
 from ._classic_cdf._assets import AssetsExtractor

cognite/neat/{core → v0/core}/_instances/extractors/_base.py

@@ -4,13 +4,13 @@ from typing import TYPE_CHECKING
 
 from rdflib import URIRef
 
-from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._data_model.models import ConceptualDataModel
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.auxiliary import class_html_doc
+from cognite.neat.v0.core._constants import DEFAULT_NAMESPACE
+from cognite.neat.v0.core._data_model.models import ConceptualDataModel
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.auxiliary import class_html_doc
 
 if TYPE_CHECKING:
-    from cognite.neat.core._store._provenance import Agent as ProvenanceAgent
+    from cognite.neat.v0.core._store._provenance import Agent as ProvenanceAgent
 
 
 class BaseExtractor:
@@ -53,6 +53,6 @@ class KnowledgeGraphExtractor(BaseExtractor):
     @property
     def agent(self) -> "ProvenanceAgent":
         """Provenance agent for the importer."""
-        from cognite.neat.core._store._provenance import Agent as ProvenanceAgent
+        from cognite.neat.v0.core._store._provenance import Agent as ProvenanceAgent
 
         return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])

cognite/neat/{core → v0/core}/_instances/extractors/_classic_cdf/_base.py

@@ -17,13 +17,13 @@ from pydantic import AnyHttpUrl, ValidationError
 from rdflib import RDF, XSD, Literal, Namespace, URIRef
 from typing_extensions import Self
 
-from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._instances.extractors._base import BaseExtractor
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.auxiliary import string_to_ideal_type
-from cognite.neat.core._utils.collection_ import (
+from cognite.neat.v0.core._constants import DEFAULT_NAMESPACE
+from cognite.neat.v0.core._instances.extractors._base import BaseExtractor
+from cognite.neat.v0.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._issues.warnings import CDFAuthWarning, NeatValueWarning
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.auxiliary import string_to_ideal_type
+from cognite.neat.v0.core._utils.collection_ import (
     iterate_progress_bar_if_above_config_threshold,
 )
 

cognite/neat/{core → v0/core}/_instances/extractors/_classic_cdf/_classic.py

@@ -9,24 +9,24 @@ from cognite.client import CogniteClient
 from cognite.client.exceptions import CogniteAPIError
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import (
+from cognite.neat.v0.core._constants import (
     CLASSIC_CDF_NAMESPACE,
     DEFAULT_NAMESPACE,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat.core._data_model._shared import ImportedDataModel
-from cognite.neat.core._data_model.catalog import classic_model
-from cognite.neat.core._data_model.models import (
+from cognite.neat.v0.core._data_model._shared import ImportedDataModel
+from cognite.neat.v0.core._data_model.catalog import classic_model
+from cognite.neat.v0.core._data_model.models import (
     ConceptualDataModel,
     UnverifiedConceptualDataModel,
 )
-from cognite.neat.core._instances.extractors._base import KnowledgeGraphExtractor
-from cognite.neat.core._issues.errors import NeatValueError, ResourceNotFoundError
-from cognite.neat.core._issues.warnings import CDFAuthWarning, NeatValueWarning
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.collection_ import chunker, iterate_progress_bar
-from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
-from cognite.neat.core._utils.text import to_snake_case
+from cognite.neat.v0.core._instances.extractors._base import KnowledgeGraphExtractor
+from cognite.neat.v0.core._issues.errors import NeatValueError, ResourceNotFoundError
+from cognite.neat.v0.core._issues.warnings import CDFAuthWarning, NeatValueWarning
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.collection_ import chunker, iterate_progress_bar
+from cognite.neat.v0.core._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat.v0.core._utils.text import to_snake_case
 
 from ._assets import AssetsExtractor
 from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
@@ -210,7 +210,7 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
 
     def get_conceptual_data_model(self) -> ConceptualDataModel:
         # To avoid circular imports
-        from cognite.neat.core._data_model.importers import ExcelImporter
+        from cognite.neat.v0.core._data_model.importers import ExcelImporter
 
         unverified = cast(
             ImportedDataModel[UnverifiedConceptualDataModel],

cognite/neat/{core → v0/core}/_instances/extractors/_classic_cdf/_relationships.py

@@ -9,9 +9,9 @@ from cognite.client import CogniteClient
 from cognite.client.data_classes import Relationship, RelationshipList
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._issues.warnings import NeatValueWarning
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.auxiliary import create_sha256_hash
+from cognite.neat.v0.core._issues.warnings import NeatValueWarning
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.auxiliary import create_sha256_hash
 
 from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix, T_CogniteResource
 

cognite/neat/{core → v0/core}/_instances/extractors/_classic_cdf/_sequences.py

@@ -10,11 +10,11 @@ from cognite.client.data_classes import Sequence, SequenceFilter
 from rdflib import RDF, XSD, Literal, Namespace, URIRef
 from typing_extensions import Self
 
-from cognite.neat.core._client.data_classes.neat_sequence import (
+from cognite.neat.v0.core._client.data_classes.neat_sequence import (
     NeatSequence,
     NeatSequenceList,
 )
-from cognite.neat.core._shared import Triple
+from cognite.neat.v0.core._shared import Triple
 
 from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
 

cognite/neat/{core → v0/core}/_instances/extractors/_dict.py

@@ -7,8 +7,8 @@ from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling.instances import Instance
 from rdflib import XSD, Literal, Namespace, URIRef
 
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.auxiliary import string_to_ideal_type
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.auxiliary import string_to_ideal_type
 
 from ._base import BaseExtractor
 
@@ -43,9 +43,12 @@ class DictExtractor(BaseExtractor):
         self, key: str, value: Any, unpack_json: bool
     ) -> Iterable[tuple[str, Literal | URIRef]]:
         if key in self.uri_ref_keys and not isinstance(value, dict | list):
+            # exist if key is meant to form a URIRef
             yield key, URIRef(self.namespace[urllib.parse.quote(value)])
-        if isinstance(value, str | float | bool | int):
+        elif isinstance(value, float | bool | int):
             yield key, Literal(value)
+        elif isinstance(value, str):
+            yield key, Literal(string_to_ideal_type(value)) if self.str_to_ideal_type else Literal(value)
         elif isinstance(value, dict) and unpack_json:
             yield from self._unpack_json(value)
         elif isinstance(value, dict):

cognite/neat/{core → v0/core}/_instances/extractors/_dms.py

@@ -9,12 +9,12 @@ from cognite.client.data_classes.data_modeling.instances import Edge, Instance,
 from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import RDF, Literal, Namespace, URIRef
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._config import GLOBAL_CONFIG
-from cognite.neat.core._constants import DEFAULT_SPACE_URI, is_readonly_property
-from cognite.neat.core._issues.errors import ResourceRetrievalError
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.collection_ import iterate_progress_bar
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._config import GLOBAL_CONFIG
+from cognite.neat.v0.core._constants import DEFAULT_SPACE_URI, is_readonly_property
+from cognite.neat.v0.core._issues.errors import ResourceRetrievalError
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.collection_ import iterate_progress_bar
 
 from ._base import BaseExtractor
 from ._dict import DEFAULT_EMPTY_VALUES, DMSPropertyExtractor

cognite/neat/{core → v0/core}/_instances/extractors/_dms_graph.py

@@ -5,24 +5,24 @@ from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
-from cognite.neat.core._data_model.importers import DMSImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
-from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
-from cognite.neat.core._data_model.models.data_types import Json
-from cognite.neat.core._data_model.models.entities import UnknownEntity
-from cognite.neat.core._data_model.transformers import (
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
+from cognite.neat.v0.core._data_model.importers import DMSImporter
+from cognite.neat.v0.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.v0.core._data_model.models.conceptual import ConceptualProperty
+from cognite.neat.v0.core._data_model.models.data_types import Json
+from cognite.neat.v0.core._data_model.models.entities import UnknownEntity
+from cognite.neat.v0.core._data_model.transformers import (
     PhysicalToConceptual,
     VerifyPhysicalDataModel,
 )
-from cognite.neat.core._issues import IssueList, NeatIssue, catch_warnings
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._issues import IssueList, NeatIssue, catch_warnings
+from cognite.neat.v0.core._issues.warnings import (
     CDFAuthWarning,
     ResourceNotFoundWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._shared import Triple
+from cognite.neat.v0.core._shared import Triple
 
 from ._base import KnowledgeGraphExtractor
 from ._dms import DMSExtractor

cognite/neat/{core → v0/core}/_instances/extractors/_mock_graph_generator.py

@@ -11,15 +11,15 @@ import numpy
 import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
-from cognite.neat.core._data_model._constants import EntityTypes
-from cognite.neat.core._data_model.analysis import DataModelAnalysis
-from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
-from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import ConceptEntity
-from cognite.neat.core._data_model.transformers import SubsetConceptualDataModel
-from cognite.neat.core._shared import Triple
-from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat.v0.core._data_model._constants import EntityTypes
+from cognite.neat.v0.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.v0.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.v0.core._data_model.models.conceptual import ConceptualProperty
+from cognite.neat.v0.core._data_model.models.data_types import DataType
+from cognite.neat.v0.core._data_model.models.entities import ConceptEntity
+from cognite.neat.v0.core._data_model.transformers import SubsetConceptualDataModel
+from cognite.neat.v0.core._shared import Triple
+from cognite.neat.v0.core._utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExtractor
 
@@ -45,7 +45,7 @@ class MockGraphGenerator(BaseExtractor):
     ):
         if isinstance(data_model, PhysicalDataModel):
             # fixes potential issues with circular dependencies
-            from cognite.neat.core._data_model.transformers import PhysicalToConceptual
+            from cognite.neat.v0.core._data_model.transformers import PhysicalToConceptual
 
             self.data_model = PhysicalToConceptual().transform(data_model)
         elif isinstance(data_model, ConceptualDataModel):

cognite/neat/{core → v0/core}/_instances/extractors/_raw.py

@@ -6,9 +6,9 @@ from cognite.client.data_classes import Row, RowList
 from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import RDF, Namespace, URIRef
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._constants import DEFAULT_RAW_URI
-from cognite.neat.core._shared import Triple
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._constants import DEFAULT_RAW_URI
+from cognite.neat.v0.core._shared import Triple
 
 from ._base import BaseExtractor
 from ._dict import DEFAULT_EMPTY_VALUES, DictExtractor

cognite/neat/{core → v0/core}/_instances/extractors/_rdf_file.py

@@ -7,16 +7,16 @@ from rdflib import URIRef
 from rdflib.util import guess_format
 from typing_extensions import Self
 
-from cognite.neat.core._constants import DEFAULT_BASE_URI
-from cognite.neat.core._instances._shared import RDFTypes
-from cognite.neat.core._instances.extractors._base import BaseExtractor
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._issues.errors import (
+from cognite.neat.v0.core._constants import DEFAULT_BASE_URI
+from cognite.neat.v0.core._instances._shared import RDFTypes
+from cognite.neat.v0.core._instances.extractors._base import BaseExtractor
+from cognite.neat.v0.core._issues._base import IssueList
+from cognite.neat.v0.core._issues.errors import (
     FileNotFoundNeatError,
     FileTypeUnexpectedError,
 )
-from cognite.neat.core._issues.errors._general import NeatValueError
-from cognite.neat.core._shared import Triple
+from cognite.neat.v0.core._issues.errors._general import NeatValueError
+from cognite.neat.v0.core._shared import Triple
 
 
 class RdfFileExtractor(BaseExtractor):

cognite/neat/{core → v0/core}/_instances/loaders/_base.py

@@ -5,11 +5,11 @@ from typing import ClassVar, Generic, TypeVar
 
 from cognite.client.data_classes.capabilities import Capability
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._issues import IssueList, NeatIssue
-from cognite.neat.core._issues.errors import AuthorizationError
-from cognite.neat.core._utils.auxiliary import class_html_doc
-from cognite.neat.core._utils.upload import UploadResult, UploadResultList
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._issues import IssueList, NeatIssue
+from cognite.neat.v0.core._issues.errors import AuthorizationError
+from cognite.neat.v0.core._utils.auxiliary import class_html_doc
+from cognite.neat.v0.core._utils.upload import UploadResult, UploadResultList
 
 T_Output = TypeVar("T_Output")
 

cognite/neat/{core → v0/core}/_instances/loaders/_rdf2dms.py

@@ -19,46 +19,46 @@ from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 from rdflib import RDF, URIRef
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._client._api_client import SchemaAPI
-from cognite.neat.core._constants import (
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._client._api_client import SchemaAPI
+from cognite.neat.v0.core._constants import (
     COGNITE_SPACES,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     is_readonly_property,
 )
-from cognite.neat.core._data_model.analysis import DataModelAnalysis
-from cognite.neat.core._data_model.analysis._base import ViewQuery, ViewQueryDict
-from cognite.neat.core._data_model.models import PhysicalDataModel
-from cognite.neat.core._data_model.models.conceptual._verified import (
+from cognite.neat.v0.core._data_model.analysis import DataModelAnalysis
+from cognite.neat.v0.core._data_model.analysis._base import ViewQuery, ViewQueryDict
+from cognite.neat.v0.core._data_model.models import PhysicalDataModel
+from cognite.neat.v0.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.data_types import (
+from cognite.neat.v0.core._data_model.models.data_types import (
     _DATA_TYPE_BY_DMS_TYPE,
     Json,
     String,
 )
-from cognite.neat.core._issues import IssueList, NeatError, NeatIssue, catch_issues
-from cognite.neat.core._issues.errors import (
+from cognite.neat.v0.core._issues import IssueList, NeatError, NeatIssue, catch_issues
+from cognite.neat.v0.core._issues.errors import (
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceNotFoundError,
 )
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._issues.warnings import (
     PropertyDirectRelationLimitWarning,
     PropertyMultipleValueWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNeatWarning,
 )
-from cognite.neat.core._shared import InstanceType
-from cognite.neat.core._store import NeatInstanceStore
-from cognite.neat.core._utils.auxiliary import create_sha256_hash
-from cognite.neat.core._utils.collection_ import (
+from cognite.neat.v0.core._shared import InstanceType
+from cognite.neat.v0.core._store import NeatInstanceStore
+from cognite.neat.v0.core._utils.auxiliary import create_sha256_hash
+from cognite.neat.v0.core._utils.collection_ import (
     iterate_progress_bar_if_above_config_threshold,
 )
-from cognite.neat.core._utils.rdf_ import (
+from cognite.neat.v0.core._utils.rdf_ import (
     remove_namespace_from_uri,
 )
-from cognite.neat.core._utils.upload import UploadResult
+from cognite.neat.v0.core._utils.upload import UploadResult
 
 from ._base import _END_OF_CLASS, _START_OF_CLASS, CDFLoader