edsl 0.1.59__py3-none-any.whl → 0.1.61__py3-none-any.whl

edsl/coop/coop_prolific_filters.py

@@ -0,0 +1,171 @@
+import reprlib
+from typing import Optional
+
+from .exceptions import CoopValueError
+from ..scenarios import Scenario, ScenarioList
+
+
+class CoopProlificFilters(ScenarioList):
+    """Base class for Prolific filters supported on Coop.
+
+    This abstract class extends ScenarioList to provide common functionality
+    for working with Prolific filters.
+    """
+
+    def __init__(
+        self, data: Optional[list] = None, codebook: Optional[dict[str, str]] = None
+    ):
+        super().__init__(data, codebook)
+
+    def find(self, filter_id: str) -> Optional[Scenario]:
+        """
+        Find a filter by its ID. Raises a CoopValueError if the filter is not found.
+
+        >>> filters = coop.list_prolific_filters()
+        >>> filters.find("age")
+        Scenario(
+            {
+                "filter_id": "age",
+                "type": "range",
+                "range_filter_min": 18,
+                "range_filter_max": 100,
+                ...
+            }
+        """
+
+        # Prolific has inconsistent naming conventions for filters -
+        # some use underscores and some use dashes, so we need to check for both
+        id_with_dashes = filter_id.replace("_", "-")
+        id_with_underscores = filter_id.replace("-", "_")
+
+        for scenario in self:
+            if (
+                scenario["filter_id"] == id_with_dashes
+                or scenario["filter_id"] == id_with_underscores
+            ):
+                return scenario
+        raise CoopValueError(f"Filter with ID {filter_id} not found.")
+
+    def create_study_filter(
+        self,
+        filter_id: str,
+        min: Optional[int] = None,
+        max: Optional[int] = None,
+        values: Optional[list[str]] = None,
+    ) -> dict:
+        """
+        Create a valid filter dict that is compatible with Coop.create_prolific_study().
+        This function will raise a CoopValueError if:
+        - The filter ID is not found
+        - A range filter is provided with no min or max value, or a value that is outside of the allowed range
+        - A select filter is provided with no values, or a value that is not in the allowed options
+
+        For a select filter, you should pass a list of values:
+        >>> filters = coop.list_prolific_filters()
+        >>> filters.create_study_filter("current_country_of_residence", values=["United States", "Canada"])
+        {
+            "filter_id": "current_country_of_residence",
+            "selected_values": ["1", "45"],
+        }
+
+        For a range filter, you should pass a min and max value:
+        >>> filters.create_study_filter("age", min=20, max=40)
+        {
+            "filter_id": "age",
+            "selected_range": {
+                "lower": 20,
+                "upper": 40,
+            },
+        }
+        """
+        filter = self.find(filter_id)
+
+        # .find() has logic to handle inconsistent naming conventions for filter IDs,
+        # so we need to get the correct filter ID from the filter dict
+        correct_filter_id = filter.get("filter_id")
+
+        filter_type = filter.get("type")
+
+        if filter_type == "range":
+            filter_min = filter.get("range_filter_min")
+            filter_max = filter.get("range_filter_max")
+
+            if min is None and max is None:
+                raise CoopValueError("Range filters require both a min and max value.")
+            if min < filter_min:
+                raise CoopValueError(
+                    f"Min value {min} is less than the minimum allowed value {filter_min}."
+                )
+            if max > filter_max:
+                raise CoopValueError(
+                    f"Max value {max} is greater than the maximum allowed value {filter_max}."
+                )
+            if min > max:
+                raise CoopValueError("Min value cannot be greater than max value.")
+            return {
+                "filter_id": correct_filter_id,
+                "selected_range": {
+                    "lower": min,
+                    "upper": max,
+                },
+            }
+        elif filter_type == "select":
+            if values is None:
+                raise CoopValueError("Select filters require a list of values.")
+
+            if correct_filter_id == "custom_allowlist":
+                return {
+                    "filter_id": correct_filter_id,
+                    "selected_values": values,
+                }
+
+            try:
+                allowed_option_labels = filter.get("select_filter_options", {})
+                option_labels_to_ids = {v: k for k, v in allowed_option_labels.items()}
+                selected_option_ids = [option_labels_to_ids[value] for value in values]
+            except KeyError:
+                raise CoopValueError(
+                    f"Invalid value(s) provided for filter {filter_id}: {values}. "
+                    f"Call find() with the filter ID to examine the allowed values for this filter."
+                )
+
+            return {
+                "filter_id": correct_filter_id,
+                "selected_values": selected_option_ids,
+            }
+        else:
+            raise CoopValueError(f"Unsupported filter type: {filter_type}.")
+
+    def table(
+        self,
+        *fields,
+        tablefmt: Optional[str] = None,
+        pretty_labels: Optional[dict[str, str]] = None,
+    ) -> str:
+        """Return the CoopProlificFilters as a table with truncated options display for select filters."""
+
+        # Create a copy of the data with truncated options
+        truncated_scenarios = []
+        for scenario in self:
+            scenario_dict = dict(scenario)
+            if (
+                "select_filter_options" in scenario_dict
+                and scenario_dict["select_filter_options"] is not None
+            ):
+
+                # Create a truncated representation of the options list
+                formatter = reprlib.Repr()
+                formatter.maxstring = 50
+                select_filter_options = list(
+                    dict(scenario_dict["select_filter_options"]).values()
+                )
+                formatted_options = formatter.repr(select_filter_options)
+                scenario_dict["select_filter_options"] = formatted_options
+            truncated_scenarios.append(scenario_dict)
+
+        temp_scenario_list = ScenarioList([Scenario(s) for s in truncated_scenarios])
+
+        # Display the table with the truncated data
+        return temp_scenario_list.table(
+            *fields, tablefmt=tablefmt, pretty_labels=pretty_labels
+        )

