zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/task/notifier.py

@@ -1,42 +1,48 @@
-from zrb.helper.typing import (
-    Any, Callable, Iterable, Optional, Union, JinjaTemplate
-)
+import os
+import subprocess
+
+from zrb.helper.accessories.icon import get_random_icon
+from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
-from zrb.task.base_task.base_task import BaseTask
+from zrb.helper.typing import Any, Callable, Iterable, JinjaTemplate, Optional, Union
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.base_task.base_task import BaseTask
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
-from zrb.helper.accessories.icon import get_random_icon
-from zrb.helper.string.modification import double_quote
-
-import os
-import subprocess
 
 CURRENT_DIR = os.path.dirname(__file__)
-NOTIFY_PS1_PATH = os.path.realpath(os.path.abspath(os.path.join(
-    os.path.dirname(CURRENT_DIR), 'shell-scripts', 'notify.ps1'
-)))
+NOTIFY_PS1_PATH = os.path.realpath(
+    os.path.abspath(
+        os.path.join(os.path.dirname(CURRENT_DIR), "shell-scripts", "notify.ps1")
+    )
+)
 
 
 @typechecked
 class Notifier(BaseTask):
     def __init__(
         self,
-        name: str = 'port-check',
+        name: str = "port-check",
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
-        title: JinjaTemplate = '',
-        message: JinjaTemplate = '',
+        description: str = "",
+        title: JinjaTemplate = "",
+        message: JinjaTemplate = "",
         show_toast: bool = True,
         show_stdout: bool = True,
         upstreams: Iterable[AnyTask] = [],
@@ -50,7 +56,7 @@ class Notifier(BaseTask):
         checking_interval: Union[int, float] = 0,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
-        should_execute: Union[bool, str, Callable[..., bool]] = True
+        should_execute: Union[bool, str, Callable[..., bool]] = True,
     ):
         BaseTask.__init__(
             self,
@@ -76,8 +82,8 @@ class Notifier(BaseTask):
             retry_interval=retry_interval,
             should_execute=should_execute,
         )
-        self._title = title if title != '' else name
-        self._message = message if message != '' else get_random_icon()
+        self._title = title if title != "" else name
+        self._message = message if message != "" else get_random_icon()
         self._show_toast = show_toast
         self._show_stdout = show_stdout
 
@@ -86,32 +92,37 @@ class Notifier(BaseTask):
         message = self.render_str(self._message)
         notify_kwargs = {
             key: value
-            for key, value in kwargs.items() if key not in ('title', 'message')
+            for key, value in kwargs.items()
+            if key not in ("title", "message")
         }
         await self.notify(title, message, **notify_kwargs)
         return message
 
     async def notify(self, title: str, message: str, **kwargs: Any) -> None:
-        task: BaseTask = kwargs.get('_task')
+        task: BaseTask = kwargs.get("_task")
         if self._show_toast and _is_powershell_available():
             cmd = [
-                'powershell.exe',
-                '-ExecutionPolicy', 'Bypass',
-                '-File', NOTIFY_PS1_PATH,
-                '-Title', title,
-                '-Message', message
+                "powershell.exe",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                NOTIFY_PS1_PATH,
+                "-Title",
+                title,
+                "-Message",
+                message,
             ]
             subprocess.run(cmd, stdout=subprocess.DEVNULL)
         if self._show_toast and _is_osascript_available():
             q_message = double_quote(message)
             q_title = double_quote(title)
             cmd = [
-                'osascript',
-                '-e',
-                f'display notification "{q_message}" with title "{q_title}"'
+                "osascript",
+                "-e",
+                f'display notification "{q_message}" with title "{q_title}"',
             ]
         if self._show_toast and _is_notify_send_available():
-            cmd = ['notify-send', title, message]
+            cmd = ["notify-send", title, message]
             subprocess.run(cmd, stdout=subprocess.DEVNULL)
         if self._show_stdout:
             task.print_out(message)
@@ -121,9 +132,10 @@ class Notifier(BaseTask):
 def _is_powershell_available():
     try:
         subprocess.run(
-            ['powershell.exe', '-Command', 'echo "Checking PowerShell"'],
-            check=True, stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
+            ["powershell.exe", "-Command", 'echo "Checking PowerShell"'],
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
         )
         return True
     except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):
