indexify 0.0.4__tar.gz → 0.0.6__tar.gz

{indexify-0.0.4 → indexify-0.0.6}/PKG-INFO

@@ -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.4 → indexify-0.0.6}/README.md

@@ -1,5 +1,8 @@
 # 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.
@@ -13,10 +16,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
@@ -27,21 +37,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.4 → indexify-0.0.6}/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-0.0.6/indexify/client.py

@@ -0,0 +1,406 @@
+import httpx
+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, Union
+
+Document = namedtuple("Document", ["text", "labels"])
+
+
+class IndexifyClient:
+    """
+    IndexifyClient is the main entry point for the SDK.
+    For the full list of client features, see the
+    [httpx Client documentation](https://www.python-httpx.org/api/#client).
+
+    :param service_url: The URL of the Indexify service to connect to.
+    :param args: Arguments to pass to the httpx.Client constructor
+    :param kwargs: Keyword arguments to pass to the httpx.Client constructor
+
+    Example usage:
+    ```
+    from indexify import IndexifyClient
+
+    client = IndexifyClient()
+    assert client.heartbeat() == True
+    ```
+    """
+
+    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":
+        """
+        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 = 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)
+        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:
+        """
+        Make a GET request to the Indexify service.
+
+        :param endpoint: The endpoint to make the request to.
+
+        Example usage:
+        ```
+        from indexify import IndexifyClient
+
+        client = IndexifyClient()
+        response = client.get("namespaces")
+        print(response.json())
+        ```
+        """
+        return self._request("GET", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def post(self, endpoint: str, **kwargs) -> httpx.Response:
+        """
+        Make a POST request to the Indexify service.
+
+        :param endpoint: The endpoint to make the request to.
+
+        Example usage:
+
+        ```
+        from indexify import IndexifyClient
+
+        client = IndexifyClient()
+        response = client.post("namespaces", json={"name": "my-repo"})
+        print(response.json())
+        ```
+        """
+        return self._request("POST", url=f"{self._service_url}/{endpoint}", **kwargs)
+
+    def put(self, endpoint: str, **kwargs) -> httpx.Response:
+        # Not Implemented
+        raise NotImplementedError
+
+    def delete(self, endpoint: str, **kwargs) -> httpx.Response:
+        # Not Implemented
+        raise NotImplementedError
+
+    def close(self):
+        """
+        Close the underlying httpx.Client.
+        """
+        self._client.close()
+
+    # __enter__ and __exit__ allow the client to be used as a context manager
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def heartbeat(self, heartbeat_response="Indexify Server") -> bool:
+        """
+        Check if the Indexify service is alive.
+        """
+        response = self.get(f"")
+        # Server responds with text: "Indexify Server"
+        return response.text == heartbeat_response
+
+    def namespaces(self) -> list[str]:
+        """
+        Get a list of all namespaces.
+        """
+        response = self.get(f"namespaces")
+        namespaces_dict = response.json()["namespaces"]
+        namespaces = []
+        for item in namespaces_dict:
+            namespaces.append(item["name"])
+        return namespaces
+
+    @classmethod
+    def create_namespace(
+        self,
+        namespace: str,
+        extractor_bindings: list = [],
+        labels: dict = {},
+    ) -> "IndexifyClient":
+        """
+        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": namespace,
+            "extractor_bindings": bindings,
+            "labels": labels,
+        }
+
+        client = IndexifyClient(namespace=namespace)
+        client.post(f"namespaces", json=req)
+        return client
+
+    def indexes(self) -> List[Index]:
+        """
+        Get the indexes of the current namespace.
+
+        Returns:
+            List[Index]: list of indexes in the current namespace
+        """
+        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"]
+        extractors = []
+        for ed in extractors_dict:
+            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-0.0.4 → indexify-0.0.6}/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-0.0.4 → indexify-0.0.6}/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-0.0.6/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-0.0.4 → indexify-0.0.6}/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 → indexify-0.0.6}/pyproject.toml

@@ -1,16 +1,16 @@
 [tool.poetry]
 name = "indexify"
-version = "0.0.4"
+version = "0.0.6"
 description = "Python Client for Indexify"
 authors = ["Diptanu Gon Choudhury <diptanuc@gmail.com>", "Vijay Parthasarathy <vijay2win@gmail.com>"]
 license = "Apache 2.0"
 readme = "README.md"
