sunholo 0.123.2__py3-none-any.whl → 0.123.4__py3-none-any.whl

sunholo/database/alloydb_client.py

@@ -228,22 +228,31 @@ class AlloyDBClient:
     def _execute_sql_langchain(self, sql_statement):
         return self.engine._fetch(query = sql_statement)
 
-    def _execute_sql_pg8000(self, sql_statement):
-        """Executes a given SQL statement with error handling.
+    def _execute_sql_pg8000(self, sql_statement, params=None):
+        """
+        Executes a given SQL statement with error handling.
 
-         - sql_statement (str): The SQL statement to execute.
-         - Returns: The result of the execution, if any.
+        Args:
+            sql_statement (str): The SQL statement to execute.
+            params (dict or list, optional): Parameters for the SQL statement.
+            
+        Returns:
+            The result of the execution, if any.
         """
         sql_ = sqlalchemy.text(sql_statement)
         result = None
         with self.engine.connect() as conn:
             try:
                 log.info(f"Executing SQL statement: {sql_}")
-                result = conn.execute(sql_)
+                if params:
+                    result = conn.execute(sql_, params)
+                else:
+                    result = conn.execute(sql_)
             except DatabaseError as e:
                 if "already exists" in str(e):
                     log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
                 else:
+                    log.error(f"Database error: {e}, SQL: {sql_statement}, Params: {params}")
                     raise  
             finally:
                 conn.close()
@@ -253,6 +262,7 @@ class AlloyDBClient:
     async def execute_sql_async(self, sql_statement):
         log.info(f"Executing async SQL statement: {sql_statement}")
         if self.engine_type == "pg8000":
+            # dont use async???
             result = await self._execute_sql_async_pg8000(sql_statement)
         elif self.engine_type == "langchain":
             result = await self._execute_sql_async_langchain(sql_statement)
@@ -262,21 +272,38 @@ class AlloyDBClient:
     async def _execute_sql_async_langchain(self, sql_statement):
         return await self.engine._afetch(query = sql_statement)
         
-    async def _execute_sql_async_pg8000(self, sql_statement):
-        """Executes a given SQL statement asynchronously with error handling."""
+    async def _execute_sql_async_pg8000(self, sql_statement, values=None):
+        """Executes a given SQL statement asynchronously with error handling.
+        
+        Args:
+            sql_statement (str): The SQL statement to execute
+            values (list, optional): Values for parameterized query
+            
+        Returns:
+            Result of SQL execution
+        """
         sql_ = sqlalchemy.text(sql_statement)
         result = None
-        async with self.engine.connect() as conn:
-            try:
-                log.info(f"Executing SQL statement asynchronously: {sql_}")
-                result = await conn.execute(sql_)
-            except DatabaseError as e:
-                if "already exists" in str(e):
-                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
-                else:
-                    raise
-            finally:
-                await conn.close()
+        
+        # IMPORTANT: Don't use await here, the engine.connect() is synchronous
+        conn = self.engine.connect()
+        try:
+            log.info(f"Executing SQL statement asynchronously: {sql_}")
+            if values:
+                result = conn.execute(sql_, values)
+            else:
+                result = conn.execute(sql_)
+            
+            # Explicitly commit transaction
+            await conn.commit()
+        except DatabaseError as e:
+            if "already exists" in str(e):
+                log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
+            else:
+                raise
+        finally:
+            # Close connection only here, not inside the context manager
+            conn.close()
 
         return result
     
@@ -495,42 +522,6 @@ class AlloyDBClient:
 
         self.grant_table_permissions(vectorstore_id, users)
 
-    async def _execute_sql_async_pg8000(self, sql_statement, values=None):
-        """Executes a given SQL statement asynchronously with error handling."""
-        sql_ = sqlalchemy.text(sql_statement)
-        result = None
-        async with self.engine.connect() as conn:
-            try:
-                log.info(f"Executing SQL statement asynchronously: {sql_}")
-                if values:
-                    result = await conn.execute(sql_, values)
-                else:
-                    result = await conn.execute(sql_)
-            except DatabaseError as e:
-                if "already exists" in str(e):
-                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
-                else:
-                    raise
-            finally:
-                await conn.close()
-
-        return result
-
-    async def _execute_sql_async_langchain(self, sql_statement, values=None):
-        """Execute SQL asynchronously using langchain engine"""
-        if values:
-            # Implement parameterized queries for langchain engine
-            # This would need to be adjusted based on how langchain engine handles parameters
-            log.warning("Parameterized queries may not be fully supported with langchain engine")
-            # For now, attempt a basic string substitution (not ideal for production)
-            for value in values:
-                if isinstance(value, str):
-                    sql_statement = sql_statement.replace("%s", f"'{value}'", 1)
-                else:
-                    sql_statement = sql_statement.replace("%s", str(value), 1)
-        
-        return await self.engine._afetch(query=sql_statement)
-
     async def check_connection(self):
         """
         Checks if the database connection is still valid.
