zrb 1.8.10__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/task/llm/context_enrichment.py

@@ -1,199 +0,0 @@
-import json
-import traceback
-from typing import TYPE_CHECKING, Any
-
-from pydantic import BaseModel
-
-from zrb.attr.type import BoolAttr, IntAttr
-from zrb.context.any_context import AnyContext
-from zrb.llm_config import llm_config
-from zrb.llm_rate_limitter import LLMRateLimiter
-from zrb.task.llm.agent import run_agent_iteration
-from zrb.task.llm.history import (
-    count_part_in_history_list,
-    replace_system_prompt_in_history_list,
-)
-from zrb.task.llm.typing import ListOfDict
-from zrb.util.attr import get_bool_attr, get_int_attr
-from zrb.util.cli.style import stylize_faint
-
-if TYPE_CHECKING:
-    from pydantic_ai.models import Model
-    from pydantic_ai.settings import ModelSettings
-else:
-    Model = Any
-    ModelSettings = Any
-
-
-class EnrichmentConfig(BaseModel):
-    model_config = {"arbitrary_types_allowed": True}
-    model: Model | str | None = None
-    settings: ModelSettings | None = None
-    prompt: str
-    retries: int = 3
-
-
-class EnrichmentResult(BaseModel):
-    response: dict[str, Any]  # or further decompose as needed
-
-
-async def enrich_context(
-    ctx: AnyContext,
-    config: EnrichmentConfig,
-    conversation_context: dict[str, Any],
-    history_list: ListOfDict,
-    rate_limitter: LLMRateLimiter | None = None,
-) -> dict[str, Any]:
-    """Runs an LLM call to extract key info and merge it into the context."""
-    from pydantic_ai import Agent
-
-    ctx.log_info("Attempting to enrich conversation context...")
-    # Prepare context and history for the enrichment prompt
-    history_summary = conversation_context.get("history_summary")
-    try:
-        context_json = json.dumps(conversation_context)
-        history_json = json.dumps(history_list)
-        # The user prompt will now contain the dynamic data
-        user_prompt_data = "\n".join(
-            [
-                "Extract context from the following conversation info.",
-                "Extract only contexts that will be relevant across multiple conversations, like",  # noqa
-                "- user name",
-                "- user hobby",
-                "- user's long life goal",
-                "- standard/SOP",
-                "- etc.",
-                "Always maintain the relevant context and remove the irrelevant ones.",
-                "Restructure the context in a helpful way",
-                "Keep the context small",
-                f"Existing Context: {context_json}",
-                f"Conversation History: {history_json}",
-            ]
-        )
-    except Exception as e:
-        ctx.log_warning(f"Error formatting context/history for enrichment: {e}")
-        return conversation_context  # Return original context if formatting fails
-
-    enrichment_agent = Agent(
-        model=config.model,
-        system_prompt=config.prompt,  # Use the main prompt as system prompt
-        model_settings=config.settings,
-        retries=config.retries,
-        output_type=EnrichmentResult,
-    )
-
-    try:
-        ctx.print(stylize_faint("[Context Enrichment Triggered]"), plain=True)
-        enrichment_run = await run_agent_iteration(
-            ctx=ctx,
-            agent=enrichment_agent,
-            user_prompt=user_prompt_data,  # Pass the formatted data as user prompt
-            history_list=[],  # Enrichment agent doesn't need prior history itself
-            rate_limitter=rate_limitter,
-        )
-        if enrichment_run and enrichment_run.result.output:
-            response = enrichment_run.result.output.response
-            usage = enrichment_run.result.usage()
-            ctx.print(stylize_faint(f"[Token Usage] {usage}"), plain=True)
-            if response:
-                conversation_context = response
-                # Re inject history summary
-                conversation_context["history_summary"] = history_summary
-                ctx.log_info("Context enriched based on history.")
-                ctx.log_info(
-                    f"Updated conversation context: {json.dumps(conversation_context)}"
-                )
-        else:
-            ctx.log_warning("Context enrichment returned no data")
-    except Exception as e:
-        ctx.log_warning(f"Error during context enrichment LLM call: {e}")
-        traceback.print_exc()
-    return conversation_context
-
-
-def get_context_enrichment_threshold(
-    ctx: AnyContext,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
-) -> int:
-    """Gets the context enrichment threshold, handling defaults and errors."""
-    try:
-        return get_int_attr(
-            ctx,
-            context_enrichment_threshold_attr,
-            # Use llm_config default if attribute is None
-            llm_config.default_context_enrichment_threshold,
-            auto_render=render_context_enrichment_threshold,
-        )
-    except ValueError as e:
-        ctx.log_warning(
-            f"Could not convert context_enrichment_threshold to int: {e}. "
-            "Defaulting to -1 (no threshold)."
-        )
-        return -1
-
-
-def should_enrich_context(
-    ctx: AnyContext,
-    history_list: ListOfDict,
-    should_enrich_context_attr: BoolAttr | None,  # Allow None
-    render_enrich_context: bool,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
-) -> bool:
-    """
-    Determines if context enrichment should occur based on history, threshold, and config.
-    """
-    history_part_count = count_part_in_history_list(history_list)
-    if history_part_count == 0:
-        return False
-    enrichment_threshold = get_context_enrichment_threshold(
-        ctx,
-        context_enrichment_threshold_attr,
-        render_context_enrichment_threshold,
-    )
-    if enrichment_threshold == -1 or enrichment_threshold > history_part_count:
-        return False
-    return get_bool_attr(
-        ctx,
-        should_enrich_context_attr,
-        llm_config.default_enrich_context,
-        auto_render=render_enrich_context,
-    )
-
-
-async def maybe_enrich_context(
-    ctx: AnyContext,
-    history_list: ListOfDict,
-    conversation_context: dict[str, Any],
-    should_enrich_context_attr: BoolAttr | None,
-    render_enrich_context: bool,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
-    model: str | Model | None,
-    model_settings: ModelSettings | None,
-    context_enrichment_prompt: str,
-    rate_limitter: LLMRateLimiter | None = None,
-) -> dict[str, Any]:
-    """Enriches context based on history if enabled and threshold met."""
-    shorten_history_list = replace_system_prompt_in_history_list(history_list)
-    if should_enrich_context(
-        ctx,
-        shorten_history_list,
-        should_enrich_context_attr,
-        render_enrich_context,
-        context_enrichment_threshold_attr,
-        render_context_enrichment_threshold,
-    ):
-        return await enrich_context(
-            ctx=ctx,
-            config=EnrichmentConfig(
-                model=model,
-                settings=model_settings,
-                prompt=context_enrichment_prompt,
-            ),
-            conversation_context=conversation_context,
-            history_list=shorten_history_list,
-            rate_limitter=rate_limitter,
-        )
-    return conversation_context

