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

zrb/builtin/ubuntu/install/toys.py

@@ -1,18 +0,0 @@
-from zrb.builtin.ubuntu.install._group import ubuntu_install_group
-from zrb.builtin.ubuntu.update import update_ubuntu
-from zrb.runner import runner
-from zrb.task.cmd_task import CmdTask
-
-install_ubuntu_toys = CmdTask(
-    name="toys",
-    group=ubuntu_install_group,
-    description="Install ubuntu toy packages",
-    cmd=[
-        "sudo apt install -y lolcat cowsay figlet neofetch",
-    ],
-    retry_interval=3,
-    preexec_fn=None,
-)
-update_and_install_toys: CmdTask = install_ubuntu_toys.copy()
-update_and_install_toys.add_upstream(update_ubuntu)
-runner.register(update_and_install_toys)

zrb/builtin/ubuntu/update.py

@@ -1,16 +0,0 @@
-from zrb.builtin.ubuntu._group import ubuntu_group
-from zrb.runner import runner
-from zrb.task.cmd_task import CmdTask
-
-update_ubuntu = CmdTask(
-    name="update",
-    group=ubuntu_group,
-    description="Update ubuntu",
-    cmd=[
-        "sudo apt update",
-        "sudo apt upgrade -y",
-    ],
-    retry_interval=3,
-    preexec_fn=None,
-)
-runner.register(update_ubuntu)

zrb/builtin/update.py

@@ -1,10 +0,0 @@
-from zrb.runner import runner
-from zrb.task.cmd_task import CmdTask
-
-update_zrb = CmdTask(
-    name="update",
-    description="Update zrb",
-    cmd="pip install zrb -U",
-    checking_interval=3,
-)
-runner.register(update_zrb)

zrb/builtin/version.py

@@ -1,13 +0,0 @@
-from typing import Any
-
-from zrb.config.config import VERSION
-from zrb.runner import runner
-from zrb.task.decorator import python_task
-from zrb.task.task import Task
-
-
-@python_task(name="version", description="Get Zrb version", runner=runner)
-async def get_version(*args: Any, **kwargs: Any) -> str:
-    task: Task = kwargs.get("_task")
-    task.print_out(VERSION)
-    return VERSION

zrb/builtin/watch_changes.py

@@ -1,42 +0,0 @@
-from zrb.builtin._helper.reccuring_action import create_recurring_action
-from zrb.runner import runner
-from zrb.task.path_watcher import PathWatcher
-from zrb.task.server import Controller, Server
-from zrb.task_input.str_input import StrInput
-
-watch_changes = Server(
-    name="watch-changes",
-    icon="🕵️",
-    color="yellow",
-    description="Watch changes and show message/run command",
-    inputs=[
-        StrInput(
-            name="pattern",
-            default="*.*",
-            prompt="File pattern",
-            description="File pattern to be watched",
-        ),
-        StrInput(
-            name="ignored-pattern",
-            default="",
-            prompt="Ignored file pattern",
-            description="Ignored file pattern",
-        ),
-    ],
-    controllers=[
-        Controller(
-            name="watch",
-            trigger=PathWatcher(
-                name="watch-path",
-                color="cyan",
-                icon="👀",
-                path="{{input.pattern}}",
-                ignored_path="{{input.ignored_pattern}}",
-            ),
-            action=create_recurring_action(
-                notif_title="Watch",
-            ),
-        )
-    ],
-)
-runner.register(watch_changes)

zrb/config/config.py

@@ -1,49 +0,0 @@
-import importlib.metadata as metadata
-import os
-
-from zrb.helper.string.untyped_conversion import (
-    untyped_to_boolean,
-    untyped_to_logging_level,
-)
-
-
-def _get_version() -> str:
-    return metadata.version("zrb")
-
-
-def _get_current_shell() -> str:
-    current_shell = os.getenv("SHELL", "")
-    if current_shell.endswith("zsh"):
-        return "zsh"
-    return "bash"
-
-
-def _get_default_tmp_dir() -> str:
-    if os.path.isdir("/tmp"):
-        return "/tmp"
-    return os.path.expanduser(os.path.join("~", ".tmp"))
-
-
-TMP_DIR = os.getenv("ZRB_TMP_DIR", _get_default_tmp_dir())
-DEFAULT_SHELL = os.getenv("ZRB_SHELL", _get_current_shell())
-DEFAULT_EDITOR = os.getenv("ZRB_EDITOR", "nano")
-INIT_MODULES_STR = os.getenv("ZRB_INIT_MODULES", "")
-INIT_MODULES = (
-    [module.strip() for module in INIT_MODULES_STR.split(":") if module.strip() != ""]
-    if INIT_MODULES_STR != ""
-    else []
-)
-INIT_SCRIPTS_STR = os.getenv("ZRB_INIT_SCRIPTS", "")
-INIT_SCRIPTS = (
-    [script.strip() for script in INIT_SCRIPTS_STR.split(":") if script.strip() != ""]
-    if INIT_SCRIPTS_STR != ""
-    else []
-)
-LOGGING_LEVEL = untyped_to_logging_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
-SHOULD_LOAD_BUILTIN = untyped_to_boolean(os.getenv("ZRB_SHOULD_LOAD_BUILTIN", "1"))
-ENV_PREFIX = os.getenv("ZRB_ENV", "")
-SHOW_ADVERTISEMENT = untyped_to_boolean(os.getenv("ZRB_SHOW_ADVERTISEMENT", "1"))
-SHOW_PROMPT = untyped_to_boolean(os.getenv("ZRB_SHOW_PROMPT", "1"))
-SHOW_TIME = untyped_to_boolean(os.getenv("ZRB_SHOW_TIME", "1"))
-VERSION = _get_version()
-ENABLE_TYPE_CHECKING = untyped_to_boolean(os.getenv("ZRB_ENABLE_TYPE_CHECKING", "1"))

