codecraftai-interop-ext-tasker 1.3.0__py3-none-any.whl

ccai/interop/protocols/tasker/__init__.py

@@ -0,0 +1,12 @@
+"""
+    .. module:: __init__
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: __init__ module.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+

ccai/interop/protocols/tasker/examples/helloworldtasking.py

@@ -0,0 +1,97 @@
+
+"""
+    .. module:: helloworldtasking
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: helloworldtasking module.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+import os
+import time
+
+from datetime import datetime
+
+from ccai.testbase.results.model.progressinfo import ProgressInfo, ProgressType, ProgressCode
+
+from ccai.interop.protocols.tasker.tasking import Tasking
+
+class HelloWorldTasking(Tasking):
+    """
+        Simple example tasking that writes a message a number of times.
+    """
+
+    PREFIX = "helloworld"
+
+    def begin(self, kwparams: dict):
+        """
+            Called when the task is beginning execution.
+            
+            :param kwparams: Parameters describing the task execution.
+        """
+
+        self._message = kwparams["message"]
+        self._iterations = kwparams["iterations"]
+
+        self._data = {
+            "pid": os.getpid(),
+            "message": self._message,
+            "iterations": self._iterations
+        }
+        
+        time.sleep(5)
+
+        return
+
+    def mark_progress_start(self):
+        """
+            Marks the start of progress for the tasking.
+
+            :returns: ``None``
+        """
+        now = datetime.now()
+        self._current_progress = ProgressInfo(
+            self._tasking_id,
+            "hello",
+            self.full_name,
+            ProgressType.NumericRange,
+            0,
+            self._iterations,
+            0,
+            ProgressCode.Running,
+            now,
+            self._data,
+        )
+        return
+
+    def log_message(self, message) -> bool:
+        """
+            Logs a message to the tasking logger.
+
+            :param message: Text to log.
+
+            :returns: ``True`` if the message was logged.
+        """
+        self._logger.info(message)
+        return True
+
+    def perform(self):
+        """
+            Performs one iteration of work.
+
+            :returns: ``True`` if additional iterations remain.
+        """
+        position = self._current_progress.position
+
+        time.sleep(1)
+
+        morework = False
+        if position < self._current_progress.range_max:
+            morework = True
+            self._current_progress.position = position + 1
+
+        return morework

ccai/interop/protocols/tasker/itaskingsequencer.py