zrb/task/llm/history.py

@@ -1,211 +0,0 @@
-import json
-import os
-from collections.abc import Callable
-from copy import deepcopy
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-from zrb.attr.type import StrAttr
-from zrb.context.any_context import AnyContext
-from zrb.context.any_shared_context import AnySharedContext
-from zrb.task.llm.typing import ListOfDict
-from zrb.util.attr import get_str_attr
-from zrb.util.file import read_file, write_file
-from zrb.util.run import run_async
-
-
-# Define the new ConversationHistoryData model
-class ConversationHistoryData(BaseModel):
-    context: dict[str, Any] = {}
-    history: ListOfDict = []
-
-    @classmethod
-    async def read_from_sources(
-        cls,
-        ctx: AnyContext,
-        reader: Callable[[AnyContext], dict[str, Any] | list | None] | None,
-        file_path: str | None,
-    ) -> Optional["ConversationHistoryData"]:
-        """Reads conversation history from various sources with priority."""
-        # Priority 1: Reader function
-        if reader:
-            try:
-                raw_data = await run_async(reader(ctx))
-                if raw_data:
-                    instance = cls.parse_and_validate(ctx, raw_data, "reader")
-                    if instance:
-                        return instance
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error executing conversation history reader: {e}. Ignoring."
-                )
-        # Priority 2: History file
-        if file_path and os.path.isfile(file_path):
-            try:
-                content = read_file(file_path)
-                raw_data = json.loads(content)
-                instance = cls.parse_and_validate(ctx, raw_data, f"file '{file_path}'")
-                if instance:
-                    return instance
-            except json.JSONDecodeError:
-                ctx.log_warning(
-                    f"Could not decode JSON from history file '{file_path}'. "
-                    "Ignoring file content."
-                )
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error reading history file '{file_path}': {e}. "
-                    "Ignoring file content."
-                )
-        # If neither reader nor file provided valid data
-        return None
-
-    @classmethod
-    def parse_and_validate(
-        cls, ctx: AnyContext, data: Any, source: str
-    ) -> Optional["ConversationHistoryData"]:
-        """Parses raw data into ConversationHistoryData, handling validation & old formats."""
-        try:
-            if isinstance(data, cls):
-                return data  # Already a valid instance
-            if isinstance(data, dict) and "history" in data:
-                # Standard format {'context': ..., 'history': ...}
-                # Ensure context exists, even if empty
-                data.setdefault("context", {})
-                return cls.model_validate(data)
-            elif isinstance(data, list):
-                # Handle old format (just a list) - wrap it
-                ctx.log_warning(
-                    f"History from {source} contains old list format. "
-                    "Wrapping it into the new structure {'context': {}, 'history': [...]}. "
-                    "Consider updating the source format."
-                )
-                return cls(history=data, context={})
-            else:
-                ctx.log_warning(
-                    f"History data from {source} has unexpected format "
-                    f"(type: {type(data)}). Ignoring."
-                )
-                return None
-        except Exception as e:  # Catch validation errors too
-            ctx.log_warning(
-                f"Error validating/parsing history data from {source}: {e}. Ignoring."
-            )
-            return None
-
-
-def get_history_file(
-    ctx: AnyContext,
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-) -> str:
-    """Gets the path to the conversation history file, rendering if configured."""
-    return get_str_attr(
-        ctx,
-        conversation_history_file_attr,
-        "",
-        auto_render=render_history_file,
-    )
-
-
-async def read_conversation_history(
-    ctx: AnyContext,
-    conversation_history_reader: (
-        Callable[[AnySharedContext], ConversationHistoryData | dict | list | None]
-        | None
-    ),
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-    conversation_history_attr: (
-        ConversationHistoryData
-        | Callable[[AnySharedContext], ConversationHistoryData | dict | list]
-        | dict
-        | list
-    ),
-) -> ConversationHistoryData:
-    """Reads conversation history from reader, file, or attribute, with validation."""
-    history_file = get_history_file(
-        ctx, conversation_history_file_attr, render_history_file
-    )
-    # Use the class method defined above
-    history_data = await ConversationHistoryData.read_from_sources(
-        ctx=ctx,
-        reader=conversation_history_reader,
-        file_path=history_file,
-    )
-    if history_data:
-        return history_data
-    # Priority 3: Callable or direct conversation_history attribute
-    raw_data_attr: Any = None
-    if callable(conversation_history_attr):
-        try:
-            raw_data_attr = await run_async(conversation_history_attr(ctx))
-        except Exception as e:
-            ctx.log_warning(
-                f"Error executing callable conversation_history attribute: {e}. "
-                "Ignoring."
-            )
-    if raw_data_attr is None:
-        raw_data_attr = conversation_history_attr
-    if raw_data_attr:
-        # Use the class method defined above
-        history_data = ConversationHistoryData.parse_and_validate(
-            ctx, raw_data_attr, "attribute"
-        )
-        if history_data:
-            return history_data
-    # Fallback: Return default value
-    return ConversationHistoryData()
-
-
-async def write_conversation_history(
-    ctx: AnyContext,
-    history_data: ConversationHistoryData,
-    conversation_history_writer: (
-        Callable[[AnySharedContext, ConversationHistoryData], None] | None
-    ),
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-):
-    """Writes conversation history using the writer or to a file."""
-    if conversation_history_writer is not None:
-        await run_async(conversation_history_writer(ctx, history_data))
-    history_file = get_history_file(
-        ctx, conversation_history_file_attr, render_history_file
-    )
-    if history_file != "":
-        write_file(history_file, history_data.model_dump_json(indent=2))
-
-
-def replace_system_prompt_in_history_list(
-    history_list: ListOfDict, replacement: str = "<main LLM system prompt>"
-) -> ListOfDict:
-    """
-    Returns a new history list where any part with part_kind 'system-prompt'
-    has its 'content' replaced with the given replacement string.
-    Args:
-        history: List of history items (each item is a dict with a 'parts' list).
-        replacement: The string to use in place of system-prompt content.
-
-    Returns:
-        A deep-copied list of history items with system-prompt content replaced.
-    """
-    new_history = deepcopy(history_list)
-    for item in new_history:
-        parts = item.get("parts", [])
-        for part in parts:
-            if part.get("part_kind") == "system-prompt":
-                part["content"] = replacement
-    return new_history
-
-
-def count_part_in_history_list(history_list: ListOfDict) -> int:
-    """Calculates the total number of 'parts' in a history list."""
-    history_part_len = 0
-    for history in history_list:
-        if "parts" in history:
-            history_part_len += len(history["parts"])
-        else:
-            history_part_len += 1
-    return history_part_len

