zrb 0.28.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

zrb/helper/codemod/add_key_value_to_dict.py

@@ -1,52 +0,0 @@
-import libcst as cst
-
-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.codemod.add_key_value_to_dict", attrs=["dark"])
-)
-
-
-@typechecked
-class AddKeyValuePairTransformer(cst.CSTTransformer):
-    def __init__(
-        self,
-        dict_name: str,
-        key_node: cst.BaseExpression,
-        value_node: cst.BaseExpression,
-    ):
-        self.dict_name = dict_name
-        self.key_node = key_node
-        self.value_node = value_node
-        super().__init__()
-
-    def leave_Assign(
-        self, original_node: cst.Assign, updated_node: cst.Assign
-    ) -> cst.Assign:
-        if (
-            isinstance(updated_node.value, cst.Dict)
-            and isinstance(updated_node.targets[0].target, cst.Name)
-            and updated_node.targets[0].target.value == self.dict_name
-        ):
-            for element in updated_node.value.elements:
-                key = element.key
-                if isinstance(key, cst.BaseExpression) and key.value == self.key_node:
-                    return updated_node
-            new_elements = updated_node.value.elements + (
-                cst.DictElement(self.key_node, self.value_node),
-            )
-            new_value = cst.Dict(new_elements)
-            return updated_node.with_changes(value=new_value)
-        return updated_node
-
-
-def add_key_value_to_dict(code: str, dict_name: str, key: str, value: str) -> str:
-    module = cst.parse_module(code)
-    key_node = cst.parse_expression(key)
-    value_node = cst.parse_expression(value)
-    transformed_module = module.visit(
-        AddKeyValuePairTransformer(dict_name, key_node, value_node)
-    )
-    return transformed_module.code

zrb/helper/codemod/add_property_to_class.py

@@ -1,110 +0,0 @@
-from typing import Optional
-
-import libcst as cst
-
-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.codemod.add_property_to_class", attrs=["dark"])
-)
-
-
-@typechecked
-class AddPropertyTransformer(cst.CSTTransformer):
-    def __init__(
-        self,
-        class_name: str,
-        property_name_node: cst.Name,
-        property_type_node: cst.Annotation,
-        property_value_node: Optional[cst.BaseExpression],
-    ):
-        self.class_name = class_name
-        self.property_name_node = property_name_node
-        self.property_type_node = property_type_node
-        self.property_value_node = property_value_node
-        super().__init__()
-
-    def leave_ClassDef(
-        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
-    ) -> cst.ClassDef:
-        if updated_node.name.value != self.class_name:
-            return updated_node
-        class_body_statements = []
-        if not isinstance(original_node.body, cst.EmptyLine):
-            for stmt in original_node.body.body:
-                if (
-                    hasattr(stmt, "body")
-                    and not isinstance(stmt.body, cst.IndentedBlock)
-                    and len(stmt.body) > 0
-                    and isinstance(stmt.body[0], cst.Pass)
-                ):
-                    continue
-                # Add all old class body except any `pass` statement
-                class_body_statements.append(stmt)
-        # Add new property to the class
-        class_body_statements.append(
-            cst.SimpleStatementLine(
-                body=[
-                    cst.AnnAssign(
-                        target=self.property_name_node,
-                        annotation=self.property_type_node,
-                        value=self.property_value_node,
-                    )
-                ]
-            )
-        )
-        new_body = cst.IndentedBlock(
-            body=class_body_statements,
-            indent=updated_node.body.indent,
-        )
-        return updated_node.with_changes(body=new_body)
-
-
-@typechecked
-def add_property_to_class(
-    code: str,
-    class_name: str,
-    property_name: str,
-    property_type: str,
-    property_value: Optional[str] = None,
-) -> str:
-    module = cst.parse_module(code)
-    property_name_node = cst.Name(value=property_name)
-    property_type_node = _get_property_type_node(property_type)
-    property_value_node = _get_property_value_node(property_value)
-    transformed_module = module.visit(
-        AddPropertyTransformer(
-            class_name=class_name,
-            property_name_node=property_name_node,
-            property_type_node=property_type_node,
-            property_value_node=property_value_node,
-        )
-    )
-    return transformed_module.code
-
-
-def _get_property_type_node(property_type: str) -> cst.Annotation:
-    if property_type.startswith("Optional[") and property_type.endswith("]"):
-        inner_type = property_type[len("Optional[") : -1]
-        return cst.Annotation(
-            annotation=cst.Subscript(
-                value=cst.Name("Optional"),
-                slice=[
-                    cst.SubscriptElement(
-                        slice=cst.Index(value=cst.Name(value=inner_type))
-                    )
-                ],
-            )
-        )
-    else:
-        return cst.Annotation(cst.Name(value=property_type))
-
-
-def _get_property_value_node(
-    property_value: Optional[str],
-) -> Optional[cst.BaseExpression]:
-    if property_value is None:
-        return None
-    return cst.parse_expression(property_value)