zrb/helper/accessories/color.py

@@ -1,44 +0,0 @@
-import random
-from collections.abc import Iterable
-from typing import Optional
-
-from termcolor import COLORS
-
-from zrb.helper.accessories.untyped_color import untyped_colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-
-logger.debug(untyped_colored("Loading zrb.helper.accessories.color", attrs=["dark"]))
-
-
-@typechecked
-def get_random_color() -> str:
-    colors = [
-        "green",
-        "yellow",
-        "blue",
-        "magenta",
-        "cyan",
-        "white",
-        "light_green",
-        "light_yellow",
-        "light_blue",
-        "light_magenta",
-        "light_cyan",
-    ]
-    return random.choice(colors)
-
-
-@typechecked
-def is_valid_color(color: str) -> bool:
-    return color in COLORS
-
-
-@typechecked
-def colored(
-    text: str,
-    color: Optional[str] = None,
-    on_color: Optional[str] = None,
-    attrs: Optional[Iterable[str]] = None,
-) -> str:
-    return untyped_colored(text, color, on_color, attrs)

zrb/helper/accessories/icon.py

@@ -1,36 +0,0 @@
-import random
-
-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.accessories.icon", attrs=["dark"]))
-
-
-@typechecked
-def get_random_icon() -> str:
-    icons = [
-        "🐶",
-        "🐱",
-        "🐭",
-        "🐹",
-        "🦊",
-        "🐻",
-        "🐨",
-        "🐯",
-        "🦁",
-        "🐮",
-        "🐷",
-        "🍎",
-        "🍐",
-        "🍊",
-        "🍋",
-        "🍌",
-        "🍉",
-        "🍇",
-        "🍓",
-        "🍈",
-        "🍒",
-        "🍑",
-    ]
-    return random.choice(icons)

zrb/helper/accessories/name.py

@@ -1,85 +0,0 @@
-import random
-import string
-
-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.accessories.name", attrs=["dark"]))
-
-
-@typechecked
-def get_random_name(
-    separator: str = "-", add_random_digit: bool = True, digit_count: int = 4
-) -> str:
-    prefixes = [
-        "bold",
-        "calm",
-        "dark",
-        "deep",
-        "fast",
-        "firm",
-        "glad",
-        "grey",
-        "hard",
-        "high",
-        "kind",
-        "late",
-        "lean",
-        "long",
-        "loud",
-        "mild",
-        "neat",
-        "pure",
-        "rare",
-        "rich",
-        "safe",
-        "slow",
-        "soft",
-        "tall",
-        "thin",
-        "trim",
-        "vast",
-        "warm",
-        "weak",
-        "wild",
-    ]
-    suffixes = [
-        "arch",
-        "area",
-        "atom",
-        "base",
-        "beam",
-        "bell",
-        "bolt",
-        "bone",
-        "bulk",
-        "bush",
-        "cell",
-        "chip",
-        "clay",
-        "coal",
-        "coil",
-        "cone",
-        "cube",
-        "disk",
-        "dust",
-        "face",
-        "film",
-        "foam",
-        "frog",
-        "fuel",
-        "gate",
-        "gear",
-        "hall",
-        "hand",
-        "horn",
-        "leaf",
-    ]
-    prefix = random.choice(prefixes)
-    suffix = random.choice(suffixes)
-    parts = [prefix, suffix]
-    if add_random_digit:
-        random_digit = "".join(random.choices(string.digits, k=digit_count))
-        parts.append(random_digit)
-    return separator.join(parts)

