xkits-thread 0.1__tar.gz → 0.2__tar.gz

{xkits_thread-0.1 → xkits_thread-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xkits-thread
-Version: 0.1
+Version: 0.2
 Summary: Thread module
 Home-page: https://github.com/bondbox/xthreads/
 Author: Mingzhe Zou
@@ -16,8 +16,6 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: xkits-command>=0.2
-Requires-Dist: xkits-logger>=0.1
 Requires-Dist: xkits-lib>=0.1
 
 # xthreads

{xkits_thread-0.1 → xkits_thread-0.2}/xkits_thread/__init__.py

@@ -1,7 +1,7 @@
 # coding:utf-8
 
 from xkits_thread.executor import ThreadPool  # noqa:F401
-from xkits_thread.executor import hourglass  # noqa:F401
+from xkits_thread.executor import hourglass  # noqa:F401,H306
 from xkits_thread.lock import NamedLock  # noqa:F401
 from xkits_thread.task import DaemonTaskJob  # noqa:F401
 from xkits_thread.task import DelayTaskJob  # noqa:F401

{xkits_thread-0.1 → xkits_thread-0.2}/xkits_thread/attribute.py

@@ -1,7 +1,7 @@
 # coding:utf-8
 
 __project__ = "xkits-thread"
-__version__ = "0.1"
+__version__ = "0.2"
 __urlhome__ = "https://github.com/bondbox/xthreads/"
 __description__ = "Thread module"
 

{xkits_thread-0.1 → xkits_thread-0.2}/xkits_thread/executor.py

@@ -9,7 +9,6 @@ from typing import Optional
 from typing import Set
 from typing import Tuple
 
-from xkits_command.actuator import Command
 from xkits_lib.meter import TimeUnit
 
 
@@ -38,35 +37,29 @@ def hourglass(seconds: TimeUnit):
 
 
 class ThreadPool(ThreadPoolExecutor):
-    '''Thread Pool'''
+    """Thread Pool"""
 
     def __init__(self, max_workers: Optional[int] = None,
                  thread_name_prefix: str = "work_thread",
                  initializer: Optional[Callable] = None,
                  initargs: Tuple = ()):
-        '''Initializes an instance based on ThreadPoolExecutor.'''
-        self.__cmds: Command = Command()
+        """Initializes an instance based on ThreadPoolExecutor."""
         if isinstance(max_workers, int):
             max_workers = max(max_workers, 2)
         super().__init__(max_workers, thread_name_prefix, initializer, initargs)  # noqa:E501
 
-    @property
-    def cmds(self) -> Command:
-        '''command-line toolkit'''
-        return self.__cmds
-
     @property
     def alive_threads(self) -> Set[Thread]:
-        '''alive threads'''
+        """alive threads"""
         return {thread for thread in self._threads if thread.is_alive()}
 
     @property
     def other_threads(self) -> Set[Thread]:
-        '''other threads'''
+        """other threads"""
         current: Thread = current_thread()
         return {thread for thread in self._threads if thread is not current}
 
     @property
     def other_alive_threads(self) -> Set[Thread]:
-        '''other alive threads'''
+        """other alive threads"""
         return {thread for thread in self.other_threads if thread.is_alive()}

{xkits_thread-0.1 → xkits_thread-0.2}/xkits_thread/task.py

@@ -4,7 +4,6 @@ from queue import Queue
 import sys
 from threading import Lock
 from threading import Thread
-from threading import current_thread  # noqa:H306
 from time import sleep
 from typing import Any
 from typing import Callable
@@ -13,16 +12,14 @@ from typing import Optional
 from typing import Set
 from typing import Tuple
 
-from xkits_command.actuator import Command
 from xkits_lib.meter import CountMeter
 from xkits_lib.meter import StatusCountMeter
 from xkits_lib.meter import TimeMeter
 from xkits_lib.meter import TimeUnit
-from xkits_logger.logger import Logger
 
 
 class TaskJob():
-    '''Task Job'''
+    """Task Job"""
 
     def __init__(self, no: int, fn: Callable, *args: Any, **kwargs: Any):
         self.__no: int = no
@@ -43,38 +40,38 @@ class TaskJob():
 
     @property
     def id(self) -> int:
-        '''job id'''
+        """job id"""
         return self.__no
 
     @property
     def fn(self) -> Callable:
-        '''job callable function'''
+        """job callable function"""
         return self.__fn
 
     @property
     def args(self) -> Tuple[Any, ...]:
-        '''job callable arguments'''
+        """job callable arguments"""
         return self.__args
 
     @property
     def kwargs(self) -> Dict[str, Any]:
-        '''job callable keyword arguments'''
+        """job callable keyword arguments"""
         return self.__kwargs
 
     @property
     def result(self) -> Any:
-        '''job callable function return value'''
+        """job callable function return value"""
         if isinstance(self.__result, Exception):
             raise self.__result
         return self.__result
 
     @property
     def running_timer(self) -> TimeMeter:
-        '''job running timer'''
+        """job running timer"""
         return self.__running_timer
 
     def run(self) -> bool:
-        '''run job'''
+        """run job"""
         try:
             if self.running_timer.started:
                 raise RuntimeError(f"{self} is already started")
@@ -90,26 +87,26 @@ class TaskJob():
             self.running_timer.shutdown()
 
     def shutdown(self) -> None:
-        '''wait for job to finish'''
+        """wait for job to finish"""
         while self.running_timer.started:
             sleep(0.05)
 
     def startup(self) -> None:
-        '''same as run'''
+        """same as run"""
         self.run()
 
     def restart(self) -> None:
-        '''restart job'''
+        """restart job"""
         self.shutdown()
         self.startup()
 
     def barrier(self) -> None:
-        '''same as shutdown'''
+        """same as shutdown"""
         self.shutdown()
 
 
 class DelayTaskJob(TaskJob):
-    '''Delay Task Job'''
+    """Delay Task Job"""
     MIN_DELAY_TIME: float = 0.001
 
     def __init__(self, delay: TimeUnit, no: int, fn: Callable, *args: Any, **kwargs: Any):  # noqa:E501
@@ -123,34 +120,34 @@ class DelayTaskJob(TaskJob):
 
     @property
     def delay_timer(self) -> TimeMeter:
-        '''job delay timer'''
+        """job delay timer"""
         return self.__delay_timer
 
     @property
     def delay_time(self) -> float:
-        '''job delay time'''
+        """job delay time"""
         return self.__delay_time
 
     @property
     def waiting(self) -> bool:
-        '''job waiting to run'''
+        """job waiting to run"""
         return self.delay_timer.runtime < self.delay_time
 
     def renew(self, delay: Optional[TimeUnit] = None) -> None:
-        '''renew delay time'''
+        """renew delay time"""
         if delay is not None:
             self.__delay_time = float(max(delay, self.MIN_DELAY_TIME))
         self.delay_timer.restart()
 
     def run(self) -> bool:
-        '''run delay job'''
+        """run delay job"""
         self.delay_timer.alarm(self.delay_time)
         assert not self.waiting, f"{self} is waiting to run"
         return super().run()
 
 
 class DaemonTaskJob(TaskJob):
-    '''Daemon Task Job'''
+    """Daemon Task Job"""
 
     def __init__(self, no: int, fn: Callable, *args: Any, **kwargs: Any):
         self.__counter: StatusCountMeter = StatusCountMeter()
@@ -163,43 +160,44 @@ class DaemonTaskJob(TaskJob):
 
     @property
     def daemon_counter(self) -> StatusCountMeter:
-        '''daemon status counter'''
+        """daemon status counter"""
         return self.__counter
 
     @property
     def daemon_running(self) -> bool:
-        '''daemon running flag'''
+        """daemon running flag"""
         return self.__running
 
     def run_in_background(self) -> Thread:
-        '''run job in daemon mode in background'''
-        thread: Thread = Thread(target=self.run)
+        """run job in daemon mode in background"""
+        thread: Thread = Thread(target=self.run, daemon=True)
         thread.start()
         return thread
 
     def run(self):
-        '''run job in daemon mode in current thread'''
+        """run job in daemon mode in current thread"""
         self.__running = True
         while self.daemon_running:
             success: bool = super().run()
             self.daemon_counter.inc(success)
+            sleep(0.05 if success else 0.1)
 
     def shutdown(self) -> None:
-        '''wait for job to finish'''
+        """wait for job to finish"""
         self.__running = False
         super().shutdown()
 
     def startup(self) -> None:
-        '''same as run in background'''
+        """same as run in background"""
         self.run_in_background()
 
     def restart(self) -> None:
-        '''restart job'''
+        """restart job"""
         self.shutdown()
         self.startup()
 
     def barrier(self) -> None:
-        '''same as restart'''
+        """same as restart"""
         self.restart()
 
 
@@ -210,12 +208,11 @@ else:  # Python3.8 TypeError
 
 
 class TaskPool(Dict[int, TaskJob]):  # noqa: E501, pylint: disable=too-many-instance-attributes
-    '''Task Thread Pool'''
+    """Task Thread Pool"""
 
     def __init__(self, workers: int = 1, jobs: int = 0, prefix: str = "task"):
         wsize: int = max(workers, 1)
         qsize = max(wsize, jobs) if jobs > 0 else jobs
-        self.__cmds: Command = Command()
         self.__jobs: JobQueue = Queue(qsize)
         self.__prefix: str = prefix or "task"
         self.__status: StatusCountMeter = StatusCountMeter()
@@ -235,46 +232,37 @@ class TaskPool(Dict[int, TaskJob]):  # noqa: E501, pylint: disable=too-many-inst
 
     @property
     def jobs(self) -> JobQueue:
-        '''task jobs'''
+        """task jobs"""
         return self.__jobs
 
-    @property
-    def cmds(self) -> Command:
-        '''command-line toolkit'''
-        return self.__cmds
-
     @property
     def thread_name_prefix(self) -> str:
-        '''task thread name prefix'''
+        """task thread name prefix"""
         return self.__prefix
 
     @property
     def threads(self) -> Set[Thread]:
-        '''task threads'''
+        """task threads"""
         return self.__threads
 
     @property
     def running(self) -> bool:
-        '''task threads are started'''
+        """task threads are started"""
         return self.__running
 
     @property
     def workers(self) -> int:
-        '''task workers'''
+        """task workers"""
         return self.__workers
 
     @property
     def status_counter(self) -> StatusCountMeter:
-        '''task job status counter'''
+        """task job status counter"""
         return self.__status
 
     def task(self):
-        '''execute a task from jobs queue'''
+        """execute a task from jobs queue"""
         status_counter: StatusCountMeter = StatusCountMeter()
-
-        logger: Logger = self.cmds.logger
-        logger.debug("Task thread %s is running", current_thread().name)
-
         while True:
             job: Optional[TaskJob] = self.jobs.get(block=True)
             if job is None:  # stop task
@@ -292,9 +280,6 @@ class TaskPool(Dict[int, TaskJob]):  # noqa: E501, pylint: disable=too-many-inst
                 self.status_counter.inc(True)
                 status_counter.inc(True)
 
-        logger.debug("Task thread %s is stopped, %s", current_thread().name,
-                     f"{status_counter.total} jobs: {status_counter.success} success and {status_counter.failure} failure")  # noqa:E501
-
     def submit_job(self, job: TaskJob) -> TaskJob:
         assert isinstance(job, TaskJob), f"{job} is not a TaskJob"
         assert job.id not in self, f"{job} id is already in pool"
@@ -304,21 +289,20 @@ class TaskPool(Dict[int, TaskJob]):  # noqa: E501, pylint: disable=too-many-inst
         return job
 
     def submit_task(self, fn: Callable, *args: Any, **kwargs: Any) -> TaskJob:
-        '''submit a task to jobs queue'''
+        """submit a task to jobs queue"""
         with self.__intlock:  # generate job id under lock protection
             sn: int = self.__counter.inc()  # serial number
             return self.submit_job(TaskJob(sn, fn, *args, **kwargs))
 
     def submit_delay_task(self, delay: TimeUnit, fn: Callable, *args: Any, **kwargs: Any) -> TaskJob:  # noqa:E501
-        '''submit a delay task to jobs queue'''
+        """submit a delay task to jobs queue"""
         with self.__intlock:  # generate job id under lock protection
             sn: int = self.__counter.inc()  # serial number
             return self.submit_job(DelayTaskJob(delay, sn, fn, *args, **kwargs))  # noqa:E501
 
     def shutdown(self) -> None:
-        '''stop all task threads and waiting for all jobs finish'''
+        """stop all task threads and waiting for all jobs finish"""
         with self.__intlock:  # block submit new tasks
-            self.cmds.logger.debug("Shutdown %s tasks", self.thread_name_prefix)  # noqa:E501
             self.__running = False
             self.jobs.put(None)  # notice tasks
             while len(self.threads) > 0:
@@ -330,21 +314,20 @@ class TaskPool(Dict[int, TaskJob]):  # noqa: E501, pylint: disable=too-many-inst
                     raise RuntimeError(f"Unexecuted job: {job}")  # noqa:E501, pragma: no cover
 
     def startup(self) -> None:
-        '''start task threads'''
+        """start task threads"""
         with self.__intlock:
-            self.cmds.logger.debug("Startup %s tasks", self.thread_name_prefix)
             for i in range(self.workers):
                 thread_name: str = f"{self.thread_name_prefix}_{i}"
-                thread = Thread(name=thread_name, target=self.task)
+                thread = Thread(name=thread_name, target=self.task, daemon=True)  # noqa:E501
                 self.threads.add(thread)
                 thread.start()  # run
             self.__running = True
 
     def restart(self) -> None:
-        '''stop submit new tasks and waiting for all submitted tasks to end'''
+        """stop submit new tasks and waiting for all submitted tasks to end"""
         self.shutdown()
         self.startup()
 
     def barrier(self) -> None:
-        '''same as restart'''
+        """same as restart"""
         self.restart()

{xkits_thread-0.1 → xkits_thread-0.2}/xkits_thread.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xkits-thread
-Version: 0.1
+Version: 0.2
 Summary: Thread module
 Home-page: https://github.com/bondbox/xthreads/
 Author: Mingzhe Zou
@@ -16,8 +16,6 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: xkits-command>=0.2
-Requires-Dist: xkits-logger>=0.1
 Requires-Dist: xkits-lib>=0.1
 
 # xthreads

xkits_thread-0.2/xkits_thread.egg-info/requires.txt

@@ -0,0 +1 @@
+xkits-lib>=0.1

xkits_thread-0.1/xkits_thread.egg-info/requires.txt

@@ -1,3 +0,0 @@
-xkits-command>=0.2
-xkits-logger>=0.1
-xkits-lib>=0.1