zrb 1.0.0a3__py3-none-any.whl → 1.0.0a4__py3-none-any.whl

zrb/builtin/todo.py

@@ -1,5 +1,7 @@
 import datetime
+import json
 import os
+from typing import Any
 
 from zrb.builtin.group import todo_group
 from zrb.config import TODO_DIR
@@ -7,19 +9,16 @@ 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.cli.style import (
-    stylize_bold_green,
-    stylize_cyan,
-    stylize_magenta,
-    stylize_yellow,
-)
-from zrb.util.string.name import get_random_name
 from zrb.util.todo import (
-    TodoTask,
-    parse_todo_line,
-    read_todo_from_file,
+    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,
-    write_todo_to_file,
 )
 
 
@@ -54,14 +53,14 @@ from zrb.util.todo import (
 )
 def todo_add(ctx: AnyContext):
     todo_file_path = os.path.join(TODO_DIR, "todo.txt")
-    todo_tasks: list[TodoTask] = []
+    todo_list: list[TodoTaskModel] = []
     if os.path.isfile(todo_file_path):
-        todo_tasks = read_todo_from_file(todo_file_path)
+        todo_list = load_todo_list(todo_file_path)
     else:
         os.makedirs(TODO_DIR, exist_ok=True)
-    todo_tasks.append(
-        _complete_todo_task(
-            TodoTask(
+    todo_list.append(
+        cascade_todo_task(
+            TodoTaskModel(
                 priority=ctx.input.priority.upper(),
                 description=ctx.input.description,
                 contexts=[
@@ -77,13 +76,111 @@ def todo_add(ctx: AnyContext):
             )
         )
     )
-    write_todo_to_file(todo_file_path, todo_tasks)
-    return _get_visual_todo_list()
+    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):
-    return _get_visual_todo_list()
+    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(
@@ -96,86 +193,22 @@ def todo_list(ctx: AnyContext):
             default_str=lambda _: _get_todo_txt_content(),
         ),
     ],
-    description="✏️ Edit todo",
+    description="📝 Edit todo",
     group=todo_group,
     alias="edit",
 )
 def todo_edit(ctx: AnyContext):
-    todo_tasks = [
-        _complete_todo_task(parse_todo_line(line))
+    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_tasks)
+    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)
-    return _get_visual_todo_list()
-
-
-def _complete_todo_task(todo_task: TodoTask):
-    if todo_task.creation_date is None:
-        todo_task.creation_date = datetime.date.today()
-    if "id" not in todo_task.keyval:
-        todo_task.keyval["id"] = get_random_name()
-    return todo_task
-
-
-def _get_visual_todo_list() -> str:
-    todo_file_path = os.path.join(TODO_DIR, "todo.txt")
-    if not os.path.isfile(todo_file_path):
-        return "\n".join(["", "  Todo.txt not found... 🌵🦖", ""])
-    todo_tasks = read_todo_from_file(todo_file_path)
-    if len(todo_tasks) == 0:
-        return "\n".join(["", "  Empty todo list... 🌵🦖", ""])
-    max_desc_name_length = max(len(todo_task.description) for todo_task in todo_tasks)
-    if max_desc_name_length < len("DESCRIPTION"):
-        max_desc_name_length = len("DESCRIPTION")
-    # Headers
-    results = [
-        stylize_bold_green(
-            "  ".join(
-                [
-                    "".ljust(3),  # priority
-                    "".ljust(3),  # completed
-                    "COMPLETED AT".rjust(14),  # completed date
-                    "CREATED AT".rjust(14),  # completed date
-                    "DESCRIPTION".ljust(max_desc_name_length),
-                    "PROJECT/CONTEXT/OTHERS",
-                ]
-            )
-        )
-    ]
-    for todo_task in todo_tasks:
-        completed = "[x]" if todo_task.completed else "[ ]"
-        priority = "   " if todo_task.priority is None else f"({todo_task.priority})"
-        completion_date = stylize_yellow(_date_to_str(todo_task.completion_date))
-        creation_date = stylize_cyan(_date_to_str(todo_task.creation_date))
-        description = todo_task.description.ljust(max_desc_name_length)
-        additions = ", ".join(
-            [stylize_yellow(f"+{project}") for project in todo_task.projects]
-            + [stylize_cyan(f"@{context}") for context in todo_task.contexts]
-            + [stylize_magenta(f"{key}:{val}") for key, val in todo_task.keyval.items()]
-        )
-        results.append(
-            "  ".join(
-                [
-                    completed,
-                    priority,
-                    completion_date,
-                    creation_date,
-                    description,
-                    additions,
-                ]
-            )
-        )
-    return "\n".join(results)
-
-
-def _date_to_str(date: datetime.date | None) -> str:
-    if date is None:
-        return "".ljust(14)
-    return date.strftime("%a %Y-%m-%d")
+    todo_list = load_todo_list(todo_file_path)
+    return get_visual_todo_list(todo_list)
 
 
 def _get_todo_txt_content() -> str:

zrb/config.py

@@ -46,9 +46,8 @@ INIT_SCRIPTS = (
     else []
 )
 LOGGING_LEVEL = _get_log_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
-SHOULD_LOAD_BUILTIN = to_boolean(os.getenv("ZRB_SHOULD_LOAD_BUILTIN", "1"))
+LOAD_BUILTIN = to_boolean(os.getenv("ZRB_LOAD_BUILTIN", "1"))
 ENV_PREFIX = os.getenv("ZRB_ENV", "")
-SHOW_ADVERTISEMENT = to_boolean(os.getenv("ZRB_SHOW_ADVERTISEMENT", "1"))
 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"))
@@ -58,6 +57,17 @@ 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

zrb/runner/cli.py

@@ -5,7 +5,7 @@ from zrb.config import BANNER, WEB_HTTP_PORT
 from zrb.context.any_context import AnyContext
 from zrb.context.shared_context import SharedContext
 from zrb.group.group import Group
-from zrb.runner.web_server import create_app, run_web_server
+from zrb.runner.web_app import create_app
 from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
 from zrb.task.make_task import make_task
@@ -57,7 +57,7 @@ class Cli(Group):
         return " ".join(parts)
 
     def _get_run_command_param(self, key: str, val: str) -> str:
-        if '"' in val or "'" in val or " " in val:
+        if '"' in val or "'" in val or " " in val or val == "":
             return f"--{key} {double_quote(val)}"
         return f"--{key} {val}"
 
@@ -71,10 +71,7 @@ class Cli(Group):
                     shared_ctx, run_kwargs[task_input.name]
                 )
                 continue
