sunholo 0.116.2__py3-none-any.whl → 0.118.0__py3-none-any.whl

sunholo/cli/cli_init.py

@@ -200,7 +200,7 @@ def write_vac_config(project_dir: str, service_name: str):
 
     # Write the YAML configuration to the file
     with open(vac_config_path, 'w') as file:
-        yaml.dump(vac_config_content, file, default_flow_style=False)
+        yaml.dump(vac_config_content, file)
 
     print(f"{vac_config_path} written successfully with service name '{service_name}'.")
 

sunholo/genai/__init__.py

@@ -1,4 +1,5 @@
 from .process_funcs_cls import GenAIFunctionProcessor
 from .safety import genai_safety
 from .init import init_genai
-from .file_handling import download_gcs_upload_genai, construct_file_content
+from .file_handling import download_gcs_upload_genai, construct_file_content
+from .genaiv2 import GoogleAI, GoogleAIConfig

sunholo/genai/genaiv2.py

@@ -0,0 +1,542 @@
+from typing import Optional, List, Union, Dict, Any, TypedDict, TYPE_CHECKING, Generator
+
+import enum
+import json
+from pydantic import BaseModel
+import time
+try:
+    from google import genai
+    from google.genai import types
+except ImportError:
+    genai = None
+
+try:
+    import sounddevice as sd
+except ImportError:
+    sd = None
+except OSError:
+    sd = None
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+try:
+    import cv2 as cv2
+except ImportError:
+    cv2 = None
+
+if TYPE_CHECKING:
+    from google import genai
+    from google.genai import types
+    from google.genai.types import Tool, GenerateContentConfig, EmbedContentConfig
+else:
+    genai = None
+
+class GoogleAIConfig(BaseModel):
+    """Configuration class for GoogleAI client initialization.
+    See https://ai.google.dev/gemini-api/docs/models/gemini-v2
+    """
+    api_key: Optional[str] = None
+    project_id: Optional[str] = None
+    location: str = "us-central1"
+    use_vertex: bool = False
+
+class GoogleAI:
+    """A wrapper class for Google's v2 Generative AI APIs.
+    See https://ai.google.dev/gemini-api/docs/models/gemini-v2
+    """
+    
+    def __init__(self, config: GoogleAIConfig):
+        """Initialize the GoogleAI client.
+        
+        Args:
+            config (GoogleAIConfig): Configuration for client initialization
+        """
+        if genai is None:
+            raise ImportError("GoogleAI requires google-genai to be installed, try sunholo[gcp]")
+        if config.use_vertex:
+            if not config.project_id:
+                raise ValueError("project_id is required for Vertex AI")
+            self.client = genai.Client(
+                vertexai=True,
+                project=config.project_id,
+                location=config.location
+            )
+        else:
+            if not config.api_key:
+                raise ValueError("api_key is required for Google AI API")
+            self.client = genai.Client(api_key=config.api_key)
+        
+        self.default_model = "gemini-2.0-flash-exp"
+    
+    def google_search_tool(self) -> "types.Tool":
+        from google.genai.types import Tool, GoogleSearch
+        return Tool(
+            google_search = GoogleSearch()
+        )
+    def generate_text(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_output_tokens: int = 1024,
+        top_p: float = 0.95,
+        top_k: int = 20,
+        stop_sequences: Optional[List[str]] = None,
+        system_prompt: Optional[str] = None,
+        tools: Optional[List["types.Tool"]] = None
+    ) -> str:
+        """Generate text using the specified model.
+        
+        Args:
+            prompt (str): The input prompt
+            model (Optional[str]): Model name to use
+            temperature (float): Controls randomness (0.0-1.0)
+            max_output_tokens (int): Maximum number of tokens to generate
+            top_p (float): Nucleus sampling parameter
+            top_k (int): Top-k sampling parameter
+            stop_sequences (Optional[List[str]]): Sequences that stop generation
+            system_prompt (Optional[str]): System-level instruction
+            tools: list of python functions or Tool objects
+            
+        Returns:
+            str: Generated text response
+        """
+        model = model or self.default_model
+        
+        config = types.GenerateContentConfig(
+            temperature=temperature,
+            max_output_tokens=max_output_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            stop_sequences=stop_sequences or [],
+            tools=tools or []
+        )
+        
+        if system_prompt:
+            config.system_instruction = system_prompt
+            
+        response = self.client.models.generate_content(
+            model=model,
+            contents=prompt,
+            config=config
+        )
+        
+        return response.text
+
+    async def generate_text_async(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Async version of generate_text."""
+        model = model or self.default_model
+        response = await self.client.aio.models.generate_content(
+            model=model,
+            contents=prompt,
+            config=types.GenerateContentConfig(**kwargs)
+        )
+        return response.text
+        
+    async def _record_audio(
+            self,
+            duration: float = 5.0,
+            sample_rate: int = 16000
+        ) -> bytes:
+        """Internal method to record audio."""
+        if sd is None or np is None:
+            raise ImportError("sounddevice and numpy are required for audio. Install with pip install sunholo[tts]")
+        
+        print(f"Recording for {duration} seconds...")
+        audio_data = sd.rec(
+            int(duration * sample_rate),
+            samplerate=sample_rate,
+            channels=1,
+            dtype=np.int16
+        )
+        sd.wait()
+        print("Recording complete")
+        return audio_data.tobytes()
+
+    async def _record_video(
+            self,
+            duration: float = 5.0
+        ) -> List[bytes]:
+        """Internal method to record video frames."""
+        import cv2
+        
+        frames = []
+        screen = cv2.VideoCapture(0)
+        start_time = time.time()
+        
+        try:
+            while time.time() - start_time < duration:
+                ret, frame = screen.read()
+                if ret:
+                    _, buffer = cv2.imencode('.jpg', frame)
+                    frames.append(buffer.tobytes())
+                    time.sleep(0.1)  # Limit frame rate
+        finally:
+            screen.release()
+        
+        return frames
+
+    async def _process_responses(self, session) -> List[str]:
+        """Internal method to process session responses."""
+        responses = []
+        i = 1
+        async for response in session.receive():
+            model_turn = response.server_content.model_turn
+            if model_turn is None:
+                continue
+            for part in model_turn.parts:
+                text = part.text
+                print(f"[{i}] {text}")
+                i += 1
+                responses.append(text)
+        return responses
+
+    async def live_async(
+            self,
+            prompt: Optional[Union[str, List[Union[str, bytes]]]] = None,
+            input_type: str = "text",  # "text", "audio", or "video"
+            duration: Optional[float] = None,  # For audio/video recording duration
+            model: Optional[str] = None,
+            **kwargs
+        ) -> str:
+        """Live Multimodal API with support for text, audio, and video inputs.
+        
+        Args:
+            input_type: Type of input ("text", "audio", or "video")
+            prompt: Text prompt or list of text/binary chunks
+            duration: Recording duration for audio/video in seconds
+            model: Optional model name
+            **kwargs: Additional configuration parameters
+        
+        Returns:
+            str: Generated response text
+        """
+        client = genai.Client(
+            http_options={
+                'api_version': 'v1alpha',
+                'url': 'generativelanguage.googleapis.com',
+            }
+        )
+        
+        config = {
+            "generation_config": {"response_modalities": ["TEXT"]}
+        }
+
+        async with client.aio.live.connect(model=self.default_model, config=config) as session:
+            # Handle different input types
+            if input_type == "text":
+                message = {
+                    "client_content": {
+                        "turns": [
+                            {
+                                "parts": [{"text": prompt}],
+                                "role": "user"
+                            }
+                        ],
+                        "turn_complete": True
+                    }
+                }
+                await session.send(json.dumps(message), end_of_turn=True)
+            
+            elif input_type == "audio":
+                audio_data = await self._record_audio(duration=duration or 5.0)
+                message = {"media_chunks": [audio_data]}
+                await session.send(message)
+                await session.send(json.dumps({"turn_complete": True}), end_of_turn=True)
+            
+            elif input_type == "video":
+                frames = await self._record_video(duration=duration or 5.0)
+                for frame in frames:
+                    message = {"media_chunks": [frame]}
+                    await session.send(message)
+                await session.send(json.dumps({"turn_complete": True}), end_of_turn=True)
+            
+            else:
+                raise ValueError(f"Unsupported input_type: {input_type}")
+
+            # Process responses
+            responses = await self._process_responses(session)
+            return "OK"
+        
+    def gs_uri(self, uri, mime_type=None):
+      
+        if mime_type is None:
+            from ..utils.mime import guess_mime_type
+            mime_type = guess_mime_type(uri)
+
+        return types.Part.from_uri(
+            file_uri=uri,
+            mime_type=mime_type,
+        )
+
+    def local_file(self, filename, mime_type=None):
+        if mime_type is None:
+            from ..utils.mime import guess_mime_type
+            mime_type = guess_mime_type(filename)
+
+        with open(filename, 'rb') as f:
+            image_bytes = f.read()
+        
+        if image_bytes and mime_type:
+            return types.Part.from_bytes(
+                data=image_bytes,
+                mime_type=mime_type,
+            )
+        else:
+            raise ValueError(f"Could not read bytes or mime_type for {filename=} - {mime_type=}")
+
+    def stream_text(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        **kwargs
+    ) -> "Generator[str, None, None]":
+        """Stream text generation responses.
+        
+        Args:
+            prompt (str): The input prompt
+            model (Optional[str]): Model name to use
+            **kwargs: Additional configuration parameters
+            
+        Yields:
+            str: Chunks of generated text
+        """
+        model = model or self.default_model
+        for chunk in self.client.models.generate_content_stream(
+            model=model,
+            contents=prompt,
+            config=types.GenerateContentConfig(**kwargs)
+        ):
+            yield chunk.text
+            
+    def get_embedding(
+        self,
+        text: Union[str, List[str]],
+        model: str = "text-embedding-004",
+        output_dim: Optional[int] = None
+    ) -> Union[List[float], List[List[float]]]:
+        """Get text embeddings.
+        
+        Args:
+            text (Union[str, List[str]]): Text to embed
+            model (str): Embedding model to use
+            output_dim (Optional[int]): Desired embedding dimension
+            
+        Returns:
+            Union[List[float], List[List[float]]]: Embeddings
+        """
+        config = {}
+        if output_dim:
+            config["output_dimensionality"] = output_dim
+            
+        response = self.client.models.embed_content(
+            model=model,
+            contents=text,
+            config=types.EmbedContentConfig(**config) if config else None
+        )
+        
+        if isinstance(text, str):
+            return response.embeddings[0].values
+        return [emb.values for emb in response.embeddings]
+
+    def structured_output(
+        self,
+        prompt: str,
+        schema: Union[BaseModel, Dict, type, TypedDict],
+        model: Optional[str] = None,
+        is_list: bool = False
+    ) -> Dict:
+        """Generate structured output according to a schema.
+        
+        Args:
+            prompt (str): Input prompt
+            schema (Union[BaseModel, Dict, type]): Schema definition (Pydantic model, TypedDict, or raw schema)
+            model (Optional[str]): Model to use
+            is_list (bool): Whether to wrap the schema in a list
+            
+        Returns:
+            Dict: Structured response matching schema
+        """
+        model = model or self.default_model
+        
+        # Handle TypedDict differently than Pydantic models
+        if isinstance(schema, type):
+            if hasattr(schema, '__origin__') and schema.__origin__ is list:
+                # Handle list[TypedDict] case
+                inner_type = schema.__args__[0]
+                config = types.GenerateContentConfig(
+                    response_mime_type='application/json',
+                    response_schema=schema
+                )
+            elif hasattr(schema, '__annotations__'):  # TypedDict check
+                # Create API-compatible schema
+                schema_dict = {
+                    'type': 'OBJECT',
+                    'properties': {},
+                    'required': list(schema.__annotations__.keys())  # TypedDict fields are required by default
+                }
+                
+                for field_name, field_type in schema.__annotations__.items():
+                    if hasattr(field_type, '__base__') and field_type.__base__ == enum.Enum:
+                        schema_dict['properties'][field_name] = {
+                            'type': 'STRING',
+                            'enum': [e.value for e in field_type]
+                        }
+                    elif field_type is str:
+                        schema_dict['properties'][field_name] = {'type': 'STRING'}
+                    elif field_type is int:
+                        schema_dict['properties'][field_name] = {'type': 'INTEGER'}
+                    elif field_type is float:
+                        schema_dict['properties'][field_name] = {'type': 'NUMBER'}
+                    elif field_type is bool:
+                        schema_dict['properties'][field_name] = {'type': 'BOOLEAN'}
+                    else:
+                        schema_dict['properties'][field_name] = {'type': 'STRING'}
+                
+                if is_list:
+                    schema_dict = {
+                        'type': 'ARRAY',
+                        'items': schema_dict
+                    }
+                
+                config = types.GenerateContentConfig(
+                    response_mime_type='application/json',
+                    response_schema=schema_dict
+                )
+            elif hasattr(schema, '__origin__') and schema.__origin__ is list:
+                # Handle List[TypeDict] case
+                inner_type = schema.__args__[0]
+                if hasattr(inner_type, '__annotations__'):  # Check if inner type is TypedDict
+                    # Create API-compatible schema for the inner TypedDict
+                    schema_dict = {
+                        'type': 'OBJECT',
+                        'properties': {},
+                        'required': list(inner_type.__annotations__.keys())
+                    }
+                    
+                    for field_name, field_type in inner_type.__annotations__.items():
+                        if hasattr(field_type, '__base__') and field_type.__base__ == enum.Enum:
+                            schema_dict['properties'][field_name] = {
+                                'type': 'STRING',
+                                'enum': [e.value for e in field_type]
+                            }
+                        elif field_type is str:
+                            schema_dict['properties'][field_name] = {'type': 'STRING'}
+                        elif field_type is int:
+                            schema_dict['properties'][field_name] = {'type': 'INTEGER'}
+                        elif field_type is float:
+                            schema_dict['properties'][field_name] = {'type': 'NUMBER'}
+                        elif field_type is bool:
+                            schema_dict['properties'][field_name] = {'type': 'BOOLEAN'}
+                        else:
+                            schema_dict['properties'][field_name] = {'type': 'STRING'}
+                    
+                    # Wrap in array type
+                    array_schema = {
+                        'type': 'ARRAY',
+                        'items': schema_dict
+                    }
+                    
+                    config = types.GenerateContentConfig(
+                        response_mime_type='application/json',
+                        response_schema=array_schema
+                    )
+            elif issubclass(schema, BaseModel):
+                # Convert Pydantic model to Google's schema format
+                schema_dict = {
+                    'type': 'OBJECT',
+                    'properties': {},
+                    'required': []
+                }
+                
+                for field_name, field_info in schema.model_fields.items():
+                    # Handle different field types including enums
+                    if isinstance(field_info.annotation, type) and issubclass(field_info.annotation, enum.Enum):
+                        field_type = {
+                            'type': 'STRING',
+                            'enum': [e.value for e in field_info.annotation]
+                        }
+                    elif field_info.annotation is str:
+                        field_type = {'type': 'STRING'}
+                    elif field_info.annotation is int:
+                        field_type = {'type': 'INTEGER'}
+                    elif field_info.annotation is float:
+                        field_type = {'type': 'NUMBER'}
+                    elif field_info.annotation is bool:
+                        field_type = {'type': 'BOOLEAN'}
+                    elif field_info.annotation is list or (
+                        hasattr(field_info.annotation, '__origin__') and 
+                        field_info.annotation.__origin__ is list
+                    ):
+                        # Handle typed lists
+                        if hasattr(field_info.annotation, '__args__'):
+                            inner_type = field_info.annotation.__args__[0]
+                            if inner_type is str:
+                                item_type = 'STRING'
+                            elif inner_type is int:
+                                item_type = 'INTEGER'
+                            elif inner_type is float:
+                                item_type = 'NUMBER'
+                            elif inner_type is bool:
+                                item_type = 'BOOLEAN'
+                            else:
+                                item_type = 'STRING'
+                        else:
+                            item_type = 'STRING'
+                        field_type = {'type': 'ARRAY', 'items': {'type': item_type}}
+                    else:
+                        field_type = {'type': 'STRING'}
+                    
+                    schema_dict['properties'][field_name] = field_type
+                    if field_info.is_required:
+                        schema_dict['required'].append(field_name)
+                
+                if is_list:
+                    schema_dict = {
+                        'type': 'ARRAY',
+                        'items': schema_dict
+                    }
+                
+                config = types.GenerateContentConfig(
+                    response_mime_type='application/json',
+                    response_schema=schema_dict
+                )
+        else:
+            # Handle raw schema dict
+            config = types.GenerateContentConfig(
+                response_mime_type='application/json',
+                response_schema=schema
+            )
+            
+        response = self.client.models.generate_content(
+            model=model,
+            contents=prompt,
+            config=config
+        )
+        
+        return response.text
+    def count_tokens(self, text: str, model: Optional[str] = None) -> int:
+        """Count the number of tokens in the text.
+        
+        Args:
+            text (str): Input text
+            model (Optional[str]): Model to use for tokenization
+            
+        Returns:
+            int: Number of tokens
+        """
+        model = model or self.default_model
+        response = self.client.models.count_tokens(
+            model=model,
+            contents=text
+        )
+        return response.total_tokens
+

sunholo/langfuse/evals.py

@@ -2,7 +2,7 @@ import os
 import json
 
 from ..pubsub import decode_pubsub_message
-from langfuse import Langfuse
+
 import traceback
 
 
@@ -55,6 +55,7 @@ def direct_langfuse_evals(data, eval_funcs: list=[eval_length]):
 
 
 def do_evals(trace_id, eval_funcs: list=[eval_length], **kwargs) -> dict:
+    from langfuse import Langfuse
     # Initialize Langfuse with environment variables
     langfuse = Langfuse(
         secret_key=os.environ["LANGFUSE_SECRET_KEY"],

sunholo/mcp/cli.py

@@ -3,7 +3,6 @@ import asyncio
 from typing import Any, Sequence
 from functools import lru_cache
 import subprocess
-from ..utils.version import sunholo_version
 
 try:
     from mcp.server import Server
@@ -68,7 +67,6 @@ class SunholoMCPServer:
         async def read_resource(uri: AnyUrl) -> str:
             """Read Sunholo resources based on URI"""
             logger.info(f"{uri} available")
-            console.print(f"{uri} available")
             if str(uri) == "sunholo://vacs/list":
                 try:
                     # Execute sunholo vac list command

sunholo/utils/big_context.py

@@ -43,7 +43,7 @@ def load_gitignore_patterns(gitignore_path):
     """
     with open(gitignore_path, 'r') as f:
         patterns = [line.strip() for line in f if line.strip() and not line.startswith('#')]
-    patterns.extend(["*.git/*", "*.terraform/*"])
+    patterns.extend([".git/", ".terraform/"]) # More precise pattern matching
     return patterns
 
 def should_ignore(file_path, patterns):
@@ -62,11 +62,18 @@ def should_ignore(file_path, patterns):
         True
     """
     rel_path = os.path.relpath(file_path)
-
+    
     for pattern in patterns:
-        if fnmatch(rel_path, pattern) or fnmatch(os.path.basename(rel_path), pattern):
+        # Handle directory patterns ending with /
+        if pattern.endswith('/'):
+            if any(part == pattern[:-1] for part in rel_path.split(os.sep)):
+                print(f"Ignoring {rel_path}")
+                return True
+        # Handle file patterns
+        elif fnmatch(rel_path, pattern):
+            print(f"Ignoring {rel_path}")
             return True
-
+    
     return False
 
 

{sunholo-0.116.2.dist-info → sunholo-0.118.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sunholo
-Version: 0.116.2
+Version: 0.118.0
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.116.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -47,6 +47,7 @@ Requires-Dist: google-cloud-pubsub; extra == "all"
 Requires-Dist: google-cloud-discoveryengine; extra == "all"
 Requires-Dist: google-cloud-texttospeech; extra == "all"
 Requires-Dist: google-generativeai>=0.7.1; extra == "all"
+Requires-Dist: google-genai; extra == "all"
 Requires-Dist: gunicorn; extra == "all"
 Requires-Dist: httpcore; extra == "all"
 Requires-Dist: httpx; extra == "all"
@@ -64,6 +65,7 @@ Requires-Dist: langchain-unstructured; extra == "all"
 Requires-Dist: langfuse; extra == "all"
 Requires-Dist: mcp; extra == "all"
 Requires-Dist: numpy; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
 Requires-Dist: pg8000; extra == "all"
 Requires-Dist: pgvector; extra == "all"
 Requires-Dist: pillow; extra == "all"
@@ -118,9 +120,9 @@ Requires-Dist: unstructured[all-docs,local-inference]; extra == "pipeline"
 Provides-Extra: gcp
 Requires-Dist: anthropic[vertex]; extra == "gcp"
 Requires-Dist: google-api-python-client; extra == "gcp"
-Requires-Dist: google-cloud-alloydb-connector[pg8000]; extra == "gcp"
 Requires-Dist: google-auth-httplib2; extra == "gcp"
 Requires-Dist: google-auth-oauthlib; extra == "gcp"
+Requires-Dist: google-cloud-alloydb-connector[pg8000]; extra == "gcp"
 Requires-Dist: google-cloud-aiplatform>=1.58.0; extra == "gcp"
 Requires-Dist: google-cloud-bigquery; extra == "gcp"
 Requires-Dist: google-cloud-build; extra == "gcp"
@@ -130,6 +132,7 @@ Requires-Dist: google-cloud-logging; extra == "gcp"
 Requires-Dist: google-cloud-pubsub; extra == "gcp"
 Requires-Dist: google-cloud-discoveryengine; extra == "gcp"
 Requires-Dist: google-cloud-texttospeech; extra == "gcp"
+Requires-Dist: google-genai; extra == "gcp"
 Requires-Dist: google-generativeai>=0.8.3; extra == "gcp"
 Requires-Dist: langchain-google-genai>=2.0.0; extra == "gcp"
 Requires-Dist: langchain_google_alloydb_pg>=0.2.2; extra == "gcp"
@@ -164,6 +167,20 @@ Provides-Extra: tts
 Requires-Dist: google-cloud-texttospeech; extra == "tts"
 Requires-Dist: numpy; extra == "tts"
 Requires-Dist: sounddevice; extra == "tts"
+Provides-Extra: video
+Requires-Dist: opencv-python; extra == "video"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 [![PyPi Version](https://img.shields.io/pypi/v/sunholo.svg)](https://pypi.python.org/pypi/sunholo/)
 

{sunholo-0.116.2.dist-info → sunholo-0.118.0.dist-info}/RECORD

@@ -45,7 +45,7 @@ sunholo/chunker/splitter.py,sha256=RfekLPkjhCcNd1PFXIj_FxusJMJ8_3cyWl7bsYvtQ0g,7
 sunholo/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/cli/chat_vac.py,sha256=sYPzUDwwwebJvIobv3GRW_xbQQ4BTy9G-WHdarGCHB0,23705
 sunholo/cli/cli.py,sha256=WiWyLywKwuKR46H7a-mBLO0c7jMW-PNl8th2Mj7ioMs,4606
-sunholo/cli/cli_init.py,sha256=u6BZFtUyFMOKrXZ46-DfET0IpH3Tl2PlOz386rADtrw,8549
+sunholo/cli/cli_init.py,sha256=Nz-VvM-35K2FEsijpHeGWjT3qid5NWI1mPqE-3r_FFk,8523
 sunholo/cli/configs.py,sha256=QUM9DvKOdZmEQRM5uI3Nh887T0YDiSMr7O240zTLqws,4546
 sunholo/cli/deploy.py,sha256=zxdwUsRTRMC8U5vyRv0JiKBLFn84Ug_Tc88-_h9hJSs,1609
 sunholo/cli/embedder.py,sha256=v-FKiSPHaQzB6ctClclYueIf3bf3CqYtC1oRgPfT4dY,5566
@@ -86,8 +86,9 @@ sunholo/gcs/download_folder.py,sha256=ijJTnS595JqZhBH8iHFErQilMbkuKgL-bnTCMLGuvl
 sunholo/gcs/download_url.py,sha256=Ul81n1rklr8WogPsuxWWD1Nr8RHU451LzHPMJNhAKzw,6416
 sunholo/gcs/extract_and_sign.py,sha256=paRrTCvCN5vkQwCB7OSkxWi-pfOgOtZ0bwdXE08c3Ps,1546
 sunholo/gcs/metadata.py,sha256=oQLcXi4brsZ74aegWyC1JZmhlaEV270HS5_UWtAYYWE,898
-sunholo/genai/__init__.py,sha256=6SWK7uV5F625J-P3xQoD6WKL59a9RSaidj-Guslyt8Q,192
+sunholo/genai/__init__.py,sha256=TV3PYHWoR4cChdmCOaYB0PtAEQ86qol9XYYEtb1JmSA,239
 sunholo/genai/file_handling.py,sha256=Z3E7TR1DnP9WnneeEGC8LcT6k-9GFxwXDPaVZWw8HLE,8366
+sunholo/genai/genaiv2.py,sha256=uqWcfvlsPVPyQo-W_cP9h2TTzyYfzj4lyJlyqPyKTkI,20269
 sunholo/genai/images.py,sha256=EyjsDqt6XQw99pZUQamomCpMOoIah9bp3XY94WPU7Ms,1678
 sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
 sunholo/genai/process_funcs_cls.py,sha256=D6eNrc3vtTZzwdkacZNOSfit499N_o0C5AHspyUJiYE,33690
@@ -98,7 +99,7 @@ sunholo/invoke/direct_vac_func.py,sha256=dACx3Zh7uZnuWLIFYiyLoyXUhh5-eUpd2RatDUd
 sunholo/invoke/invoke_vac_utils.py,sha256=sJc1edHTHMzMGXjji1N67c3iUaP7BmAL5nj82Qof63M,2053
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/langfuse/callback.py,sha256=jl0SZsFS53uMW9DGeM9SOL_EsRZsba0wwFGLqKzu9_U,1684
-sunholo/langfuse/evals.py,sha256=fQBaC0dBTYfgCzyfv9QBRvUfc9f42lbwQAeZmynaHO8,3841
+sunholo/langfuse/evals.py,sha256=P6bMK22ujySYcuH1qVdnUNAmV3p1KBshYUYpfdbMWF4,3846
 sunholo/langfuse/prompts.py,sha256=E3ZBd51k8NWkeO7K-uYkUPJhbqJWXee8X0N79pVCaIA,2744
 sunholo/llamaindex/__init__.py,sha256=DlY_cHWCsVEV1C5WBgDdHRgOMlJc8pDoCRukUJ8PT9w,88
 sunholo/llamaindex/get_files.py,sha256=6rhXCDqQ_lrIapISQ_OYQDjiSATXvS_9m3qq53-oIl0,781
@@ -108,7 +109,7 @@ sunholo/llamaindex/user_history.py,sha256=ZtkecWuF9ORduyGB8kF8gP66bm9DdvCI-ZiK6K
 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=D9IFMSffCsRO6vFayzukiVX9s3CvoFFyJUcQ0S6db1s,10660
+sunholo/mcp/cli.py,sha256=d24nnVzhZYz4AWgTqmN-qjKG4rPbf8RhdmEOHZkBHy8,10570
 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
@@ -130,7 +131,7 @@ sunholo/tools/__init__.py,sha256=5NuYpwwTX81qGUWvgwfItoSLXteNnp7KjgD7IPZUFjI,53
 sunholo/tools/web_browser.py,sha256=8Gdf02F4zCOeSnijnfaL6jzk4oaSI0cj48o-esoWzwE,29086
 sunholo/utils/__init__.py,sha256=Hv02T5L2zYWvCso5hzzwm8FQogwBq0OgtUbN_7Quzqc,89
 sunholo/utils/api_key.py,sha256=Ct4bIAQZxzPEw14hP586LpVxBAVi_W9Serpy0BK-7KI,244
-sunholo/utils/big_context.py,sha256=gJIP7_ZL-YSLhOMq8jmFTMqH1wq8eB1NK7oKPeZAq2s,5578
+sunholo/utils/big_context.py,sha256=iJRbJlpgEMR8BSpSiOw35wRtZ-mjChVlei8m0lf6tIY,5876
 sunholo/utils/config.py,sha256=bz0ODJyqnoHQIsk4pmNpVxxq5WvwS0SfOq4cnCjQPJk,9105
 sunholo/utils/config_class.py,sha256=Z4sGzEkuxlCAJ8b-65_yzLmybnunywwOD9eXL8an5Wg,9619
 sunholo/utils/config_schema.py,sha256=Wv-ncitzljOhgbDaq9qnFqH5LCuxNv59dTGDWgd1qdk,4189
@@ -149,9 +150,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.116.2.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.116.2.dist-info/METADATA,sha256=YUoz-Kw42oDa68pBZ6Qd1gygiihKtR36SqJ0OnXl-6I,9297
-sunholo-0.116.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sunholo-0.116.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.116.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.116.2.dist-info/RECORD,,
+sunholo-0.118.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.118.0.dist-info/METADATA,sha256=b8HJvu2GA9AJqTfFcqKBRCw8ArVt71zvQwDUAKuKK3A,9752
+sunholo-0.118.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+sunholo-0.118.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.118.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.118.0.dist-info/RECORD,,

{sunholo-0.116.2.dist-info → sunholo-0.118.0.dist-info}/WHEEL

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