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

zrb/task/base_task/component/base_task_model.py

@@ -1,30 +1,42 @@
+import datetime
+import logging
+import os
+import sys
+from functools import lru_cache
+
+from zrb.config.config import env_prefix, logging_level, show_time
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
+from zrb.helper.string.conversion import to_variable_name
+from zrb.helper.string.modification import double_quote
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Mapping, Optional, Union, JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    List,
+    Mapping,
+    Optional,
+    Union,
 )
-from zrb.helper.typecheck import typechecked
-from zrb.config.config import show_time, logging_level
 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.helper.log import logger
-from zrb.helper.accessories.color import colored
-from zrb.task_input.any_input import AnyInput
-from zrb.task_group.group import Group
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
 from zrb.task.base_task.component.common_task_model import CommonTaskModel
 from zrb.task.base_task.component.pid_model import PidModel
 from zrb.task.base_task.component.trackers import TimeTracker
-from zrb.config.config import env_prefix
-from zrb.helper.string.modification import double_quote
-from zrb.helper.string.conversion import to_variable_name
-from functools import lru_cache
-
-import datetime
-import logging
-import os
-import sys
+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
 
 LOG_NAME_LENGTH = 20
 
@@ -35,7 +47,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         self,
         name: str,
         group: Optional[Group] = None,
-        description: str = '',
+        description: str = "",
         inputs: List[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
@@ -55,7 +67,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-        return_upstream_result: bool = False
+        return_upstream_result: bool = False,
     ):
         self.__rjust_full_cli_name: Optional[str] = None
         self.__has_cli_interface = False
@@ -84,7 +96,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             on_retry=on_retry,
             on_failed=on_failed,
             should_execute=should_execute,
-            return_upstream_result=return_upstream_result
+            return_upstream_result=return_upstream_result,
         )
         PidModel.__init__(self)
         TimeTracker.__init__(self)
@@ -92,77 +104,67 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         self.__kwargs: Mapping[str, Any] = {}
 
     def _set_args(self, args: Iterable[Any]):
-        '''
+        """
         Set args that will be shown at the end of the execution
-        '''
+        """
         self.__args = list(args)
 
     def _set_kwargs(self, kwargs: Mapping[str, Any]):
-        '''
+        """
         Set kwargs that will be shown at the end of the execution
