cognite-extractor-utils 7.5.8__py3-none-any.whl → 7.5.10__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.5.8"
+__version__ = "7.5.10"
 from .base import Extractor
 
 __all__ = ["Extractor"]

cognite/extractorutils/configtools/__init__.py

@@ -16,7 +16,7 @@
 Module containing tools for loading and verifying config files, and a YAML loader to automatically serialize these
 dataclasses from a config file.
 
-Configs are described as ``dataclass``\es, and use the ``BaseConfig`` class as a superclass to get a few things
+Configs are described as ``dataclass`` es, and use the ``BaseConfig`` class as a superclass to get a few things
 built-in: config version, Cognite project and logging. Use type hints to specify types, use the ``Optional`` type to
 specify that a config parameter is optional, and give the attribute a value to give it a default.
 

cognite/extractorutils/unstable/core/base.py

@@ -2,11 +2,10 @@ import logging
 import logging.config
 import time
 from concurrent.futures import ThreadPoolExecutor
-from contextvars import ContextVar, Token
+from functools import partial
 from logging.handlers import TimedRotatingFileHandler
 from multiprocessing import Queue
 from threading import RLock, Thread
-from traceback import format_exception
 from types import TracebackType
 from typing import Generic, Literal, TypeVar
 
@@ -25,8 +24,9 @@ from cognite.extractorutils.unstable.core._dto import Error as DtoError
 from cognite.extractorutils.unstable.core._dto import TaskUpdate
 from cognite.extractorutils.unstable.core._messaging import RuntimeMessage
 from cognite.extractorutils.unstable.core.errors import Error, ErrorLevel
+from cognite.extractorutils.unstable.core.logger import CogniteLogger
 from cognite.extractorutils.unstable.core.restart_policy import WHEN_CONTINUOUS_TASKS_CRASHES, RestartPolicy
-from cognite.extractorutils.unstable.core.tasks import ContinuousTask, ScheduledTask, StartupTask, Task
+from cognite.extractorutils.unstable.core.tasks import ContinuousTask, ScheduledTask, StartupTask, Task, TaskContext
 from cognite.extractorutils.unstable.scheduling import TaskScheduler
 from cognite.extractorutils.util import now
 
@@ -51,7 +51,7 @@ class FullConfig(Generic[_T]):
         self.current_config_revision = current_config_revision
 
 
-class Extractor(Generic[ConfigType]):
+class Extractor(Generic[ConfigType], CogniteLogger):
     NAME: str
     EXTERNAL_ID: str
     DESCRIPTION: str
@@ -62,6 +62,8 @@ class Extractor(Generic[ConfigType]):
     RESTART_POLICY: RestartPolicy = WHEN_CONTINUOUS_TASKS_CRASHES
 
     def __init__(self, config: FullConfig[ConfigType]) -> None:
+        self._logger = logging.getLogger(f"{self.EXTERNAL_ID}.main")
+
         self.cancellation_token = CancellationToken()
         self.cancellation_token.cancel_on_interrupt()
 
@@ -80,10 +82,6 @@ class Extractor(Generic[ConfigType]):
         self._task_updates: list[TaskUpdate] = []
         self._errors: dict[str, Error] = {}
 
-        self.logger = logging.getLogger(f"{self.EXTERNAL_ID}.main")
-
-        self._current_task: ContextVar[str | None] = ContextVar("current_task", default=None)
-
         self.__init_tasks__()
 
     def _setup_logging(self) -> None:
@@ -175,36 +173,34 @@ class Extractor(Generic[ConfigType]):
     def _run_checkin(self) -> None:
         while not self.cancellation_token.is_cancelled:
             try:
-                self.logger.debug("Running checkin")
+                self._logger.debug("Running checkin")
                 self._checkin()
             except Exception:
-                self.logger.exception("Error during checkin")
+                self._logger.exception("Error during checkin")
             self.cancellation_token.wait(10)
 
     def _report_error(self, error: Error) -> None:
         with self._checkin_lock:
             self._errors[error.external_id] = error
 
