splight-lib 4.3.7__tar.gz → 4.4.0__tar.gz

{splight_lib-4.3.7 → splight_lib-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: splight-lib
-Version: 4.3.7
+Version: 4.4.0
 Summary: Splight Library
 Author: Splight Dev
 Author-email: dev@splight-ae.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: apscheduler (==3.10.4)
 Requires-Dist: concurrent-log-handler (==0.9.21)
 Requires-Dist: cryptography (==35.0.0)
 Requires-Dist: email-validator (>=2.1.0.post1,<3.0.0)
@@ -37,17 +38,33 @@ Requires-Dist: stringcase (==1.2.0)
 Requires-Dist: typing-extensions (>=4.6.1,<5.0.0)
 Description-Content-Type: text/markdown
 
-[![Lib upload](https://github.com/splightplatform/splight-lib/actions/workflows/libupload.yml/badge.svg)](https://github.com/splightplatform/splight-lib/actions/workflows/libupload.yml)
+# Splight Python SDK
 
-## How to install
+## Installation
 
-For development
+A release version can be installed using `pip` with
 
-- `make install`
+```bash 
+pip install --upgrade splight-lib
+```
+
+or if you want one particular version you can use
+```bash 
+pip install splight-lib==x.y.z
+```
 
-For productive envs.
+### For Development
 
-- `python setup.py install`
+To install the library in development mode you need to have `poetry` installed
+```bash
+pip install poetry==1.7.0
+```
+
+Then to insall the library you can use the command
+
+```bash
+poetry install
+```
 
 ## Tests
 

splight_lib-4.4.0/README.md

@@ -0,0 +1,33 @@
+# Splight Python SDK
+
+## Installation
+
+A release version can be installed using `pip` with
+
+```bash 
+pip install --upgrade splight-lib
+```
+
+or if you want one particular version you can use
+```bash 
+pip install splight-lib==x.y.z
+```
+
+### For Development
+
+To install the library in development mode you need to have `poetry` installed
+```bash
+pip install poetry==1.7.0
+```
+
+Then to insall the library you can use the command
+
+```bash
+poetry install
+```
+
+## Tests
+
+```
+make test
+```

{splight_lib-4.3.7 → splight_lib-4.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "splight-lib"
-version = "4.3.7"
+version = "4.4.0"
 description = "Splight Library"
 authors = ["Splight Dev <dev@splight-ae.com>"]
 readme = "README.md"
@@ -32,6 +32,7 @@ stringcase = "1.2.0"
 typing-extensions = "^4.6.1"
 pydantic-settings = "2.0.3"
 email-validator = "^2.1.0.post1"
+apscheduler = "3.10.4"
 
 [tool.poetry.group.dev.dependencies]
 black = "23.3.0"

{splight_lib-4.3.7 → splight_lib-4.4.0}/splight_lib/component/abstract.py

@@ -2,41 +2,21 @@ import os
 import sys
 from abc import ABC, abstractmethod
 from collections import namedtuple
-from functools import partial
 from tempfile import NamedTemporaryFile
+from threading import Thread
 from time import sleep
-from typing import Callable, Dict, List, Optional, Type
+from typing import Callable, Dict, Optional, Type
 
 from pydantic import BaseModel
 
-from splight_lib.client.communication import RemoteCommunicationClient
-from splight_lib.communication.event_handler import (
-    command_event_handler,
-    database_object_event_handler,
-)
-from splight_lib.component.exceptions import (
-    InvalidBidingObject,
-    MissingBindingCallback,
-    MissingCommandCallback,
-    MissingRoutineCallback,
-)
 from splight_lib.component.spec import Spec
-
-# TODO: Use builder pattern
-from splight_lib.execution import ExecutionClient, Thread
+from splight_lib.execution.engine import EngineStatus, ExecutionEngine
 from splight_lib.logging._internal import LogTags, get_splight_logger
 from splight_lib.models.component import (
-    DB_MODEL_TYPE_MAPPING,
-    Binding,
-    Command,
     ComponentObjectInstance,
-    Routine,
-    RoutineObject,
     RoutineObjectInstance,
 )
-from splight_lib.models.event import EventNames
 from splight_lib.restclient import ConnectError, HTTPError, Timeout
-from splight_lib.settings import settings
 
 REQUEST_EXCEPTIONS = (ConnectError, HTTPError, Timeout)
 logger = get_splight_logger("Base Component")
@@ -47,7 +27,7 @@ class HealthCheckProcessor:
     _HEALTH_FILE_PREFIX = "healthy_"
     _STARTUP_FILE_PREFIX = "ready_"
 
-    def __init__(self, engine: ExecutionClient):
+    def __init__(self, engine: ExecutionEngine):
         self._logger = get_splight_logger("HealthCheckProcessor")
         self._engine = engine
         self._health_file = NamedTemporaryFile(prefix=self._HEALTH_FILE_PREFIX)
@@ -68,11 +48,9 @@ class HealthCheckProcessor:
 
     def start(self):
         self._running = True
+        # Check when there is no task in engine
         while self._running:
-            is_alive, status = self._engine.healthcheck()
-            if not is_alive:
-                exc = self._engine.get_last_exception()
-                self._log_exception(exc)
+            if not self._engine.running:
                 self._logger.info("Healthcheck finished", tags=LogTags.RUNTIME)
                 self._health_file.close()
                 self._logger.info(
@@ -86,13 +64,6 @@ class HealthCheckProcessor:
     def stop(self):
         self._running = False
 
-    def _log_exception(self, exc: Optional[Exception]) -> None:
-        """Logs the exception and the traceback."""
-        if exc:
-            stack = exc.__traceback__
-            exc_type = type(exc)
-            self._logger.exception(exc, exc_info=(exc_type, exc, stack))
-
 
 class SplightBaseComponent(ABC):
     def __init__(
@@ -100,18 +71,12 @@ class SplightBaseComponent(ABC):
         component_id: Optional[str] = None,
     ):
         self._component_id = component_id
-
-        # TODO: Change to use builder patter
-        self._comm_client = RemoteCommunicationClient(
-            url=settings.SPLIGHT_PLATFORM_API_HOST,
-            access_id=settings.SPLIGHT_ACCESS_ID,
-            secret_key=settings.SPLIGHT_SECRET_KEY,
-            instance_id=component_id,
-        )
-        self._execution_engine = ExecutionClient()
+        self._execution_engine = ExecutionEngine()
         self._health_check = HealthCheckProcessor(self._execution_engine)
         self._health_check_thread = Thread(
-            target=self._health_check.start, args=(), daemon=False
+            target=self._health_check.start,
+            args=(),
+            daemon=False,
         )
 
         self._spec = self._load_spec()
@@ -130,16 +95,6 @@ class SplightBaseComponent(ABC):
             )
             for routine in self._spec.routines
         }
-
-        # TODO: check if we are going to still use binding
-        bindings = [
-            binding
-            for binding in self._spec.bindings
-            if binding.object_type != "SetPoint"
-        ]
-        self._load_bindings(bindings, component_objects)
-        self._load_routines(self._spec.routines, routine_objects)
-        self._load_commands(self._spec.commands)
         self._custom_types = self._get_custom_type_model(component_objects)
         self._routines = self._get_routine_model(routine_objects)
 
@@ -162,11 +117,11 @@ class SplightBaseComponent(ABC):
         return self._custom_types
 
     @property
-    def execution_engine(self) -> ExecutionClient:
+    def execution_engine(self) -> ExecutionEngine:
         return self._execution_engine
 
     def _register_exit(self):
-        if self._execution_engine.get_last_exception():
+        if self._execution_engine.state == EngineStatus.FAILED:
             sys.exit(1)
         else:
             sys.exit(0)
@@ -198,12 +153,9 @@ class SplightBaseComponent(ABC):
             except Exception as exc:
                 logger.exception(exc, tags=LogTags.COMPONENT)
                 self._health_check.stop()
-                self._execution_engine.terminate_all()
+                self._execution_engine.stop()
                 sys.exit(1)
 
-            for thread in self._execution_engine.threads:
-                thread.join()
-
             self._health_check.stop()
             self._health_check_thread.join()
             self._register_exit()
@@ -234,85 +186,10 @@ class SplightBaseComponent(ABC):
         spec = Spec.from_file(os.path.join(base_path, "spec.json"))
         return spec
 
-    def _load_bindings(
-        self,
-        bindings: List[Binding],
-        component_objects: Dict[str, Type[ComponentObjectInstance]],
-    ):
-        """Loads and assigns callbacks for the bindings."""
-        for binding in bindings:
-            type_ = binding.object_type
-            model_class = DB_MODEL_TYPE_MAPPING.get(
-                type_, component_objects.get(type_)
-            )
-            if not model_class:
-                raise InvalidBidingObject(model_class.__name__)
-            event_name = model_class.get_event_name(
-                model_class.__name__, binding.object_action
-            )
-            callback_func = getattr(self, binding.name, None)
-            if not callback_func:
-                raise MissingBindingCallback(binding.name)
-
-            self._comm_client.bind(
-                event_name,
-                partial(
-                    database_object_event_handler,
-                    callback_func,
-                    model_class,
-                ),
-            )
-
-    def _load_routines(
-        self,
-        routines: List[Routine],
-        routines_objects: Dict[str, Type[RoutineObjectInstance]],
-    ) -> None:
-        """Loads and assigns callbacks to the routines."""
-
-        actions = ["create", "update", "delete"]
-        for routine in routines:
-            model_calss = routines_objects.get(routine.name)
-
-            for action in actions:
-                event_name = RoutineObject.get_event_name(
-                    model_calss.__name__, action
-                )
-
-                callback_func = getattr(
-                    self, getattr(routine, f"{action}_handler"), None
-                )
-                if not callback_func:
-                    raise MissingRoutineCallback(routine.name, action)
-                self._comm_client.bind(
-                    event_name,
-                    partial(
-                        database_object_event_handler,
-                        callback_func,
-                        model_calss,
-                    ),
-                )
-
-    def _load_commands(self, commands: List[Command]):
-        """Assigns callbacks function to each of the defined commands."""
-        for command in commands:
-            callback_func = getattr(self, command.name.lower(), None)
-            if not callback_func:
-                raise MissingCommandCallback(command.name)
-            event_name = (EventNames.COMPONENTCOMMAND_TRIGGER.value,)
-            self._comm_client.bind(
-                event_name,
-                partial(
-                    command_event_handler,
-                    callback_func,
-                    self._comm_client,
-                ),
-            )
-
     @abstractmethod
     def start(self):
         raise NotImplementedError()
 
     def stop(self):
-        self._execution_engine.terminate_all()
+        self._execution_engine.stop()
         sys.exit(1)

{splight_lib-4.3.7 → splight_lib-4.4.0}/splight_lib/component/spec.py

@@ -31,6 +31,7 @@ VALID_PARAMETER_VALUES = {
     "bool": bool,
     "str": str,
     "float": float,
+    "crontab": str,
     "url": AnyUrl,
     "datetime": None,
     "File": None,  # UUID

splight_lib-4.4.0/splight_lib/execution/__init__.py

@@ -0,0 +1,12 @@
+from splight_lib.execution.engine import ExecutionEngine
+from splight_lib.execution.scheduling import Crontab, TaskPeriod
+from splight_lib.execution.task import CronnedTask, PeriodicTask, Task
+
+__all__ = [
+    ExecutionEngine,
+    Crontab,
+    TaskPeriod,
+    CronnedTask,
+    PeriodicTask,
+    Task,
+]

splight_lib-4.4.0/splight_lib/execution/engine.py

@@ -0,0 +1,101 @@
+from enum import Enum, auto
+from typing import Set
+
+import pytz
+from apscheduler.events import EVENT_JOB_ERROR, JobExecutionEvent
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.schedulers.blocking import BlockingScheduler
+
+from splight_lib.execution.task import BaseTask
+from splight_lib.logging._internal import LogTags, get_splight_logger
+
+
+class EngineStatus(Enum):
+    RUNNING = auto()
+    STOPPED = auto()
+    FINISHED = auto()
+    FAILED = auto()
+
+
+class ExecutionEngine:
+    def __init__(self):
+        self._logger = get_splight_logger("ExecutionEngine")
+        self._logger.info(
+            "Execution client initialized.", tags=LogTags.RUNTIME
+        )
+        self._blocking_sch = BlockingScheduler(timezone=pytz.UTC)
+        self._background_sch = BackgroundScheduler(
+            timezone=pytz.UTC, daemon=True
+        )
+        self._critical_jobs: Set[str] = set()
+        self._blocking_sch.add_listener(
+            self._task_fail_callbak, EVENT_JOB_ERROR
+        )
+        self._background_sch.add_listener(
+            self._task_fail_callbak, EVENT_JOB_ERROR
+        )
+        self._running = False
+        self._state = EngineStatus.STOPPED
+
+    @property
+    def running(self) -> bool:
+        return self._running
+
+    @property
+    def state(self) -> EngineStatus:
+        return self._state
+
+    def start(self):
+        """Starts the the schedulers."""
+        self._running = True
+        self._state = EngineStatus.RUNNING
+        if self._background_sch.get_jobs():
+            self._background_sch.start()
+        if self._blocking_sch.get_jobs():
+            self._blocking_sch.start()
+        self._logger.info("Execution Engine started", tags=LogTags.RUNTIME)
+
+    def stop(self):
+        """Stops all the schedulers and its task without waiting to finish."""
+        if self._blocking_sch.running:
+            self._blocking_sch.shutdown(wait=False)
+        if self._background_sch.running:
+            self._background_sch.shutdown(wait=False)
+        self._running = False
+        self._state = EngineStatus.STOPPED
+        self._logger.info("Execution Engine stopped", tags=LogTags.RUNTIME)
+
+    def add_task(
+        self,
+        task: BaseTask,
+        in_background: bool = True,
+        exit_on_fail: bool = False,
+    ):
+        """Adds new task to the corresponding scheduler.
+
+        Parameters
+        ----------
+        task: BaseTask
+            Instance of Task to be scheduled.
+        in_background: bool
+            Wheter to run the task using the BackgroundScheduler or the
+            BlockingScheduler
+        exit_on_fail: bool
+            Used to stop the engine if the task execution failed. This
+            parameter is usefull to declare critical tasks.
+        """
+        if in_background:
+            job = self._background_sch.add_job(**task.as_job())
+        else:
+            job = self._blocking_sch.add_job(**task.as_job())
+        if exit_on_fail:
+            self._critical_jobs.add(job.id)
+        self._logger.info(f"Job {job.id} added", tags=LogTags.RUNTIME)
+
+    def _task_fail_callbak(self, event: JobExecutionEvent):
+        if event.job_id in self._critical_jobs:
+            self._logger.error(
+                "An error ocurred in job execution. Stopping engine"
+            )
+            self.stop()
+            self._state = EngineStatus.FAILED

splight_lib-4.4.0/splight_lib/execution/exceptions.py

@@ -0,0 +1,9 @@
+class InvalidCronString(Exception):
+    def __init__(self, cron_str: str):
+        self._msg = (
+            f"Invalid cron string: {cron_str}. "
+            f"Expected format: 'minute hour day_of_month month day_of_week'"
+        )
+
+    def __str__(self):
+        return self._msg

splight_lib-4.4.0/splight_lib/execution/scheduling.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timezone
+from typing import Optional, Union
+
+from pydantic import BaseModel, ValidationInfo, field_validator
+
+from splight_lib.execution.exceptions import InvalidCronString
+
+FIELD_RANGE = {
+    "month": (1, 12),
+    "day": (1, 31),
+    "week": (1, 53),
+    "day_of_week": (0, 6),
+    "hour": (0, 23),
+    "minute": (0, 59),
+    "second": (0, 59),
+}
+
+
+def validate_value_in_range(
+    value: Union[int, str], min_value: int, max_value: int, name: str
+):
+    if isinstance(value, str):
+        if "*" in value:
+            return value
+        elif value.isdigit():
+            value = int(value)
+            if not min_value <= value <= max_value:
+                raise ValueError(
+                    f"{name}'s value must be in range {min_value}-{max_value}"
+                )
+    elif isinstance(value, int):
+        if not min_value <= value <= max_value:
+            raise ValueError(
+                f"{name}'s Value must be in range {min_value}-{max_value}"
+            )
+    return value
+
+
+class TaskPeriod(BaseModel):
+    weeks: int = 0
+    days: int = 0
+    hours: int = 0
+    minutes: int = 0
+    seconds: int = 0
+    start_date: datetime = datetime.now(timezone.utc)
+    end_date: Optional[datetime] = None
+
+
+class Crontab(BaseModel):
+    year: Optional[Union[str, int]] = None
+    month: Optional[Union[str, int]] = None
+    day: Optional[Union[str, int]] = None
+    week: Optional[Union[str, int]] = None
+    day_of_week: Optional[Union[str, int]] = None
+    hour: Optional[Union[str, int]] = None
+    minute: Optional[Union[str, int]] = None
+    second: Optional[Union[str, int]] = None
+
+    @field_validator(
+        "month", "day", "week", "day_of_week", "hour", "minute", "second"
+    )
+    def validate_minute(cls, value: str, info: ValidationInfo):
+        min_value, max_value = FIELD_RANGE[info.field_name]
+        return validate_value_in_range(
+            value, min_value, max_value, info.field_name
+        )
+
+    @classmethod
+    def from_string(cls, cron_str: str) -> "Crontab":
+        """Converts a crontab string into a Crontab instance.
+        Since crontab by default uses 5 fields, seconds and years are set to
+        None
+
+        Parameters
+        ----------
+        cron_str : str
+            The crontab string to convert
+
+        Returns
+        -------
+        Crontab instance
+        """
+        elements = cron_str.split(" ")
+        if len(elements) != 5:
+            raise InvalidCronString(cron_str)
+        return cls(
+            minute=elements[0],
+            hour=elements[1],
+            day=elements[2],
+            month=elements[3],
+            day_of_week=elements[4],
+        )

splight_lib-4.4.0/splight_lib/execution/task.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, Optional, Tuple, Union
+
+import pytz
+from apscheduler.triggers.cron import CronTrigger
+
+from splight_lib.execution.scheduling import Crontab, TaskPeriod
+from splight_lib.execution.trigger import IntervalTrigger
+
+
+class BaseTask(ABC):
+    @abstractmethod
+    def as_job(self) -> Dict:
+        ...
+
+
+class PeriodicTask(BaseTask):
+    def __init__(
+        self,
+        target: Callable,
+        period: Union[TaskPeriod, int],
+        target_args: Optional[Tuple] = None,
+    ):
+        self._target = target
+        self._args = target_args
+        if isinstance(period, TaskPeriod):
+            self._trigger = IntervalTrigger(
+                **period.model_dump(), timezone=pytz.UTC
+            )
+        elif isinstance(period, int):
+            self._trigger = IntervalTrigger(seconds=period, timezone=pytz.UTC)
+
+    def as_job(self) -> dict:
+        job_dict = {
+            "func": self._target,
+            "trigger": self._trigger,
+        }
+
+        if self._args:
+            job_dict.update({"args": self._args})
+
+        return job_dict
+
+
+Task = PeriodicTask
+
+
+class CronnedTask(BaseTask):
+    def __init__(
+        self,
+        target: Callable,
+        crontab: Crontab,
+        target_args: Optional[Tuple] = None,
+    ):
+        self._target = target
+        self._trigger = CronTrigger(
+            **crontab.model_dump(exclude_none=True), timezone=pytz.UTC
+        )
+        self._args = target_args
+
+    @classmethod
+    def from_cron_string(
+        cls,
+        target: Callable,
+        cron_str: str,
+        target_args: Optional[Tuple] = None,
+    ):
+        crontab = Crontab.from_string(cron_str)
+        return cls(target, crontab, target_args)
+
+    def as_job(self) -> dict:
+        job_dict = {
+            "func": self._target,
+            "trigger": self._trigger,
+        }
+
+        if self._args:
+            job_dict.update({"args": self._args})
+
+        return job_dict

splight_lib-4.4.0/splight_lib/execution/tests/test_execution.py

@@ -0,0 +1,41 @@
+from time import sleep
+
+from splight_lib.execution.engine import EngineStatus, ExecutionEngine
+from splight_lib.execution.task import PeriodicTask
+
+
+def test_task_with_error():
+    def task_function():
+        sleep(1)
+        print("This is a function")
+        raise ValueError()
+
+    task = PeriodicTask(target=task_function, period=1)
+
+    engine = ExecutionEngine()
+    assert engine.state == EngineStatus.STOPPED
+
+    engine.add_task(task, in_background=False, exit_on_fail=True)
+
+    engine.start()
+    assert engine.state == EngineStatus.FAILED
+
+
+def test_task_with_error_on_background():
+    def task_function():
+        sleep(1)
+        print("This is a function")
+        raise ValueError()
+
+    task = PeriodicTask(target=task_function, period=1)
+
+    engine = ExecutionEngine()
+    assert engine.state == EngineStatus.STOPPED
+
+    engine.add_task(task, in_background=True, exit_on_fail=True)
+
+    engine.start()
+    assert engine.state == EngineStatus.RUNNING
+
+    sleep(2)
+    assert engine.state == EngineStatus.FAILED