ahnlich-client-py 0.0.0__py3-none-any.whl

VERSION

@@ -0,0 +1,2 @@
+CLIENT="0.0.0"
+PROTOCOL="0.0.0"

ahnlich_client_py/__init__.py

@@ -0,0 +1,5 @@
+from ahnlich_client_py import builders, libs
+from ahnlich_client_py.clients import AhnlichAIClient, AhnlichDBClient
+from ahnlich_client_py.clients import non_blocking as non_blocking_client
+from ahnlich_client_py.config import AhnlichPoolSettings
+from ahnlich_client_py.internals import ai_query, ai_response, db_query, db_response

ahnlich_client_py/builders/__init__.py

@@ -0,0 +1,10 @@
+from .ai import AhnlichAIRequestBuilder
+from .db import AhnlichDBRequestBuilder
+from .non_blocking import AsyncAhnlichAIRequestBuilder, AsyncAhnlichDBRequestBuilder
+
+__all__ = [
+    "AhnlichDBRequestBuilder",
+    "AhnlichAIRequestBuilder",
+    "AsyncAhnlichDBRequestBuilder",
+    "AsyncAhnlichAIRequestBuilder",
+]

ahnlich_client_py/builders/ai.py

@@ -0,0 +1,174 @@
+import typing
+
+from ahnlich_client_py import exceptions as ah_exceptions
+from ahnlich_client_py.internals import ai_query, ai_response
+from ahnlich_client_py.internals import serde_types as st
+from ahnlich_client_py.internals.base_client import BaseClient
+from ahnlich_client_py.libs import NonZeroSizeInteger
+
+
+class AhnlichAIRequestBuilder:
+    def __init__(self, tracing_id: str = None, client: BaseClient = None) -> None:
+        self.queries: typing.List[ai_query.AIQuery] = []
+        self.tracing_id = tracing_id
+        self.client: BaseClient = client
+
+    def create_store(
+        self,
+        store_name: str,
+        query_model: ai_query.AIModel = ai_query.AIModel__AllMiniLML6V2,
+        index_model: ai_query.AIModel = ai_query.AIModel__AllMiniLML6V2,
+        predicates: typing.Sequence[str] = None,
+        non_linear_indices: typing.Sequence[ai_query.NonLinearAlgorithm] = None,
+        error_if_exists: bool = True,
+        store_original: bool = True,
+    ):
+        if not non_linear_indices:
+            non_linear_indices = []
+        if not predicates:
+            predicates = []
+
+        self.queries.append(
+            ai_query.AIQuery__CreateStore(
+                store=store_name,
+                query_model=query_model,
+                index_model=index_model,
+                predicates=predicates,
+                non_linear_indices=non_linear_indices,
+                error_if_exists=error_if_exists,
+                store_original=store_original,
+            )
+        )
+
+    def get_pred(self, store_name: str, condition: ai_query.PredicateCondition):
+        self.queries.append(
+            ai_query.AIQuery__GetPred(store=store_name, condition=condition)
+        )
+
+    def get_sim_n(
+        self,
+        store_name: str,
+        search_input: ai_query.StoreInput,
+        closest_n: st.uint64 = 1,
+        algorithm: ai_query.Algorithm = ai_query.Algorithm__CosineSimilarity,
+        condition: typing.Optional[ai_query.PredicateCondition] = None,
+        preprocess_action: ai_query.PreprocessAction = ai_query.PreprocessAction__ModelPreprocessing,
+    ):
+        nonzero_n = NonZeroSizeInteger(closest_n)
+        self.queries.append(
+            ai_query.AIQuery__GetSimN(
+                store=store_name,
+                search_input=search_input,
+                closest_n=nonzero_n.value,
+                algorithm=algorithm,
+                condition=condition,
+                preprocess_action=preprocess_action,
+            )
+        )
+
+    def create_pred_index(self, store_name: str, predicates: typing.Sequence[str]):
+        self.queries.append(
+            ai_query.AIQuery__CreatePredIndex(store=store_name, predicates=predicates)
+        )
+
+    def create_non_linear_algorithm_index(
+        self,
+        store_name: str,
+        non_linear_indices: typing.Sequence["NonLinearAlgorithm"],
+    ):
+        self.queries.append(
+            ai_query.AIQuery__CreateNonLinearAlgorithmIndex(
+                store=store_name, non_linear_indices=non_linear_indices
+            )
+        )
+
+    def drop_pred_index(
+        self,
+        store_name: str,
+        predicates: typing.Sequence[str],
+        error_if_not_exists: bool = True,
+    ):
+        self.queries.append(
+            ai_query.AIQuery__DropPredIndex(
+                store=store_name,
+                predicates=predicates,
+                error_if_not_exists=error_if_not_exists,
+            )
+        )
+
+    def drop_non_linear_algorithm_index(
+        self,
+        store_name: str,
+        non_linear_indices: typing.Sequence["NonLinearAlgorithm"],
+        error_if_not_exists: bool = True,
+    ):
+        self.queries.append(
+            ai_query.AIQuery__DropNonLinearAlgorithmIndex(
+                store=store_name,
+                non_linear_indices=non_linear_indices,
+                error_if_not_exists=error_if_not_exists,
+            )
+        )
+
+    def set(
+        self,
+        store_name: str,
+        inputs: typing.Sequence[
+            typing.Tuple[ai_query.StoreInput, typing.Dict[str, ai_query.MetadataValue]]
+        ],
+        preprocess_action: ai_query.PreprocessAction = ai_query.PreprocessAction__NoPreprocessing,
+    ):
+        self.queries.append(
+            ai_query.AIQuery__Set(
+                store=store_name,
+                inputs=inputs,
+                preprocess_action=preprocess_action,
+            )
+        )
+
+    def del_key(self, store_name: str, key: ai_query.StoreInput):
+        self.queries.append(ai_query.AIQuery__DelKey(store=store_name, key=key))
+
+    def get_key(self, store_name: str, keys: typing.Sequence[ai_query.StoreInput]):
+        self.queries.append(ai_query.AIQuery__GetKey(store=store_name, keys=keys))
+
+    def drop_store(self, store_name: str, error_if_not_exists: bool = True):
+        self.queries.append(
+            ai_query.AIQuery__DropStore(
+                store=store_name, error_if_not_exists=error_if_not_exists
+            )
+        )
+
+    def purge_stores(self):
+        self.queries.append(ai_query.AIQuery__PurgeStores())
+
+    def info_server(self):
+        self.queries.append(ai_query.AIQuery__InfoServer())
+
+    def list_stores(self):
+        self.queries.append(ai_query.AIQuery__ListStores())
+
+    def list_clients(self):
+        self.queries.append(ai_query.AIQuery__ListClients())
+
+    def ping(self):
+        self.queries.append(ai_query.AIQuery__Ping())
+
+    def drop(self):
+        self.queries.clear()
+
+    def to_server_query(self) -> ai_query.AIServerQuery:
+        if not self.queries:
+            raise ah_exceptions.AhnlichClientException(
+                "Must have atleast one ai request to be processed"
+            )
+        # not optimal, but so far, recreating the list and dropping the internal store.
+        # seems straight forward
+        queries = self.queries[:]
+        server_query = ai_query.AIServerQuery(queries=queries, trace_id=self.tracing_id)
+        self.drop()
+        return server_query
+
+    def exec(self) -> ai_response.AIServerResult:
+        """Executes a pipelined request"""
+        return self.client.process_request(message=self.to_server_query())