-    def error(
+    def _new_error(
         self,
         level: ErrorLevel,
         description: str,
-        details: str | None = None,
         *,
-        force_global: bool = False,
+        details: str | None = None,
+        task_name: str | None = None,
     ) -> Error:
-        task_name = self._current_task.get()
-
         return Error(
             level=level,
             description=description,
             details=details,
             extractor=self,
-            task_name=None if force_global else task_name,
+            task_name=task_name,
         )
 
     def restart(self) -> None:
-        self.logger.info("Restarting extractor")
+        self._logger.info("Restarting extractor")
         if self._runtime_messages:
             self._runtime_messages.put(RuntimeMessage.RESTART)
         self.cancellation_token.cancel()
@@ -217,7 +213,7 @@ class Extractor(Generic[ConfigType]):
         # Store this for later, since we'll override it with the wrapped version
         target = task.target
 
-        def run_task() -> None:
+        def run_task(task_context: TaskContext) -> None:
             """
             A wrapped version of the task's target, with tracking and error handling
             """
@@ -227,33 +223,22 @@ class Extractor(Generic[ConfigType]):
                     TaskUpdate(type="started", name=task.name, timestamp=now()),
                 )
 
-            context_token: Token[str | None] | None = None
-
             try:
-                # Set the current task context var, used to track that we're in a task for error reporting
-                context_token = self._current_task.set(task.name)
-
                 # Run task
-                target()
+                target(task_context)
 
             except Exception as e:
-                self.logger.exception(f"Unexpected error in {task.name}")
-
                 # Task crashed, record it as a fatal error
-                self.error(
-                    ErrorLevel.fatal,
-                    description="Task crashed unexpectedly",
-                    details="".join(format_exception(e)),
-                ).instant()
+                task_context.exception(
+                    f"Task {task.name} crashed unexpectedly",
+                    e,
+                    level=ErrorLevel.fatal,
+                )
 
                 if self.__class__.RESTART_POLICY(task, e):
                     self.restart()
 
             finally:
