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

zrb/task/task.py

@@ -1,49 +1,5 @@
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.task.base_task.base_task import BaseTask
+from .base_task import BaseTask
 
-logger.debug(colored("Loading zrb.task.task", attrs=["dark"]))
 
-
-@typechecked
 class Task(BaseTask):
-    """
-    Task is the smallest Zrb automation unit.
-
-    You can configure a Task by using several interfaces:
-    - `inputs`: interfaces to read user input at the beginning of the execution.
-    - `envs`: interfaces to read and use OS Environment Variables.
-    - `env_files`: interfaces to read and use Environment Files.
-
-    Moreover, you can define Task dependencies by specifying its `upstreams` or by using shift-right operator.
-
-    Every Zrb Task has its life-cycle state:
-    - `Triggered`: The Task is triggered (either by the user or by the other Task).
-    - `Waiting`: Zrb has already triggered the Task. The Task is now waiting for all its upstreams to be ready.
-    - `Skipped`: Task upstreams are ready, but the Task is not executed and will immediately enter the `Ready` state.
-    - `Started`: The upstreams are ready, and Zrb is now starting the Task execution.
-    - `Failed`: Zrb failed to execute the Task. It will enter the `Retry` state if the current attempt does not exceed the maximum attempt.
-    - `Retry`: The task has already entered the `Failed` state. Now, Zrb will try to start the Task execution.
-    - `Ready`: The task is ready.
-
-    There are several configurations related to Task's life cycle:
-    - `retry`: Maximum retry attempt.
-    - `retry_interval`: The duration is to wait before Zrb starts the next attempt.
-    - `fallbacks`: Action to take if the Task has failed for good.
-    - `checkers`: How to determine if a Task is `Ready`.
-    - `checking_interval`: The duration to wait before Zrb checks for the Task's readiness.
-    - `run`: Action to do when Zrb executes the Task.
-    - `on_triggered`: Action to do when a Task is `Triggered`.
-    - `on_waiting`: Action to do when a Task is `Waiting`.
-    - `on_skipped`: Action to do when a Task is `Skipped`.
-    - `on_started`: Action to do when a Task is `Started`.
-    - `on_ready`: Action to do when a Task is `Ready`.
-    - `on_retry`: Action to do when a Task is `Retry`.
-    - `on_failed`: Action to do when a Task is `Failed`.
-    - `should_execute`: Condition to determine whether a Task should be `Started` or `Skipped`.
-
-    Finally, you can put related Tasks under the same `group`.
-    """
-
     pass

zrb/task/tcp_check.py

@@ -0,0 +1,71 @@
+import asyncio
+from collections.abc import Callable
+
+from ..attr.type import IntAttr, StrAttr
+from ..context.any_context import AnyContext
+from ..context.context import Context
+from ..env.any_env import AnyEnv
+from ..input.any_input import AnyInput
+from ..util.attr import get_int_attr, get_str_attr
+from .any_task import AnyTask
+from .base_task import BaseTask
+
+
+class TcpCheck(BaseTask):
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput] | AnyInput | None = None,
+        env: list[AnyEnv] | AnyEnv | None = None,
+        host: StrAttr = "localhost",
+        auto_render_host: bool = True,
+        port: IntAttr = 80,
+        interval: int = 5,
+        execute_condition: bool | str | Callable[[Context], bool] = True,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            retries=0,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._host = host
+        self._auto_render_host = auto_render_host
+        self._port = port
+        self._interval = interval
+
+    def _get_host(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._host, "localhost", auto_render=self._auto_render_host
+        )
+
+    def _get_port(self, ctx: AnyContext) -> str:
+        return get_int_attr(ctx, self._port, 80, auto_render=True)
+
+    async def _exec_action(self, ctx: AnyContext) -> bool:
+        host = self._get_host(ctx)
+        port = self._get_port(ctx)
+        while True:
+            try:
+                ctx.log_info(f"Checking TCP connection on {host}:{port}")
+                result = await asyncio.open_connection(host, port)
+                ctx.log_info(f"Connection to {host}:{port} established successfully")
+                return result
+            except asyncio.TimeoutError as e:
+                ctx.log_info(f"Timeout error {e}")
+            except Exception as e:
+                ctx.log_info(f"Error: {e}")
+            await asyncio.sleep(self._interval)

zrb/task_status/task_status.py