@@ -0,0 +1,78 @@
+"""
+    .. module:: itaskingsequencer
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: itaskingsequencer module.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+from typing import Protocol
+
+from ccai.errors.exceptions import AbstractMethodError
+
+
+from ccai.testbase.results.recorders.resultrecorder import ResultRecorder
+from ccai.testbase.results.model.taskinggroup import TaskingGroup
+from ccai.testbase.results.model.taskingresult import TaskingResult
+
+
+class ITaskingSequencer(Protocol):
+    """
+        Protocol defining the interface for task sequencing helpers.
+    """
+
+    def create_tasking_result(
+        self, scope_id: str, name: str, parent_inst: str
+    ) -> TaskingResult:
+        """
+            Creates a :class:`TaskingResult` object used to capture the outcome of a task.
+            
+            :param scope_id: The scope identifier for the result.
+            :param name: The name of the tasking instance.
+            :param parent_inst: The parent instance identifier.
+            
+            :returns: A :class:`TaskingResult` instance.
+        """
+        raise AbstractMethodError(
+            "ITaskingSequencer.create_tasking_result must be overloaded by derived types"
+        )
+
+    def create_tasking_group(
+        self, scope_id: str, name: str, parent_inst: str
+    ) -> TaskingGroup:
+        """
+            Creates a :class:`TaskingGroup` for grouping related tasking results.
+            
+            :param scope_id: The scope identifier for the group.
+            :param name: The name of the tasking group.
+            :param parent_inst: The parent instance identifier.
+            
+            :returns: A :class:`TaskingGroup` instance.
+        """
+        raise AbstractMethodError(
+            "ITaskingSequencer.create_tasking_group must be overloaded by derived types"
+        )
+
+    def get_recorder(self) -> ResultRecorder:
+        """
+            Retrieves the :class:`ResultRecorder` used for recording results.
+            
+            :returns: The active :class:`ResultRecorder` instance.
+        """
+        raise AbstractMethodError(
+            "ITaskingSequencer.get_recorder must be overloaded by derived types"
+        )
+
+    def get_top_scope_id(self) -> str:
+        """
+            Gets the identifier of the current top-level scope.
+            
+            :returns: The active scope identifier.
+        """
+        raise AbstractMethodError(
+            "ITaskingSequencer.get_top_scope_id must be overloaded by derived types"
+        )

ccai/interop/protocols/tasker/linux/tasker-service.template

@@ -0,0 +1,16 @@
+[Unit]
+Description=The Tasker RPyC base tasking service
+After=syslog.target network-online.target remote-fs.target nss-lookup.target
+Wants=network-online.target
+
+[Service]
+User={username}
+Group={group}
+Type=forking
+PIDFile=/var/run/tasker/tasker.pid
+ExecStart={tasker-binary} start
+ExecStop={tasker-binary} stop
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target

ccai/interop/protocols/tasker/linux/taskerservice

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+THIS_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+VENV_DIR="$( dirname $THIS_DIR )"
+REPOSITORY_DIR="$( dirname $VENV_DIR )"
+
+REPOSITORY_ENV_FILE="$REPOSITORY_DIR/.env"
+REPOSITORY_CONFIG_FILE="$REPOSITORY_DIR/repository-setup/repository-config.ini"
+
+
+set -a
+
+source "$REPOSITORY_ENV_FILE"
+source <( grep --color=never -E '^[\s]*[A-Za-z_]+[A-Za-z_0-9]*=' "$REPOSITORY_CONFIG_FILE" )
+
+set +a
+
+
+TASKER_DIR="$( $THIS_DIR/python3 -c 'import ccai.interop.protocols.tasker as tasker; print(tasker.__file__[:-12])' )"
+
+echo "THIS_DIR=$THIS_DIR"
+echo "VENV_DIR=$VENV_DIR"
+echo "REPOSITORY_DIR=$REPOSITORY_DIR"
+echo "REPOSITORY_ENV_FILE=$REPOSITORY_ENV_FILE"
+echo "REPOSITORY_CONFIG_FILE=$REPOSITORY_CONFIG_FILE"
+echo "TASKER_DIR=$TASKER_DIR"
+
+$THIS_DIR/python3 $TASKER_DIR/taskerdaemon.py "$@"
+

ccai/interop/protocols/tasker/taskeraspects.py

@@ -0,0 +1,100 @@
+"""
+    .. module:: taskeraspects
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: Module containing the :class:`TaskerAspects` class which is used to instruct behavior
+    around tasking.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+    
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+
+from typing import Dict, Optional
+
+
+DEFAULT_COMPLETION_TIMEOUT = 7 * 24 * 60 * 60  # The Default Timeout is 1 Week
+DEFAULT_COMPLETION_INTERVAL = 10
+
+DEFAULT_INACTIVITY_TIMEOUT = 1200  # 20 Minutes
+DEFAULT_INACTIVITY_INTERVAL = 0.5
+
+DEFAULT_PROGRESS_INTERVAL = 30
+
+from ccai.aspects.aspects import Aspects as AspectsBase
+from ccai.testbase.results.model.progressdelivery import ProgressDeliveryMethod
+
+
+class TaskerAspects(AspectsBase):
+    """
+        Parameterization object describing task execution behavior.
+    """
+
+    def __init__(
+        self,
+        completion_timeout: Optional[float] = DEFAULT_COMPLETION_TIMEOUT,
+        completion_interval: Optional[float] = DEFAULT_COMPLETION_INTERVAL,
+        inactivity_timeout: Optional[float] = DEFAULT_INACTIVITY_TIMEOUT,
+        inactivity_interval: Optional[float] = DEFAULT_INACTIVITY_INTERVAL,
+        progress_delivery: Optional[Dict[str, float]] = None,
+        sync_request_timeout: Optional[float] = None,
+    ):
+        """
+            Constructs a :class:`TaskerAspects` object describing task execution parameters.
+            
+            :param completion_timeout: Maximum wait time for a task to complete.
+            :param completion_interval: Polling interval while waiting for completion.
+            :param inactivity_timeout: Timeout for detecting inactivity.
+            :param inactivity_interval: Polling interval for inactivity checks.
+            :param progress_delivery: Progress delivery settings.
+            :param sync_request_timeout: Timeout for synchronous requests.
+        """
+
+        super().__init__(completion_interval=completion_interval, completion_timeout=completion_timeout)
+
+        self.inactivity_timeout = inactivity_timeout
+        self.inactivity_interval = inactivity_interval
+        self.progress_delivery = progress_delivery
+        self.sync_request_timeout = sync_request_timeout
+        return
+
+    def as_dict(self) -> dict:
+        """
+            Returns this instance as a dictionary.
+            
+            :returns: Dictionary representation of the aspects.
+        """
+        data = {
+            "completion_timeout": self.completion_timeout,
+            "completion_interval": self.completion_interval,
+            "inactivity_timeout": self.inactivity_timeout,
+            "inactivity_interval": self.inactivity_interval,
+            "progress_delivery": self.progress_delivery,
+            "sync_request_timeout": self.sync_request_timeout,
+        }
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TaskerAspects":
+        """
+            Creates a :class:`TaskerAspects` from a dictionary.
+            
+            :param data: Dictionary of aspect values.
+            
+            :returns: A new :class:`TaskerAspects` instance.
+        """
+
+        obj = TaskerAspects(**data)
+        return obj
+
+
+DEFAULT_TASKER_ASPECTS = TaskerAspects()
+
+DEFAULT_SUMMARY_PROGRESS_TASKER_ASPECTS = TaskerAspects(
+    progress_delivery={
+        ProgressDeliveryMethod.SUMMARY_PULL_PROGRESS: DEFAULT_PROGRESS_INTERVAL
+    }
+)