indexify 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

indexify/__init__.py

@@ -1,14 +1,12 @@
 from .index import Index
 from .client import IndexifyClient
-from .repository import Repository, Filter, FilterBuilder
+from .extractor_binding import ExtractorBinding
 from .data_containers import TextChunk
 from .settings import DEFAULT_SERVICE_URL
 
 __all__ = [
-    "Filter",
-    "FilterBuilder",
     "Index",
     "IndexifyClient",
-    "Repository",
+    "ExtractorBinding",
     "DEFAULT_SERVICE_URL",
 ]

indexify/client.py

@@ -1,9 +1,17 @@
 import httpx
-from .repository import Repository
+import json
+from collections import namedtuple
 from .settings import DEFAULT_SERVICE_URL
 from .extractor import Extractor
+from .extractor_binding import ExtractorBinding
+from .index import Index
+from .utils import json_set_default
+from .data_containers import TextChunk
+from indexify.exceptions import ApiException
 
-from typing import List, Optional
+from typing import List, Optional, Union
+
+Document = namedtuple("Document", ["text", "labels"])
 
 
 class IndexifyClient:
@@ -24,17 +32,38 @@ class IndexifyClient:
     assert client.heartbeat() == True
     ```
     """
-    def __init__(self,
-                 service_url: str = DEFAULT_SERVICE_URL,
-                 *args,
-                 **kwargs
-                 ):
+
+    def __init__(
+        self,
+        service_url: str = DEFAULT_SERVICE_URL,
+        namespace: str = "default",
+        *args,
+        **kwargs,
+    ):
+        self.namespace: str = namespace
+        self.extractor_bindings: List[ExtractorBinding] = []
+        self.labels: dict = {}
         self._service_url = service_url
         self._client = httpx.Client(*args, **kwargs)
 
+        # get namespace data
+        response = self.get(f"namespaces/{self.namespace}")
+        response.raise_for_status()
+        resp_json = response.json()
+        # initialize extractor_bindings
+        for eb in resp_json["namespace"]["extractor_bindings"]:
+            self.extractor_bindings.append(ExtractorBinding.from_dict(eb))
+
     @classmethod
-    def with_mtls(cls, cert_path: str, key_path: str, ca_bundle_path: Optional[str] = None,
-                 service_url: str = DEFAULT_SERVICE_URL, *args, **kwargs) -> "IndexifyClient":
+    def with_mtls(
+        cls,
+        cert_path: str,
+        key_path: str,
+        ca_bundle_path: Optional[str] = None,
+        service_url: str = DEFAULT_SERVICE_URL,
+        *args,
+        **kwargs,
+    ) -> "IndexifyClient":
         """
         Create a client with mutual TLS authentication. Also enables HTTP/2,
         which is required for mTLS.
@@ -62,12 +91,23 @@ class IndexifyClient:
 
         client_certs = (cert_path, key_path)
         verify_option = ca_bundle_path if ca_bundle_path else True
-        client = IndexifyClient(*args, **kwargs, service_url=service_url, http2=True, cert=client_certs, verify=verify_option)
+        client = IndexifyClient(
+            *args,
+            **kwargs,
+            service_url=service_url,
+            http2=True,
+            cert=client_certs,
+            verify=verify_option,
+        )
         return client
 
     def _request(self, method: str, **kwargs) -> httpx.Response:
         response = self._client.request(method, **kwargs)
-        response.raise_for_status()
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            print(f"exception: {exc}, response text: {response.text}")
+            raise exc
         return response
 
     def get(self, endpoint: str, **kwargs) -> httpx.Response:
@@ -81,7 +121,7 @@ class IndexifyClient:
         from indexify import IndexifyClient
 
         client = IndexifyClient()
-        response = client.get("repositories")
+        response = client.get("namespaces")
         print(response.json())
         ```
         """
@@ -99,7 +139,7 @@ class IndexifyClient:
         from indexify import IndexifyClient
 
         client = IndexifyClient()
-        response = client.post("repositories", json={"name": "my-repo"})
+        response = client.post("namespaces", json={"name": "my-repo"})
         print(response.json())
         ```
         """
@@ -134,40 +174,63 @@ class IndexifyClient:
         # Server responds with text: "Indexify Server"
         return response.text == heartbeat_response
 
-    def repositories(self) -> list[Repository]:
+    def namespaces(self) -> list[str]:
         """
-        Get a list of all repositories.
+        Get a list of all namespaces.
         """