-        '''
+        """
         self.__kwargs = kwargs
 
     def log_debug(self, message: Any):
         if logging_level > logging.DEBUG:
             return
         prefix = self.__get_log_prefix()
-        colored_message = colored(
-            f'{prefix} • {message}', attrs=['dark']
-        )
+        colored_message = colored(f"{prefix} • {message}", attrs=["dark"])
         logger.debug(colored_message)
 
     def log_warn(self, message: Any):
         if logging_level > logging.WARNING:
             return
         prefix = self.__get_log_prefix()
-        colored_message = colored(
-            f'{prefix} • {message}', attrs=['dark']
-        )
+        colored_message = colored(f"{prefix} • {message}", attrs=["dark"])
         logger.warning(colored_message)
 
     def log_info(self, message: Any):
         if logging_level > logging.INFO:
             return
         prefix = self.__get_log_prefix()
-        colored_message = colored(
-            f'{prefix} • {message}', attrs=['dark']
-        )
+        colored_message = colored(f"{prefix} • {message}", attrs=["dark"])
         logger.info(colored_message)
 
     def log_error(self, message: Any):
         if logging_level > logging.ERROR:
             return
         prefix = self.__get_log_prefix()
-        colored_message = colored(
-            f'{prefix} • {message}', color='red', attrs=['bold']
-        )
+        colored_message = colored(f"{prefix} • {message}", color="red", attrs=["bold"])
         logger.error(colored_message, exc_info=True)
 
     def log_critical(self, message: Any):
         if logging_level > logging.CRITICAL:
             return
         prefix = self.__get_log_prefix()
-        colored_message = colored(
-            f'{prefix} • {message}', color='red', attrs=['bold']
-        )
+        colored_message = colored(f"{prefix} • {message}", color="red", attrs=["bold"])
         logger.critical(colored_message, exc_info=True)
 
     def print_out(self, message: Any, trim_message: bool = True):
         prefix = self.__get_colored_print_prefix()
-        message_str = f'{message}'.rstrip() if trim_message else f'{message}'
-        print(f'🤖 ○ {prefix} • {message_str}', file=sys.stderr)
+        message_str = f"{message}".rstrip() if trim_message else f"{message}"
+        print(f"🤖 ○ {prefix} • {message_str}", file=sys.stderr)
         sys.stderr.flush()
 
     def print_err(self, message: Any, trim_message: bool = True):
         prefix = self.__get_colored_print_prefix()
-        message_str = f'{message}'.rstrip() if trim_message else f'{message}'
-        print(f'🤖 △ {prefix} • {message_str}', file=sys.stderr)
+        message_str = f"{message}".rstrip() if trim_message else f"{message}"
+        print(f"🤖 △ {prefix} • {message_str}", file=sys.stderr)
         sys.stderr.flush()
 
     def print_out_dark(self, message: Any, trim_message: bool = True):
-        message_str = f'{message}'
-        self.print_out(colored(message_str, attrs=['dark']), trim_message)
+        message_str = f"{message}"
+        self.print_out(colored(message_str, attrs=["dark"]), trim_message)
 
     def _print_result(self, result: Any):
         if result is None:
@@ -180,19 +182,19 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         print(result)
 
     def _play_bell(self):
-        print('\a', end='', file=sys.stderr, flush=True)
+        print("\a", end="", file=sys.stderr, flush=True)
 
     def _show_done_info(self):
         elapsed_time = self._get_elapsed_time()
-        self.print_out_dark(f'Completed in {elapsed_time} seconds')
+        self.print_out_dark(f"Completed in {elapsed_time} seconds")
         self._play_bell()
 
     def _show_env_prefix(self):
-        if env_prefix == '':
+        if env_prefix == "":
             return
-        colored_env_prefix = colored(env_prefix, color='yellow')
-        colored_label = colored('Your current environment: ', attrs=['dark'])
-        print(colored(f'{colored_label}{colored_env_prefix}'), file=sys.stderr)
+        colored_env_prefix = colored(env_prefix, color="yellow")
+        colored_label = colored("Your current environment: ", attrs=["dark"])
+        print(colored(f"{colored_label}{colored_env_prefix}"), file=sys.stderr)
 
     def _show_run_command(self):
         if not self.__has_cli_interface:
@@ -204,15 +206,15 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             key = task_input.get_name()
             kwarg_key = to_variable_name(key)
             quoted_value = double_quote(str(self.__kwargs[kwarg_key]))
-            params.append(f'--{key} {quoted_value}')
+            params.append(f"--{key} {quoted_value}")
         run_cmd = self._get_full_cli_name()
         run_cmd_with_param = run_cmd
         if len(params) > 0:
-            param_str = ' '.join(params)
-            run_cmd_with_param += ' ' + param_str
-        colored_command = colored(run_cmd_with_param, color='yellow')
-        colored_label = colored('To run again: ', attrs=['dark'])
-        print(colored(f'{colored_label}{colored_command}'), file=sys.stderr)
+            param_str = " ".join(params)
+            run_cmd_with_param += " " + param_str
+        colored_command = colored(run_cmd_with_param, color="yellow")
+        colored_label = colored("To run again: ", attrs=["dark"])
+        print(colored(f"{colored_label}{colored_command}"), file=sys.stderr)
 
     def __get_colored_print_prefix(self) -> str:
         return self.__get_colored(self.__get_print_prefix())
@@ -225,51 +227,51 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         icon = self.get_icon()
         length = LOG_NAME_LENGTH - len(icon)
         rjust_cli_name = self.__get_rjust_full_cli_name(length)
-        return f'{common_prefix} {icon} {rjust_cli_name}'
+        return f"{common_prefix} {icon} {rjust_cli_name}"
 
     def __get_log_prefix(self) -> str:
         common_prefix = self.__get_common_prefix(show_time=False)
         icon = self.get_icon()
         length = LOG_NAME_LENGTH - len(icon)
         filled_name = self.__get_rjust_full_cli_name(length)
-        return f'{common_prefix} {icon} {filled_name}'
+        return f"{common_prefix} {icon} {filled_name}"
 
     def __get_common_prefix(self, show_time: bool) -> str:
         attempt = self._get_attempt()
         max_attempt = self._get_max_attempt()
         pid = str(self._get_task_pid()).rjust(6)
         if show_time:
-            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
-            return f'◷ {now} ❁ {pid} → {attempt}/{max_attempt}'
-        return f'❁ {pid} → {attempt}/{max_attempt}'
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+            return f"◷ {now} ❁ {pid} → {attempt}/{max_attempt}"
+        return f"❁ {pid} → {attempt}/{max_attempt}"
 
     @lru_cache
     def __get_rjust_full_cli_name(self, length: int) -> str:
         if self.__rjust_full_cli_name is not None:
             return self.__rjust_full_cli_name
         complete_name = self._get_full_cli_name()
-        self.__rjust_full_cli_name = complete_name.rjust(length, ' ')
+        self.__rjust_full_cli_name = complete_name.rjust(length, " ")
         return self.__rjust_full_cli_name
 
     @lru_cache
     def __get_executable_name(self) -> str:
-        if len(sys.argv) > 0 and sys.argv[0] != '':
+        if len(sys.argv) > 0 and sys.argv[0] != "":
             return os.path.basename(sys.argv[0])
-        return 'zrb'
+        return "zrb"
 
     @lru_cache
     def _get_full_cli_name(self) -> str:
         if self.__complete_name is not None:
             return self.__complete_name
-        executable_prefix = ''
+        executable_prefix = ""
         if self.__has_cli_interface:
-            executable_prefix += self.__get_executable_name() + ' '
+            executable_prefix += self.__get_executable_name() + " "
         cli_name = self.get_cli_name()
         if self._group is None:
-            self.__complete_name = f'{executable_prefix}{cli_name}'
+            self.__complete_name = f"{executable_prefix}{cli_name}"
             return self.__complete_name
         group_cli_name = self._group._get_full_cli_name()
-        self.__complete_name = f'{executable_prefix}{group_cli_name} {cli_name}'  # noqa
+        self.__complete_name = f"{executable_prefix}{group_cli_name} {cli_name}"  # noqa
         return self.__complete_name
 
     def _set_has_cli_interface(self):

zrb/task/base_task/component/common_task_model.py

@@ -1,31 +1,44 @@
+import os
+
+from zrb.helper.accessories.color import get_random_color
+from zrb.helper.accessories.icon import get_random_icon
+from zrb.helper.string.conversion import to_cli_name
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Mapping, Optional, Union, JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    List,
+    Mapping,
+    Optional,
+    Union,
 )
-from zrb.helper.typecheck import typechecked
+from zrb.helper.util import coalesce_str
+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.any_task import AnyTask
-from zrb.helper.string.conversion import to_cli_name
-from zrb.helper.accessories.color import get_random_color
-from zrb.helper.accessories.icon import get_random_icon
-from zrb.helper.util import coalesce_str
-from zrb.task_input.any_input import AnyInput
-from zrb.task_group.group import Group
 from zrb.task_env.constant import RESERVED_ENV_NAMES
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
-
-import os
+from zrb.task_group.group import Group
+from zrb.task_input.any_input import AnyInput
 
 
 @typechecked
-class CommonTaskModel():
+class CommonTaskModel:
     def __init__(
         self,
         name: str,
         group: Optional[Group] = None,
-        description: str = '',
+        description: str = "",
         inputs: List[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
@@ -45,7 +58,7 @@ class CommonTaskModel():
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-        return_upstream_result: bool = False
+        return_upstream_result: bool = False,
     ):
         self._name = name
         self._group = group
@@ -72,7 +85,7 @@ class CommonTaskModel():
         self._on_failed = on_failed
         self._should_execute = should_execute
         self._return_upstream_result = return_upstream_result
-        self.__execution_id = ''
+        self.__execution_id = ""
         self.__allow_add_envs = True
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
@@ -88,7 +101,7 @@ class CommonTaskModel():
         self.__allow_add_upstreams = False
 
     def _set_execution_id(self, execution_id: str):
-        if self.__execution_id == '':
+        if self.__execution_id == "":
             self.__execution_id = execution_id
 
     def _propagate_execution_id(self):
@@ -142,12 +155,12 @@ class CommonTaskModel():
 
     def insert_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot insert inputs for `{self.get_name()}`')
+            raise Exception(f"Cannot insert inputs for `{self.get_name()}`")
         self._inputs = list(inputs) + list(self._inputs)
 
     def add_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot add inputs for `{self.get_name()}`')
+            raise Exception(f"Cannot add inputs for `{self.get_name()}`")
         self._inputs = list(self._inputs) + list(inputs)
 
     def inject_inputs(self):
@@ -160,9 +173,9 @@ class CommonTaskModel():
         return list(self._inputs)
 
     def _get_combined_inputs(self) -> Iterable[AnyInput]:
-        ''''
+        """'
         Getting all inputs of this task and all its upstream, non-duplicated.
-        '''
+        """
         if self.__all_inputs is not None:
             return self.__all_inputs
         self.__all_inputs: List[AnyInput] = []