-homepage = "https://github.com/diptanu/indexify"
-repository = "https://github.com/diptanu/indexify"
+homepage = "https://github.com/tensorlakeai/indexify"
+repository = "https://github.com/tensorlakeai/indexify"
 
 [tool.poetry.dependencies]
 python = "^3.10.0"
-httpx = { version = "^0.24.1", extras = ["http2"] }
+httpx = { version = "^0.26", extras = ["http2"] }
 
 [tool.poetry.dev-dependencies]
 black = "^22.3.0"

indexify-0.0.4/indexify/client.py

@@ -1,178 +0,0 @@
-import httpx
-from .repository import Repository
-from .settings import DEFAULT_SERVICE_URL
-from .extractor import Extractor
-
-from typing import List, Optional
-
-
-class IndexifyClient:
-    """
-    IndexifyClient is the main entry point for the SDK.
-    For the full list of client features, see the
-    [httpx Client documentation](https://www.python-httpx.org/api/#client).
-
-    :param service_url: The URL of the Indexify service to connect to.
-    :param args: Arguments to pass to the httpx.Client constructor
-    :param kwargs: Keyword arguments to pass to the httpx.Client constructor
-
-    Example usage:
-    ```
-    from indexify import IndexifyClient
-
-    client = IndexifyClient()
-    assert client.heartbeat() == True
-    ```
-    """
-    def __init__(self,
-                 service_url: str = DEFAULT_SERVICE_URL,
-                 *args,
-                 **kwargs
-                 ):
-        self._service_url = service_url
-        self._client = httpx.Client(*args, **kwargs)
-
-    @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":
-        """
-        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 = 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()
-        return response
-
-    def get(self, endpoint: str, **kwargs) -> httpx.Response:
-        """
-        Make a GET request to the Indexify service.
-
-        :param endpoint: The endpoint to make the request to.
-
-        Example usage:
-        ```
-        from indexify import IndexifyClient
-
-        client = IndexifyClient()
-        response = client.get("repositories")
-        print(response.json())
-        ```
-        """
-        return self._request("GET", url=f"{self._service_url}/{endpoint}", **kwargs)
-
-    def post(self, endpoint: str, **kwargs) -> httpx.Response:
-        """
-        Make a POST request to the Indexify service.
-
-        :param endpoint: The endpoint to make the request to.
-
-        Example usage:
-
-        ```
-        from indexify import IndexifyClient
-
-        client = IndexifyClient()
-        response = client.post("repositories", json={"name": "my-repo"})
-        print(response.json())
-        ```
-        """
-        return self._request("POST", url=f"{self._service_url}/{endpoint}", **kwargs)
-
-    def put(self, endpoint: str, **kwargs) -> httpx.Response:
-        # Not Implemented
-        raise NotImplementedError
-
-    def delete(self, endpoint: str, **kwargs) -> httpx.Response:
-        # Not Implemented
-        raise NotImplementedError
-
-    def close(self):
-        """
-        Close the underlying httpx.Client.
-        """
-        self._client.close()
-
-    # __enter__ and __exit__ allow the client to be used as a context manager
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.close()
-
-    def heartbeat(self, heartbeat_response="Indexify Server") -> bool:
-        """
-        Check if the Indexify service is alive.
-        """
-        response = self.get(f"")
-        # Server responds with text: "Indexify Server"
-        return response.text == heartbeat_response
-
-    def repositories(self) -> list[Repository]:
-        """
-        Get a list of all repositories.
-        """
-        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
-
-    def create_repository(
-        self, name: str, extractor_bindings: list = [], metadata: dict = {}
-    ) -> Repository:
-        """
-        Create a new repository.
-        """
-        req = {
-            "name": name,
-            "extractor_bindings": extractor_bindings,
-            "metadata": metadata,
-        }
-        response = self.post(f"repositories", json=req)
-        return Repository(name, self._service_url)
-
-    def get_repository(self, name: str) -> Repository:
-        """
-        Get a repository by name.
-        """
-        return Repository(name, self._service_url)
-
-    def extractors(self) -> List[Extractor]:
-        """
-        Get a list of all extractors.
-        """
-        response = self.get(f"extractors")
-        extractors_dict = response.json()["extractors"]
-        extractors = []
-        for ed in extractors_dict:
-            extractors.append(Extractor.from_dict(ed))
-        return extractors
-

indexify-0.0.4/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__()