dtSpark 1.0.4__py3-none-any.whl

dtSpark/database/credential_prompt.py

@@ -0,0 +1,218 @@
+"""
+Database credential prompting utility.
+
+Provides interactive prompts for missing database credentials.
+
+
+"""
+
+import logging
+import getpass
+from typing import Optional
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+
+from .backends import DatabaseCredentials
+
+
+def prompt_for_credentials(db_type: str, existing_credentials: Optional[DatabaseCredentials] = None) -> DatabaseCredentials:
+    """
+    Interactively prompt user for missing database credentials.
+
+    Args:
+        db_type: Database type (sqlite, mysql, mariadb, postgresql, mssql)
+        existing_credentials: Existing credentials (will only prompt for missing fields)
+
+    Returns:
+        Complete DatabaseCredentials object
+    """
+    console = Console()
+    db_type_lower = db_type.lower()
+
+    # Start with existing credentials or create new
+    if existing_credentials:
+        creds = existing_credentials
+    else:
+        creds = DatabaseCredentials()
+
+    # SQLite only needs path
+    if db_type_lower == 'sqlite':
+        if not creds.path:
+            creds.path = Prompt.ask(
+                "Enter SQLite database file path",
+                default="./running/conversations.db"
+            )
+        return creds
+
+    # Display information panel
+    console.print()
+    console.print(Panel(
+        f"[bold cyan]Database Connection Setup[/bold cyan]\n\n"
+        f"Database type: [yellow]{db_type}[/yellow]\n\n"
+        f"Please provide connection credentials for your database server.",
+        border_style="cyan",
+        padding=(1, 2)
+    ))
+    console.print()
+
+    # Prompt for remote database credentials
+    if not creds.host:
+        creds.host = Prompt.ask(
+            "Database host",
+            default="localhost"
+        )
+
+    if not creds.port:
+        default_ports = {
+            'mysql': 3306,
+            'mariadb': 3306,
+            'postgresql': 5432,
+            'mssql': 1433,
+            'sqlserver': 1433
+        }
+        default_port = default_ports.get(db_type_lower, 3306)
+
+        port_input = Prompt.ask(
+            "Database port",
+            default=str(default_port)
+        )
+        creds.port = int(port_input)
+
+    if not creds.database:
+        creds.database = Prompt.ask(
+            "Database name",
+            default="dtawsbedrockcli"
+        )
+
+    if not creds.username:
+        creds.username = Prompt.ask("Database username")
+
+    if not creds.password:
+        # Use getpass for secure password input
+        console.print("[cyan]Database password:[/cyan] ", end="")
+        creds.password = getpass.getpass("")
+
+    # SSL option
+    use_ssl = Confirm.ask("Use SSL/TLS connection?", default=False)
+    creds.ssl = use_ssl
+
+    # MSSQL-specific: driver selection
+    if db_type_lower in ('mssql', 'sqlserver', 'mssqlserver'):
+        if not creds.driver:
+            drivers = [
+                "ODBC Driver 17 for SQL Server",
+                "ODBC Driver 18 for SQL Server",
+                "SQL Server Native Client 11.0",
+                "Custom"
+            ]
+
+            console.print()
+            console.print("[bold cyan]Select ODBC driver:[/bold cyan]")
+            for i, driver in enumerate(drivers, 1):
+                console.print(f"  [{i}] {driver}")
+
+            choice = Prompt.ask(
+                "Driver selection",
+                choices=[str(i) for i in range(1, len(drivers) + 1)],
+                default="1"
+            )
+
+            choice_idx = int(choice) - 1
+            if choice_idx == len(drivers) - 1:  # Custom
+                creds.driver = Prompt.ask("Enter custom ODBC driver name")
+            else:
+                creds.driver = drivers[choice_idx]
+
+    console.print()
+    logging.info(f"Database credentials collected for {db_type}")
+
+    return creds
+
+
+def test_credentials(db_type: str, credentials: DatabaseCredentials) -> tuple[bool, Optional[str]]:
+    """
+    Test database credentials by attempting connection.
+
+    Args:
+        db_type: Database type
+        credentials: Database credentials
+
+    Returns:
+        Tuple of (success, error_message)
+    """
+    from .backends import create_backend
+
+    console = Console()
+
+    try:
+        console.print()
+        console.print("[cyan]Testing database connection...[/cyan]")
+
+        backend = create_backend(db_type, credentials)
+        success = backend.test_connection()
+        backend.close()
+
+        if success:
+            console.print("[green]✓ Database connection successful![/green]")
+            return True, None
+        else:
+            error_msg = "Connection test query failed"
+            console.print(f"[red]✗ {error_msg}[/red]")
+            return False, error_msg
+
+    except ImportError as e:
+        error_msg = str(e)
+        console.print(f"[red]✗ {error_msg}[/red]")
+        return False, error_msg
+
+    except Exception as e:
+        error_msg = f"Connection failed: {str(e)}"
+        console.print(f"[red]✗ {error_msg}[/red]")
+        logging.error(f"Database connection test failed: {e}", exc_info=True)
+        return False, error_msg
+
+
+def prompt_and_validate_credentials(db_type: str,
+                                    existing_credentials: Optional[DatabaseCredentials] = None,
+                                    max_retries: int = 3) -> Optional[DatabaseCredentials]:
+    """
+    Prompt for credentials and validate them, with retry support.
+
+    Args:
+        db_type: Database type
+        existing_credentials: Existing credentials (will only prompt for missing fields)
+        max_retries: Maximum number of retry attempts
+
+    Returns:
+        Valid DatabaseCredentials or None if max retries exceeded
+    """
+    console = Console()
+    creds = existing_credentials
+
+    for attempt in range(max_retries):
+        # Prompt for credentials
+        creds = prompt_for_credentials(db_type, creds)
+
+        # Test credentials
+        success, error_msg = test_credentials(db_type, creds)
+
+        if success:
+            return creds
+
+        # Failed - offer retry
+        if attempt < max_retries - 1:
+            console.print()
+            retry = Confirm.ask(
+                f"[yellow]Connection failed. Retry with different credentials? ({max_retries - attempt - 1} attempts remaining)[/yellow]",
+                default=True
+            )
+
+            if not retry:
+                return None
+        else:
+            console.print()
+            console.print(f"[red]Maximum connection attempts ({max_retries}) exceeded.[/red]")
+            return None
+
+    return None

