edsl 0.1.53__py3-none-any.whl → 0.1.55__py3-none-any.whl

edsl/db_list/sqlite_list.py

@@ -0,0 +1,349 @@
+import sqlite3
+import tempfile
+import os
+import json
+from typing import Any, Callable, Iterable, Iterator, List, Optional
+from abc import ABC, abstractmethod
+from collections.abc import MutableSequence
+
+
+class SQLiteList(MutableSequence, ABC):
+    """
+    An abstract base class for a MutableSequence that stores its data in a temporary SQLite file.
+    The file is removed when close() is called.
+    Subclasses must implement serialize and deserialize methods.
+    """
+
+    _TABLE_NAME = "list_data"  # Class constant instead of instance parameter
+
+    @abstractmethod
+    def serialize(self, value: Any) -> str:
+        """Convert a value to a string for storage in SQLite."""
+        pass
+
+    @abstractmethod
+    def deserialize(self, value: str) -> Any:
+        """Convert a stored string back to its original value."""
+        pass
+
+    def __init__(self, data=None):
+        # Create a temporary file for our SQLite database
+        tmpfile = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
+        self.db_path = tmpfile.name
+        # Close the file handle immediately; SQLite only needs the path
+        tmpfile.close()
+
+        self.conn = sqlite3.connect(self.db_path)
+        self._create_table_if_not_exists()
+
+        # Initialize with data if provided
+        if data is not None:
+            self._batch_insert(data)
+
+    def _create_table_if_not_exists(self):
+        query = f"CREATE TABLE IF NOT EXISTS {self._TABLE_NAME} (idx INTEGER UNIQUE, value BLOB)"
+        with self.conn:
+            self.conn.execute(query)
+            # Create an index for faster lookups
+            self.conn.execute(f"CREATE INDEX IF NOT EXISTS idx_index ON {self._TABLE_NAME} (idx)")
+
+    def _batch_insert(self, data: Iterable) -> None:
+        """
+        Insert items one at a time to minimize memory usage.
+        
+        Args:
+            data: Iterable containing items to insert
+        """
+        with self.conn:
+            # Use a single transaction for better performance
+            for idx, item in enumerate(data):
+                # Serialize and insert one item at a time to minimize memory usage
+                serialized = self.serialize(item)
+                self.conn.execute(
+                    f"INSERT INTO {self._TABLE_NAME} (idx, value) VALUES (?, ?)",
+                    (idx, serialized)
+                )
+                # Clear reference to allow garbage collection
+                del serialized
+
+    def __len__(self):
+        cursor = self.conn.execute(f"SELECT COUNT(*) FROM {self._TABLE_NAME}")
+        (count,) = cursor.fetchone()
+        return count
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            # Handle slice object
+            start, stop, step = index.indices(len(self))
+            if step == 1:  # Simple range
+                cursor = self.conn.execute(
+                    f"SELECT value FROM {self._TABLE_NAME} WHERE idx >= ? AND idx < ? ORDER BY idx",
+                    (start, stop)
+                )
+                return [self.deserialize(row[0]) for row in cursor]
+            else:  # Need to handle step
+                indices = range(start, stop, step)
+                return [self[i] for i in indices]
+            
+        # Handle integer index
+        if index < 0:
+            index = len(self) + index
+        if not 0 <= index < len(self):
+            raise IndexError("list index out of range")
+
+        cursor = self.conn.execute(
+            f"SELECT value FROM {self._TABLE_NAME} WHERE idx=?", (index,)
+        )
+        row = cursor.fetchone()
+        if row is None:
+            raise IndexError("list index out of range")
+        return self.deserialize(row[0])
+
+    def __setitem__(self, index, value):
+        if index < 0:
+            index = len(self) + index
+        if not 0 <= index < len(self):
+            raise IndexError("list assignment index out of range")
+
+        serialized = self.serialize(value)
+        with self.conn:
+            self.conn.execute(
+                f"UPDATE {self._TABLE_NAME} SET value=? WHERE idx=?",
+                (serialized, index),
+            )
+
+    def __delitem__(self, index):
+        if index < 0:
+            index = len(self) + index
+        if not 0 <= index < len(self):
+            raise IndexError("list assignment index out of range")
+
+        with self.conn:
+            self.conn.execute(f"DELETE FROM {self._TABLE_NAME} WHERE idx=?", (index,))
+            self.conn.execute(
+                f"UPDATE {self._TABLE_NAME} SET idx = idx - 1 WHERE idx > ?", (index,)
+            )
+
+    def insert(self, index, value):
+        """
+        Inserts a value at the given index by shifting everything
+        at or after `index` up by one in descending order.
+        """
+        length = len(self)
+        if index < 0:
+            index = 0
+        if index > length:
+            index = length
+
+        serialized = self.serialize(value)
+        with self.conn:
+            # Shift every idx >= `index` up by 1, in descending order
+            for i in reversed(range(index, length)):
+                self.conn.execute(
+                    f"UPDATE {self._TABLE_NAME} SET idx = ? WHERE idx = ?",
+                    (i + 1, i),
+                )
+
+            # Now insert the new item
+            self.conn.execute(
+                f"INSERT INTO {self._TABLE_NAME} (idx, value) VALUES (?, ?)",
+                (index, serialized),
+            )
+
+    def append(self, value):
+        """Append a value to the end of the list."""
+        index = len(self)
+        serialized = self.serialize(value)
+        with self.conn:
+            self.conn.execute(
+                f"INSERT INTO {self._TABLE_NAME} (idx, value) VALUES (?, ?)",
+                (index, serialized),
+            )
+
+    def extend(self, values: Iterable) -> None:
+        """
+        Extend the list by appending all items in the given iterable.
+        
+        Processes one item at a time to minimize memory usage.
+        
+        Args:
+            values: Iterable of values to append
+        """
+        start_idx = len(self)
+        with self.conn:
+            # Use a single transaction for efficiency
+            for i, item in enumerate(values):
+                # Serialize and insert one at a time to minimize memory usage
+                serialized = self.serialize(item)
+                self.conn.execute(
+                    f"INSERT INTO {self._TABLE_NAME} (idx, value) VALUES (?, ?)",
+                    (start_idx + i, serialized)
+                )
+                # Clear reference to allow garbage collection
+                del serialized
+
+    def close(self):
+        """
+        Close the database connection and remove the temporary file.
+        """
+        self.conn.close()
+        if os.path.exists(self.db_path):
+            os.remove(self.db_path)
+
+    def __repr__(self):
+        num_items = len(self)
+        preview_count = min(num_items, 10)
+        items = [self[i] for i in range(preview_count)]
+        if preview_count < num_items:
+            return f"{items}... (total {num_items} items)"
+        else:
+            return str(items)
+
+    def __add__(self, other):
+        """
+        Concatenates two SQLiteLists and returns a new SQLiteList containing all elements.
+        Use memory-efficient copy operation.
+        """
+        if not isinstance(other, SQLiteList):
+            raise TypeError(
+                f"unsupported operand type(s) for +: '{type(self).__name__}' and '{type(other).__name__}'"
+            )
+
+        # Create a new instance of the same class
+        result = type(self)()
+        
+        # Use stream to copy all items from self
+        result.extend(self.stream())
+        
+        # Use stream to copy all items from other
+        result.extend(other.stream())
+
+        return result
+
+    def stream(self) -> Iterator[Any]:
+        """Stream items from the database without loading everything into memory."""
+        cursor = self.conn.execute(f"SELECT value FROM {self._TABLE_NAME} ORDER BY idx")
+        for row in cursor:
+            yield self.deserialize(row[0])
+
+    def stream_batched(self, batch_size: int = 1000) -> Iterator[List[Any]]:
+        """
+        Stream items in batches to reduce memory usage and improve performance.
+        
+        Args:
+            batch_size: Number of items to yield in each batch
+            
+        Yields:
+            Lists of deserialized items, with at most batch_size items per list
+        """
+        cursor = self.conn.execute(f"SELECT value FROM {self._TABLE_NAME} ORDER BY idx")
+        batch = []
+        
+        for row in cursor:
+            batch.append(self.deserialize(row[0]))
+            if len(batch) >= batch_size:
+                yield batch
+                batch = []
+                
+        if batch:  # Don't forget the last batch if it's not full
+            yield batch
+
+    def __iter__(self):
+        """Iterate over items using streaming."""
+        return self.stream()
+
+    def equals(self, other):
+        """Memory-efficient comparison of two SQLiteLists."""
+        if len(self) != len(other):
+            return False
+        
+        # Compare in batches to reduce memory usage
+        batch_size = 1000
+        self_batches = self.stream_batched(batch_size)
+        other_batches = other.stream_batched(batch_size) if hasattr(other, 'stream_batched') else None
+        
+        if other_batches:
+            # Both objects support batched streaming
+            for self_batch, other_batch in zip(self_batches, other_batches):
+                if len(self_batch) != len(other_batch):
+                    return False
+                for i in range(len(self_batch)):
+                    if self_batch[i] != other_batch[i]:
+                        return False
+            return True
+        else:
+            # Fall back to item-by-item comparison
+            for i in range(len(self)):
+                if self[i] != other[i]:
+                    return False
+            return True
+
+    def __eq__(self, other):
+        """Use memory-efficient comparison by default."""
+        return self.equals(other)
+
+    def copy_from(self, source_db_path: str) -> None:
+        """Copy data from another SQLite database file.
+        
+        Args:
+            source_db_path: Path to the source SQLite database file
+            
+        Raises:
+            sqlite3.Error: If there's an error accessing the source database
+        """
+        import sqlite3
+        import time
+        import shutil
+        import tempfile
+        
+        # Make a temporary copy of the source database to avoid locking issues
+        with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as temp_file:
+            temp_db_path = temp_file.name
+        
+        try:
+            # Copy the source database to a temporary file
+            shutil.copy2(source_db_path, temp_db_path)
+            
+            # Connect to the copied database
+            source_conn = sqlite3.connect(temp_db_path)
+            source_cursor = source_conn.cursor()
+            
+            try:
+                # Check if the table exists in the source database
+                source_cursor.execute(f"SELECT name FROM sqlite_master WHERE type='table' AND name='{self._TABLE_NAME}'")
+                if not source_cursor.fetchone():
+                    return  # Table doesn't exist in source, nothing to copy
+                
+                # Get data from source database
+                source_cursor.execute(f"SELECT idx, value FROM {self._TABLE_NAME} ORDER BY idx")
+                rows = source_cursor.fetchall()
+                
+                # Empty the current database
+                with self.conn:
+                    self.conn.execute(f"DELETE FROM {self._TABLE_NAME}")
+                
+                # Insert data into the destination database
+                with self.conn:
+                    self.conn.executemany(
+                        f"INSERT INTO {self._TABLE_NAME} (idx, value) VALUES (?, ?)",
+                        rows
+                    )
+            finally:
+                source_cursor.close()
+                source_conn.close()
+        finally:
+            # Clean up the temporary file
+            import os
+            if os.path.exists(temp_db_path):
+                try:
+                    os.unlink(temp_db_path)
+                except:
+                    pass
+
+    def __del__(self):
+        """Clean up the temporary file when the object is deleted."""
+        try:
+            self.conn.close()
+            os.unlink(self.db_path)
+        except:
+            pass

