Python client connection pooling fix and add context manager capability to protocol (deven96#69)

* utilize connection pool properly. Add ability to use protocol as a context

* add formatting and linting to python actions

* Refactor: Make protocol dep internal
- extract base class needed by clients.
- Add ai_response, ai_query
- Update tests and Readme

* format

* fix python import path and update readme

Author: Iamdavidonuh

.github/workflows/test.yml

@@ -77,6 +77,12 @@ jobs:
     - name: Installing poetry dependencies
       working-directory: ./sdk/ahnlich-client-py
       run: poetry install
+
+    - name: Check Python Linting
+      working-directory: ./sdk/ahnlich-client-py
+      run: |
+        poetry run isort . -c --profile black; echo $?
+        poetry run black . --check; echo $?
       
     - name: Set up Rust cache
       uses: Swatinem/rust-cache@v2

README.md

@@ -35,4 +35,13 @@ Available languages are:
 - typescript.
 
 In order to communicate effectively with the ahnlich db, you would have to extend the bincode serialization protocol automatically provided by `serde_generate`.
-Your message(in bytes) should be serialized and deserialized in the following format => `AHNLICH_HEADERS` + `VERSION` + `QUERY/SERVER_RESPONSE`. Bytes are `Little Endian`.
+Your message(in bytes) should be serialized and deserialized in the following format => `AHNLICH_HEADERS` + `VERSION` + `QUERY/SERVER_RESPONSE`. Bytes are `Little Endian`.
+
+
+## How Client Releases Work
+
+The clients follow a similar process when deploying new releases.
+[Example with python client](https://github.com/deven96/ahnlich/blob/main/sdk/ahnlich-client-py/README.md#deploy-to-artifactory).
+
+
+

ahnlich/typegen/src/tracers/mod.rs

@@ -134,13 +134,15 @@ impl<'a> OutputFile<'a> {
                 let _ = std::fs::create_dir_all(&output_dir);
                 let output_file = output_dir.join(format!("{}.{extension}", self.output_file));
                 let mut buffer = self.get_output_buffer(output_file);
-                let installer = serde_generate::python3::Installer::new(
-                    output_dir,
-                    Some(format!("ahnlich_client_{extension}.internals")),
-                );
+                let import_path = Some(format!("ahnlich_client_{extension}.internals"));
+
+                let installer =
+                    serde_generate::python3::Installer::new(output_dir, import_path.clone());
                 installer.install_bincode_runtime().unwrap();
                 installer.install_serde_runtime().unwrap();
-                serde_generate::python3::CodeGenerator::new(config).output(&mut buffer, registry)
+                serde_generate::python3::CodeGenerator::new(config)
+                    .with_serde_package_name(import_path)
+                    .output(&mut buffer, registry)
             }
             Language::Golang => {
                 // All packages are already published

sdk/ahnlich-client-py/README.md

@@ -31,6 +31,7 @@ The following topics are covered:
     * [Delete Key](#delete-key)
     * [Delete Predicate](#delete-predicate)
 * [Bulk Requests](#bulk-requests)
+* [Client As Context Manager](#client-as-context-manager)
 * [How to Deploy to Artifactory](#deploy-to-artifactory)
 * [Type Meanings](#type-meanings)
 * [Change Log](#change-log)
@@ -334,6 +335,23 @@ response: server_response.ServerResult = client.exec()
 
 
 
+## Client As Context Manager
+
+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
+
+
+ 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.
+
+
+
 ## Deploy to Artifactory
 
 Replace the contents of `MSG_TAG` file with your new tag message

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 ai_query, ai_response, db_query, db_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,32 +1,47 @@
 import typing
 
-from ahnlich_client_py import builders, protocol
+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, port: int, timeout_sec: float = 5.0) -> None:
-        self.protocol = protocol.AhnlichProtocol(
-            address=address, port=port, timeout_sec=timeout_sec
+    def __init__(
+        self,
+        address: str,
+        port: int,
+        connect_timeout_sec: float = 5.0,
+        pool_settings: AhnlichDBPoolSettings = AhnlichDBPoolSettings(),
+    ) -> None:
+
+        super().__init__(
+            address=address,
+            port=port,
+            connect_timeout_sec=connect_timeout_sec,
+            pool_settings=pool_settings,
         )
-        # would abstract this away eventually, but for now easy does it
+
         self.builder = builders.AhnlichDBRequestBuilder()
 
+    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,
@@ -43,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,
@@ -62,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,
@@ -72,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,
@@ -112,41 +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 close(self):
-        """closes the socket connection"""
-        self.protocol.close()
-
-    def cleanup(self):
-        """closes the socket connection as well as connection pool"""
-        self.close()
-        self.protocol.cleanup()
+        return self.process_request(message=self.builder.to_server_query())