@@ -540,7 +531,7 @@ class AlloyDBClient:
         """
         try:
             # Simple query to check connection
-            result = await self.execute_sql_async("SELECT 1")
+            _ = await self.execute_sql_async("SELECT 1")
             return True
         except Exception as e:
             log.warning(f"Database connection check failed: {e}")
@@ -565,7 +556,7 @@ class AlloyDBClient:
                 # Re-create the engine
                 self.engine = self._create_engine()
                 
-            log.info(f"Successfully reconnected to AlloyDB")
+            log.info("Successfully reconnected to AlloyDB")
             return True
         except Exception as e:
             log.error(f"Failed to reconnect to AlloyDB: {e}")
@@ -633,14 +624,24 @@ class AlloyDBClient:
         )
         '''
         
-        # Execute SQL to create table
-        result = await self.execute_sql_async(sql)
+        # Execute SQL to create table based on engine type
+        if self.engine_type == "pg8000":
+            # Use the synchronous method for pg8000
+            result = self._execute_sql_pg8000(sql)
+        else:
+            # Use the async method for langchain
+            result = await self._execute_sql_async_langchain(sql)
+        
         log.info(f"Created or ensured table {table_name} exists")
         
         # Grant permissions if users are provided
         if users:
             for user in users:
-                await self.execute_sql_async(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";')
+                grant_sql = f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";'
+                if self.engine_type == "pg8000":
+                    self.execute_sql(grant_sql)
+                else:
+                    await self._execute_sql_async_langchain(grant_sql)
         
         return result
 
@@ -665,15 +666,22 @@ class AlloyDBClient:
             insert_data["extraction_backend"] = metadata.get("extraction_backend", "unknown")
             insert_data["extraction_model"] = metadata.get("extraction_model", "unknown")
         
-        # Prepare column names and placeholders for values
+        # Prepare column names and values for SQL
         columns = [f'"{key}"' for key in insert_data.keys()]
-        placeholders = []
-        values = []
         
-        # Process values and create properly formatted placeholders
-        for key, value in insert_data.items():
-            values.append(json.dumps(value) if isinstance(value, (dict, list)) else value)
-            placeholders.append("%s")
+        # Process values
+        processed_values = {}
+        for i, (key, value) in enumerate(insert_data.items()):
+            # Create a unique parameter name
+            param_name = f"param_{i}"
+            # For JSON values, convert to string
+            if isinstance(value, (dict, list)):
+                processed_values[param_name] = json.dumps(value)
+            else:
+                processed_values[param_name] = value
+        
+        # Create placeholders using named parameters
+        placeholders = [f":{param_name}" for param_name in processed_values.keys()]
         
         # Create SQL statement for insertion
         columns_str = ", ".join(columns)
@@ -685,28 +693,14 @@ class AlloyDBClient:
         RETURNING id
         '''
         
-        # Execute SQL to insert data
-        result = await self.execute_sql_async(sql, values)
-        log.info(f"Inserted data into table {table_name}")
-        
-        return result
-
-    async def execute_sql_async(self, sql_statement, values=None):
-        """
-        Executes a given SQL statement asynchronously with optional parameter values.
-        
-        Args:
-            sql_statement (str): The SQL statement to execute
-            values (list, optional): Values for parameterized query
-            
-        Returns:
-            Result of SQL execution
-        """
-        log.info(f"Executing async SQL statement: {sql_statement}")
+        # Execute SQL to insert data based on engine type
         if self.engine_type == "pg8000":
-            result = await self._execute_sql_async_pg8000(sql_statement, values)
-        elif self.engine_type == "langchain":
-            result = await self._execute_sql_async_langchain(sql_statement, values)
+            # Use the synchronous method for pg8000 with properly formatted parameters
+            result = self._execute_sql_pg8000(sql, processed_values)
+        else:
+            # Use the async method for langchain
+            result = await self._execute_sql_async_langchain(sql, processed_values)
         
-        return result
-
+        log.info(f"Inserted data into table {table_name}")
+        
+        return result

{sunholo-0.123.2.dist-info → sunholo-0.123.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.123.2
+Version: 0.123.4
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0

{sunholo-0.123.2.dist-info → sunholo-0.123.4.dist-info}/RECORD

@@ -60,7 +60,7 @@ sunholo/components/retriever.py,sha256=Wmchv3huAM4w7DIS-a5Lp9Hi7M8pE6vZdxgseiT9S
 sunholo/components/vectorstore.py,sha256=k7GS1Y5c6ZGXSDAJvyCes6dTjhDAi0fjGbVLqpyfzBc,5918
 sunholo/database/__init__.py,sha256=bpB5Nk21kwqYj-qdVnvNgXjLsbflnH4g-San7OHMqR4,283
 sunholo/database/alloydb.py,sha256=x1zUMB-EVWbE2Zvp4nAs2Z-tB_kOZmS45H2lwVHdYnk,11678
-sunholo/database/alloydb_client.py,sha256=uPRcdfrE1YXCUoDbaKopjlKXXP5deceEn08bJKUeWI4,27596
+sunholo/database/alloydb_client.py,sha256=pppcmPx1liMmQSiKCdpNR6BLODbvEdICAQMz2EEjxnQ,27081
 sunholo/database/database.py,sha256=VqhZdkXUNdvWn8sUcUV3YNby1JDVf7IykPVXWBtxo9U,7361
 sunholo/database/lancedb.py,sha256=DyfZntiFKBlVPaFooNN1Z6Pl-LAs4nxWKKuq8GBqN58,715
 sunholo/database/static_dbs.py,sha256=8cvcMwUK6c32AS2e_WguKXWMkFf5iN3g9WHzsh0C07Q,442
@@ -168,9 +168,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.123.2.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.123.2.dist-info/METADATA,sha256=0w8jC9b0-_LEB8VnRcKIIbSlHCIJRFPyiuqwfTnbsm8,10001
-sunholo-0.123.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sunholo-0.123.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.123.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.123.2.dist-info/RECORD,,
+sunholo-0.123.4.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.123.4.dist-info/METADATA,sha256=iJAH2MBdmtJhWAoZmyMoVQZUGHs3Q8iuJYkC_JmRhSo,10001
+sunholo-0.123.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+sunholo-0.123.4.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.123.4.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.123.4.dist-info/RECORD,,