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

cognite/extractorutils/unstable/core/runtime.py

@@ -28,9 +28,13 @@ import os
 import sys
 import time
 from argparse import ArgumentParser, Namespace
-from multiprocessing import Process, Queue
+from dataclasses import dataclass
+from logging.handlers import NTEventLogHandler as WindowsEventHandler
+from multiprocessing import Event, Process, Queue
+from multiprocessing.synchronize import Event as MpEvent
 from pathlib import Path
 from random import randint
+from threading import Thread
 from typing import Any, Generic, TypeVar
 from uuid import uuid4
 
@@ -44,24 +48,80 @@ from cognite.client.exceptions import (
     CogniteConnectionError,
 )
 from cognite.extractorutils.threading import CancellationToken
-from cognite.extractorutils.unstable.configuration.exceptions import InvalidConfigError
+from cognite.extractorutils.unstable.configuration.exceptions import InvalidArgumentError, InvalidConfigError
 from cognite.extractorutils.unstable.configuration.loaders import (
     load_file,
     load_from_cdf,
 )
-from cognite.extractorutils.unstable.configuration.models import ConnectionConfig
+from cognite.extractorutils.unstable.configuration.models import ConnectionConfig, ExtractorConfig
 from cognite.extractorutils.unstable.core._dto import Error
+from cognite.extractorutils.unstable.core.checkin_worker import CheckinWorker
 from cognite.extractorutils.unstable.core.errors import ErrorLevel
 from cognite.extractorutils.util import now
 
 from ._messaging import RuntimeMessage
-from .base import ConfigRevision, ConfigType, Extractor, FullConfig
+from .base import ConfigRevision, Extractor, FullConfig
 
 __all__ = ["ExtractorType", "Runtime"]
 
 ExtractorType = TypeVar("ExtractorType", bound=Extractor)
 
 
