Refactor: Make protocol dep internal

- extract base class needed by clients.
- Add ai_response, ai_query
- Update tests and Readme

Author: Iamdavidonuh

sdk/ahnlich-client-py/README.md

@@ -31,7 +31,7 @@ The following topics are covered:
     * [Delete Key](#delete-key)
     * [Delete Predicate](#delete-predicate)
 * [Bulk Requests](#bulk-requests)
-* [Protocol As Context Manager](#protocol-as-context-manager)
+* [Client As Context Manager](#client-as-context-manager)
 * [How to Deploy to Artifactory](#deploy-to-artifactory)
 * [Type Meanings](#type-meanings)
 * [Change Log](#change-log)
@@ -335,20 +335,17 @@ response: server_response.ServerResult = client.exec()
 
 
 
-## Protocol As Context Manager
+## Client As Context Manager
 
-The protocol class can be used as a context manager hereby closing the connection pool automatically upon context end.
+The DB client class can be used as a context manager hereby closing the connection pool automatically upon context end.
 
 
 ```py
 from ahnlich_client_py import AhnlichDBClient
-from ahnlich_client_py import AhnlichProtocol
 
-connection_protocol = AhnlichProtocol(address="127.0.0.1", port=1369)
 
- with pro as protocol:
-    client = AhnlichDBClient(connection_protocol=connection_protocol)
-    response: server_response.ServerResult = client.ping()
+ with client.AhnlichDBClient(address="127.0.0.1", port=port) as db_client:
+    response: server_response.ServerResult = db_client.ping()
 
 ```
 However, closing the connection pool can be done by calling `cleanup()` on the client.

sdk/ahnlich-client-py/ahnlich_client_py/__init__.py

@@ -1,5 +1,4 @@
 from ahnlich_client_py import builders, libs
 from ahnlich_client_py.client import AhnlichDBClient
 from ahnlich_client_py.config import AhnlichDBPoolSettings
-from ahnlich_client_py.internals import db_query, db_response
-from ahnlich_client_py.protocol import AhnlichProtocol
+from ahnlich_client_py.internals import db_query, db_response, ai_query, ai_response

sdk/ahnlich-client-py/ahnlich_client_py/builders/db.py

@@ -5,7 +5,6 @@
 from ahnlich_client_py import exceptions as ah_exceptions
 from ahnlich_client_py.internals import db_query
 from ahnlich_client_py.internals import serde_types as st
-from ahnlich_client_py.protocol import AhnlichProtocol
 
 
 class NonZeroSizeInteger:
@@ -142,7 +141,3 @@ def to_server_query(self) -> db_query.ServerQuery:
         server_query = db_query.ServerQuery(queries=queries)
         self.drop()
         return server_query
-
-    def execute_requests(self, protocol: AhnlichProtocol):
-        response = protocol.process_request(message=self.to_server_query())
-        return response

sdk/ahnlich-client-py/ahnlich_client_py/client.py

@@ -1,45 +1,47 @@
 import typing
 
-from ahnlich_client_py import builders, protocol
-from ahnlich_client_py.exceptions import AhnlichClientException
+from ahnlich_client_py import builders
+from ahnlich_client_py.config import AhnlichDBPoolSettings
 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
 
 
-class AhnlichDBClient:
-    """Wrapper for interacting with Ahnlich database or ai"""
+class AhnlichDBClient(BaseClient):
+    """Wrapper for interacting with Ahnlich database"""
 
     def __init__(
         self,
-        address: str = None,
-        port: int = None,
-        timeout_sec: float = 5.0,
-        connection_protocol: protocol.AhnlichProtocol = None,
+        address: str,
+        port: int,
+        connect_timeout_sec: float = 5.0,
+        pool_settings: AhnlichDBPoolSettings = AhnlichDBPoolSettings(),
     ) -> None:
-        if not connection_protocol and (address is None or port is None):
-            raise AhnlichClientException(
-                "Either connection protocol or address and port must be provided"
-            )
-        self.protocol = connection_protocol or protocol.AhnlichProtocol(
-            address=address, port=port, timeout_sec=timeout_sec
+
+        super().__init__(
+            address=address,
+            port=port,
+            connect_timeout_sec=connect_timeout_sec,
+            pool_settings=pool_settings,
         )
+
         self.builder = builders.AhnlichDBRequestBuilder()
 
-    def __del__(self):
-        self.cleanup()
+    def get_response_class(self):
+        return db_response.ServerResult
 
     def get_key(
         self, store_name: str, keys: typing.Sequence[db_query.Array]
     ) -> db_response.ServerResult:
 
         self.builder.get_key(store_name=store_name, keys=keys)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def get_by_predicate(
         self, store_name: str, condition: db_query.PredicateCondition
     ) -> db_response.ServerResult:
         self.builder.get_by_predicate(store_name=store_name, condition=condition)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def get_sim_n(
         self,
@@ -56,13 +58,13 @@ def get_sim_n(
             algorithm=algorithm,
             condition=condition,
         )
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def create_pred_index(
         self, store_name: str, predicates: typing.Sequence[str]
     ) -> db_response.ServerResult:
         self.builder.create_pred_index(store_name=store_name, predicates=predicates)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def drop_pred_index(
         self,
@@ -75,7 +77,7 @@ def drop_pred_index(
             predicates=predicates,
             error_if_not_exists=error_if_not_exists,
         )
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def set(
         self,
@@ -85,27 +87,27 @@ def set(
         ],
     ) -> db_response.ServerResult:
         self.builder.set(store_name=store_name, inputs=inputs)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def delete_key(
         self, store_name: str, keys: typing.Sequence[db_query.Array]
     ) -> db_response.ServerResult:
         self.builder.delete_key(store_name=store_name, keys=keys)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def delete_predicate(
         self, store_name: str, condition: db_query.PredicateCondition
     ) -> db_response.ServerResult:
         self.builder.delete_predicate(store_name=store_name, condition=condition)
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def drop_store(
         self, store_name: str, error_if_not_exists: bool
     ) -> db_response.ServerResult:
         self.builder.drop_store(
             store_name=store_name, error_if_not_exists=error_if_not_exists
         )
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def create_store(
         self,
@@ -125,36 +127,32 @@ def create_store(
             error_if_exists=error_if_exists,
         )
         message = self.builder.to_server_query()
-        return self.protocol.process_request(message=message)
+        return self.process_request(message=message)
 
     def list_stores(self) -> db_response.ServerResult:
         self.builder.list_stores()
-        return self.protocol.process_request(self.builder.to_server_query())
+        return self.process_request(self.builder.to_server_query())
 
     def info_server(self) -> db_response.ServerResult:
         self.builder.info_server()
-        return self.protocol.process_request(
+        return self.process_request(
             message=self.builder.to_server_query(),
         )
 
     def list_clients(self) -> db_response.ServerResult:
         self.builder.list_clients()
-        return self.protocol.process_request(
+        return self.process_request(
             message=self.builder.to_server_query(),
         )
 
     def ping(self) -> db_response.ServerResult:
         self.builder.ping()
-        return self.protocol.process_request(message=self.builder.to_server_query())
+        return self.process_request(message=self.builder.to_server_query())
 
     def pipeline(self) -> builders.AhnlichDBRequestBuilder:
         """Gives you a request builder to create multple requests"""
         return self.builder
 
     def exec(self) -> db_response.ServerResult:
         """Executes a pipelined request"""
-        return self.protocol.process_request(message=self.builder.to_server_query())
-
-    def cleanup(self):
-        """closes the socket connection as well as connection pool"""
-        self.protocol.cleanup()
+        return self.process_request(message=self.builder.to_server_query())