-                # Unset the current task
-                if context_token is not None:
-                    self._current_task.reset(context_token)
-
                 # Record task end
                 with self._checkin_lock:
                     self._task_updates.append(
@@ -265,7 +250,16 @@ class Extractor(Generic[ConfigType]):
 
         match task:
             case ScheduledTask() as t:
-                self._scheduler.schedule_task(name=t.name, schedule=t.schedule, task=t.target)
+                self._scheduler.schedule_task(
+                    name=t.name,
+                    schedule=t.schedule,
+                    task=lambda: t.target(
+                        TaskContext(
+                            task=task,
+                            extractor=self,
+                        )
+                    ),
+                )
 
     def _report_extractor_info(self) -> None:
         self.cognite_client.post(
@@ -281,6 +275,8 @@ class Extractor(Generic[ConfigType]):
                     {
                         "name": t.name,
                         "type": "continuous" if isinstance(t, ContinuousTask) else "batch",
+                        "action": True if isinstance(t, ScheduledTask) else False,
+                        "description": t.description,
                     }
                     for t in self._tasks
                 ],
@@ -310,7 +306,7 @@ class Extractor(Generic[ConfigType]):
         with self._checkin_lock:
             self._checkin()
 
-        self.logger.info("Shutting down extractor")
+        self._logger.info("Shutting down extractor")
         return exc_val is None
 
     def run(self) -> None:
@@ -333,15 +329,27 @@ class Extractor(Generic[ConfigType]):
                 case _:
                     assert_never(task)
 
-        self.logger.info("Starting extractor")
+        self._logger.info("Starting extractor")
         if startup:
             with ThreadPoolExecutor() as pool:
                 for task in startup:
-                    pool.submit(task.target)
-        self.logger.info("Startup done")
+                    pool.submit(
+                        partial(
+                            task.target,
+                            TaskContext(
+                                task=task,
+                                extractor=self,
+                            ),
+                        )
+                    )
+        self._logger.info("Startup done")
 
         for task in continuous:
-            Thread(name=pascalize(task.name), target=task.target).start()
+            Thread(
+                name=pascalize(task.name),
+                target=task.target,
+                args=(TaskContext(task=task, extractor=self),),
+            ).start()
 
         if has_scheduled:
             self._scheduler.run()

cognite/extractorutils/unstable/core/errors.py

@@ -1,11 +1,14 @@
-import typing
+import logging
 from enum import Enum
 from types import TracebackType
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
+from typing_extensions import assert_never
+
 from cognite.extractorutils.util import now
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from .base import Extractor
 
 __all__ = ["Error", "ErrorLevel"]
@@ -16,6 +19,18 @@ class ErrorLevel(Enum):
     error = "error"
     fatal = "fatal"
 
+    @property
+    def log_level(self) -> int:
+        match self:
+            case ErrorLevel.warning:
+                return logging.WARNING
+            case ErrorLevel.error:
+                return logging.ERROR
+            case ErrorLevel.fatal:
+                return logging.CRITICAL
+            case _:
+                assert_never(self)
+
 
 class Error:
     def __init__(

cognite/extractorutils/unstable/core/logger.py

@@ -0,0 +1,149 @@
+from abc import ABC, abstractmethod
+from logging import Logger, getLogger
+from traceback import format_exception
+from typing import Literal
+
+from typing_extensions import assert_never
+
+from cognite.extractorutils.unstable.core.errors import Error, ErrorLevel
+
+
+class CogniteLogger(ABC):
+    def __init__(self) -> None:
+        self._logger: Logger = getLogger()
+
+    @abstractmethod
+    def _new_error(
+        self,
+        level: ErrorLevel,
+        description: str,
+        *,
+        details: str | None = None,
+        task_name: str | None = None,
+    ) -> Error:
+        pass
+
+    def debug(self, message: str) -> None:
+        self._logger.debug(message)
+
+    def info(self, message: str) -> None:
+        self._logger.info(message)
+
+    def begin_warning(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> Error:
+        if auto_log:
+            self._logger.warning(message)
+        return self._new_error(
+            level=ErrorLevel.warning,
+            description=message,
+            details=details,
+        )
+
+    def begin_error(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> Error:
+        if auto_log:
+            self._logger.error(message)
+        return self._new_error(
+            level=ErrorLevel.error,
+            description=message,
+            details=details,
+        )
+
+    def begin_fatal(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> Error:
+        if auto_log:
+            self._logger.critical(message)
+        return self._new_error(
+            level=ErrorLevel.fatal,
+            description=message,
+            details=details,
+        )
+
+    def warning(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> None:
+        if auto_log:
+            self._logger.warning(message)
+        self._new_error(
+            level=ErrorLevel.warning,
+            description=message,
+            details=details,
+        ).instant()
+
+    def error(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> None:
+        if auto_log:
+            self._logger.error(message)
+        self._new_error(
+            level=ErrorLevel.error,
+            description=message,
+            details=details,
+        ).instant()
+
+    def fatal(
+        self,
+        message: str,
+        *,
+        details: str | None = None,
+        auto_log: bool = True,
+    ) -> None:
+        if auto_log:
+            self._logger.critical(message)
+        self._new_error(
+            level=ErrorLevel.fatal,
+            description=message,
+            details=details,
+        ).instant()
+
+    def exception(
+        self,
+        message: str,
+        exception: Exception,
+        *,
+        level: ErrorLevel = ErrorLevel.error,
+        include_details: Literal["stack_trace"] | Literal["exception_message"] | bool = "exception_message",
+        auto_log: bool = True,
+    ) -> None:
+        if auto_log:
+            self._logger.log(level=level.log_level, msg=message, exc_info=exception)
+
+        details: str | None
+        match include_details:
+            case "stack_trace":
+                details = "".join(format_exception(exception))
+            case "exception_message" | True:
+                details = str(exception)
+            case False:
+                details = None
+            case _:
+                assert_never(include_details)
+
+        self._new_error(
+            level=level,
+            description=message,
+            details=details,
+        ).instant()

cognite/extractorutils/unstable/core/tasks.py

@@ -1,30 +1,115 @@
-from abc import ABC
+import logging
 from collections.abc import Callable
-from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from cognite.extractorutils.unstable.configuration.models import ScheduleConfig
+from cognite.extractorutils.unstable.configuration.models import (
+    CronConfig,
+    IntervalConfig,
+    ScheduleConfig,
+    TimeIntervalConfig,
+)
+from cognite.extractorutils.unstable.core.errors import Error, ErrorLevel
+from cognite.extractorutils.unstable.core.logger import CogniteLogger
 
-__all__ = ["ScheduledTask", "ContinuousTask", "StartupTask", "Task"]
+if TYPE_CHECKING:
+    from cognite.extractorutils.unstable.core.base import Extractor
 
+__all__ = ["ScheduledTask", "ContinuousTask", "StartupTask", "Task", "TaskContext"]
 
-@dataclass
-class _Task(ABC):
-    name: str
-    target: Callable[[], None]
+
+class TaskContext(CogniteLogger):
+    def __init__(self, task: "Task", extractor: "Extractor"):
+        super().__init__()
+        self._task = task
+        self._extractor = extractor
+
+        self._logger = logging.getLogger(f"{self._extractor.EXTERNAL_ID}.{self._task.name.replace(' ', '')}")
+
+    def _new_error(
+        self,
+        level: ErrorLevel,
+        description: str,
+        *,
+        details: str | None = None,
+        task_name: str | None = None,
+    ) -> Error:
+        return self._extractor._new_error(
+            level=level,
+            description=description,
+            details=details,
+            task_name=self._task.name,
+        )
+
+
+TaskTarget = Callable[[TaskContext], None]
+
+
+class _Task:
+    def __init__(
+        self,
+        *,
+        name: str,
+        target: TaskTarget,
+        description: str | None = None,
+    ) -> None:
+        self.name = name
+        self.target = target
+        self.description = description
 
 
-@dataclass
 class ScheduledTask(_Task):
-    schedule: ScheduleConfig
+    def __init__(
+        self,
+        *,
+        name: str,
+        target: TaskTarget,
+        description: str | None = None,
+        schedule: ScheduleConfig,
+    ):
+        super().__init__(name=name, target=target, description=description)
+        self.schedule = schedule
+
+    @classmethod
+    def from_interval(
+        cls, *, interval: str, name: str, target: TaskTarget, description: str | None = None
+    ) -> "ScheduledTask":
+        return ScheduledTask(
+            name=name,
+            target=target,
+            description=description,
+            schedule=IntervalConfig(type="interval", expression=TimeIntervalConfig(interval)),
+        )
+
+    @classmethod
+    def from_cron(cls, *, cron: str, name: str, target: TaskTarget, description: str | None = None) -> "ScheduledTask":
+        return ScheduledTask(
+            name=name,
+            target=target,
+            description=description,
+            schedule=CronConfig(type="cron", expression=cron),
+        )
 
 
-@dataclass
 class ContinuousTask(_Task):
-    pass
+    def __init__(
+        self,
+        *,
+        name: str,
+        target: TaskTarget,
+        description: str | None = None,
+    ) -> None:
+        super().__init__(name=name, target=target, description=description)
 
 
 class StartupTask(_Task):
-    pass
+    def __init__(
+        self,
+        *,
+        name: str,
+        target: TaskTarget,
+        description: str | None = None,
+    ) -> None:
+        super().__init__(name=name, target=target, description=description)
 
 
 # Making a type union to help with exhaustion checks in matches

cognite/extractorutils/unstable/scheduling/_scheduler.py

@@ -71,7 +71,7 @@ class TaskScheduler:
                 with self._running_lock:
                     self._running.remove(job)
 
-        Thread(target=wrap, name=f"{pascalize(job.name)}").start()
+        Thread(target=wrap, name=f"{pascalize(job.name.replace(' ', '_'))}").start()
         return True
 
     def trigger(self, name: str) -> bool:

cognite/extractorutils/uploader/files.py

@@ -25,6 +25,7 @@ from typing import (
 )
 from urllib.parse import ParseResult, urlparse
 
+from h11._util import LocalProtocolError
 from httpx import URL, Client, Headers, Request, StreamConsumed, SyncByteStream
 from requests.utils import super_len
 
@@ -481,6 +482,19 @@ class IOFileUploadQueue(AbstractUploadQueue):
             try:
                 upload_file(read_file, file_meta)
 
+            except LocalProtocolError as e:
+                error_message = str(e)
+                if (
+                    "Too much data for declared Content" in error_message
+                    or "Too little data for declared Content-Length" in error_message
+                ):
+                    self.logger.error(
+                        f"Content Length Mismatch while uploading file: {file_meta} error message: {error_message}"
+                    )
+
+                self.add_entry_failure_logger(file_name=str(file_meta.name), error=e)
+                self.errors.append(e)
+
             except Exception as e:
                 self.logger.exception(
                     f"Unexpected error while uploading file: {file_meta.external_id} {file_meta.name}"

{cognite_extractor_utils-7.5.8.dist-info → cognite_extractor_utils-7.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-extractor-utils
-Version: 7.5.8
+Version: 7.5.10
 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>
@@ -14,7 +14,7 @@ Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: azure-keyvault-secrets>=4.7.0
 Requires-Dist: cognite-sdk>=7.59.0
 Requires-Dist: croniter>=6.0.0
-Requires-Dist: dacite>=1.6.0
+Requires-Dist: dacite<1.9.0,>=1.6.0
 Requires-Dist: decorator>=5.1.1
 Requires-Dist: httpx<1,>=0.27.0
 Requires-Dist: jsonlines>=4.0.0

{cognite_extractor_utils-7.5.8.dist-info → cognite_extractor_utils-7.5.10.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cognite/extractorutils/__init__.py,sha256=ciNieD74DRL7inQf43jjmTN97a3JEKmrkskKOrIDRVM,764
+cognite/extractorutils/__init__.py,sha256=PPeqjI1OnpB1kdKnuKjHukkj9BauAO6kJHugrm8GbH4,765
 cognite/extractorutils/_inner_util.py,sha256=ZMZIBwFpSD39RzLZq_OJlrFtVt8NFOtU4ObzAG8vTB4,1779
 cognite/extractorutils/base.py,sha256=-jkGgUMYKdhFReua8ZoGUQwT1qbOvg6nTrt0lyJOGVc,16354
 cognite/extractorutils/exceptions.py,sha256=4qreRiTwZH9lyLIKR67TP02MUxN9oYhCd2vFTb5bRME,1125
@@ -8,7 +8,7 @@ cognite/extractorutils/threading.py,sha256=bO0EdGje42I3JOjyo3JKjqCjRk9W4ZCyKC2jC
 cognite/extractorutils/uploader_extractor.py,sha256=MFS4GG9hPNaZ8EB3pP_bJNVi0r1y_wDYq7MrjwbpwO4,7639
 cognite/extractorutils/uploader_types.py,sha256=lePcXPrXVcQYtvnF9Uv12gHaeOIGfYKxIjwy-ez5p7E,892
 cognite/extractorutils/util.py,sha256=ZAx688yXV85xmWuAASlZ3e9yY5pvyR8H0r4rhnPdgF4,21052
-cognite/extractorutils/configtools/__init__.py,sha256=llNMzHu4yCWx5Kjm8G9IN5Pij8OUaVT_VZuZ2r3JtAA,3616
+cognite/extractorutils/configtools/__init__.py,sha256=LSa7gVws_mrLCMRTKGs1zfiG6-IM0HzyOF6x0EfllSo,3616
 cognite/extractorutils/configtools/_util.py,sha256=VMxXXmPvNPf3Jjwknqm7i-Bp-z_ORN0DFKjBHgBsWA0,4773
 cognite/extractorutils/configtools/elements.py,sha256=chgcv7WSOb1zbHl1XU5dlsCSB7SDTY4NeKREYNeF9kE,26590
 cognite/extractorutils/configtools/loaders.py,sha256=a3LMwcuPCvuegxGzOrS3-mcnErd9R-oa0JRFEKhE5fs,18309
@@ -25,13 +25,14 @@ cognite/extractorutils/unstable/configuration/models.py,sha256=vrwe53CZroujNVVpg
 cognite/extractorutils/unstable/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/extractorutils/unstable/core/_dto.py,sha256=tvvy39cvf-QT28GWz5FpqxQ5vAVk0t69JoPPhpWlweY,1293
 cognite/extractorutils/unstable/core/_messaging.py,sha256=D9rOW8fijryXffbm90d8VTf2vy5FmwVGU-H0O-cn-EI,68
-cognite/extractorutils/unstable/core/base.py,sha256=-Vgq615KMeJo5IscWQbH3IM09fpIRAXWEGLlwzsCNKk,12024
-cognite/extractorutils/unstable/core/errors.py,sha256=J_dU3ozLyULNrXcxQc2HqYq58mBKO1ce3NGDIdIZoWQ,1699
+cognite/extractorutils/unstable/core/base.py,sha256=eOtz4nNR3bv-vgQ-ma5yaUGpNN4nNNB5MSrtRRqy8tI,12249
+cognite/extractorutils/unstable/core/errors.py,sha256=oTRB5Alt-rM90wHfQQM0idjATpv0BrKtoAIOvtu7P-k,2115
+cognite/extractorutils/unstable/core/logger.py,sha256=MLkOZ6ofFKBpm7UAVy7l_RoUEm9ipLdkkay4mxzJJH0,3765
 cognite/extractorutils/unstable/core/restart_policy.py,sha256=4FUohTXeC74mnq36Q16PQ2i9jPI-WuUZm8XwClFSnYk,631
 cognite/extractorutils/unstable/core/runtime.py,sha256=vz9gE05u4UMn8QkGhc6ooPLo7ZTkGZGBzWY9kl0L2gk,9779
-cognite/extractorutils/unstable/core/tasks.py,sha256=x2JrLmTt6KiNC1DHN5o1F9UJNmlA-bA3h75o_6K1igM,594
+cognite/extractorutils/unstable/core/tasks.py,sha256=XvakIwp_zCV7XaWUgYT2z3LCGoQTljY0xdVJWFfm-ng,3158
 cognite/extractorutils/unstable/scheduling/__init__.py,sha256=L90_rCZNHvti-PInne0r7W9edIkifctELjiaxEoQiSc,67
-cognite/extractorutils/unstable/scheduling/_scheduler.py,sha256=YNUz7atHri4Sg0OHOX6RSmm74XqgdElJgxzWHH7o2YY,3703
+cognite/extractorutils/unstable/scheduling/_scheduler.py,sha256=jxr5gICz0nrLFr7PfplEWi1nrO5uW1NS-F9CH9v3eHs,3721
 cognite/extractorutils/unstable/scheduling/_schedules.py,sha256=y0NVeXYZOFcAyzBgAe8jqK0W-SZL5m99UwXAacGzqIw,677
 cognite/extractorutils/uploader/__init__.py,sha256=MgyvZojwLE-oUCZ0VALISd2rUCqShlyozxhzAKX5uj4,3396
 cognite/extractorutils/uploader/_base.py,sha256=WO8dftb7J9alEIuC4iOd8X3WliD1ODgjge6IFNimsxc,5300
@@ -39,11 +40,11 @@ cognite/extractorutils/uploader/_metrics.py,sha256=J2LJXb19L_SLSJ_voNIQHYLp0pjxU
 cognite/extractorutils/uploader/assets.py,sha256=a6LKbGjWh29Lj0PnL1bdhP88e27FKh8xfTFTsOBUOew,5713
 cognite/extractorutils/uploader/data_modeling.py,sha256=h4uRnppU2dVBquJz0Uy2SKNy5A1Gq-g7ZAlERu5vjIU,3614
 cognite/extractorutils/uploader/events.py,sha256=soU8TslPFIA7Ck4ATR_a7MHGitztRcn0cEt7LIbMPsE,5643
-cognite/extractorutils/uploader/files.py,sha256=U3wBU8iJNbOIP-JV_K3tRVHkB1gsb4lCjNlWbr-wg-0,26553
+cognite/extractorutils/uploader/files.py,sha256=ag3TUrImJdAUiOSXugagD03-9WGlFpIyd31z3WMJU20,27180
 cognite/extractorutils/uploader/raw.py,sha256=8duMk9uVJPK3O6C0nzwnvrl0UzBtJs_T_L1la0Vo89k,6713
 cognite/extractorutils/uploader/time_series.py,sha256=rs-jEChEZymxc98TYePpSRstPjQnDJd97vjOEYc-0-A,26568
 cognite/extractorutils/uploader/upload_failure_handler.py,sha256=wbUSXUP26rbmK2NGdQMzcWQwNOh2sXYOnlj0A_sk1n8,2003
-cognite_extractor_utils-7.5.8.dist-info/METADATA,sha256=Jsxfo92QSUGRF1vYTuZp221WHGgM5y0xIwHlLZ6nj5k,5272
-cognite_extractor_utils-7.5.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_extractor_utils-7.5.8.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-cognite_extractor_utils-7.5.8.dist-info/RECORD,,
+cognite_extractor_utils-7.5.10.dist-info/METADATA,sha256=cSWsbtpDLUv9uUtC_9lLcuBwv1oBW_3XiDVIXXOSFyo,5280
+cognite_extractor_utils-7.5.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_extractor_utils-7.5.10.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+cognite_extractor_utils-7.5.10.dist-info/RECORD,,