stores 0.1.6__tar.gz → 0.1.7.dev1__tar.gz

{stores-0.1.6 → stores-0.1.7.dev1}/PKG-INFO

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

stores-0.1.7.dev1/local_generator.py

@@ -0,0 +1,33 @@
+import asyncio
+
+import stores
+
+
+def func():
+    yield "Hello"
+    yield 51
+    yield "Good Bye"
+
+
+async def func_d():
+    for i in range(3):
+        await asyncio.sleep(0.5)
+        yield f"sleep {i}"
+
+
+index = stores.Index(
+    ["silanthro/todoist"], include={"silanthro/todoist": ["todoist.func"]}
+)
+
+print(index.tools)
+quit()
+
+
+# for i in index.tools[1]():
+#     print(i)
+
+print(index.execute("todoist.func_d"))
+
+
+for i in index.stream_execute("todoist.func_d"):
+    print(i)

{stores-0.1.6 → stores-0.1.7.dev1}/pyproject.toml

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

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

@@ -128,6 +128,29 @@ def _undo_non_string_literal(annotation: type, value: Any, literal_map: dict):
     return value
 
 
+def _preprocess_args(
+    original_signature: inspect.Signature, literal_maps: dict, args: list, kwargs: dict
+):
+    # Inject default values within wrapper
+    bound_args = original_signature.bind(*args, **kwargs)
+    bound_args.apply_defaults()
+    for k, v in bound_args.arguments.items():
+        if (
+            v is None
+            and original_signature.parameters[k].default is not Parameter.empty
+        ):
+            bound_args.arguments[k] = original_signature.parameters[k].default
+    _cast_bound_args(bound_args)
+    # Inject correct Literals
+    for k, v in bound_args.arguments.items():
+        if k in literal_maps:
+            param = original_signature.parameters[k]
+            bound_args.arguments[k] = _undo_non_string_literal(
+                param.annotation, v, literal_maps[k]
+            )
+    return bound_args
+
+
 def wrap_tool(tool: Callable):
     """
     Wrap tool to make it compatible with LLM libraries
@@ -189,42 +212,37 @@ def wrap_tool(tool: Callable):
         new_args.append(new_arg)
     new_sig = original_signature.replace(parameters=new_args)
 
-    if inspect.iscoroutinefunction(tool):
+    if inspect.isasyncgenfunction(tool):
+
+        async def wrapper(*args, **kwargs):
+            bound_args = _preprocess_args(
+                original_signature, literal_maps, args, kwargs
+            )
+            async for value in tool(*bound_args.args, **bound_args.kwargs):
+                yield value
+
+    elif inspect.isgeneratorfunction(tool):
+
+        def wrapper(*args, **kwargs):
+            bound_args = _preprocess_args(
+                original_signature, literal_maps, args, kwargs
+            )
+            for value in tool(*bound_args.args, **bound_args.kwargs):
+                yield value
+
+    elif inspect.iscoroutinefunction(tool):
 
         async def wrapper(*args, **kwargs):
-            # Inject default values within wrapper
-            bound_args = original_signature.bind(*args, **kwargs)
-            bound_args.apply_defaults()
-            _cast_bound_args(bound_args)
-            # Inject correct Literals
-            for k, v in bound_args.arguments.items():
-                if k in literal_maps:
-                    param = original_signature.parameters[k]
-                    bound_args.arguments[k] = _undo_non_string_literal(
-                        param.annotation, v, literal_maps[k]
-                    )
+            bound_args = _preprocess_args(
+                original_signature, literal_maps, args, kwargs
+            )
             return await tool(*bound_args.args, **bound_args.kwargs)
     else:
 
         def wrapper(*args, **kwargs):
-            # Inject default values within wrapper
-            bound_args = original_signature.bind(*args, **kwargs)
-            bound_args.apply_defaults()
-            # Inject correct Literals
-            for k, v in bound_args.arguments.items():
-                if (
-                    v is None
-                    and original_signature.parameters[k].default is not Parameter.empty
-                ):
-                    bound_args.arguments[k] = original_signature.parameters[k].default
-
-            _cast_bound_args(bound_args)
-            for k, v in bound_args.arguments.items():
-                if k in literal_maps:
-                    param = original_signature.parameters[k]
-                    bound_args.arguments[k] = _undo_non_string_literal(
-                        param.annotation, v, literal_maps[k]
-                    )
+            bound_args = _preprocess_args(
+                original_signature, literal_maps, args, kwargs
+            )
             return tool(*bound_args.args, **bound_args.kwargs)
 
     wrapped = create_function(
@@ -249,14 +267,7 @@ class BaseIndex:
     def tools_dict(self):
         return {tool.__name__: tool for tool in self.tools}
 
-    def execute(self, toolname: str, kwargs: dict | None = None):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        return loop.run_until_complete(self.async_execute(toolname, kwargs))
-
-    async def async_execute(self, toolname: str, kwargs: dict | None = None):
-        kwargs = kwargs or {}
-
+    def _get_tool(self, toolname: str):
         # Use regex since we need to match cases where we perform
         # substitutions such as replace(".", "-")
         pattern = re.compile(":?" + re.sub("-|\\.", "(-|\\.)", toolname) + "$")
@@ -272,11 +283,124 @@ class BaseIndex:
         else:
             toolname = matching_tools[0]
 
-        tool = self.tools_dict[toolname]
-        if inspect.iscoroutinefunction(tool):
-            return await tool(**kwargs)
+        return self.tools_dict[toolname]
+
+    def execute(self, toolname: str, kwargs: dict | None = None, collect_results=False):
+        tool_fn = self._get_tool(toolname)
+        kwargs = kwargs or {}
+        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 aexecute(
+        self, toolname: str, kwargs: dict | None = None, collect_results=False
+    ):
+        tool_fn = self._get_tool(toolname)
+        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 stream_execute(self, toolname: str, kwargs: dict | None = None):
+        tool_fn = self._get_tool(toolname)
+        kwargs = kwargs or {}
+        if inspect.isasyncgenfunction(tool_fn):
+            # Handle async generator
+
+            async def collect():
+                async for value in tool_fn(**kwargs):
+                    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()
+        elif inspect.isgeneratorfunction(tool_fn):
+            # Handle sync generator
+            for value in tool_fn(**kwargs):
+                yield value
+        elif inspect.iscoroutinefunction(tool_fn):
+            # Handle async
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            yield loop.run_until_complete(tool_fn(**kwargs))
+        else:
+            # Handle sync
+            yield tool_fn(**kwargs)
+
+    async def astream_execute(self, toolname: str, kwargs: dict | None = None):
+        tool_fn = self._get_tool(toolname)
+        kwargs = kwargs or {}
+        if inspect.isasyncgenfunction(tool_fn):
+            # Handle async generator
+            async for value in tool_fn(**kwargs):
+                yield value
+        elif inspect.isgeneratorfunction(tool_fn):
+            # Handle sync generator
+            for value in tool_fn(**kwargs):
+                yield value
+        elif inspect.iscoroutinefunction(tool_fn):
+            # Handle async
+            yield await tool_fn(**kwargs)
         else:
-            return tool(**kwargs)
+            # Handle sync
+            yield tool_fn(**kwargs)
 
     def parse_and_execute(self, msg: str):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
@@ -284,9 +408,18 @@ class BaseIndex:
 
     async def async_parse_and_execute(self, msg: str):
         toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
-        return await self.async_execute(
+        return await self.aexecute(toolcall.get("toolname"), toolcall.get("kwargs"))
+
+    def stream_parse_and_execute(self, msg: str):
+        toolcall = llm_parse_json(msg, keys=["toolname", "kwargs"])
+        return self.stream_execute(toolcall.get("toolname"), toolcall.get("kwargs"))
+
+    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(
             toolcall.get("toolname"), toolcall.get("kwargs")
-        )
+        ):
+            yield value
 
     def format_tools(self, provider: ProviderFormat):
         return format_tools(self.tools, provider)

{stores-0.1.6 → stores-0.1.7.dev1}/stores/indexes/index.py

@@ -17,11 +17,15 @@ class Index(BaseIndex):
         self,
         tools: list[Callable, os.PathLike] | None = None,
         env_var: dict[str, dict] | None = None,
+        include: dict[str, list[str]] | None = None,
+        exclude: dict[str, list[str]] | None = None,
         cache_dir: Optional[os.PathLike] = None,
         reset_cache=False,
         sys_executable: str | None = None,
     ):
         self.env_var = env_var or {}
+        include = include or {}
+        exclude = exclude or {}
         tools = tools or []
 
         _tools = []
@@ -32,7 +36,11 @@ class Index(BaseIndex):
                 if Path(index_name).exists():
                     # Load LocalIndex
                     try:
-                        loaded_index = LocalIndex(index_name)
+                        loaded_index = LocalIndex(
+                            index_name,
+                            include=include.get(index_name),
+                            exclude=exclude.get(index_name),
+                        )
                     except Exception:
                         logger.warning(
                             f'Unable to load index "{index_name}"', exc_info=True
@@ -43,6 +51,8 @@ class Index(BaseIndex):
                         loaded_index = RemoteIndex(
                             index_name,
                             env_var=self.env_var.get(index_name),
+                            include=include.get(index_name),
+                            exclude=exclude.get(index_name),
                             cache_dir=cache_dir,
                             reset_cache=reset_cache,
                             sys_executable=sys_executable,

{stores-0.1.6 → stores-0.1.7.dev1}/stores/indexes/local_index.py

@@ -26,10 +26,14 @@ class LocalIndex(BaseIndex):
         index_folder: os.PathLike,
         create_venv: bool = False,
         env_var: dict | None = None,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
         sys_executable: str | None = None,
     ):
         self.index_folder = Path(index_folder)
         self.env_var = env_var or {}
+        include = include or []
+        exclude = exclude or []
 
         if not self.index_folder.exists():
             raise ValueError(
@@ -50,21 +54,31 @@ class LocalIndex(BaseIndex):
                     )
             install_venv_deps(self.index_folder)
             # Initialize tools
-            tools = init_venv_tools(self.index_folder, self.env_var)
+            tools = init_venv_tools(
+                self.index_folder,
+                env_var=self.env_var,
+                include=include,
+                exclude=exclude,
+            )
         else:
             if self.env_var:
                 raise ValueError(
                     "Environment variables will only be restricted if create_venv=True when initializing LocalIndex"
                 )
-            tools = self._init_tools()
+            tools = self._init_tools(include=include, exclude=exclude)
         super().__init__(tools)
 
-    def _init_tools(self):
+    def _init_tools(
+        self, include: list[str] | None = None, exclude: list[str] | None = None
+    ):
         """
         Load local tools.toml file and import tool functions
 
         NOTE: Can we just add index_folder to sys.path and import the functions?
         """
+        include = include or []
+        exclude = exclude or []
+
         index_manifest = self.index_folder / TOOLS_CONFIG_FILENAME
         if not index_manifest.exists():
             raise ValueError(f"Unable to load index - {index_manifest} does not exist")
@@ -73,7 +87,9 @@ class LocalIndex(BaseIndex):
             manifest = tomllib.load(file)["index"]
 
         tools = []
-        for tool_id in manifest.get("tools", []):
+        for tool_id in include or manifest.get("tools", []):
+            if tool_id in exclude:
+                continue
             module_name = ".".join(tool_id.split(".")[:-1])
             tool_name = tool_id.split(".")[-1]
 

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

@@ -51,6 +51,8 @@ class RemoteIndex(BaseIndex):
         self,
         index_id: str,
         env_var: dict | None = None,
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
         cache_dir: Optional[PathLike] = None,
         reset_cache=False,
         sys_executable: str | None = None,
@@ -64,6 +66,8 @@ class RemoteIndex(BaseIndex):
             shutil.rmtree(cache_dir)
         self.index_folder = cache_dir / self.index_id
         self.env_var = env_var or {}
+        include = include or []
+        exclude = exclude or []
         if not self.index_folder.exists():
             logger.info(f"Installing {index_id}...")
             commit_like = None
@@ -99,5 +103,7 @@ class RemoteIndex(BaseIndex):
                 venv.create(self.venv, symlinks=True, with_pip=True, upgrade_deps=True)
         install_venv_deps(self.index_folder)
         # Initialize tools
-        tools = init_venv_tools(self.index_folder, self.env_var)
+        tools = init_venv_tools(
+            self.index_folder, env_var=self.env_var, include=include, exclude=exclude
+        )
         super().__init__(tools)

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

@@ -104,16 +104,25 @@ def install_venv_deps(index_folder: os.PathLike):
             return message
 
 
-def init_venv_tools(index_folder: os.PathLike, env_var: dict | None = None):
+def init_venv_tools(
+    index_folder: os.PathLike,
+    env_var: dict | None = None,
+    include: list[str] | None = None,
+    exclude: list[str] | None = None,
+):
     index_folder = Path(index_folder)
     env_var = env_var or {}
+    include = include or []
+    exclude = exclude or []
 
     index_manifest = index_folder / TOOLS_CONFIG_FILENAME
     with open(index_manifest, "rb") as file:
         manifest = tomllib.load(file)["index"]
 
     tools = []
-    for tool_id in manifest.get("tools", []):
+    for tool_id in include or manifest.get("tools", []):
+        if tool_id in exclude:
+            continue
         tool_sig = get_tool_signature(
             tool_id=tool_id,
             index_folder=index_folder,
@@ -215,7 +224,9 @@ try:
                 "tool_id": "{tool_id}",
                 "params": params,
                 "return": return_info,
-                "is_async": inspect.iscoroutinefunction({tool_name}),
+                "iscoroutinefunction": inspect.iscoroutinefunction({tool_name}),
+                "isgeneratorfunction": inspect.isgeneratorfunction({tool_name}),
+                "isasyncgenfunction": inspect.isasyncgenfunction({tool_name}),
                 "doc": inspect.getdoc({tool_name}),
             }},
         }},
@@ -293,25 +304,56 @@ def parse_tool_signature(
     """
     env_var = env_var or {}
 
