zrb 0.26.2__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

zrb/task/port_checker.py

@@ -1,137 +0,0 @@
-import socket
-from collections.abc import Callable, Iterable
-from typing import Any, Optional, TypeVar, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.checker import Checker
-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
-
-logger.debug(colored("Loading zrb.task.port_checker", attrs=["dark"]))
-
-TPortChecker = TypeVar("TPortChecker", bound="PortChecker")
-
-
-@typechecked
-class PortConfig:
-    def __init__(self, host: str, port: int, timeout: int):
-        self.host = host
-        self.port = port
-        self.timeout = timeout
-        self.label = f"Checking {host}:{port}"
-
-
-@typechecked
-class PortChecker(Checker):
-    def __init__(
-        self,
-        name: str = "check-port",
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        host: JinjaTemplate = "localhost",
-        port: Union[int, JinjaTemplate] = 80,
-        timeout: Union[int, JinjaTemplate] = 5,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0.05,
-        progress_interval: Union[int, float] = 5,
-        expected_result: bool = True,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-    ):
-        Checker.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checking_interval=checking_interval,
-            progress_interval=progress_interval,
-            expected_result=expected_result,
-            should_execute=should_execute,
-        )
-        self._host = host
-        self._port = port
-        self._timeout = timeout
-        self._config: Optional[PortChecker] = None
-
-    def copy(self) -> TPortChecker:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        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=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 = PortConfig(
-            host=self.render_str(self._host),
-            port=self.render_int(self._port),
-            timeout=self.render_int(self._timeout),
-        )
-        return await super().run(*args, **kwargs)
-
-    async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                sock.settimeout(self._config.timeout)
-                result = sock.connect_ex((self._config.host, self._config.port))
-                if result == 0:
-                    self.print_out(f"{self._config.label} (OK)")
-                    return True
-                self.show_progress(f"{self._config.label} (Not OK)")
-        except Exception:
-            self.show_progress(f"{self._config.label} (Socker error)")
-        return False

zrb/task/recurring_task.py

@@ -1,203 +0,0 @@
-import asyncio
-import copy
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.accessories.name import get_random_name
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.base_task.base_task import BaseTask
-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
-
-logger.debug(colored("Loading zrb.task.recurring_task", attrs=["dark"]))
-
-
-class RunConfig:
-    def __init__(
-        self,
-        fn: Callable[..., Any],
-        args: list[Any],
-        kwargs: Mapping[Any, Any],
-        execution_id: str,
-    ):
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-        self.execution_id = execution_id
-
-    async def run(self):
-        return await self.fn(*self.args, **self.kwargs)
-
-
-@typechecked
-class RecurringTask(BaseTask):
-    """
-    A class representing a recurring task that is triggered based on
-    specified conditions.
-
-    Examples:
-
-        >>> from zrb import RecurringTask
-    """
-
-    def __init__(
-        self,
-        name: str,
-        task: AnyTask,
-        triggers: Iterable[AnyTask] = [],
-        single_execution: bool = False,
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: float = 0.05,
-        retry: int = 0,
-        retry_interval: float = 1,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-    ):
-        self._task: AnyTask = task.copy()
-        inputs = list(inputs) + self._task._get_combined_inputs()
-        envs = list(envs) + self._task._get_envs()
-        env_files = list(env_files) + self._task._get_env_files()
-        BaseTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-        )
-        self._triggers: list[AnyTask] = [trigger.copy() for trigger in triggers]
-        self._run_configs: list[RunConfig] = []
-        self._single_execution = single_execution
-        self.print_err("Deprecated, please use Server instead")
-
-    async def _set_keyval(self, kwargs: Mapping[str, Any], env_prefix: str):
-        await super()._set_keyval(kwargs=kwargs, env_prefix=env_prefix)
-        new_kwargs = copy.deepcopy(kwargs)
-        new_kwargs.update(self.get_input_map())
-        trigger_coroutines = []
-        for trigger in self._triggers:
-            trigger.add_input(*self._get_inputs())
-            trigger.add_env(*self._get_envs())
-            trigger_coroutines.append(
-                asyncio.create_task(
-                    trigger._set_keyval(kwargs=new_kwargs, env_prefix=env_prefix)
-                )
-            )
-        await asyncio.gather(*trigger_coroutines)
-
-    async def run(self, *args: Any, **kwargs: Any):
-        await asyncio.gather(
-            asyncio.create_task(self.__check_trigger(*args, **kwargs)),
-            asyncio.create_task(self.__run_from_queue()),
-        )
-
-    async def __check_trigger(self, *args: Any, **kwargs: Any):
-        task_kwargs = {key: kwargs[key] for key in kwargs if key not in ["_task"]}
-        is_first_time = True
-        while True:
-            execution_id = get_random_name(add_random_digit=True, digit_count=5)
-            # Create trigger functions
-            trigger_functions = []
-            for trigger in self._triggers:
-                trigger_copy = trigger.copy()
-                trigger_copy._set_execution_id(execution_id)
-                trigger_function = trigger_copy.to_function(
-                    is_async=True, raise_error=False, show_done_info=False
-                )
-                trigger_functions.append(
-                    asyncio.create_task(trigger_function(*args, **task_kwargs))
-                )
-            self.print_out_dark("Waiting for next trigger")
-            # Mark task as done since trigger has been defined.
-            if is_first_time:
-                await self._mark_done()
-                is_first_time = False
-            # Wait for the first task to complete
-            _, pending = await asyncio.wait(
-                trigger_functions, return_when=asyncio.FIRST_COMPLETED
-            )
-            # Cancel the remaining tasks
-            for process in pending:
-                try:
-                    process.cancel()
-                except Exception as e:
-                    self.print_err(e)
-            # Run the task
-            task_copy = self._task.copy()
-            task_copy._set_execution_id(execution_id)
-            fn = task_copy.to_function(
-                is_async=True, raise_error=False, show_done_info=False
-            )
-            self.print_out_dark(f"Add execution to the queue: {execution_id}")
-            self._run_configs.append(
-                RunConfig(
-                    fn=fn, args=args, kwargs=task_kwargs, execution_id=execution_id
-                )
-            )
-
-    async def __run_from_queue(self):
-        while True:
-            if len(self._run_configs) == 0:
-                await asyncio.sleep(0.05)
-                continue
-            if self._single_execution:
-                # Drain the queue, leave only the latest task
-                while len(self._run_configs) > 1:
-                    run_config = self._run_configs.pop(0)
-                    self.print_out_dark(f"Skipping {run_config.execution_id}")
-                    self.clear_xcom(execution_id=run_config.execution_id)
-            # Run task
-            run_config = self._run_configs.pop(0)
-            self.print_out_dark(f"Executing {run_config.execution_id}")
-            self.print_out_dark(f"{len(self._run_configs)} tasks left")
-            await run_config.run()
-            self.clear_xcom(execution_id=run_config.execution_id)
-            self._play_bell()

