stores 0.1.7.dev5__tar.gz → 0.1.8.dev1__tar.gz

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stores
-Version: 0.1.7.dev5
+Version: 0.1.8.dev1
 Summary: Repository of Python functions and tools for LLMs
 License-File: LICENSE
 Requires-Python: >=3.10

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stores"
-version = "0.1.7dev5"
+version = "0.1.8dev1"
 description = "Repository of Python functions and tools for LLMs"
 readme = "README.md"
 requires-python = ">=3.10"

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/run_browser_use.py

@@ -1,16 +1,16 @@
 import stores  # noqa
 
+
 index = stores.indexes.LocalIndex(
     "/drive3/Silanthro/tools/basic-browser-use",
     create_venv=True,
-    include=["basic_browser_use.stream_browser_agent"],
+    include=["basic_browser_use.stream_browser_agent_gui"],
 )
-# print(index.tools)
 
 
 async def collect():
     async for value in index.astream_execute(
-        "basic_browser_use.stream_browser_agent",
+        "basic_browser_use.stream_browser_agent_gui",
         {"task": "What are the latest OpenAI models?"},
     ):
         print(value)
@@ -28,7 +28,7 @@ async def collect():
 # asyncio.run(collect())
 
 for value in index.stream_execute(
-    "basic_browser_use.stream_browser_agent",
+    "basic_browser_use.stream_browser_agent_gui",
     {"task": "What are the latest OpenAI models?"},
 ):
     print(value)

stores-0.1.8.dev1/run_sandbox.py

@@ -0,0 +1,24 @@
+import stores  # noqa
+
+index = stores.Index(
+    ["silanthro/python-sandbox"],
+    # env_var={
+    #     "silanthro/python-sandbox": {
+    #         "DENO_PATH": "/drive3/Silanthro/tools/python-sandbox/deno"
+    #     }
+    # },
+)
+print(index.tools)
+
+# for value in index.stream_execute("sandbox.run_code", {"code": "1+1"}):
+#     print(value)
+
+print(
+    index.execute(
+        "sandbox.run_code",
+        kwargs={
+            "timeout": 5,
+            "code": "def is_prime(n):\n    if n <= 1:\n        return False\n    for i in range(2, int(n**0.5) + 1):\n        if n % i == 0:\n            return False\n    return True\n\nprimes = []\nnum = 2\nwhile len(primes) < 10:\n    if is_prime(num):\n        primes.append(num)\n    num += 1\n\nsum(primes)",
+        },
+    )
+)

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/stores/format.py

@@ -61,7 +61,7 @@ def get_type_repr(typ: Type | GenericAlias) -> list[str]:
         return [type_mappings[typ.__name__]]
 
 
-def get_type_schema(typ: Type | GenericAlias):
+def get_type_schema(typ: Type | GenericAlias, provider: ProviderFormat):
     origin = get_origin(typ)
     args = get_args(typ)
 
@@ -77,24 +77,27 @@ def get_type_schema(typ: Type | GenericAlias):
         schema["enum"] = [v.value for v in typ]
     elif isinstance(typ, type) and typ.__class__.__name__ == "_TypedDictMeta":
         hints = get_type_hints(typ)
-        schema["properties"] = {k: get_type_schema(v) for k, v in hints.items()}
-        schema["additionalProperties"] = False
+        schema["properties"] = {
+            k: get_type_schema(v, provider) for k, v in hints.items()
+        }
+        if provider != ProviderFormat.GOOGLE_GEMINI:
+            schema["additionalProperties"] = False
         schema["required"] = list(hints.keys())
     elif origin in (list, List) or typ is dict:
         if args:
-            schema["items"] = get_type_schema(args[0])
+            schema["items"] = get_type_schema(args[0], provider)
         else:
             raise TypeError("Insufficient argument type information")
     elif origin in (dict, Dict) or typ is dict:
         raise TypeError("Insufficient argument type information")
     elif origin in (tuple, Tuple) or typ is tuple:
         if args:
-            schema["items"] = get_type_schema(args[0])
+            schema["items"] = get_type_schema(args[0], provider)
         else:
             raise TypeError("Insufficient argument type information")
     elif origin is Union or origin is T.UnionType:
         for arg in args:
-            subschema = get_type_schema(arg)
+            subschema = get_type_schema(arg, provider)
             del subschema["type"]
             schema = {
                 **schema,
@@ -103,14 +106,17 @@ def get_type_schema(typ: Type | GenericAlias):
 
     # Un-nest single member type lists since Gemini does not accept list of types
     # Optional for OpenAI or Anthropic
-    if schema["type"] and len(schema["type"]) == 1:
-        schema["type"] = schema["type"][0]
+    if schema["type"]:
+        if len(schema["type"]) == 1:
+            schema["type"] = schema["type"][0]
+        elif len(schema["type"]) > 1 and provider == ProviderFormat.GOOGLE_GEMINI:
+            schema["type"] = schema["type"][0]
 
     return schema
 
 
 def get_param_schema(param: inspect.Parameter, provider: ProviderFormat):
-    param_schema = get_type_schema(param.annotation)
+    param_schema = get_type_schema(param.annotation, provider)
 
     if param_schema["type"] is None:
         raise TypeError(f"Unsupported type: {param.annotation.__name__}")

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/stores/indexes/base_index.py

@@ -9,7 +9,6 @@ from typing import (
     Callable,
     List,
     Literal,
-    Optional,
     Tuple,
     Union,
     get_args,
@@ -98,7 +97,7 @@ def _handle_non_string_literal(annotation: type):
         return list[new_annotation], {"item": literal_map}
     if origin is Union or origin is UnionType:
         union_literal_maps = {}
-        argtype_args = [a for a in get_args(annotation) if a != NoneType]
+        argtype_args = [a for a in get_args(annotation)]
         new_union, literal_map = _handle_non_string_literal(argtype_args[0])
         union_literal_maps[new_union.__name__] = literal_map
         for child_argtype in argtype_args[1:]:
@@ -198,12 +197,12 @@ def wrap_tool(tool: Callable):
             # Process args with default values: make sure type includes None
             new_annotation = argtype
             if new_annotation is Parameter.empty:
-                new_annotation = Optional[type(new_arg.default)]
+                new_annotation = type(new_arg.default) | None
             origin = get_origin(new_annotation)
             if origin not in [Union, UnionType] or NoneType not in get_args(
                 new_annotation
             ):
-                new_annotation = Optional[new_annotation]
+                new_annotation = new_annotation | None
             new_arg = new_arg.replace(
                 default=None,
                 kind=Parameter.POSITIONAL_OR_KEYWORD,
@@ -402,13 +401,17 @@ class BaseIndex:
             # Handle sync
             yield tool_fn(**kwargs)
 
-    def parse_and_execute(self, msg: str):
+    def parse_and_execute(self, msg: str, collect_results=False):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
-        return self.execute(toolcall.get("toolname"), toolcall.get("kwargs"))
+        return self.execute(
+            toolcall.get("toolname"), toolcall.get("kwargs"), collect_results
+        )
 
-    async def async_parse_and_execute(self, msg: str):
+    async def aparse_and_execute(self, msg: str, collect_results=False):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
-        return await self.aexecute(toolcall.get("toolname"), toolcall.get("kwargs"))
+        return await self.aexecute(
+            toolcall.get("toolname"), toolcall.get("kwargs"), collect_results
+        )
 
     def stream_parse_and_execute(self, msg: str):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
@@ -416,7 +419,7 @@ class BaseIndex:
 
     async def astream_parse_and_execute(self, msg: str):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
-        async for value in self.astream_parse_and_execute(
+        async for value in self.astream_execute(
             toolcall.get("toolname"), toolcall.get("kwargs")
         ):
             yield value

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/stores/indexes/remote_index.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Optional
 
 import requests
-from git import Repo
+from git import GitCommandError, Repo
 
 from stores.constants import VENV_NAME
 from stores.indexes.base_index import BaseIndex
@@ -44,6 +44,8 @@ def lookup_index(index_id: str, index_version: str | None = None):
     )
     if response.ok:
         return response.json()
+    else:
+        raise ValueError(f"Index {index_id} not found in database")
 
 
 class RemoteIndex(BaseIndex):
@@ -88,7 +90,10 @@ class RemoteIndex(BaseIndex):
             if not repo_url:
                 # Otherwise, assume index references a GitHub repo
                 repo_url = f"https://github.com/{index_id}.git"
-            repo = Repo.clone_from(repo_url, self.index_folder)
+            try:
+                repo = Repo.clone_from(repo_url, self.index_folder)
+            except GitCommandError as e:
+                raise ValueError(f"Index {index_id} not found") from e
             if commit_like:
                 repo.git.checkout(commit_like)
 

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/stores/indexes/venv_utils.py

@@ -5,6 +5,7 @@ import json
 import logging
 import os
 import pickle
+import queue
 import socket
 import subprocess
 import sys
@@ -340,28 +341,43 @@ def parse_tool_signature(
     elif signature_dict.get("isgeneratorfunction"):
 
         def func_handler(*args, **kwargs):
-            async def collect():
-                async for value in run_remote_tool(
-                    tool_id=signature_dict["tool_id"],
-                    index_folder=index_folder,
-                    args=args,
-                    kwargs=kwargs,
-                    venv=venv,
-                    env_var=env_var,
-                    stream=True,
-                ):
-                    yield value
-
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            agen = collect()
-            try:
-                while True:
-                    yield loop.run_until_complete(agen.__anext__())
-            except StopAsyncIteration:
-                pass
-            finally:
-                loop.close()
+            q = queue.Queue()
+            sentinel = object()
+
+            def run():
+                async def runner():
+                    try:
+                        async for item in run_remote_tool(
+                            tool_id=signature_dict["tool_id"],
+                            index_folder=index_folder,
+                            args=args,
+                            kwargs=kwargs,
+                            venv=venv,
+                            env_var=env_var,
+                            stream=True,
+                        ):
+                            q.put(item)
+                    except Exception as e:
+                        q.put(e)
+                    finally:
+                        q.put(sentinel)
+
+                asyncio.run(runner())
+
+            t = threading.Thread(target=run)
+            t.start()
+
+            while True:
+                item = q.get()
+                if item is sentinel:
+                    break
+                elif isinstance(item, Exception):
+                    raise item
+                else:
+                    yield item
+
+            t.join()
+
     elif signature_dict.get("iscoroutinefunction"):
 
         async def func_handler(*args, **kwargs):

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/mock_index/tools.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import TypedDict
+from typing import Literal, TypedDict
 
 
 def foo(bar: str):
@@ -46,3 +46,25 @@ class Animal(TypedDict):
 
 def typed_dict_input(bar: Animal):
     return bar
+
+
+def literal_input(bar: Literal["red", "green", "blue"]):
+    return bar
+
+
+def literal_nonstring_input(bar: Literal[1, 2, 3]):
+    return bar
+
+
+def default_input(bar: str = "foo"):
+    return bar
+
+
+def stream_input(bar: str):
+    for _ in range(3):
+        yield bar
+
+
+async def astream_input(bar: str):
+    for _ in range(3):
+        yield bar

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/mock_index/tools.toml

@@ -6,5 +6,10 @@ tools = [
     "tools.async_foo",
     "tools.enum_input",
     "tools.typed_dict_input",
+    "tools.literal_input",
+    "tools.literal_nonstring_input",
+    "tools.default_input",
+    "tools.stream_input",
+    "tools.astream_input",
     "hello.world",
 ]

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/mock_index_w_deps/mock_index/__init__.py

@@ -55,3 +55,13 @@ def tuple_input(bar: tuple[Animal]) -> tuple[Animal]:
 
 def union_input(bar: Union[Color, Animal]) -> Union[Color, Animal]:
     return bar
+
+
+def stream_input(bar: str):
+    for _ in range(3):
+        yield bar
+
+
+async def astream_input(bar: str):
+    for _ in range(3):
+        yield bar

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/mock_index_w_deps/tools.toml

@@ -11,4 +11,7 @@ tools = [
   "mock_index.dict_input",
   "mock_index.tuple_input",
   "mock_index.union_input",
+  "mock_index.stream_input",
+  "mock_index.astream_input",
+  "mock_index.not_a_function",
 ]

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_format/conftest.py

@@ -128,6 +128,8 @@ def a_tool_with_complex_args(provider):
     elif provider == ProviderFormat.GOOGLE_GEMINI:
         for k in parameters.keys():
             parameters[k]["nullable"] = False
+            if parameters[k]["type"] == "object":
+                del parameters[k]["additionalProperties"]
         schema = {
             "name": tool.__name__,
             "parameters": {

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/conftest.py

@@ -196,15 +196,15 @@ def foo_w_optional_and_default(bar: Optional[str] = "test"):
     params=[
         {
             "function": foo_w_default,
-            "signature": "(bar: Optional[str] = None)",
+            "signature": "(bar: str | None = None)",
         },
         {
             "function": foo_w_default_notype,
-            "signature": "(bar: Optional[str] = None)",
+            "signature": "(bar: str | None = None)",
         },
         {
             "function": foo_w_optional_and_default,
-            "signature": "(bar: Optional[str] = None)",
+            "signature": "(bar: str | None = None)",
         },
     ],
 )
@@ -466,3 +466,28 @@ def cast_foo_unhandled(bar: list[str, int]):
 )
 def cast_tool(request):
     yield request.param
+
+
+def foo(bar: str):
+    return bar
+
+
+async def afoo(bar: str):
+    return bar
+
+
+def stream_foo(bar: str):
+    for _ in range(3):
+        yield bar
+
+
+async def astream_foo(bar: str):
+    for _ in range(3):
+        yield bar
+
+
+@pytest.fixture(
+    params=[foo, afoo, stream_foo, astream_foo],
+)
+def various_runtype_tool(request):
+    yield request.param

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/test_base_index.py

@@ -1,4 +1,6 @@
+import asyncio
 import inspect
+import json
 import logging
 
 import pytest
@@ -197,3 +199,162 @@ def test_base_index_format_tools(sample_tool, provider):
                 },
             }
         ]
+
+
+def handle_various_run_type(tool_fn, kwargs: dict, collect_results=False):
+    if inspect.isasyncgenfunction(tool_fn):
+        # Handle async generator
+
+        async def collect():
+            results = []
+            async for value in tool_fn(**kwargs):
+                results.append(value)
+            if collect_results:
+                return results
+            else:
+                return results[-1]
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(collect())
+    elif inspect.isgeneratorfunction(tool_fn):
+        # Handle sync generator
+        results = []
+        for value in tool_fn(**kwargs):
+            results.append(value)
+        if collect_results:
+            return results
+        else:
+            return results[-1]
+    elif inspect.iscoroutinefunction(tool_fn):
+        # Handle async
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop.run_until_complete(tool_fn(**kwargs))
+    else:
+        # Handle sync
+        return tool_fn(**kwargs)
+
+
+async def ahandle_various_run_type(tool_fn, kwargs: dict, collect_results=False):
+    kwargs = kwargs or {}
+    if inspect.isasyncgenfunction(tool_fn):
+        # Handle async generator
+        results = []
+        async for value in tool_fn(**kwargs):
+            results.append(value)
+        if collect_results:
+            return results
+        else:
+            return results[-1]
+    elif inspect.isgeneratorfunction(tool_fn):
+        # Handle sync generator
+        results = []
+        for value in tool_fn(**kwargs):
+            results.append(value)
+        if collect_results:
+            return results
+        else:
+            return results[-1]
+    elif inspect.iscoroutinefunction(tool_fn):
+        # Handle async
+        return await tool_fn(**kwargs)
+    else:
+        # Handle sync
+        return tool_fn(**kwargs)
+
+
+def test_base_index_execute(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    assert index.parse_and_execute(
+        json.dumps(
+            {
+                "toolname": various_runtype_tool.__name__,
+                "kwargs": {"bar": "hello"},
+            }
+        )
+    ) == handle_various_run_type(various_runtype_tool, {"bar": "hello"})
+
+
+async def test_base_index_aexecute(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    assert await index.aparse_and_execute(
+        json.dumps(
+            {
+                "toolname": various_runtype_tool.__name__,
+                "kwargs": {"bar": "hello"},
+            }
+        )
+    ) == await ahandle_various_run_type(various_runtype_tool, {"bar": "hello"})
+
+
+def test_base_index_execute_collect(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    assert index.execute(
+        various_runtype_tool.__name__, {"bar": "hello"}, collect_results=True
+    ) == handle_various_run_type(
+        various_runtype_tool, {"bar": "hello"}, collect_results=True
+    )
+
+
+async def test_base_index_aexecute_collect(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    assert await index.aexecute(
+        various_runtype_tool.__name__, {"bar": "hello"}, collect_results=True
+    ) == await ahandle_various_run_type(
+        various_runtype_tool, {"bar": "hello"}, collect_results=True
+    )
+
+
+def test_base_index_stream_execute(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    results = []
+    for result in index.stream_parse_and_execute(
+        json.dumps(
+            {
+                "toolname": various_runtype_tool.__name__,
+                "kwargs": {"bar": "hello"},
+            }
+        )
+    ):
+        results.append(result)
+    if not inspect.isgeneratorfunction(
+        various_runtype_tool
+    ) and not inspect.isasyncgenfunction(various_runtype_tool):
+        results = results[0]
+
+    answer = handle_various_run_type(
+        various_runtype_tool, {"bar": "hello"}, collect_results=True
+    )
+
+    assert results == answer
+
+
+async def test_base_index_astream_execute(various_runtype_tool):
+    index = BaseIndex([various_runtype_tool])
+
+    results = []
+    async for result in index.astream_parse_and_execute(
+        json.dumps(
+            {
+                "toolname": various_runtype_tool.__name__,
+                "kwargs": {"bar": "hello"},
+            }
+        )
+    ):
+        results.append(result)
+    if not inspect.isgeneratorfunction(
+        various_runtype_tool
+    ) and not inspect.isasyncgenfunction(various_runtype_tool):
+        results = results[0]
+
+    answer = await ahandle_various_run_type(
+        various_runtype_tool, {"bar": "hello"}, collect_results=True
+    )
+
+    assert results == answer

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/test_index.py

@@ -31,6 +31,11 @@ async def test_index(local_index_folder):
         "tools.async_foo",
         "tools.enum_input",
         "tools.typed_dict_input",
+        "tools.literal_input",
+        "tools.literal_nonstring_input",
+        "tools.default_input",
+        "tools.stream_input",
+        "tools.astream_input",
         "hello.world",
         "foo",
     ]

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/test_local_index.py

@@ -13,6 +13,11 @@ def test_local_index_basic(local_index_folder):
         "tools.async_foo",
         "tools.enum_input",
         "tools.typed_dict_input",
+        "tools.literal_input",
+        "tools.literal_nonstring_input",
+        "tools.default_input",
+        "tools.stream_input",
+        "tools.astream_input",
         "hello.world",
     ]
     # Test tool execution
@@ -22,6 +27,11 @@ def test_local_index_basic(local_index_folder):
         "tools.async_foo": "hello world",
         "tools.enum_input": "red",
         "tools.typed_dict_input": {"name": "Tiger", "num_legs": 4},
+        "tools.literal_input": "red",
+        "tools.literal_nonstring_input": 1,
+        "tools.default_input": "foo",
+        "tools.stream_input": "hello world",
+        "tools.astream_input": "hello world",
         "hello.world": "hello world",
     }
     for tool in index.tools[:-1]:
@@ -53,9 +63,11 @@ def test_local_index_invalid_folder(buggy_index_folder):
 def test_local_index_with_deps(remote_index_folder):
     # Regular LocalIndex should not load index folder with deps since deps are not installed
     with pytest.raises(ModuleNotFoundError):
-        LocalIndex(remote_index_folder)
+        LocalIndex(remote_index_folder, exclude=["mock_index.not_a_function"])
     # LocalIndex can load index folder with deps if create_venv=True
-    LocalIndex(remote_index_folder, create_venv=True)
+    LocalIndex(
+        remote_index_folder, exclude=["mock_index.not_a_function"], create_venv=True
+    )
 
 
 def test_local_index_with_env_var():

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/test_remote_index.py

@@ -21,6 +21,12 @@ def test_lookup_index():
     }
 
 
+async def test_fake_remote_index():
+    fake_index = "no_such_index"
+    with pytest.raises(ValueError, match=f"Index {fake_index} not found"):
+        stores.indexes.RemoteIndex(fake_index)
+
+
 async def test_remote_index():
     # Check that env_vars are set correctly
     index = stores.indexes.RemoteIndex(

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/tests/test_indexes/test_venv_utils.py

@@ -1,6 +1,7 @@
 import inspect
 import logging
 import venv
+from typing import get_args, get_origin, get_type_hints
 
 import pytest
 
@@ -48,7 +49,11 @@ async def test_install_venv_deps(remote_index_folder):
     assert reinstall_result == "Already installed"
 
     # Tools should load and be runnable
-    tools = venv_utils.init_venv_tools(remote_index_folder)
+    tools = venv_utils.init_venv_tools(
+        remote_index_folder,
+        # Test exclude
+        exclude=["mock_index.not_a_function"],
+    )
 
     # Tools should run successfully
     sample_string = "red"
@@ -73,15 +78,55 @@ async def test_install_venv_deps(remote_index_folder):
             kwargs = {"bar": [sample_animal, sample_animal]}
         elif tool.__name__ == "mock_index.union_input":
             kwargs = {"bar": sample_animal}
+        elif tool.__name__ in ["mock_index.stream_input", "mock_index.astream_input"]:
+            kwargs = {"bar": sample_string}
         else:
             kwargs = {}
         output = kwargs.get("bar", "pip_install_test")
-        if inspect.iscoroutinefunction(tool):
+        if inspect.isasyncgenfunction(tool):
+            async for value in tool(**kwargs):
+                assert value == output
+        elif inspect.isgeneratorfunction(tool):
+            for value in tool(**kwargs):
+                assert value == output
+        elif inspect.iscoroutinefunction(tool):
             assert await tool(**kwargs) == output
         else:
             assert tool(**kwargs) == output
 
 
+async def test_install_venv_deps_with_include(remote_index_folder):
+    # Create venv
+    venv_folder = remote_index_folder / VENV_NAME
+    venv.create(venv_folder, symlinks=True, with_pip=True)
+    # Test installation
+    result = venv_utils.install_venv_deps(remote_index_folder)
+    assert (remote_index_folder / venv_utils.HASH_FILE).exists()
+
+    for config_file in venv_utils.SUPPORTED_CONFIGS:
+        if (remote_index_folder / config_file).exists():
+            assert result.endswith(
+                f'"{" ".join(venv_utils.get_pip_command(venv_folder, config_file))}"'
+            )
+            assert venv_utils.has_installed(remote_index_folder / config_file)
+            break
+
+    # Running install again should show "Already installed"
+    reinstall_result = venv_utils.install_venv_deps(remote_index_folder)
+    assert reinstall_result == "Already installed"
+
+    # Tools should load and be runnable
+    tools = venv_utils.init_venv_tools(
+        remote_index_folder,
+        # Test include
+        include=["mock_index.typed_function"],
+    )
+
+    assert len(tools) == 1
+    tool = tools[0]
+    assert tool.__name__ == "mock_index.typed_function"
+
+
 def test_index_with_invalid_tool(index_folder_custom_class):
     with pytest.raises(RuntimeError, match="Error loading tool"):
         venv_utils.init_venv_tools(index_folder_custom_class)
@@ -93,6 +138,37 @@ def test_index_with_tool_error(index_folder_function_error):
         tools[0]()
 
 
+def test_parse_param_type_with_forward_ref():
+    param_info = {
+        "type": "TypedDict",
+        "type_name": "Person",
+        "fields": {
+            "name": {"type": str},
+            "friends": {
+                "type": "List",
+                "item_type": {
+                    "type": "Person",
+                },
+            },
+        },
+    }
+    typ = venv_utils.parse_param_type(param_info)
+    assert typ.__class__.__name__ == "_TypedDictMeta"
+    assert typ.__name__ == "Person"
+    hints = get_type_hints(typ)
+    for k, v in hints.items():
+        if k == "name":
+            assert v is str
+        elif k == "friends":
+            origin = get_origin(v)
+            assert origin is list
+            args = list(get_args(v))
+            assert len(args) == 1
+            assert args[0] == "Person"
+        else:
+            raise AssertionError("Invalid attribute")
+
+
 def test_parse_param_type_with_invalid_type():
     with pytest.raises(TypeError, match="Invalid param type"):
         venv_utils.parse_param_type({"type": "not a type"})

{stores-0.1.7.dev5 → stores-0.1.8.dev1}/uv.lock

@@ -2963,7 +2963,7 @@ wheels = [
 
 [[package]]
 name = "stores"
-version = "0.1.7.dev5"
+version = "0.1.7.dev6"
 source = { editable = "." }
 dependencies = [
     { name = "dirtyjson" },

stores-0.1.7.dev5/run_sandbox.py

@@ -1,16 +0,0 @@
-import stores  # noqa
-
-index = stores.Index(
-    ["silanthro/python-sandbox"],
-    # env_var={
-    #     "silanthro/python-sandbox": {
-    #         "DENO_PATH": "/drive3/Silanthro/tools/python-sandbox/deno"
-    #     }
-    # },
-)
-print(index.tools)
-
-# for value in index.stream_execute("sandbox.run_code", {"code": "1+1"}):
-#     print(value)
-
-print(index.execute("sandbox.run_code", {"code": "1+1"}))