genxai-framework 0.1.0__py3-none-any.whl

genxai/core/memory/working.py

@@ -0,0 +1,211 @@
+"""Working memory implementation for active processing."""
+
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+import logging
+from collections import deque
+
+from genxai.core.memory.base import Memory, MemoryType
+
+logger = logging.getLogger(__name__)
+
+
+class WorkingMemory:
+    """Working memory for active processing and temporary storage.
+    
+    Working memory holds information that is currently being processed:
+    - Current task context
+    - Intermediate results
+    - Active goals
+    - Temporary computations
+    
+    Has limited capacity and items are automatically evicted when full.
+    """
+
+    def __init__(
+        self,
+        capacity: int = 5,
+    ) -> None:
+        """Initialize working memory.
+
+        Args:
+            capacity: Maximum number of items to hold
+        """
+        self._capacity = capacity
+        self._items: deque = deque(maxlen=capacity)
+        self._item_map: Dict[str, Any] = {}  # id -> item for fast lookup
+        
+        logger.info(f"Initialized working memory with capacity {capacity}")
+
+    def add(
+        self,
+        key: str,
+        value: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Add an item to working memory.
+
+        Args:
+            key: Item key/identifier
+            value: Item value
+            metadata: Optional metadata
+        """
+        item = {
+            "key": key,
+            "value": value,
+            "metadata": metadata or {},
+            "timestamp": datetime.now(),
+        }
+
+        # Remove old item with same key if exists
+        if key in self._item_map:
+            self.remove(key)
+
+        # Add new item
+        self._items.append(item)
+        self._item_map[key] = item
+
+        # If capacity exceeded, oldest item was automatically removed by deque
+        # Update item_map accordingly
+        if len(self._items) < len(self._item_map):
+            # Find and remove evicted items from map
+            current_keys = {item["key"] for item in self._items}
+            evicted_keys = set(self._item_map.keys()) - current_keys
+            for evicted_key in evicted_keys:
+                del self._item_map[evicted_key]
+                logger.debug(f"Evicted item from working memory: {evicted_key}")
+
+        logger.debug(f"Added to working memory: {key}")
+
+    def get(self, key: str) -> Optional[Any]:
+        """Get an item from working memory.
+
+        Args:
+            key: Item key
+
+        Returns:
+            Item value if found, None otherwise
+        """
+        item = self._item_map.get(key)
+        if item:
+            return item["value"]
+        return None
+
+    def get_all(self) -> List[Dict[str, Any]]:
+        """Get all items in working memory.
+
+        Returns:
+            List of all items
+        """
+        return list(self._items)
+
+    def get_recent(self, n: int = 3) -> List[Dict[str, Any]]:
+        """Get n most recent items.
+
+        Args:
+            n: Number of items to retrieve
+
+        Returns:
+            List of recent items
+        """
+        return list(self._items)[-n:] if len(self._items) >= n else list(self._items)
+
+    def remove(self, key: str) -> bool:
+        """Remove an item from working memory.
+
+        Args:
+            key: Item key
+
+        Returns:
+            True if removed, False if not found
+        """
+        if key not in self._item_map:
+            return False
+
+        # Remove from deque
+        self._items = deque(
+            (item for item in self._items if item["key"] != key),
+            maxlen=self._capacity
+        )
+
+        # Remove from map
+        del self._item_map[key]
+
+        logger.debug(f"Removed from working memory: {key}")
+        return True
+
+    def clear(self) -> None:
+        """Clear all items from working memory."""
+        count = len(self._items)
+        self._items.clear()
+        self._item_map.clear()
+        logger.info(f"Cleared {count} items from working memory")
+
+    def contains(self, key: str) -> bool:
+        """Check if key exists in working memory.
+
+        Args:
+            key: Item key
+
+        Returns:
+            True if exists, False otherwise
+        """
+        return key in self._item_map
+
+    def get_size(self) -> int:
+        """Get current number of items.
+
+        Returns:
+            Number of items
+        """
+        return len(self._items)
+
+    def get_capacity(self) -> int:
+        """Get maximum capacity.
+
+        Returns:
+            Capacity
+        """
+        return self._capacity
+
+    def is_full(self) -> bool:
+        """Check if working memory is full.
+
+        Returns:
+            True if full, False otherwise
+        """
+        return len(self._items) >= self._capacity
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get working memory statistics.
+
+        Returns:
+            Statistics dictionary
+        """
+        if not self._items:
+            return {
+                "size": 0,
+                "capacity": self._capacity,
+                "utilization": 0.0,
+            }
+
+        return {
+            "size": len(self._items),
+            "capacity": self._capacity,
+            "utilization": len(self._items) / self._capacity,
+            "oldest_item": self._items[0]["timestamp"].isoformat(),
+            "newest_item": self._items[-1]["timestamp"].isoformat(),
+            "keys": [item["key"] for item in self._items],
+        }
+
+    def __len__(self) -> int:
+        """Get number of items."""
+        return len(self._items)
+
+    def __contains__(self, key: str) -> bool:
+        """Check if key exists."""
+        return key in self._item_map
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"WorkingMemory(size={len(self._items)}/{self._capacity})"

genxai/core/state/__init__.py

@@ -0,0 +1,6 @@
+"""State management for GenXAI workflows."""
+
+from genxai.core.state.manager import StateManager
+from genxai.core.state.schema import StateSchema
+
+__all__ = ["StateManager", "StateSchema"]

genxai/core/state/manager.py

@@ -0,0 +1,293 @@
+"""State manager for workflow execution."""
+
+import json
+from typing import Any, Dict, Optional
+from datetime import datetime
+from pathlib import Path
+import logging
+
+from genxai.core.state.schema import StateSchema
+
+logger = logging.getLogger(__name__)
+
+
+class StateManager:
+    """Manages workflow state with persistence and versioning."""
+
+    def __init__(
+        self,
+        schema: Optional[StateSchema] = None,
+        enable_persistence: bool = False,
+        persistence_path: Optional[Path] = None,
+    ) -> None:
+        """Initialize state manager.
+
+        Args:
+            schema: State schema for validation
+            enable_persistence: Whether to enable state persistence
+            persistence_path: Path for state persistence
+        """
+        self.schema = schema
+        self.enable_persistence = enable_persistence
+        self.persistence_path = persistence_path or Path(".genxai/state")
+        self._state: Dict[str, Any] = {}
+        self._history: list[Dict[str, Any]] = []
+        self._version = 0
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get value from state.
+
+        Args:
+            key: State key
+            default: Default value if key not found
+
+        Returns:
+            State value or default
+        """
+        return self._state.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set value in state.
+
+        Args:
+            key: State key
+            value: Value to set
+        """
+        old_value = self._state.get(key)
+        self._state[key] = value
+        self._version += 1
+
+        # Record in history
+        self._history.append(
+            {
+                "version": self._version,
+                "timestamp": datetime.now().isoformat(),
+                "action": "set",
+                "key": key,
+                "old_value": old_value,
+                "new_value": value,
+            }
+        )
+
+        logger.debug(f"State updated: {key} = {value}")
+
+        # Persist if enabled
+        if self.enable_persistence:
+            self._persist()
+
+    def update(self, updates: Dict[str, Any]) -> None:
+        """Update multiple state values.
+
+        Args:
+            updates: Dictionary of updates
+        """
+        for key, value in updates.items():
+            self.set(key, value)
+
+    def delete(self, key: str) -> None:
+        """Delete key from state.
+
+        Args:
+            key: State key to delete
+        """
+        if key in self._state:
+            old_value = self._state[key]
+            del self._state[key]
+            self._version += 1
+
+            self._history.append(
+                {
+                    "version": self._version,
+                    "timestamp": datetime.now().isoformat(),
+                    "action": "delete",
+                    "key": key,
+                    "old_value": old_value,
+                }
+            )
+
+            logger.debug(f"State key deleted: {key}")
+
+            if self.enable_persistence:
+                self._persist()
+
+    def get_all(self) -> Dict[str, Any]:
+        """Get all state values.
+
+        Returns:
+            Complete state dictionary
+        """
+        return self._state.copy()
+
+    def clear(self) -> None:
+        """Clear all state."""
+        self._state.clear()
+        self._version += 1
+        self._history.append(
+            {
+                "version": self._version,
+                "timestamp": datetime.now().isoformat(),
+                "action": "clear",
+            }
+        )
+        logger.info("State cleared")
+
+        if self.enable_persistence:
+            self._persist()
+
+    def validate(self) -> bool:
+        """Validate current state against schema.
+
+        Returns:
+            True if valid
+
+        Raises:
+            ValueError: If validation fails
+        """
+        if self.schema is None:
+            return True
+
+        return self.schema.validate_state(self._state)
+
+    def checkpoint(self, name: str) -> None:
+        """Create a named checkpoint of current state.
+
+        Args:
+            name: Checkpoint name
+        """
+        checkpoint = {
+            "name": name,
+            "version": self._version,
+            "timestamp": datetime.now().isoformat(),
+            "state": self._state.copy(),
+        }
+
+        self._history.append(
+            {
+                "version": self._version,
+                "timestamp": datetime.now().isoformat(),
+                "action": "checkpoint",
+                "checkpoint": checkpoint,
+            }
+        )
+
+        logger.info(f"Checkpoint created: {name}")
+
+        if self.enable_persistence:
+            self._persist_checkpoint(name, checkpoint)
+
+    def rollback(self, version: Optional[int] = None) -> None:
+        """Rollback state to a previous version.
+
+        Args:
+            version: Version to rollback to (default: previous version)
+        """
+        if not self._history:
+            logger.warning("No history to rollback to")
+            return
+
+        target_version = version or (self._version - 1)
+
+        # Find state at target version
+        for entry in reversed(self._history):
+            if entry.get("version") == target_version:
+                if entry.get("action") == "checkpoint":
+                    self._state = entry["checkpoint"]["state"].copy()
+                    self._version = target_version
+                    logger.info(f"Rolled back to version {target_version}")
+                    return
+
+        logger.warning(f"Version {target_version} not found in history")
+
+    def get_history(self, limit: Optional[int] = None) -> list[Dict[str, Any]]:
+        """Get state change history.
+
+        Args:
+            limit: Maximum number of entries to return
+
+        Returns:
+            List of history entries
+        """
+        if limit:
+            return self._history[-limit:]
+        return self._history.copy()
+
+    def _persist(self) -> None:
+        """Persist current state to disk."""
+        if not self.persistence_path:
+            return
+
+        self.persistence_path.mkdir(parents=True, exist_ok=True)
+        state_file = self.persistence_path / "current_state.json"
+
+        try:
+            with open(state_file, "w") as f:
+                json.dump(
+                    {
+                        "version": self._version,
+                        "timestamp": datetime.now().isoformat(),
+                        "state": self._state,
+                    },
+                    f,
+                    indent=2,
+                    default=str,
+                )
+            logger.debug(f"State persisted to {state_file}")
+        except Exception as e:
+            logger.error(f"Failed to persist state: {e}")
+
+    def _persist_checkpoint(self, name: str, checkpoint: Dict[str, Any]) -> None:
+        """Persist a checkpoint to disk.
+
+        Args:
+            name: Checkpoint name
+            checkpoint: Checkpoint data
+        """
+        if not self.persistence_path:
+            return
+
+        self.persistence_path.mkdir(parents=True, exist_ok=True)
+        checkpoint_file = self.persistence_path / f"checkpoint_{name}.json"
+
+        try:
+            with open(checkpoint_file, "w") as f:
+                json.dump(checkpoint, f, indent=2, default=str)
+            logger.debug(f"Checkpoint persisted to {checkpoint_file}")
+        except Exception as e:
+            logger.error(f"Failed to persist checkpoint: {e}")
+
+    def load(self, path: Optional[Path] = None) -> None:
+        """Load state from disk.
+
+        Args:
+            path: Path to load from (default: persistence_path)
+        """
+        load_path = path or (self.persistence_path / "current_state.json")
+
+        if not load_path.exists():
+            logger.warning(f"State file not found: {load_path}")
+            return
+
+        try:
+            with open(load_path, "r") as f:
+                data = json.load(f)
+                self._state = data.get("state", {})
+                self._version = data.get("version", 0)
+            logger.info(f"State loaded from {load_path}")
+        except Exception as e:
+            logger.error(f"Failed to load state: {e}")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert state manager to dictionary.
+
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "version": self._version,
+            "state": self._state,
+            "history_length": len(self._history),
+        }
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"StateManager(version={self._version}, keys={len(self._state)})"