zrb/task/remote_cmd_task.py

@@ -1,119 +0,0 @@
-import os
-import pathlib
-from collections.abc import Callable, Iterable
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
-from zrb.task.cmd_task import CmdTask, CmdVal
-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
-
-logger.debug(colored("Loading zrb.task.remote_cmd_task", attrs=["dark"]))
-
-_CURRENT_DIR = os.path.dirname(__file__)
-_SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
-with open(os.path.join(_SHELL_SCRIPT_DIR, "ssh-util.sh")) as file:
-    _SSH_UTIL_SCRIPT = file.read()
-
-ensure_ssh_is_installed = CmdTask(
-    name="ensure-ssh-is-installed",
-    cmd_path=[
-        os.path.join(_SHELL_SCRIPT_DIR, "_common-util.sh"),
-        os.path.join(_SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
-    ],
-    preexec_fn=None,
-)
-
-
-@typechecked
-class RemoteCmdTask(BaseRemoteCmdTask):
-    def __init__(
-        self,
-        name: str,
-        remote_configs: Iterable[RemoteConfig],
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        executable: Optional[str] = None,
-        cmd: CmdVal = "",
-        cmd_path: CmdVal = "",
-        cwd: Optional[Union[str, pathlib.Path]] = None,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0.05,
-        retry: int = 2,
-        retry_interval: Union[float, int] = 1,
-        max_output_line: int = 1000,
-        max_error_line: int = 1000,
-        preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-    ):
-        pre_cmd = "\n".join(
-            [
-                _SSH_UTIL_SCRIPT,
-                "_SCRIPT=\"$(cat <<'ENDSCRIPT'",
-            ]
-        )
-        post_cmd = "\n".join(["ENDSCRIPT", ')"', 'auth_ssh "$_SCRIPT"'])
-        BaseRemoteCmdTask.__init__(
-            self,
-            name=name,
-            remote_configs=remote_configs,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            executable=executable,
-            pre_cmd=pre_cmd,
-            cmd=cmd,
-            cmd_path=cmd_path,
-            post_cmd=post_cmd,
-            cwd=cwd,
-            upstreams=[ensure_ssh_is_installed] + upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            max_output_line=max_output_line,
-            max_error_line=max_error_line,
-            preexec_fn=preexec_fn,
-            should_execute=should_execute,
-        )

zrb/task/resource_maker.py

@@ -1,220 +0,0 @@
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, TypeVar, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.file.copy_tree import copy_tree
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.helper.util import (
-    to_camel_case,
-    to_capitalized_human_readable,
-    to_human_readable,
-    to_kebab_case,
-    to_pascal_case,
-    to_snake_case,
-)
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.base_task.base_task import BaseTask
-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
-
-logger.debug(colored("Loading zrb.task.resource_maker", attrs=["dark"]))
-
-Replacement = Mapping[str, JinjaTemplate]
-ReplacementMutator = Callable[[AnyTask, Replacement], Replacement]
-TResourceMaker = TypeVar("TResourceMaker", bound="ResourceMaker")
-
-
-def get_default_resource_skip_parsing() -> list[str]:
-    return [
-        "*.mp3",
-        "*.pdf",
-        "*.exe",
-        "*.dll",
-        "*.bin",
-        "*.iso",
-        "*.png",
-        "*.jpg",
-        "*.gif",
-        "*.ico",
-        "*.pyc",
-        "*.gz",
-        "*.whl",
-        "*.db",
-    ]
-
-
-def get_default_resource_excludes() -> list[str]:
-    return [
-        "*/.git",
-        "*/__pycache__",
-        "*/node_modules",
-        "*/.venv",
-        "*/poetry.lock",
-        "*/.env",
-    ]
-
-
-@typechecked
-class ResourceMaker(BaseTask):
-    def __init__(
-        self,
-        name: str,
-        template_path: JinjaTemplate,
-        destination_path: JinjaTemplate,
-        replacements: Replacement = {},
-        replacement_mutator: Optional[ReplacementMutator] = None,
-        excludes: Iterable[str] = get_default_resource_excludes(),
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-        skip_parsing: Iterable[str] = get_default_resource_skip_parsing(),
-    ):
-        BaseTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=[],
-            checking_interval=0.05,
-            retry=0,
-            retry_interval=0,
-            should_execute=should_execute,
-        )
-        self._template_path = template_path
-        self._destination_path = destination_path
-        self._excludes = excludes
-        self._replacements = replacements
-        self._replacement_mutator = replacement_mutator
-        self._skip_parsing = skip_parsing
-
-    def copy(self) -> TResourceMaker:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        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=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:
-        # render parameters
-        template_path = self.render_str(self._template_path)
-        destination_path = self.render_str(self._destination_path)
-        # render excludes
-        self.log_debug(f"Render excludes: {self._excludes}")
-        excludes = [self.render_str(exclude) for exclude in self._excludes]
-        self.log_debug(f"Rendered excludes: {excludes}")
-        # render replacements
-        self.log_debug(f"Render replacements: {self._replacements}")
-        rendered_replacements: Mapping[str, str] = {
-            old: self.render_str(new) for old, new in self._replacements.items()
-        }
-        self.log_debug(f"Rendered replacements: {rendered_replacements}")
-        if self._replacement_mutator is not None:
-            self.log_debug("Apply replacement mutator")
-            rendered_replacements = self._replacement_mutator(
-                self, rendered_replacements
-            )
-        self.log_debug(f"Apply default replacement mutator: {rendered_replacements}")
-        rendered_replacements = self._default_mutate_replacements(rendered_replacements)
-        self.log_debug(f"Final replacement: {rendered_replacements}")
-        self.print_out_dark(f"Template: {template_path}")
-        self.print_out_dark(f"Destination: {destination_path}")
-        self.print_out_dark(f"Replacements: {rendered_replacements}")
-        self.print_out_dark(f"Excludes: {excludes}")
-        self.print_out_dark(f"Skip parsing: {self._skip_parsing}")
-        await copy_tree(
-            src=template_path,
-            dst=destination_path,
-            replacements=rendered_replacements,
-            excludes=excludes,
-            skip_parsing=self._skip_parsing,
-        )
-        return True
-
-    def _default_mutate_replacements(
-        self, rendered_replacements: Mapping[str, str]
-    ) -> Mapping[str, str]:
-        transformations: Mapping[str, Callable[[str], str]] = {
-            "Pascal": to_pascal_case,
-            "camel": to_camel_case,
-            "kebab": to_kebab_case,
-            "KEBAB": _to_upper(to_kebab_case),
-            "snake": to_snake_case,
-            "SNAKE": _to_upper(to_snake_case),
-            "human readable": to_human_readable,
-            "Human readable": to_capitalized_human_readable,
-            "HUMAN READABLE": _to_upper(to_capitalized_human_readable),
-        }
-        keys = list(rendered_replacements.keys())
-        for key in keys:
-            value = rendered_replacements[key]
-            for prefix, transform in transformations.items():
-                prefixed_key = transform(prefix + " " + key)
-                if prefixed_key in rendered_replacements:
-                    continue
-                transformed_value = transform(value)
-                rendered_replacements[prefixed_key] = transformed_value
-            if key != key.upper():
-                rendered_replacements[key.upper()] = value.upper()
-        return rendered_replacements
-
-
-def _to_upper(fn: Callable[[str], str]) -> Callable[[str], str]:
-    def upperized_fn(text: str) -> str:
-        return fn(text).upper()
-
-    return upperized_fn