genxai-framework 0.1.0__py3-none-any.whl

genxai/triggers/registry.py

@@ -0,0 +1,82 @@
+"""Trigger registry for managing workflow triggers."""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+import logging
+
+from genxai.triggers.base import BaseTrigger, TriggerStatus
+
+logger = logging.getLogger(__name__)
+
+
+class TriggerRegistry:
+    """Central registry for triggers."""
+
+    _instance: Optional["TriggerRegistry"] = None
+    _triggers: Dict[str, BaseTrigger] = {}
+
+    def __new__(cls) -> "TriggerRegistry":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def register(cls, trigger: BaseTrigger) -> None:
+        """Register a trigger instance."""
+        if trigger.trigger_id in cls._triggers:
+            logger.warning("Trigger %s already registered, overwriting", trigger.trigger_id)
+        cls._triggers[trigger.trigger_id] = trigger
+        logger.info("Registered trigger: %s", trigger.trigger_id)
+
+    @classmethod
+    def unregister(cls, trigger_id: str) -> None:
+        """Unregister a trigger by id."""
+        trigger = cls._triggers.pop(trigger_id, None)
+        if trigger:
+            logger.info("Unregistered trigger: %s", trigger_id)
+        else:
+            logger.warning("Trigger %s not found in registry", trigger_id)
+
+    @classmethod
+    def get(cls, trigger_id: str) -> Optional[BaseTrigger]:
+        """Get a trigger by id."""
+        return cls._triggers.get(trigger_id)
+
+    @classmethod
+    def list_all(cls) -> List[BaseTrigger]:
+        """List all registered triggers."""
+        return list(cls._triggers.values())
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all triggers from the registry."""
+        cls._triggers.clear()
+        logger.info("Cleared all triggers from registry")
+
+    @classmethod
+    async def start_all(cls) -> None:
+        """Start all registered triggers."""
+        for trigger in cls._triggers.values():
+            if trigger.status != TriggerStatus.RUNNING:
+                await trigger.start()
+
+    @classmethod
+    async def stop_all(cls) -> None:
+        """Stop all registered triggers."""
+        for trigger in cls._triggers.values():
+            if trigger.status != TriggerStatus.STOPPED:
+                await trigger.stop()
+
+    @classmethod
+    def get_stats(cls) -> Dict[str, int]:
+        """Return registry stats by trigger status."""
+        stats: Dict[str, int] = {}
+        for trigger in cls._triggers.values():
+            status = trigger.status.value
+            stats[status] = stats.get(status, 0) + 1
+        stats["total"] = len(cls._triggers)
+        return stats
+
+    def __repr__(self) -> str:
+        return f"TriggerRegistry(triggers={len(self._triggers)})"

genxai/triggers/schedule.py

@@ -0,0 +1,66 @@
+"""Schedule-based trigger implementation."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+import logging
+
+from genxai.triggers.base import BaseTrigger
+
+logger = logging.getLogger(__name__)
+
+
+class ScheduleTrigger(BaseTrigger):
+    """Cron/interval trigger using APScheduler if available."""
+
+    def __init__(
+        self,
+        trigger_id: str,
+        cron: Optional[str] = None,
+        interval_seconds: Optional[int] = None,
+        payload: Optional[Dict[str, Any]] = None,
+        name: Optional[str] = None,
+        timezone: str = "UTC",
+    ) -> None:
+        super().__init__(trigger_id=trigger_id, name=name)
+        self.cron = cron
+        self.interval_seconds = interval_seconds
+        self.payload = payload or {}
+        self.timezone = timezone
+        self._scheduler = None
+        self._job = None
+
+        if not self.cron and not self.interval_seconds:
+            raise ValueError("Either cron or interval_seconds must be provided")
+
+    async def _start(self) -> None:
+        try:
+            from apscheduler.schedulers.asyncio import AsyncIOScheduler
+            from apscheduler.triggers.cron import CronTrigger
+            from apscheduler.triggers.interval import IntervalTrigger
+        except ImportError as exc:
+            raise ImportError(
+                "APScheduler is required for ScheduleTrigger. Install with: pip install apscheduler"
+            ) from exc
+
+        scheduler = AsyncIOScheduler(timezone=self.timezone)
+
+        if self.cron:
+            trigger = CronTrigger.from_crontab(self.cron, timezone=self.timezone)
+        else:
+            trigger = IntervalTrigger(seconds=self.interval_seconds)
+
+        async def _emit_wrapper() -> None:
+            await self.emit(payload={"scheduled_at": datetime.utcnow().isoformat(), **self.payload})
+
+        scheduler.add_job(_emit_wrapper, trigger=trigger)
+        scheduler.start()
+        self._scheduler = scheduler
+        logger.info("ScheduleTrigger %s started", self.trigger_id)
+
+    async def _stop(self) -> None:
+        if self._scheduler:
+            self._scheduler.shutdown(wait=False)
+            self._scheduler = None
+        logger.info("ScheduleTrigger %s stopped", self.trigger_id)