zrb-1.8.10.dist-info/METADATA

@@ -1,264 +0,0 @@
-Metadata-Version: 2.1
-Name: zrb
-Version: 1.8.10
-Summary: Your Automation Powerhouse
-Home-page: https://github.com/state-alchemists/zrb
-License: AGPL-3.0-or-later
-Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
-Author: Go Frendi Gunawan
-Author-email: gofrendiasgard@gmail.com
-Requires-Python: >=3.10.0,<4.0.0
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: all
-Provides-Extra: playwright
-Provides-Extra: rag
-Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
-Requires-Dist: black (>=25.1.0,<25.2.0)
-Requires-Dist: chromadb (>=0.6.3,<0.7.0) ; extra == "rag" or extra == "all"
-Requires-Dist: fastapi[standard] (>=0.115.14,<0.116.0)
-Requires-Dist: isort (>=6.0.1,<6.1.0)
-Requires-Dist: libcst (>=1.7.0,<2.0.0)
-Requires-Dist: openai (>=1.86.0,<2.0.0) ; extra == "rag" or extra == "all"
-Requires-Dist: pdfplumber (>=0.11.6,<0.12.0) ; extra == "rag" or extra == "all"
-Requires-Dist: playwright (>=1.53.0,<2.0.0) ; extra == "playwright" or extra == "all"
-Requires-Dist: psutil (>=7.0.0,<8.0.0)
-Requires-Dist: pydantic-ai (>=0.3.4,<0.4.0)
-Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
-Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
-Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
-Requires-Dist: requests (>=2.32.4,<3.0.0)
-Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
-Requires-Dist: ulid-py (>=1.1.0,<2.0.0)
-Project-URL: Documentation, https://github.com/state-alchemists/zrb
-Project-URL: Repository, https://github.com/state-alchemists/zrb
-Description-Content-Type: text/markdown
-
-![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb/android-chrome-192x192.png)
-
-[Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md)
-
-# 🤖 Zrb: Your Automation Powerhouse
-
-
-**Unlock the full potential of automation in your projects!**
-
-Zrb streamlines repetitive tasks, integrates with powerful LLMs, and lets you create custom automation workflows effortlessly. Whether you’re building CI/CD pipelines, code generators, or unique automation scripts, Zrb is designed to simplify and supercharge your workflow.
-
-
-## 🚀 Why Zrb?
-
-- **Easy Automation with Python:** Write your tasks in Python and let Zrb handle the rest.
-- **Seamless Integration:** Utilize built-in support for LLM tasks, command execution, and more.
-- **Custom Workflows:** Chain tasks, set dependencies, and build robust automation pipelines.
-- **Developer-Friendly:** Quick to install and get started, with clear documentation and examples.
-- **Web Interface:** Run Zrb as a server to make tasks accessible even to non-technical team members.
-
-
-## 🔥 Key Features
-
-- **LLM Integration:** Leverage state-of-the-art language models to generate code, diagrams, and documentation.
-- **Task Chaining:** Easily define dependencies between tasks to create complex workflows.
-- **CLI & Server Mode:** Run tasks directly from the command line or through a user-friendly web UI.
-- **Flexible Input Handling:** Defaults, prompts, and command-line parameters to suit any workflow.
-- **Extensible & Open Source:** Contribute, customize, or extend Zrb to fit your unique needs.
-
-
-# 🛠️ Installation
-
-Install Zrb via pip:
-
-```bash
-pip install zrb
-# pip install --pre zrb
-```
-
-Or run our installation script to set up Zrb along with all prerequisites:
-
-```bash
-bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
-```
-
-You can also [run Zrb as container](https://github.com/state-alchemists/zrb?tab=readme-ov-file#-run-zrb-as-a-container)
-
-# 🍲 Quick Start: Build Your First Automation Workflow
-
-Zrb empowers you to create custom automation tasks using Python. This guide shows you how to define two simple tasks: one to generate a Mermaid script from your source code and another to convert that script into a PNG image.
-
-## 1. Create Your Task Definition File
-
-Place a file named `zrb_init.py` in a directory that's accessible from your projects. Zrb will automatically search for this file by starting in your current directory and then moving upward (i.e., checking parent directories) until it finds one. This means if you place your `zrb_init.py` in your home directory (e.g., `/home/<your-user-name>/zrb_init.py`), the tasks defined there will be available for any project.
-
-Add the following content to your zrb_init.py:
-
-```python
-from zrb import cli, LLMTask, CmdTask, StrInput, Group
-from zrb.builtin.llm.tool.code import analyze_repo
-from zrb.builtin.llm.tool.file import write_to_file
-
-
-# Create a group for Mermaid-related tasks
-mermaid_group = cli.add_group(Group(name="mermaid", description="🧜 Mermaid diagram related tasks"))
-
-# Task 1: Generate a Mermaid script from your source code
-make_mermaid_script = mermaid_group.add_task(
-    LLMTask(
-        name="make-script",
-        description="Creating mermaid diagram based on source code in current directory",
-        input=[
-            StrInput(name="dir", default="./"),
-            StrInput(name="diagram", default="state-diagram"),
-        ],
-        message=(
-            "Read all necessary files in {ctx.input.dir}, "
-            "make a {ctx.input.diagram} in mermaid format. "
-            "Write the script into `{ctx.input.dir}/{ctx.input.diagram}.mmd`"
-        ),
-        tools=[
-            analyze_repo, write_to_file
-        ],
-    )
-)
-
-# Task 2: Convert the Mermaid script into a PNG image
-make_mermaid_image = mermaid_group.add_task(
-    CmdTask(
-        name="make-image",
-        description="Creating png based on source code in current directory",
-        input=[
-            StrInput(name="dir", default="./"),
-            StrInput(name="diagram", default="state-diagram"),
-        ],
-        cmd="mmdc -i '{ctx.input.diagram}.mmd' -o '{ctx.input.diagram}.png'",
-        cwd="{ctx.input.dir}",
-    )
-)
-
-# Set up the dependency: the image task runs after the script is created
-make_mermaid_script >> make_mermaid_image
-```
-
-**What This Does**
-
-- **Task 1 – make-script**:
-
-    Uses an LLM to read all files in your current directory and generate a Mermaid script (e.g., `state diagram.mmd`).
-
-- **Task 2 – make-image**:
-
-    Executes a command that converts the Mermaid script into a PNG image (e.g., `state diagram.png`). This task will run only after the script has been generated.
-
-
-## 2. Run Your Tasks
-
-After setting up your tasks, you can execute them from any project. For example:
-
-- Clone/Create a Project:
-
-    ```bash
-    git clone git@github.com:jjinux/gotetris.git
-    cd gotetris
-    ```
-
-- Create a state diagram:
-
-    ```bash
-    zrb mermaid make-image --diagram "state diagram" --dir ./
-    ```
-
-- Or use the interactive mode:
-
-    ```bash
-    zrb mermaid make-image
-    ```
-
-    Zrb will prompt:
-
-    ```bash
-    dir [./]:
-    diagram [state diagram]:
-    ```
-
-    Press **Enter** to use the default value
-
-![State Diagram](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/state-diagram.png)
-
-
-## 3. Try Out the Web UI
-
-You can also serve your tasks through a user-friendly web interface:
-
-```bash
-zrb server start
-```
-
-Then open your browser and visit `http://localhost:21213`
-
-![Zrb Web UI](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb-web-ui.png)
-
-
-# 🐋 Run Zrb as a Container
-
-Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
-
-- **Standard Version**: Ideal for general use cases where Docker CLI access is not required.
-- **Dind (Docker in Docker) Version**: Includes built-in Docker commands, perfect for scenarios where you need to access the host's Docker CLI.
-
-### Standard Version
-
-The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
-
-```bash
-# Replace <host-path> and <container-path> with your desired paths
-docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
-```
-
-### Dind Version
-
-The Dind version is tailored for advanced use cases where Docker commands need to be executed within the container. This version allows the container to interact with the host's Docker daemon. To run the Dind version, use the command below:
-
-```bash
-# Replace <host-path> and <container-path> with your desired paths
-docker run \
-    -v ${HOME}:/zrb-home \
-    -v /var/run/docker.sock:/var/run/docker.sock \
-    -it --rm stalchmst/zrb:1.8.1-dind docker ps
-```
-
-> **Note:** The Dind (Docker in Docker) version of the container is larger in size compared to the standard version due to the inclusion of Docker CLI tools. Consider this when choosing the appropriate version for your needs.
-
-# 🎥 Demo & Documentation
-
-- **Full documentation:** [Zrb Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md)
-- **Video demo:**
-
-    [![Video Title](https://img.youtube.com/vi/W7dgk96l__o/0.jpg)](https://www.youtube.com/watch?v=W7dgk96l__o)
-
-
-# 🤝 Join the Community
-
-- **Bug Reports & Feature Requests:** Create an [issue](https://github.com/state-alchemists/zrb/issues) on Zrb's GitHub Repositories and include:
-    - Your Zrb version (i.e., `zrb version`).
-    - Steps you’ve taken and what you expected versus what happened
-- **Contributions:** We welcome pull requests! Check out our [contribution guidelines](https://github.com/state-alchemists/zrb/pulls).
-
-
-# ☕ Support The Project
-
-If you find Zrb valuable, please consider donating:
-
-[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com)
-
-# 🎉 Fun Fact
-
-Did you know?
-
-Zrb is named after `Zaruba`, a powerful support tool from the Garo universe!
-
-> Madou Ring Zaruba (魔導輪ザルバ, Madōrin Zaruba) is a Madougu which supports bearers of the Garo Armor. [(Garo Wiki | Fandom)](https://garo.fandom.com/wiki/Zaruba)
-
-![Madou Ring Zaruba on Kouga's Hand](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/madou-ring-zaruba.jpg)
-