edsl 0.1.39__py3-none-any.whl → 0.1.39.dev1__py3-none-any.whl

edsl/agents/question_option_processor.py

@@ -1,172 +0,0 @@
-from jinja2 import Environment, meta
-from typing import List, Optional, Union
-
-
-class QuestionOptionProcessor:
-    """
-    Class that manages the processing of question options.
-    These can be provided directly, as a template string, or fetched from prior answers or the scenario.
-    """
-
-    def __init__(self, prompt_constructor):
-        self.prompt_constructor = prompt_constructor
-
-    @staticmethod
-    def _get_default_options() -> list:
-        """Return default placeholder options."""
-        return [f"<< Option {i} - Placeholder >>" for i in range(1, 4)]
-
-    @staticmethod
-    def _parse_template_variable(template_str: str) -> str:
-        """
-        Extract the variable name from a template string.
-
-        Args:
-            template_str (str): Jinja template string
-
-        Returns:
-            str: Name of the first undefined variable in the template
-
-        >>> QuestionOptionProcessor._parse_template_variable("Here are some {{ options }}")
-        'options'
-        >>> QuestionOptionProcessor._parse_template_variable("Here are some {{ options }} and {{ other }}")
-        Traceback (most recent call last):
-        ...
-        ValueError: Multiple variables found in template string
-        >>> QuestionOptionProcessor._parse_template_variable("Here are some")
-        Traceback (most recent call last):
-        ...
-        ValueError: No variables found in template string
-        """
-        env = Environment()
-        parsed_content = env.parse(template_str)
-        undeclared_variables = list(meta.find_undeclared_variables(parsed_content))
-        if not undeclared_variables:
-            raise ValueError("No variables found in template string")
-        if len(undeclared_variables) > 1:
-            raise ValueError("Multiple variables found in template string")
-        return undeclared_variables[0]
-
-    @staticmethod
-    def _get_options_from_scenario(
-        scenario: dict, option_key: str
-    ) -> Union[list, None]:
-        """
-        Try to get options from scenario data.
-
-        >>> from edsl import Scenario
-        >>> scenario = Scenario({"options": ["Option 1", "Option 2"]})
-        >>> QuestionOptionProcessor._get_options_from_scenario(scenario, "options")
-        ['Option 1', 'Option 2']
-
-
-        Returns:
-            list | None: List of options if found in scenario, None otherwise
-        """
-        scenario_options = scenario.get(option_key)
-        return scenario_options if isinstance(scenario_options, list) else None
-
-    @staticmethod
-    def _get_options_from_prior_answers(
-        prior_answers: dict, option_key: str
-    ) -> Union[list, None]:
-        """
-        Try to get options from prior answers.
-
-        prior_answers (dict): Dictionary of prior answers
-        option_key (str): Key to look up in prior answers
-
-        >>> from edsl import QuestionList as Q
-        >>> q = Q.example()
-        >>> q.answer = ["Option 1", "Option 2"]
-        >>> prior_answers = {"options": q}
-        >>> QuestionOptionProcessor._get_options_from_prior_answers(prior_answers, "options")
-        ['Option 1', 'Option 2']
-        >>> QuestionOptionProcessor._get_options_from_prior_answers(prior_answers, "wrong_key") is None
-        True
-
-        Returns:
-            list | None: List of options if found in prior answers, None otherwise
-        """
-        prior_answer = prior_answers.get(option_key)
-        if prior_answer and hasattr(prior_answer, "answer"):
-            if isinstance(prior_answer.answer, list):
-                return prior_answer.answer
-        return None
-
-    def get_question_options(self, question_data: dict) -> list:
-        """
-        Extract and process question options from question data.
-
-        Args:
-            question_data (dict): Dictionary containing question configuration
-
-        Returns:
-            list: List of question options. Returns default placeholders if no valid options found.
-
-        >>> class MockPromptConstructor:
-        ...     pass
-        >>> mpc = MockPromptConstructor()
-        >>> from edsl import Scenario
-        >>> mpc.scenario = Scenario({"options": ["Option 1", "Option 2"]})
-        >>> processor = QuestionOptionProcessor(mpc)
-
-        The basic case where options are directly provided:
-
-        >>> question_data = {"question_options": ["Option 1", "Option 2"]}
-        >>> processor.get_question_options(question_data)
-        ['Option 1', 'Option 2']
-
-        The case where options are provided as a template string:
-
-        >>> question_data = {"question_options": "{{ options }}"}
-        >>> processor.get_question_options(question_data)
-        ['Option 1', 'Option 2']
-
-        The case where there is a templace string but it's in the prior answers:
-
-        >>> class MockQuestion:
-        ...     pass
-        >>> q0 = MockQuestion()
-        >>> q0.answer = ["Option 1", "Option 2"]
-        >>> mpc.prior_answers_dict = lambda: {'q0': q0}
-        >>> processor = QuestionOptionProcessor(mpc)
-        >>> question_data = {"question_options": "{{ q0 }}"}
-        >>> processor.get_question_options(question_data)
-        ['Option 1', 'Option 2']
-
-        The case we're no options are found:
-        >>> processor.get_question_options({"question_options": "{{ poop }}"})
-        ['<< Option 1 - Placeholder >>', '<< Option 2 - Placeholder >>', '<< Option 3 - Placeholder >>']
-
-        """
-        options_entry = question_data.get("question_options")
-
-        # If not a template string, return as is or default
-        if not isinstance(options_entry, str):
-            return options_entry if options_entry else self._get_default_options()
-
-        # Parse template to get variable name
-        option_key = self._parse_template_variable(options_entry)
-
-        # Try getting options from scenario
-        scenario_options = self._get_options_from_scenario(
-            self.prompt_constructor.scenario, option_key
-        )
-        if scenario_options:
-            return scenario_options
-
-        # Try getting options from prior answers
-        prior_answer_options = self._get_options_from_prior_answers(
-            self.prompt_constructor.prior_answers_dict(), option_key
-        )
-        if prior_answer_options:
-            return prior_answer_options
-
-        return self._get_default_options()
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/coop/CoopFunctionsMixin.py

