task-scheduling 2.3.0__tar.gz → 2.3.2__tar.gz

{task_scheduling-2.3.0/task_scheduling.egg-info → task_scheduling-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: task_scheduling
-Version: 2.3.0
+Version: 2.3.2
 Summary: It is mainly used for task scheduling
 Home-page: https://github.com/fallingmeteorite/task_scheduling
 Author: fallingmeteorite
@@ -81,7 +81,9 @@ pip install --upgrade task_scheduling
 ```
 
 # Interface UI
+
 Use the function in code
+
 ```
 
 from task_scheduling.task_info import start_task_status_ui
@@ -95,13 +97,16 @@ Task status UI available at http://localhost:8000
 # Function introduction
 
 ## Tips
+
 1.Detailed information requires changing the log level to `debug`.
 
-2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating tasks by injecting exceptions.
+2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating
+tasks by injecting exceptions.
 
 3.Most of the API calls for this task scheduling can be added to the scheduler for execution as tasks.
 
 4.The log display level is available
+
 ```
 from task_scheduling.common import set_log_level
 
@@ -110,7 +115,9 @@ set_log_level("DEBUG") # INFO, DEBUG, ERROR, WARNING
 if __name__ == "__main__":
     ......
 ```
-5.The task priority is modified to high when necessary, and the task will start executing directly after submission. However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
+
+5.The task priority is modified to high when necessary, and the task will start executing directly after submission.
+However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
 
 ### Function: task_creation(delay: int or None, daily_time: str or None, function_type: str, timeout_processing: bool, task_name: str, func: Callable, *args, **kwargs) -> str or None:
 
@@ -376,6 +383,78 @@ if __name__ == "__main__":
 
 ```
 
+### pause_and_resume_task(self, task_id: str, action: str) -> bool:
+
+A function is used to pause a task and resume running at a specified time.
+
+```
+import asyncio
+import time
+
+from task_scheduling.utils import interruptible_sleep
+
+
+def line_task(input_info):
+    for i in range(10):
+        interruptible_sleep(1)
+        print(input_info)
+
+
+async def asyncio_task(input_info):
+    for i in range(10):
+        await asyncio.sleep(1)
+        print(input_info)
+
+
+input_info = "test"
+
+from task_scheduling.common import set_log_level
+
+set_log_level("DEBUG")
+if __name__ == "__main__":
+    from task_scheduling.task_creation import task_creation, shutdown
+    from task_scheduling.task_info import start_task_status_ui
+    from task_scheduling.scheduler import io_liner_task
+
+    start_task_status_ui()
+    from task_scheduling.variable import *
+
+    task_id1 = task_creation(None,
+                             # This is how long the delay is executed (in seconds)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the daily_time is not required
+                             None,
+                             # This is to be performed at what point (24-hour clock)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the delay is not required
+                             scheduler_io,
+                             # Running function type, there are "io, cpu, timer"
+                             True,
+                             # Set to True to enable timeout detection, tasks that do not finish within the runtime will be forcibly terminated
+                             "task2",
+                             # Task ID, in linear tasks, tasks with the same ID will be queued, different IDs will be executed directly, the same applies to asynchronous tasks
+                             line_task,
+                             # The function to be executed, parameters should not be passed here
+                             priority_low,
+                             # The task priority is modified to high when necessary, and the task will start executing directly after submission
+                             input_info
+                             # Pass the parameters required by the function, no restrictions
+                             )
+
+    # cf478b6e-5e02-49b8-9031-4adc6ff915c2, cf478b6e-5e02-49b8-9031-4adc6ff915c2
+    time.sleep(2.0)
+    print("Pause")
+    io_liner_task.pause_and_resume_task(task_id1, "pause")
+    time.sleep(4.0)
+    print("Resume")
+    io_liner_task.pause_and_resume_task(task_id1, "resume")
+
+    try:
+        while True:
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        shutdown(True)
+
+```
+
 ### FunctionRunner(self, func: Callable, task_name: str, *args, **kwargs) -> None:
 
 A task that detects what type of function is executed. The detected parameters are stored in a file and read directly at
@@ -818,9 +897,11 @@ if __name__ == "__main__":
 ### force_stop_task(task_id: str) -> bool:
 
 All 4 schedulers have this function for terminating a running task. Warning: If the function is executing a
-process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the function
+process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the
+function
 
 Warn!!! `cpu_liner_task.force_stop_task()` is different and requires the addition of additional parameters
+
 ```
 import asyncio
 import time

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/README.md

@@ -58,7 +58,9 @@ pip install --upgrade task_scheduling
 ```
 
 # Interface UI
+
 Use the function in code
+
 ```
 
 from task_scheduling.task_info import start_task_status_ui
@@ -72,13 +74,16 @@ Task status UI available at http://localhost:8000
 # Function introduction
 
 ## Tips
+
 1.Detailed information requires changing the log level to `debug`.
 
-2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating tasks by injecting exceptions.
+2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating
+tasks by injecting exceptions.
 
 3.Most of the API calls for this task scheduling can be added to the scheduler for execution as tasks.
 
 4.The log display level is available
+
 ```
 from task_scheduling.common import set_log_level
 
@@ -87,7 +92,9 @@ set_log_level("DEBUG") # INFO, DEBUG, ERROR, WARNING
 if __name__ == "__main__":
     ......
 ```
-5.The task priority is modified to high when necessary, and the task will start executing directly after submission. However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
+
+5.The task priority is modified to high when necessary, and the task will start executing directly after submission.
+However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
 
 ### Function: task_creation(delay: int or None, daily_time: str or None, function_type: str, timeout_processing: bool, task_name: str, func: Callable, *args, **kwargs) -> str or None:
 
@@ -353,6 +360,78 @@ if __name__ == "__main__":
 
 ```
 
+### pause_and_resume_task(self, task_id: str, action: str) -> bool:
+
+A function is used to pause a task and resume running at a specified time.
+
+```
+import asyncio
+import time
+
+from task_scheduling.utils import interruptible_sleep
+
+
+def line_task(input_info):
+    for i in range(10):
+        interruptible_sleep(1)
+        print(input_info)
+
+
+async def asyncio_task(input_info):
+    for i in range(10):
+        await asyncio.sleep(1)
+        print(input_info)
+
+
+input_info = "test"
+
+from task_scheduling.common import set_log_level
+
+set_log_level("DEBUG")
+if __name__ == "__main__":
+    from task_scheduling.task_creation import task_creation, shutdown
+    from task_scheduling.task_info import start_task_status_ui
+    from task_scheduling.scheduler import io_liner_task
+
+    start_task_status_ui()
+    from task_scheduling.variable import *
+
+    task_id1 = task_creation(None,
+                             # This is how long the delay is executed (in seconds)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the daily_time is not required
+                             None,
+                             # This is to be performed at what point (24-hour clock)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the delay is not required
+                             scheduler_io,
+                             # Running function type, there are "io, cpu, timer"
+                             True,
+                             # Set to True to enable timeout detection, tasks that do not finish within the runtime will be forcibly terminated
+                             "task2",
+                             # Task ID, in linear tasks, tasks with the same ID will be queued, different IDs will be executed directly, the same applies to asynchronous tasks
+                             line_task,
+                             # The function to be executed, parameters should not be passed here
+                             priority_low,
+                             # The task priority is modified to high when necessary, and the task will start executing directly after submission
+                             input_info
+                             # Pass the parameters required by the function, no restrictions
+                             )
+
+    # cf478b6e-5e02-49b8-9031-4adc6ff915c2, cf478b6e-5e02-49b8-9031-4adc6ff915c2
+    time.sleep(2.0)
+    print("Pause")
+    io_liner_task.pause_and_resume_task(task_id1, "pause")
+    time.sleep(4.0)
+    print("Resume")
+    io_liner_task.pause_and_resume_task(task_id1, "resume")
+
+    try:
+        while True:
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        shutdown(True)
+
+```
+
 ### FunctionRunner(self, func: Callable, task_name: str, *args, **kwargs) -> None:
 
 A task that detects what type of function is executed. The detected parameters are stored in a file and read directly at
@@ -795,9 +874,11 @@ if __name__ == "__main__":
 ### force_stop_task(task_id: str) -> bool:
 
 All 4 schedulers have this function for terminating a running task. Warning: If the function is executing a
-process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the function
+process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the
+function
 
 Warn!!! `cpu_liner_task.force_stop_task()` is different and requires the addition of additional parameters
+
 ```
 import asyncio
 import time

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task_scheduling"
-version = "2.3.0"
+version = "2.3.2"
 description = "It is mainly used for task scheduling"
 authors = [
     { name = "fallingmeteorite", email = "2327667836@qq.com" }

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="task_scheduling",
-    version="2.3.0",
+    version="2.3.2",
     description="It is mainly used for task scheduling",
     author="fallingmeteorite",
     author_email="2327667836@qq.com",

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/control/__init__.py

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 # Author: fallingmeteorite
 from .process_manager import ProcessTaskManager
-from .skip_run import skip_on_demand, StopException
+from .terminate_run import ThreadTerminator, StopException
 
 from .thread_manager import ThreadTaskManager
 from .timeout_run import TimeoutException, ThreadingTimeout
 
-from .pause_run import ThreadController
+from .pause_run import ThreadSuspender

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/control/pause_run.py

@@ -9,7 +9,7 @@ from typing import Dict
 from ..common import logger
 
 
-class ThreadController:
+class ThreadSuspender:
     """Simplified thread controller, fully controlled through context management"""
 
     def __init__(self):
@@ -31,7 +31,7 @@ class ThreadController:
             raise NotImplementedError(f"Unsupported platform: {self.platform}")
 
     @contextmanager
-    def control_context(self):
+    def suspend_context(self):
         """Thread control context manager"""
         current_thread = threading.current_thread()
         tid = current_thread.ident
@@ -125,7 +125,7 @@ class ThreadController:
 class _ThreadControl:
     """Thread control interface (for internal use only)"""
 
-    def __init__(self, controller: ThreadController, tid: int):
+    def __init__(self, controller: ThreadSuspender, tid: int):
         self._controller = controller
         self._tid = tid
         self._paused = False
@@ -153,4 +153,4 @@ class _ThreadControl:
     @property
     def is_paused(self) -> bool:
         """Check if thread is paused"""
-        return self._paused
+        return self._paused

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/control/process_manager.py

@@ -23,10 +23,10 @@ class ProcessTaskManager:
         self._start: bool = True
         self._start_monitor_thread()  # Start the monitor thread
 
-    def add(self, skip_obj: Any, pause_ctx: Any, task_id: str) -> None:
+    def add(self, terminate_obj: Any, pause_ctx: Any, task_id: str) -> None:
         """
         Add task control objects to the dictionary.
-        :param skip_obj: An object that has a skip method.
+        :param terminate_obj: An object that has a terminate method.
           :param pause_ctx: An object that has a pause method.
         :param task_id: Task ID, used as the key in the dictionary.
         """
@@ -34,7 +34,7 @@ class ProcessTaskManager:
             if task_id in self._tasks:
                 logger.warning(f"Task with task_id '{task_id}' already exists, overwriting")
             self._tasks[task_id] = {
-                'skip': skip_obj,
+                'terminate': terminate_obj,
                 'pause': pause_ctx
             }
 
@@ -59,17 +59,17 @@ class ProcessTaskManager:
         with self._operation_lock:  # Lock for thread-safe dictionary access
             return task_id in self._tasks
 
-    def skip_task(self, task_id: str) -> None:
+    def terminate_task(self, task_id: str) -> None:
         """
-        Skip the task based on task_id.
+        Terminate the task based on task_id.
         :param task_id: Task ID.
         """
         with self._operation_lock:  # Lock for thread-safe dictionary access
             if task_id in self._tasks:
                 try:
-                    self._tasks[task_id]['skip'].skip()  # Perform the skip operation outside the lock
+                    self._tasks[task_id]['terminate'].terminate()  # Perform the terminate operation outside the lock
                 except Exception as error:
-                    logger.error(f"Error skipping task '{task_id}': {error}")
+                    logger.error(f"Error terminating task '{task_id}': {error}")
 
             else:
                 logger.warning(f"No task found with task_id '{task_id}', operation invalid")
@@ -118,7 +118,7 @@ class ProcessTaskManager:
 
                 if self.check(task_id):  # Check if the task_id exists in the dictionary
                     if target == "kill":
-                        self.skip_task(task_id)  # Skip the task if it exists
+                        self.terminate_task(task_id)  # Terminate the task if it exists
                     if target == "pause":
                         self.pause_task(task_id)  # Pause the task if it exists
                     if target == "resume":
@@ -130,7 +130,7 @@ class ProcessTaskManager:
                             break  # Stop the loop if tasks dictionary is empty
 
                 else:
-                    self._task_queue.put(task_id)
+                    self._task_queue.put((task_id, target))
             except queue.Empty:
                 pass  # Ignore empty queue exceptions
             except Exception as error:

task_scheduling-2.3.2/task_scheduling/control/terminate_run.py

@@ -0,0 +1,109 @@
+import threading
+import ctypes
+import platform
+from contextlib import contextmanager
+from typing import Dict
+
+
+class StopException(Exception):
+    """Custom exception for thread termination"""
+    pass
+
+
+class ThreadTerminator:
+    """Thread terminator using context manager that raises StopException in target thread"""
+
+    def __init__(self):
+        self._handles: Dict[int, int] = {}
+        self._lock = threading.Lock()
+        self._setup_platform()
+
+    def _setup_platform(self):
+        self.platform = platform.system()
+        if self.platform == "Windows":
+            self._kernel32 = ctypes.windll.kernel32
+            self.THREAD_ACCESS = 0x0001 | 0x0002  # TERMINATE + SUSPEND
+        elif self.platform in ("Linux", "Darwin"):
+            lib_name = "libc.so.6" if self.platform == "Linux" else "libSystem.dylib"
+            self._libc = ctypes.CDLL(lib_name)
+        else:
+            raise NotImplementedError(f"Unsupported platform: {self.platform}")
+
+    @contextmanager
+    def terminate_control(self):
+        """Context manager for thread termination"""
+        tid = threading.current_thread().ident
+        if not tid:
+            raise RuntimeError("Thread not running")
+
+        if not self._register_thread(tid):
+            raise RuntimeError("Thread registration failed")
+
+        controller = TerminateController(self, tid)
+        try:
+            yield controller
+        finally:
+            self._unregister_thread(tid)
+
+    def _register_thread(self, tid: int) -> bool:
+        """Register thread with OS"""
+        with self._lock:
+            if tid in self._handles:
+                return True
+
+            try:
+                if self.platform == "Windows":
+                    handle = self._kernel32.OpenThread(self.THREAD_ACCESS, False, tid)
+                    if not handle:
+                        raise ctypes.WinError()
+                    self._handles[tid] = handle
+                else:
+                    self._handles[tid] = tid
+                return True
+            except Exception:
+                return False
+
+    def _unregister_thread(self, tid: int) -> bool:
+        """Unregister thread from OS"""
+        with self._lock:
+            if tid not in self._handles:
+                return False
+
+            try:
+                if self.platform == "Windows":
+                    self._kernel32.CloseHandle(self._handles[tid])
+                del self._handles[tid]
+                return True
+            except Exception:
+                return False
+
+    def _raise_stop_exception(self, tid: int):
+        """Raise StopException in target thread"""
+        if self.platform == "Windows":
+            # Use async exception on Windows
+            ret = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_long(tid),
+                ctypes.py_object(StopException))
+
+            if ret == 0:
+                raise ValueError("Invalid thread ID")
+            elif ret > 1:
+                ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), None)
+                raise SystemError("Async exception failed")
+        else:
+            # Use pthread_cancel on POSIX
+            if self._libc.pthread_cancel(tid) != 0:
+                raise RuntimeError("Failed to cancel thread")
+
+
+class TerminateController:
+    """Controller for terminating the current thread"""
+
+    def __init__(self, terminator: ThreadTerminator, tid: int):
+        self._terminator = terminator
+        self._tid = tid
+
+    def terminate(self):
+        """Terminate the current thread by raising StopException in it"""
+        self._terminator._raise_stop_exception(self._tid)
+        # This line won't be reached as the thread will be terminated

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/control/thread_manager.py