ahnlich_client_py/builders/db.py

@@ -0,0 +1,163 @@
+import typing
+
+from ahnlich_client_py import exceptions as ah_exceptions
+from ahnlich_client_py.internals import db_query, db_response
+from ahnlich_client_py.internals import serde_types as st
+from ahnlich_client_py.internals.base_client import BaseClient
+from ahnlich_client_py.libs import NonZeroSizeInteger
+
+
+class AhnlichDBRequestBuilder:
+    def __init__(self, tracing_id: str = None, client: BaseClient = None) -> None:
+        self.queries: typing.List[db_query.Query] = []
+        self.tracing_id = tracing_id
+        self.client: BaseClient = client
+
+    def create_store(
+        self,
+        store_name: str,
+        dimension: st.uint64,
+        create_predicates: typing.Sequence[str] = None,
+        non_linear_indices: typing.Sequence[db_query.NonLinearAlgorithm] = None,
+        error_if_exists: bool = True,
+    ):
+        if not create_predicates:
+            create_predicates = []
+        if not non_linear_indices:
+            non_linear_indices = []
+
+        non_zero = NonZeroSizeInteger(num=dimension)
+        self.queries.append(
+            db_query.Query__CreateStore(
+                store=store_name,
+                dimension=non_zero.value,
+                create_predicates=create_predicates,
+                non_linear_indices=non_linear_indices,
+                error_if_exists=error_if_exists,
+            )
+        )
+
+    def get_key(self, store_name: str, keys: typing.Sequence[db_query.Array]):
+        self.queries.append(db_query.Query__GetKey(store=store_name, keys=keys))
+
+    def get_by_predicate(self, store_name: str, condition: db_query.PredicateCondition):
+        self.queries.append(
+            db_query.Query__GetPred(store=store_name, condition=condition)
+        )
+
+    def get_sim_n(
+        self,
+        store_name: str,
+        search_input: db_query.Array,
+        closest_n: st.uint64 = 1,
+        algorithm: db_query.Algorithm = db_query.Algorithm__CosineSimilarity,
+        condition: db_query.PredicateCondition = None,
+    ):
+        nonzero = NonZeroSizeInteger(closest_n)
+        self.queries.append(
+            db_query.Query__GetSimN(
+                store=store_name,
+                search_input=search_input,
+                closest_n=nonzero.value,
+                algorithm=algorithm,
+                condition=condition,
+            )
+        )
+
+    def create_pred_index(self, store_name: str, predicates: typing.Sequence[str]):
+        self.queries.append(
+            db_query.Query__CreatePredIndex(store=store_name, predicates=predicates)
+        )
+
+    def create_non_linear_algorithm_index(
+        self, store_name: str, non_linear_indices: typing.Sequence["NonLinearAlgorithm"]
+    ):
+        self.queries.append(
+            db_query.Query__CreateNonLinearAlgorithmIndex(
+                store=store_name, non_linear_indices=non_linear_indices
+            )
+        )
+
+    def drop_pred_index(
+        self,
+        store_name: str,
+        predicates: typing.Sequence[str],
+        error_if_not_exists: bool = True,
+    ):
+        self.queries.append(
+            db_query.Query__DropPredIndex(
+                store=store_name,
+                predicates=predicates,
+                error_if_not_exists=error_if_not_exists,
+            )
+        )
+
+    def drop_non_linear_algorithm_index(
+        self,
+        store_name: str,
+        non_linear_indices: typing.Sequence["NonLinearAlgorithm"],
+        error_if_not_exists: bool = True,
+    ):
+        self.queries.append(
+            db_query.Query__DropNonLinearAlgorithmIndex(
+                store=store_name,
+                non_linear_indices=non_linear_indices,
+                error_if_not_exists=error_if_not_exists,
+            )
+        )
+
+    def set(
+        self,
+        store_name,
+        inputs: typing.Sequence[
+            typing.Tuple[db_query.Array, typing.Dict[str, db_query.MetadataValue]]
+        ],
+    ):
+        self.queries.append(db_query.Query__Set(store=store_name, inputs=inputs))
+
+    def delete_key(self, store_name: str, keys: typing.Sequence[db_query.Array]):
+        self.queries.append(db_query.Query__DelKey(store=store_name, keys=keys))
+
+    def delete_predicate(self, store_name: str, condition: db_query.PredicateCondition):
+        self.queries.append(
+            db_query.Query__DelPred(store=store_name, condition=condition)
+        )
+
+    def drop_store(self, store_name: str, error_if_not_exists: bool = True):
+        self.queries.append(
+            db_query.Query__DropStore(
+                store=store_name, error_if_not_exists=error_if_not_exists
+            )
+        )
+
+    def list_stores(self):
+        self.queries.append(db_query.Query__ListStores())
+
+    def info_server(self):
+        self.queries.append(db_query.Query__InfoServer())
+
+    def list_clients(self):
+        self.queries.append(db_query.Query__ListClients())
+
+    def ping(self):
+        self.queries.append(db_query.Query__Ping())
+
+    def drop(self):
+        self.queries.clear()
+
+    def to_server_query(self) -> db_query.ServerQuery:
+        if not self.queries:
+            raise ah_exceptions.AhnlichClientException(
+                "Must have atleast one request to be processed"
+            )
+        # not optimal, but so far, recreating the list and dropping the internal store.
+        # seems straight forward
+        queries = self.queries[:]
+
+        server_query = db_query.ServerQuery(queries=queries, trace_id=self.tracing_id)
+        self.drop()
+        return server_query
+
+    def exec(self) -> db_response.ServerResult:
+        """Executes a pipelined request"""
+        return self.client.process_request(message=self.to_server_query())