zrb/helper/codemod/add_upstream_to_task.py

@@ -1,91 +0,0 @@
-import libcst as cst
-
-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.codemod.add_upstream_to_task", attrs=["dark"]))
-
-
-@typechecked
-class TaskTransformer(cst.CSTTransformer):
-    def __init__(self, task_name: str, upstream_task_name: str):
-        super().__init__()
-        self.task_name: str = task_name
-        self.upstream_task_name: str = upstream_task_name
-        self._on_task_call = False
-        self._upstream_added = False
-
-    def _is_task(self, node: cst.Call) -> bool:
-        if not isinstance(node.func, cst.Name) or node.func.value != "Task":
-            return False
-        # Look for name keyword
-        for name_arg in node.args:
-            if (
-                isinstance(name_arg, cst.Arg)
-                and name_arg.keyword.value == "name"
-                and name_arg.value.evaluated_value == self.task_name
-            ):
-                return True
-        return False
-
-    def visit_Call(self, node: cst.Call):
-        # Visit all function call (or class initiation)
-        # If it is the task we seek, flag it
-        if self._is_task(node):
-            self._on_task_call = True
-
-    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
-        # Remove flags.
-        # If upstreams argument not found (see: self.leave_Arg), add it
-        if not self._is_task(updated_node):
-            return updated_node
-        self._on_task_call = False
-        if self._upstream_added:
-            return updated_node
-        new_args = [arg for arg in updated_node.args]
-        new_args.append(
-            cst.Arg(
-                keyword=cst.parse_expression("upstreams"),
-                value=cst.List(
-                    [cst.Element(cst.parse_expression(self.upstream_task_name))]
-                ),
-            )
-        )
-        self._upstream_added = True
-        return updated_node.with_changes(args=new_args)
-
-    def leave_Arg(self, orginnal_node: cst.Arg, updated_node: cst.Arg):
-        # Once the flag was set (see: self.visit_Call), look for
-        # `upstreams` argument and modify the value
-        if (
-            not self._on_task_call
-            or updated_node.keyword is None
-            or updated_node.keyword.value != "upstreams"
-        ):
-            return updated_node
-        new_elements = [old_element for old_element in updated_node.value.elements]
-        new_elements.append(
-            cst.Element(value=cst.parse_expression(self.upstream_task_name))
-        )
-        self._upstream_added = True
-        return updated_node.with_changes(value=cst.List(new_elements))
-
-
-@typechecked
-def add_upstream_to_task(code: str, task_name: str, upstream_task_name: str) -> str:
-    """
-    Transformer to add an upstream task to a Task object.
-
-    Args:
-        code (str): The code to modify.
-        task_name (str): Name of the task to modify.
-        upstream_task_name (str): Name of the upstream task to add.
-
-    Returns:
-        A modified version of the input code with the upstream task added.
-    """
-    transformer: TaskTransformer = TaskTransformer(task_name, upstream_task_name)
-    original_tree: cst.Module = cst.parse_module(code)
-    modified_tree: cst.Module = original_tree.visit(transformer)
-    return modified_tree.code

zrb/helper/codemod/append_code_to_function.py

@@ -1,32 +0,0 @@
-import libcst as cst
-
-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.codemod.append_code_to_function", attrs=["dark"])
-)
-
-
-@typechecked
-class AppendCodeTransformer(cst.CSTTransformer):
-    def __init__(self, function_name: str, new_code: str):
-        self.function_name = function_name
-        self.new_code = new_code
-        super().__init__()
-
-    def leave_FunctionDef(
-        self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
-    ) -> cst.FunctionDef:
-        if updated_node.name.value == self.function_name:
-            new_body = updated_node.body.body + (cst.parse_statement(self.new_code),)
-            return updated_node.with_changes(body=cst.IndentedBlock(body=new_body))
-        return updated_node
-
-
-@typechecked
-def append_code_to_function(code: str, function_name: str, new_code: str) -> str:
-    module = cst.parse_module(code)
-    transformed_module = module.visit(AppendCodeTransformer(function_name, new_code))
-    return transformed_module.code

zrb/helper/codemod/format_code.py

@@ -1,12 +0,0 @@
-import autopep8
-
-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.codemod.format_code", attrs=["dark"]))
-
-
-@typechecked
-def format_code(code: str) -> str:
-    return autopep8.fix_code(code)