@@ -12,12 +12,12 @@ class ThreadTaskManager:
         self._tasks: Dict[str, Dict[str, Any]] = {}
         self._lock = threading.Lock()  # Use a lock to control concurrent operations
 
-    def add(self, cancel_obj: Any, skip_obj: Any, pause_ctx: Any, task_id: str) -> None:
+    def add(self, cancel_obj: Any, terminate_obj: Any, pause_ctx: Any, task_id: str) -> None:
         """
         Add task control objects to the dictionary.
 
         :param cancel_obj: An object that has a cancel method.
-        :param skip_obj: An object that has a skip method.
+        :param terminate_obj: An object that has a terminate method.
         :param pause_ctx: An object that has a pause method.
         :param task_id: Task ID, used as the key in the dictionary.
         """
@@ -26,7 +26,7 @@ class ThreadTaskManager:
                 logger.warning(f"Task with task_id '{task_id}' already exists, overwriting")
             self._tasks[task_id] = {
                 'cancel': cancel_obj,
-                'skip': skip_obj,
+                'terminate': terminate_obj,
                 'pause': pause_ctx
             }
 
@@ -74,28 +74,28 @@ class ThreadTaskManager:
                 self._tasks.keys()):  # Use list(self._tasks.keys()) to avoid errors due to dictionary size changes
             self.cancel_task(task_id)
 
