scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/ai/genai/chat_history.py

@@ -1,307 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2025-05-31 10:10:00"
-# Author: ywatanabe
-# File: ./src/scitex/ai/genai/chat_history.py
-
-"""
-Manages conversation history for AI providers.
-
-This module handles chat history management including:
-- Message storage and retrieval
-- Role alternation enforcement
-- System message handling
-- History truncation
-"""
-
-from typing import List, Dict, Optional, Any
-from dataclasses import dataclass, field
-from copy import deepcopy
-
-
-@dataclass
-class Message:
-    """Represents a single message in chat history.
-
-    Attributes
-    ----------
-    role : str
-        Message role (system, user, assistant)
-    content : str
-        Message content
-    images : Optional[List[str]]
-        Optional base64-encoded images
-    """
-
-    role: str
-    content: str
-    images: Optional[List[str]] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert message to dictionary.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary representation
-        """
-        d = {"role": self.role, "content": self.content}
-        if self.images:
-            d["images"] = self.images
-        return d
-
-
-class ChatHistory:
-    """Manages conversation history with role enforcement.
-
-    Example
-    -------
-    >>> history = ChatHistory(n_keep=5)
-    >>> history.add_message("user", "Hello")
-    >>> history.add_message("assistant", "Hi there!")
-    >>> messages = history.get_messages()
-    >>> print(len(messages))
-    2
-
-    Parameters
-    ----------
-    system_prompt : Optional[str]
-        Optional system prompt to prepend
-    n_keep : int
-        Number of recent exchanges to keep (default: 1)
-    """
-
-    VALID_ROLES = {"system", "user", "assistant"}
-
-    def __init__(self, system_prompt: Optional[str] = None, n_keep: int = 1):
-        """Initialize chat history manager.
-
-        Parameters
-        ----------
-        system_prompt : Optional[str]
-            Optional system prompt
-        n_keep : int
-            Number of recent exchanges to keep (-1 to keep all)
-        """
-        self.system_prompt = system_prompt or ""
-        self.n_keep = n_keep
-        self.messages: List[Message] = []
-
-        # Add system message if provided
-        if system_prompt:
-            self.messages.append(Message(role="system", content=system_prompt))
-
-    def add_message(
-        self, role: str, content: str, images: Optional[List[str]] = None
-    ) -> None:
-        """Add a message to the history.
-
-        Parameters
-        ----------
-        role : str
-            Message role ("user", "assistant", "system")
-        content : str
-            Message content
-        images : Optional[List[str]]
-            Optional images for multimodal messages
-
-        Raises
-        ------
-        ValueError
-            If role is invalid
-        """
-        if role not in self.VALID_ROLES:
-            raise ValueError(f"Invalid role: {role}. Must be one of {self.VALID_ROLES}")
-
-        # Don't add duplicate system messages
-        if role == "system" and self.messages and self.messages[0].role == "system":
-            self.messages[0] = Message(role=role, content=content)
-            return
-
-        self.messages.append(Message(role=role, content=content, images=images))
-        self._trim_history()
-
-    def _trim_history(self) -> None:
-        """Trim history to n_keep exchanges."""
-        if self.n_keep == -1:
-            return
-
-        # Count system message
-        has_system = self.messages and self.messages[0].role == "system"
-        start_idx = 1 if has_system else 0
-
-        # Keep only last n_keep exchanges (2 messages per exchange)
-        if len(self.messages) - start_idx > self.n_keep * 2:
-            kept_messages = self.messages[-self.n_keep * 2 :]
-            if has_system:
-                self.messages = [self.messages[0]] + kept_messages
-            else:
-                self.messages = kept_messages
-
-    def format_for_api(self, provider: str) -> List[Dict[str, Any]]:
-        """Format messages for specific provider API.
-
-        Parameters
-        ----------
-        provider : str
-            Provider name (openai, anthropic, google)
-
-        Returns
-        -------
-        List[Dict[str, Any]]
-            Formatted messages
-        """
-        provider = provider.lower()
-
-        if provider == "openai":
-            return self._format_for_openai()
-        elif provider == "anthropic":
-            return self._format_for_anthropic()
-        elif provider == "google":
-            return self._format_for_google()
-        else:
-            # Default format
-            return [msg.to_dict() for msg in self.messages]
-
-    def _format_for_openai(self) -> List[Dict[str, Any]]:
-        """Format messages for OpenAI API."""
-        formatted = []
-
-        for msg in self.messages:
-            if msg.images:
-                # Multimodal message
-                content = [{"type": "text", "text": msg.content}]
-                for img in msg.images:
-                    content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{img}"},
-                        }
-                    )
-                formatted.append({"role": msg.role, "content": content})
-            else:
-                formatted.append({"role": msg.role, "content": msg.content})
-
-        return formatted
-
-    def _format_for_anthropic(self) -> List[Dict[str, Any]]:
-        """Format messages for Anthropic API (excludes system)."""
-        formatted = []
-
-        for msg in self.messages:
-            if msg.role == "system":
-                continue  # Anthropic handles system separately
-            formatted.append({"role": msg.role, "content": msg.content})
-
-        return formatted
-
-    def _format_for_google(self) -> List[Dict[str, Any]]:
-        """Format messages for Google API."""
-        formatted = []
-
-        for msg in self.messages:
-            if msg.images:
-                parts = [{"text": msg.content}]
-                for img in msg.images:
-                    parts.append(
-                        {"inline_data": {"mime_type": "image/jpeg", "data": img}}
-                    )
-                formatted.append({"role": msg.role, "parts": parts})
-            else:
-                formatted.append({"role": msg.role, "parts": [{"text": msg.content}]})
-
-        return formatted
-
-    def ensure_valid_sequence(self) -> None:
-        """Ensure messages follow valid sequence rules.
-
-        - Must start with user message (after system)
-        - Must alternate between user and assistant
-        """
-        if not self.messages:
-            return
-
-        # Skip system message if present
-        start_idx = 1 if self.messages and self.messages[0].role == "system" else 0
-
-        # Ensure starts with user
-        if (
-            len(self.messages) > start_idx
-            and self.messages[start_idx].role == "assistant"
-        ):
-            self.messages.insert(start_idx, Message(role="user", content="Hello"))
-
-        # Ensure alternating
-        i = start_idx
-        while i < len(self.messages) - 1:
-            current = self.messages[i]
-            next_msg = self.messages[i + 1]
-
-            if current.role == next_msg.role:
-                # Insert appropriate message
-                if current.role == "user":
-                    self.messages.insert(
-                        i + 1, Message(role="assistant", content="...")
-                    )
-                else:
-                    self.messages.insert(i + 1, Message(role="user", content="..."))
-            i += 1
-
-    def clear(self) -> None:
-        """Clear history, keeping only system message if present."""
-        if self.messages and self.messages[0].role == "system":
-            self.messages = [self.messages[0]]
-        else:
-            self.messages = []
-
-    def get_messages(self) -> List[Message]:
-        """Get copy of messages.
-
-        Returns
-        -------
-        List[Message]
-            Copy of message list
-        """
-        return deepcopy(self.messages)
-
-    def __len__(self) -> int:
-        """Get number of messages in history."""
-        return len(self.messages)
-
-    def __repr__(self) -> str:
-        """String representation of ChatHistory."""
-        return f"ChatHistory(messages={len(self.messages)}, n_keep={self.n_keep})"
-
-
-# Backward compatibility aliases
-def get_history(self) -> List[Dict[str, Any]]:
-    """Get history as list of dicts (backward compatibility)."""
-    return [msg.to_dict() for msg in self.messages]
-
-
-def ensure_alternating(self) -> None:
-    """Ensure alternating messages (backward compatibility)."""
-    self.ensure_valid_sequence()
-
-
-def ensure_user_first(self) -> None:
-    """Ensure user first (backward compatibility)."""
-    self.ensure_valid_sequence()
-
-
-def reset(self, system_message: Optional[str] = None) -> None:
-    """Reset history (backward compatibility)."""
-    self.clear()
-    if system_message:
-        self.system_prompt = system_message
-        self.messages.append(Message(role="system", content=system_message))
-
-
-# Add backward compatibility methods to ChatHistory
-ChatHistory.get_history = get_history
-ChatHistory.ensure_alternating = ensure_alternating
-ChatHistory.ensure_user_first = ensure_user_first
-ChatHistory.reset = reset
-
-
-# EOF

scitex/ai/genai/cost_tracker.py

@@ -1,276 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2025-05-31 10:15:00"
-# Author: ywatanabe
-# File: ./src/scitex/ai/genai/cost_tracker.py
-
-"""
-Tracks token usage and costs for AI API calls.
-
-This module provides cost tracking functionality including:
-- Token counting for input/output
-- Cost calculation based on model pricing
-- Usage statistics aggregation
-"""
-
-from typing import Dict, Optional, List, Any
-from dataclasses import dataclass, field
-
-from .calc_cost import calc_cost
-
-
-@dataclass
-class TokenUsage:
-    """Token usage statistics.
-
-    Attributes
-    ----------
-    input_tokens : int
-        Total input tokens used
-    output_tokens : int
-        Total output tokens used
-    total_tokens : int
-        Total tokens (input + output)
-    """
-
-    input_tokens: int = 0
-    output_tokens: int = 0
-
-    @property
-    def total_tokens(self) -> int:
-        """Get total token count."""
-        return self.input_tokens + self.output_tokens
-
-
-class CostTracker:
-    """Tracks token usage and associated costs.
-
-    Example
-    -------
-    >>> tracker = CostTracker("openai", "gpt-4")
-    >>> tracker.update(input_tokens=100, output_tokens=50)
-    >>> cost = tracker.calculate_cost()
-    >>> print(f"Total cost: ${cost:.4f}")
-    Total cost: $0.0045
-
-    Parameters
-    ----------
-    provider : str
-        The provider name (e.g., "openai", "anthropic")
-    model : str
-        The model name for cost calculation
-    """
-
-    def __init__(self, provider: str, model: str):
-        """Initialize cost tracker.
-
-        Parameters
-        ----------
-        provider : str
-            The provider name
-        model : str
-            The model name
-        """
-        self.provider = provider
-        self.model = model
-
-        # Total token counters
-        self.input_tokens = 0
-        self.output_tokens = 0
-
-        # Session token counters
-        self.session_input_tokens = 0
-        self.session_output_tokens = 0
-
-        # Token history for detailed tracking
-        self._history: List[TokenUsage] = []
-
-        # Request counter
-        self.request_count = 0
-
-    # Properties for backward compatibility
-    @property
-    def total_prompt_tokens(self) -> int:
-        """Get total prompt (input) tokens."""
-        return self.input_tokens
-
-    @property
-    def total_completion_tokens(self) -> int:
-        """Get total completion (output) tokens."""
-        return self.output_tokens
-
-    @property
-    def total_cost(self) -> float:
-        """Get total cost."""
-        return self.calculate_cost()
-
-    def update(self, input_tokens: int, output_tokens: int) -> None:
-        """Update token counts.
-
-        Parameters
-        ----------
-        input_tokens : int
-            Number of input tokens to add
-        output_tokens : int
-            Number of output tokens to add
-        """
-        # Update total counters
-        self.input_tokens += input_tokens
-        self.output_tokens += output_tokens
-
-        # Update session counters
-        self.session_input_tokens += input_tokens
-        self.session_output_tokens += output_tokens
-
-        # Record in history
-        usage = TokenUsage(input_tokens=input_tokens, output_tokens=output_tokens)
-        self._history.append(usage)
-
-        # Increment request count
-        self.request_count += 1
-
-    def track_usage(self, model: str, usage: TokenUsage) -> None:
-        """Track usage (for backward compatibility).
-
-        Parameters
-        ----------
-        model : str
-            Model name (ignored, uses instance model)
-        usage : TokenUsage
-            Token usage to track
-        """
-        self.update(usage.input_tokens, usage.output_tokens)
-
-    def calculate_cost(self) -> float:
-        """Calculate total cost based on token usage.
-
-        Returns
-        -------
-        float
-            Total cost in USD
-        """
-        return calc_cost(
-            model=self.model,
-            input_tokens=self.input_tokens,
-            output_tokens=self.output_tokens,
-        )
-
-    def calculate_session_cost(self) -> float:
-        """Calculate session cost based on session token usage.
-
-        Returns
-        -------
-        float
-            Session cost in USD
-        """
-        return calc_cost(
-            model=self.model,
-            input_tokens=self.session_input_tokens,
-            output_tokens=self.session_output_tokens,
-        )
-
-    def reset_session(self) -> None:
-        """Reset session counters while keeping totals."""
-        self.session_input_tokens = 0
-        self.session_output_tokens = 0
-
-    def reset(self) -> None:
-        """Reset all token usage and cost tracking."""
-        self.input_tokens = 0
-        self.output_tokens = 0
-        self.session_input_tokens = 0
-        self.session_output_tokens = 0
-        self._history = []
-
-    def get_usage_stats(self) -> Dict[str, Any]:
-        """Get comprehensive usage statistics.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary containing usage statistics
-        """
-        return {
-            "total_input_tokens": self.input_tokens,
-            "total_output_tokens": self.output_tokens,
-            "total_tokens": self.input_tokens + self.output_tokens,
-            "session_input_tokens": self.session_input_tokens,
-            "session_output_tokens": self.session_output_tokens,
-            "session_total_tokens": self.session_input_tokens
-            + self.session_output_tokens,
-        }
-
-    def get_summary(self) -> str:
-        """Get a cost summary (alias for format_cost_summary).
-
-        Returns
-        -------
-        str
-            Formatted cost summary
-        """
-        return self.format_cost_summary()
-
-    def format_cost_summary(self) -> str:
-        """Format a human-readable cost summary.
-
-        Returns
-        -------
-        str
-            Formatted cost summary
-        """
-        total_cost = self.calculate_cost()
-        session_cost = self.calculate_session_cost()
-
-        return (
-            f"Cost Summary for {self.provider} - {self.model}\n"
-            f"{'=' * 50}\n"
-            f"Total Usage:\n"
-            f"  Input tokens:  {self.input_tokens:,}\n"
-            f"  Output tokens: {self.output_tokens:,}\n"
-            f"  Total tokens:  {self.input_tokens + self.output_tokens:,}\n"
-            f"  Total cost:    ${total_cost:.4f}\n"
-            f"\n"
-            f"Session Usage:\n"
-            f"  Input tokens:  {self.session_input_tokens:,}\n"
-            f"  Output tokens: {self.session_output_tokens:,}\n"
-            f"  Total tokens:  {self.session_input_tokens + self.session_output_tokens:,}\n"
-            f"  Session cost:  ${session_cost:.4f}\n"
-        )
-
-    def get_detailed_report(self) -> Dict[str, Any]:
-        """Get a detailed cost and usage report.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Comprehensive report including usage, costs, and statistics
-        """
-        return {
-            "provider": self.provider,
-            "model": self.model,
-            "total_cost": self.calculate_cost(),
-            "session_cost": self.calculate_session_cost(),
-            "usage_stats": self.get_usage_stats(),
-            "num_api_calls": len(self._history),
-            "average_per_call": {
-                "input_tokens": (
-                    self.input_tokens / len(self._history) if self._history else 0
-                ),
-                "output_tokens": (
-                    self.output_tokens / len(self._history) if self._history else 0
-                ),
-            },
-        }
-
-    def __repr__(self) -> str:
-        """String representation of CostTracker."""
-        cost = self.calculate_cost()
-        return (
-            f"CostTracker(provider={self.provider}, "
-            f"model={self.model}, "
-            f"total_tokens={self.input_tokens + self.output_tokens}, "
-            f"cost=${cost:.4f})"
-        )
-
-
-# EOF