queuerPy 0.1.0__py3-none-any.whl

queuerPy/queuer_next_interval.py

@@ -0,0 +1,96 @@
+"""
+Next interval function-related methods for the Python queuer implementation.
+Mirrors Go's queuerNextInterval.go functionality.
+"""
+
+import logging
+from typing import Any, Callable
+
+from queuer_global import QueuerGlobalMixin
+from model.worker import Worker
+
+logger = logging.getLogger(__name__)
+
+
+class QueuerNextIntervalMixin(QueuerGlobalMixin):
+    """
+    Mixin class containing next interval function-related methods for the Queuer.
+    Mirrors Go's queuerNextInterval.go functionality.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def add_next_interval_func(self, nif: Callable[..., Any]) -> Worker:
+        """
+        Add a NextIntervalFunc to the worker's available next interval functions.
+        Takes a NextIntervalFunc and adds it to the worker's available_next_interval_funcs.
+        The function name is derived from the function using helper.get_task_name_from_interface.
+
+        :param nif: The next interval function to add
+        :return: The updated worker after adding the function
+        :raises ValueError: If function is None
+        :raises RuntimeError: If function already exists or database update fails
+        """
+        from helper.task import get_task_name_from_interface
+
+        if nif is None:
+            raise ValueError("NextIntervalFunc cannot be None")
+
+        try:
+            nif_name = get_task_name_from_interface(nif)
+        except Exception as e:
+            raise RuntimeError(f"Error getting function name: {str(e)}")
+
+        if nif_name in self.worker.available_next_interval_funcs:
+            raise RuntimeError(f"NextIntervalFunc already exists: {nif_name}")
+
+        self.next_interval_funcs[nif_name] = nif
+        self.worker.available_next_interval_funcs.append(nif_name)
+
+        try:
+            worker = self.db_worker.update_worker(self.worker)
+            if not worker:
+                raise Exception("Worker could not be updated")
+
+            logger.info(f"NextInterval function added: {nif_name}")
+            return worker
+        except Exception as e:
+            raise RuntimeError(f"Error updating worker: {str(e)}")
+
+    def add_next_interval_func_with_name(
+        self, nif: Callable[..., Any], name: str
+    ) -> Worker:
+        """
+        Add a NextIntervalFunc to the worker's available next interval functions with a specific name.
+        Takes a NextIntervalFunc and a name, checks if the function is not None
+        and doesn't already exist in the worker's available next interval functions,
+        and adds it to the worker's available_next_interval_funcs.
+
+        This function is useful when you want to add a NextIntervalFunc
+        with a specific name that you control, rather than deriving it from the function itself.
+
+        :param nif: The next interval function to add
+        :param name: The specific name for the function
+        :return: The updated worker after adding the function with the specified name
+        :raises ValueError: If function is None
+        :raises RuntimeError: If function already exists or database update fails
+        """
+        if nif is None:
+            raise ValueError("NextIntervalFunc cannot be None")
+
+        if name in self.worker.available_next_interval_funcs:
+            raise RuntimeError(f"NextIntervalFunc with name already exists: {name}")
+
+        self.next_interval_funcs[name] = nif
+        self.worker.available_next_interval_funcs.append(name)
+
+        try:
+            worker = self.db_worker.update_worker(self.worker)
+            if not worker:
+                raise Exception("Worker could not be updated")
+
+            logger.info(f"NextInterval function added: {name}")
+            return worker
+        except Exception as e:
+            raise RuntimeError(f"Error updating worker: {str(e)}")

queuerPy/queuer_task.py

@@ -0,0 +1,89 @@
+"""
+Task-related methods for the Python queuer implementation.
+Mirrors Go's queuerTask.go functionality.
+"""
+
+import logging
+from typing import Any, Callable, Optional
+
+from model.task import new_task, new_task_with_name
+from model.task import Task
+from queuer_global import QueuerGlobalMixin
+
+logger = logging.getLogger(__name__)
+
+
+class QueuerTaskMixin(QueuerGlobalMixin):
+    """
+    Mixin class containing task-related methods for the Queuer.
+    Mirrors Go's queuerTask.go functionality.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def add_task(self, task: Callable[..., Any]) -> Optional[Task]:
+        """
+        Add a new task to the queuer.
+        Creates a new task with the provided task function, adds it to the worker's available tasks,
+        and updates the worker in the database.
+        The task name is automatically generated based on the task's function name.
+
+        :param task: The task function to add
+        :return: The newly created task
+        :raises RuntimeError: If task creation fails or task already exists
+        """
+        task_name = task.__name__
+        if task_name in self.tasks:
+            raise RuntimeError(f"Task already exists: {task_name}")
+
+        try:
+            new_task_obj = new_task(task)
+        except Exception as e:
+            raise RuntimeError(f"Error creating new task: {str(e)}")
+
+        if new_task_obj.name in self.worker.available_tasks:
+            raise RuntimeError(f"Task already exists: {new_task_obj.name}")
+
+        self.tasks[new_task_obj.name] = new_task_obj
+        self.worker.available_tasks.append(new_task_obj.name)
+
+        # Update worker in DB
+        try:
+            self.db_worker.update_worker(self.worker)
+        except Exception as e:
+            raise RuntimeError(f"Error updating worker: {str(e)}")
+
+        logger.info(f"Task added: {new_task_obj.name}")
+        return new_task_obj
+
+    def add_task_with_name(self, task: Callable[..., Any], name: str) -> "Task":
+        """
+        Add a new task with a specific name to the queuer.
+        Creates a new task with the provided task function and name, adds it to the worker's available tasks,
+        and updates the worker in the database.
+
+        :param task: The task function to add
+        :param name: The specific name for the task
+        :return: The newly created task
+        :raises RuntimeError: If task creation fails or task already exists
+        """
+        try:
+            new_task_obj = new_task_with_name(task, name)
+        except Exception as e:
+            raise RuntimeError(f"Error creating new task: {str(e)}")
+
+        if name in self.worker.available_tasks:
+            raise RuntimeError(f"Task already exists: {name}")
+
+        self.tasks[new_task_obj.name] = new_task_obj
+        self.worker.available_tasks.append(new_task_obj.name)
+
+        # Update worker in DB
+        try:
+            self.db_worker.update_worker(self.worker)
+        except Exception as e:
+            raise RuntimeError(f"Error updating worker: {str(e)}")
+
+        logger.info(f"Task added: {new_task_obj.name}")
+        return new_task_obj

