grasp_agents 0.2.0__tar.gz → 0.2.1__tar.gz

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/LICENSE.md

@@ -8,6 +8,6 @@ Package production dependencies are licensed under the following terms:
 | dotenv    | 0.9.9   | BSD-3-Clause license                              | https://github.com/pedroburon/dotenv    |
 | httpx     | 0.28.1  | BSD License                                       | https://github.com/encode/httpx         |
 | openai    | 1.77.0  | Apache Software License                           | https://github.com/openai/openai-python |
-| tenacity  | 9.1.2   | Apache Software License                           | https://github.com/jd/tenacity          |
+| tenacity  | 8.5.0   | Apache Software License                           | https://github.com/jd/tenacity          |
 | termcolor | 2.5.0   | MIT License                                       | https://github.com/termcolor/termcolor  |
 | tqdm      | 4.67.1  | MIT License; Mozilla Public License 2.0 (MPL 2.0) | https://tqdm.github.io                  |

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.2.0
+Version: 0.2.1
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "grasp_agents"
-version = "0.2.0"
+version = "0.2.1"
 description = "Grasp Agents Library"
 readme = "README.md"
 requires-python = ">=3.11.4,<4"

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/cloud_llm.py

@@ -286,6 +286,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
                 validate_obj_from_json_or_py_string(
                     message.content,
                     adapter=self._response_format_pyd,
+                    from_substring=True,
                 )
 
     async def generate_completion_stream(

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/llm_agent.py

@@ -10,7 +10,7 @@ from .comm_agent import CommunicatingAgent
 from .llm import LLM, LLMSettings
 from .llm_agent_state import (
     LLMAgentState,
-    MakeCustomAgentState,
+    SetAgentState,
     SetAgentStateStrategy,
 )
 from .prompt_builder import (
@@ -25,7 +25,11 @@ from .run_context import (
     SystemRunArgs,
     UserRunArgs,
 )
-from .tool_orchestrator import ExitToolCallLoopHandler, ToolOrchestrator
+from .tool_orchestrator import (
+    ExitToolCallLoopHandler,
+    ManageAgentStateHandler,
+    ToolOrchestrator,
+)
 from .typing.content import ImageData
 from .typing.converters import Converters
 from .typing.io import (
@@ -43,9 +47,14 @@ from .typing.tool import BaseTool
 from .utils import get_prompt, validate_obj_from_json_or_py_string
 
 
-class ParseOutputHandler(Protocol[OutT, CtxT]):
+class ParseOutputHandler(Protocol[InT, OutT, CtxT]):
     def __call__(
-        self, *args: Any, ctx: RunContextWrapper[CtxT] | None, **kwargs: Any
+        self,
+        conversation: Conversation,
+        *,
+        rcv_args: InT | None,
+        batch_idx: int,
+        ctx: RunContextWrapper[CtxT] | None,
     ) -> OutT: ...
 
 
@@ -91,9 +100,15 @@ class LLMAgent(
         # Agent state
         self._state: LLMAgentState = LLMAgentState()
         self.set_state_strategy: SetAgentStateStrategy = set_state_strategy
-        self._make_custom_agent_state_impl: MakeCustomAgentState | None = None
+        self._set_agent_state_impl: SetAgentState | None = None
 
         # Tool orchestrator
+
+        self._using_default_llm_response_format: bool = False
+        if llm.response_format is None and tools is None:
+            llm.response_format = self.out_type
+            self._using_default_llm_response_format = True
+
         self._tool_orchestrator: ToolOrchestrator[CtxT] = ToolOrchestrator[CtxT](
             agent_id=self.agent_id,
             llm=llm,
@@ -152,16 +167,28 @@ class LLMAgent(
         conversation: Conversation,
         *,
         rcv_args: InT | None = None,
+        batch_idx: int = 0,
         ctx: RunContextWrapper[CtxT] | None = None,
-        **kwargs: Any,
     ) -> OutT:
         if self._parse_output_impl:
+            if self._using_default_llm_response_format:
+                # When using custom output parsing, the required LLM response format
+                # can differ from the final agent output type ->
+                # set it back to None unless it was specified explicitly at init.
+                self._tool_orchestrator.llm.response_format = None
+                self._using_default_llm_response_format = False
+
             return self._parse_output_impl(
-                conversation=conversation, rcv_args=rcv_args, ctx=ctx, **kwargs
+                conversation=conversation,
+                rcv_args=rcv_args,
+                batch_idx=batch_idx,
+                ctx=ctx,
             )
 
         return validate_obj_from_json_or_py_string(
-            str(conversation[-1].content), self._out_type_adapter
+            str(conversation[-1].content),
+            adapter=self._out_type_adapter,
+            from_substring=True,
         )
 
     @final
@@ -210,7 +237,7 @@ class LLMAgent(
             rcv_state=rcv_state,
             sys_prompt=formatted_sys_prompt,
             strategy=self.set_state_strategy,
-            make_custom_state_impl=self._make_custom_agent_state_impl,
+            set_agent_state_impl=self._set_agent_state_impl,
             ctx=ctx,
         )
 
@@ -234,7 +261,7 @@ class LLMAgent(
         else:
             # 4. Run tool call loop (new messages are added to the message
             #    history inside the loop)
-            await self._tool_orchestrator.run_loop(agent_state=state, ctx=ctx)
+            await self._tool_orchestrator.run_loop(state=state, ctx=ctx)
 
         # 5. Parse outputs
         batch_size = state.message_history.batch_size
@@ -324,15 +351,13 @@ class LLMAgent(
         return func
 
     def parse_output_handler(
-        self, func: ParseOutputHandler[OutT, CtxT]
-    ) -> ParseOutputHandler[OutT, CtxT]:
+        self, func: ParseOutputHandler[InT, OutT, CtxT]
+    ) -> ParseOutputHandler[InT, OutT, CtxT]:
         self._parse_output_impl = func
 
         return func
 
-    def make_custom_agent_state_handler(
-        self, func: MakeCustomAgentState
-    ) -> MakeCustomAgentState:
+    def set_agent_state_handler(self, func: SetAgentState) -> SetAgentState:
         self._make_custom_agent_state_impl = func
 
         return func
@@ -344,6 +369,13 @@ class LLMAgent(
 
         return func
 
+    def manage_agent_state_handler(
+        self, func: ManageAgentStateHandler[CtxT]
+    ) -> ManageAgentStateHandler[CtxT]:
+        self._tool_orchestrator.manage_agent_state_impl = func
+
+        return func
+
     # -- Override these methods in subclasses if needed --
 
     def _register_overridden_handlers(self) -> None:
@@ -356,15 +388,18 @@ class LLMAgent(
         if cur_cls._format_inp_args is not base_cls._format_inp_args:  # noqa: SLF001
             self._prompt_builder.format_inp_args_impl = self._format_inp_args
 
-        if cur_cls._make_custom_agent_state is not base_cls._make_custom_agent_state:  # noqa: SLF001
-            self._make_custom_agent_state_impl = self._make_custom_agent_state
+        if cur_cls._set_agent_state is not base_cls._set_agent_state:  # noqa: SLF001
+            self._set_agent_state_impl = self._set_agent_state
+
+        if cur_cls._manage_agent_state is not base_cls._manage_agent_state:  # noqa: SLF001
+            self._tool_orchestrator.manage_agent_state_impl = self._manage_agent_state
 
         if (
             cur_cls._tool_call_loop_exit is not base_cls._tool_call_loop_exit  # noqa: SLF001
         ):
             self._tool_orchestrator.exit_tool_call_loop_impl = self._tool_call_loop_exit
 
-        self._parse_output_impl: ParseOutputHandler[OutT, CtxT] | None = None
+        self._parse_output_impl: ParseOutputHandler[InT, OutT, CtxT] | None = None
 
     def _format_sys_args(
         self,
@@ -381,21 +416,24 @@ class LLMAgent(
         self,
         usr_args: LLMPromptArgs,
         rcv_args: InT,
+        *,
+        batch_idx: int = 0,
         ctx: RunContextWrapper[CtxT] | None = None,
     ) -> LLMFormattedArgs:
         raise NotImplementedError(
             "LLMAgent._format_inp_args must be overridden by a subclass"
         )
 
-    def _make_custom_agent_state(
+    def _set_agent_state(
         self,
-        cur_state: LLMAgentState | None,
+        cur_state: LLMAgentState,
+        *,
         rcv_state: AgentState | None,
         sys_prompt: LLMPrompt | None,
         ctx: RunContextWrapper[Any] | None,
     ) -> LLMAgentState:
         raise NotImplementedError(
-            "LLMAgent._make_custom_agent_state_handler must be overridden by a subclass"
+            "LLMAgent._set_agent_state_handler must be overridden by a subclass"
         )
 
     def _tool_call_loop_exit(
@@ -408,3 +446,14 @@ class LLMAgent(
         raise NotImplementedError(
             "LLMAgent._tool_call_loop_exit must be overridden by a subclass"
         )
+
+    def _manage_agent_state(
+        self,
+        state: LLMAgentState,
+        *,
+        ctx: RunContextWrapper[CtxT] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        raise NotImplementedError(
+            "LLMAgent._manage_agent_state must be overridden by a subclass"
+        )

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/llm_agent_state.py

@@ -10,10 +10,11 @@ from .typing.io import AgentState, LLMPrompt
 SetAgentStateStrategy = Literal["keep", "reset", "from_sender", "custom"]
 
 
-class MakeCustomAgentState(Protocol):
+class SetAgentState(Protocol):
     def __call__(
         self,
-        cur_state: Optional["LLMAgentState"],
+        cur_state: "LLMAgentState",
+        *,
         rcv_state: AgentState | None,
         sys_prompt: LLMPrompt | None,
         ctx: RunContextWrapper[Any] | None,
@@ -30,11 +31,12 @@ class LLMAgentState(AgentState):
     @classmethod
     def from_cur_and_rcv_states(
         cls,
-        cur_state: Optional["LLMAgentState"] = None,
+        cur_state: "LLMAgentState",
+        *,
         rcv_state: Optional["AgentState"] = None,
         sys_prompt: LLMPrompt | None = None,
         strategy: SetAgentStateStrategy = "from_sender",
-        make_custom_state_impl: MakeCustomAgentState | None = None,
+        set_agent_state_impl: SetAgentState | None = None,
         ctx: RunContextWrapper[Any] | None = None,
     ) -> "LLMAgentState":
         upd_mh = cur_state.message_history if cur_state else None
@@ -59,10 +61,10 @@ class LLMAgentState(AgentState):
                 upd_mh.reset(sys_prompt)
 
         elif strategy == "custom":
-            assert make_custom_state_impl is not None, (
-                "Custom message history handler implementation is not provided."
+            assert set_agent_state_impl is not None, (
+                "Agent state setter implementation is not provided."
             )
-            return make_custom_state_impl(
+            return set_agent_state_impl(
                 cur_state=cur_state,
                 rcv_state=rcv_state,
                 sys_prompt=sys_prompt,

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/prompt_builder.py

@@ -35,6 +35,8 @@ class FormatInputArgsHandler(Protocol[InT, CtxT]):
         self,
         usr_args: LLMPromptArgs,
         rcv_args: InT,
+        *,
+        batch_idx: int,
         ctx: RunContextWrapper[CtxT] | None,
     ) -> LLMFormattedArgs: ...
 
@@ -77,11 +79,13 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         self,
         usr_args: LLMPromptArgs,
         rcv_args: InT,
+        *,
+        batch_idx: int = 0,
         ctx: RunContextWrapper[CtxT] | None = None,
     ) -> LLMFormattedArgs:
         if self.format_inp_args_impl:
             return self.format_inp_args_impl(
-                usr_args=usr_args, rcv_args=rcv_args, ctx=ctx
+                usr_args=usr_args, rcv_args=rcv_args, batch_idx=batch_idx, ctx=ctx
             )
 
         if not isinstance(rcv_args, BaseModel) and rcv_args is not None:
@@ -100,6 +104,7 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
     def make_sys_prompt(
         self,
         sys_args: LLMPromptArgs,
+        *,
         ctx: RunContextWrapper[CtxT] | None,
     ) -> LLMPrompt | None:
         if self.sys_prompt is None:
@@ -151,9 +156,11 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         ]
 
         formatted_inp_args_batch = [
-            self._format_inp_args(usr_args=val_usr_args, rcv_args=val_rcv_args, ctx=ctx)
-            for val_usr_args, val_rcv_args in zip(
-                val_usr_args_batch_, val_rcv_args_batch_, strict=False
+            self._format_inp_args(
+                usr_args=val_usr_args, rcv_args=val_rcv_args, batch_idx=i, ctx=ctx
+            )
+            for i, (val_usr_args, val_rcv_args) in enumerate(
+                zip(val_usr_args_batch_, val_rcv_args_batch_, strict=False)
             )
         ]
 

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/tool_orchestrator.py

@@ -29,7 +29,7 @@ class ExitToolCallLoopHandler(Protocol[CtxT]):
 class ManageAgentStateHandler(Protocol[CtxT]):
     def __call__(
         self,
-        agent_state: LLMAgentState,
+        state: LLMAgentState,
         *,
         ctx: RunContextWrapper[CtxT] | None,
         **kwargs: Any,
@@ -93,13 +93,13 @@ class ToolOrchestrator(Generic[CtxT]):
 
     def _manage_agent_state(
         self,
-        agent_state: LLMAgentState,
+        state: LLMAgentState,
         *,
         ctx: RunContextWrapper[CtxT] | None = None,
         **kwargs: Any,
     ) -> None:
         if self.manage_agent_state_impl:
-            self.manage_agent_state_impl(agent_state=agent_state, ctx=ctx, **kwargs)
+            self.manage_agent_state_impl(state=state, ctx=ctx, **kwargs)
 
     async def generate_once(
         self,
@@ -119,10 +119,10 @@ class ToolOrchestrator(Generic[CtxT]):
 
     async def run_loop(
         self,
-        agent_state: LLMAgentState,
+        state: LLMAgentState,
         ctx: RunContextWrapper[CtxT] | None = None,
     ) -> None:
-        message_history = agent_state.message_history
+        message_history = state.message_history
         assert message_history.batch_size == 1, (
             "Batch size must be 1 for tool call loop"
         )
@@ -131,13 +131,13 @@ class ToolOrchestrator(Generic[CtxT]):
 
         tool_choice = "none" if self._react_mode else "auto"
         gen_message_batch = await self.generate_once(
-            agent_state, tool_choice=tool_choice, ctx=ctx
+            state, tool_choice=tool_choice, ctx=ctx
         )
 
         turns = 0
 
         while True:
-            self._manage_agent_state(agent_state=agent_state, ctx=ctx, num_turns=turns)
+            self._manage_agent_state(state=state, ctx=ctx, num_turns=turns)
 
             if self._exit_tool_call_loop(
                 message_history.batched_conversations[0], ctx=ctx, num_turns=turns
@@ -156,7 +156,7 @@ class ToolOrchestrator(Generic[CtxT]):
 
             tool_choice = "none" if (self._react_mode and msg.tool_calls) else "auto"
             gen_message_batch = await self.generate_once(
-                agent_state, tool_choice=tool_choice, ctx=ctx
+                state, tool_choice=tool_choice, ctx=ctx
             )
 
             turns += 1

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/typing/content.py

@@ -1,6 +1,6 @@
 import base64
 import re
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from enum import StrEnum
 from pathlib import Path
 from typing import Annotated, Any, Literal, TypeAlias
@@ -66,7 +66,7 @@ class Content(BaseModel):
     def from_formatted_prompt(
         cls,
         prompt_template: str,
-        prompt_args: dict[str, str | ImageData] | None = None,
+        prompt_args: Mapping[str, str | int | bool | ImageData] | None = None,
     ) -> "Content":
         prompt_args = prompt_args or {}
         image_args = {

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/typing/io.py

@@ -1,3 +1,4 @@
+from collections.abc import Mapping
 from typing import TypeAlias, TypeVar
 
 from pydantic import BaseModel
@@ -20,5 +21,5 @@ OutT = TypeVar("OutT", covariant=True)  # noqa: PLC0105
 StateT = TypeVar("StateT", bound=AgentState, covariant=True)  # noqa: PLC0105
 
 LLMPrompt: TypeAlias = str
-LLMFormattedSystemArgs: TypeAlias = dict[str, str]
-LLMFormattedArgs: TypeAlias = dict[str, str | ImageData]
+LLMFormattedSystemArgs: TypeAlias = Mapping[str, str | int | bool]
+LLMFormattedArgs: TypeAlias = Mapping[str, str | int | bool | ImageData]

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/typing/message.py

@@ -1,5 +1,5 @@
 import json
-from collections.abc import Hashable, Sequence
+from collections.abc import Hashable, Mapping, Sequence
 from enum import StrEnum
 from typing import Annotated, Any, Literal, TypeAlias
 from uuid import uuid4
@@ -79,7 +79,7 @@ class UserMessage(MessageBase):
     def from_formatted_prompt(
         cls,
         prompt_template: str,
-        prompt_args: dict[str, str | ImageData] | None = None,
+        prompt_args: Mapping[str, str | int | bool | ImageData] | None = None,
         model_id: str | None = None,
     ) -> "UserMessage":
         content = Content.from_formatted_prompt(

{grasp_agents-0.2.0 → grasp_agents-0.2.1}/src/grasp_agents/typing/tool.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import asyncio
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
 
 from pydantic import BaseModel, PrivateAttr, TypeAdapter
@@ -60,11 +58,6 @@ class BaseTool(
     ) -> _ToolOutT:
         pass
 
-    async def run_batch(
-        self, inp_batch: Sequence[_ToolInT], ctx: RunContextWrapper[CtxT] | None = None
-    ) -> Sequence[_ToolOutT]:
-        return await asyncio.gather(*[self.run(inp, ctx=ctx) for inp in inp_batch])
-
     async def __call__(
         self, ctx: RunContextWrapper[CtxT] | None = None, **kwargs: Any
     ) -> _ToolOutT:

grasp_agents-0.2.1/src/grasp_agents/utils.py

@@ -0,0 +1,194 @@
+import ast
+import asyncio
+import json
+import re
+from collections.abc import Coroutine, Mapping
+from datetime import datetime
+from logging import getLogger
+from pathlib import Path
+from typing import Any, TypeVar
+
+from pydantic import (
+    GetCoreSchemaHandler,
+    TypeAdapter,
+    ValidationError,
+)
+from pydantic_core import core_schema
+from tqdm.autonotebook import tqdm
+
+logger = getLogger(__name__)
+
+_JSON_START_RE = re.compile(r"[{\[]")
+
+T = TypeVar("T")
+
+
+def extract_json_substring(text: str) -> str | None:
+    decoder = json.JSONDecoder()
+    for match in _JSON_START_RE.finditer(text):
+        start = match.start()
+        try:
+            _, end = decoder.raw_decode(text, idx=start)
+            return text[start:end]
+        except ValueError:
+            continue
+
+    return None
+
+
+def parse_json_or_py_string(
+    s: str, return_none_on_failure: bool = False
+) -> dict[str, Any] | list[Any] | None:
+    s_fmt = re.sub(r"```[a-zA-Z0-9]*\n|```", "", s).strip()
+    try:
+        return ast.literal_eval(s_fmt)
+    except (ValueError, SyntaxError):
+        try:
+            return json.loads(s_fmt)
+        except json.JSONDecodeError as exc:
+            if return_none_on_failure:
+                return None
+            raise ValueError(
+                "Invalid JSON/Python string - Both ast.literal_eval and json.loads "
+                f"failed to parse the following response:\n{s}"
+            ) from exc
+
+
+def parse_json_or_py_substring(
+    json_str: str, return_none_on_failure: bool = False
+) -> dict[str, Any] | list[Any] | None:
+    return parse_json_or_py_string(
+        extract_json_substring(json_str) or "", return_none_on_failure
+    )
+
+
+def validate_obj_from_json_or_py_string(
+    s: str, adapter: TypeAdapter[T], from_substring: bool = False
+) -> T:
+    try:
+        if from_substring:
+            parsed = parse_json_or_py_substring(s, return_none_on_failure=True)
+        else:
+            parsed = parse_json_or_py_string(s, return_none_on_failure=True)
+        if parsed is None:
+            parsed = s
+        return adapter.validate_python(parsed)
+    except (json.JSONDecodeError, ValidationError) as exc:
+        raise ValueError(
+            f"Invalid JSON or Python string:\n{s}\nExpected type: {adapter._type}",  # type: ignore[arg-type]
+        ) from exc
+
+
+def extract_xml_list(text: str) -> list[str]:
+    pattern = re.compile(r"<(chunk_\d+)>(.*?)</\1>", re.DOTALL)
+
+    chunks: list[str] = []
+    for match in pattern.finditer(text):
+        content = match.group(2).strip()
+        chunks.append(content)
+    return chunks
+
+
+def build_marker_json_parser_type(
+    marker_to_model: Mapping[str, type],
+) -> type:
+    """
+    Return a Pydantic-compatible *type* that, when given a **str**, searches for
+    the first marker substring and validates the JSON that follows with the
+    corresponding Pydantic model.
+
+    If no marker is found, the raw string is returned unchanged.
+
+    Example:
+    -------
+    >>> Todo = build_marker_json_parser_type({'```json': MyModel})
+    >>> Todo.validate('```json {"a": 1}')
+    MyModel(a=1)
+
+    """
+
+    class MarkerParsedOutput:
+        """String → (Model | str) parser generated by build_marker_json_parser_type."""
+
+        @classmethod
+        def __get_pydantic_core_schema__(
+            cls,
+            _source_type: Any,
+            _handler: GetCoreSchemaHandler,
+        ) -> core_schema.CoreSchema:
+            def _validate(value: Any) -> Any:
+                if not isinstance(value, str):
+                    raise TypeError("MarkerParsedOutput expects a string")
+
+                for marker, model in marker_to_model.items():
+                    if marker in value:
+                        adapter = TypeAdapter[Any](model)
+                        return validate_obj_from_json_or_py_string(
+                            value, adapter=adapter, from_substring=True
+                        )
+
+                return value
+
+            return core_schema.no_info_after_validator_function(
+                _validate, core_schema.any_schema()
+            )
+
+        @classmethod
+        def __get_pydantic_json_schema__(
+            cls,
+            schema: core_schema.CoreSchema,
+            handler: GetCoreSchemaHandler,
+        ):
+            return handler(schema)
+
+    unique_suffix = "_".join(sorted(marker_to_model))[:40]
+    MarkerParsedOutput.__name__ = f"MarkerParsedOutput_{unique_suffix}"
+
+    return MarkerParsedOutput
+
+
+def read_txt(file_path: str | Path, encoding: str = "utf-8") -> str:
+    return Path(file_path).read_text(encoding=encoding)
+
+
+def read_contents_from_file(
+    file_path: str | Path,
+    binary_mode: bool = False,
+) -> str | bytes:
+    try:
+        if binary_mode:
+            return Path(file_path).read_bytes()
+        return Path(file_path).read_text()
+    except FileNotFoundError:
+        logger.error(f"File {file_path} not found.")
+        return ""
+
+
+def get_prompt(prompt_text: str | None, prompt_path: str | Path | None) -> str | None:
+    if prompt_text is None:
+        return read_contents_from_file(prompt_path) if prompt_path is not None else None  # type: ignore[arg-type]
+
+    return prompt_text
+
+
+async def asyncio_gather_with_pbar(
+    *corouts: Coroutine[Any, Any, Any],
+    no_tqdm: bool = False,
+    desc: str | None = None,
+) -> list[Any]:
+    pbar = tqdm(total=len(corouts), desc=desc, disable=no_tqdm)
+
+    async def run_and_update(coro: Coroutine[Any, Any, Any]) -> Any:
+        result = await coro
+        pbar.update(1)
+        return result
+
+    wrapped_tasks = [run_and_update(c) for c in corouts]
+    results = await asyncio.gather(*wrapped_tasks)
+    pbar.close()
+
+    return results
+
+
+def get_timestamp() -> str:
+    return datetime.now().strftime("%Y%m%d_%H%M%S")

grasp_agents-0.2.0/src/grasp_agents/utils.py

@@ -1,187 +0,0 @@
-import ast
-import asyncio
-import json
-import re
-from collections.abc import Coroutine
-from datetime import datetime
-from logging import getLogger
-from pathlib import Path
-from typing import Any, TypeVar
-
-from pydantic import (
-    BaseModel,
-    GetCoreSchemaHandler,
-    TypeAdapter,
-    ValidationError,
-)
-from pydantic_core import core_schema
-from tqdm.autonotebook import tqdm
-
-logger = getLogger(__name__)
-
-T = TypeVar("T")
-
-
-def filter_fields(data: dict[str, Any], model: type[BaseModel]) -> dict[str, Any]:
-    return {key: data[key] for key in model.model_fields if key in data}
-
-
-def read_txt(file_path: str) -> str:
-    return Path(file_path).read_text()
-
-
-def format_json_string(text: str) -> str:
-    decoder = json.JSONDecoder()
-    text = text.replace("\n", "")
-    length = len(text)
-    i = 0
-    while i < length:
-        ch = text[i]
-        if ch in "{[":
-            try:
-                _, end = decoder.raw_decode(text[i:])
-                return text[i : i + end]
-            except ValueError:
-                pass
-        i += 1
-
-    return text
-
-
-def parse_json_or_py_string(
-    json_str: str, return_none_on_failure: bool = False
-) -> dict[str, Any] | list[Any] | None:
-    try:
-        json_response = ast.literal_eval(json_str)
-    except (ValueError, SyntaxError):
-        try:
-            json_response = json.loads(json_str)
-        except json.JSONDecodeError as exc:
-            if return_none_on_failure:
-                return None
-            raise ValueError(
-                "Invalid JSON - Both ast.literal_eval and json.loads "
-                f"failed to parse the following response:\n{json_str}"
-            ) from exc
-
-    return json_response
-
-
-def extract_json(
-    json_str: str, return_none_on_failure: bool = False
-) -> dict[str, Any] | list[Any] | None:
-    return parse_json_or_py_string(format_json_string(json_str), return_none_on_failure)
-
-
-def validate_obj_from_json_or_py_string(s: str, adapter: TypeAdapter[T]) -> T:
-    s_fmt = re.sub(r"```[a-zA-Z0-9]*\n|```", "", s).strip()
-    try:
-        parsed = json.loads(s_fmt)
-        return adapter.validate_python(parsed)
-    except (json.JSONDecodeError, ValidationError):
-        try:
-            return adapter.validate_python(s_fmt)
-        except ValidationError as exc:
-            raise ValueError(
-                f"Invalid JSON or Python string:\n{s}\nExpected type: {adapter._type}",  # type: ignore[arg-type]
-            ) from exc
-
-
-def extract_xml_list(text: str) -> list[str]:
-    pattern = re.compile(r"<(chunk_\d+)>(.*?)</\1>", re.DOTALL)
-
-    chunks: list[str] = []
-    for match in pattern.finditer(text):
-        content = match.group(2).strip()
-        chunks.append(content)
-    return chunks
-
-
-def make_conditional_parsed_output_type(
-    response_format: type, marker: str = "<DONE>"
-) -> type:
-    class ParsedOutput:
-        """
-        * Accepts any **str**.
-        * If the string contains `marker`, it must contain a valid JSON for
-        `response_format` → we return that a response_format instance.
-        * Otherwise we leave the string untouched.
-        """
-
-        @classmethod
-        def __get_pydantic_core_schema__(
-            cls,
-            _source_type: Any,
-            _handler: GetCoreSchemaHandler,
-        ) -> core_schema.CoreSchema:
-            def validator(v: Any) -> Any:
-                if isinstance(v, str) and marker in v:
-                    v_json_str = format_json_string(v)
-                    response_format_adapter = TypeAdapter[Any](response_format)
-
-                    return response_format_adapter.validate_json(v_json_str)
-
-                return v
-
-            return core_schema.no_info_after_validator_function(
-                validator, core_schema.any_schema()
-            )
-
-        @classmethod
-        def __get_pydantic_json_schema__(
-            cls, core_schema: core_schema.CoreSchema, handler: GetCoreSchemaHandler
-        ):
-            return handler(core_schema)
-
-    return ParsedOutput
-
-
-def read_contents_from_file(
-    file_path: str | Path,
-    binary_mode: bool = False,
-) -> str | bytes:
-    """Reads and returns contents of file"""
-    try:
-        if binary_mode:
-            with open(file_path, "rb") as file:
-                return file.read()
-        else:
-            with open(file_path) as file:
-                return file.read()
-    except FileNotFoundError:
-        logger.error(f"File {file_path} not found.")
-        return ""
-
-
-def get_prompt(prompt_text: str | None, prompt_path: str | Path | None) -> str | None:
-    if prompt_text is None:
-        prompt = (
-            read_contents_from_file(prompt_path) if prompt_path is not None else None
-        )
-    else:
-        prompt = prompt_text
-
-    return prompt  # type: ignore[assignment]
-
-
-async def asyncio_gather_with_pbar(
-    *corouts: Coroutine[Any, Any, Any],
-    no_tqdm: bool = False,
-    desc: str | None = None,
-) -> list[Any]:
-    pbar = tqdm(total=len(corouts), desc=desc, disable=no_tqdm)
-
-    async def run_and_update(coro: Coroutine[Any, Any, Any]) -> Any:
-        result = await coro
-        pbar.update(1)
-        return result
-
-    wrapped_tasks = [run_and_update(c) for c in corouts]
-    results = await asyncio.gather(*wrapped_tasks)
-    pbar.close()
-
-    return results
-
-
-def get_timestamp() -> str:
-    return datetime.now().strftime("%Y%m%d_%H%M%S")