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

cognite/extractorutils/__init__.py

@@ -16,7 +16,7 @@
 Cognite extractor utils is a Python package that simplifies the development of new extractors.
 """
 
-__version__ = "7.6.0"
+__version__ = "7.7.0"
 from .base import Extractor
 
 __all__ = ["Extractor"]

cognite/extractorutils/uploader/__init__.py

@@ -71,6 +71,7 @@ from .events import EventUploadQueue
 from .files import BytesUploadQueue, FileUploadQueue, IOFileUploadQueue
 from .raw import RawUploadQueue
 from .time_series import (
+    CDMTimeSeriesUploadQueue,
     DataPoint,
     DataPointList,
     SequenceUploadQueue,
@@ -81,6 +82,7 @@ from .time_series import (
 __all__ = [
     "AssetUploadQueue",
     "BytesUploadQueue",
+    "CDMTimeSeriesUploadQueue",
     "DataPoint",
     "DataPointList",
     "EventUploadQueue",

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,8 +121,6 @@ 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,
     ):
         # Super sets post_upload and threshold
@@ -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,
+    ):
+        # 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,
+    ):
+        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:
         """
-        return self.upload_queue_size
+        Trigger an upload of the queue, clears queue afterwards.
+        """
+
+        @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):

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
@@ -153,6 +158,10 @@ 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)}")
 
@@ -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
 
 
@@ -23,6 +24,16 @@ class InsertDatapoints:
         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]):
+        self.instance_id = instance_id
+        self.datapoints = datapoints
+
+
 class RawRow:
     """
     A class representing a row of data to be inserted into a RAW table.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-extractor-utils
-Version: 7.6.0
+Version: 7.7.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>

{cognite_extractor_utils-7.6.0.dist-info → cognite_extractor_utils-7.7.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-cognite/extractorutils/__init__.py,sha256=U1YH1j-q2xL7GZf-1I0pvGe7gE5L01XYq_fRj4fqBcI,764
+cognite/extractorutils/__init__.py,sha256=Wn0kPh1z4ahQxBmba_sEQKfDuquoNoSIok9yk7kN5g4,764
 cognite/extractorutils/_inner_util.py,sha256=v0SvTyFqwjWkJLGoYh2-i5jry3I43BFoRkhj2MjMSQ0,1780
 cognite/extractorutils/base.py,sha256=Kabgxd269K_aw-P5EdCTP45mrFaIA4YBj5SZjlBVRnY,18605
 cognite/extractorutils/exceptions.py,sha256=VAGAO5sH6-2DgJZGCMeoCojdRDf9o3g1r3__8REFv-Y,1361
 cognite/extractorutils/metrics.py,sha256=gLoDWQlXNOOVLr4uQzw_l7RE85l4ljHweakzFbrx6-Y,15621
 cognite/extractorutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/extractorutils/threading.py,sha256=GybbefZkxIqxUgxQHAiGZyEcMz-Cc3k1peILcDiG1G8,4555
-cognite/extractorutils/uploader_extractor.py,sha256=ZqBgDkNcwdWKWzSC_Gq6CCtYl0m7VHQDyo5KHuiUcgw,8326
-cognite/extractorutils/uploader_types.py,sha256=bMvaFMCd5B1QDuvHhwb-v7i5QPanme52jIoiyzp5BkI,1302
+cognite/extractorutils/uploader_extractor.py,sha256=ZPy-tc9F9fOG6GS2oOdWodolbcFa-4gHXIY8IWaWraA,9015
+cognite/extractorutils/uploader_types.py,sha256=86wPnkEBE3_3r__4KHjxcF0unqdUXHaNrUU1bi0bOjY,1648
 cognite/extractorutils/util.py,sha256=hs0jKwQZO3Owvrld2wzA8HUDjz4uAAcjnJ8hfLYqHv4,22887
 cognite/extractorutils/configtools/__init__.py,sha256=oK0VmZ5hBEuTRwJebVPl_3zlbf6P_Cf5G3VU7u6Shic,3533
 cognite/extractorutils/configtools/_util.py,sha256=NVGaUjCwUCKFMFOKZxco02q6jwdVU4vHYk67i6R_Zxc,4829
@@ -34,7 +34,7 @@ cognite/extractorutils/unstable/core/tasks.py,sha256=8R0kvKTydpnGaGLlgvhp8_uaq9J
 cognite/extractorutils/unstable/scheduling/__init__.py,sha256=NGVNw-dq7eYwm8jLwb8ChPTSyfAnAKMzi3_QDsh46yw,809
 cognite/extractorutils/unstable/scheduling/_scheduler.py,sha256=xfAKAI_pyahdFo7zPOmvAQ_16MFE46zFIYSopzwpLag,3741
 cognite/extractorutils/unstable/scheduling/_schedules.py,sha256=y0NVeXYZOFcAyzBgAe8jqK0W-SZL5m99UwXAacGzqIw,677
-cognite/extractorutils/uploader/__init__.py,sha256=Kf71QoyIhR4tF7R92jnQ0SC87z8WQDEK2NoEzn7OGxc,3396
+cognite/extractorutils/uploader/__init__.py,sha256=U6feg43wlrB3K5lhGXBSDJJWOdtuHIse0G1ZsP3MdxM,3458
 cognite/extractorutils/uploader/_base.py,sha256=ZcCVAC7rCe2klCapbKUg4q7p_9KqQg890MvUmHt6j1M,5230
 cognite/extractorutils/uploader/_metrics.py,sha256=J2LJXb19L_SLSJ_voNIQHYLp0pjxUKevpH1q_xKX6Hk,3247
 cognite/extractorutils/uploader/assets.py,sha256=Dio6m-KFZ4EgFfNKET36K3vL-O6Mp9aHVEC3GPfo6J8,5753
@@ -42,9 +42,9 @@ cognite/extractorutils/uploader/data_modeling.py,sha256=ncSbUsybirOg7WqPqhJKe5n-
 cognite/extractorutils/uploader/events.py,sha256=YSU0wRfN0dLKMmhmyVrZ1afJcX7kT0wxDLgQ7gBpoco,5676
 cognite/extractorutils/uploader/files.py,sha256=NIPg6CpUp2y5fRMDHQXt1igSxyJkdN-K1ANGTv0r98E,28680
 cognite/extractorutils/uploader/raw.py,sha256=KBvlBBwKNfaoY9RgOsyKq7ylHjQCxhIznlQ-lQS_XM4,6754
-cognite/extractorutils/uploader/time_series.py,sha256=PR-Wj-k9P4xltTrspQexjnKIVVS-BOs5EADTDHbvvIs,26546
+cognite/extractorutils/uploader/time_series.py,sha256=LV_z2XLiY3oyQwnkgTF4QkPSrvIQ40C1mbDYLh86NW8,37324
 cognite/extractorutils/uploader/upload_failure_handler.py,sha256=nXw9IVcOxxuywd_17ybXijdpo0omtY0Bkb9fT_fWYFM,3048
-cognite_extractor_utils-7.6.0.dist-info/METADATA,sha256=uQityPrYAtrEXqt4gSNE7aZx4YNnvXGVSKYRJo5Gb64,4888
-cognite_extractor_utils-7.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_extractor_utils-7.6.0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-cognite_extractor_utils-7.6.0.dist-info/RECORD,,
+cognite_extractor_utils-7.7.0.dist-info/METADATA,sha256=_HrMZjtxJ_fnHfguavXWF6pi8-QI8eZRD1re5jM0NMg,4888
+cognite_extractor_utils-7.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_extractor_utils-7.7.0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+cognite_extractor_utils-7.7.0.dist-info/RECORD,,