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

sunholo/__init__.py

@@ -15,6 +15,8 @@ from . import invoke
 from . import langfuse
 from . import llamaindex
 from . import lookup
+from . import mcp
+from . import ollama
 from . import pubsub
 from . import qna
 from . import senses
@@ -43,6 +45,8 @@ __all__ = ['agents',
            'langfuse', 
            'llamaindex',
            'lookup', 
+           'mcp',
+           'ollama', 
            'pubsub',
            'qna', 
            'senses',

sunholo/database/alloydb_client.py

@@ -8,6 +8,7 @@ except ImportError:
     AlloyDBEngine = None
     pass
 
+import json
 from .database import get_vector_size
 from .uuid import generate_uuid_from_object_id
 from ..custom_logging import log
@@ -492,4 +493,220 @@ class AlloyDBClient:
         '''
         self.execute_sql(sql)
 
-        self.grant_table_permissions(vectorstore_id, users)
+        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.
+        
+        Returns:
+            bool: True if connection is valid, False otherwise
+        """
+        try:
+            # Simple query to check connection
+            result = await self.execute_sql_async("SELECT 1")
+            return True
+        except Exception as e:
+            log.warning(f"Database connection check failed: {e}")
+            return False
+
+    async def ensure_connected(self):
+        """
+        Ensures the database connection is valid, attempting to reconnect if necessary.
+        
+        Returns:
+            bool: True if connection is valid or reconnection successful, False otherwise
+        """
+        if await self.check_connection():
+            return True
+            
+        try:
+            # Attempt to reconnect - implementation depends on your database driver
+            if self.engine_type == "pg8000":
+                # Re-create the engine
+                self.engine = self._create_engine_from_pg8000(self.user, self.password, self.database)
+            elif self.engine_type == "langchain":
+                # Re-create the engine
+                self.engine = self._create_engine()
+                
+            log.info(f"Successfully reconnected to AlloyDB")
+            return True
+        except Exception as e:
+            log.error(f"Failed to reconnect to AlloyDB: {e}")
+            return False
+
+    async def close(self):
+        """
+        Properly close the database connection.
+        """
+        try:
+            if self.engine_type == "pg8000":
+                # Close engine or connector
+                if hasattr(self, 'connector'):
+                    await self.connector.close()
+            # For langchain engine, additional cleanup might be needed
+            log.info("Closed AlloyDB connection")
+        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
+        
+    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
+        
+    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
+        
+    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
+

sunholo/ollama/ollama_images.py

@@ -0,0 +1,71 @@
+import os.path
+import argparse
+from typing import List, Optional
+import sys
+from ..custom_logging import log
+
+try:
+    import PIL.Image
+    from ollama import generate
+except ImportError:
+    generate = None
+
+CHAT_MODEL_NAME = os.getenv("MODEL_NAME_LATEST")
+
+def chat_ollama(msg, model_name, the_images=None):
+    
+    if not generate:
+        raise ImportError("Import ollama via `pip install ollama`")
+    
+    chat_images = []
+    if the_images:
+        for the_image in the_images:
+            chat_image = PIL.Image.open(the_image)
+            chat_images.append(chat_image)
+
+    log.info(f"Ollama [{model_name}]: Chatting...{msg=}")
+    for response in generate(model_name, msg, images=chat_images, stream=True):
+        print(response['response'], end='', flush=True)
+
+def main():
+    parser = argparse.ArgumentParser(description='Chat with Ollama models from the command line')
+    parser.add_argument('--model', '-m', type=str, default=CHAT_MODEL_NAME,
+                        help='Model name to use (defaults to MODEL_NAME_LATEST env var)')
+    parser.add_argument('--images', '-i', type=str, nargs='+',
+                        help='Image file paths to include in the prompt')
+    parser.add_argument('--message', '-p', type=str,
+                        help='Message to send')
+    
+    args = parser.parse_args()
+    
+    if not args.model:
+        print("Error: No model specified. Either set MODEL_NAME_LATEST environment variable or use --model flag.")
+        sys.exit(1)
+    
+    # If no message provided via args, read from stdin
+    if not args.message:
+        print(f"Enter your message to {args.model} (Ctrl+D to send):")
+        user_input = sys.stdin.read().strip()
+    else:
+        user_input = args.message
+    
+    if not user_input:
+        print("Error: Empty message. Exiting.")
+        sys.exit(1)
+    
+    try:
+        chat_ollama(user_input, args.model, args.images)
+        print()  # Add a newline after the response
+    except ImportError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    # uv run src/sunholo/ollama/ollama_images.py --model=gemma3:12b - chat and then CTRL+D
+    # uv run src/sunholo/ollama/ollama_images.py --model gemma3:12b --message "Tell me about quantum computing"
+
+
+    main()

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sunholo
-Version: 0.121.0
+Version: 0.123.1
 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
@@ -20,6 +20,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aiohttp
 Requires-Dist: google-auth
+Requires-Dist: ollama>=0.4.7
+Requires-Dist: pillow>=11.0.0
 Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
@@ -144,6 +146,9 @@ Requires-Dist: langchain-google-genai>=2.0.0; extra == "gcp"
 Requires-Dist: langchain_google_alloydb_pg>=0.2.2; extra == "gcp"
 Requires-Dist: langchain-google-vertexai; extra == "gcp"
 Requires-Dist: pillow; extra == "gcp"
+Provides-Extra: ollama
+Requires-Dist: pillow; extra == "ollama"
+Requires-Dist: ollama>=0.4.7; extra == "ollama"
 Provides-Extra: openai
 Requires-Dist: langchain-openai>=0.3.2; extra == "openai"
 Requires-Dist: tiktoken; extra == "openai"
@@ -175,6 +180,7 @@ Requires-Dist: numpy; extra == "tts"
 Requires-Dist: sounddevice; extra == "tts"
 Provides-Extra: video
 Requires-Dist: opencv-python; extra == "video"
+Dynamic: license-file
 
 [![PyPi Version](https://img.shields.io/pypi/v/sunholo.svg)](https://pypi.python.org/pypi/sunholo/)
 

{sunholo-0.121.0.dist-info → sunholo-0.123.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sunholo/__init__.py,sha256=Ap2yX2ITBVt_vkloYipUM8OwW14g6aor2NX7LWp0-mI,1133
+sunholo/__init__.py,sha256=InRbX4V0-qdNHo9zYH3GEye7ASLR6LX8-SMvPV4Jsaw,1212
 sunholo/custom_logging.py,sha256=YfIN1oP3dOEkkYkyRBU8BGS3uJFGwUDsFCl8mIVbwvE,12225
 sunholo/langchain_types.py,sha256=uZ4zvgej_f7pLqjtu4YP7qMC_eZD5ym_5x4pyvA1Ih4,1834
 sunholo/agents/__init__.py,sha256=X2I3pPkGeKWjc3d0QgSpkTyqD8J8JtrEWqwrumf1MMc,391
@@ -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=q732tmRdSDutnUk7vRUPUPpi-yU5FK5rQko8co6yke0,19132
+sunholo/database/alloydb_client.py,sha256=WpkrQmy2hK4148df-6Ys8XRjCGpObZa9Dc9TXLSX_sE,27108
 sunholo/database/database.py,sha256=VqhZdkXUNdvWn8sUcUV3YNby1JDVf7IykPVXWBtxo9U,7361
 sunholo/database/lancedb.py,sha256=DyfZntiFKBlVPaFooNN1Z6Pl-LAs4nxWKKuq8GBqN58,715
 sunholo/database/static_dbs.py,sha256=8cvcMwUK6c32AS2e_WguKXWMkFf5iN3g9WHzsh0C07Q,442
@@ -112,6 +112,8 @@ sunholo/lookup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/lookup/model_lookup.yaml,sha256=O7o-jP53MLA06C8pI-ILwERShO-xf6z_258wtpZBv6A,739
 sunholo/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/mcp/cli.py,sha256=d24nnVzhZYz4AWgTqmN-qjKG4rPbf8RhdmEOHZkBHy8,10570
+sunholo/ollama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/ollama/ollama_images.py,sha256=H2cpcNu88R4TwyfL_nnqkQhdvBQ2FPCAy4Ok__0yQmo,2351
 sunholo/pubsub/__init__.py,sha256=DfTEk4zmCfqn6gFxRrqDO0pOrvXTDqH-medpgYO4PGw,117
 sunholo/pubsub/process_pubsub.py,sha256=rN2N4WM6PZkMKDrdT8pnEfTvsXACRyJFqIHJQCbuxLs,3088
 sunholo/pubsub/pubsub_manager.py,sha256=19w_N0LiG-wgVWvgJ13b8BUeN8ZzgSPXAhPmL1HRRSI,6966
@@ -166,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.121.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.121.0.dist-info/METADATA,sha256=xfdz083WUmJThGmmnsBzJl1kN_l5xw9L8ogD6L0i0qw,9808
-sunholo-0.121.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-sunholo-0.121.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.121.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.121.0.dist-info/RECORD,,
+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.121.0.dist-info → sunholo-0.123.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any