zrb 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

zrb/helper/file/match.py

@@ -1,9 +1,13 @@
 import fnmatch
 import glob
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Iterable, List
 
+logger.debug(colored("Loading zrb.helper.file.match", attrs=["dark"]))
+
 
 @typechecked
 def get_file_names(glob_path: str, glob_ignored_paths: Iterable[str]) -> List[str]:

zrb/helper/file/text.py

@@ -2,8 +2,12 @@ import os
 
 import aiofiles
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 
+logger.debug(colored("Loading zrb.helper.file.text", attrs=["dark"]))
+
 
 @typechecked
 async def read_text_file_async(file_name: str) -> str:

zrb/helper/git/detect_changes.py

@@ -1,8 +1,12 @@
 import subprocess
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Mapping
 
+logger.debug(colored("Loading zrb.helper.git.detect_changes", attrs=["dark"]))
+
 
 @typechecked
 class ModificationState:

zrb/helper/loader/load_module.py

@@ -8,6 +8,8 @@ from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 
+logger.debug(colored("Loading zrb.helper.loader.load_module", attrs=["dark"]))
+
 pattern = re.compile("[^a-zA-Z0-9]")
 
 

zrb/helper/log.py

@@ -1,7 +1,7 @@
 import logging
 
 from zrb.config.config import logging_level
-from zrb.helper.accessories.color import colored
+from zrb.helper.accessories.untyped_color import untyped_colored as colored
 
 # create logger
 logger = logging.getLogger("zrb")

zrb/helper/map/conversion.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Mapping
 