ahnlich_client_py/builders/non_blocking/__init__.py

@@ -0,0 +1,2 @@
+from .ai import AsyncAhnlichAIRequestBuilder
+from .db import AsyncAhnlichDBRequestBuilder

ahnlich_client_py/builders/non_blocking/ai.py

@@ -0,0 +1,16 @@
+import typing
+
+from ahnlich_client_py.builders import AhnlichAIRequestBuilder
+from ahnlich_client_py.internals import ai_query, ai_response
+from ahnlich_client_py.internals.async_base_client import BaseClient
+
+
+class AsyncAhnlichAIRequestBuilder(AhnlichAIRequestBuilder):
+    def __init__(self, tracing_id: str = None, client: BaseClient = None) -> None:
+        self.queries: typing.List[ai_query.AIQuery] = []
+        self.tracing_id = tracing_id
+        self.client: BaseClient = client
+
+    async def exec(self) -> ai_response.AIServerResult:
+        """Executes a pipelined request"""
+        return await self.client.process_request(message=self.to_server_query())

ahnlich_client_py/builders/non_blocking/db.py

@@ -0,0 +1,16 @@
+import typing
+
+from ahnlich_client_py.builders import AhnlichDBRequestBuilder
+from ahnlich_client_py.internals import db_query, db_response
+from ahnlich_client_py.internals.async_base_client import BaseClient
+
+
+class AsyncAhnlichDBRequestBuilder(AhnlichDBRequestBuilder):
+    def __init__(self, tracing_id: str = None, client: BaseClient = None) -> None:
+        self.queries: typing.List[db_query.Query] = []
+        self.tracing_id = tracing_id
+        self.client: BaseClient = client
+
+    async def exec(self) -> db_response.ServerResult:
+        """Executes a pipelined request"""
+        return await self.client.process_request(message=self.to_server_query())

