tilebox-datasets 0.38.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

tilebox/datasets/aio/client.py

@@ -5,10 +5,10 @@ from _tilebox.grpc.aio.error import with_pythonic_errors
 from tilebox.datasets.aio.dataset import DatasetClient
 from tilebox.datasets.client import Client as BaseClient
 from tilebox.datasets.client import token_from_env
-from tilebox.datasets.datasetsv1.collections_pb2_grpc import CollectionServiceStub
-from tilebox.datasets.datasetsv1.data_access_pb2_grpc import DataAccessServiceStub
-from tilebox.datasets.datasetsv1.data_ingestion_pb2_grpc import DataIngestionServiceStub
-from tilebox.datasets.datasetsv1.datasets_pb2_grpc import DatasetServiceStub
+from tilebox.datasets.datasets.v1.collections_pb2_grpc import CollectionServiceStub
+from tilebox.datasets.datasets.v1.data_access_pb2_grpc import DataAccessServiceStub
+from tilebox.datasets.datasets.v1.data_ingestion_pb2_grpc import DataIngestionServiceStub
+from tilebox.datasets.datasets.v1.datasets_pb2_grpc import DatasetServiceStub
 from tilebox.datasets.group import Group
 from tilebox.datasets.service import TileboxDatasetService
 

tilebox/datasets/aio/dataset.py

@@ -11,18 +11,11 @@ from _tilebox.grpc.aio.pagination import Pagination as PaginationProtocol
 from _tilebox.grpc.aio.pagination import paginated_request
 from _tilebox.grpc.aio.producer_consumer import async_producer_consumer
 from _tilebox.grpc.error import ArgumentError, NotFoundError
-from tilebox.datasets.aio.pagination import (
-    with_progressbar,
-    with_time_progress_callback,
-    with_time_progressbar,
-)
+from tilebox.datasets.aio.pagination import with_progressbar, with_time_progress_callback, with_time_progressbar
 from tilebox.datasets.data.collection import CollectionInfo
 from tilebox.datasets.data.data_access import QueryFilters, SpatialFilter, SpatialFilterLike
-from tilebox.datasets.data.datapoint import DatapointInterval, DatapointIntervalLike, QueryResultPage
+from tilebox.datasets.data.datapoint import QueryResultPage
 from tilebox.datasets.data.datasets import Dataset
-from tilebox.datasets.data.pagination import Pagination
-from tilebox.datasets.data.time_interval import TimeInterval, TimeIntervalLike
-from tilebox.datasets.data.uuid import as_uuid
 from tilebox.datasets.message_pool import get_message_type
 from tilebox.datasets.progress import ProgressCallback
 from tilebox.datasets.protobuf_conversion.protobuf_xarray import MessageToXarrayConverter
@@ -33,7 +26,11 @@ from tilebox.datasets.protobuf_conversion.to_protobuf import (
     marshal_messages,
     to_messages,
 )
+from tilebox.datasets.query.id_interval import IDInterval, IDIntervalLike
+from tilebox.datasets.query.pagination import Pagination
+from tilebox.datasets.query.time_interval import TimeInterval, TimeIntervalLike
 from tilebox.datasets.service import TileboxDatasetService
+from tilebox.datasets.uuid import as_uuid
 
 # allow private member access: we allow it here because we want to make as much private as possible so that we can
 # minimize the publicly facing API (which allows us to change internals later, and also limits to auto-completion)
@@ -240,7 +237,7 @@ class CollectionClient:
 
     async def _find_interval(
         self,
-        datapoint_id_interval: DatapointIntervalLike,
+        datapoint_id_interval: IDIntervalLike,
         end_inclusive: bool = True,
         *,
         skip_data: bool = False,
@@ -259,9 +256,7 @@ class CollectionClient:
         Returns:
             The datapoints in the given interval as an xarray dataset
         """
-        filters = QueryFilters(
-            temporal_extent=DatapointInterval.parse(datapoint_id_interval, end_inclusive=end_inclusive)
-        )
+        filters = QueryFilters(temporal_extent=IDInterval.parse(datapoint_id_interval, end_inclusive=end_inclusive))
 
         async def request(page: PaginationProtocol) -> QueryResultPage:
             query_page = Pagination(page.limit, page.starting_after)

tilebox/datasets/aio/pagination.py

@@ -5,11 +5,9 @@ from typing import TypeVar
 
 from tqdm.auto import tqdm
 
-from tilebox.datasets.data import (
-    TimeInterval,
-)
 from tilebox.datasets.data.datapoint import QueryResultPage
 from tilebox.datasets.progress import ProgressCallback, TimeIntervalProgressBar
+from tilebox.datasets.query.time_interval import TimeInterval
 
 ResultPage = TypeVar("ResultPage", bound=QueryResultPage)
 

tilebox/datasets/client.py

@@ -8,10 +8,10 @@ from promise import Promise
 
 from _tilebox.grpc.channel import parse_channel_info
 from tilebox.datasets.data.datasets import Dataset, DatasetGroup, ListDatasetsResponse
-from tilebox.datasets.data.uuid import as_uuid
 from tilebox.datasets.group import Group
 from tilebox.datasets.message_pool import register_once
 from tilebox.datasets.service import TileboxDatasetService
+from tilebox.datasets.uuid import as_uuid
 
 
 class TimeseriesDatasetLike(Protocol):

tilebox/datasets/data/__init__.py

@@ -1,16 +1,28 @@
-from tilebox.datasets.data.time_interval import (
-    TimeInterval,
-    TimeIntervalLike,
-    datetime_to_timestamp,
-    timestamp_to_datetime,
-)
-from tilebox.datasets.data.uuid import uuid_message_to_uuid, uuid_to_uuid_message
+# for backwards compatibility, we can remove this hack in the future
 
-__all__ = [
-    "TimeInterval",
-    "TimeIntervalLike",
-    "datetime_to_timestamp",
-    "timestamp_to_datetime",
-    "uuid_message_to_uuid",
-    "uuid_to_uuid_message",
-]
+from warnings import warn
+
+from tilebox.datasets.query.time_interval import TimeInterval as _TimeInterval
+from tilebox.datasets.query.time_interval import TimeIntervalLike
+
+
+class TimeInterval(_TimeInterval):
+    def __post_init__(self) -> None:
+        warn(
+            "The TimeInterval class has been deprecated, import from tilebox.datasets.query instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__post_init__()
+
+    @classmethod
+    def parse(cls, arg: TimeIntervalLike) -> "_TimeInterval":
+        warn(
+            "The TimeInterval class has been deprecated, import from tilebox.datasets.query instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return super().parse(arg)
+
+
+__all__ = ["TimeInterval"]

tilebox/datasets/data/collection.py

@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 from uuid import UUID
 
-from tilebox.datasets.data.time_interval import TimeInterval
-from tilebox.datasets.data.uuid import uuid_message_to_uuid, uuid_to_uuid_message
-from tilebox.datasets.datasetsv1 import core_pb2
+from tilebox.datasets.datasets.v1 import core_pb2
+from tilebox.datasets.query.time_interval import TimeInterval
+from tilebox.datasets.uuid import uuid_message_to_uuid, uuid_to_uuid_message
 
 
 @dataclass

tilebox/datasets/data/data_access.py

@@ -7,9 +7,9 @@ from shapely import Geometry, from_wkb, to_wkb
 # from python 3.11 onwards this is available as typing.NotRequired:
 from typing_extensions import NotRequired
 
-from tilebox.datasets.data.datapoint import DatapointInterval
-from tilebox.datasets.data.time_interval import TimeInterval
-from tilebox.datasets.datasetsv1 import data_access_pb2, well_known_types_pb2
+from tilebox.datasets.datasets.v1 import data_access_pb2, well_known_types_pb2
+from tilebox.datasets.query.id_interval import IDInterval
+from tilebox.datasets.query.time_interval import TimeInterval
 
 
 class SpatialFilterMode(Enum):
@@ -104,16 +104,16 @@ class SpatialFilter:
 
 @dataclass(frozen=True)
 class QueryFilters:
-    temporal_extent: TimeInterval | DatapointInterval
+    temporal_extent: TimeInterval | IDInterval
     spatial_extent: SpatialFilter | None = None
 
     @classmethod
     def from_message(cls, filters: data_access_pb2.QueryFilters) -> "QueryFilters":
-        temporal_extent: TimeInterval | DatapointInterval | None = None
+        temporal_extent: TimeInterval | IDInterval | None = None
         if filters.HasField("time_interval"):
             temporal_extent = TimeInterval.from_message(filters.time_interval)
         if filters.HasField("datapoint_interval"):
-            temporal_extent = DatapointInterval.from_message(filters.datapoint_interval)
+            temporal_extent = IDInterval.from_message(filters.datapoint_interval)
 
         if temporal_extent is None:
             raise ValueError("Invalid filter: time or datapoint interval must be set")

tilebox/datasets/data/datapoint.py

@@ -1,81 +1,14 @@
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, TypeAlias
+from typing import Any
 from uuid import UUID
 
-from tilebox.datasets.data.pagination import Pagination
-from tilebox.datasets.data.time_interval import timestamp_to_datetime
-from tilebox.datasets.data.uuid import uuid_message_to_uuid, uuid_to_uuid_message
-from tilebox.datasets.datasetsv1 import core_pb2, data_access_pb2, data_ingestion_pb2
+from tilebox.datasets.datasets.v1 import core_pb2, data_access_pb2, data_ingestion_pb2
 from tilebox.datasets.message_pool import get_message_type
-
-DatapointIntervalLike: TypeAlias = "tuple[str, str] | tuple[UUID, UUID] | DatapointInterval"
-
-
-@dataclass(frozen=True)
-class DatapointInterval:
-    start_id: UUID
-    end_id: UUID
-    start_exclusive: bool
-    end_inclusive: bool
-
-    @classmethod
-    def from_message(cls, interval: core_pb2.DatapointInterval) -> "DatapointInterval":
-        return cls(
-            start_id=uuid_message_to_uuid(interval.start_id),
-            end_id=uuid_message_to_uuid(interval.end_id),
-            start_exclusive=interval.start_exclusive,
-            end_inclusive=interval.end_inclusive,
-        )
-
-    def to_message(self) -> core_pb2.DatapointInterval:
-        return core_pb2.DatapointInterval(
-            start_id=uuid_to_uuid_message(self.start_id),
-            end_id=uuid_to_uuid_message(self.end_id),
-            start_exclusive=self.start_exclusive,
-            end_inclusive=self.end_inclusive,
-        )
-
-    @classmethod
-    def parse(
-        cls, arg: DatapointIntervalLike, start_exclusive: bool = False, end_inclusive: bool = True
-    ) -> "DatapointInterval":
-        """
-        Convert a variety of input types to a DatapointInterval.
-
-        Supported input types:
-        - DatapointInterval: Return the input as is
-        - tuple of two UUIDs: Return an DatapointInterval with start and end id set to the given values
-        - tuple of two strings: Return an DatapointInterval with start and end id set to the UUIDs parsed from the given strings
-
-        Args:
-            arg: The input to convert
-            start_exclusive: Whether the start id is exclusive
-            end_inclusive: Whether the end id is inclusive
-
-        Returns:
-            DatapointInterval: The parsed ID interval
-        """
-
-        match arg:
-            case DatapointInterval(_, _, _, _):
-                return arg
-            case (UUID(), UUID()):
-                start, end = arg
-                return DatapointInterval(
-                    start_id=start,
-                    end_id=end,
-                    start_exclusive=start_exclusive,
-                    end_inclusive=end_inclusive,
-                )
-            case (str(), str()):
-                start, end = arg
-                return DatapointInterval(
-                    start_id=UUID(start),
-                    end_id=UUID(end),
-                    start_exclusive=start_exclusive,
-                    end_inclusive=end_inclusive,
-                )
+from tilebox.datasets.query.pagination import Pagination
+from tilebox.datasets.query.time_interval import timestamp_to_datetime
+from tilebox.datasets.tilebox.v1 import id_pb2
+from tilebox.datasets.uuid import uuid_message_to_uuid
 
 
 @dataclass(frozen=True)
@@ -173,5 +106,5 @@ class IngestResponse:
         return data_ingestion_pb2.IngestResponse(
             num_created=self.num_created,
             num_existing=self.num_existing,
-            datapoint_ids=[core_pb2.ID(uuid=datapoint_id.bytes) for datapoint_id in self.datapoint_ids],
+            datapoint_ids=[id_pb2.ID(uuid=datapoint_id.bytes) for datapoint_id in self.datapoint_ids],
         )

tilebox/datasets/data/datasets.py

@@ -3,8 +3,8 @@ from uuid import UUID
 
 from google.protobuf.descriptor_pb2 import FileDescriptorSet
 
-from tilebox.datasets.data.uuid import uuid_message_to_optional_uuid, uuid_message_to_uuid, uuid_to_uuid_message
-from tilebox.datasets.datasetsv1 import core_pb2, dataset_type_pb2, datasets_pb2
+from tilebox.datasets.datasets.v1 import core_pb2, dataset_type_pb2, datasets_pb2
+from tilebox.datasets.uuid import uuid_message_to_optional_uuid, uuid_message_to_uuid, uuid_to_uuid_message
 
 
 @dataclass(frozen=True)

tilebox/datasets/data/time_interval.py

@@ -1,237 +1,18 @@
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from typing import TypeAlias
+# kept for backwards compatibility, we can remove this whole file in the future
 
-import numpy as np
-import xarray as xr
-from google.protobuf.duration_pb2 import Duration
-from google.protobuf.timestamp_pb2 import Timestamp
-from pandas.core.tools.datetimes import DatetimeScalar, to_datetime
+from warnings import warn
 
-from tilebox.datasets.datasetsv1 import core_pb2
-
-_SMALLEST_POSSIBLE_TIMEDELTA = timedelta(microseconds=1)
-_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
-
-# A type alias for the different types that can be used to specify a time interval
-TimeIntervalLike: TypeAlias = (
-    DatetimeScalar | tuple[DatetimeScalar, DatetimeScalar] | xr.DataArray | xr.Dataset | "TimeInterval"
+from tilebox.datasets.query.time_interval import (
+    TimeInterval,
+    TimeIntervalLike,
+    datetime_to_timestamp,
+    timestamp_to_datetime,
 )
 
+warn(
+    "The time_interval module has been deprecated, import from tilebox.datasets.query instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-@dataclass(frozen=True)
-class TimeInterval:
-    """
-    A time interval from a given start to a given end time.
-    Both the start and end time can be exclusive or inclusive.
-    """
-
-    start: datetime
-    end: datetime
-
-    # We use exclusive for start and inclusive for end, because that way when both are false
-    # we have a half-open interval [start, end) which is the default behaviour we want to achieve.
-    start_exclusive: bool = False
-    end_inclusive: bool = False
-
-    def __post_init__(self) -> None:
-        """Validate the time interval"""
-        if not isinstance(self.start, datetime):
-            raise TypeError(f"Start time {self.start} must be a datetime object")
-        if not isinstance(self.end, datetime):
-            raise TypeError(f"End time {self.end} must be a datetime object")
-
-        # in case datetime objects are timezone naive, we assume they are in UTC
-        if self.start.tzinfo is None:
-            object.__setattr__(self, "start", self.start.replace(tzinfo=timezone.utc))  # since self is frozen
-        if self.end.tzinfo is None:
-            object.__setattr__(self, "end", self.end.replace(tzinfo=timezone.utc))  # since self is frozen
-
-    def to_half_open(self) -> "TimeInterval":
-        """Convert the time interval to a half-open interval [start, end)"""
-        return TimeInterval(
-            start=self.start + int(self.start_exclusive) * _SMALLEST_POSSIBLE_TIMEDELTA,
-            end=self.end + int(self.end_inclusive) * _SMALLEST_POSSIBLE_TIMEDELTA,
-            start_exclusive=False,
-            end_inclusive=False,
-        )
-
-    def astimezone(self, tzinfo: timezone) -> "TimeInterval":
-        """Convert start and end time to the given timezone"""
-        return TimeInterval(
-            start=self.start.astimezone(tzinfo),
-            end=self.end.astimezone(tzinfo),
-            start_exclusive=self.start_exclusive,
-            end_inclusive=self.end_inclusive,
-        )
-
-    def __eq__(self, other: object) -> bool:
-        """Check whether two intervals are equal"""
-        if not isinstance(other, TimeInterval):
-            return False
-
-        a, b = self.to_half_open(), other.to_half_open()
-        return (a.start, a.end) == (b.start, b.end)
-
-    def __hash__(self) -> int:
-        """Hash the time interval"""
-
-        # if two intervals are equal, they should have the same hash, so we convert to half-open intervals first
-        half_open = self.to_half_open()
-        return hash((half_open.start, half_open.end))
-
-    def __repr__(self) -> str:
-        return self.format()
-
-    def format(self, endpoints: bool = True, sep: str = ", ", timespec: str = "milliseconds") -> str:
-        """Human readable representation of the time interval
-
-        Args:
-            endpoints: Whether to format as interval using scientific interval notation [start, end].
-                "[", "]" for closed intervals and "(", ")" for open intervals.
-            sep: The separator to use between the start and end of the interval.
-            timespec: Specifies the number of additional terms of the time to include. Valid options are 'auto',
-                'hours', 'minutes', 'seconds', 'milliseconds' and 'microseconds'.
-        """
-        if self == _EMPTY_TIME_INTERVAL:
-            return "<empty>"
-
-        start = self.start.isoformat(timespec=timespec).replace("+00:00", " UTC")
-        end = self.end.isoformat(timespec=timespec).replace("+00:00", " UTC")
-
-        formatted = f"{start}{sep}{end}"
-        if endpoints:
-            start_ch = "[" if not self.start_exclusive else "("
-            end_ch = "]" if self.end_inclusive else ")"
-            formatted = f"{start_ch}{formatted}{end_ch}"
-        return formatted
-
-    def __str__(self) -> str:
-        """Human readable representation of the time interval"""
-        return self.format()
-
-    @classmethod
-    def parse(cls, arg: TimeIntervalLike) -> "TimeInterval":
-        """
-        Convert a variety of input types to a TimeInterval.
-
-        Supported input types:
-        - TimeInterval: Return the input as is
-        - DatetimeScalar: Return a TimeInterval with start and end time set to the same value and the end time inclusive
-        - tuple of two DatetimeScalar: Return a TimeInterval with start and end time
-        - xr.DataArray: Return a TimeInterval with start and end time set to the first and last value in the array and
-            the end time inclusive
-        - xr.Dataset: Return a TimeInterval with start and end time set to the first and last value in the time
-            coordinate of the dataset and the end time inclusive
-
-        Args:
-            arg: The input to convert
-
-        Returns:
-            TimeInterval: The parsed time interval
-        """
-
-        match arg:
-            case TimeInterval(_, _, _, _):
-                return arg
-            case (start, end):
-                return TimeInterval(start=_convert_to_datetime(start), end=_convert_to_datetime(end))
-            case point_in_time if isinstance(point_in_time, DatetimeScalar | int):
-                dt = _convert_to_datetime(point_in_time)
-                return TimeInterval(start=dt, end=dt, start_exclusive=False, end_inclusive=True)
-            case arr if (
-                isinstance(arr, xr.DataArray)
-                and arr.ndim == 1
-                and arr.size > 0
-                and arr.dtype == np.dtype("datetime64[ns]")
-            ):
-                start = arr.data[0]
-                end = arr.data[-1]
-                return TimeInterval(
-                    start=_convert_to_datetime(start),
-                    end=_convert_to_datetime(end),
-                    start_exclusive=False,
-                    end_inclusive=True,
-                )
-            case ds if isinstance(ds, xr.Dataset) and "time" in ds.coords:
-                return cls.parse(ds.time)
-
-        raise ValueError(f"Failed to convert {arg} ({type(arg)}) to TimeInterval)")
-
-    @classmethod
-    def from_message(
-        cls, interval: core_pb2.TimeInterval
-    ) -> "TimeInterval":  # lets use typing.Self once we require python >= 3.11
-        """Convert a TimeInterval protobuf message to a TimeInterval object."""
-
-        start = timestamp_to_datetime(interval.start_time)
-        end = timestamp_to_datetime(interval.end_time)
-        if start == _EPOCH and end == _EPOCH and not interval.start_exclusive and not interval.end_inclusive:
-            return _EMPTY_TIME_INTERVAL
-
-        return cls(
-            start=timestamp_to_datetime(interval.start_time),
-            end=timestamp_to_datetime(interval.end_time),
-            start_exclusive=interval.start_exclusive,
-            end_inclusive=interval.end_inclusive,
-        )
-
-    def to_message(self) -> core_pb2.TimeInterval:
-        """Convert a TimeInterval object to a TimeInterval protobuf message."""
-        return core_pb2.TimeInterval(
-            start_time=datetime_to_timestamp(self.start),
-            end_time=datetime_to_timestamp(self.end),
-            start_exclusive=self.start_exclusive,
-            end_inclusive=self.end_inclusive,
-        )
-
-
-# A sentinel value to use for time interval that are empty
-_EMPTY_TIME_INTERVAL = TimeInterval(_EPOCH, _EPOCH, start_exclusive=True, end_inclusive=False)
-
-
-def _convert_to_datetime(arg: DatetimeScalar) -> datetime:
-    """Convert the given datetime scalar to a datetime object in the UTC timezone"""
-    dt: datetime = to_datetime(arg, utc=True).to_pydatetime()
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-    return dt.astimezone(timezone.utc)
-
-
-def timestamp_to_datetime(timestamp: Timestamp) -> datetime:
-    """Convert a protobuf timestamp to a datetime object."""
-    # datetime.fromtimestamp() expects a timestamp in seconds, not microseconds
-    # if we pass it as a floating point number, we will run into rounding errors
-    offset = timedelta(seconds=timestamp.seconds, microseconds=timestamp.nanos // 1000)
-    return _EPOCH + offset
-
-
-def datetime_to_timestamp(dt: datetime) -> Timestamp:
-    """Convert a datetime object to a protobuf timestamp."""
-    # manual epoch offset calculation to avoid rounding errors and support negative timestamps (before 1970)
-    offset_us = datetime_to_us(dt.astimezone(timezone.utc))
-    seconds, us = divmod(offset_us, 10**6)
-    return Timestamp(seconds=seconds, nanos=us * 10**3)
-
-
-def datetime_to_us(dt: datetime) -> int:
-    """Convert a datetime object to a timestamp in microseconds since the epoch."""
-    offset = dt - _EPOCH
-    # implementation taken from timedelta.total_seconds() but without dividing by 10**6 at the end to avoid floating
-    # point rounding errors
-    return (offset.days * 86400 + offset.seconds) * 10**6 + offset.microseconds
-
-
-def us_to_datetime(us: int) -> datetime:
-    """Convert a timestamp in microseconds since the epoch to a datetime object."""
-    return _EPOCH + timedelta(microseconds=us)
-
-
-def timedelta_to_duration(td: timedelta) -> Duration:
-    """Convert a timedelta to a duration protobuf message."""
-    return Duration(seconds=int(td.total_seconds()), nanos=int(td.microseconds * 1000))
-
-
-def duration_to_timedelta(duration: Duration) -> timedelta:
-    """Convert a duration protobuf message to a timedelta."""
-    return timedelta(seconds=duration.seconds, microseconds=duration.nanos // 1000)
+__all__ = ["TimeInterval", "TimeIntervalLike", "datetime_to_timestamp", "timestamp_to_datetime"]

tilebox/datasets/data/timeseries.py

@@ -2,10 +2,10 @@ from dataclasses import dataclass
 from datetime import timedelta
 from uuid import UUID
 
-from tilebox.datasets.data.datapoint import DatapointInterval
-from tilebox.datasets.data.time_interval import TimeInterval, duration_to_timedelta, timedelta_to_duration
-from tilebox.datasets.data.uuid import uuid_message_to_uuid, uuid_to_uuid_message
-from tilebox.datasets.datasetsv1 import timeseries_pb2
+from tilebox.datasets.datasets.v1 import timeseries_pb2
+from tilebox.datasets.query.id_interval import IDInterval
+from tilebox.datasets.query.time_interval import TimeInterval, duration_to_timedelta, timedelta_to_duration
+from tilebox.datasets.uuid import uuid_message_to_uuid, uuid_to_uuid_message
 
 
 @dataclass
@@ -13,7 +13,7 @@ class TimeseriesDatasetChunk:
     dataset_id: UUID
     collection_id: UUID
     time_interval: TimeInterval | None
-    datapoint_interval: DatapointInterval | None
+    datapoint_interval: IDInterval | None
     branch_factor: int
     chunk_size: int
     datapoints_per_365_days: int
@@ -28,7 +28,7 @@ class TimeseriesDatasetChunk:
             and chunk.datapoint_interval.start_id.uuid
             and chunk.datapoint_interval.end_id.uuid
         ):
-            datapoint_interval = DatapointInterval.from_message(chunk.datapoint_interval)
+            datapoint_interval = IDInterval.from_message(chunk.datapoint_interval)
 
         time_interval = None
         if chunk.time_interval and chunk.time_interval.start_time and chunk.time_interval.end_time:

tilebox/datasets/datasets/v1/collections_pb2.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: datasets/v1/collections.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'datasets/v1/collections.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from tilebox.datasets.datasets.v1 import core_pb2 as datasets_dot_v1_dot_core__pb2
+from tilebox.datasets.tilebox.v1 import id_pb2 as tilebox_dot_v1_dot_id__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x64\x61tasets/v1/collections.proto\x12\x0b\x64\x61tasets.v1\x1a\x16\x64\x61tasets/v1/core.proto\x1a\x13tilebox/v1/id.proto\"\\\n\x17\x43reateCollectionRequest\x12-\n\ndataset_id\x18\x01 \x01(\x0b\x32\x0e.tilebox.v1.IDR\tdatasetId\x12\x12\n\x04name\x18\x02 \x01(\tR\x04name\"\xc0\x01\n\x1aGetCollectionByNameRequest\x12\'\n\x0f\x63ollection_name\x18\x01 \x01(\tR\x0e\x63ollectionName\x12+\n\x11with_availability\x18\x02 \x01(\x08R\x10withAvailability\x12\x1d\n\nwith_count\x18\x03 \x01(\x08R\twithCount\x12-\n\ndataset_id\x18\x04 \x01(\x0b\x32\x0e.tilebox.v1.IDR\tdatasetId\"}\n\x17\x44\x65leteCollectionRequest\x12\x33\n\rcollection_id\x18\x01 \x01(\x0b\x32\x0e.tilebox.v1.IDR\x0c\x63ollectionId\x12-\n\ndataset_id\x18\x02 \x01(\x0b\x32\x0e.tilebox.v1.IDR\tdatasetId\"\x1a\n\x18\x44\x65leteCollectionResponse\"\x93\x01\n\x16ListCollectionsRequest\x12-\n\ndataset_id\x18\x01 \x01(\x0b\x32\x0e.tilebox.v1.IDR\tdatasetId\x12+\n\x11with_availability\x18\x02 \x01(\x08R\x10withAvailability\x12\x1d\n\nwith_count\x18\x03 \x01(\x08R\twithCount2\x86\x03\n\x11\x43ollectionService\x12W\n\x10\x43reateCollection\x12$.datasets.v1.CreateCollectionRequest\x1a\x1b.datasets.v1.CollectionInfo\"\x00\x12]\n\x13GetCollectionByName\x12\'.datasets.v1.GetCollectionByNameRequest\x1a\x1b.datasets.v1.CollectionInfo\"\x00\x12\x61\n\x10\x44\x65leteCollection\x12$.datasets.v1.DeleteCollectionRequest\x1a%.datasets.v1.DeleteCollectionResponse\"\x00\x12V\n\x0fListCollections\x12#.datasets.v1.ListCollectionsRequest\x1a\x1c.datasets.v1.CollectionInfos\"\x00\x42u\n\x0f\x63om.datasets.v1B\x10\x43ollectionsProtoP\x01\xa2\x02\x03\x44XX\xaa\x02\x0b\x44\x61tasets.V1\xca\x02\x0b\x44\x61tasets\\V1\xe2\x02\x17\x44\x61tasets\\V1\\GPBMetadata\xea\x02\x0c\x44\x61tasets::V1\x92\x03\x02\x08\x02\x62\x08\x65\x64itionsp\xe8\x07')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'datasets.v1.collections_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\017com.datasets.v1B\020CollectionsProtoP\001\242\002\003DXX\252\002\013Datasets.V1\312\002\013Datasets\\V1\342\002\027Datasets\\V1\\GPBMetadata\352\002\014Datasets::V1\222\003\002\010\002'
+  _globals['_CREATECOLLECTIONREQUEST']._serialized_start=91
+  _globals['_CREATECOLLECTIONREQUEST']._serialized_end=183
+  _globals['_GETCOLLECTIONBYNAMEREQUEST']._serialized_start=186
+  _globals['_GETCOLLECTIONBYNAMEREQUEST']._serialized_end=378
+  _globals['_DELETECOLLECTIONREQUEST']._serialized_start=380
+  _globals['_DELETECOLLECTIONREQUEST']._serialized_end=505
+  _globals['_DELETECOLLECTIONRESPONSE']._serialized_start=507
+  _globals['_DELETECOLLECTIONRESPONSE']._serialized_end=533
+  _globals['_LISTCOLLECTIONSREQUEST']._serialized_start=536
+  _globals['_LISTCOLLECTIONSREQUEST']._serialized_end=683
+  _globals['_COLLECTIONSERVICE']._serialized_start=686
+  _globals['_COLLECTIONSERVICE']._serialized_end=1076
+# @@protoc_insertion_point(module_scope)