indexify 0.0.42__py3-none-any.whl → 0.2__py3-none-any.whl

indexify/local_client.py

@@ -0,0 +1,183 @@
+from collections import defaultdict
+from queue import deque
+from typing import Any, Dict, List, Optional, Type, Union
+
+from nanoid import generate
+from pydantic import BaseModel, Json
+from rich import print
+
+from indexify.base_client import IndexifyClient
+from indexify.functions_sdk.data_objects import (
+    File,
+    IndexifyData,
+    RouterOutput,
+)
+from indexify.functions_sdk.graph import Graph
+from indexify.functions_sdk.local_cache import CacheAwareFunctionWrapper
+from indexify.functions_sdk.object_serializer import get_serializer
+
+
+# Holds the outputs of a
+class ContentTree(BaseModel):
+    id: str
+    outputs: Dict[str, List[IndexifyData]]
+
+
+class LocalClient(IndexifyClient):
+    def __init__(self, cache_dir: str = "./indexify_local_runner_cache"):
+        self._cache_dir = cache_dir
+        self._graphs: Dict[str, Graph] = {}
+        self._results: Dict[str, Dict[str, List[IndexifyData]]] = {}
+        self._cache = CacheAwareFunctionWrapper(self._cache_dir)
+        self._accumulators: Dict[str, Dict[str, IndexifyData]] = {}
+
+    def register_compute_graph(self, graph: Graph):
+        self._graphs[graph.name] = graph
+
+    def run_from_serialized_code(self, code: bytes, **kwargs):
+        g = Graph.deserialize(graph=code)
+        self.run(g, **kwargs)
+
+    def run(self, g: Graph, **kwargs):
+        serializer = get_serializer(
+            g.get_function(g._start_node).indexify_function.payload_encoder
+        )
+        input = IndexifyData(id=generate(), payload=serializer.serialize(kwargs))
+        print(f"[bold] Invoking {g._start_node}[/bold]")
+        outputs = defaultdict(list)
+        for k, v in g.get_accumulators().items():
+            serializer = get_serializer(
+                g.get_function(k).indexify_function.payload_encoder
+            )
+            self._accumulators[k] = IndexifyData(payload=serializer.deserialize(v))
+        self._results[input.id] = outputs
+        self._run(g, input, outputs)
+        return input.id
+
+    def _run(
+        self,
+        g: Graph,
+        initial_input: bytes,
+        outputs: Dict[str, List[bytes]],
+    ):
+        queue = deque([(g._start_node, initial_input)])
+        while queue:
+            node_name, input = queue.popleft()
+            serializer = get_serializer(
+                g.get_function(node_name).indexify_function.payload_encoder
+            )
+            input_bytes = serializer.serialize(input)
+            cached_output_bytes: Optional[bytes] = self._cache.get(
+                g.name, node_name, input_bytes
+            )
+            if cached_output_bytes is not None:
+                print(
+                    f"ran {node_name}: num outputs: {len(cached_output_bytes)} (cache hit)"
+                )
+                function_outputs: List[IndexifyData] = []
+                cached_output_list = serializer.deserialize_list(cached_output_bytes)
+                if self._accumulators.get(node_name, None) is not None:
+                    self._accumulators[node_name] = cached_output_list[-1].model_copy()
+                    outputs[node_name] = []
+                function_outputs.extend(cached_output_list)
+                outputs[node_name].extend(cached_output_list)
+            else:
+                function_outputs: List[IndexifyData] = g.invoke_fn_ser(
+                    node_name, input, self._accumulators.get(node_name, None)
+                )
+                print(f"ran {node_name}: num outputs: {len(function_outputs)}")
+                if self._accumulators.get(node_name, None) is not None:
+                    self._accumulators[node_name] = function_outputs[-1].model_copy()
+                    outputs[node_name] = []
+                outputs[node_name].extend(function_outputs)
+                function_outputs_bytes: List[bytes] = [
+                    serializer.serialize_list(function_outputs)
+                ]
+                self._cache.set(
+                    g.name,
+                    node_name,
+                    input_bytes,
+                    function_outputs_bytes,
+                )
+            if self._accumulators.get(node_name, None) is not None and queue:
+                print(
+                    f"accumulator not none for {node_name}, continuing, len queue: {len(queue)}"
+                )
+                continue
+
+            out_edges = g.edges.get(node_name, [])
+            # Figure out if there are any routers for this node
+            for i, edge in enumerate(out_edges):
+                if edge in g.routers:
+                    out_edges.remove(edge)
+                    for output in function_outputs:
+                        dynamic_edges = self._route(g, edge, output) or []
+                        for dynamic_edge in dynamic_edges.edges:
+                            if dynamic_edge in g.nodes:
+                                print(
+                                    f"[bold]dynamic router returned node: {dynamic_edge}[/bold]"
+                                )
+                                out_edges.append(dynamic_edge)
+            for out_edge in out_edges:
+                for output in function_outputs:
+                    queue.append((out_edge, output))
+
+    def _route(
+        self, g: Graph, node_name: str, input: IndexifyData
+    ) -> Optional[RouterOutput]:
+        return g.invoke_router(node_name, input)
+
+    def graphs(self) -> str:
+        return list(self._graphs.keys())
+
+    def namespaces(self) -> str:
+        return "local"
+
+    def create_namespace(self, namespace: str):
+        pass
+
+    def rerun_graph(self, graph: str):
+        return super().rerun_graph(graph)
+
+    def invoke_graph_with_object(
+        self, graph: str, block_until_done: bool = False, **kwargs
+    ) -> str:
+        graph: Graph = self._graphs[graph]
+        return self.run(graph, **kwargs)
+
+    def invoke_graph_with_file(
+        self,
+        graph: str,
+        path: str,
+        metadata: Optional[Dict[str, Json]] = None,
+        block_until_done: bool = False,
+    ) -> str:
+        graph = self._graphs[graph]
+        with open(path, "rb") as f:
+            data = f.read()
+            file = File(data=data, metadata=metadata).model_dump()
+        return self.run(graph, file=file)
+
+    def graph_outputs(
+        self,
+        graph: str,
+        invocation_id: str,
+        fn_name: str,
+    ) -> Union[Dict[str, List[Any]], List[Any]]:
+        if invocation_id not in self._results:
+            raise ValueError(f"no results found for graph {graph}")
+        if fn_name not in self._results[invocation_id]:
+            raise ValueError(f"no results found for fn {fn_name} on graph {graph}")
+        results = []
+        fn_model = self._graphs[graph].get_function(fn_name).get_output_model()
+        serializer = get_serializer(
+            self._graphs[graph].get_function(fn_name).indexify_function.payload_encoder
+        )
+        for result in self._results[invocation_id][fn_name]:
+            payload_dict = serializer.deserialize(result.payload)
+            if issubclass(fn_model, BaseModel) and isinstance(payload_dict, dict):
+                payload = fn_model.model_validate(payload_dict)
+            else:
+                payload = payload_dict
+            results.append(payload)
+        return results