edsl/inference_services/__init__.py

@@ -1,13 +1,48 @@
-from .inference_services_collection import InferenceServicesCollection
-from .registry import default
+# Import only the exceptions first to avoid circular imports
+from .exceptions import InferenceServiceError
+
+# Import the classes directly here for external use
+# While avoiding circular imports with other modules
 from .inference_service_abc import InferenceServiceABC
 from .data_structures import AvailableModels
-from .exceptions import InferenceServiceError
+from .inference_services_collection import InferenceServicesCollection
 
+# Define __all__ without default - we'll add it later
 __all__ = [
     "InferenceServicesCollection",
-    "default",
     "InferenceServiceABC",
     "AvailableModels",
     "InferenceServiceError"
-]
+]
+
+# Better approach: import the default instance immediately in a try/except
+# If it fails, we'll define the default variable later to make imports work
+try:
+    from .registry import default
+except ImportError:
+    # This allows all imports to still work, while deferring the actual
+    # import of registry.default to when it's accessed
+    from types import SimpleNamespace
+    
+    # Global placeholder for default registry instance
+    _default_instance = None
+    
+    def _get_default():
+        """Load the default registry instance the first time it's needed"""
+        global _default_instance
+        if _default_instance is None:
+            from .registry import default as registry_default
+            _default_instance = registry_default
+        return _default_instance
+    
+    # Define a simple proxy class for default
+    class DefaultProxy(SimpleNamespace):
+        def __getattr__(self, name):
+            # Forward all attribute access to the real default instance
+            return getattr(_get_default(), name)
+    
+    # Create the proxy instance that stands in for default
+    default = DefaultProxy()
+
+# Add default to __all__ now that we've defined it
+__all__.append("default")