-        try:
-            return task.run(Session(shared_ctx=shared_ctx, root_group=self))
-        except KeyboardInterrupt:
-            pass
+        return task.run(Session(shared_ctx=shared_ctx, root_group=self))
 
     def _get_run_kwargs(
         self, task: AnyTask, args: list[str], kwargs: dict[str, str]
@@ -182,5 +179,9 @@ server_group = cli.add_group(
     alias="start",
 )
 async def run(_: AnyContext):
+    from uvicorn import Config, Server
+
     app = create_app(cli, WEB_HTTP_PORT)
-    await run_web_server(app, WEB_HTTP_PORT)
+    config = Config(app=app, host="0.0.0.0", port=WEB_HTTP_PORT, loop="asyncio")
+    server = Server(config)
+    await server.serve()

zrb/runner/{web_server.py → web_app.py}

@@ -1,21 +1,15 @@
 import asyncio
 import os
 import sys
-from contextlib import asynccontextmanager
 from datetime import datetime, timedelta
 from typing import Any, Dict, List
 
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.staticfiles import StaticFiles
-from uvicorn import Config, Server
-
 from zrb.config import BANNER, WEB_HTTP_PORT
 from zrb.context.shared_context import SharedContext
 from zrb.group.any_group import AnyGroup
-from zrb.runner.web_app.group_info_ui.controller import handle_group_info_ui
-from zrb.runner.web_app.home_page.controller import handle_home_page
-from zrb.runner.web_app.task_ui.controller import handle_task_ui
+from zrb.runner.web_controller.group_info_ui.controller import handle_group_info_ui
+from zrb.runner.web_controller.home_page.controller import handle_home_page
+from zrb.runner.web_controller.task_ui.controller import handle_task_ui
 from zrb.runner.web_util import NewSessionResponse
 from zrb.session.session import Session
 from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
@@ -27,6 +21,12 @@ from zrb.util.group import extract_node_from_args, get_node_path
 
 
 def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
+    from contextlib import asynccontextmanager
+
+    from fastapi import FastAPI, HTTPException, Request
+    from fastapi.responses import FileResponse, HTMLResponse
+    from fastapi.staticfiles import StaticFiles
+
     _STATIC_DIR = os.path.join(os.path.dirname(__file__), "web_app", "static")
     _COROS = []
 
@@ -144,7 +144,7 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
     return app
 
 
-async def run_web_server(app: FastAPI, port: int = WEB_HTTP_PORT):
-    config = Config(app=app, host="0.0.0.0", port=port, loop="asyncio")
-    server = Server(config)
-    await server.serve()
+# async def run_web_server(app: FastAPI, port: int = WEB_HTTP_PORT):
+#     config = Config(app=app, host="0.0.0.0", port=port, loop="asyncio")
+#     server = Server(config)
+#     await server.serve()

zrb/runner/{web_app → web_controller}/group_info_ui/controller.py

@@ -1,7 +1,5 @@
 import os
 
-from fastapi.responses import HTMLResponse
-
 from zrb.group.any_group import AnyGroup
 from zrb.util.group import get_non_empty_subgroups, get_subtasks
 from zrb.util.string.format import fstring_format
@@ -25,6 +23,8 @@ with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
 
 
 def handle_group_info_ui(root_group: AnyGroup, group: AnyGroup, url: str):
+    from fastapi.responses import HTMLResponse
+
     url_parts = url.split("/")
     parent_url_parts = url_parts[:-2] + [""]
     parent_url = "/".join(parent_url_parts)

zrb/runner/{web_app → web_controller}/home_page/controller.py

@@ -1,7 +1,5 @@
 import os
 
-from fastapi.responses import HTMLResponse
-
 from zrb.group.any_group import AnyGroup
 from zrb.util.group import get_non_empty_subgroups, get_subtasks
 from zrb.util.string.format import fstring_format
@@ -25,6 +23,8 @@ with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
 
 
 def handle_home_page(root_group: AnyGroup):
+    from fastapi.responses import HTMLResponse
+
     subgroups = get_non_empty_subgroups(root_group, web_only=True)
     group_info = (
         ""

zrb/runner/{web_app → web_controller}/task_ui/controller.py

@@ -1,7 +1,5 @@
 import os
 
-from fastapi.responses import HTMLResponse
-
 from zrb.group.any_group import AnyGroup
 from zrb.session.any_session import AnySession
 from zrb.task.any_task import AnyTask
@@ -31,6 +29,8 @@ with open(os.path.join(_DIR, "partial", "common-util.js")) as f:
 def handle_task_ui(
     root_group: AnyGroup, task: AnyTask, session: AnySession, url: str, args: list[str]
 ):
+    from fastapi.responses import HTMLResponse
+
     session.register_task(task)
     ctx = task.get_ctx(session)
     url_parts = url.split("/")

zrb/task/cmd_task.py

@@ -26,22 +26,22 @@ class CmdTask(BaseTask):
         input: list[AnyInput | None] | AnyInput | None = None,
         env: list[AnyEnv | None] | AnyEnv | None = None,
         shell: StrAttr | None = None,
-        auto_render_shell: bool = True,
+        render_shell: bool = True,
         shell_flag: StrAttr | None = None,
-        auto_render_shell_flag: bool = True,
+        render_shell_flag: bool = True,
         remote_host: StrAttr | None = None,
-        auto_render_remote_host: bool = True,
+        render_remote_host: bool = True,
         remote_port: IntAttr | None = None,
         remote_user: StrAttr | None = None,
-        auto_render_remote_user: bool = True,
+        render_remote_user: bool = True,
         remote_password: StrAttr | None = None,
-        auto_render_remote_password: bool = True,
+        render_remote_password: bool = True,
         remote_ssh_key: StrAttr | None = None,
-        auto_render_remote_ssh_key: bool = True,
+        render_remote_ssh_key: bool = True,
         cmd: CmdVal = "",
-        auto_render_cmd: bool = True,
+        render_cmd: bool = True,
         cwd: str | None = None,
-        auto_render_cwd: bool = True,
+        render_cwd: bool = True,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         execute_condition: BoolAttr = True,
@@ -77,22 +77,22 @@ class CmdTask(BaseTask):
             fallback=fallback,
         )
         self._shell = shell
-        self._auto_render_shell = auto_render_shell
+        self._render_shell = render_shell
         self._shell_flag = shell_flag
-        self._auto_render_shell_flag = auto_render_shell_flag
+        self._render_shell_flag = render_shell_flag
         self._remote_host = remote_host
-        self._auto_render_remote_host = auto_render_remote_host
+        self._render_remote_host = render_remote_host
         self._remote_port = remote_port
         self._remote_user = remote_user
-        self._auto_render_remote_user = auto_render_remote_user
+        self._render_remote_user = render_remote_user
         self._remote_password = remote_password
-        self._auto_render_remote_password = auto_render_remote_password
+        self._render_remote_password = render_remote_password
         self._remote_ssh_key = remote_ssh_key
-        self._auto_render_remote_ssh_key = auto_render_remote_ssh_key
+        self._render_remote_ssh_key = render_remote_ssh_key
         self._cmd = cmd
-        self._auto_render_cmd = auto_render_cmd
+        self._render_cmd = render_cmd
         self._cwd = cwd
-        self._auto_render_cwd = auto_render_cwd
+        self._render_cwd = render_cwd
         self._max_output_line = max_output_line
         self._max_error_line = max_error_line
 
@@ -171,7 +171,7 @@ class CmdTask(BaseTask):
 
     def _get_shell(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._shell, DEFAULT_SHELL, auto_render=self._auto_render_shell
+            ctx, self._shell, DEFAULT_SHELL, auto_render=self._render_shell
         )
 
     def _get_shell_flag(self, ctx: AnyContext) -> str:
@@ -186,12 +186,12 @@ class CmdTask(BaseTask):
             ctx,
             self._shell_flag,
             default_shell_flag,
-            auto_render=self._auto_render_shell_flag,
+            auto_render=self._render_shell_flag,
         )
 
     def _get_remote_host(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_host, "", auto_render=self._auto_render_remote_host
+            ctx, self._remote_host, "", auto_render=self._render_remote_host
         )
 
     def _get_remote_port(self, ctx: AnyContext) -> int:
@@ -199,7 +199,7 @@ class CmdTask(BaseTask):
 
     def _get_remote_user(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_user, "", auto_render=self._auto_render_remote_user
+            ctx, self._remote_user, "", auto_render=self._render_remote_user
         )
 
     def _get_remote_password(self, ctx: AnyContext) -> str:
@@ -207,18 +207,16 @@ class CmdTask(BaseTask):
             ctx,
             self._remote_password,
             "",
-            auto_render=self._auto_render_remote_password,
+            auto_render=self._render_remote_password,
         )
 
     def _get_remote_ssh_key(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_ssh_key, "", auto_render=self._auto_render_remote_ssh_key
+            ctx, self._remote_ssh_key, "", auto_render=self._render_remote_ssh_key
         )
 
     def _get_cwd(self, ctx: AnyContext) -> str:
-        cwd = get_str_attr(
-            ctx, self._cwd, os.getcwd(), auto_render=self._auto_render_cwd
-        )
+        cwd = get_str_attr(ctx, self._cwd, os.getcwd(), auto_render=self._render_cwd)
         if cwd is None:
             cwd = os.getcwd()
         return os.path.abspath(cwd)
@@ -258,7 +256,7 @@ class CmdTask(BaseTask):
         if callable(single_cmd_val):
             return single_cmd_val(ctx)
         if isinstance(single_cmd_val, str):
-            if self._auto_render_cmd:
+            if self._render_cmd:
                 return ctx.render(single_cmd_val)
             return single_cmd_val
         if isinstance(single_cmd_val, AnyCmdVal):

zrb/task/http_check.py

@@ -1,8 +1,6 @@
 import asyncio
 from collections.abc import Callable
 
-import requests
-
 from zrb.attr.type import StrAttr
 from zrb.context.any_context import AnyContext
 from zrb.context.context import Context
@@ -24,7 +22,7 @@ class HttpCheck(BaseTask):
         input: list[AnyInput] | AnyInput | None = None,
         env: list[AnyEnv] | AnyEnv | None = None,
         url: StrAttr = "http://localhost",
-        auto_render_url: bool = True,
+        render_url: bool = True,
         http_method: StrAttr = "GET",
         interval: int = 5,
         execute_condition: bool | str | Callable[[Context], bool] = True,
@@ -45,19 +43,21 @@ class HttpCheck(BaseTask):
             fallback=fallback,
         )
         self._url = url
-        self._auto_render_url = auto_render_url
+        self._render_url = render_url
         self._http_method = http_method
         self._interval = interval
 
     def _get_url(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._url, "http://localhost", auto_render=self._auto_render_url
+            ctx, self._url, "http://localhost", auto_render=self._render_url
         )
 
     def _get_http_method(self, ctx: AnyContext) -> str:
         return get_str_attr(ctx, self._http_method, "GET", auto_render=True).upper()
 
     async def _exec_action(self, ctx: AnyContext) -> bool:
+        import requests
+
         url = self._get_url(ctx)
         http_method = self._get_http_method(ctx)
         while True: