zrb 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_util.py

@@ -17,8 +17,8 @@ from zrb.util.string.conversion import (
 
 
 def is_gateway_navigation_config_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(
-        APP_DIR, "module", "gateway", "config", "navigation.py"
+    return file_path == os.path.abspath(
+        os.path.join(APP_DIR, "module", "gateway", "config", "navigation.py")
     )
 
 
@@ -76,106 +76,126 @@ def get_existing_auth_migration_xcom_key(ctx: AnyContext) -> str:
 
 def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
-        os.path.join(APP_DIR, "schema", to_snake_case(ctx.input.entity))
+        os.path.abspath(
+            os.path.join(APP_DIR, "schema", to_snake_case(ctx.input.entity))
+        )
     )
 
 
 def is_in_module_entity_test_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
-        os.path.join(
-            APP_DIR,
-            "test",
-            to_snake_case(ctx.input.module),
-            to_snake_case(ctx.input.entity),
+        os.path.abspath(
+            os.path.join(
+                APP_DIR,
+                "test",
+                to_snake_case(ctx.input.module),
+                to_snake_case(ctx.input.entity),
+            )
         )
     )
 
 
 def is_in_module_entity_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
-        os.path.join(
-            APP_DIR,
-            "module",
-            to_snake_case(ctx.input.module),
-            "service",
-            to_snake_case(ctx.input.entity),
+        os.path.abspath(
+            os.path.join(
+                APP_DIR,
+                "module",
+                to_snake_case(ctx.input.module),
+                "service",
+                to_snake_case(ctx.input.entity),
+            )
         )
     )
 
 
 def is_module_route_file(ctx: AnyContext, file_path: str) -> bool:
-    module_route_file = os.path.join(
-        APP_DIR,
-        "module",
-        to_snake_case(ctx.input.module),
-        "route.py",
+    module_route_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "route.py",
+        )
     )
     return file_path == module_route_file
 
 
 def is_module_migration_metadata_file(ctx: AnyContext, file_path: str) -> bool:
-    module_migration_metadata_file = os.path.join(
-        APP_DIR,
-        "module",
-        to_snake_case(ctx.input.module),
-        "migration_metadata.py",
+    module_migration_metadata_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "migration_metadata.py",
+        )
     )
     return file_path == module_migration_metadata_file
 
 
 def is_module_client_file(ctx: AnyContext, file_path: str) -> bool:
-    module_any_client_file = os.path.join(
-        APP_DIR,
-        "module",
-        to_snake_case(ctx.input.module),
-        "client",
-        f"{to_snake_case(ctx.input.module)}_client.py",
+    module_any_client_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "client",
+            f"{to_snake_case(ctx.input.module)}_client.py",
+        )
     )
     return file_path == module_any_client_file
 
 
 def is_module_api_client_file(ctx: AnyContext, file_path: str) -> bool:
-    module_api_client_file = os.path.join(
-        APP_DIR,
-        "module",
-        to_snake_case(ctx.input.module),
-        "client",
-        f"{to_snake_case(ctx.input.module)}_api_client.py",
+    module_api_client_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "client",
+            f"{to_snake_case(ctx.input.module)}_api_client.py",
+        )
     )
     return file_path == module_api_client_file
 
 
 def is_module_direct_client_file(ctx: AnyContext, file_path: str) -> bool:
-    module_direct_client_file = os.path.join(
-        APP_DIR,
-        "module",
-        to_snake_case(ctx.input.module),
-        "client",
-        f"{to_snake_case(ctx.input.module)}_direct_client.py",
+    module_direct_client_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "client",
+            f"{to_snake_case(ctx.input.module)}_direct_client.py",
+        )
     )
     return file_path == module_direct_client_file
 
 
 def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
-    module_gateway_subroute_file = os.path.join(
-        APP_DIR,
-        "module",
-        "gateway",
-        "subroute",
-        f"{to_snake_case(ctx.input.module)}.py",
+    module_gateway_subroute_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            "gateway",
+            "subroute",
+            f"{to_snake_case(ctx.input.module)}.py",
+        )
     )
     return file_path == module_gateway_subroute_file
 
 
 def is_module_gateway_subroute_view_file(ctx: AnyContext, file_path: str) -> bool:
-    module_gateway_subroute_file = os.path.join(
-        APP_DIR,
-        "module",
-        "gateway",
-        "view",
-        "content",
-        f"{to_kebab_case(ctx.input.module)}",
-        f"{to_kebab_case(ctx.input.entity)}.html",
+    module_gateway_subroute_file = os.path.abspath(
+        os.path.join(
+            APP_DIR,
+            "module",
+            "gateway",
+            "view",
+            "content",
+            f"{to_kebab_case(ctx.input.module)}",
+            f"{to_kebab_case(ctx.input.entity)}.html",
+        )
     )
     return file_path == module_gateway_subroute_file
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/add_module_util.py

@@ -16,41 +16,47 @@ from zrb.util.string.conversion import (
 
 
 def is_app_config_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(APP_DIR, "config.py")
+    return file_path == os.path.abspath(os.path.join(APP_DIR, "config.py"))
 
 
 def is_app_main_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(APP_DIR, "main.py")
+    return file_path == os.path.abspath(os.path.join(APP_DIR, "main.py"))
 
 
 def is_gateway_route_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(APP_DIR, "module", "gateway", "route.py")
+    return file_path == os.path.abspath(
+        os.path.join(APP_DIR, "module", "gateway", "route.py")
+    )
 
 
 def is_gateway_navigation_config_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(
-        APP_DIR, "module", "gateway", "config", "navigation.py"
+    return file_path == os.path.abspath(
+        os.path.join(APP_DIR, "module", "gateway", "config", "navigation.py")
     )
 
 
 def is_app_zrb_task_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(APP_DIR, "_zrb", "task.py")
+    return file_path == os.path.abspath(os.path.join(APP_DIR, "_zrb", "task.py"))
 
 
 def is_app_zrb_config_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(APP_DIR, "_zrb", "config.py")
+    return file_path == os.path.abspath(os.path.join(APP_DIR, "_zrb", "config.py"))
 
 
 def is_in_module_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
-        os.path.join(APP_DIR, "module", to_snake_case(ctx.input.module))
+        os.path.abspath(
+            os.path.join(APP_DIR, "module", to_snake_case(ctx.input.module))
+        )
     )
 
 
 def is_gateway_module_subroute_file(ctx: AnyContext, file_path: str) -> bool:
     module_subroute_file_name = f"{to_snake_case(ctx.input.module)}.py"
-    return file_path == os.path.join(
-        APP_DIR, "module", "gateway", "subroute", module_subroute_file_name
+    return file_path == os.path.abspath(
+        os.path.join(
+            APP_DIR, "module", "gateway", "subroute", module_subroute_file_name
+        )
     )
 
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/logger_factory.py

@@ -7,4 +7,4 @@ logging.basicConfig(
 )
 
 # Create a logger for your application
-logger: logging.Logger = logging.getLogger("fastapp")
+logger: logging.Logger = logging.getLogger("my-app-name")

zrb/builtin/project/add/fastapp/fastapp_util.py

@@ -7,12 +7,16 @@ from zrb.util.string.conversion import double_quote, to_snake_case
 
 def is_in_project_app_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
-        os.path.join(ctx.input.project_dir, to_snake_case(ctx.input.app))
+        os.path.abspath(
+            os.path.join(ctx.input.project_dir, to_snake_case(ctx.input.app))
+        )
     )
 
 
 def is_project_zrb_init_file(ctx: AnyContext, file_path: str) -> bool:
-    return file_path == os.path.join(ctx.input.project_dir, "zrb_init.py")
+    return file_path == os.path.abspath(
+        os.path.join(ctx.input.project_dir, "zrb_init.py")
+    )
 
 
 def update_project_zrb_init_file(ctx: AnyContext, zrb_init_path: str):

zrb/config.py

@@ -92,7 +92,8 @@ LLM_HISTORY_DIR = os.getenv(
 LLM_HISTORY_FILE = os.getenv(
     "ZRB_LLM_HISTORY_FILE", os.path.join(LLM_HISTORY_DIR, "history.json")
 )
-LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_FILE", "1"))
+LLM_ALLOW_ACCESS_LOCAL_FILE = to_boolean(os.getenv("ZRB_LLM_ACCESS_LOCAL_FILE", "1"))
+LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_SHELL", "1"))
 LLM_ALLOW_ACCESS_INTERNET = to_boolean(os.getenv("ZRB_LLM_ACCESS_INTERNET", "1"))
 # noqa See: https://qdrant.github.io/fastembed/examples/Supported_Models/#supported-text-embedding-models
 RAG_EMBEDDING_MODEL = os.getenv(
@@ -101,6 +102,7 @@ RAG_EMBEDDING_MODEL = os.getenv(
 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"))
+SERP_API_KEY = os.getenv("SERP_API_KEY", "")
 
 
 BANNER = f"""

zrb/content_transformer/content_transformer.py

@@ -1,4 +1,5 @@
 import fnmatch
+import os
 import re
 from collections.abc import Callable
 
@@ -40,7 +41,12 @@ class ContentTransformer(AnyContentTransformer):
                     return True
             except re.error:
                 pass
-            return fnmatch.fnmatch(file_path, pattern)
+            if os.sep not in pattern and (
+                os.altsep is None or os.altsep not in pattern
+            ):
+                # Pattern like "*.txt" – match only the basename.
+                return fnmatch.fnmatch(file_path, os.path.basename(file_path))
+            return fnmatch.fnmatch(file_path, file_path)
 
     def transform_file(self, ctx: AnyContext, file_path: str):
         if callable(self._transform_file):

zrb/context/context.py

@@ -88,7 +88,7 @@ class Context(AnyContext):
             return template
         return int(self.render(template))
 
-    def render_float(self, template: str) -> float:
+    def render_float(self, template: str | float) -> float:
         if isinstance(template, float):
             return template
         return float(self.render(template))
@@ -102,9 +102,10 @@ class Context(AnyContext):
         flush: bool = True,
         plain: bool = False,
     ):
+        sep = " " if sep is None else sep
         message = sep.join([f"{value}" for value in values])
         if plain:
-            self.append_to_shared_log(remove_style(message))
+            # self.append_to_shared_log(remove_style(message))
             print(message, sep=sep, end=end, file=file, flush=flush)
             return
         color = self._color
@@ -132,6 +133,7 @@ class Context(AnyContext):
         flush: bool = True,
     ):
         if self._shared_ctx.get_logging_level() <= logging.DEBUG:
+            sep = " " if sep is None else sep
             message = sep.join([f"{value}" for value in values])
             stylized_message = stylize_log(f"[DEBUG] {message}")
             self.print(stylized_message, sep=sep, end=end, file=file, flush=flush)
@@ -145,6 +147,7 @@ class Context(AnyContext):
         flush: bool = True,
     ):
         if self._shared_ctx.get_logging_level() <= logging.INFO:
+            sep = " " if sep is None else sep
             message = sep.join([f"{value}" for value in values])
             stylized_message = stylize_log(f"[INFO] {message}")
             self.print(stylized_message, sep=sep, end=end, file=file, flush=flush)
@@ -158,6 +161,7 @@ class Context(AnyContext):
         flush: bool = True,
     ):
         if self._shared_ctx.get_logging_level() <= logging.INFO:
+            sep = " " if sep is None else sep
             message = sep.join([f"{value}" for value in values])
             stylized_message = stylize_warning(f"[WARNING] {message}")
             self.print(stylized_message, sep=sep, end=end, file=file, flush=flush)
@@ -171,6 +175,7 @@ class Context(AnyContext):
         flush: bool = True,
     ):
         if self._shared_ctx.get_logging_level() <= logging.ERROR:
+            sep = " " if sep is None else sep
             message = sep.join([f"{value}" for value in values])
             stylized_message = stylize_error(f"[ERROR] {message}")
             self.print(stylized_message, sep=sep, end=end, file=file, flush=flush)
@@ -184,6 +189,7 @@ class Context(AnyContext):
         flush: bool = True,
     ):
         if self._shared_ctx.get_logging_level() <= logging.CRITICAL:
+            sep = " " if sep is None else sep
             message = sep.join([f"{value}" for value in values])
             stylized_message = stylize_error(f"[CRITICAL] {message}")
             self.print(stylized_message, sep=sep, end=end, file=file, flush=flush)

zrb/input/text_input.py

@@ -69,16 +69,17 @@ class TextInput(BaseInput):
         )
 
     def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
-        prompt_message = (
-            f"{self.comment_start}{super().prompt_message}{self.comment_end}"
+        prompt_message = super().prompt_message
+        comment_prompt_message = (
+            f"{self.comment_start}{prompt_message}{self.comment_end}"
         )
-        prompt_message_eol = f"{prompt_message}\n"
+        comment_prompt_message_eol = f"{comment_prompt_message}\n"
         default_value = self.get_default_str(shared_ctx)
         with tempfile.NamedTemporaryFile(
             delete=False, suffix=self._extension
         ) as temp_file:
             temp_file_name = temp_file.name
-            temp_file.write(prompt_message_eol.encode())
+            temp_file.write(comment_prompt_message_eol.encode())
             # Pre-fill with default content
             if default_value:
                 temp_file.write(default_value.encode())
@@ -87,7 +88,10 @@ class TextInput(BaseInput):
         subprocess.call([self._editor, temp_file_name])
         # Read the edited content
         edited_content = read_file(temp_file_name)
-        parts = [text.strip() for text in edited_content.split(prompt_message, 1)]
+        parts = [
+            text.strip() for text in edited_content.split(comment_prompt_message, 1)
+        ]
         edited_content = "\n".join(parts).lstrip()
         os.remove(temp_file_name)
+        print(f"{prompt_message}: {edited_content}")
         return edited_content

zrb/task/llm_task.py

@@ -4,10 +4,20 @@ from collections.abc import Callable
 from typing import Any
 
 from pydantic_ai import Agent, Tool
-from pydantic_ai.messages import ModelMessagesTypeAdapter
+from pydantic_ai.messages import (
+    FinalResultEvent,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
+    ModelMessagesTypeAdapter,
+    PartDeltaEvent,
+    PartStartEvent,
+    TextPartDelta,
+    ToolCallPartDelta,
+)
+from pydantic_ai.models import Model
 from pydantic_ai.settings import ModelSettings
 
-from zrb.attr.type import StrAttr
+from zrb.attr.type import StrAttr, fstring
 from zrb.config import LLM_MODEL, LLM_SYSTEM_PROMPT
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
@@ -15,7 +25,7 @@ from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
-from zrb.util.attr import get_str_attr
+from zrb.util.attr import get_attr, get_str_attr
 from zrb.util.cli.style import stylize_faint
 from zrb.util.file import read_file, write_file
 from zrb.util.run import run_async
@@ -34,7 +44,9 @@ class LLMTask(BaseTask):
         cli_only: bool = False,
         input: list[AnyInput | None] | AnyInput | None = None,
         env: list[AnyEnv | None] | AnyEnv | None = None,
-        model: StrAttr | None = LLM_MODEL,
+        model: (
+            Callable[[AnySharedContext], Model | str | fstring] | Model | None
+        ) = LLM_MODEL,
         model_settings: (
             ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
         ) = None,
@@ -93,7 +105,7 @@ class LLMTask(BaseTask):
             successor=successor,
         )
         self._model = model
-        self._model_settings = (model_settings,)
+        self._model_settings = model_settings
         self._agent = agent
         self._render_model = render_model
         self._system_prompt = system_prompt
@@ -108,6 +120,9 @@ class LLMTask(BaseTask):
         self._render_history_file = render_history_file
         self._max_call_iteration = max_call_iteration
 
+    def set_model(self, model: Model | str):
+        self._model = model
+
     def add_tool(self, tool: ToolOrCallable):
         self._additional_tools.append(tool)
 
@@ -115,15 +130,85 @@ class LLMTask(BaseTask):
         history = await self._read_conversation_history(ctx)
         user_prompt = self._get_message(ctx)
         agent = self._get_agent(ctx)
-        result = await agent.run(
+        async with agent.iter(
             user_prompt=user_prompt,
             message_history=ModelMessagesTypeAdapter.validate_python(history),
-        )
-        new_history = json.loads(result.all_messages_json())
-        for history in new_history:
-            ctx.print(stylize_faint(json.dumps(history)))
+        ) as agent_run:
+            async for node in agent_run:
+                # Each node represents a step in the agent's execution
+                await self._print_node(ctx, agent_run, node)
+        new_history = json.loads(agent_run.result.all_messages_json())
         await self._write_conversation_history(ctx, new_history)
-        return result.data
+        return agent_run.result.data
+
+    async def _print_node(self, ctx: AnyContext, agent_run: Any, node: Any):
+        if Agent.is_user_prompt_node(node):
+            # A user prompt node => The user has provided input
+            ctx.print(stylize_faint(f">> UserPromptNode: {node.user_prompt}"))
+        elif Agent.is_model_request_node(node):
+            # A model request node => We can stream tokens from the model"s request
+            ctx.print(
+                stylize_faint(">> ModelRequestNode: streaming partial request tokens")
+            )
+            async with node.stream(agent_run.ctx) as request_stream:
+                is_streaming = False
+                async for event in request_stream:
+                    if isinstance(event, PartStartEvent):
+                        if is_streaming:
+                            ctx.print("", plain=True)
+                        ctx.print(
+                            stylize_faint(
+                                f"[Request] Starting part {event.index}: {event.part!r}"
+                            ),
+                        )
+                        is_streaming = False
+                    elif isinstance(event, PartDeltaEvent):
+                        if isinstance(event.delta, TextPartDelta):
+                            ctx.print(
+                                stylize_faint(f"{event.delta.content_delta}"),
+                                end="",
+                                plain=is_streaming,
+                            )
+                        elif isinstance(event.delta, ToolCallPartDelta):
+                            ctx.print(
+                                stylize_faint(f"{event.delta.args_delta}"),
+                                end="",
+                                plain=is_streaming,
+                            )
+                        is_streaming = True
+                    elif isinstance(event, FinalResultEvent):
+                        if is_streaming:
+                            ctx.print("", plain=True)
+                        ctx.print(
+                            stylize_faint(f"[Result] tool_name={event.tool_name}"),
+                        )
+                        is_streaming = False
+                if is_streaming:
+                    ctx.print("", plain=True)
+        elif Agent.is_call_tools_node(node):
+            # A handle-response node => The model returned some data, potentially calls a tool
+            ctx.print(
+                stylize_faint(
+                    ">> CallToolsNode: streaming partial response & tool usage"
+                )
+            )
+            async with node.stream(agent_run.ctx) as handle_stream:
+                async for event in handle_stream:
+                    if isinstance(event, FunctionToolCallEvent):
+                        ctx.print(
+                            stylize_faint(
+                                f"[Tools] The LLM calls tool={event.part.tool_name!r} with args={event.part.args} (tool_call_id={event.part.tool_call_id!r})"  # noqa
+                            )
+                        )
+                    elif isinstance(event, FunctionToolResultEvent):
+                        ctx.print(
+                            stylize_faint(
+                                f"[Tools] Tool call {event.tool_call_id!r} returned => {event.result.content}"  # noqa
+                            )
+                        )
+        elif Agent.is_end_node(node):
+            # Once an End node is reached, the agent run is complete
+            ctx.print(stylize_faint(f"{agent_run.result.data}"))
 
     async def _write_conversation_history(
         self, ctx: AnyContext, conversations: list[Any]
@@ -135,11 +220,9 @@ class LLMTask(BaseTask):
             write_file(history_file, json.dumps(conversations, indent=2))
 
     def _get_model_settings(self, ctx: AnyContext) -> ModelSettings | None:
-        if isinstance(self._model_settings, ModelSettings):
-            return self._model_settings
         if callable(self._model_settings):
             return self._model_settings(ctx)
-        return None
+        return self._model_settings
 
     def _get_agent(self, ctx: AnyContext) -> Agent:
         if isinstance(self._agent, Agent):
@@ -158,12 +241,16 @@ class LLMTask(BaseTask):
             self._get_model(ctx),
             system_prompt=self._get_system_prompt(ctx),
             tools=tools,
+            model_settings=self._get_model_settings(ctx),
         )
 
-    def _get_model(self, ctx: AnyContext) -> str:
-        return get_str_attr(
+    def _get_model(self, ctx: AnyContext) -> str | Model | None:
+        model = get_attr(
             ctx, self._model, "ollama_chat/llama3.1", auto_render=self._render_model
         )
+        if isinstance(model, (Model, str)) or model is None:
+            return model
+        raise ValueError("Invalid model")
 
     def _get_system_prompt(self, ctx: AnyContext) -> str:
         return get_str_attr(

{zrb-1.2.0.dist-info → zrb-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.2.0
+Version: 1.2.2
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -24,7 +24,7 @@ Requires-Dist: isort (>=5.13.2,<5.14.0)
 Requires-Dist: libcst (>=1.5.0,<2.0.0)
 Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
 Requires-Dist: psutil (>=6.1.1,<7.0.0)
-Requires-Dist: pydantic-ai (>=0.0.19,<0.0.20)
+Requires-Dist: pydantic-ai (>=0.0.31,<0.0.32)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
@@ -79,8 +79,7 @@ pip install --pre zrb
 Alternatively, you can also use our installation script to install Zrb along with some prerequisites:
 
 ```bash
-bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/refs/heads/1.0.0/install.sh)"
-# bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
 ```
 
 # 🐞 Bug Report + Feature Request