@@ -133,10 +145,10 @@ def _is_powershell_available():
 def _is_notify_send_available():
     try:
         subprocess.run(
-            ['notify-send', '--version'],
+            ["notify-send", "--version"],
             check=True,
             stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
+            stderr=subprocess.DEVNULL,
         )
         return True
     except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):
@@ -146,10 +158,10 @@ def _is_notify_send_available():
 def _is_osascript_available():
     try:
         subprocess.run(
-            ['osascript', '-e', 'return'],
+            ["osascript", "-e", "return"],
             check=True,
             stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
+            stderr=subprocess.DEVNULL,
         )
         return True
     except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):

zrb/task/parallel.py

@@ -1,10 +1,10 @@
-from zrb.helper.typing import TypeVar, List, Union
 from abc import ABC, abstractmethod
+
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import List, TypeVar, Union
 from zrb.task.any_task import AnyTask
 
-
-TParallel = TypeVar('TParallel', bound='Parallel')
+TParallel = TypeVar("TParallel", bound="Parallel")
 
 
 class AnyParallel(ABC):

zrb/task/path_checker.py

@@ -1,34 +1,46 @@
+from zrb.helper.file.match import get_file_names
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Optional, Union, TypeVar, JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    List,
+    Optional,
+    TypeVar,
+    Union,
 )
-from zrb.helper.typecheck import typechecked
-from zrb.helper.file.match import get_file_names
-from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.checker import Checker
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-TPathChecker = TypeVar('TPathChecker', bound='PathChecker')
+TPathChecker = TypeVar("TPathChecker", bound="PathChecker")
 
 
 @typechecked
 class PathChecker(Checker):
-
     def __init__(
         self,
-        name: str = 'check-path',
+        name: str = "check-path",
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         upstreams: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
@@ -37,12 +49,12 @@ class PathChecker(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        path: JinjaTemplate = '',
+        path: JinjaTemplate = "",
         ignored_path: Union[JinjaTemplate, Iterable[JinjaTemplate]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True
+        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):
         Checker.__init__(
             self,
@@ -69,7 +81,7 @@ class PathChecker(Checker):
         )
         self._path = path
         self._ignored_path = ignored_path
-        self._rendered_path: str = ''
+        self._rendered_path: str = ""
         self._rendered_ignored_paths: List[str] = []
 
     def copy(self) -> TPathChecker:
@@ -77,43 +89,38 @@ class PathChecker(Checker):
 
     def to_function(
         self,
-        env_prefix: str = '',
+        env_prefix: str = "",
         raise_error: bool = True,
         is_async: bool = False,
-        show_done_info: bool = True
+        show_done_info: bool = True,
     ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix, raise_error, is_async, show_done_info
-        )
+        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)
         self._rendered_ignored_paths = [
             ignored_path
             for ignored_path in self._get_rendered_ignored_paths()
-            if ignored_path != ''
+            if ignored_path != ""
         ]
         return await super().run(*args, **kwargs)
 
     def _get_rendered_ignored_paths(self) -> List[str]:
         if isinstance(self._ignored_path, str):
             return [self.render_str(self._ignored_path)]
-        return [
-            self.render_str(ignored_path)
-            for ignored_path in self._ignored_path
-        ]
+        return [self.render_str(ignored_path) for ignored_path in self._ignored_path]
 
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        label = f'Checking {self._rendered_path}'
+        label = f"Checking {self._rendered_path}"
         try:
             matches = get_file_names(
                 glob_path=self._rendered_path,
-                glob_ignored_paths=self._rendered_ignored_paths
+                glob_ignored_paths=self._rendered_ignored_paths,
             )
             if len(matches) > 0:
-                self.print_out(f'{label} (Exist)')
+                self.print_out(f"{label} (Exist)")
                 return True
-            self.show_progress(f'{label} (Not Exist)')
+            self.show_progress(f"{label} (Not Exist)")
         except Exception:
-            self.show_progress(f'{label} Cannot inspect')
+            self.show_progress(f"{label} Cannot inspect")
         return False

zrb/task/path_watcher.py

@@ -1,27 +1,40 @@
+import os
+
+from zrb.helper.file.match import get_file_names
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Mapping, Optional, Union, TypeVar,
-    JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    List,
+    Mapping,
+    Optional,
+    TypeVar,
+    Union,
 )
