cognite-extractor-utils 5.0.1__py3-none-any.whl → 5.2.0__py3-none-any.whl

cognite/extractorutils/uploader/time_series.py

@@ -15,14 +15,15 @@
 import math
 import threading
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from types import TracebackType
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
 
 import arrow
+from requests import ConnectionError
+
 from cognite.client import CogniteClient
 from cognite.client.data_classes import Sequence, SequenceData, TimeSeries
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
-from requests import ConnectionError
-
 from cognite.extractorutils.uploader._base import (
     RETRIES,
     RETRY_BACKOFF_FACTOR,
@@ -48,9 +49,7 @@ MAX_DATAPOINT_STRING_LENGTH = 255
 MAX_DATAPOINT_VALUE = 1e100
 MIN_DATAPOINT_VALUE = -1e100
 
-DataPoint = Union[
-    Dict[str, Union[int, float, str, datetime]], Tuple[Union[int, float, datetime], Union[int, float, str]]
-]
+DataPoint = Tuple[Union[int, float, datetime], Union[int, float, str]]
 DataPointList = List[DataPoint]
 
 
@@ -66,7 +65,7 @@ def default_time_series_factory(external_id: str, datapoints: DataPointList) ->
         A TimeSeries object with external_id set, and the is_string automatically detected
     """
     is_string = (
-        isinstance(datapoints[0].get("value"), str)
+        isinstance(datapoints[0].get("value"), str)  # type: ignore  # input might be dict to keep compatibility
         if isinstance(datapoints[0], dict)
         else isinstance(datapoints[0][1], str)
     )
@@ -118,6 +117,8 @@ 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
@@ -125,7 +126,7 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
             self.create_missing = True
             self.missing_factory = create_missing
 
-        self.upload_queue: Dict[EitherId, DataPointList] = dict()
+        self.upload_queue: Dict[EitherId, DataPointList] = {}
 
         self.points_queued = TIMESERIES_UPLOADER_POINTS_QUEUED
         self.points_written = TIMESERIES_UPLOADER_POINTS_WRITTEN
@@ -134,19 +135,23 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         self.latency_zero_point = arrow.utcnow()
         self.data_set_id = data_set_id
 
-    def _verify_datapoint_time(self, time: Union[int, float, datetime]) -> bool:
+    def _verify_datapoint_time(self, time: Union[int, float, datetime, str]) -> bool:
         if isinstance(time, int) or isinstance(time, float):
             return not math.isnan(time) and time >= MIN_DATAPOINT_TIMESTAMP
+        elif isinstance(time, str):
+            return False
         else:
             return time.timestamp() * 1000.0 >= MIN_DATAPOINT_TIMESTAMP
 
-    def _verify_datapoint_value(self, value: Union[int, float, str]) -> bool:
+    def _verify_datapoint_value(self, value: Union[int, float, datetime, str]) -> bool:
         if isinstance(value, float):
             return not (
                 math.isnan(value) or math.isinf(value) or value > MAX_DATAPOINT_VALUE or value < MIN_DATAPOINT_VALUE
             )
         elif isinstance(value, str):
             return len(value) <= MAX_DATAPOINT_STRING_LENGTH
+        elif isinstance(value, datetime):
+            return False
         else:
             return True
 
@@ -154,14 +159,16 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         self,
         dp: DataPoint,
     ) -> bool:
-        if isinstance(dp, Dict):
+        if isinstance(dp, dict):
             return self._verify_datapoint_time(dp["timestamp"]) and self._verify_datapoint_value(dp["value"])
-        elif isinstance(dp, Tuple):
+        elif isinstance(dp, tuple):
             return self._verify_datapoint_time(dp[0]) and self._verify_datapoint_value(dp[1])
         else:
             return True
 
-    def add_to_upload_queue(self, *, id: int = None, external_id: str = None, datapoints: DataPointList = []) -> None:
+    def add_to_upload_queue(
+        self, *, id: Optional[int] = None, external_id: Optional[str] = None, datapoints: DataPointList = []
+    ) -> None:
         """
         Add data points to upload queue. The queue will be uploaded if the queue size is larger than the threshold
         specified in the __init__.
@@ -236,7 +243,7 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         max_delay=RETRY_MAX_DELAY,
         backoff=RETRY_BACKOFF_FACTOR,
     )