zrb/helper/default_env.py

@@ -1,56 +0,0 @@
-import os
-from collections.abc import Mapping
-from functools import lru_cache
-from typing import Optional
-
-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.default_env", attrs=["dark"]))
-_PROJECT_DIR_MAP: Mapping[str, str] = {}
-
-
-@lru_cache
-def inject_default_env():
-    # Inject PYTHONUNBUFFERED
-    if "PYTHONUNBUFFERED" not in os.environ:
-        logger.info(colored("Set PYTHONUNBUFFERED to 1", attrs=["dark"]))
-        os.environ["PYTHONUNBUFFERED"] = "1"
-    # Inject ZRB_HOME_DIR
-    if "ZRB_HOME_DIR" not in os.environ:
-        default_home_dir = os.path.dirname(os.path.dirname(__file__))
-        logger.info(colored(f"Set ZRB_HOME_DIR to {default_home_dir}", attrs=["dark"]))
-        os.environ["ZRB_HOME_DIR"] = default_home_dir
-    # Inject ZRB_PROJECT_DIR
-    current_dir = os.getcwd()
-    if current_dir not in _PROJECT_DIR_MAP:
-        logger.info(colored("Getting project directory", attrs=["dark"]))
-        zrb_project_dir = _get_project_dir(current_dir)
-        if zrb_project_dir is None:
-            zrb_project_dir = current_dir
-        _PROJECT_DIR_MAP[current_dir] = zrb_project_dir
-        logger.info(
-            colored(f"Set ZRB_PROJECT_DIR to {zrb_project_dir}", attrs=["dark"])
-        )
-        os.environ["ZRB_PROJECT_DIR"] = zrb_project_dir
-    # Inject ZRB_PROJECT_NAME
-    if "ZRB_PROJECT_NAME" not in os.environ:
-        zrb_project_name = os.path.basename(zrb_project_dir)
-        logger.info(
-            colored(f"Set ZRB_PROJECT_NAME to {zrb_project_name}", attrs=["dark"])
-        )
-        os.environ["ZRB_PROJECT_NAME"] = zrb_project_name
-
-
-@lru_cache
-@typechecked
-def _get_project_dir(project_dir: str) -> Optional[str]:
-    project_script = os.path.join(project_dir, "zrb_init.py")
-    if os.path.isfile(project_script):
-        return project_dir
-    # zrb_init.py not found, look for it on the parent directory
-    parent_project_dir = os.path.dirname(project_dir)
-    if parent_project_dir == project_dir:
-        return None
-    return _get_project_dir(parent_project_dir)

zrb/helper/docker_compose/fetch_external_env.py

@@ -1,66 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-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.docker_compose.fetch_external_env", attrs=["dark"])
-)
-
-
-@typechecked
-def fetch_compose_file_env_map(data: Any) -> Mapping[str, str]:
-    global_env_dict = {}
-    if "services" not in data:
-        return global_env_dict
-    for service in data["services"]:
-        if "environment" not in data["services"][service]:
-            continue
-        environments = data["services"][service]["environment"]
-        if isinstance(environments, list):
-            for environment in environments:
-                parts: list[str] = environment.split("=")
-                if len(parts) > 0:
-                    env_str = str(parts[1])
-                    env_dict = parse_compose_file_env_string(env_str)
-                    global_env_dict.update(env_dict)
-        if isinstance(environments, dict):
-            for _, env_str in environments.items():
-                env_str = str(env_str)
-                env_dict = parse_compose_file_env_string(env_str)
-                global_env_dict.update(env_dict)
-    return global_env_dict
-
-
-@typechecked
-def parse_compose_file_env_string(env_str: str) -> Mapping[str, str]:
-    env_dict = {}
-    stack = []
-    key = ""
-    value = ""
-    index = 0
-    while index < len(env_str):
-        char = env_str[index]
-        if char == "{":
-            stack.append(index)
-        elif char == "}":
-            start = stack.pop()
-            if not stack:
-                segment = env_str[start + 1 : index]
-                if ":-" in segment:
-                    key, value = segment.split(":-", 1)
-                    if value.startswith("${") and value.endswith("}"):
-                        sub_dict = parse_compose_file_env_string(value)
-                        env_dict.update(sub_dict)
-                else:
-                    key = segment
-                    value = ""
-                if "${" in value:
-                    value = ""
-                env_dict[key] = value
-                key = ""
-                value = ""
-        index += 1
-    return env_dict

zrb/helper/docker_compose/file.py

