cognite-neat 0.123.33__py3-none-any.whl → 0.123.34__py3-none-any.whl

cognite/neat/__init__.py

@@ -1,6 +1,6 @@
-from cognite.neat.core._utils.auth import get_cognite_client
+from cognite.neat.v0.core._utils.auth import get_cognite_client
+from cognite.neat.v0.session import NeatSession
 
 from ._version import __version__
-from .session import NeatSession
 
 __all__ = ["NeatSession", "__version__", "get_cognite_client"]

cognite/neat/_data_model/_constants.py

@@ -0,0 +1,3 @@
+from ._identifiers import NameSpace
+
+XML_SCHEMA_NAMESPACE = NameSpace("http://www.w3.org/2001/XMLSchema#")

cognite/neat/_data_model/_identifiers.py

@@ -0,0 +1,61 @@
+from pydantic import HttpUrl, RootModel, ValidationError
+
+from cognite.neat.v0.core._utils.auxiliary import local_import
+
+
+class URI(RootModel[str]):
+    def __init__(self, value: str):
+        try:
+            # Use Pydantic's AnyUrl to validate the URI
+            _ = HttpUrl(value)
+        except ValidationError as e:
+            raise ValueError(f"Invalid URI: {value}") from e
+        super().__init__(value)
+
+    def __str__(self) -> str:
+        return self.root
+
+    def __repr__(self) -> str:
+        return f"URI({self.root!r})"
+
+    def as_rdflib_uriref(self):  # type: ignore[no-untyped-def]
+        # rdflib is an optional dependency, so import here
+        local_import("rdflib", "rdflib")
+        from rdflib import URIRef
+
+        return URIRef(self.root)
+
+
+class NameSpace(RootModel[str]):
+    def __init__(self, value: str):
+        try:
+            # Use Pydantic's AnyUrl to validate the URI
+            _ = HttpUrl(value)
+        except ValidationError as e:
+            raise ValueError(f"Invalid Namespace: {value}") from e
+        super().__init__(value)
+
+    def __str__(self) -> str:
+        return self.root
+
+    def __repr__(self) -> str:
+        return f"NameSpace({self.root!r})"
+
+    def term(self, name: str) -> URI:
+        # need to handle slices explicitly because of __getitem__ override
+        return URI(self.root + (name if isinstance(name, str) else ""))
+
+    def __getitem__(self, key: str) -> URI:  # type: ignore[override]
+        return self.term(key)
+
+    def __getattr__(self, name: str) -> URI:
+        if name.startswith("__"):  # ignore any special Python names!
+            raise AttributeError
+        return self.term(name)
+
+    def as_rdflib_namespace(self):  # type: ignore[no-untyped-def]
+        # rdflib is an optional dependency, so import here
+        local_import("rdflib", "rdflib")
+        from rdflib import Namespace
+
+        return Namespace(self.root)

cognite/neat/_data_model/models/dms/_space.py

@@ -2,7 +2,7 @@ from abc import ABC
 
 from pydantic import Field, field_validator
 
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat.v0.core._utils.text import humanize_collection
 
 from ._base import WriteableResource
 from ._constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN

cognite/neat/_data_model/models/entities/__init__.py

@@ -0,0 +1,46 @@
+from ._constants import Undefined, Unknown
+from ._data_types import (
+    AnyURI,
+    Boolean,
+    DataType,
+    Date,
+    DateTime,
+    DateTimeStamp,
+    Double,
+    Enum,
+    File,
+    Float,
+    Integer,
+    Json,
+    Long,
+    Sequence,
+    String,
+    Timeseries,
+)
+from ._identifiers import URI, NameSpace
+from ._parser import ParsedEntity, parse_entity
+
+__all__ = [
+    "URI",
+    "AnyURI",
+    "Boolean",
+    "DataType",
+    "Date",
+    "DateTime",
+    "DateTimeStamp",
+    "Double",
+    "Enum",
+    "File",
+    "Float",
+    "Integer",
+    "Json",
+    "Long",
+    "NameSpace",
+    "ParsedEntity",
+    "Sequence",
+    "String",
+    "Timeseries",
+    "Undefined",
+    "Unknown",
+    "parse_entity",
+]

cognite/neat/_data_model/models/entities/_base.py