-    def _upload_batch(self, upload_this: List[Dict], retries=5) -> List[Dict]:
+    def _upload_batch(self, upload_this: List[Dict], retries: int = 5) -> List[Dict]:
         if len(upload_this) == 0:
             return upload_this
 
@@ -276,8 +283,9 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
 
                 if len(ex.not_found) != len(create_these_ids):
                     missing = [id_dict for id_dict in ex.not_found if id_dict.get("externalId") not in retry_these]
+                    missing_num = len(ex.not_found) - len(create_these_ids)
                     self.logger.error(
-                        f"{len(ex.not_found) - len(create_these_ids)} time series not found, and could not be created automatically:\n"
+                        f"{missing_num} time series not found, and could not be created automatically:\n"
                         + str(missing)
                         + "\nData will be dropped"
                     )
@@ -304,7 +312,9 @@ class TimeSeriesUploadQueue(AbstractUploadQueue):
         self.start()
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> None:
         """
         Wraps around stop method, for use as context manager
 
@@ -334,14 +344,14 @@ class SequenceUploadQueue(AbstractUploadQueue):
         max_upload_interval: Optional[int] = None,
         trigger_log_level: str = "DEBUG",
         thread_name: Optional[str] = None,
-        create_missing=False,
+        create_missing: bool = False,
         cancellation_token: threading.Event = threading.Event(),
     ):
         """
         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 the events that were uploaded.
+            post_upload_function: A function that will be called after each upload. The function will be given one
+                argument: A list of the events that were uploaded.
             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).
@@ -360,15 +370,15 @@ class SequenceUploadQueue(AbstractUploadQueue):
             thread_name,
             cancellation_token,
         )
-        self.upload_queue: Dict[EitherId, SequenceData] = dict()
-        self.sequence_metadata: Dict[EitherId, Dict[str, Union[str, int, float]]] = dict()
-        self.sequence_asset_external_ids: Dict[EitherId, str] = dict()
-        self.sequence_dataset_external_ids: Dict[EitherId, str] = dict()
-        self.sequence_names: Dict[EitherId, str] = dict()
-        self.sequence_descriptions: Dict[EitherId, str] = dict()
-        self.column_definitions: Dict[EitherId, List[Dict[str, str]]] = dict()
-        self.asset_ids: Dict[str, int] = dict()
-        self.dataset_ids: Dict[str, int] = dict()
+        self.upload_queue: Dict[EitherId, SequenceData] = {}
+        self.sequence_metadata: Dict[EitherId, Dict[str, Union[str, int, float]]] = {}
+        self.sequence_asset_external_ids: Dict[EitherId, str] = {}
+        self.sequence_dataset_external_ids: Dict[EitherId, str] = {}
+        self.sequence_names: Dict[EitherId, str] = {}
+        self.sequence_descriptions: Dict[EitherId, str] = {}
+        self.column_definitions: Dict[EitherId, List[Dict[str, str]]] = {}
+        self.asset_ids: Dict[str, int] = {}
+        self.dataset_ids: Dict[str, int] = {}
         self.create_missing = create_missing
 
         self.points_queued = SEQUENCES_UPLOADER_POINTS_QUEUED
@@ -380,12 +390,12 @@ class SequenceUploadQueue(AbstractUploadQueue):
     def set_sequence_metadata(
         self,
         metadata: Dict[str, Union[str, int, float]],
-        id: int = None,
-        external_id: str = None,
-        asset_external_id: str = None,
-        dataset_external_id: str = None,
-        name: str = None,
-        description: str = None,
+        id: Optional[int] = None,
+        external_id: Optional[str] = None,
+        asset_external_id: Optional[str] = None,
+        dataset_external_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
     ) -> None:
         """
         Set sequence metadata. Metadata will be cached until the sequence is created. The metadata will be updated
@@ -404,13 +414,17 @@ class SequenceUploadQueue(AbstractUploadQueue):
         """
         either_id = EitherId(id=id, external_id=external_id)
         self.sequence_metadata[either_id] = metadata