@@ -1,15 +0,0 @@
-class CoopFunctionsMixin:
-    def better_names(self, existing_names):
-        from edsl import QuestionList, Scenario
-
-        s = Scenario({"existing_names": existing_names})
-        q = QuestionList(
-            question_text="""The following colum names are already in use: {{ existing_names }} 
-                         Please provide new names for the columns.
-                         They should be short, one or two words, and unique. They should be valid Python idenifiers. 
-                         No spaces - use underscores instead. 
-                         """,
-            question_name="better_names",
-        )
-        results = q.by(s).run(verbose=False)
-        return results.select("answer.better_names").first()

edsl/coop/ExpectedParrotKeyHandler.py

@@ -1,125 +0,0 @@
-from pathlib import Path
-import os
-import platformdirs
-
-
-import sys
-import select
-
-
-def get_input_with_timeout(prompt, timeout=5, default="y"):
-    print(prompt, end="", flush=True)
-    ready, _, _ = select.select([sys.stdin], [], [], timeout)
-    if ready:
-        return sys.stdin.readline().strip()
-    print(f"\nNo input received within {timeout} seconds. Using default: {default}")
-    return default
-
-
-class ExpectedParrotKeyHandler:
-    asked_to_store_file_name = "asked_to_store.txt"
-    ep_key_file_name = "ep_api_key.txt"
-    application_name = "edsl"
-
-    @property
-    def config_dir(self):
-        return platformdirs.user_config_dir(self.application_name)
-
-    def _ep_key_file_exists(self) -> bool:
-        """Check if the Expected Parrot key file exists."""
-        return Path(self.config_dir).joinpath(self.ep_key_file_name).exists()
-
-    def ok_to_ask_to_store(self):
-        """Check if it's okay to ask the user to store the key."""
-        from edsl.config import CONFIG
-
-        if CONFIG.get("EDSL_RUN_MODE") != "production":
-            return False
-
-        return (
-            not Path(self.config_dir).joinpath(self.asked_to_store_file_name).exists()
-        )
-
-    def reset_asked_to_store(self):
-        """Reset the flag that indicates whether the user has been asked to store the key."""
-        asked_to_store_path = Path(self.config_dir).joinpath(
-            self.asked_to_store_file_name
-        )
-        if asked_to_store_path.exists():
-            os.remove(asked_to_store_path)
-            print(
-                "Deleted the file that indicates whether the user has been asked to store the key."
-            )
-
-    def ask_to_store(self, api_key) -> bool:
-        """Ask the user if they want to store the Expected Parrot key. If they say "yes", store it."""
-        if self.ok_to_ask_to_store():
-            # can_we_store = get_input_with_timeout(
-            #     "Would you like to store your Expected Parrot key for future use? (y/n): ",
-            #     timeout=5,
-            #     default="y",
-            # )
-            can_we_store = "y"
-            if can_we_store.lower() == "y":
-                Path(self.config_dir).mkdir(parents=True, exist_ok=True)
-                self.store_ep_api_key(api_key)
-                # print("Stored Expected Parrot API key at ", self.config_dir)
-                return True
-            else:
-                Path(self.config_dir).mkdir(parents=True, exist_ok=True)
-                with open(
-                    Path(self.config_dir).joinpath(self.asked_to_store_file_name), "w"
-                ) as f:
-                    f.write("Yes")
-        return False
-
-    def get_ep_api_key(self):
-        # check if the key is stored in the config_dir
-        api_key = None
-        api_key_from_cache = None
-        api_key_from_os = None
-
-        if self._ep_key_file_exists():
-            with open(Path(self.config_dir).joinpath(self.ep_key_file_name), "r") as f:
-                api_key_from_cache = f.read().strip()
-
-        api_key_from_os = os.getenv("EXPECTED_PARROT_API_KEY")
-
-        if api_key_from_os and api_key_from_cache:
-            if api_key_from_os != api_key_from_cache:
-                import warnings
-
-                warnings.warn(
-                    "WARNING: The Expected Parrot API key from the environment variable "
-                    "differs from the one stored in the config directory. Using the one "
-                    "from the environment variable."
-                )
-            api_key = api_key_from_os
-
-        if api_key_from_os and not api_key_from_cache:
-            api_key = api_key_from_os
-
-        if not api_key_from_os and api_key_from_cache:
-            api_key = api_key_from_cache
-
-        if api_key is not None:
-            _ = self.ask_to_store(api_key)
-        return api_key
-
-    def delete_ep_api_key(self):
-        key_path = Path(self.config_dir) / self.ep_key_file_name
-        if key_path.exists():
-            os.remove(key_path)
-            print("Deleted Expected Parrot API key at ", key_path)
-
-    def store_ep_api_key(self, api_key):
-        # Create the directory if it doesn't exist
-        os.makedirs(self.config_dir, exist_ok=True)
-
-        # Create the path for the key file
-        key_path = Path(self.config_dir) / self.ep_key_file_name
-
-        # Save the key
-        with open(key_path, "w") as f:
-            f.write(api_key)
-        # print("Stored Expected Parrot API key at ", key_path)

