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

zrb/task/time_watcher.py

@@ -1,42 +1,55 @@
+import datetime
+
+import croniter
+
+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.helper.typecheck import typechecked
-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 croniter
-import datetime
-
-TTimeWatcher = TypeVar('TTimeWatcher', bound='TimeWatcher')
+TTimeWatcher = TypeVar("TTimeWatcher", bound="TimeWatcher")
 
 
 @typechecked
 class TimeWatcher(Checker):
-    '''
+    """
     TimeWatcher will wait for any changes specified on  path.
 
     Once the changes detected, TimeWatcher will be completed
     and <task-name>.scheduled-time xcom will be set.
-    '''
+    """
 
     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,
@@ -45,10 +58,10 @@ class TimeWatcher(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        schedule: JinjaTemplate = '',
+        schedule: JinjaTemplate = "",
         checking_interval: Union[int, float] = 1,
         progress_interval: Union[int, float] = 30,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True
+        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):
         Checker.__init__(
             self,
@@ -74,42 +87,34 @@ class TimeWatcher(Checker):
         )
         self._schedule = schedule
         self._scheduled_time: Optional[datetime.datetime] = None
-        self._rendered_schedule: str = ''
+        self._rendered_schedule: str = ""
 
     def copy(self) -> TTimeWatcher:
         return super().copy()
 
     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_schedule = self.render_str(self._schedule)
         margin = datetime.timedelta(seconds=0.001)
         slightly_before_check_time = datetime.datetime.now() - margin
-        cron = croniter.croniter(
-            self._rendered_schedule, slightly_before_check_time
-        )
+        cron = croniter.croniter(self._rendered_schedule, slightly_before_check_time)
         self._scheduled_time = cron.get_next(datetime.datetime)
-        self.set_task_xcom(key='scheduled-time', value=self._scheduled_time)
+        self.set_task_xcom(key="scheduled-time", value=self._scheduled_time)
         return await super().run(*args, **kwargs)
 
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        label = f'Watching {self._rendered_schedule}'
+        label = f"Watching {self._rendered_schedule}"
         now = datetime.datetime.now()
         if now > self._scheduled_time:
-            self.print_out_dark(
-                f'{label} (Meet {self._scheduled_time})'
-            )
+            self.print_out_dark(f"{label} (Meet {self._scheduled_time})")
             return True
-        self.show_progress(
-            f'{label} (Waiting for {self._scheduled_time})'
-        )
+        self.show_progress(f"{label} (Waiting for {self._scheduled_time})")
         return False

zrb/task_env/constant.py

@@ -1 +1 @@
-RESERVED_ENV_NAMES = ('_ZRB_EXECUTION_ID',)
+RESERVED_ENV_NAMES = ("_ZRB_EXECUTION_ID",)

zrb/task_env/env.py

@@ -1,15 +1,17 @@
-from zrb.helper.typing import Optional, JinjaTemplate
+import os
+
+from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import JinjaTemplate, Optional
 from zrb.task_env.constant import RESERVED_ENV_NAMES
-from zrb.helper.string.modification import double_quote
-import os
 
 # flake8: noqa E501
 
+
 @typechecked
-class Env():
-    '''
-    Env Represents an environment configuration for a task, encapsulating details such as environment name, OS-specific 
+class Env:
+    """
+    Env Represents an environment configuration for a task, encapsulating details such as environment name, OS-specific
     environment name, default values, and rendering behavior.
 
     Attributes:
@@ -17,7 +19,7 @@ class Env():
         os_name (Optional[str]): The corresponding name in the OS's environment, if different from 'name'. You can set os_name to empty string if you don't want the environment to be linked to OS environment name.
         default (JinjaTemplate): Default value of the environment variable.
         should_render (bool): Flag to determine if the environment value should be rendered.
-    
+
     Examples:
         >>> from zrb import Env, Task
         >>> task = Task(
@@ -26,60 +28,60 @@ class Env():
         >>>         Env(name='DATABASE_URL', os_name='SYSTEM_DATABASE_URL', default='postgresql://...')
         >>>     ]
         >>> )
