zrb 1.5.14__tar.gz → 1.5.16__tar.gz

{zrb-1.5.14 → zrb-1.5.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.5.14
+Version: 1.5.16
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -27,6 +27,7 @@ Requires-Dist: pdfplumber (>=0.11.6,<0.12.0) ; extra == "rag" or extra == "all"
 Requires-Dist: playwright (>=1.51.0,<2.0.0) ; extra == "playwright" or extra == "all"
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pydantic-ai (>=0.1.6,<0.2.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)

{zrb-1.5.14 → zrb-1.5.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.5.14"
+version = "1.5.16"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -53,6 +53,7 @@ pydantic-ai = "^0.1.6"
 openai = {version = "^1.76.0", optional = true}
 playwright = {version = "^1.51.0", optional = true}
 psutil = "^7.0.0"
+pyjwt = "^2.10.1"
 
 [tool.poetry.extras]
 # poetry install -E rag

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/builtin/__init__.py

@@ -1,4 +1,4 @@
-from zrb.builtin.base64 import decode_base64, encode_base64
+from zrb.builtin.base64 import decode_base64, encode_base64, validate_base64
 from zrb.builtin.git import (
     get_git_diff,
     git_commit,
@@ -7,8 +7,10 @@ from zrb.builtin.git import (
     prune_local_branches,
 )
 from zrb.builtin.git_subtree import git_add_subtree, git_pull_subtree, git_push_subtree
+from zrb.builtin.http import generate_curl, http_request
+from zrb.builtin.jwt import decode_jwt, encode_jwt, validate_jwt
 from zrb.builtin.llm.llm_chat import llm_chat
-from zrb.builtin.md5 import hash_md5, sum_md5
+from zrb.builtin.md5 import hash_md5, sum_md5, validate_md5
 from zrb.builtin.project.add.fastapp.fastapp_task import add_fastapp_to_project
 from zrb.builtin.project.create.project_task import create_project
 from zrb.builtin.python import format_python_code
@@ -30,6 +32,17 @@ from zrb.builtin.todo import (
     log_todo,
     show_todo,
 )
+from zrb.builtin.uuid import (
+    generate_uuid_v1,
+    generate_uuid_v3,
+    generate_uuid_v4,
+    generate_uuid_v5,
+    validate_uuid,
+    validate_uuid_v1,
+    validate_uuid_v3,
+    validate_uuid_v4,
+    validate_uuid_v5,
+)
 
 assert create_project
 assert add_fastapp_to_project
@@ -38,9 +51,14 @@ assert make_bash_autocomplete
 assert make_zsh_autocomplete
 assert encode_base64
 assert decode_base64
+assert validate_base64
+assert encode_jwt
+assert decode_jwt
+assert validate_jwt
 assert llm_chat
 assert hash_md5
 assert sum_md5
+assert validate_md5
 assert get_git_diff
 assert prune_local_branches
 assert format_python_code
@@ -64,3 +82,14 @@ assert setup_latex_on_ubuntu
 assert setup_asdf
 assert setup_tmux
 assert setup_zsh
+assert validate_uuid
+assert validate_uuid_v1
+assert validate_uuid_v3
+assert validate_uuid_v4
+assert validate_uuid_v5
+assert generate_uuid_v1
+assert generate_uuid_v3
+assert generate_uuid_v4
+assert generate_uuid_v5
+assert http_request
+assert generate_curl

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/builtin/base64.py

@@ -32,3 +32,27 @@ def decode_base64(ctx: AnyContext) -> str:
     result = base64.b64decode(ctx.input.text.encode()).decode()
     ctx.print(result)
     return result
+
+
+@make_task(
+    name="validate-base64",
+    input=StrInput(
+        name="text",
+        description="Text to validate",
+        prompt="Enter text to validate as base64",
+    ),
+    description="✅ Validate base64 text",
+    group=base64_group,
+    alias="validate",
+)
+def validate_base64(ctx: AnyContext) -> bool:
+    import base64
+    import binascii
+
+    try:
+        base64.b64decode(ctx.input.text.encode()).decode()
+        ctx.print("Valid base64")
+        return True
+    except (binascii.Error, UnicodeDecodeError):
+        ctx.print("Invalid base64")
+        return False

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/builtin/group.py

@@ -2,6 +2,15 @@ from zrb.group.group import Group
 from zrb.runner.cli import cli
 
 base64_group = cli.add_group(Group(name="base64", description="📄 Base64 operations"))
+uuid_group = cli.add_group(Group(name="uuid", description="🆔 UUID operations"))
+uuid_v1_group = uuid_group.add_group(Group(name="v1", description="UUID V1 operations"))
+uuid_v3_group = uuid_group.add_group(Group(name="v3", description="UUID V3 operations"))
+uuid_v4_group = uuid_group.add_group(Group(name="v4", description="UUID V4 operations"))
+uuid_v5_group = uuid_group.add_group(Group(name="v5", description="UUID V5 operations"))
+ulid_group = cli.add_group(Group(name="ulid", description="🔢 ULID operations"))
+jwt_group = cli.add_group(Group(name="jwt", description="🔒 JWT encode/decode"))
+http_group = cli.add_group(Group(name="http", description="🌐 HTTP request operations"))
+
 random_group = cli.add_group(Group(name="random", description="🔀 Random operation"))
 git_group = cli.add_group(Group(name="git", description="🌱 Git related commands"))
 git_branch_group = git_group.add_group(

zrb-1.5.16/src/zrb/builtin/http.py

@@ -0,0 +1,152 @@
+from typing import Any
+
+from zrb.builtin.group import http_group
+from zrb.context.any_context import AnyContext
+from zrb.input.option_input import OptionInput
+from zrb.input.str_input import StrInput
+from zrb.task.make_task import make_task
+
+
+@make_task(
+    name="http-request",
+    description="🌐 Send HTTP request (Postman-like)",
+    group=http_group,
+    alias="request",
+    input=[
+        OptionInput(
+            name="method",
+            default="GET",
+            options=["GET", "POST", "PUT", "DELETE", "PATCH"],
+            prompt="HTTP method",
+        ),
+        StrInput(name="url", description="Target URL", prompt="Enter request URL"),
+        StrInput(
+            name="headers",
+            description="Request headers (JSON)",
+            prompt="Enter headers as JSON",
+            default="{}",
+        ),
+        StrInput(
+            name="body",
+            description="Request body (JSON)",
+            prompt="Enter body as JSON",
+            default="{}",
+        ),
+        OptionInput(
+            name="verify_ssl",
+            default="true",
+            options=["true", "false"],
+            description="Verify SSL certificate",
+        ),
+    ],
+)
+def http_request(ctx: AnyContext) -> Any:
+    import json
+
+    import requests
+
+    try:
+        # Prepare headers
+        headers = json.loads(ctx.input.headers)
+
+        # Prepare body
+        body = None
+        if ctx.input.body != "{}":
+            body = json.loads(ctx.input.body)
+
+        # Make request
+        verify = ctx.input.verify_ssl.lower() == "true"
+        response = requests.request(
+            method=ctx.input.method,
+            url=ctx.input.url,
+            headers=headers,
+            json=body,
+            verify=verify,
+        )
+
+        # Print request/response details
+        ctx.print("🌐 Request:")
+        ctx.print(f"  Method: {ctx.input.method}")
+        ctx.print(f"  URL: {ctx.input.url}")
+        ctx.print(f"  Headers: {headers}")
+        ctx.print(f"  Body: {body}")
+        ctx.print(f"  Verify SSL: {verify}")
+        ctx.print("📥 Response:")
+        ctx.print(f"  Status: {response.status_code}")
+        ctx.print(f"  Headers: {dict(response.headers)}")
+        ctx.print(f"  Body: {response.text}")
+
+        return response
+    except Exception as e:
+        ctx.print_err(f"HTTP request failed: {e}")
+        raise
+
+
+@make_task(
+    name="generate-curl",
+    description="🔄 Generate curl command",
+    group=http_group,
+    alias="curl",
+    input=[
+        OptionInput(
+            name="method",
+            default="GET",
+            options=["GET", "POST", "PUT", "DELETE", "PATCH"],
+            prompt="HTTP method",
+        ),
+        StrInput(name="url", description="Target URL", prompt="Enter request URL"),
+        StrInput(
+            name="headers",
+            description="Request headers (JSON)",
+            prompt="Enter headers as JSON",
+            default="{}",
+        ),
+        StrInput(
+            name="body",
+            description="Request body (JSON)",
+            prompt="Enter body as JSON",
+            default="{}",
+        ),
+        OptionInput(
+            name="verify_ssl",
+            default="true",
+            options=["true", "false"],
+            description="Verify SSL certificate",
+        ),
+    ],
+)
+def generate_curl(ctx: AnyContext) -> str:
+    import json
+    import shlex
+
+    try:
+        # Prepare curl command parts
+        parts = ["curl"]
+
+        # Add method
+        parts.extend(["-X", ctx.input.method])
+
+        # Add headers
+        if ctx.input.headers != "{}":
+            headers = json.loads(ctx.input.headers)
+            for key, value in headers.items():
+                parts.extend(["-H", f"{key}: {value}"])
+
+        # Add body
+        if ctx.input.body != "{}":
+            parts.extend(["--data-raw", shlex.quote(ctx.input.body)])
+
+        # Add SSL verification
+        if ctx.input.verify_ssl.lower() == "false":
+            parts.append("--insecure")
+
+        # Add URL
+        parts.append(shlex.quote(ctx.input.url))
+
+        # Join parts into command string
+        curl_command = " ".join(parts)
+        ctx.print(f"🔄 Curl command: {curl_command}")
+        return curl_command
+    except Exception as e:
+        ctx.print_err(f"Failed to generate curl command: {e}")
+        raise

zrb-1.5.16/src/zrb/builtin/jwt.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict
+
+from zrb.builtin.group import jwt_group
+from zrb.context.any_context import AnyContext
+from zrb.input.option_input import OptionInput
+from zrb.input.str_input import StrInput
+from zrb.task.make_task import make_task
+
+
+@make_task(
+    name="encode-jwt",
+    description="🔒 Encode JWT token",
+    group=jwt_group,
+    alias="encode",
+    input=[
+        StrInput(name="secret", prompt="Secret", default=""),
+        StrInput(name="payload", prompt="Payload (JSON format)", default="{}"),
+        OptionInput(
+            name="algorithm",
+            prompt="Algorithm",
+            default="HS256",
+            options=["HS256", "HS384", "HS512"],
+        ),
+    ],
+)
+def encode_jwt(ctx: AnyContext) -> str:
+    import jwt
+
+    try:
+        payload = eval(ctx.input.payload)
+        token = jwt.encode(
+            payload=payload, key=ctx.input.secret, algorithm=ctx.input.algorithm
+        )
+        ctx.print(token)
+        return token
+    except Exception as e:
+        ctx.print_err(f"Failed to encode JWT: {e}")
+        raise
+
+
+@make_task(
+    name="decode-jwt",
+    description="🔓 Decode JWT token",
+    group=jwt_group,
+    alias="decode",
+    input=[
+        StrInput(name="token", prompt="Token", default=""),
+        StrInput(name="secret", prompt="Secret", default=""),
+        OptionInput(
+            name="algorithm",
+            prompt="Algorithm",
+            default="HS256",
+            options=["HS256", "HS384", "HS512"],
+        ),
+    ],
+)
+def decode_jwt(ctx: AnyContext) -> Dict[str, Any]:
+    import jwt
+
+    try:
+        payload = jwt.decode(
+            jwt=ctx.input.token, key=ctx.input.secret, algorithms=[ctx.input.algorithm]
+        )
+        ctx.print(payload)
+        return payload
+    except Exception as e:
+        ctx.print_err(f"Failed to decode JWT: {e}")
+        raise
+
+
+@make_task(
+    name="validate-jwt",
+    description="✅ Validate JWT token",
+    group=jwt_group,
+    alias="validate",
+    input=[
+        StrInput(name="token", prompt="Token", default=""),
+        StrInput(name="secret", prompt="Secret", default=""),
+        OptionInput(
+            name="algorithm",
+            prompt="Algorithm",
+            default="HS256",
+            options=["HS256", "HS384", "HS512"],
+        ),
+    ],
+)
+def validate_jwt(ctx: AnyContext) -> bool:
+    import jwt
+
+    try:
+        jwt.decode(
+            jwt=ctx.input.token, key=ctx.input.secret, algorithms=[ctx.input.algorithm]
+        )
+        ctx.print("✅ Token is valid")
+        return True
+    except jwt.ExpiredSignatureError:
+        ctx.print_err("❌ Token has expired")
+        return False
+    except jwt.InvalidTokenError:
+        ctx.print_err("❌ Invalid token")
+        return False
+    except Exception as e:
+        ctx.print_err(f"❌ Validation failed: {e}")
+        return False

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/builtin/md5.py

@@ -34,3 +34,26 @@ def sum_md5(ctx: AnyContext) -> str:
     result = hashlib.md5(content).hexdigest()
     ctx.print(result)
     return result
+
+
+@make_task(
+    name="validate-md5",
+    input=StrInput(
+        name="hash",
+        description="Hash to validate",
+        prompt="Enter hash to validate as MD5",
+    ),
+    description="✅ Validate MD5 hash",
+    group=md5_group,
+    alias="validate",
+)
+def validate_md5(ctx: AnyContext) -> bool:
+    import re
+
+    pattern = r"^[a-f0-9]{32}$"
+    is_valid = bool(re.fullmatch(pattern, ctx.input.hash))
+    if is_valid:
+        ctx.print("Valid MD5 hash")
+    else:
+        ctx.print("Invalid MD5 hash")
+    return is_valid

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/builtin/todo.py

@@ -215,7 +215,7 @@ def archive_todo(ctx: AnyContext):
     # Save the new todo list and add the archived ones
     save_todo_list(archive_file_path, archived_todo_list)
     save_todo_list(todo_file_path, working_todo_list)
-    return get_visual_todo_list(todo_list, filter=ctx.input.filter)
+    return get_visual_todo_list(working_todo_list, filter=ctx.input.filter)
 
 
 @make_task(

zrb-1.5.16/src/zrb/builtin/uuid.py

@@ -0,0 +1,224 @@
+from zrb.builtin.group import (
+    uuid_group,
+    uuid_v1_group,
+    uuid_v3_group,
+    uuid_v4_group,
+    uuid_v5_group,
+)
+from zrb.context.any_context import AnyContext
+from zrb.input.option_input import OptionInput
+from zrb.input.str_input import StrInput
+from zrb.task.make_task import make_task
+
+
+@make_task(
+    name="generate-uuid-v1",
+    description="🔨 Generate UUID V1",
+    input=[
+        StrInput(
+            name="node",
+            description="48-bit hardware address as integer (leave empty for random)",
+            prompt="Enter node address (48-bit integer)",
+            allow_empty=True,
+        ),
+        StrInput(
+            name="clock-seq",
+            description="14-bit sequence number as integer (leave empty for random)",
+            prompt="Enter clock sequence (14-bit integer)",
+            allow_empty=True,
+        ),
+    ],
+    group=uuid_v1_group,
+    alias="generate",
+)
+def generate_uuid_v1(ctx: AnyContext) -> str:
+    import uuid
+
+    result = str(
+        uuid.uuid1(
+            node=int(ctx.input.node) if ctx.input.node != "" else None,
+            clock_seq=int(ctx.input.clock_seq) if ctx.input.clock_seq != "" else None,
+        )
+    )
+    ctx.print(result)
+    return result
+
+
+@make_task(
+    name="generate-uuid-v3",
+    description="🔨 Generate UUID v3 (MD5 namespace-based)",
+    input=[
+        OptionInput(
+            name="namespace",
+            description="Namespace for v3",
+            prompt="Select a namespace",
+            options=["dns", "url", "oid", "x500"],
+        ),
+        StrInput(
+            name="name",
+            description="Name string",
+            prompt="Enter the name to namespace-hash",
+        ),
+    ],
+    group=uuid_v3_group,
+    alias="generate",
+)
+def generate_uuid_v3(ctx: AnyContext) -> str:
+    import uuid
+
+    ns_map = {
+        "dns": uuid.NAMESPACE_DNS,
+        "url": uuid.NAMESPACE_URL,
+        "oid": uuid.NAMESPACE_OID,
+        "x500": uuid.NAMESPACE_X500,
+    }
+    namespace = ns_map[ctx.input.namespace]
+    result = str(uuid.uuid3(namespace, ctx.input.name))
+    ctx.print(result)
+    return result
+
+
+@make_task(
+    name="generate-uuid-v4",
+    description="🔨 Generate UUID v4 (random)",
+    group=uuid_v4_group,
+    alias="generate",
+)
+def generate_uuid_v4(ctx: AnyContext) -> str:
+    import uuid
+
+    result = str(uuid.uuid4())
+    ctx.print(result)
+    return result
+
+
+uuid_group.add_task(generate_uuid_v4, alias="generate")
+
+
+@make_task(
+    name="generate-uuid-v5",
+    description="🔨 Generate UUID v5 (SHA1 namespace-based)",
+    input=[
+        OptionInput(
+            name="namespace",
+            description="Namespace for v5",
+            prompt="Select a namespace",
+            options=["dns", "url", "oid", "x500"],
+        ),
+        StrInput(
+            name="name",
+            description="Name string",
+            prompt="Enter the name to namespace-hash",
+        ),
+    ],
+    group=uuid_v5_group,
+    alias="generate",
+)
+def generate_uuid_v5(ctx: AnyContext) -> str:
+    import uuid
+
+    ns_map = {
+        "dns": uuid.NAMESPACE_DNS,
+        "url": uuid.NAMESPACE_URL,
+        "oid": uuid.NAMESPACE_OID,
+        "x500": uuid.NAMESPACE_X500,
+    }
+    namespace = ns_map[ctx.input.namespace]
+    result = str(uuid.uuid5(namespace, ctx.input.name))
+    ctx.print(result)
+    return result
+
+
+@make_task(
+    name="validate-uuid",
+    description="✅ Validate UUID",
+    input=StrInput(name="id"),
+    group=uuid_group,
+    alias="validate",
+)
+def validate_uuid(ctx: AnyContext) -> bool:
+    import uuid
+
+    try:
+        uuid.UUID(ctx.input.id, version=1)
+        ctx.print("Valid UUID")
+        return True
+    except Exception:
+        ctx.print("Invalid UUID")
+        return False
+
+
+@make_task(
+    name="validate-uuid-v1",
+    description="✅ Validate UUID V1",
+    input=StrInput(name="id"),
+    group=uuid_v1_group,
+    alias="validate",
+)
+def validate_uuid_v1(ctx: AnyContext) -> bool:
+    import uuid
+
+    try:
+        uuid.UUID(ctx.input.id, version=1)
+        ctx.print("Valid UUID V1")
+        return True
+    except Exception:
+        ctx.print("Invalid UUID V1")
+        return False
+
+
+@make_task(
+    name="validate-uuid-v3",
+    description="✅ Validate UUID V3",
+    input=StrInput(name="id"),
+    group=uuid_v3_group,
+    alias="validate",
+)
+def validate_uuid_v3(ctx: AnyContext) -> bool:
+    import uuid
+
+    try:
+        uuid.UUID(ctx.input.id, version=3)
+        ctx.print("Valid UUID V3")
+        return True
+    except Exception:
+        ctx.print("Invalid UUID V3")
+        return False
+
+
+@make_task(
+    name="validate-uuid-v4",
+    description="✅ Validate UUID V4",
+    input=StrInput(name="id"),
+    group=uuid_v4_group,
+    alias="validate",
+)
+def validate_uuid_v4(ctx: AnyContext) -> bool:
+    import uuid
+
+    try:
+        uuid.UUID(ctx.input.id, version=4)
+        ctx.print("Valid UUID V4")
+        return True
+    except Exception:
+        ctx.print("Invalid UUID V4")
+        return False
+
+
+@make_task(
+    name="validate-uuid-v5",
+    description="✅ Validate UUID V5",
+    input=StrInput(name="id"),
+    group=uuid_v5_group,
+    alias="validate",
+)
+def validate_uuid_v5(ctx: AnyContext) -> bool:
+    import uuid
+
+    try:
+        uuid.UUID(ctx.input.id, version=5)
+        ctx.print("Valid UUID V5")
+        return True
+    except Exception:
+        ctx.print("Invalid UUID V5")
+        return False

zrb-1.5.16/src/zrb/callback/any_callback.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from zrb.session.any_session import AnySession
+
+
+class AnyCallback(ABC):
+    @abstractmethod
+    async def async_run(self, session: AnySession) -> Any:
+        pass

{zrb-1.5.14 → zrb-1.5.16}/src/zrb/runner/cli.py

@@ -4,6 +4,7 @@ from typing import Any
 from zrb.config import BANNER, VERSION, WEB_HTTP_PORT
 from zrb.context.any_context import AnyContext
 from zrb.context.shared_context import SharedContext
+from zrb.group.any_group import AnyGroup
 from zrb.group.group import Group
 from zrb.runner.common_util import get_run_kwargs
 from zrb.runner.web_app import create_web_app
@@ -25,7 +26,7 @@ class Cli(Group):
     def run(self, args: list[str] = []):
         kwargs, args = self._extract_kwargs_from_args(args)
         node, node_path, args = extract_node_from_args(self, args)
-        if isinstance(node, Group):
+        if isinstance(node, AnyGroup):
             self._show_group_info(node)
             return
         if "h" in kwargs or "help" in kwargs:
@@ -88,7 +89,7 @@ class Cli(Group):
                 print(f"  --{task_input_name}: {task_input.description}")
             print()
 
-    def _show_group_info(self, group: Group):
+    def _show_group_info(self, group: AnyGroup):
         if group.banner != "":
             print(group.banner)
             print()