-        response = self.get(f"repositories")
-        repositories_dict = response.json()["repositories"]
-        repositories = []
-        for rd in repositories_dict:
-            repositories.append(Repository(rd["name"], self._service_url))
-        return repositories
+        response = self.get(f"namespaces")
+        namespaces_dict = response.json()["namespaces"]
+        namespaces = []
+        for item in namespaces_dict:
+            namespaces.append(item["name"])
+        return namespaces
 
-    def create_repository(
-        self, name: str, extractor_bindings: list = [], metadata: dict = {}
-    ) -> Repository:
+    @classmethod
+    def create_namespace(
+        self,
+        namespace: str,
+        extractor_bindings: list = [],
+        labels: dict = {},
+    ) -> "IndexifyClient":
         """
-        Create a new repository.
+        Create a new namespace.
+
+        Returns:
+            IndexifyClient: a new client with the given namespace
         """
+        bindings = []
+        for bd in extractor_bindings:
+            if isinstance(bd, ExtractorBinding):
+                bindings.append(bd.to_dict())
+            else:
+                bindings.append(bd)
         req = {
-            "name": name,
-            "extractor_bindings": extractor_bindings,
-            "metadata": metadata,
+            "name": namespace,
+            "extractor_bindings": bindings,
+            "labels": labels,
         }
-        response = self.post(f"repositories", json=req)
-        return Repository(name, self._service_url)
 
-    def get_repository(self, name: str) -> Repository:
+        client = IndexifyClient(namespace=namespace)
+        client.post(f"namespaces", json=req)
+        return client
+
+    def indexes(self) -> List[Index]:
         """
-        Get a repository by name.
+        Get the indexes of the current namespace.
+
+        Returns:
+            List[Index]: list of indexes in the current namespace
         """
-        return Repository(name, self._service_url)
+        response = self.get(f"namespaces/{self.namespace}/indexes")
+        response.raise_for_status()
+        return response.json()["indexes"]
 
     def extractors(self) -> List[Extractor]:
         """
         Get a list of all extractors.
+
+        Returns:
+            List[Extractor]: list of extractors
         """
         response = self.get(f"extractors")
         extractors_dict = response.json()["extractors"]
@@ -176,3 +239,168 @@ class IndexifyClient:
             extractors.append(Extractor.from_dict(ed))
         return extractors
 