-        self.sequence_asset_external_ids[either_id] = asset_external_id
-        self.sequence_dataset_external_ids[either_id] = dataset_external_id
-        self.sequence_names[either_id] = name
-        self.sequence_descriptions[either_id] = description
+        if asset_external_id:
+            self.sequence_asset_external_ids[either_id] = asset_external_id
+        if dataset_external_id:
+            self.sequence_dataset_external_ids[either_id] = dataset_external_id
+        if name:
+            self.sequence_names[either_id] = name
+        if description:
+            self.sequence_descriptions[either_id] = description
 
     def set_sequence_column_definition(
-        self, col_def: List[Dict[str, str]], id: int = None, external_id: str = None
+        self, col_def: List[Dict[str, str]], id: Optional[int] = None, external_id: Optional[str] = None
     ) -> None:
         """
         Set sequence column definition
@@ -434,8 +448,8 @@ class SequenceUploadQueue(AbstractUploadQueue):
             SequenceData,
         ],
         column_external_ids: Optional[List[dict]] = None,
-        id: int = None,
-        external_id: str = None,
+        id: Optional[int] = None,
+        external_id: Optional[str] = None,
     ) -> None:
         """
         Add sequence rows to upload queue. Mirrors implementation of SequenceApi.insert. Inserted rows will be
@@ -462,13 +476,13 @@ class SequenceUploadQueue(AbstractUploadQueue):
         elif isinstance(rows, dict):
             rows = [{"rowNumber": row_number, "values": values} for row_number, values in rows.items()]
 
-            rows = SequenceData(id=id, external_id=id, rows=rows, columns=column_external_ids)
+            rows = SequenceData(id=id, external_id=id, rows=rows, columns=column_external_ids)  # type: ignore
 
         elif isinstance(rows, list):
             if isinstance(rows[0], tuple) or isinstance(rows[0], list):
                 rows = [{"rowNumber": row_number, "values": values} for row_number, values in rows]
 
-            rows = SequenceData(id=id, external_id=id, rows=rows, columns=column_external_ids)
+            rows = SequenceData(id=id, external_id=id, rows=rows, columns=column_external_ids)  # type: ignore
         else:
             raise TypeError("Unsupported type for sequence rows: {}".format(type(rows)))
 
@@ -476,8 +490,8 @@ class SequenceUploadQueue(AbstractUploadQueue):
             seq = self.upload_queue.get(either_id)
             if seq is not None:
                 # Update sequence
-                seq.values.extend(rows.values)
-                seq.row_numbers.extend(rows.row_numbers)
+                seq.values.extend(rows.values)  # type: ignore  # type is list, mypy is wrong
+                seq.row_numbers.extend(rows.row_numbers)  # type: ignore
 
                 self.upload_queue[either_id] = seq
             else:
