chat-console 0.4.3__py3-none-any.whl → 0.4.6__py3-none-any.whl

app/console_main.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Entry point for the pure console version of Chat CLI
+"""
+
+import os
+import sys
+import asyncio
+import argparse
+import logging
+
+# Setup logging suppression BEFORE any imports
+def setup_console_logging():
+    """Setup logging to minimize disruption to console UI - must run before imports"""
+    # Set root logger to ERROR to suppress all INFO messages
+    logging.getLogger().setLevel(logging.ERROR)
+    
+    # Completely disable all handlers to prevent any output
+    logging.basicConfig(
+        level=logging.CRITICAL,  # Only show CRITICAL messages
+        format='',  # Empty format
+        handlers=[logging.NullHandler()]  # Null handler suppresses all output
+    )
+    
+    # Clear any existing handlers
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    
+    # Add only NullHandler
+    logging.root.addHandler(logging.NullHandler())
+    
+    # Pre-emptively suppress known noisy loggers
+    for logger_name in ['app', 'app.api', 'app.api.base', 'app.api.ollama', 
+                        'app.utils', 'app.console_utils', 'aiohttp', 'urllib3', 
+                        'httpx', 'asyncio', 'root']:
+        logging.getLogger(logger_name).setLevel(logging.ERROR)
+        logging.getLogger(logger_name).addHandler(logging.NullHandler())
+
+# Apply logging suppression immediately
+setup_console_logging()
+
+async def run_console_app():
+    """Run the console application"""
+    from .console_chat import main as console_main
+    await console_main()
+
+def main():
+    """Main entry point for console version"""
+    try:
+        asyncio.run(run_console_app())
+    except KeyboardInterrupt:
+        print("\nGoodbye!")
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

app/console_utils.py

@@ -0,0 +1,195 @@
+"""
+Console-specific utilities for the pure terminal version
+No Textual dependencies
+"""
+
+import asyncio
+import time
+from typing import Dict, List, Any, Optional, Callable, AsyncGenerator
+from .api.base import BaseModelClient
+
+async def console_streaming_response(
+    messages: List[Dict[str, str]],
+    model: str,
+    style: Optional[str],
+    client: BaseModelClient,
+    update_callback: Optional[Callable[[str], None]] = None
+) -> AsyncGenerator[str, None]:
+    """
+    Enhanced streaming response for console UI with provider-specific optimizations
+    """
+    try:
+        # Detect provider type for optimizations
+        client_type = type(client).__name__.lower()
+        is_ollama = 'ollama' in client_type
+        is_openai = 'openai' in client_type
+        is_anthropic = 'anthropic' in client_type
+        
+        # Initialize tracking variables
+        full_content = ""
+        buffer = []
+        last_update = time.time()
+        
+        # Provider-specific configuration
+        if is_ollama:
+            update_interval = 0.15  # Slower updates for Ollama (model loading)
+            buffer_size = 3  # Smaller buffer for Ollama
+        elif is_openai:
+            update_interval = 0.08  # Fast updates for OpenAI
+            buffer_size = 5  # Medium buffer for OpenAI
+        elif is_anthropic:
+            update_interval = 0.1   # Medium updates for Anthropic
+            buffer_size = 4  # Medium buffer for Anthropic
+        else:
+            update_interval = 0.1   # Default timing
+            buffer_size = 4  # Default buffer
+        
+        # Special handling for reasoning models (slower, more deliberate)
+        if model.startswith(("o1", "o3", "o4")) or model in ["o1", "o3", "o4-mini"]:
+            update_interval = 0.2  # Slower updates for reasoning models
+            buffer_size = 2  # Smaller buffer for reasoning
+        
+        async for chunk in client.generate_stream(
+            messages=messages,
+            model=model,
+            style=style
+        ):
+            if chunk:
+                buffer.append(chunk)
+                current_time = time.time()
+                
+                # Update based on time interval or buffer size
+                should_update = (
+                    current_time - last_update >= update_interval or
+                    len(buffer) >= buffer_size or
+                    len(full_content) < 100  # Always update quickly for first few chars
+                )
+                
+                if should_update:
+                    # Process buffered chunks
+                    new_content = ''.join(buffer)
+                    full_content += new_content
+                    buffer = []
+                    last_update = current_time
+                    
+                    # Call update callback with accumulated content
+                    if update_callback:
+                        update_callback(full_content)
+                    
+                    # Yield the new chunk for compatibility
+                    yield new_content
+                    
+                    # Provider-specific delays
+                    if is_ollama:
+                        await asyncio.sleep(0.02)  # Small delay for Ollama
+                    elif is_openai and not model.startswith(("o1", "o3", "o4")):
+                        await asyncio.sleep(0.01)  # Minimal delay for fast OpenAI models
+                    else:
+                        await asyncio.sleep(0.015)  # Default delay
+        
+        # Process any remaining buffer content
+        if buffer:
+            final_content = ''.join(buffer)
+            full_content += final_content
+            if update_callback:
+                update_callback(full_content)
+            yield final_content
+                
+    except asyncio.CancelledError:
+        # Handle cancellation gracefully
+        if update_callback:
+            update_callback(full_content + "\n[Generation cancelled]")
+        raise
+        
+    except Exception as e:
+        error_msg = f"Error generating response: {str(e)}"
+        if update_callback:
+            update_callback(error_msg)
+        yield error_msg
+
+def apply_style_prefix(messages: List[Dict[str, str]], style: str) -> List[Dict[str, str]]:
+    """Apply style instructions to the message list"""
+    if not style or style == "default":
+        return messages
+    
+    style_instructions = {
+        "concise": "Please provide a brief and concise response.",
+        "detailed": "Please provide a comprehensive and detailed response.",
+        "technical": "Please provide a technical response with precise terminology.",
+        "friendly": "Please provide a warm and friendly response."
+    }
+    
+    instruction = style_instructions.get(style, "")
+    if instruction and messages:
+        # Add style instruction to the first user message
+        modified_messages = messages.copy()
+        for msg in modified_messages:
+            if msg["role"] == "user":
+                msg["content"] = f"{instruction}\n\n{msg['content']}"
+                break
+        return modified_messages
+    
+    return messages
+
+async def test_model_connection(model: str) -> bool:
+    """Test if we can connect to the specified model"""
+    try:
+        client = await BaseModelClient.get_client_for_model(model)
+        # Try a simple test message
+        test_messages = [{"role": "user", "content": "Hello"}]
+        async for _ in client.generate_stream(test_messages, model):
+            break  # Just test that we can start streaming
+        return True
+    except Exception:
+        return False
+
+def format_model_list() -> List[str]:
+    """Format the available models for console display"""
+    from .config import CONFIG
+    
+    formatted = []
+    for model_id, model_info in CONFIG["available_models"].items():
+        provider = model_info["provider"].capitalize()
+        display_name = model_info["display_name"]
+        formatted.append(f"{display_name} ({provider})")
+    
+    return formatted
+
+def get_terminal_size():
+    """Get terminal size with fallback"""
+    try:
+        import shutil
+        return shutil.get_terminal_size()
+    except Exception:
+        # Fallback size
+        class Size:
+            columns = 80
+            lines = 24
+        return Size()
+
+def truncate_text(text: str, max_length: int, suffix: str = "...") -> str:
+    """Truncate text to fit within max_length"""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - len(suffix)] + suffix
+
+def word_wrap(text: str, width: int) -> List[str]:
+    """Wrap text to specified width"""
+    words = text.split()
+    lines = []
+    current_line = ""
+    
+    for word in words:
+        if len(current_line) + len(word) + 1 <= width:
+            if current_line:
+                current_line += " "
+            current_line += word
+        else:
+            if current_line:
+                lines.append(current_line)
+            current_line = word
+    
+    if current_line:
+        lines.append(current_line)
+    
+    return lines or [""]