@@ -197,12 +210,12 @@ class CommonTaskModel():
 
     def insert_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot insert envs to `{self.get_name()}`')
+            raise Exception(f"Cannot insert envs to `{self.get_name()}`")
         self._envs = list(envs) + list(self._envs)
 
     def add_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot add envs to `{self.get_name()}`')
+            raise Exception(f"Cannot add envs to `{self.get_name()}`")
         self._envs = list(self._envs) + list(envs)
 
     def inject_envs(self):
@@ -233,12 +246,12 @@ class CommonTaskModel():
 
     def insert_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
-            raise Exception(f'Cannot insert env_files to `{self.get_name()}`')
+            raise Exception(f"Cannot insert env_files to `{self.get_name()}`")
         self._env_files = list(env_files) + list(self._env_files)
 
     def add_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
-            raise Exception(f'Cannot add env_files to `{self.get_name()}`')
+            raise Exception(f"Cannot add env_files to `{self.get_name()}`")
         self._env_files = list(self._env_files) + list(env_files)
 
     def inject_env_files(self):
@@ -246,12 +259,12 @@ class CommonTaskModel():
 
     def insert_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot insert upstreams to `{self.get_name()}`')
+            raise Exception(f"Cannot insert upstreams to `{self.get_name()}`")
         self._upstreams = list(upstreams) + list(self._upstreams)
 
     def add_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot add upstreams to `{self.get_name()}`')