-    def skip_task(self, task_id: str) -> None:
+    def terminate_task(self, task_id: str) -> None:
         """
-        Skip the task based on task_id.
+        Terminate the task based on task_id.
 
         :param task_id: Task ID.
         """
         with self._lock:  # Acquire the lock to ensure thread-safe operations
             if task_id in self._tasks:
                 try:
-                    self._tasks[task_id]['skip'].skip()
+                    self._tasks[task_id]['terminate'].terminate()
                 except Exception as error:
                     logger.error(error)
             else:
                 logger.warning(f"No task found with task_id '{task_id}', operation invalid")
 
-    def skip_all_tasks(self) -> None:
+    def terminate_all_tasks(self) -> None:
         """
-        Skip all tasks in the dictionary.
+        Terminate all tasks in the dictionary.
         """
         for task_id in list(
                 self._tasks.keys()):  # Use list(self._tasks.keys()) to avoid errors due to dictionary size changes
-            self.skip_task(task_id)
+            self.terminate_task(task_id)
 
     def pause_task(self, task_id: str) -> None:
         """

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/scheduler/cpu_asyncio_task.py

@@ -12,9 +12,11 @@ from typing import Callable, Dict, Tuple, Optional, Any
 from ..common import logger
 from ..config import config
 from ..manager import task_status_manager
-from ..control import ProcessTaskManager, skip_on_demand, StopException
+from ..control import ProcessTaskManager, ThreadTerminator, StopException
 from ..utils import worker_initializer_asyncio
 
+_threadterminator = ThreadTerminator()
+
 
 async def _execute_task_async(task: Tuple[bool, str, str, Callable, Tuple, Dict],
                               task_status_queue: queue.Queue, task_manager: Any) -> Any:
@@ -36,8 +38,8 @@ async def _execute_task_async(task: Tuple[bool, str, str, Callable, Tuple, Dict]
     """
     timeout_processing, task_name, task_id, func, args, kwargs = task
 