genxai/triggers/webhook.py

@@ -0,0 +1,68 @@
+"""Webhook trigger implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+import hmac
+import hashlib
+import logging
+
+from genxai.triggers.base import BaseTrigger
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookTrigger(BaseTrigger):
+    """HTTP webhook trigger.
+
+    This trigger does not start its own web server; it provides a handler that
+    can be mounted in FastAPI or other ASGI frameworks.
+    """
+
+    def __init__(
+        self,
+        trigger_id: str,
+        secret: Optional[str] = None,
+        name: Optional[str] = None,
+        header_name: str = "X-GenXAI-Signature",
+        hash_alg: str = "sha256",
+    ) -> None:
+        super().__init__(trigger_id=trigger_id, name=name)
+        self.secret = secret
+        self.header_name = header_name
+        self.hash_alg = hash_alg
+
+    async def _start(self) -> None:
+        logger.debug("Webhook trigger %s ready for requests", self.trigger_id)
+
+    async def _stop(self) -> None:
+        logger.debug("Webhook trigger %s stopped", self.trigger_id)
+
+    def validate_signature(self, payload: bytes, signature: Optional[str]) -> bool:
+        """Validate the webhook signature when a secret is provided."""
+        if not self.secret:
+            return True
+        if not signature:
+            return False
+
+        digest = hmac.new(self.secret.encode(), payload, getattr(hashlib, self.hash_alg)).hexdigest()
+        expected = f"{self.hash_alg}={digest}"
+        return hmac.compare_digest(expected, signature)
+
+    async def handle_request(
+        self,
+        payload: Dict[str, Any],
+        raw_body: Optional[bytes] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """Process an inbound webhook request and emit a trigger event."""
+        headers = headers or {}
+        signature = headers.get(self.header_name)
+
+        if self.secret and raw_body is not None:
+            if not self.validate_signature(raw_body, signature):
+                logger.warning("Webhook signature validation failed for %s", self.trigger_id)
+                return {"status": "rejected", "reason": "invalid signature"}
+
+        await self.emit(payload=payload, metadata={"headers": headers})
+        return {"status": "accepted", "trigger_id": self.trigger_id}

genxai/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions for GenXAI."""

genxai/utils/tokens.py