queuer_global.py

@@ -0,0 +1,56 @@
+from typing import Any, Callable, Dict, Optional
+from core.broadcaster import new_broadcaster
+from core.listener import Listener
+from database.db_job import JobDBHandler
+from database.db_worker import WorkerDBHandler
+from helper.database import Database, DatabaseConfiguration, new_database
+from helper.logging import get_logger
+from model.job import Job
+from model.task import Task
+from model.worker import Worker
+
+logger = get_logger()
+
+
+class QueuerGlobalMixin:
+    def __init__(self):
+        self.running: bool = False
+
+        # DB
+        self.db_job: JobDBHandler
+        self.db_worker: WorkerDBHandler
+
+        # Broadcaster
+        self.job_insert_broadcaster = new_broadcaster("job.INSERT")
+        self.job_update_broadcaster = new_broadcaster("job.UPDATE")
+        self.job_delete_broadcaster = new_broadcaster("job.DELETE")
+
+        # Listener
+        self.job_insert_listener = Listener[Job](self.job_insert_broadcaster)
+        self.job_update_listener = Listener[Job](self.job_update_broadcaster)
+        self.job_delete_listener = Listener[Job](self.job_delete_broadcaster)
+
+        # Ticker
+        self.heartbeat_ticker: Optional[Any] = None
+        self.poll_job_ticker: Optional[Any] = None
+
+        self.worker: Worker
+        self.tasks: Dict[str, Task] = {}
+        self.next_interval_funcs: Dict[str, Callable[..., Any]] = {}
+
+    def initialise(
+        self,
+        db_config: DatabaseConfiguration,
+        encryption_key: str = "",
+    ):
+        # Database connection
+        self.database: Database = new_database("queuer", db_config, logger)
+        self.DB = self.database.instance
+
+        # Database handlers
+        self.db_job: JobDBHandler = JobDBHandler(
+            self.database, db_config.with_table_drop, encryption_key
+        )
+        self.db_worker: WorkerDBHandler = WorkerDBHandler(
+            self.database, db_config.with_table_drop
+        )