+            raise Exception(f"Cannot add upstreams to `{self.get_name()}`")
         self._upstreams = list(self._upstreams) + list(upstreams)
 
     def inject_upstreams(self):
@@ -277,13 +290,13 @@ class CommonTaskModel():
 
     def insert_checker(self, *checkers: AnyTask):
         if not self.__allow_add_checkers:
-            raise Exception(f'Cannot insert checkers to `{self.get_name()}`')
+            raise Exception(f"Cannot insert checkers to `{self.get_name()}`")
         additional_checkers = [checker.copy() for checker in checkers]
         self._checkers = additional_checkers + self._checkers
 
     def add_checker(self, *checkers: AnyTask):
         if not self.__allow_add_checkers:
-            raise Exception(f'Cannot add checkers to `{self.get_name()}`')
+            raise Exception(f"Cannot add checkers to `{self.get_name()}`")
         additional_checkers = [checker.copy() for checker in checkers]
         self._checkers = self._checkers + additional_checkers
 

zrb/task/base_task/component/pid_model.py

@@ -1,11 +1,10 @@
-from zrb.helper.typecheck import typechecked
-
 import os
 
+from zrb.helper.typecheck import typechecked
+
 
 @typechecked
-class PidModel():
-
+class PidModel:
     def __init__(self):
         self.__task_pid: int = os.getpid()
 
@@ -14,4 +13,3 @@ class PidModel():
 
     def _get_task_pid(self) -> int:
         return self.__task_pid
-

zrb/task/base_task/component/renderer.py

@@ -1,28 +1,28 @@
-from zrb.task.any_task import AnyTask
-from zrb.helper.typing import Any, JinjaTemplate, Mapping, Optional, Union
-from zrb.helper.typecheck import typechecked
-from zrb.helper.string.conversion import to_boolean
-from zrb.helper.string.jinja import is_probably_jinja
-from zrb.helper.render_data import DEFAULT_RENDER_DATA
-
 import os
+
 import jinja2
 
+from zrb.helper.render_data import DEFAULT_RENDER_DATA
+from zrb.helper.string.conversion import to_boolean
+from zrb.helper.string.jinja import is_probably_jinja
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Any, JinjaTemplate, Mapping, Optional, Union
+from zrb.task.any_task import AnyTask
+
 
 class AnyExtensionFileSystemLoader(jinja2.FileSystemLoader):
     def get_source(self, environment, template):
         for search_dir in self.searchpath:
             file_path = os.path.join(search_dir, template)
             if os.path.exists(file_path):
-                with open(file_path, 'r') as file:
+                with open(file_path, "r") as file:
                     contents = file.read()
                 return contents, file_path, lambda: False
         raise jinja2.TemplateNotFound(template)
 
 
 @typechecked
-class Renderer():
-
+class Renderer:
     def __init__(self):
         self.__input_map: Mapping[str, Any] = {}
         self.__task: Optional[AnyTask] = None
@@ -47,9 +47,7 @@ class Renderer():
     def _set_env_map(self, key: str, val: str):
         self.__env_map[key] = val
 
-    def render_any(
-        self, value: Any, data: Optional[Mapping[str, Any]] = None
-    ) -> Any:
+    def render_any(self, value: Any, data: Optional[Mapping[str, Any]] = None) -> Any:
         if isinstance(value, str):
             return self.render_str(value, data)
         return value
@@ -57,16 +55,14 @@ class Renderer():
     def render_float(
         self,
         value: Union[JinjaTemplate, float],
-        data: Optional[Mapping[str, Any]] = None
+        data: Optional[Mapping[str, Any]] = None,
     ) -> float:
         if isinstance(value, str):
             return float(self.render_str(value, data))
         return value
 
     def render_int(
-        self,
-        value: Union[JinjaTemplate, int],
-        data: Optional[Mapping[str, Any]] = None
+        self, value: Union[JinjaTemplate, int], data: Optional[Mapping[str, Any]] = None
     ) -> int:
         if isinstance(value, str):
             return int(self.render_str(value, data))
@@ -75,16 +71,14 @@ class Renderer():
     def render_bool(
         self,
         value: Union[JinjaTemplate, bool],
-        data: Optional[Mapping[str, Any]] = None
+        data: Optional[Mapping[str, Any]] = None,
     ) -> bool:
         if isinstance(value, str):
             return to_boolean(self.render_str(value, data))
         return value
 
     def render_str(
-        self,
-        value: JinjaTemplate,
-        data: Optional[Mapping[str, Any]] = None
+        self, value: JinjaTemplate, data: Optional[Mapping[str, Any]] = None
     ) -> str:
         if value in self.__rendered_str:
             return self.__rendered_str[value]
@@ -95,24 +89,18 @@ class Renderer():
         try:
             rendered_text = template.render(render_data)
         except Exception:
-            raise Exception(
-                f'Fail to render "{value}" with data: {render_data}'
-            )
+            raise Exception(f'Fail to render "{value}" with data: {render_data}')
         self.__rendered_str[value] = rendered_text
         return rendered_text
 
     def render_file(
-        self,
-        path: JinjaTemplate,
-        data: Optional[Mapping[str, Any]] = None
+        self, path: JinjaTemplate, data: Optional[Mapping[str, Any]] = None
     ) -> str:
         location_dir = os.path.dirname(path)
-        env = jinja2.Environment(
-            loader=AnyExtensionFileSystemLoader([location_dir])
-        )
+        env = jinja2.Environment(loader=AnyExtensionFileSystemLoader([location_dir]))
         template = env.get_template(path)
         render_data = self.__get_render_data(additional_data=data)
-        render_data['TEMPLATE_DIR'] = location_dir
+        render_data["TEMPLATE_DIR"] = location_dir
         rendered_text = template.render(render_data)
         return rendered_text
 
@@ -128,10 +116,12 @@ class Renderer():
         if self.__render_data is not None:
             return self.__render_data
         render_data = dict(DEFAULT_RENDER_DATA)
-        render_data.update({
-            'env': self.__env_map,
-            'input': self.__input_map,
-            'task': self.__task,
-        })
+        render_data.update(
+            {
+                "env": self.__env_map,
+                "input": self.__input_map,
+                "task": self.__task,
+            }
+        )
         self.__render_data = render_data
         return render_data

zrb/task/base_task/component/trackers.py

@@ -1,15 +1,14 @@
-from zrb.helper.typing import Optional
-from zrb.helper.typecheck import typechecked
-
 import asyncio
 import time
 
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Optional
+
 LOG_NAME_LENGTH = 20
 
 
 @typechecked
-class TimeTracker():
-
+class TimeTracker:
     def __init__(self):
         self.__start_time: float = 0
         self.__end_time: float = 0
@@ -25,8 +24,7 @@ class TimeTracker():
 
 
 @typechecked
-class AttemptTracker():
-
+class AttemptTracker:
     def __init__(self, retry: int = 2):
         self.__retry = retry
         self.__attempt: int = 1
@@ -52,8 +50,7 @@ class AttemptTracker():
 
 
 @typechecked
-class FinishTracker():
-
+class FinishTracker:
     def __init__(self):
         self.__execution_queue: Optional[asyncio.Queue] = None
         self.__counter = 0