Revert "upload"

This reverts commit fe1defb.

Author: FusionSolutions

.github/workflows/python-package.yml

@@ -23,17 +23,14 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install mypy pyflakes
+        python -m pip install mypy
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
     - name: MyPy check
       run: |
-        mypy --strict fsSignal
-    - name: PyFlakes check
-      run: |
-        pyflakes fsSignal
+        mypy fsSignal
     - name: Install package
       run: |
         python setup.py install
-    - name: Test package
+    - name: Unittest
       run: |
-        python setup.py test
+        python -m fsSignal

.github/workflows/python-publish.yml

@@ -26,6 +26,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
+        python -m fsSignal
         pip install build
     - name: Build package
       run: python -m build

fsSignal/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.4"
+__version__ = "0.0.3"
 __doc__ = """
 Signal capturer v{}
 Copyright (C) 2021 Fusion Solutions KFT <contact@fusionsolutions.io>

fsSignal/__main__.py

@@ -0,0 +1,6 @@
+# Builtin modules
+import unittest
+# Local modules
+from .fsSignal import SignalTest
+# Program
+unittest.main(verbosity=2)

fsSignal/fsSignal.py

@@ -1,32 +1,24 @@
 # Builtin modules
 from __future__ import annotations
-import traceback,  signal as _signal
-from threading import Event
+import os, traceback, unittest, signal as _signal
+from threading import Timer, Event
 from time import monotonic, sleep
 from typing import Callable, Dict, Any, Iterator, Iterable, Optional, Union
-from types import FrameType
-# Third party modules
 # Local modules
 # Program
-Signals = _signal.Signals
-
 class KillSignal(Exception): pass
 
-class SignalIterator(Iterator[Any]):
+class SignalIterator(Iterator):
 	__slots__ = ("event", "it", "checkDelay", "lastCheck")
-	event:Event
-	it:Iterator[Any]
-	checkDelay:float
-	lastCheck:float
-	def __init__(self, event:Event, it:Iterable[Any], checkDelay:float=1.0):
-		self.event      = event
-		self.it         = it.__iter__()
-		self.checkDelay = checkDelay
-		self.lastCheck  = monotonic()
-	def __iter__(self) -> Iterator[Any]:
+	def __init__(self, event:Event, it:Iterable, checkDelay:float=1.0):
+		self.event:Event = event
+		self.it:Iterator = it.__iter__()
+		self.checkDelay:float = checkDelay
+		self.lastCheck:float = monotonic()
+	def __iter__(self) -> Iterator:
 		return self
 	def __next__(self) -> Any:
-		m = monotonic()
+		m:float = monotonic()
 		if m-self.lastCheck > self.checkDelay:
 			self.lastCheck = m
 			if self.event.is_set():
@@ -36,16 +28,11 @@ def __next__(self) -> Any:
 class BaseSignal:
 	_force:bool
 	@classmethod
-	def get(self) -> bool:
+	def check(self) -> bool:
 		if not isinstance(Signal._handler, Signal):
 			return False
 		return Signal._handler._check(self._force)
 	@classmethod
-	def check(self) -> None:
-		if not isinstance(Signal._handler, Signal):
-			return
-		return Signal._handler.get(self._force)
-	@classmethod
 	def checkSoft(self) -> bool:
 		if not isinstance(Signal._handler, Signal):
 			return False
@@ -61,15 +48,15 @@ def sleep(self, seconds:Union[int, float], raiseOnKill:bool=False) -> None:
 			return sleep(seconds)
 		return Signal._handler._sleep(seconds, raiseOnKill, self._force)
 	@classmethod
-	def signalSoftKill(self, *args:Any, **kwargs:Any) -> None:
+	def signalSoftKill(self, *args, **kwargs) -> None:
 		if isinstance(Signal._handler, Signal):
 			return Signal._handler._signalSoftKill(*args, **kwargs)
 	@classmethod
-	def signalHardKill(self, *args:Any, **kwargs:Any) -> None:
+	def signalHardKill(self, *args, **kwargs) -> None:
 		if isinstance(Signal._handler, Signal):
 			return Signal._handler._signalHardKill(*args, **kwargs)
 	@classmethod
-	def iter(self, it:Iterable[Any], checkDelay:float=1.0) -> Iterable[Any]:
+	def iter(self, it:Iterable, checkDelay:float=1.0) -> Iterable:
 		if not isinstance(Signal._handler, Signal):
 			return it
 		return Signal._handler._iter(it, checkDelay, self._force)
@@ -102,22 +89,16 @@ class HardSignal(BaseSignal):
 	_force:bool = True
 
 class Signal(HardSignal):
-	_handler:Optional[Signal] = None
-	softKillFn:Optional[Callable[[Signals, FrameType], Any]]
-	hardKillFn:Optional[Callable[[Signals, FrameType], Any]]
-	forceKillCounterFn:Optional[Callable[[int, int], Any]]
-	counter:int
-	forceCounter:int
 	eSoft:Event
 	eHard:Event
-	def __init__(self, softKillFn:Optional[Callable[[Signals, FrameType], Any]]=None,
-	hardKillFn:Optional[Callable[[Signals, FrameType], Any]]=None,
-	forceKillCounterFn:Optional[Callable[[int, int], Any]]=None, forceCounter:int=10):
-		self.softKillFn = softKillFn
-		self.hardKillFn = hardKillFn
-		self.forceKillCounterFn = forceKillCounterFn
-		self.counter = 0
-		self.forceCounter = forceCounter
+	_handler:Optional[Signal] = None
+	def __init__(self, softKillFn:Optional[Callable]=None, hardKillFn:Optional[Callable]=None,
+	forceKillCounterFn:Optional[Callable]=None, forceCounter:int=10):
+		self.softKillFn:Optional[Callable] = softKillFn
+		self.hardKillFn:Optional[Callable] = hardKillFn
+		self.forceKillCounterFn:Optional[Callable] = forceKillCounterFn
+		self.counter:int = 0
+		self.forceCounter:int = forceCounter
 		self.eSoft = Event()
 		self.eHard = Event()
 		Signal._handler = self
@@ -142,21 +123,16 @@ def __setstate__(self, states:Dict[str, Any]) -> None:
 	def _activate(self) -> None:
 		_signal.signal(_signal.SIGINT, Signal.signalSoftKill)
 		_signal.signal(_signal.SIGTERM, Signal.signalHardKill)
-	def _get(self, force:bool=True) -> bool:
+	def _check(self, force:bool=True) -> bool:
 		if force:
 			return self.eHard.is_set()
 		return self.eSoft.is_set()
-	def _check(self, force:bool=True) -> None:
-		if (force and self.eHard.is_set()) or (not force and self.eSoft.is_set()):
-			raise KillSignal
-		return None
 	def _sleep(self, seconds:Union[int, float], raiseOnKill:bool=False, force:bool=True) -> None:
 		if (self.eHard if force else self.eSoft).wait(float(seconds)) and raiseOnKill:
 			raise KillSignal
-		return None
-	def _iter(self, it:Iterable[Any], checkDelay:float=1.0, force:bool=True) -> Iterator[Any]:
+	def _iter(self, it:Iterable, checkDelay:float=1.0, force:bool=True) -> Iterator:
 		return SignalIterator(self.eHard if force else self.eSoft, it, checkDelay)
-	def _signalSoftKill(self, *args:Any, **kwargs:Any) -> None:
+	def _signalSoftKill(self, *args, **kwargs) -> None:
 		self._softKill()
 		if not self.eHard.is_set():
 			self.counter += 1
@@ -167,26 +143,67 @@ def _signalSoftKill(self, *args:Any, **kwargs:Any) -> None:
 					traceback.print_exc()
 			if self.counter >= self.forceCounter:
 				self._hardKill()
-	def _signalHardKill(self, *args:Any, **kwargs:Any) -> None:
+	def _signalHardKill(self, *args, **kwargs) -> None:
 		self._softKill()
 		self._hardKill()
 	def _softKill(self) -> None:
 		if not self.eSoft.is_set():
 			self.eSoft.set()
 			if callable(self.softKillFn):
 				try:
-					self.softKillFn() # type: ignore
+					self.softKillFn()
 				except:
 					traceback.print_exc()
 	def _hardKill(self) -> None:
 		if not self.eHard.is_set():
 			self.eHard.set()
 			if callable(self.hardKillFn):
 				try:
-					self.hardKillFn() # type: ignore
+					self.hardKillFn()
 				except:
 					traceback.print_exc()
 	def _reset(self) -> None:
 		self.eSoft.clear()
 		self.eHard.clear()
 		self.counter = 0
+
+class SignalTest(unittest.TestCase):
+	rootSignal:Signal
+	@classmethod
+	def setUpClass(self) -> None:
+		self.rootSignal = Signal()
+	def tearDown(self) -> None:
+		self.rootSignal.reset()
+	def killmeTimer(self) -> None:
+		def suicide():
+			os.kill(os.getpid(), _signal.SIGINT)
+		Timer(1, suicide).start()
+	def test_sleep(self) -> None:
+		t:float = monotonic()
+		self.rootSignal.sleep(2)
+		self.assertGreater(monotonic()-t, 2.0)
+	def test_sleepRaise(self) -> None:
+		self.killmeTimer()
+		with self.assertRaises(KillSignal):
+			self.rootSignal.getSoftSignal().sleep(2, raiseOnKill=True)
+	def test_iter(self) -> None:
+		s:list = list(range(5))
+		d:list = []
+		i:int
+		signal:SoftSignal = self.rootSignal.getSoftSignal()
+		self.killmeTimer()
+		with self.assertRaises(KillSignal):
+			for i in s:
+				signal.sleep(0.5, raiseOnKill=True)
+				d.append(i)
+	def test_hardkill(self) -> None:
+		self.killmeTimer()
+		sleep(0.1)
+		self.killmeTimer()
+		sleep(0.1)
+		self.killmeTimer()
+		sleep(0.1)
+		self.rootSignal.forceCounter = 3
+		with self.assertRaises(KillSignal):
+			self.rootSignal.sleep(10, raiseOnKill=True)
+		self.rootSignal.forceCounter = 10

fsSignal/py.typed

@@ -17,13 +17,12 @@
 	author_email = "ifa@fusionsolutions.io",
 	url = "https://github.com/FusionSolutions/python-fssignal",
 	license = "GPL-3",
+	package_dir={"fsSignal": "fsSignal"},
 	packages=["fsSignal"],
 	long_description=open(os.path.join(pwd, "README.md")).read(),
 	long_description_content_type="text/markdown",
 	zip_safe=False,
 	python_requires=">=3.7.0",
-	test_suite="fsSignal.test",
-	package_data={ "":["py.typed"] },
 	classifiers=[ # https://pypi.org/pypi?%3Aaction=list_classifiers
 		"Development Status :: 4 - Beta",
 		"Topic :: Utilities",