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

zrb/builtin/todo.py

@@ -0,0 +1,219 @@
+import datetime
+import json
+import os
+from typing import Any
+
+from zrb.builtin.group import todo_group
+from zrb.config import TODO_DIR
+from zrb.context.any_context import AnyContext
+from zrb.input.str_input import StrInput
+from zrb.input.text_input import TextInput
+from zrb.task.make_task import make_task
+from zrb.util.todo import (
+    TodoTaskModel,
+    add_durations,
+    cascade_todo_task,
+    get_visual_todo_list,
+    line_to_todo_task,
+    load_todo_list,
+    save_todo_list,
+    select_todo_task,
+    todo_task_to_line,
+)
+
+
+@make_task(
+    name="todo-add",
+    input=[
+        StrInput(
+            name="description",
+            description="Task description",
+            prompt="Task description",
+        ),
+        StrInput(
+            name="priority",
+            description="Task priority",
+            prompt="Task priority",
+            default_str="E",
+        ),
+        StrInput(
+            name="project",
+            description="Task project",
+            prompt="Task project (space separated)",
+        ),
+        StrInput(
+            name="context",
+            description="Task context",
+            prompt="Task context (space separated)",
+        ),
+    ],
+    description="➕ Add todo",
+    group=todo_group,
+    alias="add",
+)
+def todo_add(ctx: AnyContext):
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    todo_list: list[TodoTaskModel] = []
+    if os.path.isfile(todo_file_path):
+        todo_list = load_todo_list(todo_file_path)
+    else:
+        os.makedirs(TODO_DIR, exist_ok=True)
+    todo_list.append(
+        cascade_todo_task(
+            TodoTaskModel(
+                priority=ctx.input.priority.upper(),
+                description=ctx.input.description,
+                contexts=[
+                    context.strip()
+                    for context in ctx.input.context.split(" ")
+                    if context.strip() != ""
+                ],
+                projects=[
+                    project.strip()
+                    for project in ctx.input.project.split(" ")
+                    if project.strip() != ""
+                ],
+            )
+        )
+    )
+    save_todo_list(todo_file_path, todo_list)
+    return get_visual_todo_list(todo_list)
+
+
+@make_task(name="todo-list", description="📋 List todo", group=todo_group, alias="list")
+def todo_list(ctx: AnyContext):
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    todo_tasks: list[TodoTaskModel] = []
+    if os.path.isfile(todo_file_path):
+        todo_tasks = load_todo_list(todo_file_path)
+    return get_visual_todo_list(todo_tasks)
+
+
+@make_task(
+    name="todo-complete",
+    input=StrInput(name="keyword", prompt="Task keyword", description="Task Keyword"),
+    description="✅ Complete todo",
+    group=todo_group,
+    alias="complete",
+)
+def todo_complete(ctx: AnyContext):
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    todo_list: list[TodoTaskModel] = []
+    if os.path.isfile(todo_file_path):
+        todo_list = load_todo_list(todo_file_path)
+    # Get todo task
+    todo_task = select_todo_task(todo_list, ctx.input.keyword)
+    if todo_task is None:
+        ctx.log_error("Task not found")
+        return get_visual_todo_list(todo_list)
+    # Update todo task
+    todo_task = cascade_todo_task(todo_task)
+    if todo_task.creation_date is not None:
+        todo_task.completion_date = datetime.date.today()
+    todo_task.completed = True
+    # Save todo list
+    save_todo_list(todo_file_path, todo_list)
+    return get_visual_todo_list(todo_list)
+
+
+@make_task(
+    name="todo-log",
+    input=[
+        StrInput(name="keyword", prompt="Task keyword", description="Task Keyword"),
+        StrInput(
+            name="start",
+            prompt="Working start time (%Y-%m-%d %H:%M:%S)",
+            description="Working start time",
+            default_str=lambda _: _get_default_start(),
+        ),
+        StrInput(
+            name="duration",
+            prompt="Working duration",
+            description="Working duration",
+            default_str="30m",
+        ),
+        StrInput(
+            name="log",
+            prompt="Working log",
+            description="Working log",
+        ),
+    ],
+    description="🕒 Log work todo",
+    group=todo_group,
+    alias="log",
+)
+def todo_log(ctx: AnyContext):
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    todo_list: list[TodoTaskModel] = []
+    if os.path.isfile(todo_file_path):
+        todo_list = load_todo_list(todo_file_path)
+    # Get todo task
+    todo_task = select_todo_task(todo_list, ctx.input.keyword)
+    if todo_task is None:
+        ctx.log_error("Task not found")
+        return get_visual_todo_list(todo_list)
+    # Update todo task
+    todo_task = cascade_todo_task(todo_task)
+    current_duration = todo_task.keyval.get("duration", "0")
+    todo_task.keyval["duration"] = add_durations(current_duration, ctx.input.duration)
+    print(current_duration, todo_task.keyval)
+    # Save todo list
+    save_todo_list(todo_file_path, todo_list)
+    # Add log work
+    log_work_dir = os.path.join(TODO_DIR, "log-work")
+    os.makedirs(log_work_dir, exist_ok=True)
+    log_work_file_path = os.path.join(
+        log_work_dir, f"{todo_task.keyval.get('id')}.json"
+    )
+    if os.path.isfile(log_work_file_path):
+        with open(log_work_file_path, "r") as f:
+            log_work_json = f.read()
+    else:
+        log_work_json = "[]"
+    log_work: list[dict[str, Any]] = json.loads(log_work_json)
+    log_work.append(
+        {"log": ctx.input.log, "duration": ctx.input.duration, "start": ctx.input.start}
+    )
+    with open(log_work_file_path, "w") as f:
+        f.write(json.dumps(log_work, indent=2))
+    return get_visual_todo_list(todo_list)
+
+
+def _get_default_start() -> str:
+    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+@make_task(
+    name="todo-edit",
+    input=[
+        TextInput(
+            name="text",
+            description="Todo.txt content",
+            prompt="Todo.txt content (will override existing)",
+            default_str=lambda _: _get_todo_txt_content(),
+        ),
+    ],
+    description="📝 Edit todo",
+    group=todo_group,
+    alias="edit",
+)
+def todo_edit(ctx: AnyContext):
+    todo_list = [
+        cascade_todo_task(line_to_todo_task(line))
+        for line in ctx.input.text.split("\n")
+        if line.strip() != ""
+    ]
+    new_content = "\n".join(todo_task_to_line(todo_task) for todo_task in todo_list)
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    with open(todo_file_path, "w") as f:
+        f.write(new_content)
+    todo_list = load_todo_list(todo_file_path)
+    return get_visual_todo_list(todo_list)
+
+
+def _get_todo_txt_content() -> str:
+    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
+    if not os.path.isfile(todo_file_path):
+        return ""
+    with open(todo_file_path, "r") as f:
+        return f.read()