indexify/remote_client.py

@@ -0,0 +1,319 @@
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import cloudpickle
+import httpx
+import msgpack
+import yaml
+from httpx_sse import connect_sse
+from pydantic import BaseModel, Json
+from rich import print
+
+from indexify.base_client import IndexifyClient
+from indexify.error import ApiException
+from indexify.functions_sdk.data_objects import IndexifyData
+from indexify.functions_sdk.graph import ComputeGraphMetadata, Graph
+from indexify.settings import DEFAULT_SERVICE_URL, DEFAULT_SERVICE_URL_HTTPS
+
+
+class InvocationEventPayload(BaseModel):
+    invocation_id: str
+    fn_name: str
+    task_id: str
+    executor_id: Optional[str] = None
+    outcome: Optional[str] = None
+
+
+class InvocationEvent(BaseModel):
+    event_name: str
+    payload: InvocationEventPayload
+
+
+class GraphOutputMetadata(BaseModel):
+    id: str
+    compute_fn: str
+
+
+class GraphOutputs(BaseModel):
+    outputs: List[GraphOutputMetadata]
+
+
+class RemoteClient(IndexifyClient):
+    def __init__(
+        self,
+        service_url: str = DEFAULT_SERVICE_URL,
+        config_path: Optional[str] = None,
+        namespace: str = "default",
+        **kwargs,
+    ):
+        if os.environ.get("INDEXIFY_URL"):
+            print("Using INDEXIFY_URL environment variable to connect to Indexify")
+            service_url = os.environ["INDEXIFY_URL"]
+
+        self.service_url = service_url
+        self._client = httpx.Client()
+        if config_path:
+            with open(config_path, "r") as file:
+                config = yaml.safe_load(file)
+
+            if config.get("use_tls", False):
+                tls_config = config["tls_config"]
+                self._client = httpx.Client(
+                    http2=True,
+                    cert=(tls_config["cert_path"], tls_config["key_path"]),
+                    verify=tls_config.get("ca_bundle_path", True),
+                )
+
+        self.namespace: str = namespace
+        self.compute_graphs: List[Graph] = []
+        self.labels: dict = {}
+        self._service_url = service_url
+        self._timeout = kwargs.get("timeout")
+        self._graphs: Dict[str, Graph] = {}
+
+    def _request(self, method: str, **kwargs) -> httpx.Response:
+        try:
+            response = self._client.request(method, timeout=self._timeout, **kwargs)
+            status_code = str(response.status_code)
+            if status_code.startswith("4"):
+                raise ApiException(
+                    "status code: " + status_code + " request args: " + str(kwargs)
+                )
+            if status_code.startswith("5"):
+                raise ApiException(response.text)
+        except httpx.ConnectError:
+            message = (
+                f"Make sure the server is running and accesible at {self._service_url}"
+            )
+            ex = ApiException(status="ConnectionError", message=message)
+            print(ex)
+            raise ex
+        return response
+
+    @classmethod
+    def with_mtls(
+        cls,
+        cert_path: str,
+        key_path: str,
+        ca_bundle_path: Optional[str] = None,
+        service_url: str = DEFAULT_SERVICE_URL_HTTPS,
+        *args,
+        **kwargs,
+    ) -> "RemoteClient":
+        """
+        Create a client with mutual TLS authentication. Also enables HTTP/2,
+        which is required for mTLS.
+        NOTE: mTLS must be enabled on the Indexify service for this to work.
+
+        :param cert_path: Path to the client certificate. Resolution handled by httpx.
+        :param key_path: Path to the client key. Resolution handled by httpx.
+        :param args: Arguments to pass to the httpx.Client constructor
+        :param kwargs: Keyword arguments to pass to the httpx.Client constructor
+        :return: A client with mTLS authentication
+
+        Example usage:
+        ```
+        from indexify import IndexifyClient
+
+        client = IndexifyClient.with_mtls(
+            cert_path="/path/to/cert.pem",
+            key_path="/path/to/key.pem",
+        )
+        assert client.heartbeat() == True
+        ```
+        """
+        if not (cert_path and key_path):
+            raise ValueError("Both cert and key must be provided for mTLS")
+
+        client_certs = (cert_path, key_path)
+        verify_option = ca_bundle_path if ca_bundle_path else True
+        client = RemoteClient(
+            *args,
+            **kwargs,
+            service_url=service_url,
+            http2=True,
+            cert=client_certs,
+            verify=verify_option,
+        )
+        return client
+
+    def _get(self, endpoint: str, **kwargs) -> httpx.Response:
+        return self._request("GET", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def _post(self, endpoint: str, **kwargs) -> httpx.Response:
+        return self._request("POST", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def _put(self, endpoint: str, **kwargs) -> httpx.Response:
+        return self._request("PUT", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def _delete(self, endpoint: str, **kwargs) -> httpx.Response:
+        return self._request("DELETE", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def _close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def register_compute_graph(self, graph: Graph):
+        graph_metadata = graph.definition()
+        serialized_code = graph.serialize()
+        response = self._post(
+            f"namespaces/{self.namespace}/compute_graphs",
+            files={"code": serialized_code},
+            data={"compute_graph": graph_metadata.model_dump_json(exclude_none=True)},
+        )
+        print(response.content.decode("utf-8"))
+        response.raise_for_status()
+        self._graphs[graph.name] = graph
+
+    def graphs(self) -> List[str]:
+        response = self._get(f"graphs")
+        return response.json()["graphs"]
+
+    def graph(self, name: str) -> ComputeGraphMetadata:
+        response = self._get(f"namespaces/{self.namespace}/compute_graphs/{name}")
+        return ComputeGraphMetadata(**response.json())
+
+    def load_graph(self, name: str) -> Graph:
+        response = self._get(
+            f"internal/namespaces/{self.namespace}/compute_graphs/{name}/code"
+        )
+        return Graph.deserialize(response.content)
+
+    def namespaces(self) -> List[str]:
+        response = self._get(f"namespaces")
+        namespaces_dict = response.json()["namespaces"]
+        namespaces = []
+        for item in namespaces_dict:
+            namespaces.append(item["name"])
+        return namespaces
+
+    def create_namespace(self, namespace: str):
+        self._post("namespaces", json={"namespace": namespace})
+
+    def logs(
+        self, invocation_id: str, cg_name: str, fn_name: str, file: str
+    ) -> Optional[str]:
+        try:
+            response = self._get(
+                f"namespaces/{self.namespace}/compute_graphs/{cg_name}/invocations/{invocation_id}/fn/{fn_name}/logs/{file}"
+            )
+            response.raise_for_status()
+            return response.content.decode("utf-8")
+        except ApiException as e:
+            print(f"failed to fetch logs: {e}")
+            return None
+
+    def rerun_graph(self, graph: str):
+        self._post(f"namespaces/{self.namespace}/compute_graphs/{graph}/rerun")
+
+    def invoke_graph_with_object(
+        self, graph: str, block_until_done: bool = False, **kwargs
+    ) -> str:
+        ser_input = cloudpickle.dumps(kwargs)
+        params = {"block_until_finish": block_until_done}
+        with httpx.Client() as client:
+            with connect_sse(
+                client,
+                "POST",
+                f"{self.service_url}/namespaces/{self.namespace}/compute_graphs/{graph}/invoke_object",
+                headers={"Content-Type": "application/cbor"},
+                data=ser_input,
+                params=params,
+            ) as event_source:
+                for sse in event_source.iter_sse():
+                    obj = json.loads(sse.data)
+                    for k, v in obj.items():
+                        if k == "InvocationFinished":
+                            return v["id"]
+                        event_payload = InvocationEventPayload.model_validate(v)
+                        event = InvocationEvent(event_name=k, payload=event_payload)
+                        if (
+                            event.event_name == "TaskCompleted"
+                            and event.payload.outcome == "Failure"
+                        ):
+                            stdout = self.logs(
+                                event.payload.invocation_id,
+                                graph,
+                                event.payload.fn_name,
+                                "stdout",
+                            )
+                            stderr = self.logs(
+                                event.payload.invocation_id,
+                                graph,
+                                event.payload.fn_name,
+                                "stderr",
+                            )
+                            if stdout:
+                                print(f"[bold red]stdout[/bold red]: \n {stdout}")
+                            if stderr:
+                                print(f"[bold red]stderr[/bold red]: \n {stderr}")
+                        print(
+                            f"[bold green]{event.event_name}[/bold green]: {event.payload}"
+                        )
+        raise Exception("invocation ID not returned")
+
+    def _download_output(
+        self,
+        namespace: str,
+        graph: str,
+        invocation_id: str,
+        fn_name: str,
+        output_id: str,
+    ) -> IndexifyData:
+        response = self._get(
+            f"namespaces/{namespace}/compute_graphs/{graph}/invocations/{invocation_id}/fn/{fn_name}/{output_id}",
+        )
+        response.raise_for_status()
+        data_dict = msgpack.unpackb(response.content)
+        return IndexifyData.model_validate(data_dict)
+
+    def graph_outputs(
+        self,
+        graph: str,
+        invocation_id: str,
+        fn_name: Optional[str],
+    ) -> List[Any]:
+        """
+        Returns the extracted objects by a graph for an ingested object. If the extractor name is provided, only the objects extracted by that extractor are returned.
+        If the extractor name is not provided, all the extracted objects are returned for the input object.
+        graph: str: The name of the graph
+        invocation_id: str: The ID of the ingested object
+        extractor_name: Optional[str]: The name of the extractor whose output is to be returned if provided
+        block_until_done: bool = True: If True, the method will block until the extraction is done. If False, the method will return immediately.
+        return: Union[Dict[str, List[Any]], List[Any]]: The extracted objects. If the extractor name is provided, the output is a list of extracted objects by the extractor. If the extractor name is not provided, the output is a dictionary with the extractor name as the key and the extracted objects as the value. If no objects are found, an empty list is returned.
+        """
+        if graph not in self._graphs:
+            self._graphs[graph] = self.load_graph(graph)
+        response = self._get(
+            f"namespaces/{self.namespace}/compute_graphs/{graph}/invocations/{invocation_id}/outputs",
+        )
+        response.raise_for_status()
+        graph_outputs = GraphOutputs(**response.json())
+        outputs = []
+        for output in graph_outputs.outputs:
+            if output.compute_fn == fn_name:
+                indexify_data = self._download_output(
+                    self.namespace, graph, invocation_id, fn_name, output.id
+                )
+                output = self._graphs[graph].deserialize_fn_output(
+                    fn_name, indexify_data
+                )
+                outputs.append(output)
+        return outputs
+
+    def invoke_graph_with_file(
+        self, graph: str, path: str, metadata: Optional[Dict[str, Json]] = None
+    ) -> str:
+        """
+        Invokes a graph with an input file. The file's mimetype is appropriately detected.
+        graph: str: The name of the graph to invoke
+        path: str: The path to the file to be ingested
+        return: str: The ID of the ingested object
+        """
+        pass

indexify-0.2.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: indexify
+Version: 0.2
+Summary: Python Client for Indexify
+Home-page: https://github.com/tensorlakeai/indexify
+License: Apache 2.0
+Author: Tensorlake Inc.
+Author-email: support@tensorlake.ai
+Requires-Python: >=3.9,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cloudpickle (>=3,<4)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
+Requires-Dist: httpx[http2] (>=0,<1)
+Requires-Dist: msgpack (>=1.1.0,<2.0.0)
+Requires-Dist: nanoid (>=2.0.0,<3.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: pyyaml (>=6,<7)
+Requires-Dist: rich (>=13,<14)
+Requires-Dist: typer (>=0.12.5,<0.13.0)
+Project-URL: Repository, https://github.com/tensorlakeai/indexify
+Description-Content-Type: text/markdown
+
+# Indexify Python SDK
+
+[![PyPI version](https://badge.fury.io/py/indexify.svg)](https://badge.fury.io/py/indexify)
+[![Discord](https://dcbadge.vercel.app/api/server/VXkY7zVmTD?style=flat&compact=true)](https://discord.gg/VXkY7zVmTD)
+
+This is the Python SDK to build real-time continuously running unstructured data processing pipelines with Indexify.
+
+Start by writing and testing your pipelines locally using your data, then deploy them into the Indexify service to process data in real-time at scale.
+
+## Installation
+
+```shell
+pip install indexify
+```
+
+## Examples 
+**[PDF Document Extraction](./examples/pdf_document_extraction/workflow.py)**
+1. Extracts text, tables and images from an ingested PDF file
+2. Indexes the text using MiniLM-L6-v2, the images with CLIP
+3. Writes the results into a vector database.
+
+**[Youtube Transcription Summarizer](./examples/video_summarization/workflow.py)**
+1. Downloads Youtube Video
+2. Extracts audio from the video and transcribes using `Faster Whisper` 
+3. Uses Llama 3.1 backed by `Llama.cpp` to understand and classify the nature of the video.
+4. Routes the transcription dynamically to one of the transcription summarizer to retain specific summarization attributes.
+5. Finally the entire transcription is embedded and stored in a vector database for retrieval.
+
+## Quick Start
+1. Write data processing functions in Python and use Pydantic objects for returning complex data types from functions
+2. Connect functions using a graph interface. Indexify automatically stores function outputs and passes them along to downstream functions. 
+3. If a function returns a list, the downstream functions will be called with each item in the list in **parallel**.
+4. The input of the first function becomes the input to the HTTP endpoint of the Graph.
+
+## Functional Features
+1. There is **NO** limit to volume of data being ingested since we use blob stores for storing metadata and objects
+2. The server can handle 10s of 1000s of files being ingested into the graphs in parallel. 
+3. The scheduler reacts under 8 microseconds to ingestion events, so it's suitable for workflows which needs to run in realtime.
+4. Batch ingestion is handled gracefully by batching ingested data and scheduling for high throughput in production settings.
+
+```python
+from pydantic import BaseModel
+from indexify import indexify_function
+from typing import Dict, Any, Optional, List
+
+# Define function inputs and outputs
+class Document(BaseModel):
+    text: str
+    metadata: Dict[str, Any]
+
+class TextChunk(BaseModel):
+    text: str
+    metadata: Dict[str, Any]
+    embedding: Optional[List[float]] = None
+
+
+# Decorate a function which is going to be part of your data processing graph
+@indexify_function()
+def split_text(doc: Document) -> List[TextChunk]:
+    midpoint = len(doc.text) // 2
+    first_half = TextChunk(text=doc.text[:midpoint], metadata=doc.metadata)
+    second_half = TextChunk(text=doc.text[midpoint:], metadata=doc.metadata)
+    return [first_half, second_half]
+
+# Any requirements specified is automatically installed in production clusters
+@indexify_function(requirements=["langchain_text_splitter"])
+def compute_embedding(chunk: TextChunk) -> TextChunk:
+    chunk.embedding = [0.1, 0.2, 0.3]
+    return chunk
+
+# You can constrain functions to run on specific executors 
+@indexify_function(executor_runtime_name="postgres-driver-image")
+def write_to_db(chunk: TextChunk):
+    # Write to your favorite vector database
+    ...
+
+## Create a graph
+from indexify import Graph
+
+g = Graph(name="my_graph", start_node=split_text)
+g.add_edge(split_text, compute_embedding)
+g.add_edge(embed_text, write_to_db)
+```
+
+## Graph Execution
+Every time the Graph is invoked, Indexify will provide an `Invocation Id` which can be used to know about the status of the processing and any outputs from the Graph.
+
+## Run the Graph Locally
+```python
+from indexify import IndexifyClient
+
+client = IndexifyClient(local=True)
+client.register_graph(g)
+invocation_id = client.invoke_graph_with_object(g.name, Document(text="Hello, world!", metadata={"source": "test"}))
+graph_outputs = client.graph_outputs(g.name, invocation_id)
+```
+
+## Deploy the Graph to Indexify Server for Production
+> Work In Progress - The version of server that works with python based graphs haven't been released yet. It will be shortly released. Join discord for development updates. 
+```python
+from indexify import IndexifyClient
+
+client = IndexifyClient(service_url="http://localhost:8900")
+client.register_graph(g)
+```
+
+#### Ingestion into the Service
+Extraction Graphs continuously run on the Indexify Service like any other web service. Indexify Server runs the extraction graphs in parallel and in real-time when new data is ingested into the service.
+
+```python
+output_id = client.invoke_graph_with_object(g.name, Document(text="Hello, world!", metadata={"source": "test"}))
+```
+
+#### Retrieve Graph Outputs for a given ingestion object
+```python
+graph_outputs = client.graph_outputs(g.name, output_id)
+```
+
+#### Retrieve All Graph Inputs 
+```python
+graph_inputs = client.graph_inputs(g.name)
+```
+

indexify-0.2.dist-info/RECORD

@@ -0,0 +1,32 @@
+indexify/__init__.py,sha256=fD9E-i9gawBNwbMd8ZIfiNsxUtL1S5VBCiyvKU5Yslc,497
+indexify/base_client.py,sha256=Si1XnZ6X_mFvkYCnS6qx6axFsBpkrGiorqmKohFwvLQ,3324
+indexify/cli.py,sha256=XZYU9iMVHqNzecMU6LdAyfa_JkHb0Xx35akaW319tTI,7091
+indexify/client.py,sha256=sopeSA9hc7QHIHdpGq5rehSkr0tiPvdsLSJsaVzw3kY,491
+indexify/data_loaders/__init__.py,sha256=Y5NEuseTcYAICRiweYw5wBQ2m2YplbsY21I7df-rdi4,1339
+indexify/data_loaders/local_directory_loader.py,sha256=fCrgj5drnW71ZUdDDvcB1-VJjIs1w6Q8sEW0HSGSAiA,1247
+indexify/data_loaders/url_loader.py,sha256=32SERljcq1Xsi4RdLz2dgyk2TER5pQPTtXl3gUzwHbY,1533
+indexify/error.py,sha256=vjd5SPPNFIEW35GorSIodsqvm9RKHQm9kdp8t9gv-WM,111
+indexify/executor/agent.py,sha256=RxpmnZ4ne-2BCv6Lv0kkkBJX3Dz71bruvaFC8V3O1D0,14563
+indexify/executor/api_objects.py,sha256=nvRmKYngjrv8sc_GoYM1MSLdFMYB6hoq7XK4LMx2U-s,814
+indexify/executor/downloader.py,sha256=0MPiKw0AWs3Z7ReC9l2z-3515yqq85ghPzdh485dnuw,3998
+indexify/executor/executor_tasks.py,sha256=gAZ2pvza1YwGlaR1o_tJW4SXtdCgK7sLJgp4W7rOjR0,1834
+indexify/executor/function_worker.py,sha256=83ih8TjAJHtrH6LqqDoSfzAj4zB7ZZPR2Voq0RMZ1T8,5410
+indexify/executor/indexify_executor.py,sha256=2Ut_VX-Su_lm4b4aEROyRJ3gXx-uFHA-V7EN0sWiARE,771
+indexify/executor/task_reporter.py,sha256=gnnse0v6rjjni8lNzeb-ZYq6iF2DgafKoT7dcGUZhQ4,3716
+indexify/executor/task_store.py,sha256=q8s2gImsFffWeXQR0mk1Xlo1Aj_2GfclNPjQ2EA_YBo,3984
+indexify/foo,sha256=e385Ws-u8zx-LOq3tdfTa-siK9pMaccdAE8_0rrp_k4,5165
+indexify/functions_sdk/data_objects.py,sha256=2LqAWJ_S2Xkp4OQTmhd3InVIrBs7juV41udnSQFMMfM,840
+indexify/functions_sdk/graph.py,sha256=ilImZsALzOQLwioPYqva0_FxHtrn3FscCmtVniPJecU,9764
+indexify/functions_sdk/graph_validation.py,sha256=UgP_iMlUsH3jO0aBkQOwfxGQV1_x2qx9_iZvSxvuJBo,2419
+indexify/functions_sdk/image.py,sha256=0A8xTjLv0jITRu0u06iCFplS_cu47Zu3fUCXq9Rc7zI,525
+indexify/functions_sdk/indexify_functions.py,sha256=sJclmxvOAiAPUONbcwmUwywsUEzMvMA6gIE6zaURr1s,5955
+indexify/functions_sdk/local_cache.py,sha256=cNWF67zbhbTJe3g86hyLBy3Rqzs6dNvp2SjLazGZWvw,1348
+indexify/functions_sdk/object_serializer.py,sha256=HPH0Ym6-Los8lg_RHxmerrAh5fSLBHDeTZikom0eXxk,1689
+indexify/local_client.py,sha256=9wPYHjG516ZX6q5sPj5Pnn9C-Fi0sghYiLaNMe7LPPk,7220
+indexify/remote_client.py,sha256=oKgTqLbIxQVDqkMjQmNCOOEIM156UeYMC1jDWWSqBAQ,12297
+indexify/settings.py,sha256=LSaWZ0ADIVmUv6o6dHWRC3-Ry5uLbCw2sBSg1e_U7UM,99
+indexify-0.2.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+indexify-0.2.dist-info/METADATA,sha256=GuigbP7vmakmIXhhijeYAiCbhvaFZX-Np2gZAcHYwrc,6127
+indexify-0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+indexify-0.2.dist-info/entry_points.txt,sha256=Pih7WV-XMpAzI5dEvROcpLr-ybVhd9Y-AtuzBKUdcDs,49
+indexify-0.2.dist-info/RECORD,,

indexify-0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+indexify-cli=indexify.cli:app
+