edsl/dataset/dataset_operations_mixin.py

@@ -357,7 +357,7 @@ class DataOperationsBase:
             4
             >>> engine = Results.example()._db(shape = "long")
             >>> len(engine.execute(text("SELECT * FROM self")).fetchall())
-            204
+            212
         """
         # Import needed for database connection
         from sqlalchemy import create_engine
@@ -442,7 +442,7 @@ class DataOperationsBase:
 
             # Using long format
             >>> len(r.sql("SELECT * FROM self", shape="long"))
-            204
+            212
         """
         import pandas as pd
 

edsl/dataset/display/table_display.py

@@ -55,13 +55,46 @@ class TableDisplay:
             self.printing_parameters = {}
 
     def _repr_html_(self) -> str:
-        table_data = TableData(
-            headers=self.headers,
-            data=self.data,
-            parameters=self.printing_parameters,
-            raw_data_set=self.raw_data_set,
-        )
-        return self.renderer_class(table_data).render_html()
+        """
+        HTML representation for Jupyter/Colab notebooks.
+
+        The primary path uses the configured `renderer_class` to build an HTML
+        string.  Unfortunately, in shared or long-running notebook runtimes it
+        is not uncommon for binary dependencies (NumPy, Pandas, etc.) to get
+        into an incompatible state, raising import-time errors that would
+        otherwise bubble up to the notebook and obscure the actual table
+        output.  To make the developer experience smoother we catch *any*
+        exception, log/annotate it, and fall back to a plain-text rendering via
+        `tabulate`, wrapped in a <pre> block so at least a readable table is
+        shown.
+        """
+        try:
+            table_data = TableData(
+                headers=self.headers,
+                data=self.data,
+                parameters=self.printing_parameters,
+                raw_data_set=self.raw_data_set,
+            )
+            return self.renderer_class(table_data).render_html()
+        except Exception as exc:  # pragma: no cover
+            # --- graceful degradation -------------------------------------------------
+            try:
+                from tabulate import tabulate
+
+                plain = tabulate(
+                    self.data,
+                    headers=self.headers,
+                    tablefmt=self.tablefmt or "simple",
+                )
+            except Exception:
+                # Even `tabulate` failed – resort to the default __repr__.
+                plain = super().__repr__() if hasattr(super(), "__repr__") else str(self.data)
+
+            # Escape HTML-sensitive chars so the browser renders plain text.
+            import html
+
+            safe_plain = html.escape(plain)
+            return f"<pre>{safe_plain}\n\n[TableDisplay fallback – original error: {exc}]</pre>"
 
     def __repr__(self):
         # If rich format is requested, use RichRenderer