zrb/callback/any_callback.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from zrb.context.any_shared_context import AnySharedContext
+
+
+class AnyCallback(ABC):
+    @abstractmethod
+    async def async_run(self, parent_ctx: AnySharedContext) -> Any:
+        pass

zrb/callback/callback.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from zrb.attr.type import StrDictAttr
+from zrb.callback.any_callback import AnyCallback
+from zrb.session.any_session import AnySession
+from zrb.task.any_task import AnyTask
+from zrb.util.attr import get_str_dict_attr
+
+
+class Callback(AnyCallback):
+
+    def __init__(
+        self,
+        input_mapping: StrDictAttr,
+        task: AnyTask,
+        auto_render: bool = True,
+    ):
+        self._input_mapping = input_mapping
+        self._task = task
+        self._auto_render = auto_render
+
+    async def async_run(self, session: AnySession) -> Any:
+        inputs = get_str_dict_attr(
+            session.shared_ctx, self._input_mapping, auto_render=self._auto_render
+        )
+        for name, value in inputs.items():
+            session.shared_ctx.input[name] = value
+        return await self._task.async_run(session)

zrb/cmd/cmd_result.py

@@ -0,0 +1,15 @@
+class CmdResult:
+    def __init__(self, output: str, error: str):
+        self.output = output
+        self.error = error
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        last_line_output = self.output.split("\n")[-1]
+        shown_output = f"...{last_line_output}" if last_line_output != "" else ""
+        last_line_error = self.error.split("\n")[-1]
+        shown_error = f"...{last_line_error}" if last_line_error != "" else ""
+        return f"<{class_name} output={shown_output} error=...{shown_error}>"
+
+    def __str__(self) -> str:
+        return self.output

zrb/cmd/cmd_val.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+
+from zrb.attr.type import fstring
+from zrb.context.context import Context
+
+
+class AnyCmdVal(ABC):
+    @abstractmethod
+    def to_str(self, ctx: Context) -> str:
+        pass
+
+
+class CmdPath(AnyCmdVal):
+    def __init__(self, path: str, auto_render: bool = True):
+        self._path = path
+        self._auto_render = auto_render
+
+    def to_str(self, ctx: Context) -> str:
+        file_path = ctx.render(self._path) if self._auto_render else self._path
+        with open(file_path) as file:
+            return file.read()
+
+
+class Cmd(AnyCmdVal):
+    def __init__(self, cmd: str, auto_render: str):
+        self._cmd = cmd
+        self._auto_render = auto_render
+
+    def to_str(self, ctx: Context) -> str:
+        return ctx.render(self._cmd) if self._auto_render else self._cmd
+
+
+SingleCmdVal = AnyCmdVal | fstring | Callable[[Context], str]
+CmdVal = SingleCmdVal | list[SingleCmdVal]

