cognite-neat 0.107.0__py3-none-any.whl → 0.109.0__py3-none-any.whl

cognite/neat/_graph/transformers/_value_type.py

@@ -4,10 +4,10 @@ from typing import Any, cast
 from urllib.parse import quote
 
 import rdflib
-from rdflib import RDF, Namespace, URIRef
+from rdflib import RDF, RDFS, Literal, Namespace, URIRef
 from rdflib.query import ResultRow
 
-from cognite.neat._constants import UNKNOWN_TYPE
+from cognite.neat._constants import NEAT
 from cognite.neat._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat._utils.auxiliary import string_to_ideal_type
 from cognite.neat._utils.rdf_ import Triple, get_namespace, remove_namespace_from_uri
@@ -24,7 +24,7 @@ class SplitMultiValueProperty(BaseTransformerStandardised):
     _need_changes = frozenset({})
 
     def __init__(self, unknown_type: URIRef | None = None) -> None:
-        self.unknown_type = unknown_type or UNKNOWN_TYPE
+        self.unknown_type = unknown_type or NEAT.UnknownType
 
     def _iterate_query(self) -> str:
         query = """SELECT ?subjectType ?property
@@ -78,8 +78,8 @@ class SplitMultiValueProperty(BaseTransformerStandardised):
 
         new_property = URIRef(f"{old_property}_{remove_namespace_from_uri(value_type)}")
 
-        row_output.add_triples.append(cast(Triple, (subject, new_property, object)))
-        row_output.remove_triples.append(cast(Triple, (subject, old_property, object)))
+        row_output.add_triples.add(cast(Triple, (subject, new_property, object)))
+        row_output.remove_triples.add(cast(Triple, (subject, old_property, object)))
 
         row_output.instances_modified_count += 1
 
@@ -143,8 +143,8 @@ class ConvertLiteral(BaseTransformerStandardised):
                 PropertyDataTypeConversionWarning(str(instance), self._type_name, self._property_name, str(e)),
                 stacklevel=2,
             )
-        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(converted_value)))  # type: ignore[arg-type]
-        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.add_triples.add((instance, self.subject_predicate, rdflib.Literal(converted_value)))  # type: ignore[arg-type]
+        row_output.remove_triples.add((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
         row_output.instances_modified_count += 1
 
         return row_output
@@ -221,15 +221,15 @@ class LiteralToEntity(BaseTransformerStandardised):
         namespace = Namespace(get_namespace(instance))  # type: ignore[arg-type]
         entity_type = namespace[self.entity_type]
         new_entity = namespace[f"{self.entity_type}_{quote(value)!s}"]
-        row_output.add_triples.append((new_entity, RDF.type, entity_type))
+        row_output.add_triples.add((new_entity, RDF.type, entity_type))
         row_output.instances_added_count += 1  # we add one new entity
 
         if self.new_property is not None:
-            row_output.add_triples.append((new_entity, namespace[self.new_property], rdflib.Literal(value)))  # type: ignore[arg-type]
+            row_output.add_triples.add((new_entity, namespace[self.new_property], rdflib.Literal(value)))  # type: ignore[arg-type]
             row_output.instances_modified_count += 1  # we modify the new entity
 
-        row_output.add_triples.append((instance, self.subject_predicate, new_entity))  # type: ignore[arg-type]
-        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.add_triples.add((instance, self.subject_predicate, new_entity))  # type: ignore[arg-type]
+        row_output.remove_triples.add((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
         row_output.instances_modified_count += 1  # we modify the old entity
 
         return row_output
@@ -300,8 +300,66 @@ class ConnectionToLiteral(BaseTransformerStandardised):
         instance, object_entity = cast(tuple[URIRef, URIRef], query_result_row)
         value = remove_namespace_from_uri(object_entity)
 
-        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(value)))
-        row_output.remove_triples.append((instance, self.subject_predicate, object_entity))
+        row_output.add_triples.add((instance, self.subject_predicate, rdflib.Literal(value)))
+        row_output.remove_triples.add((instance, self.subject_predicate, object_entity))
+        row_output.instances_modified_count += 1
+
+        return row_output
+
+
+class SetType(BaseTransformerStandardised):
+    description = "Set the type of an instance based on a property"
+
+    def __init__(
+        self,
+        subject_type: URIRef,
+        subject_predicate: URIRef,
+        drop_property: bool = False,
+        namespace: Namespace | None = None,
+    ) -> None:
+        self.subject_type = subject_type
+        self.subject_predicate = subject_predicate
+        self.drop_property = drop_property
+        self._namespace = namespace or Namespace(get_namespace(subject_type))
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?object) AS ?objectCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isLiteral(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        query = """SELECT (COUNT(?object) AS ?objectCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isIRI(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _iterate_query(self) -> str:
+        query = """SELECT ?instance ?object
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isLiteral(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, object_literal = cast(tuple[URIRef, Literal], query_result_row)
+        if self.drop_property:
+            row_output.remove_triples.add((instance, self.subject_predicate, object_literal))
+
+        row_output.remove_triples.add((instance, RDF.type, self.subject_type))
+        new_type = self._namespace[quote(object_literal.toPython())]
+        row_output.add_triples.add((instance, RDF.type, new_type))
+        row_output.add_triples.add((new_type, RDFS.subClassOf, self.subject_type))
         row_output.instances_modified_count += 1
 
         return row_output

cognite/neat/_issues/errors/__init__.py

@@ -9,6 +9,7 @@ from ._external import (
     FileReadError,
     FileTypeUnexpectedError,
     NeatYamlError,
+    OxigraphStorageLockedError,
 )
 from ._general import NeatImportError, NeatTypeError, NeatValueError, RegexViolationError
 from ._properties import (
@@ -51,6 +52,7 @@ __all__ = [
     "NeatTypeError",
     "NeatValueError",
     "NeatYamlError",
+    "OxigraphStorageLockedError",
     "PropertyDefinitionDuplicatedError",
     "PropertyDefinitionError",
     "PropertyMappingDuplicatedError",

cognite/neat/_issues/errors/_external.py

@@ -23,6 +23,14 @@ class FileReadError(NeatError, RuntimeError):
     reason: str
 
 
+@dataclass(unsafe_hash=True)
+class OxigraphStorageLockedError(NeatError, RuntimeError):
+    """Oxigraph on-disk storage locked at the path {filepath}"""
+
+    fix = "Delete LOCK file in the {filepath} folder to unlock the storage or use another storage path"
+    filepath: Path
+
+
 @dataclass(unsafe_hash=True)
 class FileNotFoundNeatError(NeatError, FileNotFoundError):
     """File {filepath} not found"""

cognite/neat/_issues/errors/_resources.py

@@ -30,7 +30,7 @@ class ResourceRetrievalError(ResourceError[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} does not exist"""
+    """The {resource_type} with identifier '{identifier}' does not exist"""
 
     extra = " This is expected by {referred_type} {referred_by}."
 

cognite/neat/_issues/warnings/__init__.py

@@ -31,7 +31,6 @@ from ._properties import (
     PropertyDirectRelationLimitWarning,
     PropertyNotFoundWarning,
     PropertyOverwritingWarning,
-    PropertySkippedWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
 )
@@ -68,7 +67,6 @@ __all__ = [
     "PropertyDirectRelationLimitWarning",
     "PropertyNotFoundWarning",
     "PropertyOverwritingWarning",
-    "PropertySkippedWarning",
     "PropertyTypeNotSupportedWarning",
     "PropertyValueTypeUndefinedWarning",
     "RegexViolationWarning",

cognite/neat/_issues/warnings/_models.py

@@ -74,7 +74,7 @@ class CDFNotSupportedWarning(NeatWarning, ABC):
 class NotSupportedViewContainerLimitWarning(CDFNotSupportedWarning):
     """The view {view_id} maps, {count} containers, which is more than the limit {limit}."""
 
-    fix = "Reduce the number of containers the view maps to." ""
+    fix = "Reduce the number of containers the view maps to."
 
     view_id: ViewId
     count: int

cognite/neat/_issues/warnings/_properties.py

@@ -65,14 +65,6 @@ class PropertyOverwritingWarning(PropertyWarning[T_Identifier]):
     overwriting: tuple[str, ...]
 
 
-@dataclass(unsafe_hash=True)
-class PropertySkippedWarning(PropertyWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} has a property {property_name}
-    which is skipped. {reason}."""
-
-    reason: str
-
-
 @dataclass(unsafe_hash=True)
 class PropertyDataTypeConversionWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} with identifier {identifier} failed to convert the property {property_name}: {error}"""

cognite/neat/_issues/warnings/_resources.py

@@ -21,7 +21,7 @@ class ResourceRegexViolationWarning(ResourceNeatWarning):
 
     fix = (
         "Either export the data model and make the necessary changes manually"
-        " or run prepare.data_model.cdf_compliant_external_ids."
+        " or run fix.data_model.cdf_compliant_external_ids."
     )
 
     location: str

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -96,13 +96,13 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
 def _add_index_identifiers(workbook: Workbook, sheet: str, no_rows: int):
     """Adds index-based auto identifier to a sheet identifier column"""
     for i in range(no_rows):
-        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{i+1}")'
+        workbook[sheet][f"A{i + 2}"] = f'=IF(ISBLANK(B{i + 2}), "","{sheet}-{i + 1}")'
 
 
 def _add_uuid_identifiers(workbook: Workbook, sheet: str, no_rows: int):
     """Adds UUID-based auto identifier to a sheet identifier column"""
     for i in range(no_rows):
-        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{uuid.uuid4()}")'
+        workbook[sheet][f"A{i + 2}"] = f'=IF(ISBLANK(B{i + 2}), "","{sheet}-{uuid.uuid4()}")'
 
 
 def _add_drop_down_list(
@@ -122,7 +122,7 @@ def _add_drop_down_list(
     workbook[sheet].add_data_validation(drop_down_list)
 
     for i in range(no_rows):
-        drop_down_list.add(workbook[sheet][f"{column}{i+2}"])
+        drop_down_list.add(workbook[sheet][f"{column}{i + 2}"])
 
 
 def _adjust_column_width(workbook: Workbook):

cognite/neat/_rules/exporters/_rules2yaml.py

@@ -72,7 +72,7 @@ class YAMLExporter(BaseExporter[VerifiedRules, str]):
         """
         # model_dump_json ensures that the output is in JSON format,
         # if we don't do this, we will get Enums and other types that are not serializable to YAML
-        json_output = rules.dump(mode="json", exclude_none=True, exclude_unset=True)
+        json_output = rules.dump(mode="json", sort=True, exclude_none=True, exclude_unset=True)
         if self.output == "json":
             return json.dumps(json_output)
         elif self.output == "yaml":

cognite/neat/_rules/importers/__init__.py

@@ -1,7 +1,7 @@
 from ._base import BaseImporter
 from ._dms2rules import DMSImporter
 from ._dtdl2rules import DTDLImporter
-from ._rdf import IMFImporter, InferenceImporter, OWLImporter
+from ._rdf import IMFImporter, InferenceImporter, OWLImporter, SubclassInferenceImporter
 from ._spreadsheet2rules import ExcelImporter, GoogleSheetImporter
 from ._yaml2rules import YAMLImporter
 
@@ -14,6 +14,7 @@ __all__ = [
     "IMFImporter",
     "InferenceImporter",
     "OWLImporter",
+    "SubclassInferenceImporter",
     "YAMLImporter",
 ]
 
@@ -26,6 +27,7 @@ RulesImporters = (
     | DTDLImporter
     | YAMLImporter
     | InferenceImporter
+    | SubclassInferenceImporter
 )
 
 

cognite/neat/_rules/importers/_dtdl2rules/spec.py

@@ -302,8 +302,7 @@ class Interface(DTDLBase):
     spec_version = frozenset(["2", "3"])
     default_context: ClassVar[IRI] = Field(
         "dtmi:dtdl:context;3",
-        description="This can be set directly on the class to change the "
-        "default context used when parsing a document.",
+        description="This can be set directly on the class to change the default context used when parsing a document.",
     )
     id_: DTMI = Field(alias="@id")  # type: ignore[assignment]
     context: IRI | None = Field(alias="@context")

cognite/neat/_rules/importers/_rdf/__init__.py

@@ -1,5 +1,5 @@
 from ._imf2rules import IMFImporter
-from ._inference2rules import InferenceImporter
+from ._inference2rules import InferenceImporter, SubclassInferenceImporter
 from ._owl2rules import OWLImporter
 
-__all__ = ["IMFImporter", "InferenceImporter", "OWLImporter"]
+__all__ = ["IMFImporter", "InferenceImporter", "OWLImporter", "SubclassInferenceImporter"]

cognite/neat/_rules/importers/_rdf/_base.py

@@ -72,7 +72,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
     ):
         return cls(
             IssueList(title=f"{cls.__name__} issues"),
-            store.graph,
+            store.dataset,
             data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
@@ -140,7 +140,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             prefixes: Dict of prefixes and namespaces
         """
         if Namespace(get_namespace(URI)) not in prefixes.values():
-            prefixes[f"prefix_{len(prefixes)+1}"] = Namespace(get_namespace(URI))
+            prefixes[f"prefix_{len(prefixes) + 1}"] = Namespace(get_namespace(URI))
 
     @property
     def _metadata(self) -> dict: