cognite-extractor-utils 7.6.0__py3-none-any.whl → 7.8.0__py3-none-any.whl

cognite/extractorutils/uploader/time_series.py

@@ -19,7 +19,7 @@ import math
 from collections.abc import Callable
 from datetime import datetime
 from types import TracebackType
-from typing import Any
+from typing import Any, Generic, Literal, TypedDict, TypeVar
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import (
@@ -29,6 +29,9 @@ from cognite.client.data_classes import (
     StatusCode,
     TimeSeries,
 )
+from cognite.client.data_classes.data_modeling import NodeId
+from cognite.client.data_classes.data_modeling.extractor_extensions.v1 import CogniteExtractorTimeSeriesApply
+from cognite.client.data_classes.data_modeling.instances import DirectRelationReference
 from cognite.client.exceptions import CogniteDuplicatedError, CogniteNotFoundError
 from cognite.extractorutils.threading import CancellationToken
 from cognite.extractorutils.uploader._base import (
@@ -62,6 +65,18 @@ DataPointWithStatus = tuple[TimeStamp, float, FullStatusCode] | tuple[TimeStamp,
 DataPoint = DataPointWithoutStatus | DataPointWithStatus
 DataPointList = list[DataPoint]
 
+TQueue = TypeVar("TQueue", bound="BaseTimeSeriesUploadQueue")
+IdType = TypeVar("IdType", EitherId, NodeId)
+
+
+class CdmDatapointsPayload(TypedDict):
+    """
+    Represents a payload for CDF datapoints, linking them to a specific instance.
+    """
+
+    instanceId: NodeId
+    datapoints: DataPointList
+
 
 def default_time_series_factory(external_id: str, datapoints: DataPointList) -> TimeSeries:
     """
@@ -82,9 +97,9 @@ def default_time_series_factory(external_id: str, datapoints: DataPointList) ->
     return TimeSeries(external_id=external_id, is_string=is_string)
 
 
-class TimeSeriesUploadQueue(AbstractUploadQueue):
+class BaseTimeSeriesUploadQueue(AbstractUploadQueue, Generic[IdType]):
     """
-    Upload queue for time series.
+    Abstract base upload queue for time series.
 
     Args:
         cdf_client: Cognite Data Fusion client to use
@@ -96,12 +111,6 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
             methods).
         trigger_log_level: Log level to log upload triggers to.
         thread_name: Thread name of uploader thread.
-        create_missing: Create missing time series if possible (ie, if external id is used). Either given as a boolean
-            (True would auto-create a time series with nothing but an external ID), or as a factory function taking an
-            external ID and a list of datapoints about to be inserted and returning a TimeSeries object.
-        data_set_id: Data set id passed to create_missing. Does nothing if create_missing is False.
-            If a custom timeseries creation method is set in create_missing, this is used as fallback if
-            that method does not set data set id on its own.
     """
 
     def __init__(
@@ -112,10 +121,8 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         max_upload_interval: int | None = None,
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
-        create_missing: Callable[[str, DataPointList], TimeSeries] | bool = False,
-        data_set_id: int | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client,
@@ -127,21 +134,11 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
             cancellation_token,
         )
 
-        self.missing_factory: Callable[[str, DataPointList], TimeSeries]
-
-        if isinstance(create_missing, bool):
-            self.create_missing = create_missing
-            self.missing_factory = default_time_series_factory
-        else:
-            self.create_missing = True
-            self.missing_factory = create_missing
-
-        self.upload_queue: dict[EitherId, DataPointList] = {}
+        self.upload_queue: dict[IdType, DataPointList] = {}
 
         self.points_queued = TIMESERIES_UPLOADER_POINTS_QUEUED
         self.points_written = TIMESERIES_UPLOADER_POINTS_WRITTEN
         self.queue_size = TIMESERIES_UPLOADER_QUEUE_SIZE
-        self.data_set_id = data_set_id
 
     def _verify_datapoint_time(self, time: int | float | datetime | str) -> bool:
         if isinstance(time, int | float):
@@ -171,6 +168,109 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         else:
             return True
 
+    def _sanitize_datapoints(self, datapoints: DataPointList | None) -> DataPointList:
+        datapoints = datapoints or []
+        old_len = len(datapoints)
+        datapoints = list(filter(self._is_datapoint_valid, datapoints))
+
+        new_len = len(datapoints)
+
+        if old_len > new_len:
+            diff = old_len - new_len
+            self.logger.warning(f"Discarding {diff} datapoints due to bad timestamp or value")
+            TIMESERIES_UPLOADER_POINTS_DISCARDED.inc(diff)
+
+        return datapoints
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        """
+        Wraps around stop method, for use as context manager.
+
+        Args:
+            exc_type: Exception type
+            exc_val: Exception value
+            exc_tb: Traceback
+        """
+        self.stop()
+
+    def __len__(self) -> int:
+        """
+        The size of the upload queue.
+
+        Returns:
+            Number of data points in queue
+        """
+        return self.upload_queue_size
+
+    def __enter__(self: TQueue) -> TQueue:
+        """
+        Wraps around start method, for use as context manager.
+
+        Returns:
+            self
+        """
+        self.start()
+        return self
+
+
+class TimeSeriesUploadQueue(BaseTimeSeriesUploadQueue[EitherId]):
+    """
+    Upload queue for time series.
+
+    Args:
+        cdf_client: Cognite Data Fusion client to use
+        post_upload_function: A function that will be called after each upload. The function will be given one argument:
+            A list of dicts containing the datapoints that were uploaded (on the same format as the kwargs in
+            datapoints upload in the Cognite SDK).
+        max_queue_size: Maximum size of upload queue. Defaults to no max size.
+        max_upload_interval: Automatically trigger an upload each m seconds when run as a thread (use start/stop
+            methods).
+        trigger_log_level: Log level to log upload triggers to.
+        thread_name: Thread name of uploader thread.
+        create_missing: Create missing time series if possible (ie, if external id is used). Either given as a boolean
+            (True would auto-create a time series with nothing but an external ID), or as a factory function taking an
+            external ID and a list of datapoints about to be inserted and returning a TimeSeries object.
+        data_set_id: Data set id passed to create_missing. Does nothing if create_missing is False.
+            If a custom timeseries creation method is set in create_missing, this is used as fallback if
+            that method does not set data set id on its own.
+    """
+
+    def __init__(
+        self,
+        cdf_client: CogniteClient,
+        post_upload_function: Callable[[list[dict[str, str | DataPointList]]], None] | None = None,
+        max_queue_size: int | None = None,
+        max_upload_interval: int | None = None,
+        trigger_log_level: str = "DEBUG",
+        thread_name: str | None = None,
+        create_missing: Callable[[str, DataPointList], TimeSeries] | bool = False,
+        data_set_id: int | None = None,
+        cancellation_token: CancellationToken | None = None,
+    ) -> None:
+        # Super sets post_upload and threshold
+        super().__init__(
+            cdf_client,
+            post_upload_function,
+            max_queue_size,
+            max_upload_interval,
+            trigger_log_level,
+            thread_name,
+            cancellation_token,
+        )
+
+        self.missing_factory: Callable[[str, DataPointList], TimeSeries]
+
+        if isinstance(create_missing, bool):
+            self.create_missing = create_missing
+            self.missing_factory = default_time_series_factory
+        else:
+            self.create_missing = True
+            self.missing_factory = create_missing
+
+        self.data_set_id = data_set_id
+
     def add_to_upload_queue(
         self,
         *,
@@ -188,16 +288,7 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
             external_id: External ID of time series. Either this or external_id must be set.
             datapoints: list of data points to add
         """
-        datapoints = datapoints or []
-        old_len = len(datapoints)
-        datapoints = list(filter(self._is_datapoint_valid, datapoints))
-
-        new_len = len(datapoints)
-
-        if old_len > new_len:
-            diff = old_len - new_len
-            self.logger.warning(f"Discarding {diff} datapoints due to bad timestamp or value")
-            TIMESERIES_UPLOADER_POINTS_DISCARDED.inc(diff)
+        datapoints = self._sanitize_datapoints(datapoints)
 
         either_id = EitherId(id=id, external_id=external_id)
 
@@ -310,37 +401,213 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
             self.upload_queue_size = 0
             self.queue_size.set(self.upload_queue_size)
 
-    def __enter__(self) -> "TimeSeriesUploadQueue":
+
+class CDMTimeSeriesUploadQueue(BaseTimeSeriesUploadQueue[NodeId]):
+    """
+    Upload queue for CDM time series.
+
+    Args:
+        cdf_client: Cognite Data Fusion client to use
+        post_upload_function: A function that will be called after each upload. The function will be given one argument:
+            A list of dicts containing the datapoints that were uploaded (on the same format as the kwargs in
+            datapoints upload in the Cognite SDK).
+        max_queue_size: Maximum size of upload queue. Defaults to no max size.
+        max_upload_interval: Automatically trigger an upload each m seconds when run as a thread (use start/stop
+            methods).
+        trigger_log_level: Log level to log upload triggers to.
+        thread_name: Thread name of uploader thread.
+    """
+
+    def __init__(
+        self,
+        cdf_client: CogniteClient,
+        post_upload_function: Callable[[list[dict[str, str | DataPointList]]], None] | None = None,
+        max_queue_size: int | None = None,
+        max_upload_interval: int | None = None,
+        trigger_log_level: str = "DEBUG",
+        thread_name: str | None = None,
+        create_missing: Callable[[NodeId, DataPointList], CogniteExtractorTimeSeriesApply] | bool = False,
+        cancellation_token: CancellationToken | None = None,
+        source: DirectRelationReference | None = None,
+    ) -> None:
+        super().__init__(
+            cdf_client,
+            post_upload_function,
+            max_queue_size,
+            max_upload_interval,
+            trigger_log_level,
+            thread_name,
+            cancellation_token,
+        )
+
+        self.missing_factory: Callable[[NodeId, DataPointList], CogniteExtractorTimeSeriesApply]
+        self.source = source
+
+        if isinstance(create_missing, bool):
+            self.create_missing = create_missing
+            self.missing_factory = self.default_cdm_time_series_factory
+        else:
+            self.create_missing = True
+            self.missing_factory = create_missing
+
+    def default_cdm_time_series_factory(
+        self, instance_id: NodeId, datapoints: DataPointList
+    ) -> CogniteExtractorTimeSeriesApply:
         """
-        Wraps around start method, for use as context manager.
+        Default CDM time series factory used when create_missing in a CDMTimeSeriesUploadQueue is given as a boolean.
 
+        Args:
+            instance_id: Instance ID of time series to create
+            datapoints: The list of datapoints that were tried to be inserted
+            source: The source of the time series, used for creating the DirectRelationReference
         Returns:
-            self
+            A CogniteExtractorTimeSeriesApply object with instance_id set, and the is_string automatically detected
         """
-        self.start()
-        return self
+        is_string = (
+            isinstance(datapoints[0].get("value"), str)
+            if isinstance(datapoints[0], dict)
+            else isinstance(datapoints[0][1], str)
+        )
 
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        time_series_type: Literal["numeric", "string"] = "string" if is_string else "numeric"
+
+        return CogniteExtractorTimeSeriesApply(
+            space=instance_id.space,
+            external_id=instance_id.external_id,
+            is_step=False,
+            time_series_type=time_series_type,
+            source=self.source,
+        )
+
+    def add_to_upload_queue(
+        self,
+        *,
+        instance_id: NodeId,
+        datapoints: DataPointList | None = None,
     ) -> None:
         """
-        Wraps around stop method, for use as context manager.
+        Add data points to upload queue.
+
+        The queue will be uploaded if the queue size is larger than the threshold specified in the __init__.
 
         Args:
-            exc_type: Exception type
-            exc_val: Exception value
-            exc_tb: Traceback
+            instance_id: The identifier for the time series to which the datapoints belong.
+            datapoints: list of data points to add
         """
-        self.stop()
+        datapoints = self._sanitize_datapoints(datapoints)
 
-    def __len__(self) -> int:
-        """
-        The size of the upload queue.
+        with self.lock:
+            if instance_id not in self.upload_queue:
+                self.upload_queue[instance_id] = []
 
-        Returns:
-            Number of data points in queue
+            self.upload_queue[instance_id].extend(datapoints)
+            self.points_queued.inc(len(datapoints))
+            self.upload_queue_size += len(datapoints)
+            self.queue_size.set(self.upload_queue_size)
+
+            self._check_triggers()
+
+    def upload(self) -> None:
+        """
+        Trigger an upload of the queue, clears queue afterwards.
         """
-        return self.upload_queue_size
+
+        @retry(
+            exceptions=cognite_exceptions(),
+            cancellation_token=self.cancellation_token,
+            tries=RETRIES,
+            delay=RETRY_DELAY,
+            max_delay=RETRY_MAX_DELAY,
+            backoff=RETRY_BACKOFF_FACTOR,
+        )
+        def _upload_batch(upload_this: list[CdmDatapointsPayload], retries: int = 5) -> list[CdmDatapointsPayload]:
+            if len(upload_this) == 0:
+                return upload_this
+
+            try:
+                self.cdf_client.time_series.data.insert_multiple(upload_this)  # type: ignore[arg-type]
+            except CogniteNotFoundError as ex:
+                if not retries:
+                    raise ex
+
+                if not self.create_missing:
+                    self.logger.error("Could not upload data points to %s: %s", str(ex.not_found), str(ex))
+
+                # Get IDs of time series that exists, but failed because of the non-existing time series
+                retry_these = [
+                    NodeId(id_dict["instanceId"]["space"], id_dict["instanceId"]["externalId"])
+                    for id_dict in ex.failed
+                    if id_dict not in ex.not_found
+                ]
+
+                if self.create_missing:
+                    # Get the time series that can be created
+                    create_these_ids = {
+                        NodeId(id_dict["instanceId"]["space"], id_dict["instanceId"]["externalId"])
+                        for id_dict in ex.not_found
+                    }
+                    self.logger.info(f"Creating {len(create_these_ids)} time series")
+
+                    datapoints_lists: dict[NodeId, DataPointList] = {
+                        ts_dict["instanceId"]: ts_dict["datapoints"]
+                        for ts_dict in upload_this
+                        if ts_dict["instanceId"] in create_these_ids
+                    }
+
+                    to_create: list[CogniteExtractorTimeSeriesApply] = [
+                        self.missing_factory(instance_id, datapoints_lists[instance_id])
+                        for instance_id in create_these_ids
+                    ]
+
+                    instance_result = self.cdf_client.data_modeling.instances.apply(to_create)
+                    retry_these.extend([node.as_id() for node in instance_result.nodes])
+
+                    if len(ex.not_found) != len(create_these_ids):
+                        missing = [
+                            id_dict
+                            for id_dict in ex.not_found
+                            if NodeId(id_dict["instanceId"]["space"], id_dict["instanceId"]["externalId"])
+                            not in retry_these
+                        ]
+                        missing_num = len(ex.not_found) - len(create_these_ids)
+                        self.logger.error(
+                            f"{missing_num} time series not found, and could not be created automatically: "
+                            + str(missing)
+                            + " Data will be dropped"
+                        )
+
+                # Remove entries with non-existing time series from upload queue
+                upload_this = [entry for entry in upload_this if entry["instanceId"] in retry_these]
+
+                # Upload remaining
+                _upload_batch(upload_this, retries - 1)
+
+            return upload_this
+
+        if len(self.upload_queue) == 0:
+            return
+
+        with self.lock:
+            upload_this = _upload_batch(
+                [
+                    {"instanceId": instance_id, "datapoints": list(datapoints)}
+                    for instance_id, datapoints in self.upload_queue.items()
+                    if len(datapoints) > 0
+                ]
+            )
+
+            for datapoints in self.upload_queue.values():
+                self.points_written.inc(len(datapoints))
+
+            try:
+                self._post_upload(upload_this)
+            except Exception as e:
+                self.logger.error("Error in upload callback: %s", str(e))
+
+            self.upload_queue.clear()
+            self.logger.info(f"Uploaded {self.upload_queue_size} datapoints")
+            self.upload_queue_size = 0
+            self.queue_size.set(self.upload_queue_size)
 
 
 class SequenceUploadQueue(AbstractUploadQueue):
@@ -369,7 +636,7 @@ class SequenceUploadQueue(AbstractUploadQueue):
         thread_name: str | None = None,
         create_missing: bool = False,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client,

cognite/extractorutils/uploader_extractor.py

@@ -31,8 +31,13 @@ from cognite.extractorutils.configtools import BaseConfig, TimeIntervalConfig
 from cognite.extractorutils.metrics import BaseMetrics
 from cognite.extractorutils.statestore import AbstractStateStore
 from cognite.extractorutils.threading import CancellationToken
-from cognite.extractorutils.uploader import EventUploadQueue, RawUploadQueue, TimeSeriesUploadQueue
-from cognite.extractorutils.uploader_types import CdfTypes, Event, InsertDatapoints, RawRow
+from cognite.extractorutils.uploader import (
+    CDMTimeSeriesUploadQueue,
+    EventUploadQueue,
+    RawUploadQueue,
+    TimeSeriesUploadQueue,
+)
+from cognite.extractorutils.uploader_types import CdfTypes, Event, InsertCDMDatapoints, InsertDatapoints, RawRow
 
 
 @dataclass
@@ -100,7 +105,7 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         heartbeat_waiting_time: int = 600,
         handle_interrupts: bool = True,
         middleware: list[Callable[[dict], dict]] | None = None,
-    ):
+    ) -> None:
         super().__init__(
             name=name,
             description=description,
@@ -153,10 +158,14 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
                     self.time_series_queue.add_to_upload_queue(
                         id=dp.id, external_id=dp.external_id, datapoints=dp.datapoints
                     )
+        elif isinstance(peek, InsertCDMDatapoints):
+            for dp in peekable_output:
+                if isinstance(dp, InsertCDMDatapoints):
+                    self.cdm_time_series_queue.add_to_upload_queue(instance_id=dp.instance_id, datapoints=dp.datapoints)
         else:
             raise ValueError(f"Unexpected type: {type(peek)}")
 
-    def _apply_middleware(self, item: Any) -> Any:
+    def _apply_middleware(self, item: Any) -> Any:  # noqa: ANN401
         for mw in self.middleware:
             item = mw(item)
         return item
@@ -187,7 +196,12 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
             trigger_log_level="INFO",
             create_missing=True,
         ).__enter__()
-
+        self.cdm_time_series_queue = CDMTimeSeriesUploadQueue(
+            self.cognite_client,
+            max_queue_size=queue_config.timeseries_size,
+            max_upload_interval=queue_config.upload_interval.seconds,
+            trigger_log_level="INFO",
+        ).__enter__()
         return self
 
     def __exit__(
@@ -199,4 +213,5 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         self.event_queue.__exit__(exc_type, exc_val, exc_tb)
         self.raw_queue.__exit__(exc_type, exc_val, exc_tb)
         self.time_series_queue.__exit__(exc_type, exc_val, exc_tb)
+        self.cdm_time_series_queue.__exit__(exc_type, exc_val, exc_tb)
         return super().__exit__(exc_type, exc_val, exc_tb)

cognite/extractorutils/uploader_types.py

@@ -9,6 +9,7 @@ from typing import TypeAlias
 
 from cognite.client.data_classes import Event as _Event
 from cognite.client.data_classes import Row as _Row
+from cognite.client.data_classes.data_modeling import NodeId
 from cognite.extractorutils.uploader.time_series import DataPoint
 
 
@@ -17,18 +18,28 @@ class InsertDatapoints:
     A class representing a batch of datapoints to be inserted into a time series.
     """
 
-    def __init__(self, *, id: int | None = None, external_id: str | None = None, datapoints: list[DataPoint]):  # noqa: A002
+    def __init__(self, *, id: int | None = None, external_id: str | None = None, datapoints: list[DataPoint]) -> None:  # noqa: A002
         self.id = id
         self.external_id = external_id
         self.datapoints = datapoints
 
 
+class InsertCDMDatapoints:
+    """
+    A class representing a batch of datapoints to be inserted into a cdm time series.
+    """
+
+    def __init__(self, *, instance_id: NodeId, datapoints: list[DataPoint]) -> None:
+        self.instance_id = instance_id
+        self.datapoints = datapoints
+
+
 class RawRow:
     """
     A class representing a row of data to be inserted into a RAW table.
     """
 
-    def __init__(self, db_name: str, table_name: str, row: _Row | Iterable[_Row]):
+    def __init__(self, db_name: str, table_name: str, row: _Row | Iterable[_Row]) -> None:
         self.db_name = db_name
         self.table_name = table_name
         if isinstance(row, Iterable):

cognite/extractorutils/util.py

@@ -30,12 +30,14 @@ from typing import Any, TypeVar
 from decorator import decorator
 
 from cognite.client import CogniteClient
+from cognite.client._api.assets import AssetsAPI
+from cognite.client._api.time_series import TimeSeriesAPI
 from cognite.client.data_classes import Asset, ExtractionPipelineRun, TimeSeries
 from cognite.client.exceptions import CogniteAPIError, CogniteException, CogniteFileUploadError, CogniteNotFoundError
 from cognite.extractorutils.threading import CancellationToken
 
 
-def _ensure(endpoint: Any, items: Iterable[Any]) -> None:
+def _ensure(endpoint: TimeSeriesAPI | AssetsAPI, items: Iterable[Any]) -> None:
     try:
         external_ids = [ts.external_id for ts in items]
 
@@ -90,7 +92,7 @@ class EitherId:
         TypeError: If none of both of id types are set.
     """
 
-    def __init__(self, **kwargs: int | str | None):
+    def __init__(self, **kwargs: int | str | None) -> None:
         internal_id = kwargs.get("id")
         external_id = kwargs.get("externalId") or kwargs.get("external_id")
 
@@ -127,7 +129,7 @@ class EitherId:
         """
         return self.internal_id or self.external_id  # type: ignore  # checked to be not None in init
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         """
         Compare with another object. Only returns true if other is an EitherId with the same type and content.
 
@@ -210,7 +212,7 @@ def add_extraction_pipeline(
 
     def decorator_ext_pip(input_function: Callable[..., _T1]) -> Callable[..., _T1]:
         @wraps(input_function)
-        def wrapper_ext_pip(*args: Any, **kwargs: Any) -> _T1:
+        def wrapper_ext_pip(*args: Any, **kwargs: Any) -> _T1:  # noqa: ANN401
             ##############################
             # Setup Extraction Pipelines #
             ##############################
@@ -397,7 +399,7 @@ def retry(
     """
 
     @decorator
-    def retry_decorator(f: Callable[..., _T2], *fargs: Any, **fkwargs: Any) -> _T2:
+    def retry_decorator(f: Callable[..., _T2], *fargs: Any, **fkwargs: Any) -> _T2:  # noqa: ANN401
         args = fargs if fargs else []
         kwargs = fkwargs if fkwargs else {}
 
@@ -657,7 +659,7 @@ def iterable_to_stream(
         def readable(self) -> bool:
             return True
 
-        def readinto(self, buffer: Any) -> int | None:
+        def readinto(self, buffer: "WritableBuffer") -> int | None:  # type: ignore[name-defined]  # noqa: F821
             try:
                 # Bytes to return
                 ln = len(buffer)

{cognite_extractor_utils-7.6.0.dist-info → cognite_extractor_utils-7.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-extractor-utils
-Version: 7.6.0
+Version: 7.8.0
 Summary: Utilities for easier development of extractors for CDF
 Project-URL: repository, https://github.com/cognitedata/python-extractor-utils
 Author-email: Mathias Lohne <mathias.lohne@cognite.com>
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Requires-Dist: arrow>=1.0.0
 Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: azure-keyvault-secrets>=4.7.0
-Requires-Dist: cognite-sdk>=7.59.0
+Requires-Dist: cognite-sdk>=7.75.2
 Requires-Dist: croniter>=6.0.0
 Requires-Dist: dacite<1.9.0,>=1.6.0
 Requires-Dist: decorator>=5.1.1
@@ -26,6 +26,7 @@ Requires-Dist: pydantic>=2.8.2
 Requires-Dist: pyhumps>=3.8.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml<7,>=5.3.0
+Requires-Dist: simple-winservice>=0.1.0; sys_platform == 'win32'
 Requires-Dist: typing-extensions<5,>=3.7.4
 Provides-Extra: experimental
 Requires-Dist: cognite-sdk-experimental; extra == 'experimental'