@@ -517,7 +531,7 @@ class SequenceUploadQueue(AbstractUploadQueue):
             self.queue_size.set(self.upload_queue_size)
 
     @retry(
-        exceptions=CogniteAPIError,
+        exceptions=[CogniteAPIError],
         tries=RETRIES,
         delay=RETRY_DELAY,
         max_delay=RETRY_MAX_DELAY,
@@ -528,7 +542,10 @@ class SequenceUploadQueue(AbstractUploadQueue):
 
         try:
             self.cdf_client.sequences.data.insert(
-                id=either_id.internal_id, external_id=either_id.external_id, rows=upload_this, column_external_ids=None
+                id=either_id.internal_id,  # type: ignore
+                external_id=either_id.external_id,  # type: ignore
+                rows=upload_this,
+                column_external_ids=None,
             )
         except CogniteNotFoundError as ex:
             if self.create_missing:
@@ -537,8 +554,8 @@ class SequenceUploadQueue(AbstractUploadQueue):
 
                 # Retry
                 self.cdf_client.sequences.data.insert(
-                    id=either_id.internal_id,
-                    external_id=either_id.external_id,
+                    id=either_id.internal_id,  # type: ignore
+                    external_id=either_id.external_id,  # type: ignore
                     rows=upload_this,
                     column_external_ids=None,
                 )
@@ -556,24 +573,29 @@ class SequenceUploadQueue(AbstractUploadQueue):
         """
 
         column_def = self.column_definitions.get(either_id)
+        if column_def is None:
+            self.logger.error(f"Can't create sequence {str(either_id)}, no column definitions provided")
 
         try:
             seq = self.cdf_client.sequences.create(
                 Sequence(
-                    id=either_id.internal_id,
-                    external_id=either_id.external_id,
-                    name=self.sequence_names.get(either_id, None),
-                    description=self.sequence_descriptions.get(either_id, None),
-                    metadata=self.sequence_metadata.get(either_id, None),
-                    asset_id=self.asset_ids.get(self.sequence_asset_external_ids.get(either_id, None), None),
-                    data_set_id=self.dataset_ids.get(self.sequence_dataset_external_ids.get(either_id, None), None),
-                    columns=column_def,
+                    id=either_id.internal_id,  # type: ignore  # these are optional, the SDK types are wrong
+                    external_id=either_id.external_id,  # type: ignore
+                    name=self.sequence_names.get(either_id, None),  # type: ignore
+                    description=self.sequence_descriptions.get(either_id, None),  # type: ignore
+                    metadata=self.sequence_metadata.get(either_id, None),  # type: ignore
+                    asset_id=self.asset_ids.get(self.sequence_asset_external_ids.get(either_id, None), None),  # type: ignore
+                    data_set_id=self.dataset_ids.get(self.sequence_dataset_external_ids.get(either_id, None), None),  # type: ignore
+                    columns=column_def,  # type: ignore  # We already  checked for None, mypy is wrong
                 )
             )
 
         except CogniteDuplicatedError:
             self.logger.info("Sequnce already exist: {}".format(either_id))
-            seq = self.cdf_client.sequences.retrieve(id=either_id.internal_id, external_id=either_id.external_id)
+            seq = self.cdf_client.sequences.retrieve(
+                id=either_id.internal_id,  # type: ignore  # these are optional, the SDK types are wrong
+                external_id=either_id.external_id,  # type: ignore
+            )
 
         # Update definition of cached sequence
         cseq = self.upload_queue[either_id]
@@ -584,7 +606,7 @@ class SequenceUploadQueue(AbstractUploadQueue):
         Resolve id of assets if specified, for use in sequence creation
         """
         assets = set(self.sequence_asset_external_ids.values())
-        assets.discard(None)
+        assets.discard(None)  # type: ignore  # safeguard, remove Nones if any
 
         if len(assets) > 0:
             try:
@@ -596,14 +618,14 @@ class SequenceUploadQueue(AbstractUploadQueue):
                 }
             except Exception as e:
                 self.logger.error("Error in resolving asset id: %s", str(e))
-                self.asset_ids = dict()
+                self.asset_ids = {}
 
     def _resolve_dataset_ids(self) -> None:
         """
         Resolve id of datasets if specified, for use in sequence creation
         """
         datasets = set(self.sequence_dataset_external_ids.values())
-        datasets.discard(None)
+        datasets.discard(None)  # type: ignore  # safeguard, remove Nones if any
 
         if len(datasets) > 0:
             try:
@@ -615,7 +637,7 @@ class SequenceUploadQueue(AbstractUploadQueue):
                 }
             except Exception as e:
                 self.logger.error("Error in resolving dataset id: %s", str(e))
-                self.dataset_ids = dict()
+                self.dataset_ids = {}
 
     def __enter__(self) -> "SequenceUploadQueue":
         """
@@ -627,7 +649,9 @@ class SequenceUploadQueue(AbstractUploadQueue):
         self.start()
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> None:
         """
         Wraps around stop method, for use as context manager
 

cognite/extractorutils/uploader_extractor.py

@@ -15,14 +15,14 @@
 """
 A module containing a slightly more advanced base extractor class, sorting a generic output into upload queues.
 """
-
+import threading
 from dataclasses import dataclass
 from types import TracebackType
-from typing import Callable, Iterable, List, Optional, Type, TypeVar
+from typing import Any, Callable, Iterable, List, Optional, Type, TypeVar
 
-from cognite.client import CogniteClient
 from more_itertools import peekable
 
+from cognite.client import CogniteClient
 from cognite.extractorutils.base import Extractor
 from cognite.extractorutils.configtools import BaseConfig, TimeIntervalConfig
 from cognite.extractorutils.metrics import BaseMetrics
@@ -78,12 +78,12 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         description: str,
         version: Optional[str] = None,
         run_handle: Optional[
-            Callable[[CogniteClient, AbstractStateStore, UploaderExtractorConfigClass, Event], None]
+            Callable[[CogniteClient, AbstractStateStore, UploaderExtractorConfigClass, threading.Event], None]
         ] = None,
         config_class: Type[UploaderExtractorConfigClass],
         metrics: Optional[BaseMetrics] = None,
         use_default_state_store: bool = True,
-        cancellation_token: Event = Event(),
+        cancellation_token: threading.Event = threading.Event(),
         config_file_path: Optional[str] = None,
         continuous_extractor: bool = False,
         heartbeat_waiting_time: int = 600,
@@ -107,10 +107,9 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         self.middleware = middleware if isinstance(middleware, list) else []
 
     def handle_output(self, output: CdfTypes) -> None:
-        if not isinstance(output, Iterable):
-            output = [output]
+        list_output = [output] if not isinstance(output, Iterable) else output
+        peekable_output = peekable(list_output)
 
-        peekable_output = peekable(output)
         peek = peekable_output.peek(None)
 
         if peek is None:
@@ -133,7 +132,7 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         else:
             raise ValueError(f"Unexpected type: {type(peek)}")
 
-    def _apply_middleware(self, item):
+    def _apply_middleware(self, item: Any) -> Any:
         for mw in self.middleware:
             item = mw(item)
         return item

cognite/extractorutils/util.py

@@ -23,12 +23,13 @@ import threading
 from functools import partial, wraps
 from threading import Event, Thread
 from time import time
-from typing import Any, Dict, Generator, Iterable, Optional, Tuple, Type, Union
+from typing import Any, Callable, Generator, Iterable, Optional, Tuple, Type, TypeVar, Union
+
+from decorator import decorator
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import Asset, ExtractionPipelineRun, TimeSeries
 from cognite.client.exceptions import CogniteNotFoundError
-from decorator import decorator
 
 
 def _ensure(endpoint: Any, items: Iterable[Any]) -> None:
@@ -80,7 +81,7 @@ def set_event_on_interrupt(stop_event: Event) -> None:
         stop_event: Event to set
     """
 
-    def sigint_handler(sig, frame):
+    def sigint_handler(sig_num: int, frame: Any) -> None:
         logger = logging.getLogger(__name__)
         logger.warning("Interrupt signal received, stopping extractor gracefully")
         stop_event.set()
@@ -106,7 +107,7 @@ class EitherId:
         TypeError: If none of both of id types are set.
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Union[int, str, None]):
         internal_id = kwargs.get("id")
         external_id = kwargs.get("externalId") or kwargs.get("external_id")
 
@@ -116,8 +117,14 @@ class EitherId:
         if internal_id is not None and external_id is not None:
             raise TypeError("Only one of id and external_id can be set")
 
-        self.internal_id = internal_id
-        self.external_id = external_id
+        if internal_id is not None and not isinstance(internal_id, int):
+            raise TypeError("Internal IDs must be integers")
+
+        if external_id is not None and not isinstance(external_id, str):
+            raise TypeError("Internal IDs must be integers")
+
+        self.internal_id: Optional[int] = internal_id
+        self.external_id: Optional[str] = external_id
 
     def type(self) -> str:
         """
@@ -135,7 +142,7 @@ class EitherId:
         Returns:
             The ID
         """
-        return self.internal_id or self.external_id
+        return self.internal_id or self.external_id  # type: ignore  # checked to be not None in init
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -180,12 +187,15 @@ class EitherId:
         return self.__str__()
 
 
+_T1 = TypeVar("_T1")
+
+
 def add_extraction_pipeline(
     extraction_pipeline_ext_id: str,
     cognite_client: CogniteClient,
     heartbeat_waiting_time: int = 600,
     added_message: str = "",
-):
+) -> Callable[[Callable[..., _T1]], Callable[..., _T1]]:
     """
     This is to be used as a decorator for extractor functions to add extraction pipeline information
 