+logger.debug(colored("Loading zrb.helper.map.conversion", attrs=["dark"]))
+
 
 @typechecked
 def to_str(

zrb/helper/python_task.py

@@ -1,10 +1,13 @@
 import sys
 
 from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.task import show_lines as task_show_lines
 from zrb.helper.typecheck import typechecked
 from zrb.task.task import Task
 
+logger.debug(colored("Loading zrb.helper.python_task", attrs=["dark"]))
+
 _DEPRECATION_WARNING = """
 DEPRECATED: zrb.helper.python_task
 Use zrb.helper.task instead

zrb/helper/render_data.py

@@ -3,6 +3,8 @@ import os
 import platform
 import time
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.util import (
     coalesce,
     coalesce_str,
@@ -14,6 +16,8 @@ from zrb.helper.util import (
     to_snake_case,
 )
 
+logger.debug(colored("Loading zrb.helper.render_data", attrs=["dark"]))
+
 DEFAULT_RENDER_DATA = {
     "datetime": datetime,
     "os": os,

zrb/helper/string/conversion.py

@@ -1,54 +1,31 @@
-import keyword
-import logging
-import re
-
-from zrb.helper.string.constant import FALSE_STRS, TRUE_STRS
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
+from zrb.helper.string.untyped_conversion import (
+    untyped_to_boolean,
+    untyped_to_cli_name,
+    untyped_to_logging_level,
+    untyped_to_variable_name,
+)
 from zrb.helper.typecheck import typechecked
 
-NON_WORD = re.compile(r"[\W]+")
-LEADING_NUM = re.compile(r"^\d+")
-LOGGING_LEVEL_MAP = {
-    "critical": logging.CRITICAL,
-    "fatal": logging.FATAL,
-    "error": logging.ERROR,
-    "warning": logging.WARNING,
-    "warn": logging.WARN,
-    "info": logging.INFO,
-    "debug": logging.DEBUG,
-    "notset": logging.NOTSET,
-}
+logger.debug(colored("Loading zrb.helper.string.conversion", attrs=["dark"]))
 
 
 @typechecked
 def to_cli_name(name: str) -> str:
-    return NON_WORD.sub("-", name).strip("-").lower()
+    return untyped_to_cli_name((name))
 
 
 @typechecked
 def to_variable_name(string: str) -> str:
-    # Replace any non-word characters with underscore
-    string = NON_WORD.sub("_", string).strip()
-    # Remove leading digits
-    string = LEADING_NUM.sub("", string)
-    # Convert to lowercase
-    string = string.lower()
-    if keyword.iskeyword(string):
-        return string + "_"
-    return string
+    return untyped_to_variable_name(string)
 
 
 @typechecked
 def to_boolean(string: str) -> bool:
-    if string.lower() in TRUE_STRS:
-        return True
-    if string.lower() in FALSE_STRS:
-        return False
-    raise Exception(f'Cannot infer boolean value from "{string}"')
+    return untyped_to_boolean(string)
 
 
 @typechecked
 def to_logging_level(logging_level_str: str) -> int:
-    lower_logging_level_str = logging_level_str.lower()
-    if lower_logging_level_str in LOGGING_LEVEL_MAP:
-        return LOGGING_LEVEL_MAP[lower_logging_level_str]
-    return logging.WARNING
+    return untyped_to_logging_level(logging_level_str)

zrb/helper/string/jinja.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any
 
+logger.debug(colored("Loading zrb.helper.string.jinja", attrs=["dark"]))
+
 
 @typechecked
 def is_probably_jinja(value: Any) -> bool:

zrb/helper/string/modification.py

@@ -1,5 +1,9 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 
+logger.debug(colored("Loading zrb.helper.string.modification", attrs=["dark"]))
+
 
 @typechecked
 def double_quote(text: str) -> str:

zrb/helper/string/parse_replacement.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Mapping
 
+logger.debug(colored("Loading zrb.helper.string.parse_replacment", attrs=["dark"]))
+
 
 @typechecked
 def parse_replacement(text: str, replacement: Mapping[str, str]):

zrb/helper/string/untyped_conversion.py

@@ -0,0 +1,49 @@
+import keyword
+import logging
+import re
+
+from zrb.helper.string.constant import FALSE_STRS, TRUE_STRS
+
+NON_WORD = re.compile(r"[\W]+")
+LEADING_NUM = re.compile(r"^\d+")
+LOGGING_LEVEL_MAP = {
+    "critical": logging.CRITICAL,
+    "fatal": logging.FATAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "warn": logging.WARN,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+    "notset": logging.NOTSET,
+}
+
+
+def untyped_to_cli_name(name: str) -> str:
+    return NON_WORD.sub("-", name).strip("-").lower()
+
+
+def untyped_to_variable_name(string: str) -> str:
+    # Replace any non-word characters with underscore
+    string = NON_WORD.sub("_", string).strip()
+    # Remove leading digits
+    string = LEADING_NUM.sub("", string)
+    # Convert to lowercase
+    string = string.lower()
+    if keyword.iskeyword(string):
+        return string + "_"
+    return string
+
+
+def untyped_to_boolean(string: str) -> bool:
+    if string.lower() in TRUE_STRS:
+        return True
+    if string.lower() in FALSE_STRS:
+        return False
+    raise Exception(f'Cannot infer boolean value from "{string}"')
+
+
+def untyped_to_logging_level(logging_level_str: str) -> int:
+    lower_logging_level_str = logging_level_str.lower()
+    if lower_logging_level_str in LOGGING_LEVEL_MAP:
+        return LOGGING_LEVEL_MAP[lower_logging_level_str]
+    return logging.WARNING

zrb/helper/task.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.task.task import Task
 
+logger.debug(colored("Loading zrb.helper.task", attrs=["dark"]))
+
 
 @typechecked
 def show_lines(task: Task, *lines: str):

zrb/helper/typecheck.py

@@ -1,17 +1,16 @@
-import os
 from typing import TypeVar
 
-from beartype import beartype
-
-from zrb.helper.string.constant import FALSE_STRS
-
-enable_type_checking_str = os.getenv("ZRB_ENABLE_TYPE_CHECKING", "1").lower()
-enable_type_checking = enable_type_checking_str not in FALSE_STRS
+from zrb.config.config import enable_type_checking
+from zrb.helper.accessories.untyped_color import untyped_colored as colored
+from zrb.helper.log import logger
 
+logger.debug(colored("Loading zrb.helper.typecheck", attrs=["dark"]))
 T = TypeVar("T")
 
 
 def typechecked(anything: T) -> T:
     if enable_type_checking:
+        from beartype import beartype
+
         return beartype(anything)
     return anything

zrb/helper/typing.py

@@ -1,15 +1,35 @@
-from beartype.typing import (
-    Any,
-    Callable,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from zrb.config.config import enable_type_checking
+from zrb.helper.accessories.untyped_color import untyped_colored as colored
+from zrb.helper.log import logger
+
+logger.debug(colored("Loading zrb.helper.typing", attrs=["dark"]))
+
+if enable_type_checking:
+    from beartype.typing import (
+        Any,
+        Callable,
+        Iterable,
+        List,
+        Mapping,
+        Optional,
+        Tuple,
+        Type,
+        TypeVar,
+        Union,
+    )
+else:
+    from typing import (
+        Any,
+        Callable,
+        Iterable,
+        List,
+        Mapping,
+        Optional,
+        Tuple,
+        Type,
+        TypeVar,
+        Union,
+    )
 
 JinjaTemplate = str
 

zrb/helper/util.py

@@ -2,10 +2,14 @@ import re
 
 import jinja2
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.string.conversion import to_boolean as conversion_to_boolean
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Optional
 
+logger.debug(colored("Loading zrb.helper.util", attrs=["dark"]))
+
 NON_ALPHA_NUM = re.compile(r"[^a-zA-Z0-9]+")
 
 

zrb/runner.py

@@ -1,4 +1,7 @@
 from zrb.action.runner import Runner
 from zrb.config.config import env_prefix
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 
+logger.debug(colored("Loading zrb.runner", attrs=["dark"]))
 runner = Runner(env_prefix=env_prefix)

zrb/task/any_task.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typing import (
     Any,
     Callable,
@@ -15,6 +17,8 @@ from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.any_task", attrs=["dark"]))
+
 # flake8: noqa E501
 TAnyTask = TypeVar("TAnyTask", bound="AnyTask")
 
@@ -304,6 +308,7 @@ class AnyTask(ABC):
         is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
         """
         Converts the current task into a callable function.

zrb/task/any_task_event_handler.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typing import Any, Callable
 from zrb.task.any_task import AnyTask
 
+logger.debug(colored("Loading zrb.task.any_task_event_handler", attrs=["dark"]))
+
 _TaskEventHandler = Callable[[AnyTask], Any]
 OnTriggered = _TaskEventHandler
 OnWaiting = _TaskEventHandler

zrb/task/base_remote_cmd_task.py

@@ -2,6 +2,8 @@ import copy
 import os
 import pathlib
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -31,6 +33,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.base_remote_cmd_task", attrs=["dark"]))
+
 TSingleBaseRemoteCmdTask = TypeVar(
     "TSingleBaseRemoteCmdTask", bound="SingleBaseRemoteCmdTask"
 )

zrb/task/base_task/base_task.py

@@ -26,6 +26,7 @@ from zrb.task.any_task_event_handler import (
 from zrb.task.base_task.component.base_task_model import BaseTaskModel
 from zrb.task.base_task.component.renderer import Renderer
 from zrb.task.base_task.component.trackers import AttemptTracker, FinishTracker
+from zrb.task.looper import looper
 from zrb.task.parallel import AnyParallel
 from zrb.task_env.env import Env, PrivateEnv
 from zrb.task_env.env_file import EnvFile
@@ -140,7 +141,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         xcom_dir = self.__get_xcom_dir()
         xcom_file = os.path.join(xcom_dir, key)
         with open(xcom_file, "w") as f:
-            f.write(value)
+            f.write(f"{value}")
 
     def get_xcom(self, key: str) -> str:
         self.__ensure_xcom_dir_exists()
@@ -164,6 +165,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
         async def function(*args: Any, **kwargs: Any) -> Any:
             self.log_info("Copy task")
@@ -175,6 +177,8 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
                 kwargs=kwargs,
                 show_done_info=show_done_info,
             )
+            if should_stop_looper:
+                looper.stop()
             if should_clear_xcom:
                 self_cp.clear_xcom()
             return result

zrb/task/checker.py

@@ -1,5 +1,7 @@
 import asyncio
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
 from zrb.task.any_task import AnyTask
@@ -18,6 +20,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.checker", attrs=["dark"]))
+
 
 @typechecked
 class Checker(BaseTask):
@@ -79,15 +83,15 @@ class Checker(BaseTask):
         while True:
             self._should_show_progress = wait_time >= self._progress_interval
             inspect_result = await self.inspect(*args, **kwargs)
-            if inspect_result == self._expected_result:
+            if inspect_result is not None and inspect_result == self._expected_result:
                 return True
             if wait_time >= self._progress_interval:
                 wait_time = 0
             await asyncio.sleep(self._checking_interval)
             wait_time += self._checking_interval
 
-    async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        return False
+    async def inspect(self, *args: Any, **kwargs: Any) -> Optional[bool]:
+        return None
 
     def show_progress(self, message: str):
         if self._should_show_progress:

zrb/task/cmd_task.py

@@ -8,7 +8,8 @@ import sys
 import time
 
 from zrb.config.config import default_shell
-from zrb.helper.string.conversion import to_variable_name
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -36,6 +37,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.cmd_task", attrs=["dark"]))
+
 _has_stty = True
 try:
     _original_stty = subprocess.getoutput("stty -g").rstrip()
@@ -196,8 +199,17 @@ class CmdTask(BaseTask):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., CmdResult]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     def print_result(self, result: CmdResult):
         if not self._should_print_cmd_result or result.output == "":