genxai/core/state/schema.py

@@ -0,0 +1,115 @@
+"""State schema definition and validation."""
+
+from typing import Any, Dict, Optional, Type
+from pydantic import BaseModel, Field, create_model, ConfigDict
+
+
+class StateSchema(BaseModel):
+    """Schema for workflow state."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    fields: Dict[str, Type[Any]] = Field(default_factory=dict)
+    required_fields: set[str] = Field(default_factory=set)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+    def validate_state(self, state: Dict[str, Any]) -> bool:
+        """Validate state against schema.
+
+        Args:
+            state: State dictionary to validate
+
+        Returns:
+            True if valid
+
+        Raises:
+            ValueError: If validation fails
+        """
+        # Check required fields
+        missing_fields = self.required_fields - set(state.keys())
+        if missing_fields:
+            raise ValueError(f"Missing required fields: {missing_fields}")
+
+        # Type validation
+        for field_name, field_type in self.fields.items():
+            if field_name in state:
+                value = state[field_name]
+                if not isinstance(value, field_type):
+                    raise ValueError(
+                        f"Field '{field_name}' has wrong type. "
+                        f"Expected {field_type}, got {type(value)}"
+                    )
+
+        return True
+
+    def create_pydantic_model(self, model_name: str = "DynamicState") -> Type[BaseModel]:
+        """Create a Pydantic model from the schema.
+
+        Args:
+            model_name: Name for the generated model
+
+        Returns:
+            Pydantic model class
+        """
+        field_definitions = {}
+        for field_name, field_type in self.fields.items():
+            if field_name in self.required_fields:
+                field_definitions[field_name] = (field_type, ...)
+            else:
+                field_definitions[field_name] = (Optional[field_type], None)
+
+        return create_model(model_name, **field_definitions)
+
+    def add_field(
+        self, name: str, field_type: Type[Any], required: bool = False
+    ) -> None:
+        """Add a field to the schema.
+
+        Args:
+            name: Field name
+            field_type: Field type
+            required: Whether field is required
+        """
+        self.fields[name] = field_type
+        if required:
+            self.required_fields.add(name)
+
+    def remove_field(self, name: str) -> None:
+        """Remove a field from the schema.
+
+        Args:
+            name: Field name to remove
+        """
+        if name in self.fields:
+            del self.fields[name]
+        if name in self.required_fields:
+            self.required_fields.remove(name)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert schema to dictionary.
+
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "fields": {name: str(type_) for name, type_ in self.fields.items()},
+            "required_fields": list(self.required_fields),
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "StateSchema":
+        """Create schema from dictionary.
+
+        Args:
+            data: Dictionary representation
+
+        Returns:
+            StateSchema instance
+        """
+        schema = cls()
+        schema.required_fields = set(data.get("required_fields", []))
+        schema.metadata = data.get("metadata", {})
+        # Note: Type reconstruction from string would need eval or mapping
+        return schema

genxai/llm/__init__.py

@@ -0,0 +1,14 @@
+"""LLM provider integrations for GenXAI."""
+
+from genxai.llm.base import LLMProvider, LLMResponse
+from genxai.llm.providers.openai import OpenAIProvider
+from genxai.llm.providers.ollama import OllamaProvider
+from genxai.llm.factory import LLMProviderFactory
+
+__all__ = [
+    "LLMProvider",
+    "LLMResponse",
+    "OpenAIProvider",
+    "OllamaProvider",
+    "LLMProviderFactory",
+]