@@ -0,0 +1,105 @@
+import datetime
+
+TASK_STARTED = "started"
+TASK_READY = "ready"
+TASK_COMPLETED = "completed"
+TASK_SKIPPED = "skipped"
+TASK_FAILED = "failed"
+TASK_PERMANENTLY_FAILED = "permanently-failed"
+TASK_TERMINATED = "terminated"
+TASK_RESET = "reset"
+
+
+class TaskStatus:
+    def __init__(self):
+        self._history: list[tuple[str, datetime.datetime]] = []
+        self._is_started: bool = False
+        self._is_ready: bool = False
+        self._is_completed: bool = False
+        self._is_skipped: bool = False
+        self._is_failed: bool = False
+        self._is_permanently_failed: bool = False
+        self._is_terminated: bool = False
+
+    def __repr__(self):
+        return f"<TaskStatus {self._history}>"
+
+    def reset_history(self):
+        self._history = []
+
+    def reset(self):
+        self._is_started = False
+        self._is_ready = False
+        self._is_completed = False
+        self._is_skipped = False
+        self._is_failed = False
+        self._is_permanently_failed = False
+        self._history.append((TASK_RESET, datetime.datetime.now()))
+
+    def mark_as_started(self):
+        self._is_failed = False
+        self._is_started = True
+        self._history.append((TASK_STARTED, datetime.datetime.now()))
+
+    def mark_as_failed(self):
+        self._is_failed = True
+        self._history.append((TASK_FAILED, datetime.datetime.now()))
+
+    def mark_as_ready(self):
+        self._is_ready = True
+        self._history.append((TASK_READY, datetime.datetime.now()))
+
+    def mark_as_completed(self):
+        self._is_completed = True
+        self._history.append((TASK_COMPLETED, datetime.datetime.now()))
+
+    def mark_as_skipped(self):
+        self._is_skipped = True
+        self._history.append((TASK_SKIPPED, datetime.datetime.now()))
+
+    def mark_as_permanently_failed(self):
+        self._is_permanently_failed = True
+        self._history.append((TASK_PERMANENTLY_FAILED, datetime.datetime.now()))
+
+    def mark_as_terminated(self):
+        self._is_terminated = True
+        if not self.is_completed and not self.is_permanently_failed:
+            self._history.append((TASK_TERMINATED, datetime.datetime.now()))
+
+    @property
+    def is_started(self) -> bool:
+        return self._is_started
+
+    @property
+    def is_ready(self) -> bool:
+        return self._is_ready
+
+    @property
+    def is_completed(self) -> bool:
+        return self._is_completed
+
+    @property
+    def is_skipped(self) -> bool:
+        return self._is_skipped
+
+    @property
+    def is_failed(self) -> bool:
+        return self._is_failed
+
+    @property
+    def is_permanently_failed(self) -> bool:
+        return self._is_permanently_failed
+
+    @property
+    def is_terminated(self) -> bool:
+        return self._is_terminated
+
+    @property
+    def allow_run_downstream(self):
+        if self.is_failed or self.is_permanently_failed or self.is_terminated:
+            return False
+        return self.is_skipped or self.is_ready
+
+    @property
+    def history(self):
+        return self._history

zrb/util/attr.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from ..attr.type import AnyAttr, BoolAttr, FloatAttr, IntAttr, StrAttr, StrDictAttr
+from ..context.any_shared_context import AnySharedContext
+from ..util.string.conversion import to_boolean
+
+
+def get_str_dict_attr(
+    shared_ctx: AnySharedContext, attr: StrDictAttr | None, auto_render: bool = True
+) -> dict[str, Any]:
+    if callable(attr):
+        return attr(shared_ctx)
+    return {
+        key: get_str_attr(shared_ctx, val, "", auto_render) for key, val in attr.items()
+    }
+
+
+def get_str_attr(
+    shared_ctx: AnySharedContext,
+    attr: StrAttr | None,
+    default: StrAttr = "",
+    auto_render: bool = True,
+) -> str:
+    val = get_attr(shared_ctx, attr, default, auto_render)
+    if not isinstance(val, str):
+        return str(val)
+    return val
+
+
+def get_bool_attr(
+    shared_ctx: AnySharedContext,
+    attr: BoolAttr | None,
+    default: BoolAttr = False,
+    auto_render: bool = True,
+) -> bool:
+    val = get_attr(shared_ctx, attr, default, auto_render)
+    if isinstance(val, str):
+        return to_boolean(val)
+    return val
+
+
+def get_int_attr(
+    shared_ctx: AnySharedContext,
+    attr: IntAttr | None,
+    default: IntAttr = 0,
+    auto_render: bool = True,
+) -> int:
+    val = get_attr(shared_ctx, attr, default, auto_render)
+    if isinstance(val, str):
+        return int(val)
+    return val
+
+
+def get_float_attr(
+    shared_ctx: AnySharedContext,
+    attr: FloatAttr | None,
+    default: FloatAttr = 0.0,
+    auto_render: bool = True,
+) -> str | None:
+    val = get_attr(shared_ctx, attr, default, auto_render)
+    if isinstance(val, str):
+        return float(val)
+    return val
+
+
+def get_attr(
+    shared_ctx: AnySharedContext,
+    attr: AnyAttr,
+    default: AnyAttr,
+    auto_render: bool = True,
+) -> Any | None:
+    if attr is None:
+        if callable(default):
+            return default(shared_ctx)
+        return default
+    if callable(attr):
+        return attr(shared_ctx)
+    if isinstance(attr, str) and auto_render:
+        return shared_ctx.render(attr)
+    return attr