-    '''
+    """
 
     def __init__(
         self,
         name: str,
         os_name: Optional[str] = None,
-        default: JinjaTemplate = '',
+        default: JinjaTemplate = "",
         should_render: bool = True,
     ):
         if name in RESERVED_ENV_NAMES:
-            raise ValueError(f'Forbidden input name: {name}')
+            raise ValueError(f"Forbidden input name: {name}")
         self.__name: str = name
         self.__os_name: str = os_name if os_name is not None else name
         self.__default: str = default
         self.__should_render: bool = should_render
 
     def get_name(self) -> str:
-        '''
+        """
         Retrieves the name of the environment variable.
 
         Returns:
             str: The name of the environment variable.
-        '''
+        """
         return self.__name
 
     def get_os_name(self) -> Optional[str]:
-        '''
+        """
         Retrieves the OS-specific name of the environment variable.
 
         Returns:
             Optional[str]: The OS-specific name of the environment variable.
-        '''
+        """
         return self.__os_name
 
     def get_default(self) -> str:
-        '''
+        """
         Retrieves the default value of the environment variable.
 
         Returns:
             str: The default value of the environment variable.
-        '''
+        """
         return self.__default
 
     def should_render(self) -> bool:
-        '''
+        """
         Determines whether the environment value should be rendered.
 
         Returns:
             bool: True if the environment value should be rendered, False otherwise.
-        '''
+        """
         return self.__should_render
 
-    def get(self, prefix: str = '') -> str:
-        '''
+    def get(self, prefix: str = "") -> str:
+        """
         Retrieves the value of the environment variable, considering an optional prefix.
 
         Args:
@@ -97,21 +99,21 @@ class Env():
             >>> print(env.get('DEV'))   # will show 'localhost'
             >>> print(env.get('PROD'))  # will show 'example.com'
             >>> print(env.get('STAG'))  # will show '0.0.0.0'
-        '''
-        if self.__os_name == '':
+        """
+        if self.__os_name == "":
             return self.__default
         prefixed_name = self.__get_prefixed_name(self.__os_name, prefix)
-        if prefixed_name in os.environ and os.environ[prefixed_name] != '':
+        if prefixed_name in os.environ and os.environ[prefixed_name] != "":
             return os.environ[prefixed_name]
-        if self.__os_name in os.environ and os.environ[self.__os_name] != '':
+        if self.__os_name in os.environ and os.environ[self.__os_name] != "":
             return os.environ[self.__os_name]
         return self.__default
 
     def __get_prefixed_name(self, name: str, prefix: str):
-        '''
+        """
         Constructs the prefixed name of the environment variable.
 
-        This method is intended for internal use only. 
+        This method is intended for internal use only.
 
         Args:
             name (str): The base name of the environment variable.
@@ -119,14 +121,14 @@ class Env():
 
         Returns:
             str: The prefixed name of the environment variable.
-        '''
-        if prefix is None or prefix == '':
+        """
+        if prefix is None or prefix == "":
             return name
-        return prefix + '_' + name
+        return prefix + "_" + name
 
     def __repr__(self) -> str:
         cls_name = self.__class__.__name__
         name = double_quote(self.__name)
-        os_name = 'None' if self.__os_name is None else double_quote(self.__os_name)
+        os_name = "None" if self.__os_name is None else double_quote(self.__os_name)
         default = double_quote(self.__default)
-        return f'<{cls_name} {name} os_name={os_name} default={default}>'
+        return f"<{cls_name} {name} os_name={os_name} default={default}>"

zrb/task_env/env_file.py

@@ -1,16 +1,18 @@
-from zrb.helper.typing import List, Optional
-from zrb.helper.typecheck import typechecked
 from dotenv import dotenv_values
-from zrb.task_env.constant import RESERVED_ENV_NAMES
+
 from zrb.helper.string.modification import double_quote
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import List, Optional
+from zrb.task_env.constant import RESERVED_ENV_NAMES
 from zrb.task_env.env import Env
 
 # flake8: noqa E501
 
+
 @typechecked
-class EnvFile():
-    '''
-    Represents a handler for an environment file, facilitating the creation and management of environment variables 
+class EnvFile:
+    """
+    Represents a handler for an environment file, facilitating the creation and management of environment variables
     (Env objects) based on the contents of the specified environment file.
 
     Attributes:
@@ -28,13 +30,10 @@ class EnvFile():
         >>>         EnvFile(path=os.path.join(CURRENT_DIR, '.env'), prefix='SYSTEM')
         >>>     ]
         >>> )
-    '''
+    """
 
     def __init__(
-        self,
-        path: str,
-        prefix: Optional[str] = None,
-        should_render: bool = False
+        self, path: str, prefix: Optional[str] = None, should_render: bool = False
     ):
         self.__path = path
         self.__prefix = prefix.upper() if prefix is not None else None
