stores 0.1.6__py3-none-any.whl → 0.1.7.dev2__py3-none-any.whl

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/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/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/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/indexes/venv_utils.py

@@ -1,3 +1,4 @@
+import asyncio
 import hashlib
 import inspect
 import json
@@ -104,16 +105,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 +225,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 +305,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
+            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 +372,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 +388,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 +409,131 @@ def run_remote_tool(
     listener.listen(1)
     _, port = listener.getsockname()
 
-    def handle_connection():
+    result_data = {}
+
+    def handle_connection_sync():
         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:
+                        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"):
+                        return
+
+    async def handle_connection_async():
+        loop = asyncio.get_running_loop()
+        conn, _ = await loop.sock_accept(listener)
+        conn.setblocking(False)
+        buffer = ""
+        try:
+            while True:
+                chunk = await loop.sock_recv(conn, 4096)
+                if not chunk:
+                    break
+                buffer += chunk.decode("utf-8")
+                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:
+                        yield msg["stream"]
+                    elif msg.get("ok") and "result" in msg:
+                        yield msg["result"]
+                    elif "error" in msg:
+                        raise RuntimeError(f"Subprocess error:\n{msg['error']}")
+                    elif msg.get("done"):
+                        return
+        finally:
+            conn.close()
+
+    if not stream:
+        thread = threading.Thread(target=lambda: list(handle_connection_sync()))
+        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)
+        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({tool_name}(*args, **kwargs))
+        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(
+
+    proc = subprocess.Popen(
         [get_python_command(Path(index_folder) / venv), "-c", runner],
-        input=payload,
-        capture_output=True,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
         env=env_var or None,
     )
-
-    t.join()
-    response = json.loads(result_data["data"].decode("utf-8"))
-    if response.get("ok"):
-        return response["result"]
+    proc.stdin.write(payload)
+    proc.stdin.close()
+
+    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_async()

{stores-0.1.6.dist-info → stores-0.1.7.dev2.dist-info}/METADATA

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

stores-0.1.7.dev2.dist-info/RECORD

@@ -0,0 +1,15 @@
+stores/__init__.py,sha256=KYpKkNrMLx6ssVUbxHnn9wFBq5F5KnaFchcimIfDf9g,186
+stores/constants.py,sha256=7WqFmoGCtmUKHA5WHxOJvvK7g-yYu_KGoqnuVFADNao,57
+stores/format.py,sha256=LduYBVDiUDB1J1HDyu9jHrRG1V97pw6C5g76OirpJJY,7792
+stores/parse.py,sha256=HYPNPzQod2vpu1Cln7yQ8aVkZT1Mw2IN0sZ2A1DIaqE,4967
+stores/utils.py,sha256=GPWT6lCoGobwP3PlEOHyJfKyd0dobamjyErcR7lgm7M,242
+stores/indexes/__init__.py,sha256=s-RNqml8uGREQhxwSdDoxcbcxeD8soB9BcL5dBKsQfI,215
+stores/indexes/base_index.py,sha256=YrEwETZ5eXj3rXK5qxOllRXqFifQoteYdzPAasbvEyg,15536
+stores/indexes/index.py,sha256=Cub5mtnYGipHfPR8BexJYRSKfuJmcGPp0B3ou2bGNqs,2901
+stores/indexes/local_index.py,sha256=Gg9LkEo1L0_NZZYPItsF_-1y6nFP369C3QlPvPyvPx8,3708
+stores/indexes/remote_index.py,sha256=-GV4l2c7GL6_bcVOQnSK5rzYru237bwC5L6eiO-QFzM,3438
+stores/indexes/venv_utils.py,sha256=tS2ZYt2Cf7rqHxBXwn5EoEdUFjyaAIXVRiy8iXjCMb4,17397
+stores-0.1.7.dev2.dist-info/METADATA,sha256=AciMTIC_8qRvud2y3guHn78X-F_n5j-rlCOUNeFLBAc,3081
+stores-0.1.7.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+stores-0.1.7.dev2.dist-info/licenses/LICENSE,sha256=VTidYE7_Dam0Dwyq095EhhDIqi47g03oVpLAHQgKws0,1066
+stores-0.1.7.dev2.dist-info/RECORD,,

stores-0.1.6.dist-info/RECORD

@@ -1,15 +0,0 @@
-stores/__init__.py,sha256=KYpKkNrMLx6ssVUbxHnn9wFBq5F5KnaFchcimIfDf9g,186
-stores/constants.py,sha256=7WqFmoGCtmUKHA5WHxOJvvK7g-yYu_KGoqnuVFADNao,57
-stores/format.py,sha256=LduYBVDiUDB1J1HDyu9jHrRG1V97pw6C5g76OirpJJY,7792
-stores/parse.py,sha256=HYPNPzQod2vpu1Cln7yQ8aVkZT1Mw2IN0sZ2A1DIaqE,4967
-stores/utils.py,sha256=GPWT6lCoGobwP3PlEOHyJfKyd0dobamjyErcR7lgm7M,242
-stores/indexes/__init__.py,sha256=s-RNqml8uGREQhxwSdDoxcbcxeD8soB9BcL5dBKsQfI,215
-stores/indexes/base_index.py,sha256=U12ZuvyuHSZJGdVdTMakdz6yHJQ1No0wOY45W5FoN0s,11073
-stores/indexes/index.py,sha256=C3i5JAwYoKEK7jIJRAgnLrQxjeewtInKcMinep6yvyA,2432
-stores/indexes/local_index.py,sha256=TVk7W8BXF5KEqjEK0LYqq3CtLMfHaF-Tk_5cZ6bjsBU,3189
-stores/indexes/remote_index.py,sha256=CHa9kQVDQlgI8qw3XQXchrE1cjXJk9fNY2j2HWL2gio,3226
-stores/indexes/venv_utils.py,sha256=2D0VasFfjwzEu_-LEyXREDN-SkWHGzx5TImvMpuKbjU,13313
-stores-0.1.6.dist-info/METADATA,sha256=u3ytaMMFLUQCgij7JRgstw-RRyAqlrsp4wXF2-55i8g,3076
-stores-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-stores-0.1.6.dist-info/licenses/LICENSE,sha256=VTidYE7_Dam0Dwyq095EhhDIqi47g03oVpLAHQgKws0,1066
-stores-0.1.6.dist-info/RECORD,,