@@ -1,33 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from ruamel.yaml import YAML, CommentedMap
-
-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.docker_compose.file", attrs=["dark"]))
-
-
-@typechecked
-def read_compose_file(file_name: str) -> Any:
-    yaml = YAML()
-    with open(file_name, "r") as f:
-        data = yaml.load(f)
-    return data
-
-
-@typechecked
-def write_compose_file(file_name: str, data: Any):
-    yaml = YAML()
-    with open(file_name, "w") as f:
-        yaml.dump(data, f)
-
-
-@typechecked
-def add_services(file_name: str, new_services: Mapping[str, str]):
-    data = read_compose_file(file_name)
-    data = CommentedMap(data)
-    data["services"].update(CommentedMap(new_services))
-    write_compose_file(file_name, data)

zrb/helper/docstring.py

@@ -1,137 +0,0 @@
-import inspect
-import re
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-
-logger.debug(colored("Loading zrb.helper.docstring", attrs=["dark"]))
-
-
-def get_markdown_from_docstring(cls) -> str:
-    """
-    Convert Google Style docstrings of a class and its methods to Markdown.
-
-    Args:
-        cls (class): The class whose docstrings are to be converted.
-
-    Returns:
-        str: The converted Markdown text.
-    """
-    markdown = f"## `{cls.__name__}`\n\n"
-    cls_doc = get_doc(cls)
-    markdown += parse_docstring(cls_doc) + "\n"
-    for method_name, _ in inspect.getmembers(cls, predicate=inspect.isfunction):  # noqa
-        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"
-    return markdown
-
-
-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__"):
-        for parent in cls.__bases__:
-            parent_method_doc = get_method_doc(parent, method_name)
-            if parent_method_doc:
-                return parent_method_doc
-    return method.__doc__
-
-
-def get_doc(cls) -> str:
-    if not cls.__doc__ and hasattr(cls, "__bases__"):
-        for parent in cls.__bases__:
-            parent_doc = get_doc(parent)
-            if parent_doc:
-                return parent_doc
-    return cls.__doc__
-
-
-def parse_docstring(docstring: str) -> str:
-    if not docstring:
-        return "No documentation available.\n"
-    # Split the docstring into lines
-    lines = docstring.strip().split("\n")
-    line_length = len(lines)
-    # Process each line
-    markdown_lines = []
-    section = ""
-    is_previous_code = False
-    has_unclosed_backtick = False
-    for line_index, line in enumerate(lines):
-        line = line.strip()
-        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")
-            has_unclosed_backtick = True
-        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("")
-            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:")
-        ):
-            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:")
-        ):
-            markdown_lines.append("__Arguments:__\n")
-            section = "args"
-            is_new_section = True
-        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"
-            is_new_section = True
-        elif line == "```":
-            markdown_lines.append(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()}"
-                )
-            else:
-                markdown_lines.append(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()}")
-            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("")
-            has_unclosed_backtick = False
-    return "\n".join(markdown_lines)

zrb/helper/env_map/fetch.py

@@ -1,76 +0,0 @@
-from collections.abc import Mapping
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.string.jinja import is_probably_jinja
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
-from zrb.task_env.env import Env
-from zrb.task_group.group import Group
-
-logger.debug(colored("Loading zrb.helper.env_map.fetch", attrs=["dark"]))
-
-
-@typechecked
-def fetch_env_map_from_group(
-    env_map: Mapping[str, str], group: Group
-) -> Mapping[str, str]:
-    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)
-        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):
-    task_env_map: Mapping[str, str] = {}
-    for env_file in task._get_env_files():
-        envs = env_file.get_envs()
-        task_env_map = _add_envs_to_env_map(task_env_map, envs)
-    task_env_map = _add_envs_to_env_map(task_env_map, task._envs)
-    env_map = _cascade_env_map(env_map, task_env_map)
-    for upstream in task._get_upstreams():
-        task_env_map = fetch_env_map_from_task(env_map, upstream)
-    for checker in task._get_checkers():
-        task_env_map = fetch_env_map_from_task(env_map, checker)
-    return env_map
-
-
-@typechecked
-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() == "":
-            continue
-        env_name = _get_env_name(env)
-        env_default = _get_env_default(env)
-        env_map[env_name] = env_default
-    return env_map
-
-
-@typechecked
-def _cascade_env_map(
-    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:
-            continue
-        env_map[key] = value
-    return env_map
-
-
-@typechecked
-def _get_env_name(env: Env) -> str:
-    if env.get_os_name() is None:
-        return env.get_name()
-    return env.get_os_name()
-
-
-@typechecked
-def _get_env_default(env: Env) -> str:
-    if is_probably_jinja(env.get_default()):
-        return ""
-    return env.get_default()