edsl/db_list/sqlite_list.py

@@ -4,7 +4,7 @@ import os
 import json
 from typing import Any, Callable, Iterable, Iterator, List, Optional
 from abc import ABC, abstractmethod
-from collections.abc import MutableSequence
+from collections.abc import MutableSequence, MutableMapping
 
 
 class SQLiteList(MutableSequence, ABC):
@@ -97,7 +97,20 @@ class SQLiteList(MutableSequence, ABC):
         row = cursor.fetchone()
         if row is None:
             raise IndexError("list index out of range")
-        return self.deserialize(row[0])
+
+        obj = self.deserialize(row[0])
+
+        # If the stored object is a Scenario (or subclass), return a specialised proxy
+        try:
+            from edsl.scenarios.scenario import Scenario
+            if isinstance(obj, Scenario):
+                return self._make_scenario_proxy(self, index, obj)
+        except ImportError:
+            # Scenario not available – fall back to generic proxy
+            pass
+
+        # Generic proxy for other types
+        return self._RowProxy(self, index, obj)
 
     def __setitem__(self, index, value):
         if index < 0:
@@ -346,4 +359,90 @@ class SQLiteList(MutableSequence, ABC):
             self.conn.close()
             os.unlink(self.db_path)
         except:
-            pass
+            pass
+
+    class _RowProxy(MutableMapping):
+        """A write-through proxy returned by SQLiteList.__getitem__.
+
+        Any mutation on the proxy (e.g. proxy[key] = value) is immediately
+        re-serialised and written back to the underlying SQLite storage,
+        ensuring the database stays in sync with in-memory edits.
+        """
+
+        def __init__(self, parent: "SQLiteList", idx: int, obj: Any):
+            self._parent = parent
+            self._idx = idx
+            self._obj = obj  # The real deserialised object (e.g. Scenario)
+
+        # ---- MutableMapping interface ----
+        def __getitem__(self, key):
+            return self._obj[key]
+
+        def __setitem__(self, key, value):
+            self._obj[key] = value
+            # Propagate change back to SQLite via parent list
+            self._parent.__setitem__(self._idx, self._obj)
+
+        def __delitem__(self, key):
+            del self._obj[key]
+            self._parent.__setitem__(self._idx, self._obj)
+
+        def __iter__(self):
+            return iter(self._obj)
+
+        def __len__(self):
+            return len(self._obj)
+
+        # ---- Convenience helpers ----
+        def __getattr__(self, name):  # Delegate attribute access
+            return getattr(self._obj, name)
+
+        def __repr__(self):
+            return repr(self._obj)
+
+    # Specialised proxy for Scenario objects so isinstance(obj, Scenario) remains True.
+    # Defined lazily to avoid importing Scenario at module load time for performance.
+    @staticmethod
+    def _make_scenario_proxy(parent: "SQLiteList", idx: int, scenario_obj: Any):
+        """Create and return an on-the-fly proxy class inheriting from Scenario but
+        immediately removed from the global subclass registry so serialization
+        coverage tests ignore it.
+        """
+        from edsl.scenarios.scenario import Scenario  # local import
+        from edsl.base import RegisterSubclassesMeta
+
+        # Dynamically build class dict with required methods
+        def _proxy_setitem(self, key, value):
+            Scenario.__setitem__(self, key, value)  # super call avoids MRO confusion
+            from edsl.scenarios.scenario import Scenario as S
+            self._parent.__setitem__(self._idx, S(dict(self)))
+
+        def _proxy_delitem(self, key):
+            Scenario.__delitem__(self, key)
+            from edsl.scenarios.scenario import Scenario as S
+            self._parent.__setitem__(self._idx, S(dict(self)))
+
+        def _proxy_reduce(self):
+            from edsl.scenarios.scenario import Scenario as S
+            return (S, (dict(self),))
+
+        proxy_cls = type(
+            "_ScenarioRowProxy",
+            (Scenario,),
+            {
+                "__setitem__": _proxy_setitem,
+                "__delitem__": _proxy_delitem,
+                "__reduce__": _proxy_reduce,
+                "__module__": Scenario.__module__,
+            },
+        )
+
+        # Remove this helper class from global registry so tests ignore it
+        RegisterSubclassesMeta._registry.pop(proxy_cls.__name__, None)
+
+        # Instantiate
+        instance = proxy_cls(dict(scenario_obj))
+        # attach parent tracking attributes
+        instance._parent = parent
+        instance._idx = idx
+        return instance