ahnlich_client_py/clients/__init__.py

@@ -0,0 +1,2 @@
+from .ai import AhnlichAIClient
+from .db import AhnlichDBClient

ahnlich_client_py/clients/ai.py

@@ -0,0 +1,224 @@
+import typing
+
+from ahnlich_client_py import builders
+from ahnlich_client_py.config import AhnlichPoolSettings
+from ahnlich_client_py.internals import ai_query, ai_response
+from ahnlich_client_py.internals import serde_types as st
+from ahnlich_client_py.internals.base_client import BaseClient
+
+
+class AhnlichAIClient(BaseClient):
+    """Wrapper for interacting with Ahnlich AI Proxy"""
+
+    def __init__(
+        self,
+        address: str,
+        port: int,
+        connect_timeout_sec: float = 5.0,
+        pool_settings: AhnlichPoolSettings = AhnlichPoolSettings(),
+    ) -> None:
+        super().__init__(
+            address=address,
+            port=port,
+            connect_timeout_sec=connect_timeout_sec,
+            pool_settings=pool_settings,
+        )
+
+    def get_response_class(self):
+        return ai_response.AIServerResult
+
+    def create_store(
+        self,
+        store_name: str,
+        query_model: ai_query.AIModel,
+        index_model: ai_query.AIModel,
+        predicates: typing.Sequence[str] = None,
+        non_linear_indices: typing.Sequence[ai_query.NonLinearAlgorithm] = None,
+        error_if_exists: bool = True,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.create_store(
+            store_name=store_name,
+            query_model=query_model,
+            index_model=index_model,
+            predicates=predicates,
+            non_linear_indices=non_linear_indices,
+            error_if_exists=error_if_exists,
+        )
+        return self.process_request(builder.to_server_query())
+
+    def get_pred(
+        self,
+        store_name: str,
+        condition: ai_query.PredicateCondition,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.get_pred(store_name=store_name, condition=condition)
+        return self.process_request(builder.to_server_query())
+
+    def get_sim_n(
+        self,
+        store_name: str,
+        search_input: ai_query.StoreInput,
+        closest_n: st.uint64,
+        algorithm: ai_query.Algorithm,
+        condition: typing.Optional[ai_query.PredicateCondition] = None,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.get_sim_n(
+            store_name=store_name,
+            search_input=search_input,
+            closest_n=closest_n,
+            algorithm=algorithm,
+            condition=condition,
+        )
+        return self.process_request(builder.to_server_query())
+
+    def create_pred_index(
+        self,
+        store_name: str,
+        predicates: typing.Sequence[str],
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.create_pred_index(store_name=store_name, predicates=predicates)
+        return self.process_request(builder.to_server_query())
+
+    def create_non_linear_algorithm_index(
+        self,
+        store_name: str,
+        non_linear_indices: typing.Sequence["NonLinearAlgorithm"],
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.create_non_linear_algorithm_index(
+            store_name=store_name, non_linear_indices=non_linear_indices
+        )
+        return self.process_request(builder.to_server_query())
+
+    def drop_pred_index(
+        self,
+        store_name: str,
+        predicates: typing.Sequence[str],
+        error_if_not_exists: bool,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.drop_pred_index(
+            store_name=store_name,
+            predicates=predicates,
+            error_if_not_exists=error_if_not_exists,
+        )
+        return self.process_request(builder.to_server_query())
+
+    def drop_non_linear_algorithm_index(
+        self,
+        store_name: str,
+        non_linear_indices: typing.Sequence["NonLinearAlgorithm"],
+        error_if_not_exists: bool,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.drop_non_linear_algorithm_index()(
+            store_name=store_name,
+            non_linear_indices=non_linear_indices,
+            error_if_not_exists=error_if_not_exists,
+        )
+        return self.process_request(builder.to_server_query())
+
+    def set(
+        self,
+        store_name: str,
+        inputs: typing.Sequence[
+            typing.Tuple[ai_query.StoreInput, typing.Dict[str, ai_query.MetadataValue]]
+        ],
+        preprocess_action=ai_query.PreprocessAction,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.set(
+            store_name=store_name, inputs=inputs, preprocess_action=preprocess_action
+        )
+        return self.process_request(builder.to_server_query())
+
+    def del_key(
+        self,
+        store_name: str,
+        key: ai_query.StoreInput,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.del_key(store_name=store_name, key=key)
+        return self.process_request(builder.to_server_query())
+
+    def get_key(
+        self,
+        store_name: str,
+        keys: typing.Sequence[ai_query.StoreInput],
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.get_key(store_name=store_name, keys=keys)
+        return self.process_request(builder.to_server_query())
+
+    def drop_store(
+        self,
+        store_name: str,
+        error_if_not_exists: bool,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.drop_store(
+            store_name=store_name, error_if_not_exists=error_if_not_exists
+        )
+        return self.process_request(builder.to_server_query())
+
+    def purge_stores(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.purge_stores()
+        return self.process_request(builder.to_server_query())
+
+    def info_server(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.info_server()
+        return self.process_request(builder.to_server_query())
+
+    def list_stores(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.list_stores()
+        return self.process_request(builder.to_server_query())
+
+    def list_clients(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.list_clients()
+        return self.process_request(builder.to_server_query())
+
+    def ping(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ):
+        builder = builders.AhnlichAIRequestBuilder(tracing_id)
+        builder.ping()
+        return self.process_request(builder.to_server_query())
+
+    def pipeline(
+        self,
+        tracing_id: typing.Optional[str] = None,
+    ) -> builders.AhnlichAIRequestBuilder:
+        """Gives you a request builder to create multple requests"""
+        return builders.AhnlichAIRequestBuilder(tracing_id, client=self)