+    def get_extractor_bindings(self):
+        """
+        Retrieve and update the list of extractor bindings for the current namespace.
+        """
+        response = self.get(f"namespaces/{self.namespace}")
+        response.raise_for_status()
+
+        self.extractor_bindings = []
+        for eb in response.json()["namespace"]["extractor_bindings"]:
+            self.extractor_bindings.append(ExtractorBinding.from_dict(eb))
+        return self.extractor_bindings
+
+    def bind_extractor(
+        self,
+        extractor: str,
+        name: str,
+        input_params: dict = {},
+        labels_eq: str = None,
+    ) -> dict:
+        """Bind an extractor.
+
+        Args:
+            - extractor (str): Name of the extractor
+            - name (str): Name for this instance
+            - input_params (dict): Dictionary containing extractor input params
+            - filter (Filter): Optional filter for this extractor
+
+        Returns:
+            dict: response payload
+
+        Examples:
+            >>> repo.bind_extractor("EfficientNet", "efficientnet")
+
+            >>> repo.bind_extractor("MiniLML6", "minilm")
+
+        """
+        req = {
+            "extractor": extractor,
+            "name": name,
+            "input_params": input_params,
+            "filters_eq": labels_eq,
+        }
+        if req["filters_eq"] == None:
+            del req["filters_eq"]
+
+        request_body = json.dumps(req, default=json_set_default)
+        response = self.post(
+            f"namespaces/{self.namespace}/extractor_bindings",
+            data=request_body,
+            headers={"Content-Type": "application/json"},
+        )
+
+        # update self.extractor_bindings
+        self.get_extractor_bindings()
+
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            raise ApiException(exc.response.text)
+        return
+
+    def get_content(
+        self,
+        parent_id: str = None,
+        labels_eq: str = None,
+    ):
+        """
+        Get list of content from current namespace.
+
+        Args:
+            - parent_id (str): Optional filter for parent id
+            - labels_eq (str): Optional filter for labels
+        """
+        params = {}
+        if parent_id:
+            params.update({"parent_id": parent_id})
+        if labels_eq:
+            params.update({"labels_eq": labels_eq})
+
+        response = self.get(f"namespaces/{self.namespace}/content", params=params)
+        response.raise_for_status()
+        return response.json()["content_list"]
+
+    def add_documents(
+        self, documents: Union[Document, str, List[Union[Document, str]]]
+    ) -> None:
+        """
+        Add documents to current namespace.
+
+        Args:
+            - documents (Union[Document, str, List[Union[Document, str]]]): this can be a list of strings, list of Documents or a mix of both
+        """
+        if isinstance(documents, Document):
+            documents = [documents]
+        elif isinstance(documents, str):
+            documents = [Document(documents, {})]
+        elif isinstance(documents, list):
+            new_documents = []
+            for item in documents:
+                if isinstance(item, Document):
+                    new_documents.append(item)
+                elif isinstance(item, str):
+                    new_documents.append(Document(item, {}))
+                else:
+                    raise ValueError(
+                        "List items must be either Document instances or strings."
+                    )
+            documents = new_documents
+        else:
+            raise TypeError(
+                "Invalid type for documents. Expected Document, str, or list of these."
+            )
+
+        req = {"documents": documents}
+        response = self.post(
+            f"namespaces/{self.namespace}/add_texts",
+            json=req,
+            headers={"Content-Type": "application/json"},
+        )
+        response.raise_for_status()
+
+    def query_metadata(self, index_name: str, content_id: str) -> dict:
+        """
+        Query metadata for a specific content ID in a given index.
+
+        Args:
+            - index_name (str): index to query
+            - content_id (str): content id to query
+        """
+        params = {"index": index_name, "content_id": content_id}
+        response = self.get(f"namespaces/{self.namespace}/metadata", params=params)
+        response.raise_for_status()
+        return response.json()["attributes"]
+
+    def search_index(self, name: str, query: str, top_k: int) -> list[TextChunk]:
+        """
+        Search index in the current namespace.
+
+        Args:
+            - name (str): name of index to search
+            - query (str): query string
+            - top_k (int): top k nearest neighbors to be returned
+        """
+        req = {"index": name, "query": query, "k": top_k}
+        response = self.post(
+            f"namespaces/{self.namespace}/search",
+            json=req,
+            headers={"Content-Type": "application/json"},
+        )
+        response.raise_for_status()
+        return response.json()["results"]
+
+    def upload_file(self, path: str):
+        """
+        Upload a file.
+
+        Args:
+            - path (str): relative path to the file to be uploaded
+        """
+        with open(path, "rb") as f:
+            response = self.post(
+                f"namespaces/{self.namespace}/upload_file",
+                files={"file": f},
+            )
+            response.raise_for_status()

indexify/data_containers.py

@@ -21,6 +21,7 @@ class TextChunk:
     def to_dict(self):
         return {"text": self.text, "metadata": self.metadata}
 
+
 @dataclass
 class SearchChunk:
     index: str

indexify/extractor.py

@@ -1,27 +1,10 @@
-import requests
+import httpx
 from dataclasses import dataclass
 from typing import Union
 
 from .settings import DEFAULT_SERVICE_URL
 
 
-def list_extractors(base_url: str = DEFAULT_SERVICE_URL) -> list[dict]:
-    response = requests.get(f"{base_url}/extractors")
-    response.raise_for_status()
-    return response.json()["extractors"]
-
-
-@dataclass
-class EmbeddingExtractor:
-    dim: int
-    distance: str
-
-
-@dataclass
-class AttributeExtractor:
-    json_schema: str
-
-
 @dataclass
 class EmbeddingSchema:
     distance: str
@@ -38,17 +21,17 @@ class Extractor:
     name: str
     description: str
     input_params: dict
-    schemas: ExtractorSchema
+    outputs: ExtractorSchema
 
 
 class Extractor:
     def __init__(
-        self, name: str, description: str, input_params: dict, schemas: ExtractorSchema
+        self, name: str, description: str, input_params: dict, outputs: ExtractorSchema
     ):
         self.name = name
         self.description = description
         self.input_params = input_params
-        self.schemas = schemas
+        self.outputs = outputs
 
     @classmethod
     def from_dict(cls, data):