zrb/config.py

@@ -0,0 +1,85 @@
+import importlib.metadata as metadata
+import logging
+import os
+import platform
+
+from zrb.util.string.conversion import to_boolean
+
+
+def _get_current_shell() -> str:
+    if platform.system() == "Windows":
+        return "PowerShell"
+    current_shell = os.getenv("SHELL", "")
+    if current_shell.endswith("zsh"):
+        return "zsh"
+    return "bash"
+
+
+def _get_log_level(level: str) -> int:
+    level = level.upper()
+    log_levels = {
+        "CRITICAL": logging.CRITICAL,  # 50
+        "ERROR": logging.ERROR,  # 40
+        "WARN": logging.WARNING,  # 30
+        "WARNING": logging.WARNING,  # 30
+        "INFO": logging.INFO,  # 20
+        "DEBUG": logging.DEBUG,  # 10
+        "NOTSET": logging.NOTSET,  # 0
+    }
+    if level in log_levels:
+        return log_levels[level]
+    return logging.WARNING
+
+
+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 = _get_log_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
+LOAD_BUILTIN = to_boolean(os.getenv("ZRB_LOAD_BUILTIN", "1"))
+ENV_PREFIX = os.getenv("ZRB_ENV", "")
+SHOW_PROMPT = to_boolean(os.getenv("ZRB_SHOW_PROMPT", "1"))
+SESSION_LOG_DIR = os.getenv(
+    "ZRB_SESSION_LOG_DIR", os.path.expanduser(os.path.join("~", ".zrb-session"))
+)
+TODO_DIR = os.getenv("ZRB_TODO_DIR", os.path.expanduser(os.path.join("~", "todo")))
+VERSION = metadata.version("zrb")
+WEB_HTTP_PORT = int(os.getenv("ZRB_WEB_HTTP_PORT", "21213"))
+LLM_MODEL = os.getenv("ZRB_LLM_MODEL", "ollama_chat/llama3.1")
+LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", "You are a helpful assistant")
+LLM_HISTORY_FILE = os.getenv(
+    "ZRB_LLM_HISTORY_FILE",
+    os.path.expanduser(os.path.join("~", ".zrb-llm-history.json")),
+)
+LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_FILE", "1"))
+LLM_ALLOW_ACCESS_WEB = to_boolean(os.getenv("ZRB_LLM_ACCESS_WEB", "1"))
+RAG_EMBEDDING_MODEL = os.getenv("ZRB_RAG_EMBEDDING_MODEL", "ollama/nomic-embed-text")
+RAG_CHUNK_SIZE = int(os.getenv("ZRB_RAG_CHUNK_SIZE", "1024"))
+RAG_OVERLAP = int(os.getenv("ZRB_RAG_OVERLAP", "128"))
+RAG_MAX_RESULT_COUNT = int(os.getenv("ZRB_RAG_MAX_RESULT_COUNT", "5"))
+
+
+BANNER = f"""
+                bb
+   zzzzz rr rr  bb
+     zz  rrr  r bbbbbb
+    zz   rr     bb   bb
+   zzzzz rr     bbbbbb   {VERSION} Janggala
+   _ _ . .  . _ .  _ . . .
+
+A Framework to Enhance Your Workflow
+
+☕ Donate at: https://stalchmst.com/donation
+🐙 Submit issues/PR at: https://github.com/state-alchemists/zrb
+🐤 Follow us at: https://twitter.com/zarubastalchmst
+"""

zrb/content_transformer/any_content_transformer.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+from zrb.context.any_context import AnyContext
+
+
+class AnyContentTransformer(ABC):
+    @abstractmethod
+    def match(self, ctx: AnyContext, file_path: str) -> bool:
+        """
+        Determine whether a file path should be processed or not
+
+        Args:
+            ctx (AnyContext): The context
+            file_path(str): The file path
+
+        Returns:
+            bool: Whether the file path should be processed or not
+        """
+        pass
+
+    @abstractmethod
+    def transform_file(self, ctx: AnyContext, file_path: str):
+        """
+        Transform  the file path
+
+        Args:
+            ctx (AnyContext): The context
+            file_path(str): The file path
+        """
+        pass