-from zrb.helper.typecheck import typechecked
-from zrb.helper.file.match import get_file_names
-from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.checker import Checker
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import os
-
-TPathWatcher = TypeVar('TPathWatcher', bound='PathWatcher')
+TPathWatcher = TypeVar("TPathWatcher", bound="PathWatcher")
 
 
 @typechecked
 class PathWatcher(Checker):
-    '''
+    """
     PathWatcher will wait for any changes specified on  path.
 
     Once the changes detected, PathWatcher will be completed
@@ -30,18 +43,18 @@ class PathWatcher(Checker):
     - <task-name>.new-file
     - <task-name>.modified-file
     - <task-name>.deleted-file
-    '''
+    """
 
     def __init__(
         self,
-        name: str = 'watch-path',
+        name: str = "watch-path",
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         upstreams: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
@@ -50,14 +63,14 @@ class PathWatcher(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        path: JinjaTemplate = '',
+        path: JinjaTemplate = "",
         ignored_path: Union[JinjaTemplate, Iterable[JinjaTemplate]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 30,
         watch_new_files: bool = True,
         watch_modified_files: bool = True,
         watch_deleted_files: bool = True,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True
+        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):
         Checker.__init__(
             self,
@@ -86,7 +99,7 @@ class PathWatcher(Checker):
         self._watch_new_files = watch_new_files
         self._watch_modified_files = watch_modified_files
         self._watch_deleted_files = watch_deleted_files
-        self._rendered_path: str = ''
+        self._rendered_path: str = ""
         self._rendered_ignored_paths: List[str] = []
         self._init_times: Mapping[str, float] = {}
 
@@ -95,21 +108,19 @@ class PathWatcher(Checker):
 
     def to_function(
         self,
-        env_prefix: str = '',
+        env_prefix: str = "",
         raise_error: bool = True,
         is_async: bool = False,
-        show_done_info: bool = True
+        show_done_info: bool = True,
     ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix, raise_error, is_async, show_done_info
-        )
+        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)
         self._rendered_ignored_paths = [
             ignored_path
             for ignored_path in self._get_rendered_ignored_paths()
-            if ignored_path != ''
+            if ignored_path != ""
         ]
         self._init_times = self._get_mod_times()
         return await super().run(*args, **kwargs)
@@ -117,50 +128,48 @@ class PathWatcher(Checker):
     def _get_rendered_ignored_paths(self) -> List[str]:
         if isinstance(self._ignored_path, str):
             return [self.render_str(self._ignored_path)]
-        return [
-            self.render_str(ignored_path)
-            for ignored_path in self._ignored_path
-        ]
+        return [self.render_str(ignored_path) for ignored_path in self._ignored_path]
 
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        label = f'Watching {self._rendered_path}'
+        label = f"Watching {self._rendered_path}"
         try:
             mod_times = self._get_mod_times()
         except Exception as e:
-            self.show_progress(f'{label} Cannot inspect')
+            self.show_progress(f"{label} Cannot inspect")
             raise e
         # watch changes
         if self._watch_new_files:
             new_files = mod_times.keys() - self._init_times.keys()
             for file in new_files:
-                self.print_out_dark(f'{label} [+] New file detected: {file}')
-                self.set_task_xcom('new-file', file)
-                self.set_task_xcom('file', file)
+                self.print_out_dark(f"{label} [+] New file detected: {file}")
+                self.set_task_xcom("new-file", file)
+                self.set_task_xcom("file", file)
                 return True
         if self._watch_deleted_files:
             deleted_files = self._init_times.keys() - mod_times.keys()
             for file in deleted_files:
-                self.print_out_dark(f'{label} [-] File deleted: {file}')
-                self.set_task_xcom('deleted-file', file)
-                self.set_task_xcom('file', file)
+                self.print_out_dark(f"{label} [-] File deleted: {file}")
+                self.set_task_xcom("deleted-file", file)
+                self.set_task_xcom("file", file)
                 return True
         if self._watch_modified_files:
             modified_files = {
-                file for file, mod_time in mod_times.items()
+                file
+                for file, mod_time in mod_times.items()
                 if file in mod_times and self._init_times[file] != mod_time
             }
             for file in modified_files:
-                self.print_out_dark(f'{label} [/] File modified: {file}')
-                self.set_task_xcom('modified-file', file)
-                self.set_task_xcom('file', file)
+                self.print_out_dark(f"{label} [/] File modified: {file}")
+                self.set_task_xcom("modified-file", file)
+                self.set_task_xcom("file", file)
                 return True
-        self.show_progress(f'{label} (Nothing changed)')
+        self.show_progress(f"{label} (Nothing changed)")
         return False
 
     def _get_mod_times(self) -> Mapping[str, float]:
         matches = get_file_names(
             glob_path=self._rendered_path,
-            glob_ignored_paths=self._rendered_ignored_paths
+            glob_ignored_paths=self._rendered_ignored_paths,
         )
         mod_times: Mapping[str, float] = {}
         for file_name in matches:

zrb/task/port_checker.py

@@ -1,45 +1,56 @@
+import socket
+
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, Optional, Union, TypeVar, JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    Optional,
+    TypeVar,
+    Union,
 )
-from zrb.task.checker import Checker
-from zrb.helper.typecheck import typechecked
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.checker import Checker
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import socket
-
-TPortChecker = TypeVar('TPortChecker', bound='PortChecker')
+TPortChecker = TypeVar("TPortChecker", bound="PortChecker")
 
 
 @typechecked
-class PortConfig():
+class PortConfig:
     def __init__(self, host: str, port: int, timeout: int):
         self.host = host
         self.port = port
         self.timeout = timeout
-        self.label = f'Checking {host}:{port}'
+        self.label = f"Checking {host}:{port}"
 
 
 @typechecked
 class PortChecker(Checker):
-
     def __init__(
         self,
-        name: str = 'check-port',
+        name: str = "check-port",
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
-        host: JinjaTemplate = 'localhost',
+        description: str = "",
+        host: JinjaTemplate = "localhost",
         port: Union[int, JinjaTemplate] = 80,
         timeout: Union[int, JinjaTemplate] = 5,
         upstreams: Iterable[AnyTask] = [],
@@ -53,7 +64,7 @@ class PortChecker(Checker):
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
-        should_execute: Union[bool, str, Callable[..., bool]] = True
+        should_execute: Union[bool, str, Callable[..., bool]] = True,
     ):
         Checker.__init__(
             self,
@@ -88,20 +99,18 @@ class PortChecker(Checker):
 
     def to_function(
         self,
-        env_prefix: str = '',
+        env_prefix: str = "",
         raise_error: bool = True,
         is_async: bool = False,
-        show_done_info: bool = True
+        show_done_info: bool = True,
     ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix, raise_error, is_async, show_done_info
-        )
+        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._config = PortConfig(
             host=self.render_str(self._host),
             port=self.render_int(self._port),
-            timeout=self.render_int(self._timeout)
+            timeout=self.render_int(self._timeout),
         )
         return await super().run(*args, **kwargs)
 
@@ -109,13 +118,11 @@ class PortChecker(Checker):
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                 sock.settimeout(self._config.timeout)
-                result = sock.connect_ex(
-                    (self._config.host, self._config.port)
-                )
+                result = sock.connect_ex((self._config.host, self._config.port))
                 if result == 0:
-                    self.print_out(f'{self._config.label} (OK)')
+                    self.print_out(f"{self._config.label} (OK)")
                     return True
-                self.show_progress(f'{self._config.label} (Not OK)')
+                self.show_progress(f"{self._config.label} (Not OK)")
         except Exception:
-            self.show_progress(f'{self._config.label} (Socker error)')
+            self.show_progress(f"{self._config.label} (Socker error)")
         return False