-    def func_handler(*args, **kwargs):
-        return run_remote_tool(
-            tool_id=signature_dict["tool_id"],
-            index_folder=index_folder,
-            args=args,
-            kwargs=kwargs,
-            venv=venv,
-            env_var=env_var,
-        )
+    if signature_dict.get("isasyncgenfunction"):
+
+        async def func_handler(*args, **kwargs):
+            # TODO: Make this truly 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
+    elif signature_dict.get("isgeneratorfunction"):
+
+        def func_handler(*args, **kwargs):
+            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
+    elif signature_dict.get("iscoroutinefunction"):
+
+        async def func_handler(*args, **kwargs):
+            # TODO: Make this truly async
+            return run_remote_tool(
+                tool_id=signature_dict["tool_id"],
+                index_folder=index_folder,
+                args=args,
+                kwargs=kwargs,
+                venv=venv,
+                env_var=env_var,
+            )
+    else:
 
-    async def async_func_handler(*args, **kwargs):
-        return run_remote_tool(
-            tool_id=signature_dict["tool_id"],
-            index_folder=index_folder,
-            args=args,
-            kwargs=kwargs,
-            venv=venv,
-            env_var=env_var,
-        )
+        def func_handler(*args, **kwargs):
+            return run_remote_tool(
+                tool_id=signature_dict["tool_id"],
+                index_folder=index_folder,
+                args=args,
+                kwargs=kwargs,
+                venv=venv,
+                env_var=env_var,
+            )
 
     # Reconstruct signature from list of args
     params = []