+@dataclass
+class _RuntimeControls:
+    cancel_event: MpEvent
+    message_queue: Queue
+
+
+def _extractor_process_entrypoint(
+    extractor_class: type[Extractor],
+    controls: _RuntimeControls,
+    config: FullConfig,
+    checkin_worker: CheckinWorker,
+) -> None:
+    logger = logging.getLogger(f"{extractor_class.EXTERNAL_ID}.runtime")
+    checkin_worker.active_revision = config.current_config_revision
+    checkin_worker.set_on_fatal_error_handler(lambda _: on_fatal_error(controls))
+    checkin_worker.set_on_revision_change_handler(lambda _: on_revision_changed(controls))
+    if config.application_config.retry_startup:
+        checkin_worker.set_retry_startup(config.application_config.retry_startup)
+    extractor = extractor_class._init_from_runtime(config, checkin_worker)
+    extractor._attach_runtime_controls(
+        cancel_event=controls.cancel_event,
+        message_queue=controls.message_queue,
+    )
+
+    try:
+        with extractor:
+            extractor.run()
+
+    except Exception:
+        logger.exception("Extractor crashed, will attempt restart")
+        controls.message_queue.put(RuntimeMessage.RESTART)
+
+
+def on_revision_changed(controls: _RuntimeControls) -> None:
+    """
+    Handle a change in the configuration revision.
+
+    Args:
+        controls(_RuntimeControls): The runtime controls containing the message queue and cancellation event.
+    """
+    controls.message_queue.put(RuntimeMessage.RESTART)
+    controls.cancel_event.set()
+
+
+def on_fatal_error(controls: _RuntimeControls) -> None:
+    """
+    Handle a fatal error in the extractor.
+
+    Args:
+        logger(logging.Logger): The logger to use for logging messages.
+        controls(_RuntimeControls): The runtime controls containing the message queue and cancellation event.
+    """
+    controls.cancel_event.set()
+
+
 class Runtime(Generic[ExtractorType]):
     """
     The runtime for an extractor.
@@ -82,6 +142,7 @@ class Runtime(Generic[ExtractorType]):
         self._message_queue: Queue[RuntimeMessage] = Queue()
         self.logger = logging.getLogger(f"{self._extractor_class.EXTERNAL_ID}.runtime")
         self._setup_logging()
+        self._cancel_event: MpEvent | None = None
 
         self._cognite_client: CogniteClient
 
@@ -113,11 +174,32 @@ class Runtime(Generic[ExtractorType]):
             default=None,
             help="Include to use a local application configuration instead of fetching it from CDF",
         )
+        argparser.add_argument(
+            "-l",
+            "--log-level",
+            choices=["debug", "info", "warning", "error", "critical"],
+            type=str,
+            required=False,
+            default=None,
+            help="Set the logging level for the runtime.",
+        )
         argparser.add_argument(
             "--skip-init-checks",
             action="store_true",
             help="Skip any checks during startup. Useful for debugging, not recommended for production deployments.",
         )
+        argparser.add_argument(
+            "--cwd",
+            nargs=1,
+            type=Path,
+            required=False,
+            help="Set the current working directory for the extractor.",
+        )
+        argparser.add_argument(
+            "--service",
+            action="store_true",
+            help="Run the extractor as a Windows service (only supported on Windows).",
+        )
 
         return argparser
 
@@ -138,31 +220,55 @@ class Runtime(Generic[ExtractorType]):
 
         root.addHandler(console_handler)
 
-    def _inner_run(
-        self,
-        message_queue: Queue,
-        config: FullConfig,
-    ) -> None:
-        # This code is run inside the new extractor process
-        extractor = self._extractor_class._init_from_runtime(config)
-        extractor._set_runtime_message_queue(message_queue)
+        if sys.platform == "win32":
+            try:
+                event_log_handler = WindowsEventHandler(self._extractor_class.NAME)
 
-        try:
-            with extractor:
-                extractor.run()
+                event_log_handler.setLevel(logging.INFO)
+                root.addHandler(event_log_handler)
 
-        except Exception:
-            self.logger.exception("Extractor crashed, will attempt restart")
-            message_queue.put(RuntimeMessage.RESTART)
+                self.logger.info("Windows Event Log handler enabled for startup.")
+            except ImportError:
+                self.logger.warning(
+                    "Failed to import the 'pywin32' package. This should install automatically on windows. "
+                    "Please try reinstalling to resolve this issue."
+                )
+            except Exception as e:
+                self.logger.warning(f"Failed to initialize Windows Event Log handler: {e}")
+
+    def _start_cancellation_watcher(self, mp_cancel_event: MpEvent) -> None:
+        """
+        Start the inter-process cancellation watcher thread.
+
+        This creates a daemon thread that waits for the runtime's CancellationToken
+        and sets the multiprocessing Event to signal the child process.
+        """
+
+        def cancellation_watcher() -> None:
+            """Waits for the runtime token and sets the shared event."""
+            self._cancellation_token.wait()
+            mp_cancel_event.set()
+
+        watcher_thread = Thread(target=cancellation_watcher, daemon=True, name="RuntimeCancelWatcher")
+        watcher_thread.start()
 
     def _spawn_extractor(
         self,
         config: FullConfig,
+        checkin_worker: CheckinWorker,
     ) -> Process:
-        self._message_queue = Queue()
+        self._cancel_event = Event()
+
+        self._start_cancellation_watcher(self._cancel_event)
+
+        controls = _RuntimeControls(
+            cancel_event=self._cancel_event,
+            message_queue=self._message_queue,
+        )
+
         process = Process(
-            target=self._inner_run,
-            args=(self._message_queue, config),
+            target=_extractor_process_entrypoint,
+            args=(self._extractor_class, controls, config, checkin_worker),
         )
 
         process.start()
@@ -173,15 +279,15 @@ class Runtime(Generic[ExtractorType]):
         self,
         args: Namespace,
         connection_config: ConnectionConfig,
-    ) -> tuple[ConfigType, ConfigRevision]:
+    ) -> tuple[ExtractorConfig, ConfigRevision]:
         current_config_revision: ConfigRevision
 
-        if args.local_override:
+        if args.force_local_config:
             self.logger.info("Loading local application config")
 
             current_config_revision = "local"
             try:
-                application_config = load_file(args.local_override[0], self._extractor_class.CONFIG_TYPE)
+                application_config = load_file(args.force_local_config[0], self._extractor_class.CONFIG_TYPE)
             except InvalidConfigError as e:
                 self.logger.critical(str(e))
                 raise e
@@ -194,17 +300,29 @@ class Runtime(Generic[ExtractorType]):
 
             application_config, current_config_revision = load_from_cdf(
                 self._cognite_client,
-                connection_config.integration,
+                connection_config.integration.external_id,
                 self._extractor_class.CONFIG_TYPE,
             )
 
         return application_config, current_config_revision
 
+    def _try_set_cwd(self, args: Namespace) -> None:
+        if args.cwd is not None and len(args.cwd) > 0:
+            try:
+                resolved_path = Path(args.cwd[0]).resolve(strict=True)
+                os.chdir(resolved_path)
+                self.logger.info(f"Changed working directory to {resolved_path}")
+            except (FileNotFoundError, OSError) as e:
+                self.logger.critical(f"Could not change working directory to {args.cwd[0]}: {e}")
+                raise InvalidArgumentError(f"Could not change working directory to {args.cwd[0]}: {e}") from e
+
+        self.logger.info(f"Using {os.getcwd()} as working directory")
+
     def _safe_get_application_config(
         self,
         args: Namespace,
         connection_config: ConnectionConfig,
-    ) -> tuple[ConfigType, ConfigRevision] | None:
+    ) -> tuple[ExtractorConfig, ConfigRevision] | None:
         prev_error: str | None = None
 
         while not self._cancellation_token.is_cancelled:
@@ -222,7 +340,7 @@ class Runtime(Generic[ExtractorType]):
                 ts = now()
                 error = Error(
                     external_id=str(uuid4()),
-                    level=ErrorLevel.fatal.value,
+                    level=ErrorLevel.fatal,
                     start_time=ts,
                     end_time=ts,
                     description=error_message,
@@ -233,8 +351,8 @@ class Runtime(Generic[ExtractorType]):
                 self._cognite_client.post(
                     f"/api/v1/projects/{self._cognite_client.config.project}/odin/checkin",
                     json={
-                        "externalId": connection_config.integration,
-                        "errors": [error.model_dump()],
+                        "externalId": connection_config.integration.external_id,
+                        "errors": [error.model_dump(mode="json")],
                     },
                     headers={"cdf-version": "alpha"},
                 )
@@ -251,7 +369,7 @@ class Runtime(Generic[ExtractorType]):
             self._cognite_client.post(
                 f"/api/v1/projects/{self._cognite_client.config.project}/odin/checkin",
                 json={
-                    "externalId": connection_config.integration,
+                    "externalId": connection_config.integration.external_id,
                 },
                 headers={"cdf-version": "alpha"},
             )
@@ -304,7 +422,47 @@ class Runtime(Generic[ExtractorType]):
 
         self.logger.info(f"Started runtime with PID {os.getpid()}")
 
+        if args.service and sys.platform == "win32":
+            # Import here to avoid dependency on non-Windows systems
+            try:
+                from simple_winservice import (  # type: ignore[import-not-found]
+                    ServiceHandle,
+                    register_service,
+                    run_service,
+                )
+            except ImportError:
+                self.logger.critical("simple-winservice library is not installed.")
+                sys.exit(1)
+
+            # Cancellation function for the service
+            def cancel_service() -> None:
+                self.logger.info("Service cancellation requested.")
+                self._cancellation_token.cancel()
+
+            # Wrap the main runtime loop in a function for the service
+            def service_main(handle: ServiceHandle, service_args: list[str]) -> None:
+                handle.event_log_info("Extractor Windows service is starting.")
+                try:
+                    self._main_runtime(args)
+                except Exception as exc:
+                    handle.event_log_error(f"Service crashed: {exc}")
+                    self.logger.critical(f"Service crashed: {exc}", exc_info=True)
+                    sys.exit(1)
+                handle.event_log_info("Extractor Windows service is stopping.")
+
+            # Register and run the service
+            register_service(service_main, self._extractor_class.NAME, cancel_service)
+            run_service()
+            return
+        elif args.service and sys.platform != "win32":
+            self.logger.critical("--service is only supported on Windows.")
+            sys.exit(1)
+
+        self._main_runtime(args)
+
+    def _main_runtime(self, args: Namespace) -> None:
         try:
+            self._try_set_cwd(args)
             connection_config = load_file(args.connection_config[0], ConnectionConfig)
         except InvalidConfigError as e:
             self.logger.error(str(e))
@@ -318,6 +476,15 @@ class Runtime(Generic[ExtractorType]):
         # exist yet, and I have not found a way to represent it in a generic way that isn't just an Any in disguise.
         application_config: Any
         config: tuple[Any, ConfigRevision] | None
+        cognite_client = connection_config.get_cognite_client(
+            f"{self._extractor_class.EXTERNAL_ID}-{self._extractor_class.VERSION}"
+        )
+
+        checkin_worker = CheckinWorker(
+            cognite_client,
+            connection_config.integration.external_id,
+            self.logger,
+        )
 
         while not self._cancellation_token.is_cancelled:
             config = self._safe_get_application_config(args, connection_config)
@@ -334,7 +501,9 @@ class Runtime(Generic[ExtractorType]):
                     connection_config=connection_config,
                     application_config=application_config,
                     current_config_revision=current_config_revision,
-                )
+                    log_level_override=args.log_level,
+                ),
+                checkin_worker,
             )
             process.join()
 

cognite/extractorutils/unstable/core/tasks.py

@@ -28,7 +28,7 @@ class TaskContext(CogniteLogger):
     This class is used to log errors and messages related to the task execution.
     """
 
-    def __init__(self, task: "Task", extractor: "Extractor"):
+    def __init__(self, task: "Task", extractor: "Extractor") -> None:
         super().__init__()
         self._task = task
         self._extractor = extractor
@@ -87,7 +87,7 @@ class ScheduledTask(_Task):
         target: TaskTarget,
         description: str | None = None,
         schedule: ScheduleConfig,
-    ):
+    ) -> None:
         super().__init__(name=name, target=target, description=description)
         self.schedule = schedule
 

cognite/extractorutils/uploader/_base.py

@@ -50,7 +50,7 @@ class AbstractUploadQueue(ABC):
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         self.cdf_client = cdf_client
 
         self.threshold = max_queue_size if max_queue_size is not None else -1

cognite/extractorutils/uploader/assets.py

@@ -64,7 +64,7 @@ class AssetUploadQueue(AbstractUploadQueue):
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         super().__init__(
             cdf_client,
             post_upload_function,

cognite/extractorutils/uploader/data_modeling.py

@@ -50,7 +50,7 @@ class InstanceUploadQueue(AbstractUploadQueue):
         auto_create_start_nodes: bool = True,
         auto_create_end_nodes: bool = True,
         auto_create_direct_relations: bool = True,
-    ):
+    ) -> None:
         super().__init__(
             cdf_client,
             post_upload_function,

cognite/extractorutils/uploader/events.py

@@ -62,7 +62,7 @@ class EventUploadQueue(AbstractUploadQueue):
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client,

cognite/extractorutils/uploader/files.py

@@ -103,13 +103,13 @@ class ChunkedStream(RawIOBase, BinaryIO):
     # resolve the same way. These four useless methods with liberal use of Any are
     # required to satisfy mypy.
     # This may be solvable by changing the typing in the python SDK to use typing.Protocol.
-    def writelines(self, __lines: Any) -> None:
+    def writelines(self, __lines: Any) -> None:  # noqa: ANN401
         """
         Not supported for ChunkedStream.
         """
         raise NotImplementedError()
 
-    def write(self, __b: Any) -> int:
+    def write(self, __b: Any) -> int:  # noqa: ANN401
         """
         Not supported for ChunkedStream.
         """
@@ -250,7 +250,7 @@ class IOFileUploadQueue(AbstractUploadQueue):
         max_parallelism: int | None = None,
         failure_logging_path: None | str = None,
         ssl_verify: bool | str = True,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client,
@@ -696,7 +696,7 @@ class FileUploadQueue(IOFileUploadQueue):
         overwrite_existing: bool = False,
         cancellation_token: CancellationToken | None = None,
         ssl_verify: bool | str = True,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client=cdf_client,

cognite/extractorutils/uploader/raw.py

@@ -67,7 +67,7 @@ class RawUploadQueue(AbstractUploadQueue):
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         # Super sets post_upload and thresholds
         super().__init__(
             cdf_client,

cognite/extractorutils/uploader/time_series.py

@@ -122,7 +122,7 @@ class BaseTimeSeriesUploadQueue(AbstractUploadQueue, Generic[IdType]):
         trigger_log_level: str = "DEBUG",
         thread_name: str | None = None,
         cancellation_token: CancellationToken | None = None,
-    ):
+    ) -> None:
         # Super sets post_upload and threshold
         super().__init__(
             cdf_client,
@@ -248,7 +248,7 @@ class TimeSeriesUploadQueue(BaseTimeSeriesUploadQueue[EitherId]):
         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,
@@ -429,7 +429,7 @@ class CDMTimeSeriesUploadQueue(BaseTimeSeriesUploadQueue[NodeId]):
         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,
@@ -636,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

@@ -105,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,
@@ -165,7 +165,7 @@ class UploaderExtractor(Extractor[UploaderExtractorConfigClass]):
         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

cognite/extractorutils/uploader_types.py

@@ -18,7 +18,7 @@ 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
@@ -29,7 +29,7 @@ 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]):
+    def __init__(self, *, instance_id: NodeId, datapoints: list[DataPoint]) -> None:
         self.instance_id = instance_id
         self.datapoints = datapoints
 
@@ -39,7 +39,7 @@ 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.7.0.dist-info → cognite_extractor_utils-7.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-extractor-utils
-Version: 7.7.0
+Version: 7.8.1
 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,9 +12,9 @@ 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: dacite<1.10.0,>=1.9.2
 Requires-Dist: decorator>=5.1.1
 Requires-Dist: httpx<1,>=0.27.0
 Requires-Dist: jsonlines>=4.0.0
@@ -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'