@@ -43,8 +42,8 @@ class EnvFile():
         self.__env_list_fetched: bool = False
 
     def get_envs(self) -> List[Env]:
-        '''
-        Retrieves a list of Env objects based on the environment file. If a prefix is provided, it is 
+        """
+        Retrieves a list of Env objects based on the environment file. If a prefix is provided, it is
         applied to the environment variable names.
 
         Returns:
@@ -54,7 +53,7 @@ class EnvFile():
             >>> from zrb import Env, EnvFile
             >>> env_file = EnvFile(path='some_file.env')
             >>> envs: List[Env] = env_file.get_envs()
-        '''
+        """
         if self.__env_list_fetched:
             return self.__env_list
         env_list: List[Env] = []
@@ -63,14 +62,16 @@ class EnvFile():
             if key in RESERVED_ENV_NAMES:
                 continue
             os_name: Optional[str] = None
-            if self.__prefix is not None and self.__prefix != '':
-                os_name = f'{self.__prefix}_{key}'
-            env_list.append(Env(
-                name=key,
-                os_name=os_name,
-                default=value,
-                should_render=self.__should_render
-            ))
+            if self.__prefix is not None and self.__prefix != "":
+                os_name = f"{self.__prefix}_{key}"
+            env_list.append(
+                Env(
+                    name=key,
+                    os_name=os_name,
+                    default=value,
+                    should_render=self.__should_render,
+                )
+            )
         self.__env_list = env_list
         self.__env_list_fetched = True
         return env_list
@@ -79,4 +80,4 @@ class EnvFile():
         cls_name = self.__class__.__name__
         path = double_quote(self.__path)
         prefix = double_quote(self.__prefix)
-        return f'<{cls_name} path={path} prefix={prefix}>'
+        return f"<{cls_name} path={path} prefix={prefix}>"

zrb/task_group/group.py

@@ -1,20 +1,20 @@
-from zrb.helper.typing import List, Optional, TypeVar
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
 from zrb.helper.string.conversion import to_cli_name
 from zrb.helper.string.modification import double_quote
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import List, Optional, TypeVar
+from zrb.task.any_task import AnyTask
 
 # flake8: noqa E501
-TGroup = TypeVar('TGroup', bound='Group')
+TGroup = TypeVar("TGroup", bound="Group")
 
 
 @typechecked
-class Group():
-    '''
+class Group:
+    """
     Represents a group of tasks and subgroups, facilitating organization and hierarchy.
 
-    This class allows the creation of a hierarchical structure by grouping tasks and 
-    other task groups together. It provides methods to add tasks, retrieve tasks, 
+    This class allows the creation of a hierarchical structure by grouping tasks and
+    other task groups together. It provides methods to add tasks, retrieve tasks,
     and generate Command-Line Interface (CLI) names based on group names.
 
     Attributes:
@@ -26,13 +26,10 @@ class Group():
         >>> from zrb import Group
         >>> system_group = Group(name='system')
         >>> log_group = Group(name='log', parent='system')
-    '''
+    """
 
     def __init__(
-        self,
-        name: str,
-        description: str = '',
-        parent: Optional[TGroup] = None
+        self, name: str, description: str = "", parent: Optional[TGroup] = None
     ):
         self.__name = name
         self.__description = description
@@ -43,25 +40,25 @@ class Group():
         self.__tasks: List[AnyTask] = []
 
     def get_parent(self) -> Optional[TGroup]:
-        '''
+        """
         Retrieves parent of the Group.
 
         Returns:
             Optional[Group]: Parent of the group.
 
         Examples:
-            >>> from zrb import Group 
+            >>> from zrb import Group
             >>> system_group = Group(name='my system')
             >>> system_log_group = Group(name='log', parent=system_group)
             >>> print(system_group.get_parent())
             >>> print(system_log_group.get_parent())
             None
             <Group "my-system">
-        '''
+        """
         return self._parent
 
     def get_description(self) -> str:
-        '''
+        """
         Retrieves group description.
 
         Returns:
@@ -72,11 +69,11 @@ class Group():
             >>> group = Group(name='group', description='description of the group')
             >>> print(group.get_description())
             description of the group
-        '''
+        """
         return self.__description
 
     def get_cli_name(self) -> str:
-        '''
+        """
         Retrieves the CLI name of the group, formatted in kebab case.
 
         The method converts the group name into a CLI-friendly format, suitable for command-line usage.