@@ -329,7 +371,7 @@ def parse_tool_signature(
     signature = inspect.Signature(params, return_annotation=return_type)
     func = create_function(
         signature,
-        async_func_handler if signature_dict.get("is_async") else func_handler,
+        func_handler,
         qualname=signature_dict["tool_id"],
         doc=signature_dict.get("doc"),
     )
@@ -345,6 +387,7 @@ def run_remote_tool(
     kwargs: dict | None = None,
     venv: str = VENV_NAME,
     env_var: dict | None = None,
+    stream: bool = False,
 ):
     args = args or []
     kwargs = kwargs or {}
@@ -365,56 +408,108 @@ def run_remote_tool(
     listener.listen(1)
     _, port = listener.getsockname()
 
-    def handle_connection():
+    result_data = {}
+
+    def handle_connection(stream_mode: bool = False):
         conn, _ = listener.accept()
         with conn:
-            data = b""
+            buffer = ""
             while True:
-                chunk = conn.recv(4096)
+                chunk = conn.recv(4096).decode("utf-8")
                 if not chunk:
                     break
-                data += chunk
-            listener.close()
-            return data
-
-    result_data = {}
-    t = threading.Thread(
-        target=lambda: result_data.setdefault("data", handle_connection())
-    )
-    t.start()
+                buffer += chunk
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    if not line.strip():
+                        continue
+                    msg = json.loads(line)
+                    if msg.get("ok") and "stream" in msg:
+                        if stream_mode:
+                            yield msg["stream"]
+                        else:
+                            result_data.setdefault("stream", []).append(msg["stream"])
+                    elif msg.get("ok") and "result" in msg:
+                        result_data["result"] = msg["result"]
+                    elif "error" in msg:
+                        result_data["error"] = msg["error"]
+                    elif msg.get("done"):
+                        if stream_mode:
+                            break
+                        else:
+                            return
+
+    if not stream:
+        thread = threading.Thread(
+            target=lambda: list(handle_connection(stream_mode=False))
+        )
+        thread.start()
 
     runner = f"""
 import asyncio, inspect, json, socket, sys, traceback
 sys.path.insert(0, "{index_folder}")
+
+def send(sock, payload):
+    sock.sendall((json.dumps(payload) + "\\n").encode("utf-8"))
+
+sock = socket.create_connection(("localhost", {port}))
+
 try:
     from {module_name} import {tool_name}
     params = json.load(sys.stdin)
     args = params.get("args", [])
     kwargs = params.get("kwargs", {{}})
-    if inspect.iscoroutinefunction({tool_name}):
+
+    func = {tool_name}
+
+    if inspect.isasyncgenfunction(func):
+        async def run():
+            async for value in func(*args, **kwargs):
+                send(sock, {{"ok": True, "stream": value}})
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        result = loop.run_until_complete({tool_name}(*args, **kwargs))
+        loop.run_until_complete(run())
+    elif inspect.isgeneratorfunction(func):
+        for value in func(*args, **kwargs):
+            send(sock, {{"ok": True, "stream": value}})
+    elif inspect.iscoroutinefunction(func):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(func(*args, **kwargs))
+        send(sock, {{"ok": True, "result": result}})
     else:
-        result = {tool_name}(*args, **kwargs)
-    response = json.dumps({{"ok": True, "result": result}})
+        result = func(*args, **kwargs)
+        send(sock, {{"ok": True, "result": result}})
+    send(sock, {{"done": True}})
 except Exception as e:
     err = traceback.format_exc()
-    response = json.dumps({{"ok": False, "error": err}})
-sock = socket.create_connection(("localhost", {port}))
-sock.sendall(response.encode("utf-8"))
-sock.close()
+    try:
+        send(sock, {{"ok": False, "error": err}})
+    except:
+        pass
+finally:
+    try:
+        sock.close()
+    except:
+        pass
 """
-    result = subprocess.run(
+    subprocess.run(
         [get_python_command(Path(index_folder) / venv), "-c", runner],
         input=payload,
         capture_output=True,
         env=env_var or None,
     )
 
-    t.join()
-    response = json.loads(result_data["data"].decode("utf-8"))
-    if response.get("ok"):
-        return response["result"]
+    if not stream:
+        thread.join()
+
+        if "error" in result_data:
+            raise RuntimeError(f"Subprocess failed with error:\n{result_data['error']}")
+        elif "result" in result_data:
+            return result_data["result"]
+        elif "stream" in result_data:
+            return result_data["stream"]
+        else:
+            raise RuntimeError("Subprocess completed without returning data.")
     else:
-        raise RuntimeError(f"Subprocess failed with error:\n{response['error']}")
+        return handle_connection(stream_mode=True)

{stores-0.1.6 → stores-0.1.7.dev1}/uv.lock

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

stores-0.1.6/run_complex.py

@@ -1,123 +0,0 @@
-# import anthropic
-import inspect
-
-import dotenv
-from langchain_core.tools import tool as callable_as_lc_tool
-from langchain_google_genai import ChatGoogleGenerativeAI
-
-# from openai import OpenAI
-# from google import genai
-# from google.genai import types
-# from litellm import completion
-# from stores.indexes import LocalIndex
-import stores
-
-dotenv.load_dotenv()
-
-
-# def foo(bar: str = "test"):
-#     return bar
-
-
-# index = stores.Index([foo])
-# print(inspect.signature(index.tools[0]))
-# print(index.tools[0]())
-# quit()
-
-
-index = stores.Index(
-    ["silanthro/todoist"],
-    env_var={
-        "silanthro/todoist": {
-            "TODOIST_API_TOKEN": "6a0815ff164d7ebd6d45d433bdbd32fcb164e1ec",
-        }
-    },
-)
-
-sig = inspect.signature(index.tools[0])
-print(sig)
-
-wrap = callable_as_lc_tool()(index.tools[0])
-sig_wrap = inspect.signature(wrap)
-print(sig_wrap)
-# quit()
-
-for argname, arg in sig.parameters.items():
-    print(argname)
-    print(arg.annotation)
-    print([arg.default])
-
-# print(sig)
-# quit()
-
-# result = index.execute(
-#     "todoist.get_tasks",
-#     {
-#         "project_id": None,
-#         "search_query": None,
-#         "due_date_filter": "today",
-#         "priority": None,
-#         "other_filters": None,
-#         "limit": None,
-#     },
-# )
-# print(result)
-# quit()
-
-
-task = "Find tasks of priority 1"
-
-# print(index.tools)
-
-# print(index.format_tools("openai-chat-completions"))
-# quit()
-
-# client = OpenAI()
-# response = client.responses.create(
-#     model="gpt-4o-mini-2024-07-18",
-#     input=[{"role": "user", "content": task}],
-#     tools=index.format_tools("openai-responses"),
-# )
-# client = anthropic.Anthropic()
-# response = client.messages.create(
-#     model="claude-3-5-sonnet-20241022",
-#     max_tokens=1024,
-#     messages=[{"role": "user", "content": task}],
-#     tools=index.format_tools("anthropic"),
-# )
-# response = completion(
-#     model="gemini/gemini-2.0-flash-001",
-#     messages=[
-#         {
-#             "role": "user",
-#             "content": task,
-#         }
-#     ],
-#     tools=index.format_tools("google-gemini"),
-# )
-# client = genai.Client(
-#     # api_key=os.environ["GEMINI_API_KEY"],
-# )
-# config = types.GenerateContentConfig(
-#     tools=index.tools,
-#     automatic_function_calling=types.AutomaticFunctionCallingConfig(
-#         disable=True  # Gemini automatically executes tool calls. This script shows how to manually execute tool calls.
-#     ),
-# )
-
-# # Get the response from the model
-# response = client.models.generate_content(
-#     model="gemini-2.0-flash",
-#     contents=task,
-#     config=config,
-# )
-# tool_call = response.candidates[0].content.parts[0].function_call
-
-model = ChatGoogleGenerativeAI(model="gemini-2.0-flash-001")
-model_with_tools = model.bind_tools(index.tools)
-response = model_with_tools.invoke(task)
-tool_call = response.tool_calls[0]
-
-print(tool_call)
-# Execute the tool call
-# print(response)