zrb/helper/accessories/untyped_color.py

@@ -1,10 +0,0 @@
-from termcolor import colored as term_colored
-
-
-def untyped_colored(
-    text,
-    color=None,
-    on_color=None,
-    attrs=None,
-) -> str:
-    return term_colored(text, color, on_color, attrs)

zrb/helper/advertisement.py

@@ -1,33 +0,0 @@
-import datetime
-import random
-import re
-import sys
-from collections.abc import Iterable
-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.advertisement", attrs=["dark"]))
-
-
-@typechecked
-class Advertisement:
-    def __init__(self, content: str, time_pattern: str = ".*"):
-        self.time_pattern = time_pattern
-        self.content = content
-
-    def show(self):
-        print(colored(self.content, attrs=["dark"]), file=sys.stderr)
-
-
-@typechecked
-def get_advertisement(
-    advertisements: Iterable[Advertisement],
-) -> Optional[Advertisement]:
-    now = datetime.datetime.now().isoformat()
-    candidates = [adv for adv in advertisements if re.match(adv.time_pattern, now)]
-    if len(candidates) == 0:
-        return None
-    return random.choice(candidates)

zrb/helper/asyncio_task.py

@@ -1,36 +0,0 @@
-import asyncio
-import sys
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-
-logger.debug(colored("Loading zrb.helper.asyncio_task", attrs=["dark"]))
-
-
-def _surpress_event_loop_error(unraisable):
-    if not (
-        isinstance(unraisable.exc_value, RuntimeError)
-        and str(unraisable.exc_value) == "Event loop is closed"
-    ):
-        # Raise exception for anything except "event loop is closed"
-        sys.__unraisablehook__(unraisable)
-
-
-sys.unraisablehook = _surpress_event_loop_error
-
-
-async def stop_asyncio():
-    tasks = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
-    for task in tasks:
-        task.cancel()
-    # Wait until all tasks are cancelled
-    await asyncio.gather(*tasks, return_exceptions=True)
-
-
-def stop_asyncio_sync():
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            loop.create_task(stop_asyncio())
-    except asyncio.CancelledError:
-        logger.warning("Task is cancelled")

zrb/helper/callable.py

@@ -1,19 +0,0 @@
-import asyncio
-import inspect
-from collections.abc import Callable
-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.callable", attrs=["dark"]))
-
-
-@typechecked
-async def run_async(fn: Callable, *args: Any, **kwargs: Any) -> Any:
-    if inspect.iscoroutinefunction(fn):
-        return await fn(*args, **kwargs)
-    coro = asyncio.to_thread(fn, *args, **kwargs)
-    task = asyncio.create_task(coro)
-    return await task

zrb/helper/cli.py

@@ -1,82 +0,0 @@
-import os
-import traceback
-from functools import lru_cache
-
-import click
-
-from zrb.config.config import INIT_MODULES, INIT_SCRIPTS, SHOULD_LOAD_BUILTIN, VERSION
-from zrb.helper.accessories.color import colored
-from zrb.helper.loader.load_module import load_module
-from zrb.helper.loader.load_script import load_script
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.runner import runner
-
-logger.debug(colored("Loading zrb.helper.cli", attrs=["dark"]))
-
-HELP = f"""
-                bb
-   zzzzz rr rr  bb
-     zz  rrr  r bbbbbb
-    zz   rr     bb   bb
-   zzzzz rr     bbbbbb   {VERSION}
-   _ _ . .  . _ .  _ . . .
-
-Super framework for your super app.
-
-☕ Donate at: https://stalchmst.com/donation
-🐙 Submit issues/PR at: https://github.com/state-alchemists/zrb
-🐤 Follow us at: https://twitter.com/zarubastalchmst
-"""
-
-
-class MultilineHelpClickGroup(click.Group):
-    def format_help_text(self, ctx, formatter):
-        formatter.write(self.help)
-
-
-@lru_cache
-@typechecked
-def create_cli() -> click.Group:
-    logger.info(colored("Prepare CLI", attrs=["dark"]))
-    zrb_cli_group = MultilineHelpClickGroup(name="zrb", help=HELP)
-    # Load default tasks
-    if SHOULD_LOAD_BUILTIN:
-        logger.info(colored("Load builtins", attrs=["dark"]))
-        from zrb import builtin
-
-        assert builtin
-    # load from ZRB_INIT_MODULES
-    for init_module in INIT_MODULES:
-        try:
-            load_module(init_module)
-        except Exception:
-            logger.error(
-                colored(
-                    f"Failed to load module {init_module}",
-                    color="red",
-                    attrs=["bold"],
-                )
-            )
-    # Load zrb_init.py
-    project_dir = os.getenv("ZRB_PROJECT_DIR", os.getcwd())
-    project_script = os.path.join(project_dir, "zrb_init.py")
-    load_script(script_path=project_script, sys_path_index=0)
-    # load from ZRB_INIT_SCRIPTS environment
-    for index, init_script in enumerate(INIT_SCRIPTS):
-        logger.info(colored(f"Load module from {init_script}", attrs=["dark"]))
-        try:
-            load_script(script_path=init_script, sys_path_index=index + 1)
-        except Exception:
-            logger.error(
-                colored(
-                    f"Failed to load module from {init_script}",
-                    color="red",
-                    attrs=["bold"],
-                )
-            )
-            traceback.print_exc()
-    # Serve all tasks registered to runner
-    logger.info(colored("Serve CLI", attrs=["dark"]))
-    cli = runner.serve(zrb_cli_group)
-    return cli