@@ -214,9 +224,9 @@ def add_extraction_pipeline(
 
     _logger = logging.getLogger(__name__)
 
-    def decorator_ext_pip(input_function):
+    def decorator_ext_pip(input_function: Callable[..., _T1]) -> Callable[..., _T1]:
         @wraps(input_function)
-        def wrapper_ext_pip(*args, **kwargs):
+        def wrapper_ext_pip(*args: Any, **kwargs: Any) -> _T1:
             ##############################
             # Setup Extraction Pipelines #
             ##############################
@@ -256,6 +266,7 @@ def add_extraction_pipeline(
             ##############################
             _logger.info(f"Starting to run function: {input_function.__name__}")
 
+            heartbeat_thread: Optional[Thread] = None
             try:
                 heartbeat_thread = Thread(target=heartbeat_loop, name="HeartbeatLoop", daemon=True)
                 heartbeat_thread.start()
@@ -266,10 +277,11 @@ def add_extraction_pipeline(
                 raise e
             else:
                 _report_success()
-                _logger.info(f"Extraction ran successfully")
+                _logger.info("Extraction ran successfully")
             finally:
                 cancellation_token.set()
-                heartbeat_thread.join()
+                if heartbeat_thread:
+                    heartbeat_thread.join()
 
             return output
 
@@ -312,25 +324,28 @@ def throttled_loop(target_time: int, cancellation_token: Event) -> Generator[Non
             cancellation_token.wait(target_time - iteration_time)
 
 
+_T2 = TypeVar("_T2")
+
+
 def _retry_internal(
-    f,
+    f: Callable[..., _T2],
     cancellation_token: threading.Event = threading.Event(),
-    exceptions: Iterable[Type[Exception]] = Exception,
+    exceptions: Iterable[Type[Exception]] = [Exception],
     tries: int = -1,
     delay: float = 0,
     max_delay: Optional[float] = None,
     backoff: float = 1,
     jitter: Union[float, Tuple[float, float]] = 0,
-):
+) -> _T2:
     logger = logging.getLogger(__name__)
 
     while tries and not cancellation_token.is_set():
         try:
             return f()
-        except exceptions as e:
+        except exceptions as e:  # type: ignore  # Exception is an exception type, smh mypy
             tries -= 1
             if not tries:
-                raise
+                raise e
 
             if logger is not None:
                 logger.warning("%s, retrying in %s seconds...", e, delay)
@@ -346,16 +361,18 @@ def _retry_internal(
             if max_delay is not None:
                 delay = min(delay, max_delay)
 
+    return None  # type: ignore  # unreachable, we will have raised an exception before this
+
 
 def retry(
     cancellation_token: threading.Event = threading.Event(),
-    exceptions: Iterable[Type[Exception]] = Exception,
+    exceptions: Iterable[Type[Exception]] = [Exception],
     tries: int = -1,
     delay: float = 0,
     max_delay: Optional[float] = None,
     backoff: float = 1,
     jitter: Union[float, Tuple[float, float]] = 0,
-):
+) -> Callable[[Callable[..., _T2]], Callable[..., _T2]]:
     """
     Returns a retry decorator.
 
@@ -375,9 +392,9 @@ def retry(
     """
 
     @decorator
-    def retry_decorator(f, *fargs, **fkwargs):
-        args = fargs if fargs else list()
-        kwargs = fkwargs if fkwargs else dict()
+    def retry_decorator(f: Callable[..., _T2], *fargs: Any, **fkwargs: Any) -> _T2:
+        args = fargs if fargs else []
+        kwargs = fkwargs if fkwargs else {}
 
         return _retry_internal(
             partial(f, *args, **kwargs),

{cognite_extractor_utils-5.0.1.dist-info → cognite_extractor_utils-5.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-extractor-utils
-Version: 5.0.1
+Version: 5.2.0
 Summary: Utilities for easier development of extractors for CDF
 Home-page: https://github.com/cognitedata/python-extractor-utils
 License: Apache-2.0
@@ -121,4 +121,3 @@ Each public method, class and module should have docstrings. Docstrings are writ
 style](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings). Please include unit and/or
 integration tests for submitted code, and remember to update the [changelog](./CHANGELOG.md).
 
-

cognite_extractor_utils-5.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+cognite/extractorutils/__init__.py,sha256=YpHnq2cOlBjlfQGnnajBJHlP4R0tz1RhKjFUhN3Rp9s,739
+cognite/extractorutils/_inner_util.py,sha256=jCPLg-FfTpyLAHkhoKaKObNwbqm19d2Z11to_DYk5EU,1558
+cognite/extractorutils/base.py,sha256=ydDV0oUJH6W2S150P-PZxotnZGAwVGzKiKcpcCZdB0E,15974
+cognite/extractorutils/configtools/__init__.py,sha256=fj9kH8DdisNi9mI8cKm2sz50vnzeOkJQErIGB3mTYRo,2861
+cognite/extractorutils/configtools/_util.py,sha256=SZycZm_py9v9WZbDiDQbgS6_PiLtu-TtwuuH7tG2YCI,4739
+cognite/extractorutils/configtools/elements.py,sha256=BAfFrUrDwGPoyEMQeYySWRrqeIM_MrmLMyGPe-hrg0A,19910
+cognite/extractorutils/configtools/loaders.py,sha256=02eK2dp7zsIU7ZIsMY6o7H_VfaiQ312QzCGqTuAypbU,9545
+cognite/extractorutils/exceptions.py,sha256=PERRmySUfJRM2Ta8cFvADTe-KUdXsoMLKdk4140AOHI,1061
+cognite/extractorutils/metrics.py,sha256=HYW5oQIKd4Zk0ahIuRbxON9Y6LXJ7QODya_SWogNj0M,14929
+cognite/extractorutils/middleware.py,sha256=d5bnKEOmC49QmoBK7OyM9krOGDYX8sXxM00wRWKhmHg,1108
+cognite/extractorutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/extractorutils/statestore.py,sha256=F54IEgWUbAfeOWRPWiVEqQDUuqb_WaFdM0bzYNE-Sis,17829
+cognite/extractorutils/uploader/__init__.py,sha256=h9EAktLxNZjmZunFcK6Tngu6K7tQKwYTmNOkB4meCA8,3054
+cognite/extractorutils/uploader/_base.py,sha256=1MVzMEyuuYNlCAG7Hv1kPCzUOfVXhO2fA_sZYSGBLyY,4983
+cognite/extractorutils/uploader/_metrics.py,sha256=cF6EaixueFSSRw97O0HK3kEM7fX8AvNAUVz5xDyr4Yk,3865
+cognite/extractorutils/uploader/events.py,sha256=RmBQcHpImGJG3D7F0Ccb5aK7Ecy4mkF6GYk-UTLjp38,6118
+cognite/extractorutils/uploader/files.py,sha256=de6nny4yQiaSSEol8gE0KzYZ9srTKwjOTWVJztCnZH8,11674
+cognite/extractorutils/uploader/raw.py,sha256=B6B0B659Zfvhy9Tp_QrGi1wkwJw94Z6am5_YmFZFxvQ,7021
+cognite/extractorutils/uploader/time_series.py,sha256=gsMqwGYFS4wx3LF62URUMLx4PoCZb7MS3RWeWBQe2AM,26579
+cognite/extractorutils/uploader_extractor.py,sha256=cAseJZXBmE6feyHJNMGxXBfGbdGBmOyBTeU1ZC5Krmg,7476
+cognite/extractorutils/uploader_types.py,sha256=nztoOqdszm4BEDcCybdApub0zN3KEfwLgTDeP69Xdlk,1146
+cognite/extractorutils/util.py,sha256=6y-2ZWviLmPYSbEWu0_I8Oeuwz-4yK9EhE7FM1g_GX8,14284
+cognite_extractor_utils-5.2.0.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+cognite_extractor_utils-5.2.0.dist-info/METADATA,sha256=X0ig0LlZzWhFLMQenXn44XdKD-_YcMnT7-BakiNQFEk,5406
+cognite_extractor_utils-5.2.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+cognite_extractor_utils-5.2.0.dist-info/RECORD,,

cognite_extractor_utils-5.0.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-cognite/extractorutils/__init__.py,sha256=VsW0H6dGKBgnovfeKtFM9fsrkvp_XV6kslSkrpiIvmA,739
-cognite/extractorutils/_inner_util.py,sha256=idg6EZzcDIwCYJJVSvyyEq8M2QUyLvW4soJS1XTlFv4,1431
-cognite/extractorutils/base.py,sha256=_c7zF1_PDIwIA8lqvf0Du5vJyITYissOptBncvKY7Dg,15990
-cognite/extractorutils/configtools/__init__.py,sha256=qYBtB-wVwXV6mcdRe8xRclhF9AMADlaJaAJzTNuWT48,2861
-cognite/extractorutils/configtools/_util.py,sha256=XYNKaCD_mMgvFBxvLE_KwgvfTkgHZEzs1Wj7gL0WkpY,4294
-cognite/extractorutils/configtools/elements.py,sha256=2uT0_EeJaRbxGWBXWDWfkA8qYvpu8O8X-S2_maEeUpc,18506
-cognite/extractorutils/configtools/loaders.py,sha256=Q_aeaT-TxqRMuurLasTzbSsIq0I1cnnhcs3Zzw3-FNk,9188
-cognite/extractorutils/exceptions.py,sha256=PERRmySUfJRM2Ta8cFvADTe-KUdXsoMLKdk4140AOHI,1061
-cognite/extractorutils/metrics.py,sha256=QTIe6LIMZ8u77lImB1jXgvTvMf2mMOVPESeAZ1hA3dg,14604
-cognite/extractorutils/middleware.py,sha256=XelqIxmWBfpoDUt0cKvAXyDCYnjIFyKNHVJU4CYjXes,1005
-cognite/extractorutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/extractorutils/statestore.py,sha256=5nFkzPbrOYwlGOKyElwX-JJ1Zb9hhzJfWXyWeD-mlMs,17449
-cognite/extractorutils/uploader/__init__.py,sha256=h9EAktLxNZjmZunFcK6Tngu6K7tQKwYTmNOkB4meCA8,3054
-cognite/extractorutils/uploader/_base.py,sha256=K0pOIt-O_yIOJcpGZctm24kUsZgrvxG0L_YGw1DqHCQ,5240
-cognite/extractorutils/uploader/_metrics.py,sha256=cF6EaixueFSSRw97O0HK3kEM7fX8AvNAUVz5xDyr4Yk,3865
-cognite/extractorutils/uploader/events.py,sha256=xpxrcIpGwnKgXhfCJCovtWkl3QvHI9XZkhO6TAJBHXE,5292
-cognite/extractorutils/uploader/files.py,sha256=Mh5MxswyGjrteLd22yopWMPD036DGXc6_tibHYEnMU0,11351
-cognite/extractorutils/uploader/raw.py,sha256=wdVeyD4DoqY0eIk0fvWnAlfIXGbtG5EgWetOClbQGZU,6888
-cognite/extractorutils/uploader/time_series.py,sha256=qmamsSAJFUwX9adFgejEV_cGmjEhbTuiucIVIovj8U4,25071
-cognite/extractorutils/uploader_extractor.py,sha256=TwiRAqgVRheA-KKnxloBZvD1tZjuDGKVGuGbtvPtj8I,7404
-cognite/extractorutils/uploader_types.py,sha256=nztoOqdszm4BEDcCybdApub0zN3KEfwLgTDeP69Xdlk,1146
-cognite/extractorutils/util.py,sha256=NtqR6EGUDZmGjrfy8lnge83ITh1HzX4u_JtqGqNQb-4,13352
-cognite_extractor_utils-5.0.1.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-cognite_extractor_utils-5.0.1.dist-info/METADATA,sha256=HSvv1Zqkui1FNH0dpMtneo7rFybL6s5I3CtxRKaJZuE,5407
-cognite_extractor_utils-5.0.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-cognite_extractor_utils-5.0.1.dist-info/RECORD,,