sunholo 0.123.1__py3-none-any.whl → 0.123.3__py3-none-any.whl

sunholo/database/alloydb_client.py

@@ -262,21 +262,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_}")
+        
+        # Get connection directly, avoiding async with
+        conn = await self.engine.connect()
+        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()
+            
+            # 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
+            await conn.close()
 
         return result
     
@@ -540,7 +557,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 +582,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}")
@@ -585,128 +602,109 @@ class AlloyDBClient:
         except Exception as e:
             log.warning(f"Error closing AlloyDB connection: {e}")
 
-async def create_table_from_schema(self, table_name: str, schema_data: dict, users: list = None):
-    """
-    Creates or ensures a table exists based on the structure of the provided schema data.
-    
-    Args:
-        table_name (str): Name of the table to create
-        schema_data (dict): Data structure that matches the expected schema
-        users (list, optional): List of users to grant permissions to
+    async def create_table_from_schema(self, table_name: str, schema_data: dict, users: list = None):
+        """
+        Creates or ensures a table exists based on the structure of the provided schema data.
         
-    Returns:
-        Result of SQL execution
-    """
-    # Generate column definitions from schema data
-    columns = []
-    for key, value in schema_data.items():
-        if isinstance(value, dict):
-            # For nested objects, store as JSONB
-            columns.append(f'"{key}" JSONB')
-        elif isinstance(value, list):
-            # For arrays, store as JSONB
-            columns.append(f'"{key}" JSONB')
-        elif isinstance(value, int):
-            columns.append(f'"{key}" INTEGER')
-        elif isinstance(value, float):
-            columns.append(f'"{key}" NUMERIC')
-        elif isinstance(value, bool):
-            columns.append(f'"{key}" BOOLEAN')
-        else:
-            # Default to TEXT for strings and other types
-            columns.append(f'"{key}" TEXT')
-    
-    # Add metadata columns
-    columns.extend([
-        '"source" TEXT',
-        '"extraction_date" TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP',
-        '"extraction_backend" TEXT',
-        '"extraction_model" TEXT'
-    ])
-    
-    # Create SQL statement for table creation
-    columns_sql = ", ".join(columns)
-    sql = f'''
-    CREATE TABLE IF NOT EXISTS "{table_name}" (
-        id SERIAL PRIMARY KEY,
-        {columns_sql}
-    )
-    '''
-    
-    # Execute SQL to create table
-    result = await self.execute_sql_async(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}";')
-    
-    return result
-
-async def write_data_to_table(self, table_name: str, data: dict, metadata: dict = None):
-    """
-    Writes data to the specified table.
-    
-    Args:
-        table_name (str): Name of the table
-        data (dict): Data to write to the table
-        metadata (dict, optional): Additional metadata to include
+        Args:
+            table_name (str): Name of the table to create
+            schema_data (dict): Data structure that matches the expected schema
+            users (list, optional): List of users to grant permissions to
+            
+        Returns:
+            Result of SQL execution
+        """
+        # Generate column definitions from schema data
+        columns = []
+        for key, value in schema_data.items():
+            if isinstance(value, dict):
+                # For nested objects, store as JSONB
+                columns.append(f'"{key}" JSONB')
+            elif isinstance(value, list):
+                # For arrays, store as JSONB
+                columns.append(f'"{key}" JSONB')
+            elif isinstance(value, int):
+                columns.append(f'"{key}" INTEGER')
+            elif isinstance(value, float):
+                columns.append(f'"{key}" NUMERIC')
+            elif isinstance(value, bool):
+                columns.append(f'"{key}" BOOLEAN')
+            else:
+                # Default to TEXT for strings and other types
+                columns.append(f'"{key}" TEXT')
         
-    Returns:
-        Result of SQL execution
-    """
-    # Create copies to avoid modifying the original data
-    insert_data = dict(data)
-    
-    # Add metadata if provided
-    if metadata:
-        insert_data["source"] = metadata.get("objectId", metadata.get("source", "unknown"))
-        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
-    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")
-    
-    # Create SQL statement for insertion
-    columns_str = ", ".join(columns)
-    placeholders_str = ", ".join(placeholders)
-    
-    sql = f'''
-    INSERT INTO "{table_name}" ({columns_str})
-    VALUES ({placeholders_str})
-    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
+        # Add metadata columns
+        columns.extend([
+            '"source" TEXT',
+            '"extraction_date" TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP',
+            '"extraction_backend" TEXT',
+            '"extraction_model" TEXT'
+        ])
         
-    Returns:
-        Result of SQL execution
-    """
-    log.info(f"Executing async SQL statement: {sql_statement}")
-    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)
-    
-    return result
+        # Create SQL statement for table creation
+        columns_sql = ", ".join(columns)
+        sql = f'''
+        CREATE TABLE IF NOT EXISTS "{table_name}" (
+            id SERIAL PRIMARY KEY,
+            {columns_sql}
+        )
+        '''
+        
+        # Execute SQL to create table
+        result = await self.execute_sql_async(sql)
+        log.info(f"Created or ensured table {table_name} exists")
+        
+        # Grant permissions if users are provided
+        if users:
+            for user in users:
+                grant_sql = f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";'
+                await self.execute_sql_async(grant_sql)
+        
+        return result
 
+    async def write_data_to_table(self, table_name: str, data: dict, metadata: dict = None):
+        """
+        Writes data to the specified table.
+        
+        Args:
+            table_name (str): Name of the table
+            data (dict): Data to write to the table
+            metadata (dict, optional): Additional metadata to include
+            
+        Returns:
+            Result of SQL execution
+        """
+        # Create copies to avoid modifying the original data
+        insert_data = dict(data)
+        
+        # Add metadata if provided
+        if metadata:
+            insert_data["source"] = metadata.get("objectId", metadata.get("source", "unknown"))
+            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
+        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")
+        
+        # Create SQL statement for insertion
+        columns_str = ", ".join(columns)
+        placeholders_str = ", ".join(placeholders)
+        
+        sql = f'''
+        INSERT INTO "{table_name}" ({columns_str})
+        VALUES ({placeholders_str})
+        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

{sunholo-0.123.1.dist-info → sunholo-0.123.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.123.1
+Version: 0.123.3
 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.1.dist-info → sunholo-0.123.3.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=WpkrQmy2hK4148df-6Ys8XRjCGpObZa9Dc9TXLSX_sE,27108
+sunholo/database/alloydb_client.py,sha256=yksz52Qnx8xCsW61TPKGqSGTehSukP8suKwShec4z54,27401
 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.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.123.1.dist-info/METADATA,sha256=eMkSTIyICC03RID4bD6yN7ryL8Faglbjjj2EKsnvVf4,10001
-sunholo-0.123.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sunholo-0.123.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.123.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.123.1.dist-info/RECORD,,
+sunholo-0.123.3.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.123.3.dist-info/METADATA,sha256=BYdslKNSlXmkUMdV4JExD5JzamsfnwVfzIepQV9PsAA,10001
+sunholo-0.123.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+sunholo-0.123.3.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.123.3.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.123.3.dist-info/RECORD,,