zrb/helper/codemod/add_argument_to_function.py

@@ -1,44 +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_argument_to_function", attrs=["dark"])
-)
-
-
-@typechecked
-class AddArgumentTransformer(cst.CSTTransformer):
-    def __init__(self, function_name: str, argument_name: str, argument_type: str):
-        self.function_name = function_name
-        self.argument_name = argument_name
-        self.argument_type = argument_type
-        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_params = updated_node.params.params + (
-                cst.Param(
-                    cst.Name(self.argument_name),
-                    cst.Annotation(cst.Name(self.argument_type)),
-                ),
-            )
-            return updated_node.with_changes(
-                params=cst.Parameters(new_params),
-            )
-        return updated_node
-
-
-@typechecked
-def add_argument_to_function(
-    code: str, function_name: str, argument_name: str, argument_type: str
-) -> str:
-    module = cst.parse_module(code)
-    transformed_module = module.visit(
-        AddArgumentTransformer(function_name, argument_name, argument_type)
-    )
-    return transformed_module.code

zrb/helper/codemod/add_argument_to_function_call.py

@@ -1,37 +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_argument_to_function_call", attrs=["dark"])
-)
-
-
-@typechecked
-class AddArgumentTransformer(cst.CSTTransformer):
-    def __init__(self, function_name: str, argument_name: str):
-        self.function_name = function_name
-        self.argument_name = argument_name
-        super().__init__()
-
-    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
-        if (
-            isinstance(updated_node.func, cst.Name)
-            and updated_node.func.value == self.function_name
-        ):
-            new_args = updated_node.args + (cst.Arg(cst.Name(self.argument_name)),)
-            return updated_node.with_changes(args=new_args)
-        return updated_node
-
-
-@typechecked
-def add_argument_to_function_call(
-    code: str, function_name: str, argument_name: str
-) -> str:
-    module = cst.parse_module(code)
-    transformed_module = module.visit(
-        AddArgumentTransformer(function_name, argument_name)
-    )
-    return transformed_module.code

zrb/helper/codemod/add_assert_resource.py

@@ -1,37 +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_assert_resource", attrs=["dark"]))
-
-
-@typechecked
-def add_assert_resource(code: str, resource: str) -> str:
-    """
-    Adds an assertion statement to the end of a module that checks whether
-    a resource has been successfully loaded.
-
-    Args:
-        code (str): The code of the module to modify.
-        resoource (str): The name of the resource to check.
-
-    Returns:
-        str: The modified code with the new assertion statement added.
-    """
-
-    module = cst.parse_module(code)
-
-    # Create the new assertion statement
-    new_assert = cst.SimpleStatementLine(
-        [
-            cst.Assert(test=cst.Name(value=resource), msg=None),
-        ]
-    )
-
-    module.body.append(new_assert)
-
-    # Generate the modified code
-    modified_code = module.code
-    return modified_code

zrb/helper/codemod/add_function_call.py

@@ -1,39 +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_function_call", attrs=["dark"]))
-
-
-@typechecked
-def add_function_call(code: str, function_name: str, parameters: list) -> str:
-    """
-    Adds a function call statement to the end of a module with the specified
-    function name and parameters.
-
-    Args:
-        code (str): The code of the module to modify.
-        function_name (str): The name of the function to call.
-        parameters (list): A list of parameters to pass to the function call.
-
-    Returns:
-        str: The modified code with the new function call statement added.
-    """
-
-    module = cst.parse_module(code)
-
-    # Create the new function call statement
-    new_function_call = cst.Expr(
-        value=cst.Call(
-            func=cst.Name(value=function_name),
-            args=[cst.Arg(value=cst.parse_expression(param)) for param in parameters],
-        )
-    )
-
-    module.body.append(cst.SimpleStatementLine([new_function_call]))
-
-    # Generate the modified code
-    modified_code = module.code
-    return modified_code