edsl/inference_services/services/__init__.py

@@ -8,6 +8,7 @@ from .groq_service import GroqService
 from .mistral_ai_service import MistralAIService
 from .ollama_service import OllamaService
 from .open_ai_service import OpenAIService
+from .open_ai_service_v2 import OpenAIServiceV2
 from .perplexity_service import PerplexityService
 from .test_service import TestService
 from .together_ai_service import TogetherAIService
@@ -24,8 +25,9 @@ __all__ = [
     "MistralAIService",
     "OllamaService",
     "OpenAIService",
+    "OpenAIServiceV2",
     "PerplexityService",
     "TestService",
     "TogetherAIService",
     "XAIService",
-] 
+]

edsl/inference_services/services/open_ai_service_v2.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+from typing import Any, List, Optional, Dict, NewType, TYPE_CHECKING
+import os
+
+import openai
+
+from ..inference_service_abc import InferenceServiceABC
+
+# Use TYPE_CHECKING to avoid circular imports at runtime
+if TYPE_CHECKING:
+    from ...language_models import LanguageModel
+from ..rate_limits_cache import rate_limits
+
+# Default to completions API but can use responses API with parameter
+
+if TYPE_CHECKING:
+    from ....scenarios.file_store import FileStore as Files
+    from ....invigilators.invigilator_base import InvigilatorBase as InvigilatorAI
+
+
+APIToken = NewType("APIToken", str)
+
+
+class OpenAIServiceV2(InferenceServiceABC):
+    """OpenAI service class using the Responses API."""
+
+    _inference_service_ = "openai_v2"
+    _env_key_name_ = "OPENAI_API_KEY"
+    _base_url_ = None
+
+    _sync_client_ = openai.OpenAI
+    _async_client_ = openai.AsyncOpenAI
+
+    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
+    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
+
+    # sequence to extract text from response.output
+    key_sequence = ["output", 1, "content", 0, "text"]
+    usage_sequence = ["usage"]
+    # sequence to extract reasoning summary from response.output
+    reasoning_sequence = ["output", 0, "summary"]
+    input_token_name = "prompt_tokens"
+    output_token_name = "completion_tokens"
+
+    available_models_url = "https://platform.openai.com/docs/models/gp"
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._sync_client_instances = {}
+        cls._async_client_instances = {}
+
+    @classmethod
+    def sync_client(cls, api_key: str) -> openai.OpenAI:
+        if api_key not in cls._sync_client_instances:
+            client = cls._sync_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._sync_client_instances[api_key] = client
+        return cls._sync_client_instances[api_key]
+
+    @classmethod
+    def async_client(cls, api_key: str) -> openai.AsyncOpenAI:
+        if api_key not in cls._async_client_instances:
+            client = cls._async_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._async_client_instances[api_key] = client
+        return cls._async_client_instances[api_key]
+
+    model_exclude_list = [
+        "whisper-1",
+        "davinci-002",
+        "dall-e-2",
+        "tts-1-hd-1106",
+        "tts-1-hd",
+        "dall-e-3",
+        "tts-1",
+        "babbage-002",
+        "tts-1-1106",
+        "text-embedding-3-large",
+        "text-embedding-3-small",
+        "text-embedding-ada-002",
+        "ft:davinci-002:mit-horton-lab::8OfuHgoo",
+        "gpt-3.5-turbo-instruct-0914",
+        "gpt-3.5-turbo-instruct",
+    ]
+    _models_list_cache: List[str] = []
+
+    @classmethod
+    def get_model_list(cls, api_key: str | None = None) -> List[str]:
+        if api_key is None:
+            api_key = os.getenv(cls._env_key_name_)
+        raw = cls.sync_client(api_key).models.list()
+        return raw.data if hasattr(raw, "data") else raw
+
+    @classmethod
+    def available(cls, api_token: str | None = None) -> List[str]:
+        if api_token is None:
+            api_token = os.getenv(cls._env_key_name_)
+        if not cls._models_list_cache:
+            data = cls.get_model_list(api_key=api_token)
+            cls._models_list_cache = [
+                m.id for m in data if m.id not in cls.model_exclude_list
+            ]
+        return cls._models_list_cache
+
+    @classmethod
+    def create_model(
+        cls,
+        model_name: str,
+        model_class_name: str | None = None,
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        from ...language_models import LanguageModel
+
+        class LLM(LanguageModel):
+            """Child class for OpenAI Responses API"""
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            reasoning_sequence = cls.reasoning_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 2000,
+                "top_p": 1,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "logprobs": False,
+                "top_logprobs": 3,
+            }
+
+            def sync_client(self) -> openai.OpenAI:
+                return cls.sync_client(api_key=self.api_token)
+
+            def async_client(self) -> openai.AsyncOpenAI:
+                return cls.async_client(api_key=self.api_token)
+
+            @classmethod
+            def available(cls) -> list[str]:
+                return cls.sync_client().models.list().data
+
+            def get_headers(self) -> dict[str, Any]:
+                client = self.sync_client()
+                response = client.responses.with_raw_response.create(
+                    model=self.model,
+                    input=[{"role": "user", "content": "Say this is a test"}],
+                    store=False,
+                )
+                return dict(response.headers)
+
+            def get_rate_limits(self) -> dict[str, Any]:
+                try:
+                    headers = rate_limits.get("openai", self.get_headers())
+                except Exception:
+                    return {"rpm": 10000, "tpm": 2000000}
+                return {
+                    "rpm": int(headers["x-ratelimit-limit-requests"]),
+                    "tpm": int(headers["x-ratelimit-limit-tokens"]),
+                }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List[Files]] = None,
+                invigilator: Optional[InvigilatorAI] = None,
+            ) -> dict[str, Any]:
+                content = user_prompt
+                if files_list:
+                    # embed files as separate inputs
+                    content = [{"type": "text", "text": user_prompt}]
+                    for f in files_list:
+                        content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{f.mime_type};base64,{f.base64_string}"
+                                },
+                            }
+                        )
+                # build input sequence
+                messages: Any
+                if system_prompt and not self.omit_system_prompt_if_empty:
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": content},
+                    ]
+                else:
+                    messages = [{"role": "user", "content": content}]
+
+                # All OpenAI models with the responses API use these base parameters
+                params = {
+                    "model": self.model,
+                    "input": messages,
+                    "temperature": self.temperature,
+                    "top_p": self.top_p,
+                    "store": False,
+                }
+                
+                # Check if this is a reasoning model (o-series models)
+                is_reasoning_model = any(tag in self.model for tag in ["o1", "o1-mini", "o3", "o3-mini", "o1-pro", "o4-mini"])
+                
+                # Only add reasoning parameter for reasoning models
+                if is_reasoning_model:
+                    params["reasoning"] = {"summary": "auto"}
+                
+                # For all models using the responses API, use max_output_tokens
+                # instead of max_tokens (which is for the completions API)
+                params["max_output_tokens"] = self.max_tokens
+                
+                # Specifically for o-series, we also set temperature to 1
+                if is_reasoning_model:
+                    params["temperature"] = 1
+
+                client = self.async_client()
+                try:
+                    response = await client.responses.create(**params)
+
+                except Exception as e:
+                    return {"message": str(e)}
+
+                # convert to dict
+                response_dict = response.model_dump()
+                return response_dict
+
+        LLM.__name__ = model_class_name
+        return LLM
+
+    @staticmethod
+    def _create_reasoning_sequence():
+        """Create the reasoning sequence for extracting reasoning summaries from model responses."""
+        # For OpenAI responses, the reasoning summary is typically found at:
+        # ["output", 0, "summary"]
+        # This is the path to the 'summary' field in the first item of the 'output' array
+        return ["output", 0, "summary"]