zrb/util/cli/style.py

@@ -0,0 +1,125 @@
+BLACK = 30
+RED = 31
+GREEN = 32
+YELLOW = 33
+BLUE = 34
+MAGENTA = 35
+CYAN = 36
+WHITE = 37
+
+VALID_COLORS = [BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE]
+
+BG_BLACK = 40
+BG_RED = 41
+BG_GREEN = 42
+BG_YELLOW = 43
+BG_BLUE = 44
+BG_MAGENTA = 45
+BG_CYAN = 46
+BG_WHITE = 47
+
+VALID_BACKGROUNDS = [
+    BG_BLACK,
+    BG_RED,
+    BG_GREEN,
+    BG_YELLOW,
+    BG_BLUE,
+    BG_MAGENTA,
+    BG_CYAN,
+    BG_WHITE,
+]
+
+BOLD = 1  # Bold or increased intensity
+FAINT = 2  # Faint, decreased intensity, or dim
+ITALIC = 3  # Italicized (not widely supported)
+UNDERLINE = 4  # Underline
+BLINK_SLOW = 5  # Slow blink (less than 150 per minute)
+BLINK_FAST = 6  # Rapid blink (MS-DOS style, not widely supported)
+REVERSED = 7  # Image negative, swap foreground and background colors
+HIDE = 8  # Conceal (not widely supported)
+CROSSED_OUT = 9  # Crossed-out or strike-through text
+
+VALID_STYLES = [
+    BOLD,
+    FAINT,
+    ITALIC,
+    UNDERLINE,
+    BLINK_SLOW,
+    BLINK_FAST,
+    REVERSED,
+    HIDE,
+    CROSSED_OUT,
+]
+
+ICONS = [
+    "🐶",
+    "🐱",
+    "🐭",
+    "🐹",
+    "🦊",
+    "🐻",
+    "🐨",
+    "🐯",
+    "🦁",
+    "🐮",
+    "🐷",
+    "🍎",
+    "🍐",
+    "🍊",
+    "🍋",
+    "🍌",
+    "🍉",
+    "🍇",
+    "🍓",
+    "🍈",
+    "🍒",
+    "🍑",
+]
+
+
+def stylize(
+    text: str,
+    color: int | None = None,
+    background: int | None = None,
+    style: int | None = None,
+):
+    # Start constructing the ANSI escape code
+    code_parts = []
+    if style is not None and style in VALID_STYLES:
+        code_parts.append(str(style))
+    if color is not None and color in VALID_COLORS:
+        code_parts.append(str(color))
+    if background is not None and background in VALID_BACKGROUNDS:
+        code_parts.append(str(background))
+    # Join all parts with ';' and add the escape code ending
+    if len(code_parts) > 0:
+        return "\033[" + ";".join(code_parts) + "m" + text + "\033[0m"
+    return text
+
+
+def stylize_section_header(text: str):
+    return stylize(f" {text} ", color=BLACK, background=BG_WHITE, style=UNDERLINE)
+
+
+def stylize_bold_yellow(text: str):
+    return stylize(text, color=YELLOW, style=BOLD)
+
+
+def stylize_bold_red(text: str):
+    return stylize(text, color=RED, style=BOLD)
+
+
+def stylize_faint(text: str):
+    return stylize(text, style=FAINT)
+
+
+def stylize_log(text: str):
+    return stylize_faint(text)
+
+
+def stylize_warning(text: str):
+    return stylize_bold_yellow(text)
+
+
+def stylize_error(text: str):
+    return stylize_bold_red(text)

zrb/util/cli/subcommand.py