@@ -0,0 +1,100 @@
+from functools import total_ordering
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator, model_serializer
+
+from ._constants import (
+    Undefined,
+    Unknown,
+    _UndefinedType,
+    _UnknownType,
+)
+
+
+@total_ordering
+class Entity(BaseModel, extra="ignore", populate_by_name=True):
+    """Entity is a concept, class, property, datatype in semantics sense."""
+
+    prefix: str | _UndefinedType = Field(
+        default=Undefined, pattern=r"^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$", min_length=1, max_length=43
+    )
+    suffix: str = Field(min_length=1, max_length=255, pattern=r"^[a-zA-Z0-9._~?@!$&'*+,;=%-]+$")
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
+
+    @field_validator("*", mode="before")
+    def strip_string(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return value.strip()
+        elif isinstance(value, list):
+            return [entry.strip() if isinstance(entry, str) else entry for entry in value]
+        return value
+
+    def as_tuple(self) -> tuple[str, ...]:
+        # We haver overwritten the serialization to str, so we need to do it manually
+        extra: tuple[str, ...] = tuple(
+            [
+                str(v or "")
+                for field_name in self.model_fields.keys()
+                if (v := getattr(self, field_name)) and field_name not in {"prefix", "suffix"}
+            ]
+        )
+        if isinstance(self.prefix, _UndefinedType):
+            return str(self.suffix), *extra
+        else:
+            return self.prefix, str(self.suffix), *extra
+
+    def __lt__(self, other: object) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return self.as_tuple() < other.as_tuple()  # type: ignore[attr-defined]
+
+    def __eq__(self, other: object) -> bool:
+        # We need to be explicit that we are not allowing comparison between different types
+        if type(other) is not type(self):
+            # requires explicit raising as NotImplemented would lead to running comparison
+            raise TypeError(f"'==' not supported between instances of {type(self).__name__} and {type(other).__name__}")
+        return self.as_tuple() == other.as_tuple()  # type: ignore[attr-defined]
+
+    def __hash__(self) -> int:
+        return hash(f"{type(self).__name__}({self})")
+
+    def __str__(self) -> str:
+        # there are three cases for string representation:
+        # 1. only suffix is present -> return str(suffix)
+        # 2. prefix and suffix are present -> return "prefix:suffix"
+        # 3. prefix, suffix and other fields are present -> return "prefix:suffix(field1=value1,field2=value2)"
+
+        model_dump = {k: v for k in self.model_fields if (v := getattr(self, k)) is not None}
+
+        base_str = f"{self.prefix}:{self.suffix}" if not isinstance(self.prefix, _UndefinedType) else str(self.suffix)
+
+        extra_fields = {
+            (self.model_fields[k].alias or k): v for k, v in model_dump.items() if k not in {"prefix", "suffix"}
+        }
+        if extra_fields:
+            extra_str = ",".join([f"{k}={v}" for k, v in extra_fields.items()])
+            return f"{base_str}({extra_str})"
+        else:
+            return base_str
+
+    def __repr__(self) -> str:
+        # We have overwritten the serialization to str, so we need to do it manually
+        model_dump = {k: v for k in self.model_fields if (v := getattr(self, k)) is not None}
+        args = ",".join([f"{k}={v!r}" for k, v in model_dump.items()])
+        return f"{type(self).__name__}({args})"
+
+
+class ConceptEntity(Entity):
+    version: str | None = None
+
+
+class UnknownEntity(ConceptEntity):
+    prefix: _UndefinedType = Undefined
+    suffix: _UnknownType = Unknown  # type: ignore[assignment]
+
+    @property
+    def id(self) -> str:
+        return str(Unknown)

cognite/neat/_data_model/models/entities/_data_types.py

@@ -0,0 +1,144 @@
+from datetime import date, datetime
+
+from pydantic import Field
+
+from cognite.neat._data_model._constants import XML_SCHEMA_NAMESPACE
+from cognite.neat._data_model._identifiers import URI
+
+from ._base import Entity
+
+
+class UnitEntity(Entity): ...
+
+
+class EnumCollectionEntity(Entity): ...
+
+
+class DataType(Entity):
+    prefix: str = Field("xsd", frozen=True)
+
+    @property
+    def python(self) -> type:
+        raise NotImplementedError()
+
+    @property
+    def xsd(self) -> URI:
+        return XML_SCHEMA_NAMESPACE[self.suffix]
+
+
+class Boolean(DataType):
+    suffix: str = Field("boolean", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return bool
+
+
+class Float(DataType):
+    suffix: str = Field("float", frozen=True)
+    unit: UnitEntity | None = None
+
+    @property
+    def python(self) -> type:
+        return float
+
+
+class Double(DataType):
+    suffix: str = Field("double", frozen=True)
+    unit: UnitEntity | None = None
+
+    @property
+    def python(self) -> type:
+        return float
+
+
+class Integer(DataType):
+    suffix: str = Field("integer", frozen=True)
+    unit: UnitEntity | None = None
+
+    @property
+    def python(self) -> type:
+        return int
+
+
+class Long(DataType):
+    suffix: str = Field("long", frozen=True)
+    unit: UnitEntity | None = None
+
+    @property
+    def python(self) -> type:
+        return int
+
+
+class String(DataType):
+    suffix: str = Field("string", frozen=True)
+    max_text_size: int | None = Field(
+        None,
+        alias="maxTextSize",
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
+
+    @property
+    def python(self) -> type:
+        return str
+
+
+class AnyURI(DataType):
+    suffix: str = Field("anyURI", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return str
+
+
+class Date(DataType):
+    suffix: str = Field("date", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return date
+
+
+class DateTime(DataType):
+    suffix: str = Field("dateTime", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return datetime
+
+
+class DateTimeStamp(DataType):
+    suffix: str = Field("dateTimeStamp", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return datetime
+
+
+# CDF Specific extensions of XSD types
+
+
+class Timeseries(DataType):
+    suffix: str = Field("timeseries", frozen=True)
+
+
+class File(DataType):
+    suffix: str = Field("string", frozen=True)
+
+
+class Sequence(DataType):
+    suffix: str = Field("sequence", frozen=True)
+
+
+class Json(DataType):
+    suffix: str = Field("json", frozen=True)
+
+    @property
+    def python(self) -> type:
+        return dict
+
+
+class Enum(DataType):
+    suffix: str = Field("enum", frozen=True)
+    collection: EnumCollectionEntity
+    unknown_value: str | None = Field(None, alias="unknownValue")

cognite/neat/{data_model → _data_model}/models/entities/_identifiers.py

@@ -1,6 +1,6 @@
 from pydantic import HttpUrl, RootModel, ValidationError
 
-from cognite.neat.core._utils.auxiliary import local_import
+from cognite.neat.v0.core._utils.auxiliary import local_import
 
 
 class URI(RootModel[str]):

cognite/neat/_data_model/models/entities/_parser.py

@@ -0,0 +1,194 @@
+from dataclasses import dataclass
+
+SPECIAL_CHARACTERS = ":()=,"
+
+
+@dataclass
+class ParsedEntity:
+    """Represents a parsed entity string."""
+
+    prefix: str
+    suffix: str
+    properties: dict[str, str]
+
+
+class _EntityParser:
+    """A parser for entity strings in the format 'prefix:suffix(prop1=val1,prop2=val2)'."""
+
+    def __init__(self, entity_string: str):
+        """Initialize the parser with the entity string to parse.
+
+        Args:
+            entity_string: The entity string to parse.
+        """
+        self.entity_string = entity_string.strip() if entity_string else ""
+        self.pos = 0
+        self.length = len(self.entity_string)
+
+    def peek(self) -> str:
+        """Peek at current character without advancing position."""
+        if self.pos >= self.length:
+            return ""
+        return self.entity_string[self.pos]
+
+    def advance(self) -> str:
+        """Get current character and advance position."""
+        if self.pos >= self.length:
+            return ""
+        char = self.entity_string[self.pos]
+        self.pos += 1
+        return char
+
+    def skip_whitespace(self) -> None:
+        """Skip whitespace characters."""
+        while self.pos < self.length and self.entity_string[self.pos].isspace():
+            self.pos += 1
+
+    def parse_identifier(self) -> str:
+        """Parse an identifier (letters, numbers, underscores, etc.)."""
+        start = self.pos
+        while self.pos < self.length and self.entity_string[self.pos] not in SPECIAL_CHARACTERS:
+            self.pos += 1
+        return self.entity_string[start : self.pos].strip()
+
+    def parse_property_value(self) -> str:
+        """Parse a property value, handling nested parentheses."""
+        start = self.pos
+        paren_depth = 0
+
+        while self.pos < self.length:
+            char = self.entity_string[self.pos]
+            if char == "(":
+                paren_depth += 1
+            elif char == ")":
+                if paren_depth == 0:
+                    # This is the closing paren of the properties section
+                    break
+                paren_depth -= 1
+            elif char == "," and paren_depth == 0:
+                # This is a property separator, not part of the value
+                break
+            self.pos += 1
+
+        return self.entity_string[start : self.pos].strip()
+
+    def parse_properties(self) -> dict[str, str]:
+        """Parse properties within parentheses."""
+        properties = {}
+
+        # Skip opening parenthesis
+        if self.peek() == "(":
+            self.advance()
+        else:
+            raise ValueError("expected `(`")
+
+        self.skip_whitespace()
+
+        while self.pos < self.length and self.peek() != ")":
+            # Parse property name
+            self.skip_whitespace()
+            if self.peek() == ")":
+                break
+
+            prop_name = self.parse_identifier()
+            if not prop_name:
+                raise ValueError(f"Expected property name at position {self.pos}. Got {self.peek()!r}")
+            self.skip_whitespace()
+
+            # Expect '='
+            if self.peek() != "=":
+                raise ValueError(
+                    f"Expected '=' after property name '{prop_name}' at position {self.pos}. Got {self.peek()!r}"
+                )
+            self.advance()  # consume '='
+
+            self.skip_whitespace()
+
+            # Parse property value (handles complex values)
+            prop_value = self.parse_property_value()
+
+            properties[prop_name] = prop_value
+
+            self.skip_whitespace()
+
+            # Check for comma or end
+            if self.peek() == ",":
+                self.advance()  # consume ','
+
+        # Check if we reached the end without finding a closing parenthesis
+        if self.pos >= self.length:
+            raise ValueError(f"Expected ')' to close properties at position {self.length}")
+
+        # Skip closing parenthesis
+        if self.peek() == ")":
+            self.advance()
+
+        return properties
+
+    def parse(self) -> ParsedEntity:
+        """Parse the entity string and return prefix, suffix, and properties.
+
+        Returns:
+            A `ParsedEntity` object containing the parsed components of the entity string.
+        """
+        if not self.entity_string:
+            return ParsedEntity(prefix="", suffix="", properties={})
+        if self.entity_string.strip() == ":":
+            raise ValueError("Expected identifier at position 0")
+
+        # Parse the main identifier (could be prefix:suffix or just suffix)
+        main_id = self.parse_identifier()
+
+        # Check if there's a colon (indicating prefix:suffix)
+        prefix = ""
+        suffix = ""
+
+        if self.peek() == ":":
+            self.advance()  # consume ':'
+            prefix = main_id
+            suffix = self.parse_identifier()
+            if not suffix:
+                raise ValueError(f"Expected identifier after ':' at position {self.pos}")
+        else:
+            suffix = main_id
+
+        # Check if there are properties
+        self.skip_whitespace()
+        properties = {}
+        if self.peek() == "(":
+            properties = self.parse_properties()
+
+        # Check for unexpected trailing characters
+        self.skip_whitespace()
+        if self.pos < self.length:
+            raise ValueError(f"Unexpected characters after properties at position {self.pos}. Got {self.peek()!r}")
+
+        return ParsedEntity(prefix, suffix, properties)
+
+
+def parse_entity(entity_string: str) -> ParsedEntity:
+    """Parse an entity string into its prefix, suffix, and properties.
+
+    Args:
+        entity_string (str): The entity string to parse. It can be in the format "prefix:suffix(prop1=val1,prop2=val2)"
+        or "suffix(prop1=val1,prop2=val2)" or just "suffix".
+
+    Returns:
+        A `ParsedEntity` object containing the parsed components of the entity string.
+
+
+    Raises:
+        ValueError: If the entity string is malformed.
+
+    This parser allows arbitrary characters in property values, including nested parentheses.
+    Reserved characters like '=', ',', '(', and ')' are used for parsing structure and cannot appear
+    unescaped in property names.
+
+    For example, it can parse:
+        - "asset:vehicle(type=car,details=(color=red,size=large))"
+        - "device(sensor(model=X100,features=(wifi,bluetooth)))"
+        - "location(city=New York,state=NY)"
+
+    """
+    parser = _EntityParser(entity_string)
+    return parser.parse()

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.33"
+__version__ = "0.123.34"
 __engine__ = "^2.0.4"

cognite/neat/{core → v0/core}/_client/_api/data_modeling_loaders.py

@@ -55,14 +55,14 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._client.data_classes.data_modeling import Component
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._issues.warnings import CDFMaxIterationsWarning
-from cognite.neat.core._shared import T_ID
-from cognite.neat.core._utils.tarjan import tarjan
+from cognite.neat.v0.core._client.data_classes.data_modeling import Component
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._issues.warnings import CDFMaxIterationsWarning
+from cognite.neat.v0.core._shared import T_ID
+from cognite.neat.v0.core._utils.tarjan import tarjan
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 

cognite/neat/{core → v0/core}/_client/_api/neat_instances.py

@@ -7,13 +7,13 @@ from cognite.client.data_classes.filters import Filter
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._constants import DMS_INSTANCE_LIMIT_MARGIN
-from cognite.neat.core._issues import NeatIssue
-from cognite.neat.core._issues.errors import WillExceedLimitError
-from cognite.neat.core._issues.warnings import NeatValueWarning
+from cognite.neat.v0.core._constants import DMS_INSTANCE_LIMIT_MARGIN
+from cognite.neat.v0.core._issues import NeatIssue
+from cognite.neat.v0.core._issues.errors import WillExceedLimitError
+from cognite.neat.v0.core._issues.warnings import NeatValueWarning
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 
 class NeatInstancesAPI:

cognite/neat/{core → v0/core}/_client/_api/schema.py

@@ -5,17 +5,17 @@ from typing import TYPE_CHECKING
 
 from cognite.client import data_modeling as dm
 
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat.v0.core._client.data_classes.data_modeling import (
     ContainerApplyDict,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import is_hierarchy_property
-from cognite.neat.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._constants import is_hierarchy_property
+from cognite.neat.v0.core._issues.errors import NeatValueError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._client._api_client import NeatClient
+    from cognite.neat.v0.core._client._api_client import NeatClient
 
 
 class SchemaAPI:

cognite/neat/{core → v0/core}/_client/_api/statistics.py

@@ -7,7 +7,7 @@ from cognite.client.config import ClientConfig
 from cognite.client.data_classes.data_modeling.ids import _load_space_identifier
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite.neat.core._client.data_classes.statistics import (
+from cognite.neat.v0.core._client.data_classes.statistics import (
     ProjectStatsAndLimits,
     SpaceInstanceCounts,
     SpaceInstanceCountsList,
@@ -34,7 +34,7 @@ class StatisticsAPI(APIClient):
         Examples:
             Fetch project statistics (and limits) and check the current number of data models vs.
             and how many more can be created:
-                >>> from cognite.neat.core._client import NeatClient
+                >>> from cognite.neat.v0.core._client import NeatClient
                 >>> client = NeatClient()
                 >>> stats = client.instance_statistics.project()
                 >>> num_dm = stats.data_models.current
@@ -64,7 +64,7 @@ class StatisticsAPI(APIClient):
 
         Examples:
             Fetch statistics for a single space:
-                >>> from cognite.neat.core._client import NeatClient
+                >>> from cognite.neat.v0.core._client import NeatClient
                 >>> client = NeatClient()
                 >>> res = client.instance_statistics.list("my-space")
             Fetch statistics for multiple spaces:

cognite/neat/{core → v0/core}/_client/_api_client.py

@@ -1,6 +1,6 @@
 from cognite.client import ClientConfig, CogniteClient
 
-from cognite.neat.core._utils.auth import _CLIENT_NAME
+from cognite.neat.v0.core._utils.auth import _CLIENT_NAME
 
 from ._api.data_modeling_loaders import DataModelLoaderAPI
 from ._api.neat_instances import NeatInstancesAPI