-    with skip_on_demand() as skip_ctx:
-        task_manager.add(skip_ctx, None, task_id)
+    with _threadterminator.terminate_control() as terminate_ctx:
+        task_manager.add(terminate_ctx, None, task_id)
 
         task_status_queue.put(("running", task_id, None, time.time(), None, None, None))
         logger.debug(f"Start running cpu asyncio task, task ID: {task_id}")

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/scheduler/cpu_liner_task.py

@@ -12,13 +12,14 @@ from typing import Callable, Dict, Tuple, Optional, Any
 from ..common import logger
 from ..config import config
 from ..manager import task_status_manager
-from ..control import skip_on_demand, ProcessTaskManager, StopException, ThreadingTimeout, TimeoutException, \
-    ThreadController
+from ..control import ThreadTerminator, ProcessTaskManager, StopException, ThreadingTimeout, TimeoutException, \
+    ThreadSuspender
 from ..utils import worker_initializer_liner
 from ..scheduler_tools import TaskCounter
 
 _task_counter = TaskCounter("cpu_liner_task")
-_controller = ThreadController()
+_threadsuspender = ThreadSuspender()
+_threadterminator = ThreadTerminator()
 
 
 def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict],
@@ -47,9 +48,9 @@ def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict],
     return_results = None
 
     try:
-        with skip_on_demand() as skip_ctx:
-            with _controller.control_context() as ctrlp_ctx:
-                task_manager.add(skip_ctx, ctrlp_ctx, task_id)
+        with _threadterminator.terminate_control() as terminate_ctx:
+            with _threadsuspender.suspend_context() as pause_ctx:
+                task_manager.add(terminate_ctx, pause_ctx, task_id)
 
                 task_status_queue.put(("running", task_id, None, time.time(), None, None, None))
                 logger.debug(f"Start running cpu linear task, task ID: {task_id}")
@@ -386,7 +387,7 @@ class CpuLinerTask:
         if not future.running():
             future.cancel()
         else:
-            self._task_signal_transmission.put(task_id, "kill")
+            self._task_signal_transmission.put((task_id, "kill"))
 
         self._task_status_queue.put(("cancelled", task_id, None, None, None, None, None))
         with self._lock:
@@ -410,10 +411,10 @@ class CpuLinerTask:
 
         else:
             if action == "pause":
-                self._task_signal_transmission.put(task_id, "pause")
+                self._task_signal_transmission.put((task_id, "pause"))
                 self._task_status_queue.put(("waiting", task_id, None, None, None, None, None))
             elif action == "resume":
-                self._task_signal_transmission.put(task_id, "resume")
+                self._task_signal_transmission.put((task_id, "resume"))
                 self._task_status_queue.put(("running", task_id, None, None, None, None, None))
 
         return True

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/scheduler/io_asyncio_task.py