edsl/inference_services/exceptions.py

@@ -36,6 +36,17 @@ class InferenceServiceError(BaseException):
     relevant_doc = "https://docs.expectedparrot.com/en/latest/remote_inference.html"
 
 
+
+
+class InferenceServiceIntendedError(InferenceServiceError):
+    """
+    Test error - this is an error thrown on purpose to test the error handling in the framework.
+
+    """
+    relevant_doc = "https://docs.expectedparrot.com/en/latest/language_models.html#model-parameters"
+
+
+
 class InferenceServiceValueError(InferenceServiceError):
     """
     Exception raised when invalid values are provided to inference services.

edsl/inference_services/services/anthropic_service.py

@@ -3,9 +3,10 @@ from typing import Any, Optional, List, TYPE_CHECKING
 from anthropic import AsyncAnthropic
 
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
 
+# Use TYPE_CHECKING to avoid circular imports at runtime
 if TYPE_CHECKING:
+    from ...language_models import LanguageModel
     from ....scenarios.file_store import FileStore as Files
 
 
@@ -40,10 +41,12 @@ class AnthropicService(InferenceServiceABC):
     @classmethod
     def create_model(
         cls, model_name: str = "claude-3-opus-20240229", model_class_name=None
-    ) -> LanguageModel:
+    ) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with OpenAI models

edsl/inference_services/services/aws_bedrock.py

@@ -3,7 +3,9 @@ from typing import Any, List, Optional, TYPE_CHECKING
 import boto3
 from botocore.exceptions import ClientError
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
 
 if TYPE_CHECKING:
     from ....scenarios.file_store import FileStore
@@ -49,10 +51,12 @@ class AwsBedrockService(InferenceServiceABC):
     @classmethod
     def create_model(
         cls, model_name: str = "amazon.titan-tg1-large", model_class_name=None
-    ) -> LanguageModel:
+    ) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with AWS Bedrock models.

edsl/inference_services/services/azure_ai.py

@@ -2,7 +2,9 @@ import os
 from typing import Any, Optional, List, TYPE_CHECKING
 from openai import AsyncAzureOpenAI
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
 
 if TYPE_CHECKING:
     from ....scenarios.file_store import FileStore
@@ -98,10 +100,12 @@ class AzureAIService(InferenceServiceABC):
     @classmethod
     def create_model(
         cls, model_name: str = "azureai", model_class_name=None
-    ) -> LanguageModel:
+    ) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with Azure OpenAI models.

edsl/inference_services/services/google_service.py

@@ -7,9 +7,9 @@ from google.api_core.exceptions import InvalidArgument
 
 # from ...exceptions.general import MissingAPIKeyError
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
-
+# Use TYPE_CHECKING to avoid circular imports at runtime
 if TYPE_CHECKING:
+    from ...language_models import LanguageModel
     from ....scenarios.file_store import FileStore as Files
 #from ...coop import Coop
 
@@ -65,6 +65,7 @@ class GoogleService(InferenceServiceABC):
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
         from ...language_models import LanguageModel
 
         class LLM(LanguageModel):

edsl/inference_services/services/mistral_ai_service.py

@@ -4,7 +4,9 @@ from mistralai import Mistral
 
 
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
 
 if TYPE_CHECKING:
     from ....scenarios.file_store import FileStore
@@ -64,10 +66,12 @@ class MistralAIService(InferenceServiceABC):
     @classmethod
     def create_model(
         cls, model_name: str = "mistral", model_class_name=None
-    ) -> LanguageModel:
+    ) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with Mistral models.

edsl/inference_services/services/open_ai_service.py

@@ -5,7 +5,9 @@ import os
 import openai
 
 from ..inference_service_abc import InferenceServiceABC
-from ...language_models import LanguageModel
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
 from ..rate_limits_cache import rate_limits
 
 if TYPE_CHECKING:
@@ -110,10 +112,12 @@ class OpenAIService(InferenceServiceABC):
         return cls._models_list_cache
 
     @classmethod
-    def create_model(cls, model_name, model_class_name=None) -> LanguageModel:
+    def create_model(cls, model_name, model_class_name=None) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with OpenAI models

edsl/inference_services/services/perplexity_service.py

@@ -1,7 +1,9 @@
 from typing import Any, List, Optional, TYPE_CHECKING
 from ..rate_limits_cache import rate_limits
 
-from ...language_models import LanguageModel
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
 
 from .open_ai_service import OpenAIService
 
@@ -40,10 +42,12 @@ class PerplexityService(OpenAIService):
     @classmethod
     def create_model(
         cls, model_name="llama-3.1-sonar-large-128k-online", model_class_name=None
-    ) -> LanguageModel:
+    ) -> 'LanguageModel':
         if model_class_name is None:
             model_class_name = cls.to_class_name(model_name)
 
+        # Import LanguageModel only when actually creating a model
+        from ...language_models import LanguageModel
         class LLM(LanguageModel):
             """
             Child class of LanguageModel for interacting with Perplexity models