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

zrb/helper/docstring.py

@@ -14,14 +14,14 @@ def get_markdown_from_docstring(cls) -> str:
     """
     markdown = f"## `{cls.__name__}`\n\n"
     cls_doc = get_doc(cls)
-    markdown += parse_docstring(cls_doc) + '\n'
+    markdown += parse_docstring(cls_doc) + "\n"
     for method_name, _ in inspect.getmembers(cls, predicate=inspect.isfunction):  # noqa
-        if method_name.startswith('__'):
+        if method_name.startswith("__"):
             # Don't parse private or protected function
             continue
         markdown += f"\n### `{cls.__name__}.{method_name}`\n\n"
         method_doc = get_method_doc(cls, method_name)
-        markdown += parse_docstring(method_doc) + '\n'
+        markdown += parse_docstring(method_doc) + "\n"
     return markdown
 
 
@@ -29,7 +29,7 @@ def get_method_doc(cls, method_name: str) -> str:
     if not hasattr(cls, method_name):
         return None
     method = getattr(cls, method_name)
-    if not method.__doc__ and hasattr(cls, '__bases__'):
+    if not method.__doc__ and hasattr(cls, "__bases__"):
         for parent in cls.__bases__:
             parent_method_doc = get_method_doc(parent, method_name)
             if parent_method_doc:
@@ -38,7 +38,7 @@ def get_method_doc(cls, method_name: str) -> str:
 
 
 def get_doc(cls) -> str:
-    if not cls.__doc__ and hasattr(cls, '__bases__'):
+    if not cls.__doc__ and hasattr(cls, "__bases__"):
         for parent in cls.__bases__:
             parent_doc = get_doc(parent)
             if parent_doc:
@@ -48,88 +48,85 @@ def get_doc(cls) -> str:
 
 def parse_docstring(docstring: str) -> str:
     if not docstring:
-        return 'No documentation available.\n'
+        return "No documentation available.\n"
     # Split the docstring into lines
-    lines = docstring.strip().split('\n')
+    lines = docstring.strip().split("\n")
     line_length = len(lines)
     # Process each line
     markdown_lines = []
-    section = ''
+    section = ""
     is_previous_code = False
     has_unclosed_backtick = False
     for line_index, line in enumerate(lines):
         line = line.strip()
-        is_code = line.startswith('>>> ')
+        is_code = line.startswith(">>> ")
         is_last_line = line_index == line_length - 1
         is_new_section = False
         # Add code backticks
         if is_code and not is_previous_code:
-            markdown_lines.append('```python')
+            markdown_lines.append("```python")
             has_unclosed_backtick = True
-        elif section == 'examples' and is_previous_code and not is_code:
-            markdown_lines.append('```')
-            markdown_lines.append('')
-            markdown_lines.append('```')
+        elif section == "examples" and is_previous_code and not is_code:
+            markdown_lines.append("```")
+            markdown_lines.append("")
+            markdown_lines.append("```")
             has_unclosed_backtick = True
         elif is_previous_code and not is_code:
-            markdown_lines.append('````')
-            markdown_lines.append('')
+            markdown_lines.append("````")
+            markdown_lines.append("")
             has_unclosed_backtick = False
         # Handle lines
         if is_code:
             markdown_lines.append(line[4:])
         elif (
-            line.startswith('Attributes:') or
-            line.startswith('Attribute:') or
-            line.startswith('Attrs:') or
-            line.startswith('Attr:')
+            line.startswith("Attributes:")
+            or line.startswith("Attribute:")
+            or line.startswith("Attrs:")
+            or line.startswith("Attr:")
         ):
-            markdown_lines.append('__Attributes:__\n')
-            section = 'attributes'
+            markdown_lines.append("__Attributes:__\n")
+            section = "attributes"
             is_new_section = True
         elif (
-            line.startswith('Args:') or
-            line.startswith('Arg:') or
-            line.startswith('Arguments:') or
-            line.startswith('Argument:')
+            line.startswith("Args:")
+            or line.startswith("Arg:")
+            or line.startswith("Arguments:")
+            or line.startswith("Argument:")
         ):
-            markdown_lines.append('__Arguments:__\n')
-            section = 'args'
+            markdown_lines.append("__Arguments:__\n")
+            section = "args"
             is_new_section = True
-        elif line.startswith('Returns:'):
-            markdown_lines.append('__Returns:__\n')
-            section = 'returns'
+        elif line.startswith("Returns:"):
+            markdown_lines.append("__Returns:__\n")
+            section = "returns"
             is_new_section = True
-        elif (
-            line.startswith('Examples:') or
-            line.startswith('Examples:')
-        ):
-            markdown_lines.append('__Examples:__\n')
-            section = 'examples'
+        elif line.startswith("Examples:") or line.startswith("Examples:"):
+            markdown_lines.append("__Examples:__\n")
+            section = "examples"
             is_new_section = True
-        elif line == '```':
+        elif line == "```":
             markdown_lines.append(line)
-        elif section == 'args' or section == 'attributes':
-            named_param_match = re.match(r'^(\w+)\s+\((.+)\):(.+)$', line)
+        elif section == "args" or section == "attributes":
+            named_param_match = re.match(r"^(\w+)\s+\((.+)\):(.+)$", line)
             if named_param_match:
                 param_name, param_type, param_desc = named_param_match.groups()
                 markdown_lines.append(
-                    f'- `{param_name}` (`{param_type}`): {param_desc.strip()}'
+                    f"- `{param_name}` (`{param_type}`): {param_desc.strip()}"
                 )
             else:
                 markdown_lines.append(line)
-        elif section == 'returns':
-            return_match = re.match(r'^(.+):(.+)$', line)
+        elif section == "returns":
+            return_match = re.match(r"^(.+):(.+)$", line)
             if return_match:
                 param_type, param_desc = return_match.groups()
-                markdown_lines.append(f'`{param_type}`: {param_desc.strip()}')
+                markdown_lines.append(f"`{param_type}`: {param_desc.strip()}")
             else:
                 markdown_lines.append(line)
         else:
             markdown_lines.append(line)
         is_previous_code = is_code
         if (is_new_section or is_last_line) and has_unclosed_backtick:
-            markdown_lines.append('```')
-            markdown_lines.append('')
+            markdown_lines.append("```")
+            markdown_lines.append("")
             has_unclosed_backtick = False
-    return '\n'.join(markdown_lines)
+    return "\n".join(markdown_lines)

zrb/helper/env_map/fetch.py

@@ -1,9 +1,9 @@
+from zrb.helper.string.jinja import is_probably_jinja
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import List, Mapping
-from zrb.task_group.group import Group
 from zrb.task.any_task import AnyTask
 from zrb.task_env.env import Env
-from zrb.helper.string.jinja import is_probably_jinja
+from zrb.task_group.group import Group
 
 
 @typechecked
@@ -13,17 +13,13 @@ def fetch_env_map_from_group(
     for task in group.get_tasks():
         env_map = fetch_env_map_from_task(env_map, task)
     for sub_group in group.get_children():
-        sub_env_map: Mapping[str, str] = fetch_env_map_from_group(
-            env_map, sub_group
-        )
+        sub_env_map: Mapping[str, str] = fetch_env_map_from_group(env_map, sub_group)
         env_map = _cascade_env_map(env_map, sub_env_map)
     return env_map
 
 
 @typechecked
-def fetch_env_map_from_task(
-    env_map: Mapping[str, str], task: AnyTask
-):
+def fetch_env_map_from_task(env_map: Mapping[str, str], task: AnyTask):
     task_env_map: Mapping[str, str] = {}
     for env_file in task._get_env_files():
         envs = env_file.get_envs()
@@ -42,7 +38,7 @@ def _add_envs_to_env_map(
     env_map: Mapping[str, str], envs: List[Env]
 ) -> Mapping[str, str]:
     for env in envs:
-        if env.get_os_name() == '':
+        if env.get_os_name() == "":
             continue
         env_name = _get_env_name(env)
         env_default = _get_env_default(env)
@@ -52,8 +48,7 @@ def _add_envs_to_env_map(
 
 @typechecked
 def _cascade_env_map(
-    env_map: Mapping[str, str],
-    other_env_map: Mapping[str, str]
+    env_map: Mapping[str, str], other_env_map: Mapping[str, str]
 ) -> Mapping[str, str]:
     for key, value in other_env_map.items():
         if key in env_map:
@@ -72,5 +67,5 @@ def _get_env_name(env: Env) -> str:
 @typechecked
 def _get_env_default(env: Env) -> str:
     if is_probably_jinja(env.get_default()):
-        return ''
+        return ""
     return env.get_default()

zrb/helper/file/copy_tree.py

@@ -1,14 +1,14 @@
-from zrb.config.config import logging_level
-from zrb.helper.typing import Iterable, Mapping, Optional
-from zrb.helper.typecheck import typechecked
-from zrb.helper.file.text import read_text_file_async, write_text_file_async
-from zrb.helper.string.parse_replacement import parse_replacement
-from zrb.helper.log import logger
-
+import fnmatch
 import logging
 import os
 import shutil
-import fnmatch
+
+from zrb.config.config import logging_level
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.log import logger
+from zrb.helper.string.parse_replacement import parse_replacement
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Iterable, Mapping, Optional
 
 
 @typechecked
@@ -17,7 +17,7 @@ async def copy_tree(
     dst: str,
     replacements: Optional[Mapping[str, str]] = None,
     excludes: Optional[Iterable[str]] = None,
-    skip_parsing: Optional[Iterable[str]] = None
+    skip_parsing: Optional[Iterable[str]] = None,
 ):
     if replacements is None:
         replacements = {}
@@ -35,21 +35,16 @@ async def copy_tree(
             continue
         dst_name = os.path.join(dst, name)
         if os.path.isdir(src_name):
-            await copy_tree(
-                src_name, dst_name, replacements, excludes, skip_parsing
-            )
+            await copy_tree(src_name, dst_name, replacements, excludes, skip_parsing)
             continue
         new_dst_name = parse_replacement(dst_name, replacements)
         shutil.copy2(src_name, new_dst_name)
         try:
-            if any(
-                fnmatch.fnmatch(new_dst_name, pattern)
-                for pattern in skip_parsing
-            ):
+            if any(fnmatch.fnmatch(new_dst_name, pattern) for pattern in skip_parsing):
                 continue
             file_content = await read_text_file_async(new_dst_name)
             new_file_content = parse_replacement(file_content, replacements)
             await write_text_file_async(new_dst_name, new_file_content)
         except Exception:
             if logging_level <= logging.ERROR:
-                logger.error(f'Cannot parse file: {new_dst_name}')
+                logger.error(f"Cannot parse file: {new_dst_name}")

zrb/helper/file/match.py

@@ -1,18 +1,17 @@
-from zrb.helper.typing import List, Iterable
-from zrb.helper.typecheck import typechecked
 import fnmatch
 import glob
 
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Iterable, List
+
 
 @typechecked
-def get_file_names(
-    glob_path: str, glob_ignored_paths: Iterable[str]
-) -> List[str]:
+def get_file_names(glob_path: str, glob_ignored_paths: Iterable[str]) -> List[str]:
     matches = []
     for file in glob.glob(glob_path, recursive=True):
         should_ignore = any(
-            fnmatch.fnmatch(file, ignored_path) or
-            fnmatch.fnmatch(file, ignored_path + '**')
+            fnmatch.fnmatch(file, ignored_path)
+            or fnmatch.fnmatch(file, ignored_path + "**")
             for ignored_path in glob_ignored_paths
         )
         if not should_ignore:

zrb/helper/file/text.py

@@ -1,11 +1,13 @@
-from zrb.helper.typecheck import typechecked
-import aiofiles
 import os
 
+import aiofiles
+
+from zrb.helper.typecheck import typechecked
+
 
 @typechecked
 async def read_text_file_async(file_name: str) -> str:
-    async with aiofiles.open(file_name, mode='r') as file:
+    async with aiofiles.open(file_name, mode="r") as file:
         content = await file.read()
     return content
 
@@ -13,14 +15,14 @@ async def read_text_file_async(file_name: str) -> str:
 @typechecked
 async def write_text_file_async(file_name: str, content: str):
     os.makedirs(os.path.dirname(file_name), exist_ok=True)
-    async with aiofiles.open(file_name, mode='w') as file:
+    async with aiofiles.open(file_name, mode="w") as file:
         await file.write(content)
 
 
 @typechecked
 async def append_text_file_async(file_name: str, additional_content: str):
     content = await read_text_file_async(file_name)
-    if content != '':
-        additional_content = '\n' + additional_content
+    if content != "":
+        additional_content = "\n" + additional_content
     new_content = content + additional_content
     await write_text_file_async(file_name, new_content)

zrb/helper/git/detect_changes.py

@@ -1,10 +1,11 @@
+import subprocess
+
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Mapping
-import subprocess
 
 
 @typechecked
-class ModificationState():
+class ModificationState:
     def __init__(self):
         self.plus: bool = False
         self.minus: bool = False
@@ -12,23 +13,23 @@ class ModificationState():
 
 @typechecked
 def get_modified_file_states(commit: str) -> Mapping[str, ModificationState]:
-    exit_status, output = subprocess.getstatusoutput(f'git show {commit}')
+    exit_status, output = subprocess.getstatusoutput(f"git show {commit}")
     if exit_status != 0:
         raise Exception(output)
-    lines = output.split('\n')
+    lines = output.split("\n")
     modified_files: Mapping[str, ModificationState] = {}
     for line in lines:
-        if not line.startswith('---') and not line.startswith('+++'):
+        if not line.startswith("---") and not line.startswith("+++"):
             continue
-        if line[4:6] != 'a/' and line[4:6] != 'b/':
+        if line[4:6] != "a/" and line[4:6] != "b/":
             continue
         # line should contains something like `--- a/some-file.txt`
         file = line[6:]
         if file not in modified_files:
             modified_files[file] = ModificationState()
         modification_state = modified_files[file]
-        if line.startswith('---'):
+        if line.startswith("---"):
             modification_state.minus = True
-        if line.startswith('+++'):
+        if line.startswith("+++"):
             modification_state.plus = True
     return modified_files

zrb/helper/loader/load_module.py

@@ -1,14 +1,14 @@
-from zrb.config.config import logging_level
-from zrb.helper.typecheck import typechecked
-from zrb.helper.log import logger
-from zrb.helper.accessories.color import colored
-from functools import lru_cache
-
-import os
 import logging
+import os
 import re
+from functools import lru_cache
 
-pattern = re.compile('[^a-zA-Z0-9]')
+from zrb.config.config import logging_level
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
+from zrb.helper.typecheck import typechecked
+
+pattern = re.compile("[^a-zA-Z0-9]")
 
 
 @lru_cache
@@ -17,15 +17,16 @@ def load_module(script_path: str):
     if not os.path.isfile(script_path):
         return
     import importlib.util
-    module_name = pattern.sub('', script_path)
+
+    module_name = pattern.sub("", script_path)
     if logging_level <= logging.INFO:
-        logger.info(colored(f'Get module spec: {script_path}', attrs=['dark']))
+        logger.info(colored(f"Get module spec: {script_path}", attrs=["dark"]))
     spec = importlib.util.spec_from_file_location(module_name, script_path)
     if logging_level <= logging.INFO:
-        logger.info(colored(f'Create module: {script_path}', attrs=['dark']))
+        logger.info(colored(f"Create module: {script_path}", attrs=["dark"]))
     module = importlib.util.module_from_spec(spec)
     if logging_level <= logging.INFO:
-        logger.info(colored(f'Exec module: {script_path}', attrs=['dark']))
+        logger.info(colored(f"Exec module: {script_path}", attrs=["dark"]))
     spec.loader.exec_module(module)
     if logging_level <= logging.INFO:
-        logger.info(colored(f'Module executed: {script_path}', attrs=['dark']))
+        logger.info(colored(f"Module executed: {script_path}", attrs=["dark"]))

zrb/helper/log.py

@@ -1,9 +1,10 @@
+import logging
+
 from zrb.config.config import logging_level
 from zrb.helper.accessories.color import colored
-import logging
 
 # create logger
-logger = logging.getLogger('zrb')
+logger = logging.getLogger("zrb")
 logger.setLevel(logging_level)
 
 # create console handler and set level to debug
@@ -12,7 +13,7 @@ ch.setLevel(logging_level)
 
 # create formatter
 formatter = logging.Formatter(
-    colored('%(levelname)-6s %(asctime)s', attrs=['dark']) + ' %(message)s'
+    colored("%(levelname)-6s %(asctime)s", attrs=["dark"]) + " %(message)s"
 )
 
 # add formatter to ch

zrb/helper/map/conversion.py

@@ -5,14 +5,13 @@ from zrb.helper.typing import Any, Mapping
 @typechecked
 def to_str(
     str_map: Mapping[str, Any],
-    item_separator: str = '\n',
-    item_prefix: str = '',
-    keyval_separator: str = ' : '
+    item_separator: str = "\n",
+    item_prefix: str = "",
+    keyval_separator: str = " : ",
 ) -> str:
     keys = list(str_map.keys())
     keys.sort()
     str_list = [
-        item_prefix + key + keyval_separator + str(str_map[key])
-        for key in keys
+        item_prefix + key + keyval_separator + str(str_map[key]) for key in keys
     ]
     return item_separator.join(str_list)

zrb/helper/python_task.py

@@ -4,7 +4,5 @@ from zrb.task.task import Task
 
 @typechecked
 def show_lines(task: Task, *lines: str):
-    separator = '\n    '
-    task.print_out(
-        '\n' + separator + separator.join(lines) + '\n', trim_message=False
-    )
+    separator = "\n    "
+    task.print_out("\n" + separator + separator.join(lines) + "\n", trim_message=False)

zrb/helper/render_data.py

@@ -1,25 +1,32 @@
-from zrb.helper.util import (
-    coalesce, coalesce_str, to_camel_case, to_pascal_case, to_kebab_case,
-    to_snake_case, to_human_readable, to_boolean
-)
 import datetime
 import os
 import platform
 import time
 
+from zrb.helper.util import (
+    coalesce,
+    coalesce_str,
+    to_boolean,
+    to_camel_case,
+    to_human_readable,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
+
 DEFAULT_RENDER_DATA = {
-    'datetime': datetime,
-    'os': os,
-    'platform': platform,
-    'time': time,
-    'util': {
-        'coalesce': coalesce,
-        'coalesce_str': coalesce_str,
-        'to_camel_case': to_camel_case,
-        'to_pascal_case': to_pascal_case,
-        'to_kebab_case': to_kebab_case,
-        'to_snake_case': to_snake_case,
-        'to_human_readable': to_human_readable,
-        'to_boolean': to_boolean,
-    }
+    "datetime": datetime,
+    "os": os,
+    "platform": platform,
+    "time": time,
+    "util": {
+        "coalesce": coalesce,
+        "coalesce_str": coalesce_str,
+        "to_camel_case": to_camel_case,
+        "to_pascal_case": to_pascal_case,
+        "to_kebab_case": to_kebab_case,
+        "to_snake_case": to_snake_case,
+        "to_human_readable": to_human_readable,
+        "to_boolean": to_boolean,
+    },
 }

zrb/helper/string/constant.py

@@ -1,2 +1,2 @@
-TRUE_STRS = ['true', '1', 'yes', 'y', 'active', 'on']
-FALSE_STRS = ['false', '0', 'no', 'n', 'inactive', 'off']
+TRUE_STRS = ["true", "1", "yes", "y", "active", "on"]
+FALSE_STRS = ["false", "0", "no", "n", "inactive", "off"]

zrb/helper/string/conversion.py

@@ -1,38 +1,39 @@
-from zrb.helper.typecheck import typechecked
-from zrb.helper.string.constant import TRUE_STRS, FALSE_STRS
 import keyword
 import logging
 import re
 
-NON_WORD = re.compile(r'[\W]+')
-LEADING_NUM = re.compile(r'^\d+')
+from zrb.helper.string.constant import FALSE_STRS, TRUE_STRS
+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,
+    "critical": logging.CRITICAL,
+    "fatal": logging.FATAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "warn": logging.WARN,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+    "notset": logging.NOTSET,
 }
 
 
 @typechecked
 def to_cli_name(name: str) -> str:
-    return NON_WORD.sub('-', name).strip('-').lower()
+    return NON_WORD.sub("-", name).strip("-").lower()
 
 
 @typechecked
 def to_variable_name(string: str) -> str:
     # Replace any non-word characters with underscore
-    string = NON_WORD.sub('_', string).strip()
+    string = NON_WORD.sub("_", string).strip()
     # Remove leading digits
-    string = LEADING_NUM.sub('', string)
+    string = LEADING_NUM.sub("", string)
     # Convert to lowercase
     string = string.lower()
     if keyword.iskeyword(string):
-        return string + '_'
+        return string + "_"
     return string
 
 

zrb/helper/string/jinja.py

@@ -6,8 +6,8 @@ from zrb.helper.typing import Any
 def is_probably_jinja(value: Any) -> bool:
     if not isinstance(value, str):
         return False
-    if '{{' in value and '}}' in value:
+    if "{{" in value and "}}" in value:
         return True
-    if '{%' in value and '%}' in value:
+    if "{%" in value and "%}" in value:
         return True
     return False

zrb/helper/typecheck.py

@@ -1,12 +1,14 @@
+import os
 from typing import TypeVar
-from zrb.helper.string.constant import FALSE_STRS
+
 from beartype import beartype
-import os
 
-enable_type_checking_str = os.getenv('ZRB_ENABLE_TYPE_CHECKING', '1').lower()
+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
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 def typechecked(anything: T) -> T:

zrb/helper/typing.py

@@ -1,6 +1,14 @@
 from beartype.typing import (
-    Any, Iterable, Callable, List, Mapping, Optional, TypeVar, Type, Tuple,
-    Union
+    Any,
+    Callable,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
 )
 
 JinjaTemplate = str