@@ -0,0 +1,30 @@
+from ...group.any_group import AnyGroup
+from ..group import get_non_empty_subgroups, get_subtasks
+
+
+class SubCommand:
+    def __init__(self, paths: list[str] = [], nexts: list[str] = []):
+        self.paths = paths
+        self.nexts = nexts
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} paths={self.paths} nexts={self.nexts}>"
+
+
+def get_group_subcommands(
+    group: AnyGroup, previous_path: str = [], subcommands: list[SubCommand] = []
+) -> list[SubCommand]:
+    nexts = []
+    for task_alias in get_subtasks(group):
+        nexts.append(task_alias)
+    for subgroup_alias, subgroup in get_non_empty_subgroups(group).items():
+        nexts.append(subgroup_alias)
+        # Recursively add subgroup
+        get_group_subcommands(
+            group=subgroup,
+            previous_path=previous_path + [group.name],
+            subcommands=subcommands,
+        )
+    if len(nexts) > 0:
+        subcommands.append(SubCommand(paths=previous_path + [group.name], nexts=nexts))
+    return subcommands

zrb/util/cmd/remote.py

@@ -0,0 +1,20 @@
+import shlex
+
+
+def get_remote_cmd_script(
+    cmd_script: str,
+    host: str = "",
+    port: int | str = 22,
+    user: str = "",
+    password: str = "",
+    use_password: bool = False,
+    ssh_key: str = "",
+) -> str:
+    quoted_script = shlex.quote(cmd_script)
+    if ssh_key != "" and use_password:
+        return f'sshpass -p "{password}" ssh -t -p "{port}" -i "{ssh_key}" "{user}@{host}" {quoted_script}'  # noqa
+    if ssh_key != "":
+        return f'ssh -t -p "{port}" -i "{ssh_key}" "{user}@{host}" {quoted_script}'
+    if use_password:
+        return f'sshpass -p "{password}" ssh -t -p "{port}" "{user}@{host}" {quoted_script}'  # noqa
+    return f'ssh -t -p "{port}" "{user}@{host}" {quoted_script}'

zrb/util/cron.py

@@ -0,0 +1,71 @@
+import datetime
+
+
+def parse_cron_field(field: str, min_value: int, max_value: int):
+    """Parse a cron field with support for wildcards (*), ranges, lists, and steps."""
+    values = set()
+    if field == "*":
+        return set(range(min_value, max_value + 1))
+    elif field.startswith("*/"):
+        # Handle step values like "*/5"
+        step = int(field[2:])
+        return set(range(min_value, max_value + 1, step))
+    elif "-" in field or "," in field or "/" in field:
+        # Handle ranges, lists, and steps
+        parts = field.split(",")
+        for part in parts:
+            if "/" in part:
+                range_part, step = part.split("/")
+                step = int(step)
+                if "-" in range_part:
+                    start, end = map(int, range_part.split("-"))
+                else:
+                    start, end = int(range_part), max_value
+                values.update(range(start, end + 1, step))
+            elif "-" in part:
+                start, end = map(int, part.split("-"))
+                values.update(range(start, end + 1))
+            else:
+                values.add(int(part))
+    else:
+        # Handle individual values
+        values.add(int(field))
+    return values
+
+
+def handle_special_cron_patterns(pattern: str, dt: datetime.datetime):
+    """Handle special cron patterns like @yearly, @monthly, etc."""
+    if pattern == "@yearly" or pattern == "@annually":
+        return dt.month == 1 and dt.day == 1 and dt.hour == 0 and dt.minute == 0
+    elif pattern == "@monthly":
+        return dt.day == 1 and dt.hour == 0 and dt.minute == 0
+    elif pattern == "@weekly":
+        return (
+            dt.weekday() == 0 and dt.hour == 0 and dt.minute == 0
+        )  # Monday at midnight
+    elif pattern == "@daily" or pattern == "@midnight":
+        return dt.hour == 0 and dt.minute == 0
+    elif pattern == "@hourly":
+        return dt.minute == 0
+    elif pattern == "@minutely":
+        return True
+    return False
+
+
+def match_cron(cron_pattern: str, dt: datetime.datetime):
+    """Check if a datetime object matches a cron pattern, including special cases."""
+    # Handle special cron patterns
+    if cron_pattern.startswith("@"):
+        return handle_special_cron_patterns(cron_pattern, dt)
+    minute, hour, day, month, day_of_week = cron_pattern.split()
+    # Parse each field with step, range, and wildcard support
+    minutes = parse_cron_field(minute, 0, 59)
+    hours = parse_cron_field(hour, 0, 23)
+    days = parse_cron_field(day, 1, 31)
+    months = parse_cron_field(month, 1, 12)
+    days_of_week = parse_cron_field(day_of_week, 0, 6)
+    # Match with standard cron behavior (day OR day_of_week must match)
+    day_match = dt.day in days or dt.weekday() in days_of_week
+    return (
+        dt.minute in minutes and dt.hour in hours and dt.month in months and day_match
+    )

zrb/util/group.py

@@ -0,0 +1,86 @@
+from ..group.any_group import AnyGroup
+from ..task.any_task import AnyTask
+
+
+class NodeNotFoundError(ValueError):
+    pass
+
+
+def extract_node_from_args(
+    root_group: AnyGroup, args: list[str], web_only: bool = False
+) -> tuple[AnyGroup | AnyTask, list[str], list[str]]:
+    node = root_group
+    node_path = []
+    residual_args = []
+    for index, name in enumerate(args):
+        task = node.get_task_by_alias(name)
+        if web_only and task is not None and task.cli_only:
+            task = None
+        group = node.get_group_by_alias(name)
+        if group is not None and len(get_all_subtasks(group, web_only)) == 0:
+            # If group doesn't contain any task, then ignore its existence
+            group = None
+        if task is None and group is None:
+            raise NodeNotFoundError(
+                f"Invalid subcommand: {root_group.name} {' '.join(args)}"
+            )
+        node_path.append(name)
+        if group is not None:
+            if task is not None and index == len(args) - 1:
+                node = task
+                residual_args = args[index + 1 :]
+                break
+            node = group
+            continue
+        if task is not None:
+            node = task
+            residual_args = args[index + 1 :]
+            break
+    return node, node_path, residual_args
+
+
+def get_node_path(group: AnyGroup, node: AnyGroup | AnyTask) -> list[str] | None:
+    if group is None:
+        return []
+    if isinstance(node, AnyTask):
+        for alias, subtask in group.subtasks.items():
+            if subtask == node:
+                return [alias]
+    if isinstance(node, AnyGroup):
+        for alias, subgroup in group.subgroups.items():
+            if subgroup == node:
+                return [alias]
+    for alias, subgroup in group.subgroups.items():
+        result = get_node_path(subgroup, node)
+        if result is not None:
+            return [alias] + result
+    return None
+
+
+def get_non_empty_subgroups(
+    group: AnyGroup, web_only: bool = False
+) -> dict[str, AnyGroup]:
+    return {
+        alias: subgroup
+        for alias, subgroup in group.subgroups.items()
+        if len(get_all_subtasks(subgroup, web_only)) > 0
+    }
+
+
+def get_subtasks(group: AnyGroup, web_only: bool = False) -> dict[str, AnyTask]:
+    return {
+        alias: subtask
+        for alias, subtask in group.subtasks.items()
+        if not web_only or (web_only and not subtask.cli_only)
+    }
+
+
+def get_all_subtasks(group: AnyGroup, web_only: bool = False) -> list[AnyTask]:
+    subtasks = [
+        subtask
+        for subtask in group.subtasks.values()
+        if not web_only or (web_only and not subtask.cli_only)
+    ]
+    for subgroup in group.subgroups.values():
+        subtasks += get_all_subtasks(subgroup, web_only)
+    return subtasks

zrb/util/load.py

@@ -0,0 +1,50 @@
+import importlib
+import importlib.util
+import os
+import re
+import sys
+from typing import Any
+
+pattern = re.compile("[^a-zA-Z0-9]")
+
+
+def load_zrb_init(dir_path: str | None = None):
+    if dir_path is None:
+        dir_path = os.getcwd()
+    script_path = os.path.join(dir_path, "zrb_init.py")
+    if os.path.isfile(script_path):
+        load_file(script_path)
+        return
+    new_dir_path = os.path.dirname(dir_path)
+    if new_dir_path == dir_path:
+        return
+    load_zrb_init(new_dir_path)
+
+
+def load_file(script_path: str, sys_path_index: int = 0):
+    if not os.path.isfile(script_path):
+        return
+    # Append script dir path
+    script_dir_path = os.path.dirname(script_path)
+    if script_dir_path not in sys.path:
+        sys.path.insert(sys_path_index, script_dir_path)
+    # Add script dir path to Python path
+    os.environ["PYTHONPATH"] = _get_new_python_path(script_dir_path)
+    module_name = pattern.sub("", script_path)
+    spec = importlib.util.spec_from_file_location(module_name, script_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+
+def _get_new_python_path(dir_path: str) -> str:
+    current_python_path = os.getenv("PYTHONPATH")
+    if current_python_path is None or current_python_path == "":
+        return dir_path
+    if dir_path in current_python_path.split(":"):
+        return current_python_path
+    return ":".join([current_python_path, dir_path])
+
+
+def load_module(module_name: str) -> Any:
+    module = importlib.import_module(module_name)
+    return module