edsl/exceptions/inference_services.py

@@ -1,5 +0,0 @@
-from edsl.exceptions.BaseException import BaseException
-
-
-class InferenceServiceError(BaseException):
-    relevant_doc = "https://docs.expectedparrot.com/"

edsl/inference_services/AvailableModelCacheHandler.py

@@ -1,184 +0,0 @@
-from typing import List, Optional, get_args, Union
-from pathlib import Path
-import sqlite3
-from datetime import datetime
-import tempfile
-from platformdirs import user_cache_dir
-from dataclasses import dataclass
-import os
-
-from edsl.inference_services.data_structures import LanguageModelInfo, AvailableModels
-from edsl.enums import InferenceServiceLiteral
-
-
-class AvailableModelCacheHandler:
-    MAX_ROWS = 1000
-    CACHE_VALIDITY_HOURS = 48
-
-    def __init__(
-        self,
-        cache_validity_hours: int = 48,
-        verbose: bool = False,
-        testing_db_name: str = None,
-    ):
-        self.cache_validity_hours = cache_validity_hours
-        self.verbose = verbose
-
-        if testing_db_name:
-            self.cache_dir = Path(tempfile.mkdtemp())
-            self.db_path = self.cache_dir / testing_db_name
-        else:
-            self.cache_dir = Path(user_cache_dir("edsl", "model_availability"))
-            self.db_path = self.cache_dir / "available_models.db"
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-        if os.path.exists(self.db_path):
-            if self.verbose:
-                print(f"Using existing cache DB: {self.db_path}")
-        else:
-            self._initialize_db()
-
-    @property
-    def path_to_db(self):
-        return self.db_path
-
-    def _initialize_db(self):
-        """Initialize the SQLite database with the required schema."""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            # Drop the old table if it exists (for migration)
-            cursor.execute("DROP TABLE IF EXISTS model_cache")
-            cursor.execute(
-                """
-                CREATE TABLE IF NOT EXISTS model_cache (
-                    timestamp DATETIME NOT NULL,
-                    model_name TEXT NOT NULL,
-                    service_name TEXT NOT NULL,
-                    UNIQUE(model_name, service_name)
-                )
-            """
-            )
-            conn.commit()
-
-    def _prune_old_entries(self, conn: sqlite3.Connection):
-        """Delete oldest entries when MAX_ROWS is exceeded."""
-        cursor = conn.cursor()
-        cursor.execute("SELECT COUNT(*) FROM model_cache")
-        count = cursor.fetchone()[0]
-
-        if count > self.MAX_ROWS:
-            cursor.execute(
-                """
-                DELETE FROM model_cache 
-                WHERE rowid IN (
-                    SELECT rowid 
-                    FROM model_cache 
-                    ORDER BY timestamp ASC 
-                    LIMIT ?
-                )
-            """,
-                (count - self.MAX_ROWS,),
-            )
-            conn.commit()
-
-    @classmethod
-    def example_models(cls) -> List[LanguageModelInfo]:
-        return [
-            LanguageModelInfo(
-                "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo", "deep_infra"
-            ),
-            LanguageModelInfo("openai/gpt-4", "openai"),
-        ]
-
-    def add_models_to_cache(self, models_data: List[LanguageModelInfo]):
-        """Add new models to the cache, updating timestamps for existing entries."""
-        current_time = datetime.now()
-
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            for model in models_data:
-                cursor.execute(
-                    """
-                    INSERT INTO model_cache (timestamp, model_name, service_name)
-                    VALUES (?, ?, ?)
-                    ON CONFLICT(model_name, service_name) 
-                    DO UPDATE SET timestamp = excluded.timestamp
-                """,
-                    (current_time, model.model_name, model.service_name),
-                )
-
-            # self._prune_old_entries(conn)
-            conn.commit()
-
-    def reset_cache(self):
-        """Clear all entries from the cache."""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("DELETE FROM model_cache")
-            conn.commit()
-
-    @property
-    def num_cache_entries(self):
-        """Return the number of entries in the cache."""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM model_cache")
-            count = cursor.fetchone()[0]
-            return count
-
-    def models(
-        self,
-        service: Optional[InferenceServiceLiteral],
-    ) -> Union[None, AvailableModels]:
-        """Return the available models within the cache validity period."""
-        # if service is not None:
-        #    assert service in get_args(InferenceServiceLiteral)
-
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            valid_time = datetime.now().timestamp() - (self.cache_validity_hours * 3600)
-
-            if self.verbose:
-                print(f"Fetching all with timestamp greater than {valid_time}")
-
-            cursor.execute(
-                """
-                SELECT DISTINCT model_name, service_name
-                FROM model_cache
-                WHERE timestamp > ?
-                ORDER BY timestamp DESC
-            """,
-                (valid_time,),
-            )
-
-            results = cursor.fetchall()
-            if not results:
-                if self.verbose:
-                    print("No results found in cache DB.")
-                return None
-
-            matching_models = [
-                LanguageModelInfo(model_name=row[0], service_name=row[1])
-                for row in results
-            ]
-
-            if self.verbose:
-                print(f"Found {len(matching_models)} models in cache DB.")
-            if service:
-                matching_models = [
-                    model for model in matching_models if model.service_name == service
-                ]
-
-            return AvailableModels(matching_models)
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
-    # cache_handler = AvailableModelCacheHandler(verbose=True)
-    # models_data = cache_handler.example_models()
-    # cache_handler.add_models_to_cache(models_data)
-    # print(cache_handler.models())
-    # cache_handler.clear_cache()
-    # print(cache_handler.models())