evo-objects 0.4.2__tar.gz → 0.6.1__tar.gz

{evo_objects-0.4.2 → evo_objects-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo-objects
-Version: 0.4.2
+Version: 0.6.1
 Summary: Python SDK for using the Seequent Evo Geoscience Object API
 Project-URL: Source, https://github.com/SeequentEvo/evo-python-sdk
 Project-URL: Tracker, https://github.com/SeequentEvo/evo-python-sdk/issues
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://developer.seequent.com/
 Author-email: Seequent <support@seequent.com>
 License-File: LICENSE.md
 Requires-Python: >=3.10
-Requires-Dist: evo-sdk-common[jmespath]>=0.5.8
+Requires-Dist: evo-sdk-common[jmespath]>=0.5.26
 Requires-Dist: pydantic<3,>=2
 Provides-Extra: aiohttp
 Requires-Dist: evo-sdk-common[aiohttp]; extra == 'aiohttp'

{evo_objects-0.4.2 → evo_objects-0.6.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "evo-objects"
 description = "Python SDK for using the Seequent Evo Geoscience Object API"
-version = "0.4.2"
+version = "0.6.1"
 requires-python = ">=3.10"
 license-files = ["LICENSE.md"]
 dynamic = ["readme"]
@@ -10,7 +10,7 @@ authors = [
 ]
 
 dependencies = [
-    "evo-sdk-common[jmespath]>=0.5.8",
+    "evo-sdk-common[jmespath]>=0.5.26",
     "pydantic>=2,<3",
 ]
 

{evo_objects-0.4.2 → evo_objects-0.6.1}/src/evo/objects/typed/__init__.py

@@ -1,4 +1,4 @@
-#  Copyright © 2025 Bentley Systems, Incorporated
+#  Copyright © 2026 Bentley Systems, Incorporated
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
 #  You may obtain a copy of the License at
@@ -22,6 +22,8 @@ from .base import BaseObject, object_from_path, object_from_reference, object_fr
 from .block_model_ref import (
     BlockModel,
 )
+from .downhole_collection import DownholeCollection, DownholeCollectionData
+from .downhole_intervals import DownholeIntervals, DownholeIntervalsData
 from .pointset import (
     Locations,
     PointSet,
@@ -80,6 +82,10 @@ __all__ = [
     "BoundingBox",
     "CoordinateReferenceSystem",
     "CubicStructure",
+    "DownholeCollection",
+    "DownholeCollectionData",
+    "DownholeIntervals",
+    "DownholeIntervalsData",
     "Ellipsoid",
     "EllipsoidRanges",
     "EpsgCode",

{evo_objects-0.4.2 → evo_objects-0.6.1}/src/evo/objects/typed/_data.py

@@ -1,3 +1,14 @@
+#  Copyright © 2026 Bentley Systems, Incorporated
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
 from __future__ import annotations
 
 from typing import Annotated, Any, ClassVar
@@ -111,7 +122,7 @@ class DataTableAndAttributes(SchemaModel):
         if attr_df is not None:
             await self.attributes.set_attributes(attr_df, fb=fb)
         else:
-            await self.attributes.clear()
+            self.attributes.clear()
 
     def validate(self) -> None:
         """Validate that all attributes have the correct length."""
@@ -143,4 +154,6 @@ class DataTableAndAttributes(SchemaModel):
         builder = SchemaBuilder(cls, context)
         await builder.set_sub_model_value("_table", table_df)
         await builder.set_sub_model_value("attributes", attr_df)
-        return builder.document
+
+        # As we specially handle the _table and attributes sub-models above, we skip them in the default data processing of build_from_data.
+        return await builder.build_from_data(data, skip_sub_models={"_table", "attributes"})

evo_objects-0.6.1/src/evo/objects/typed/_downhole.py

@@ -0,0 +1,62 @@
+#  Copyright © 2026 Bentley Systems, Incorporated
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""Shared sub-models for downhole typed objects."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, ClassVar
+
+import pandas as pd
+
+from evo.common.interfaces import IContext
+from evo.objects.utils.table_formats import FLOAT_ARRAY_2, KnownTableFormat
+
+from ._data import DataTable
+from ._model import DataLocation, SchemaLocation, SchemaModel
+from .attributes import Category
+
+_HOLE_ID_COL = "hole_id"
+_FROM_COL = "from"
+_TO_COL = "to"
+_DEPTH_COLS: list[str] = [_FROM_COL, _TO_COL]
+
+
+class HoleIdCategory(Category):
+    """Categorical hole identifier column, shared by downhole typed objects."""
+
+    @classmethod
+    async def _data_to_schema(cls, data: pd.DataFrame, context: IContext) -> Any:
+        category_table = data[[_HOLE_ID_COL]].astype("category")
+        return await super()._data_to_schema(category_table, context=context)
+
+
+class DepthIntervalsTable(DataTable):
+    table_format: ClassVar[KnownTableFormat] = FLOAT_ARRAY_2
+    data_columns: ClassVar[list[str]] = _DEPTH_COLS
+
+    @classmethod
+    async def _data_to_schema(cls, data: pd.DataFrame, context: IContext) -> Any:
+        return await super()._data_to_schema(data[_DEPTH_COLS], context)
+
+
+class FromToModel(SchemaModel):
+    """Schema model for the `from_to` component of a downhole intervals object."""
+
+    intervals: Annotated[DepthIntervalsTable, SchemaLocation("intervals.start_and_end"), DataLocation("intervals")]
+    unit: Annotated[str | None, SchemaLocation("unit"), DataLocation("depth_unit")]
+
+    @classmethod
+    async def _data_to_schema(cls, data: Any, context: IContext) -> Any:
+        result = await super()._data_to_schema(data, context)
+        if data.depth_unit is not None:
+            result["unit"] = data.depth_unit
+        return result

{evo_objects-0.4.2 → evo_objects-0.6.1}/src/evo/objects/typed/_model.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import copy
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import Annotated, Any, Callable, Generic, TypeVar, get_args, get_origin, get_type_hints, overload
+from typing import Annotated, Any, Callable, ClassVar, Generic, TypeVar, get_args, get_origin, get_type_hints, overload
 
 from pydantic import TypeAdapter
 
@@ -86,11 +86,8 @@ class SubModelMetadata:
     """The field name in the data class for this sub-model."""
 
 
-class SchemaProperty(Generic[_T]):
-    """Descriptor for data within a Geoscience Object schema.
-
-    This can be used on either typed objects classes or dataset classes.
-    """
+class BaseSchemaProperty(Generic[_T]):
+    """Base descriptor for reading data from a Geoscience Object schema."""
 
     def __init__(
         self,
@@ -111,7 +108,7 @@ class SchemaProperty(Generic[_T]):
         return self._type_adapter.dump_python(value)
 
     @overload
-    def __get__(self, instance: None, owner: type[SchemaModel]) -> SchemaProperty[_T]: ...
+    def __get__(self, instance: None, owner: type[SchemaModel]) -> BaseSchemaProperty[_T]: ...
 
     @overload
     def __get__(self, instance: SchemaModel, owner: type[SchemaModel]) -> _T: ...
@@ -128,6 +125,13 @@ class SchemaProperty(Generic[_T]):
         # Use TypeAdapter to validate and apply defaults from Field annotations
         return self._type_adapter.validate_python(value)
 
+
+class SchemaProperty(BaseSchemaProperty[_T]):
+    """Descriptor for mutable data within a Geoscience Object schema.
+
+    This can be used on either typed objects classes or dataset classes.
+    """
+
     def __set__(self, instance: SchemaModel, value: Any) -> None:
         _set_property_value(self, instance._document, value)
 
@@ -140,7 +144,19 @@ class SchemaProperty(Generic[_T]):
         _set_property_value(self, document, value)
 
 
-def _set_property_value(schema_property: SchemaProperty, document: dict[str, Any], value: Any) -> None:
+class SchemaConstantProperty(BaseSchemaProperty[_T]):
+    """A SchemaProperty that always writes a fixed value to the schema."""
+
+    def __init__(self, jmespath_expr: str, type_adapter: TypeAdapter[_T], value: _T) -> None:
+        super().__init__(jmespath_expr=jmespath_expr, type_adapter=type_adapter)
+        self._value = value
+
+    @property
+    def value(self) -> _T:
+        return self._value
+
+
+def _set_property_value(schema_property: BaseSchemaProperty, document: dict[str, Any], value: Any) -> None:
     """Set the value of a SchemaProperty by name.
 
     :param property_name: The name of the property to set.
@@ -177,6 +193,26 @@ class SchemaBuilder:
         else:
             self.document.update(sub_document)
 
+    async def build_from_data(self, data: Any, skip_sub_models: set[str] | None = None) -> dict[str, Any]:
+        """Build the schema document by applying all properties and sub-models."""
+        for key, prop in self._properties.items():
+            if isinstance(prop, SchemaConstantProperty):
+                self.set_property(key, prop.value)
+            else:
+                value = getattr(data, key, None)
+                self.set_property(key, value)
+
+        for name, metadata in self._sub_models.items():
+            if skip_sub_models and name in skip_sub_models:
+                continue
+            if metadata.data_field:
+                sub_data = getattr(data, metadata.data_field, None)
+            else:
+                sub_data = data
+            await self.set_sub_model_value(name, sub_data)
+
+        return self.document
+
 
 def _get_base_type(annotation: Any) -> tuple[Any, SchemaLocation | None, DataLocation | None]:
     """Extract the base type and SchemaLocation from an annotation.
@@ -208,14 +244,14 @@ class SchemaModel:
     automatically created for nested SchemaModel/SchemaList fields.
     """
 
-    _schema_properties: dict[str, SchemaProperty[Any]] = {}
+    _schema_properties: dict[str, BaseSchemaProperty[Any]] = {}
     _sub_models: dict[str, SubModelMetadata] = {}
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
         # Initialize with inherited values (copy to avoid mutating parent)
-        schema_properties: dict[str, SchemaProperty[Any]] = {}
+        schema_properties: dict[str, BaseSchemaProperty[Any]] = {}
         sub_models: dict[str, SubModelMetadata] = {}
         for base in cls.__mro__[1:]:
             if issubclass(base, SchemaModel):
@@ -232,8 +268,28 @@ class SchemaModel:
             cls._sub_models = sub_models
             return
 
-        # Process the resolved annotations
+        # Process the resolved annotations, to produce the final set of schema properties and sub-models for this class
         for field_name, annotation in hints.items():
+            # Handle ClassVar fields
+            if get_origin(annotation) is ClassVar:
+                inner_args = get_args(annotation)
+                inner_type = inner_args[0]
+                base_type, schema_location, _ = _get_base_type(inner_type)
+                # Skip class variables without a SchemaLocation, e.g. data_columns: ClassVar[list[str]] = [],
+                if schema_location is None:
+                    continue
+
+                # Treat such remaining ClassVar fields as constants, which also have a corresponding value in the schema
+                type_adapter = TypeAdapter(base_type)
+                prop = SchemaConstantProperty(
+                    jmespath_expr=schema_location.jmespath_expr,
+                    type_adapter=type_adapter,
+                    value=getattr(cls, field_name),
+                )
+                setattr(cls, field_name, prop)
+                schema_properties[field_name] = prop
+                continue
+
             base_type, schema_location, data_location = _get_base_type(annotation)
 
             # Skip fields without a SchemaLocation
@@ -348,16 +404,7 @@ class SchemaModel:
         :return: The dictionary representation of the data.
         """
         builder = SchemaBuilder(cls, context)
-        for key in cls._schema_properties.keys():
-            value = getattr(data, key, None)
-            builder.set_property(key, value)
-        for name, metadata in cls._sub_models.items():
-            if metadata.data_field:
-                sub_data = getattr(data, metadata.data_field, None)
-            else:
-                sub_data = data
-            await builder.set_sub_model_value(name, sub_data)
-        return builder.document
+        return await builder.build_from_data(data)
 
     def search(self, expression: str) -> Any:
         """Search the model using a JMESPath expression.

{evo_objects-0.4.2 → evo_objects-0.6.1}/src/evo/objects/typed/attributes.py

@@ -1,4 +1,4 @@
-#  Copyright © 2025 Bentley Systems, Incorporated
+#  Copyright © 2026 Bentley Systems, Incorporated
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
 #  You may obtain a copy of the License at
@@ -11,7 +11,9 @@
 
 from __future__ import annotations
 
+import typing
 import uuid
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Annotated, Any
 from uuid import UUID
 
@@ -23,6 +25,7 @@ from evo.common.utils import NoFeedback, iter_with_fb
 from evo.objects import DownloadedObject
 from evo.objects.utils.table_formats import (
     BOOL_ARRAY_1,
+    DATE_TIME_ARRAY,
     FLOAT_ARRAY_1,
     INTEGER_ARRAY_1_INT32,
     INTEGER_ARRAY_1_INT64,
@@ -67,6 +70,8 @@ def _infer_attribute_type_from_series(series: pd.Series) -> str:
         return "category"
     elif pd.api.types.is_string_dtype(series):
         return "string"
+    elif pd.api.types.infer_dtype(series, skipna=True) in ["date", "datetime", "datetime64"]:
+        return "date_time"
     else:
         raise UnSupportedDataTypeError(f"Unsupported dtype for attribute: {series.dtype}")
 
@@ -76,9 +81,35 @@ _attribute_table_formats = {
     "integer": [INTEGER_ARRAY_1_INT32, INTEGER_ARRAY_1_INT64],
     "bool": [BOOL_ARRAY_1],
     "string": [STRING_ARRAY],
+    "date_time": [DATE_TIME_ARRAY],
 }
 
 
+@dataclass
+class AttributeDescription:
+    discipline: str = ""
+    type: str = ""
+    unit: str | None = None
+    scale: str | None = None
+    extensions: dict[str, typing.Any] | None = None
+    tags: dict[str, str] | None = None
+
+    def to_schema(self):
+        result = {
+            "discipline": self.discipline,
+            "type": self.type,
+        }
+        if self.unit:
+            result["unit"] = self.unit
+        if self.scale:
+            result["scale"] = self.scale
+        if self.extensions:
+            result["extensions"] = self.extensions
+        if self.tags:
+            result["tags"] = self.tags
+        return result
+
+
 class Attribute(SchemaModel):
     """A Geoscience Object Attribute"""
 
@@ -158,7 +189,7 @@ class Attribute(SchemaModel):
             table_formats = _attribute_table_formats.get(attribute_type)
             attr_doc["values"] = await data_client.upload_dataframe(df, table_format=table_formats, fb=fb)
 
-        if attribute_type in ["scalar", "integer", "category"]:
+        if attribute_type in ["scalar", "integer", "category", "date_time"]:
             attr_doc["nan_description"] = {"values": []}
 
 
@@ -203,7 +234,15 @@ class PendingAttribute:
 
 
 class Attributes(SchemaList[Attribute]):
-    """A collection of Geoscience Object Attributes"""
+    """A collection of Geoscience Object Attributes
+
+    The data source is a pandas DataFrame. If the DataFrame has attribute descriptions attached
+    to it, then they will be used to populate the schema's "attribute_description" fields. The
+    attribute descriptions are attached to the DataFrame's `attrs` attribute.
+
+    >>> df.attrs
+    {'attribute_description': {<column names>:  <AttributeDescription>}, ...}
+    """
 
     _schema_path: str | None = None
     """The full JMESPath to this attributes list within the parent object schema."""
@@ -263,7 +302,7 @@ class Attributes(SchemaList[Attribute]):
 
         for col in df.columns:
             series = df[col]
-            attribute_type = _infer_attribute_type_from_series(series)
+            attribute_type = _infer_attribute_type_from_series(df[col])
 
             attr_doc: dict[str, Any] = {
                 "name": str(col),
@@ -271,9 +310,19 @@ class Attributes(SchemaList[Attribute]):
                 "attribute_type": attribute_type,
             }
 
-            col_df = df[[col]]
+            if attribute_type == "date_time":
+                series = pd.to_datetime(series, utc=True).dt.as_unit("us")
+
+            col_df = pd.DataFrame({col: series})
             await Attribute._upload_attribute_values(attr_doc, col_df, attribute_type, data_client)
 
+            attr_desc: AttributeDescription | None = df.attrs.get("attribute_descriptions", {}).get(col)
+            if attr_desc is not None:
+                if not isinstance(attr_desc, AttributeDescription):
+                    raise TypeError("attribute description must be a AttributeDescription.")
+                if attr_desc.unit is not None:
+                    attr_doc["attribute_description"] = attr_desc.to_schema()
+
             attributes_list.append(attr_doc)
 
     async def to_dataframe(self, *keys: str, fb: IFeedback = NoFeedback) -> pd.DataFrame:
@@ -528,3 +577,27 @@ class BlockModelAttributes:
     def __repr__(self) -> str:
         names = [attr.name for attr in self._attributes]
         return f"BlockModelAttributes({names})"
+
+
+class Category(SchemaModel):
+    _data: Annotated[str, SchemaLocation("values.data")]
+    _length: Annotated[int, SchemaLocation("values.length")]
+
+    @property
+    def length(self):
+        return self._length
+
+    @classmethod
+    async def _data_to_schema(cls, category_table, context: IContext) -> Any:
+        data_client = get_data_client(context)
+        return await data_client.upload_category_dataframe(category_table)
+
+    async def to_dataframe(self, fb: IFeedback = NoFeedback) -> pd.DataFrame:
+        """Load a DataFrame containing values for this table.
+
+        :param fb: Optional feedback object to report download progress.
+        :return: The loaded DataFrame with values for this table.
+        """
+        if self._context.is_data_modified(self._data):
+            raise DataLoaderError("Data was modified since the object was downloaded")
+        return await self._obj.download_category_dataframe(self.as_dict(), fb=fb)

{evo_objects-0.4.2 → evo_objects-0.6.1}/src/evo/objects/typed/base.py

@@ -227,31 +227,8 @@ class _BaseObject(SchemaModel):
                 "sub_classification and creation_schema_version must be defined by the subclass"
             )
         schema_id = ObjectSchema("objects", cls.sub_classification, cls.creation_schema_version)
-        result: dict[str, Any] = {
-            "schema": str(schema_id),
-        }
-
-        # Handle schema properties
-        for key, prop in cls._schema_properties.items():
-            value = getattr(data, key, None)
-            if value is not None:
-                prop.apply_to(result, value)
-
-        # Handle annotation-based sub-models
-        for name, metadata in cls._sub_models.items():
-            if metadata.data_field:
-                sub_data = getattr(data, metadata.data_field, None)
-            else:
-                sub_data = data
-            if sub_data is not None:
-                from ._utils import assign_jmespath_value
-
-                sub_document = await metadata.model_type._data_to_schema(sub_data, context)
-                if metadata.jmespath_expr:
-                    assign_jmespath_value(result, metadata.jmespath_expr, sub_document)
-                else:
-                    result.update(sub_document)
-
+        result = await super()._data_to_schema(data, context)
+        result["schema"] = str(schema_id)
         return result
 
     @classmethod