zrb/content_transformer/content_transformer.py

@@ -0,0 +1,45 @@
+import fnmatch
+import re
+from collections.abc import Callable
+
+from zrb.content_transformer.any_content_transformer import AnyContentTransformer
+from zrb.context.any_context import AnyContext
+
+
+class ContentTransformer(AnyContentTransformer):
+
+    def __init__(
+        self,
+        match: list[str] | str | Callable[[AnyContext, str], bool],
+        transform: dict[str, str] | Callable[[AnyContext, str], str],
+        auto_render: bool = True,
+    ):
+        self._match = match
+        self._transform_file = transform
+        self._auto_render = auto_render
+
+    def match(self, ctx: AnyContext, file_path: str) -> bool:
+        if callable(self._match):
+            return self._match(ctx, file_path)
+        patterns = [self._match] if isinstance(self._match, str) else self._match
+        for pattern in patterns:
+            try:
+                if re.fullmatch(pattern, file_path):
+                    return True
+            except re.error:
+                pass
+            return fnmatch.fnmatch(file_path, pattern)
+
+    def transform_file(self, ctx: AnyContext, file_path: str):
+        if callable(self._transform_file):
+            return self._transform_file(ctx, file_path)
+        transform_map = {
+            keyword: ctx.render(replacement) if self._auto_render else replacement
+            for keyword, replacement in self._transform_file.items()
+        }
+        with open(file_path, "r") as f:
+            content = f.read()
+        for keyword, replacement in transform_map.items():
+            content = content.replace(keyword, replacement)
+        with open(file_path, "w") as f:
+            f.write(content)

zrb/context/any_context.py

@@ -0,0 +1,192 @@
+import sys
+from abc import abstractmethod
+from typing import TextIO
+
+from zrb.context.any_shared_context import AnySharedContext
+
+
+class AnyContext(AnySharedContext):
+    """Abstract base class for managing task contexts, logging, and rendering.
+
+    This class provides methods for managing context-specific data such as
+    attempt counts, logging, and rendering templates with additional data.
+    Subclasses must implement all abstract methods.
+    """
+
+    @abstractmethod
+    def set_attempt(self, attempt: int):
+        """Sets the current attempt count.
+
+        Args:
+            attempt (int): The current attempt count.
+        """
+        pass
+
+    @abstractmethod
+    def set_max_attempt(self, max_attempt: int):
+        """Sets the maximum number of attempts.
+
+        Args:
+            max_attempt (int): The maximum number of attempts allowed.
+        """
+        pass
+
+    @abstractmethod
+    def update_task_env(self, task_env: dict[str, str]):
+        pass
+
+    @abstractmethod
+    def print(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Prints values to the specified output stream.
+
+        Args:
+            *values (object): The values to be printed.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to print to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def log_debug(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Logs debug-level messages.
+
+        Args:
+            *values (object): The values to be logged.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to log to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def log_info(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Logs info-level messages.
+
+        Args:
+            *values (object): The values to be logged.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to log to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def log_warning(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Logs warning-level messages.
+
+        Args:
+            *values (object): The values to be logged.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to log to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def log_error(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Logs error-level messages.
+
+        Args:
+            *values (object): The values to be logged.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to log to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def log_critical(
+        self,
+        *values: object,
+        sep: str | None = " ",
+        end: str | None = "\n",
+        file: TextIO | None = sys.stderr,
+        flush: bool = True
+    ):
+        """Logs critical-level messages.
+
+        Args:
+            *values (object): The values to be logged.
+            sep (str, optional): Separator to use between values. Defaults to a space.
+            end (str, optional): String appended after the last value. Defaults to a newline.
+            file (TextIO, optional): The output stream to log to. Defaults to sys.stderr.
+            flush (bool, optional): Whether to flush the output stream. Defaults to True.
+        """
+        pass
+
+    @abstractmethod
+    def render_bool(self, template: str | bool) -> bool:
+        """Renders a template string into boolean.
+
+        Args:
+            template (str | bool): The template string to be rendered or the value.
+
+        Returns:
+            bool: The rendered template as a boolean.
+        """
+        pass
+
+    @abstractmethod
+    def render_int(self, template: str | int) -> int:
+        """Renders a template string into integer.
+
+        Args:
+            template (str | int): The template string to be rendered or the value.
+
+        Returns:
+            int: The rendered template as a integer.
+        """
+        pass
+
+    @abstractmethod
+    def render_float(self, template: str | float) -> float:
+        """Renders a template string into float.
+
+        Args:
+            template (str | float): The template string to be rendered or the value.
+
+        Returns:
+            float: The rendered template as a float.
+        """
+        pass