dtSpark/database/files.py

@@ -0,0 +1,205 @@
+"""
+File attachment operations module.
+
+This module handles:
+- Adding files to conversations
+- Retrieving attached files
+- File deletion
+- Tag-based file filtering
+"""
+
+import sqlite3
+import logging
+from datetime import datetime
+from typing import List, Dict, Optional
+
+
+def add_file(conn: sqlite3.Connection, conversation_id: int, filename: str,
+            file_type: str, file_size: int, content_text: Optional[str] = None,
+            content_base64: Optional[str] = None, mime_type: Optional[str] = None,
+            token_count: int = 0, tags: Optional[str] = None, user_guid: str = None) -> int:
+    """
+    Add a file to a conversation.
+
+    Args:
+        conn: Database connection
+        conversation_id: ID of the conversation
+        filename: Original filename
+        file_type: File extension (e.g., .pdf, .docx)
+        file_size: Size in bytes
+        content_text: Extracted text content
+        content_base64: Base64 encoded content (for images)
+        mime_type: MIME type (for images)
+        token_count: Token count of extracted content
+        tags: Comma-separated tags for the file
+        user_guid: User GUID for multi-user support
+
+    Returns:
+        ID of the newly added file
+    """
+    cursor = conn.cursor()
+    now = datetime.now()
+
+    cursor.execute('''
+        INSERT INTO conversation_files
+        (conversation_id, filename, file_type, file_size, content_text,
+         content_base64, mime_type, token_count, added_at, tags, user_guid)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (conversation_id, filename, file_type, file_size, content_text,
+          content_base64, mime_type, token_count, now, tags, user_guid))
+
+    conn.commit()
+    file_id = cursor.lastrowid
+    tags_str = f" with tags '{tags}'" if tags else ""
+    logging.info(f"Added file '{filename}' to conversation {conversation_id}{tags_str}")
+    return file_id
+
+
+def get_conversation_files(conn: sqlite3.Connection, conversation_id: int,
+                           user_guid: str = None) -> List[Dict]:
+    """
+    Retrieve all files for a conversation.
+
+    Args:
+        conn: Database connection
+        conversation_id: ID of the conversation
+        user_guid: User GUID for multi-user support
+
+    Returns:
+        List of file dictionaries
+    """
+    cursor = conn.cursor()
+    cursor.execute('''
+        SELECT id, filename, file_type, file_size, content_text,
+               content_base64, mime_type, token_count, added_at, tags
+        FROM conversation_files
+        WHERE conversation_id = ? AND user_guid = ?
+        ORDER BY added_at ASC
+    ''', (conversation_id, user_guid))
+
+    files = []
+    for row in cursor.fetchall():
+        files.append({
+            'id': row['id'],
+            'filename': row['filename'],
+            'file_type': row['file_type'],
+            'file_size': row['file_size'],
+            'content_text': row['content_text'],
+            'content_base64': row['content_base64'],
+            'mime_type': row['mime_type'],
+            'token_count': row['token_count'],
+            'added_at': row['added_at'],
+            'tags': row['tags']
+        })
+
+    return files
+
+
+def get_files_by_tag(conn: sqlite3.Connection, conversation_id: int, tag: str,
+                     user_guid: str = None) -> List[Dict]:
+    """
+    Retrieve files for a conversation filtered by tag.
+
+    Args:
+        conn: Database connection
+        conversation_id: ID of the conversation
+        tag: Tag to filter by (case-insensitive)
+        user_guid: User GUID for multi-user support
+
+    Returns:
+        List of file dictionaries with matching tag
+    """
+    cursor = conn.cursor()
+    # Use LIKE to match tag anywhere in the comma-separated tags field
+    # We add commas around the search pattern to ensure we match whole tags
+    tag_pattern = f"%{tag}%"
+
+    cursor.execute('''
+        SELECT id, filename, file_type, file_size, content_text,
+               content_base64, mime_type, token_count, added_at, tags
+        FROM conversation_files
+        WHERE conversation_id = ?
+        AND user_guid = ?
+        AND tags LIKE ?
+        ORDER BY added_at ASC
+    ''', (conversation_id, user_guid, tag_pattern))
+
+    files = []
+    for row in cursor.fetchall():
+        # Additional filtering to ensure we match whole tags (not partial matches)
+        tags_list = [t.strip().lower() for t in (row['tags'] or '').split(',') if t.strip()]
+        if tag.lower() in tags_list:
+            files.append({
+                'id': row['id'],
+                'filename': row['filename'],
+                'file_type': row['file_type'],
+                'file_size': row['file_size'],
+                'content_text': row['content_text'],
+                'content_base64': row['content_base64'],
+                'mime_type': row['mime_type'],
+                'token_count': row['token_count'],
+                'added_at': row['added_at'],
+                'tags': row['tags']
+            })
+
+    return files
+
+
+def delete_conversation_files(conn: sqlite3.Connection, conversation_id: int,
+                               user_guid: str = None):
+    """
+    Delete all files for a conversation.
+
+    Args:
+        conn: Database connection
+        conversation_id: ID of the conversation
+        user_guid: User GUID for multi-user support
+    """
+    try:
+        cursor = conn.cursor()
+        cursor.execute('''
+            DELETE FROM conversation_files
+            WHERE conversation_id = ? AND user_guid = ?
+        ''', (conversation_id, user_guid))
+        conn.commit()
+        logging.info(f"Deleted all files for conversation {conversation_id}")
+    except Exception as e:
+        logging.error(f"Failed to delete files for conversation {conversation_id}: {e}")
+        conn.rollback()
+
+
+def delete_file(conn: sqlite3.Connection, file_id: int, user_guid: str = None) -> bool:
+    """
+    Delete a specific file by ID.
+
+    Args:
+        conn: Database connection
+        file_id: ID of the file to delete
+        user_guid: User GUID for multi-user support (for security filtering)
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        cursor = conn.cursor()
+        # First, get the filename for logging (filtered by user_guid for security)
+        cursor.execute('SELECT filename FROM conversation_files WHERE id = ? AND user_guid = ?',
+                      (file_id, user_guid))
+        row = cursor.fetchone()
+
+        if not row:
+            logging.warning(f"File ID {file_id} not found for user {user_guid}")
+            return False
+
+        filename = row['filename']
+
+        # Delete the file (filtered by user_guid for security)
+        cursor.execute('DELETE FROM conversation_files WHERE id = ? AND user_guid = ?',
+                      (file_id, user_guid))
+        conn.commit()
+        logging.info(f"Deleted file '{filename}' (ID: {file_id})")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to delete file {file_id}: {e}")
+        conn.rollback()
+        return False