@@ -0,0 +1,295 @@
+"""Token counting and context window management utilities."""
+
+from typing import Dict, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# Model token limits (context window sizes)
+MODEL_TOKEN_LIMITS: Dict[str, int] = {
+    # OpenAI models
+    "gpt-4": 8192,
+    "gpt-4-32k": 32768,
+    "gpt-4-turbo": 128000,
+    "gpt-4-turbo-preview": 128000,
+    "gpt-3.5-turbo": 4096,
+    "gpt-3.5-turbo-16k": 16384,
+    # Anthropic models
+    "claude-3-opus": 200000,
+    "claude-3-sonnet": 200000,
+    "claude-3-haiku": 200000,
+    "claude-2.1": 200000,
+    "claude-2": 100000,
+    "claude-instant": 100000,
+    # Google models
+    "gemini-pro": 32768,
+    "gemini-pro-vision": 16384,
+    # Cohere models
+    "command": 4096,
+    "command-light": 4096,
+    "command-nightly": 8192,
+}
+
+
+def get_model_token_limit(model: str) -> int:
+    """Get token limit for a model.
+
+    Args:
+        model: Model name
+
+    Returns:
+        Token limit for the model, or 4096 as default
+    """
+    # Try exact match first
+    if model in MODEL_TOKEN_LIMITS:
+        return MODEL_TOKEN_LIMITS[model]
+    
+    # Try partial match (e.g., "gpt-4-0125-preview" matches "gpt-4")
+    for model_prefix, limit in MODEL_TOKEN_LIMITS.items():
+        if model.startswith(model_prefix):
+            return limit
+    
+    # Default to conservative 4K limit
+    logger.warning(f"Unknown model '{model}', using default 4096 token limit")
+    return 4096
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate token count for text.
+
+    This is a simple estimation based on character count.
+    For production use, consider using tiktoken library for accurate counting.
+
+    Args:
+        text: Text to estimate tokens for
+
+    Returns:
+        Estimated token count
+    """
+    # Rough estimation: ~4 characters per token for English text
+    # This is conservative and works reasonably well for most cases
+    return len(text) // 4
+
+
+def truncate_to_token_limit(
+    text: str,
+    max_tokens: int,
+    preserve_start: bool = True,
+) -> str:
+    """Truncate text to fit within token limit.
+
+    Args:
+        text: Text to truncate
+        max_tokens: Maximum tokens allowed
+        preserve_start: If True, keep start of text; if False, keep end
+
+    Returns:
+        Truncated text
+    """
+    estimated_tokens = estimate_tokens(text)
+    
+    if estimated_tokens <= max_tokens:
+        return text
+    
+    # Calculate how many characters to keep
+    # Using 4 chars per token estimation
+    max_chars = max_tokens * 4
+    
+    if preserve_start:
+        truncated = text[:max_chars]
+        logger.debug(f"Truncated text from {len(text)} to {len(truncated)} chars (start preserved)")
+    else:
+        truncated = text[-max_chars:]
+        logger.debug(f"Truncated text from {len(text)} to {len(truncated)} chars (end preserved)")
+    
+    return truncated
+
+
+def manage_context_window(
+    system_prompt: str,
+    user_prompt: str,
+    memory_context: str,
+    model: str,
+    reserve_tokens: int = 1000,
+) -> tuple[str, str, str]:
+    """Manage context window to fit within model limits.
+
+    Args:
+        system_prompt: System prompt text
+        user_prompt: User prompt text
+        memory_context: Memory context text
+        model: Model name
+        reserve_tokens: Tokens to reserve for response
+
+    Returns:
+        Tuple of (system_prompt, user_prompt, memory_context) adjusted to fit
+    """
+    model_limit = get_model_token_limit(model)
+    available_tokens = model_limit - reserve_tokens
+    
+    # Estimate current token usage
+    system_tokens = estimate_tokens(system_prompt)
+    user_tokens = estimate_tokens(user_prompt)
+    memory_tokens = estimate_tokens(memory_context)
+    total_tokens = system_tokens + user_tokens + memory_tokens
+    
+    logger.debug(
+        f"Context window: {total_tokens}/{model_limit} tokens "
+        f"(system: {system_tokens}, user: {user_tokens}, memory: {memory_tokens})"
+    )
+    
+    # If within limit, return as-is
+    if total_tokens <= available_tokens:
+        return system_prompt, user_prompt, memory_context
+    
+    # Need to truncate - prioritize user prompt, then system, then memory
+    tokens_to_remove = total_tokens - available_tokens
+    
+    logger.warning(
+        f"Context window exceeded by {tokens_to_remove} tokens, truncating..."
+    )
+    
+    # First, try truncating memory context
+    if memory_tokens > 0 and tokens_to_remove > 0:
+        memory_reduction = min(memory_tokens, tokens_to_remove)
+        new_memory_tokens = max(0, memory_tokens - memory_reduction)
+        memory_context = truncate_to_token_limit(
+            memory_context,
+            new_memory_tokens,
+            preserve_start=False  # Keep most recent memories
+        )
+        tokens_to_remove -= memory_reduction
+        logger.debug(f"Truncated memory context by {memory_reduction} tokens")
+    
+    # If still over limit, truncate system prompt
+    if tokens_to_remove > 0 and system_tokens > 500:  # Keep at least 500 tokens
+        system_reduction = min(system_tokens - 500, tokens_to_remove)
+        new_system_tokens = max(500, system_tokens - system_reduction)
+        system_prompt = truncate_to_token_limit(
+            system_prompt,
+            new_system_tokens,
+            preserve_start=True  # Keep role/goal at start
+        )
+        tokens_to_remove -= system_reduction
+        logger.debug(f"Truncated system prompt by {system_reduction} tokens")
+    
+    # If still over limit, truncate user prompt (last resort)
+    if tokens_to_remove > 0 and user_tokens > 0:
+        new_user_tokens = max(100, user_tokens - tokens_to_remove)  # Keep at least 100 tokens
+        user_prompt = truncate_to_token_limit(
+            user_prompt,
+            new_user_tokens,
+            preserve_start=True  # Keep task description
+        )
+        logger.warning(f"Had to truncate user prompt by {tokens_to_remove} tokens")
+    
+    return system_prompt, user_prompt, memory_context
+
+
+def split_text_by_tokens(
+    text: str,
+    max_tokens_per_chunk: int,
+    overlap_tokens: int = 100,
+) -> List[str]:
+    """Split text into chunks by token count.
+
+    Args:
+        text: Text to split
+        max_tokens_per_chunk: Maximum tokens per chunk
+        overlap_tokens: Number of tokens to overlap between chunks
+
+    Returns:
+        List of text chunks
+    """
+    estimated_total_tokens = estimate_tokens(text)
+    
+    if estimated_total_tokens <= max_tokens_per_chunk:
+        return [text]
+    
+    chunks = []
+    chars_per_chunk = max_tokens_per_chunk * 4  # 4 chars per token
+    overlap_chars = overlap_tokens * 4
+    
+    start = 0
+    while start < len(text):
+        end = start + chars_per_chunk
+        chunk = text[start:end]
+        chunks.append(chunk)
+        
+        # Move start forward, accounting for overlap
+        start = end - overlap_chars
+        
+        if start >= len(text):
+            break
+    
+    logger.debug(f"Split text into {len(chunks)} chunks")
+    return chunks
+
+
+class TokenCounter:
+    """Token counter with caching for efficiency."""
+
+    def __init__(self, model: str):
+        """Initialize token counter.
+
+        Args:
+            model: Model name for token limit
+        """
+        self.model = model
+        self.token_limit = get_model_token_limit(model)
+        self._cache: Dict[str, int] = {}
+
+    def count(self, text: str, use_cache: bool = True) -> int:
+        """Count tokens in text.
+
+        Args:
+            text: Text to count tokens for
+            use_cache: Whether to use cache
+
+        Returns:
+            Token count
+        """
+        if use_cache and text in self._cache:
+            return self._cache[text]
+        
+        count = estimate_tokens(text)
+        
+        if use_cache:
+            self._cache[text] = count
+        
+        return count
+
+    def fits_in_context(
+        self,
+        *texts: str,
+        reserve_tokens: int = 1000,
+    ) -> bool:
+        """Check if texts fit in context window.
+
+        Args:
+            *texts: Texts to check
+            reserve_tokens: Tokens to reserve for response
+
+        Returns:
+            True if texts fit in context window
+        """
+        total_tokens = sum(self.count(text) for text in texts)
+        available_tokens = self.token_limit - reserve_tokens
+        return total_tokens <= available_tokens
+
+    def clear_cache(self) -> None:
+        """Clear token count cache."""
+        self._cache.clear()
+
+    def get_stats(self) -> Dict[str, any]:
+        """Get counter statistics.
+
+        Returns:
+            Statistics dictionary
+        """
+        return {
+            "model": self.model,
+            "token_limit": self.token_limit,
+            "cache_size": len(self._cache),
+        }