zrb/task/decorator.py

@@ -1,4 +1,6 @@
 from zrb.action.runner import Runner
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
 from zrb.task.any_task import AnyTask
@@ -17,6 +19,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.decorator", attrs=["dark"]))
+
 # flake8: noqa E501
 
 

zrb/task/docker_compose_task.py

@@ -2,9 +2,11 @@ import os
 import pathlib
 
 from zrb.config.config import container_backend
+from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.docker_compose.fetch_external_env import fetch_compose_file_env_map
 from zrb.helper.docker_compose.file import read_compose_file, write_compose_file
+from zrb.helper.log import logger
 from zrb.helper.string.conversion import to_cli_name
 from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
@@ -37,6 +39,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
+
 
 def _get_ensure_zrb_network_task(backend: str):
     CURRENT_DIR = os.path.dirname(__file__)

zrb/task/flow_task.py

@@ -1,3 +1,5 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Callable, Iterable, List, Optional, TypeVar, Union
 from zrb.task.any_task import AnyTask
@@ -16,6 +18,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.flow_task", attrs=["dark"]))
+
 TFlowTask = TypeVar("TFlowTask", bound="FlowTask")
 
 

zrb/task/http_checker.py

@@ -1,5 +1,7 @@
 from http.client import HTTPConnection, HTTPSConnection
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -26,6 +28,8 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.http_checker", attrs=["dark"]))
+
 THTTPChecker = TypeVar("THTTPChecker", bound="HTTPChecker")
 
 