@@ -56,11 +39,11 @@ class Extractor:
             name=data["name"],
             description=data["description"],
             input_params=data["input_params"],
-            schemas=data["schemas"],
+            outputs=data["outputs"],
         )
 
     def __repr__(self) -> str:
-        return f"Extractor(name={self.name}, description={self.description})"
+        return f"Extractor(name={self.name}, description={self.description}, input_params={self.input_params}, outputs={self.outputs})"
 
     def __str__(self) -> str:
         return self.__repr__()

indexify/extractor_binding.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+
+@dataclass
+class ExtractorBinding:
+    extractor: str
+    name: str
+    content_source: str
+    input_params: dict
+    labels_eq: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"ExtractorBinding(name={self.name} extractor={self.extractor})"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def to_dict(self) -> dict:
+        filtered_dict = {k: v for k, v in asdict(self).items() if v is not None}
+        return filtered_dict
+
+    @classmethod
+    def from_dict(cls, json: dict):
+        if "filters_eq" in json:
+            json["labels_eq"] = json.pop("filters_eq")
+        return ExtractorBinding(**json)

indexify/index.py

@@ -1,7 +1,8 @@
-import aiohttp
+import httpx
 
 from .data_containers import SearchChunk, TextChunk
 
+
 class Index:
     def __init__(self, service_url, index):
         self._service_url = service_url
@@ -9,8 +10,8 @@ class Index:
 
     def search(self, query: str, top_k: int) -> list[TextChunk]:
         req = {"index": self._index, "query": query, "k": top_k}