@@ -89,11 +86,11 @@ class Group():
             >>> system_group = Group(name='my system')
             >>> print(system_group.get_cli_name())
             my-system
-        '''
+        """
         return to_cli_name(self.__name)
 
     def _get_full_cli_name(self) -> str:
-        '''
+        """
         Retrieves the full CLI name of the group, including names of parent groups.
 
         This method is intended for internal use and constructs a full CLI name that reflects the group's hierarchy.
@@ -107,15 +104,15 @@ class Group():
             >>> system_log_group = Group(name='log', parent=system_group)
             >>> print(system_log_group._get_full_cli_name())
             my-system log
-        '''
+        """
         cli_name = self.get_cli_name()
         if self._parent is None:
             return cli_name
         parent_cli_name = self._parent._get_full_cli_name()
-        return f'{parent_cli_name} {cli_name}'
+        return f"{parent_cli_name} {cli_name}"
 
     def _add_task(self, task: AnyTask):
-        '''
+        """
         Adds a task to the group.
 
         This method is intended for internal use. It appends a given task to the  group's task list.
@@ -132,11 +129,11 @@ class Group():
             >>> group._add_task(second_task)
             >>> print(group.get_tasks())
             [<Task "group first-task">, <Task "group second-task">]
-        '''
+        """
         self.__tasks.append(task)
 
     def get_tasks(self) -> List[AnyTask]:
-        '''
+        """
         Get direct Tasks under this Task Group.
 
         Returns:
@@ -149,11 +146,11 @@ class Group():
             >>> second_task = Task(name='second-task', group=group)
             >>> print(group.get_tasks())
             [<Task "group first-task">, <Task "group second-task">]
-        '''
+        """
         return self.__tasks
 
     def get_children(self) -> List[TGroup]:
-        '''
+        """
         Retrieves the list of direct subgroups under this group.
 
         Returns a list of immediate subgroups nested within this group, helping to understand the group's hierarchical structure.
@@ -168,10 +165,10 @@ class Group():
             >>> sub_group_2 = TaskGroup(name='sub-group-2', parent=group)
             >>> print(group.get_children())
             [<Group "group sub-group-1">, <Group "group sub-group-2">]
-        '''
+        """
         return self.__children
 
     def __repr__(self) -> str:
         cls_name = self.__class__.__name__
         full_cli_name = double_quote(self._get_full_cli_name())
-        return f'<{cls_name} {full_cli_name}>'
+        return f"<{cls_name} {full_cli_name}>"

zrb/task_input/any_input.py

@@ -1,72 +1,74 @@
-from zrb.helper.typing import Any, List, Mapping
 from abc import ABC, abstractmethod
 
+from zrb.helper.typing import Any, List, Mapping
+
 # flake8: noqa E501
 
+
 class AnyInput(ABC):
-    '''
+    """
     Abstract base class representing a generalized input specification.
-    This class serves as a template for creating various input types, 
+    This class serves as a template for creating various input types,
     providing a standardized interface for input handling and processing.
 
-    '''
+    """
 
     @abstractmethod
     def get_name(self) -> str:
-        '''
+        """
         Retrieves the name of the input.
 
         Returns:
             str: The name of the input.
-        '''
+        """
         pass
 
     @abstractmethod
     def get_default(self) -> Any:
-        '''
+        """
         Obtains the default value of the input.
 
         Returns:
             Any: The default value of the input. The type can be any, depending on the input specification.
-        '''
+        """
         pass
 
     @abstractmethod
     def get_param_decl(self) -> List[str]:
-        '''
+        """
         Fetches a list of parameter option associated with the input (i.e., `-f` or `--file`).
 
         Returns:
             List[str]: A list containing strings of parameter options.
-        '''
+        """
         pass
 
     @abstractmethod
     def get_options(self) -> Mapping[str, Any]:
-        '''
+        """
         Provides a mapping (dictionary) representing the input.
 
         Returns:
             Mapping[str, Any]: A dictionary where keys are option names and values are the corresponding details.
-        '''
+        """
         pass
 
     @abstractmethod
     def should_render(self) -> bool:
-        '''
+        """
         Determines whether or not the input should be rendered.
 
         Returns:
             bool: True if the input should be rendered, False otherwise.
-        '''
+        """
         pass
 
     @abstractmethod
     def is_hidden(self) -> bool:
-        '''
+        """
         Checks whether the input value is meant to be hidden from view or output.
 
         Returns:
             bool: True if the input is hidden, False otherwise.
-        '''
+        """
         pass