@@ -402,7 +402,7 @@ class IoAsyncioTask:
         if not future.running():
             future.cancel()
         else:
-            _task_manager.skip_task(task_id)
+            _task_manager.terminate_task(task_id)
 
         with self._condition:
             if task_id in self._task_results:

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/scheduler/io_liner_task.py

@@ -11,14 +11,15 @@ from typing import Callable, Dict, Tuple, Optional, Any
 from ..common import logger
 from ..config import config
 from ..manager import task_status_manager
-from ..control import ThreadTaskManager, skip_on_demand, StopException, ThreadingTimeout, TimeoutException, \
-    ThreadController
+from ..control import ThreadTaskManager, ThreadTerminator, StopException, ThreadingTimeout, TimeoutException, \
+    ThreadSuspender
 from ..scheduler_tools import TaskCounter
 
 # Create Manager instance
 _task_manager = ThreadTaskManager()
 _task_counter = TaskCounter("io_liner_task")
-_controller = ThreadController()
+_threadsuspender = ThreadSuspender()
+_threadterminator = ThreadTerminator()
 
 
 def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict]) -> Any:
@@ -41,13 +42,14 @@ def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict]) -> Any:
 
     return_results = None
     try:
-        with skip_on_demand() as skip_ctx:
-            with _controller.control_context() as ctrlp_ctx:
+        with _threadterminator.terminate_control() as terminate_ctx:
+            with _threadsuspender.suspend_context() as pause_ctx:
 
-                _task_manager.add(None, skip_ctx, ctrlp_ctx, task_id)
+                _task_manager.add(None, terminate_ctx, pause_ctx, task_id)
 
                 task_status_manager.add_task_status(task_id, None, "running", time.time(), None, None, None, None)
                 logger.debug(f"Start running io linear task, task ID: {task_id}")
+
                 if timeout_processing:
                     with ThreadingTimeout(seconds=config["watch_dog_time"], swallow_exc=False):
                         return_results = func(*args, **kwargs)
@@ -196,7 +198,7 @@ class IoLinerTask:
             if force_cleanup:
                 logger.debug("Force stopping scheduler and cleaning up tasks")
                 # Force stop all running tasks
-                _task_manager.skip_all_tasks()
+                _task_manager.terminate_all_tasks()
                 self._scheduler_stop_event.set()
             else:
                 self._scheduler_stop_event.set()
@@ -334,7 +336,7 @@ class IoLinerTask:
         if not future.running():
             future.cancel()
         else:
-            _task_manager.skip_task(task_id)
+            _task_manager.terminate_task(task_id)
 
         task_status_manager.add_task_status(task_id, None, "cancelled", None, None, None, None, None)
         with self._lock:

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling/scheduler/timer_task.py

@@ -11,10 +11,11 @@ from typing import Callable, Dict, List, Tuple, Optional, Any
 from ..common import logger
 from ..config import config
 from ..manager import task_status_manager
-from ..control import ThreadTaskManager, skip_on_demand, StopException, ThreadingTimeout, TimeoutException
+from ..control import ThreadTaskManager, ThreadTerminator, StopException, ThreadingTimeout, TimeoutException
 
 # Create Manager instance
 _task_manager = ThreadTaskManager()
+_threadterminator = ThreadTerminator()
 
 
 def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict]) -> Any:
@@ -37,20 +38,22 @@ def _execute_task(task: Tuple[bool, str, str, Callable, Tuple, Dict]) -> Any:
 
     return_results = None
     try:
-        task_status_manager.add_task_status(task_id, None, "running", time.time(), None, None,
-                                            None, None)
+        with _threadterminator.terminate_control() as terminate_ctx:
+            _task_manager.add(None, terminate_ctx, None, task_id)
+            task_status_manager.add_task_status(task_id, None, "running", time.time(), None, None,
+                                                None, None)
+
+            logger.debug(f"Start running timer task, task ID: {task_id}")
+
+            if timeout_processing:
+                with ThreadingTimeout(seconds=config["watch_dog_time"], swallow_exc=False):
 
-        logger.debug(f"Start running timer task, task ID: {task_id}")
-        if timeout_processing:
-            with ThreadingTimeout(seconds=config["watch_dog_time"], swallow_exc=False):
-                with skip_on_demand() as skip_ctx:
-                    _task_manager.add(None, skip_ctx, None, task_id)
                     return_results = func(*args, **kwargs)
-        else:
-            with skip_on_demand() as skip_ctx:
-                _task_manager.add(None, skip_ctx, task_id)
+            else:
                 return_results = func(*args, **kwargs)
-        _task_manager.remove(task_id)
+
+            _task_manager.remove(task_id)
+
     except TimeoutException:
         logger.debug(f"Timer task | {task_id} | timed out, forced termination")
         task_status_manager.add_task_status(task_id, None, "timeout", None, None, None,
@@ -200,7 +203,7 @@ class TimerTask:
             if force_cleanup:
                 logger.debug("Force stopping scheduler and cleaning up tasks")
                 # Force stop all running tasks
-                _task_manager.skip_all_tasks()
+                _task_manager.terminate_all_tasks()
                 self._scheduler_stop_event.set()
             else:
                 self._scheduler_stop_event.set()
@@ -358,7 +361,7 @@ class TimerTask:
         if not future.running():
             future.cancel()
         else:
-            _task_manager.skip_task(task_id)
+            _task_manager.terminate_task(task_id)
 
         task_status_manager.add_task_status(task_id, None, "cancelled", None, None, None, None, None)
         with self._lock:

{task_scheduling-2.3.0 → task_scheduling-2.3.2/task_scheduling.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: task_scheduling
-Version: 2.3.0
+Version: 2.3.2
 Summary: It is mainly used for task scheduling
 Home-page: https://github.com/fallingmeteorite/task_scheduling
 Author: fallingmeteorite
@@ -81,7 +81,9 @@ pip install --upgrade task_scheduling
 ```
 
 # Interface UI
+
 Use the function in code
+
 ```
 
 from task_scheduling.task_info import start_task_status_ui
@@ -95,13 +97,16 @@ Task status UI available at http://localhost:8000
 # Function introduction
 
 ## Tips
+
 1.Detailed information requires changing the log level to `debug`.
 
-2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating tasks by injecting exceptions.
+2.This scheduler does not support terminating blocking tasks due to various factors, so it only supports terminating
+tasks by injecting exceptions.
 
 3.Most of the API calls for this task scheduling can be added to the scheduler for execution as tasks.
 
 4.The log display level is available
+
 ```
 from task_scheduling.common import set_log_level
 
@@ -110,7 +115,9 @@ set_log_level("DEBUG") # INFO, DEBUG, ERROR, WARNING
 if __name__ == "__main__":
     ......
 ```
-5.The task priority is modified to high when necessary, and the task will start executing directly after submission. However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
+
+5.The task priority is modified to high when necessary, and the task will start executing directly after submission.
+However, this can also cause some running tasks to pause to free up resources to run high-priority tasks
 
 ### Function: task_creation(delay: int or None, daily_time: str or None, function_type: str, timeout_processing: bool, task_name: str, func: Callable, *args, **kwargs) -> str or None:
 
@@ -376,6 +383,78 @@ if __name__ == "__main__":
 
 ```
 
+### pause_and_resume_task(self, task_id: str, action: str) -> bool:
+
+A function is used to pause a task and resume running at a specified time.
+
+```
+import asyncio
+import time
+
+from task_scheduling.utils import interruptible_sleep
+
+
+def line_task(input_info):
+    for i in range(10):
+        interruptible_sleep(1)
+        print(input_info)
+
+
+async def asyncio_task(input_info):
+    for i in range(10):
+        await asyncio.sleep(1)
+        print(input_info)
+
+
+input_info = "test"
+
+from task_scheduling.common import set_log_level
+
+set_log_level("DEBUG")
+if __name__ == "__main__":
+    from task_scheduling.task_creation import task_creation, shutdown
+    from task_scheduling.task_info import start_task_status_ui
+    from task_scheduling.scheduler import io_liner_task
+
+    start_task_status_ui()
+    from task_scheduling.variable import *
+
+    task_id1 = task_creation(None,
+                             # This is how long the delay is executed (in seconds)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the daily_time is not required
+                             None,
+                             # This is to be performed at what point (24-hour clock)
+                             # This parameter is required when the function_type is "timer",if this parameter is used, the delay is not required
+                             scheduler_io,
+                             # Running function type, there are "io, cpu, timer"
+                             True,
+                             # Set to True to enable timeout detection, tasks that do not finish within the runtime will be forcibly terminated
+                             "task2",
+                             # Task ID, in linear tasks, tasks with the same ID will be queued, different IDs will be executed directly, the same applies to asynchronous tasks
+                             line_task,
+                             # The function to be executed, parameters should not be passed here
+                             priority_low,
+                             # The task priority is modified to high when necessary, and the task will start executing directly after submission
+                             input_info
+                             # Pass the parameters required by the function, no restrictions
+                             )
+
+    # cf478b6e-5e02-49b8-9031-4adc6ff915c2, cf478b6e-5e02-49b8-9031-4adc6ff915c2
+    time.sleep(2.0)
+    print("Pause")
+    io_liner_task.pause_and_resume_task(task_id1, "pause")
+    time.sleep(4.0)
+    print("Resume")
+    io_liner_task.pause_and_resume_task(task_id1, "resume")
+
+    try:
+        while True:
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        shutdown(True)
+
+```
+
 ### FunctionRunner(self, func: Callable, task_name: str, *args, **kwargs) -> None:
 
 A task that detects what type of function is executed. The detected parameters are stored in a file and read directly at
@@ -818,9 +897,11 @@ if __name__ == "__main__":
 ### force_stop_task(task_id: str) -> bool:
 
 All 4 schedulers have this function for terminating a running task. Warning: If the function is executing a
-process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the function
+process-blocking function such as `time.sleep`, it will have to wait for the execution to finish before terminating the
+function
 
 Warn!!! `cpu_liner_task.force_stop_task()` is different and requires the addition of additional parameters
+
 ```
 import asyncio
 import time

{task_scheduling-2.3.0 → task_scheduling-2.3.2}/task_scheduling.egg-info/SOURCES.txt

@@ -20,7 +20,7 @@ task_scheduling/config/config.yaml
 task_scheduling/control/__init__.py
 task_scheduling/control/pause_run.py
 task_scheduling/control/process_manager.py
-task_scheduling/control/skip_run.py
+task_scheduling/control/terminate_run.py
 task_scheduling/control/thread_manager.py
 task_scheduling/control/timeout_run.py
 task_scheduling/control/utils.py

task_scheduling-2.3.0/task_scheduling/control/skip_run.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-# Author: fallingmeteorite
-
-import ctypes
-import threading
-from contextlib import contextmanager
-
-
-class StopException(Exception):
-    """Custom timeout exception"""
-    pass
-
-
-def _async_raise(target_tid, exception):
-    """Raise an asynchronous exception in the target thread"""
-    ret = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(target_tid), ctypes.py_object(exception))
-    if ret == 0:
-        raise ValueError("Invalid thread ID {}".format(target_tid))
-    elif ret > 1:
-        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(target_tid), None)
-        raise SystemError("PyThreadState_SetAsyncExc failed")
-
-
-class _SkipContext:
-    """Context object for skipping the current line"""
-
-    def __init__(self):
-        self._target_tid = threading.current_thread().ident
-
-    def skip(self):
-        """Skip the current line"""
-        _async_raise(self._target_tid, StopException)
-
-
-@contextmanager
-def skip_on_demand():
-    """Context manager that supports manual skipping of the current line"""
-    _skip_ctx = _SkipContext()
-    yield _skip_ctx  # Provide _skip_ctx to external code