-        response = aiohttp.post(
+        response = httpx.post(
             f"{self._service_url}/indexes/{self._index}/search", json=req
         )
         response.raise_for_status()
-        return response.json()["results"]
+        return response.json()["results"]

{indexify-0.0.4.dist-info → indexify-0.0.6.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: indexify
-Version: 0.0.4
+Version: 0.0.6
 Summary: Python Client for Indexify
-Home-page: https://github.com/diptanu/indexify
+Home-page: https://github.com/tensorlakeai/indexify
 License: Apache 2.0
 Author: Diptanu Gon Choudhury
 Author-email: diptanuc@gmail.com
@@ -12,12 +12,15 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: httpx[http2] (>=0.24.1,<0.25.0)
-Project-URL: Repository, https://github.com/diptanu/indexify
+Requires-Dist: httpx[http2] (>=0.26,<0.27)
+Project-URL: Repository, https://github.com/tensorlakeai/indexify
 Description-Content-Type: text/markdown
 
 # Indexify Python Client
 
+
+[![PyPI version](https://badge.fury.io/py/indexify.svg)](https://badge.fury.io/py/indexify)
+
 ## Installation
 
 This is the Python client for interacting with the Indexify service.
@@ -31,10 +34,17 @@ pip install indexify
 ## Usage
 
 See the [getting started](https://getindexify.com/getting_started/) guide for examples of how to use the client.
-Look at the [sdk-py/examples](examples) directory for more examples.
+Look at the [examples](examples) directory for more examples.
 
 ## Development
 
+To install the client from this repository for development:
+
+```shell
+cd "path to this repository"
+pip install -e .
+```
+
 Install and run the `poetry` package manager:
 
 ```shell
@@ -45,21 +55,6 @@ poetry install
 More information at [https://python-poetry.org/docs/](https://python-poetry.org/docs/).
 
 
-### Steps for restarting dev server after updating server code
-
-```shell
-./install_python_deps.sh
-# use `-e`` if you're developing extractors
-(cd extractors && pip install -e .)
-# use `-e`` if you're developing sdk-py
-(cd sdk-py && pip install -e .)
-
-cargo build
-make local-dev
-
-# start the server
-./target/debug/indexify start-server -d -c local_config.yaml
-```
 
 ### Environment Variables
 

indexify-0.0.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+indexify/__init__.py,sha256=rNHNCfTl0zQf--3miNHf1RdXhYs3i446LpBhFYoXjrw,290
+indexify/client.py,sha256=DYFkroiNIZWTTOFcIyAzg8GzWlBBFswCaQ4RNtQGAxU,12828
+indexify/data_containers.py,sha256=--KSx_T5EsoBOemFPKSLVcKtvy3OELgPnLp4kCESHkI,690
+indexify/exceptions.py,sha256=vjd5SPPNFIEW35GorSIodsqvm9RKHQm9kdp8t9gv-WM,111
+indexify/extractor.py,sha256=FPWVd93m4edg4T6vVMl5MGtxsfLi5Vws9n9vLgLCSE8,1130
+indexify/extractor_binding.py,sha256=jVu1lAvstllNz13GxEN-IlLx3XEjzz8QCBk1SsMwsCE,721
+indexify/index.py,sha256=kELxdTnS9ddkEaxqbeZdsbYLEfZ9qi4HiqTPaznOoAo,517
+indexify/settings.py,sha256=yzWAEZkrTjykSMj3hrFU7l_jUoUCOUsgPVW1nU-qzJQ,46
+indexify/utils.py,sha256=wvQB9VpS07iZPOrpmt2i3VIncU6YBkHdpu6rXegDT3Y,282
+indexify-0.0.6.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+indexify-0.0.6.dist-info/METADATA,sha256=f6LGiyItVhg-Rb-r_GDLKY3txqMxJZZaZXr8TPhrrdM,1713
+indexify-0.0.6.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+indexify-0.0.6.dist-info/RECORD,,

indexify/repository.py

@@ -1,196 +0,0 @@
-import httpx
-import json
-
-from dataclasses import dataclass
-from collections import namedtuple
-
-from .data_containers import TextChunk
-from .settings import DEFAULT_SERVICE_URL
-from typing import List
-from .utils import json_set_default
-from indexify.exceptions import ApiException
-from .index import Index
-
-Document = namedtuple("Document", ["text", "metadata"])
-
-
-@dataclass
-class Filter:
-    includes: dict[str, str]
-    excludes: dict[str, str]
-
-    @classmethod
-    def from_dict(cls, json: dict):
-        includes = json.get("eq", {})
-        excludes = json.get("ne", {})
-        return Filter(includes=includes, excludes=excludes)
-
-    def json(self):
-        filters = []
-        for k, v in self.includes.items():
-            filters.append({"eq": {k: v}})
-        for k, v in self.excludes.items():
-            filters.append({"neq": {k: v}})
-        return filters
-
-
-class FilterBuilder:
-    def __init__(self) -> None:
-        self._filter = Filter(includes={}, excludes={})
-
-    def include(self, key: str, value: str) -> "FilterBuilder":
-        self._filter.includes[key] = value
-        return self
-
-    def exclude(self, key: str, value: str) -> "FilterBuilder":
-        self._filter.excludes[key] = value
-        return self
-
-    def build(self) -> Filter:
-        return self._filter
-
-
-@dataclass
-class ExtractorBinding:
-    extractor_name: str
-    index_name: str
-    filters: list[Filter]
-    input_params: dict
-
-    def __repr__(self) -> str:
-        return f"ExtractorBinding(extractor_name={self.extractor_name}, index_name={self.index_name})"
-
-    def __str__(self) -> str:
-        return self.__repr__()
-
-    @classmethod
-    def from_dict(cls, json: dict):
-        filters_dict = json["filters"]
-        filters = []
-        for filter_dict in filters_dict:
-            filters.append(Filter.from_dict(filter_dict))
-        json["filters"] = filters
-        return ExtractorBinding(**json)
-
-
-class Repository:
-    def __init__(
-        self,
-        name: str,
-        service_url: str,
-        extractor_bindings: List[ExtractorBinding] = None,
-        metadata: dict = None,
-    ) -> None:
-        self.name = name
-        self._service_url = service_url
-        self.extractor_bindings = extractor_bindings
-        self.metadata = metadata
-
-    async def run_extractors(self) -> dict:
-        response = httpx.post(f"{self._service_url}/run_extractors")
-        response.raise_for_status()
-
-    def add_documents(self, documents: List[Document]) -> None:
-        if isinstance(documents, Document):
-            documents = [documents]
-        req = {"documents": documents}
-        response = httpx.post(
-            f"{self._service_url}/repositories/{self.name}/add_texts",
-            json=req,
-            headers={"Content-Type": "application/json"},
-        )
-        response.raise_for_status()
-
-    def bind_extractor(
-        self,
-        extractor: str,
-        name: str,
-        input_params: dict = {},
-        filter: Filter = None,
-    ) -> dict:
-        """Bind an extractor to this repository
-
-        Args:
-            - extractor (str): Name of the extractor
-            - name (str): Name for this instance
-            - input_params (dict): Dictionary containing extractor input params
-            - filter (Filter): Optional filter for this extractor
-
-        Returns:
-            dict: response payload
-
-        Examples:
-            >>> repo.bind_extractor("EfficientNet", "efficientnet")
-
-            >>> repo.bind_extractor("MiniLML6", "minilm")
-
-        """
-        req = {
-            "extractor": extractor,
-            "name": name,
-            "input_params": input_params,
-            "filters": filter.json() if filter else [],
-        }
-
-        request_body = json.dumps(req, default=json_set_default)
-        response = httpx.post(
-            f"{self._service_url}/repositories/{self.name}/extractor_bindings",
-            data=request_body,
-            headers={"Content-Type": "application/json"},
-        )
-        try:
-            response.raise_for_status()
-        except httpx.HTTPStatusError as exc:
-            raise ApiException(exc.response.text)
-        return
-
-    def indexes(self) -> List[Index]:
-        response = httpx.get(f"{self._service_url}/repositories/{self.name}/indexes")
-        response.raise_for_status()
-        return response.json()["indexes"]
-
-    @classmethod
-    def get(cls, name: str, service_url: str = DEFAULT_SERVICE_URL) -> "Repository":
-        response = httpx.get(f"{service_url}/repositories/{name}")
-        response.raise_for_status()
-        repository_json = response.json()["repository"]
-        return Repository._from_json(repository_json)
-
-    @classmethod
-    def _from_json(cls, service_url: str, repository_json: dict):
-        extractor_bindings = []
-        for eb in repository_json["repository"]["extractor_bindings"]:
-            extractor_bindings.append(ExtractorBinding.from_dict(eb))
-        metadata = repository_json["repository"]["metadata"]
-        return Repository(
-            name=repository_json["repository"]["name"],
-            service_url=service_url,
-            extractor_bindings=extractor_bindings,
-            metadata=metadata,
-        )
-
-    def query_attribute(self, index_name: str, content_id: str = None) -> dict:
-        params = {"index": index_name}
-        if content_id:
-            params.update({"content_id": content_id})
-        response = httpx.get(
-            f"{self._service_url}/repositories/{self.name}/attributes", params=params
-        )
-        response.raise_for_status()
-        return response.json()["attributes"]
-
-    def search_index(self, name: str, query: str, top_k: int) -> list[TextChunk]:
-        req = {"index": name, "query": query, "k": top_k}
-        response = httpx.post(
-            f"{self._service_url}/repositories/{self.name}/search",
-            json=req,
-            headers={"Content-Type": "application/json"},
-        )
-        response.raise_for_status()
-        return response.json()["results"]
-
-    def __repr__(self) -> str:
-        return f"Repository(name={self.name})"
-
-    def __str__(self) -> str:
-        return self.__repr__()

indexify-0.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-indexify/__init__.py,sha256=0MDmCLdex7F2RXx-2F1lLqTYQl5Gs4tVryA7j4TXCak,329
-indexify/client.py,sha256=8IaX_1KYs-JxXH1lIlE_bFE7Aqe2-nt_RRbneHEXNp0,5798
-indexify/data_containers.py,sha256=n9YlKWUfptDkCR3NL5ldtbngRZC87xmXkoX6smxr47I,689
-indexify/exceptions.py,sha256=vjd5SPPNFIEW35GorSIodsqvm9RKHQm9kdp8t9gv-WM,111
-indexify/extractor.py,sha256=cBzF7Q3fu4jr7cIeSJXwLf9z45Z81MmwkuY4-zG8HBY,1406
-indexify/index.py,sha256=r911vtnvzQg3_Hrc3cbPDATNtAMiSbH9OovGKcYG2g8,519
-indexify/repository.py,sha256=YcJg8P2vvMzqK0AUwESMkA6YizaNBqGOfVnfRrGmMLg,6144
-indexify/settings.py,sha256=yzWAEZkrTjykSMj3hrFU7l_jUoUCOUsgPVW1nU-qzJQ,46
-indexify/utils.py,sha256=wvQB9VpS07iZPOrpmt2i3VIncU6YBkHdpu6rXegDT3Y,282
-indexify-0.0.4.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-indexify-0.0.4.dist-info/METADATA,sha256=_bQVRWubUKjdMkDmBjhH6DGw5nLGpRPKjhDyzBJnB_4,1862
-indexify-0.0.4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-indexify-0.0.4.dist-info/RECORD,,