@@ -129,8 +133,17 @@ class HTTPChecker(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._config = HttpConnectionConfig(

zrb/task/looper.py

@@ -0,0 +1,40 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.callable import run_async
+from zrb.helper.log import logger
+from zrb.helper.typing import Callable, List, Mapping, Optional
+
+logger.debug(colored("Loading zrb.task.looper", attrs=["dark"]))
+
+
+class Looper:
+    def __init__(self):
+        self._queue: Mapping[str, List[Optional[bool]]] = {}
+        self._should_stop = False
+
+    async def pop(self, identifier: str) -> Optional[bool]:
+        if identifier not in self._queue or len(self._queue[identifier]) == 0:
+            return None
+        return self._queue[identifier].pop(0)
+
+    def stop(self):
+        self._should_stop = True
+
+    def is_registered(self, identifier: str) -> bool:
+        return identifier in self._queue
+
+    async def register(self, identifier: str, function: Callable[..., Optional[bool]]):
+        if identifier in self._queue:
+            return
+        self._queue[identifier] = []
+        while not self._should_stop:
+            try:
+                result = await run_async(function)
+                if result is not None:
+                    if not result:
+                        continue
+                    self._queue[identifier].append(result)
+            except KeyboardInterrupt:
+                break
+
+
+looper = Looper()