edsl 0.1.46__py3-none-any.whl → 0.1.47__py3-none-any.whl

edsl/language_models/LanguageModel.py

@@ -379,10 +379,10 @@ class LanguageModel(
         cached_response, cache_key = cache.fetch(**cache_call_params)
 
         if cache_used := cached_response is not None:
- #           print("cache used")
+            #           print("cache used")
             response = json.loads(cached_response)
         else:
-#            print("cache not used")
+            #            print("cache not used")
             f = (
                 self.remote_async_execute_model_call
                 if hasattr(self, "remote") and self.remote
@@ -398,14 +398,14 @@ class LanguageModel(
             TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
             response = await asyncio.wait_for(f(**params), timeout=TIMEOUT)
             new_cache_key = cache.store(
-                **cache_call_params, response=response
+                **cache_call_params, response=response, service=self._inference_service_
             )  # store the response in the cache
             assert new_cache_key == cache_key  # should be the same
 
-        #breakpoint()
+        # breakpoint()
 
         cost = self.cost(response)
-        #breakpoint()
+        # breakpoint()
         return ModelResponse(
             response=response,
             cache_used=cache_used,
@@ -470,7 +470,7 @@ class LanguageModel(
             model_outputs=model_outputs,
             edsl_dict=edsl_dict,
         )
-        #breakpoint()
+        # breakpoint()
         return agent_response_dict
 
     get_response = sync_wrapper(async_get_response)

edsl/questions/QuestionBase.py

@@ -18,6 +18,7 @@ from edsl.questions.SimpleAskMixin import SimpleAskMixin
 from edsl.questions.QuestionBasePromptsMixin import QuestionBasePromptsMixin
 from edsl.questions.question_base_gen_mixin import QuestionBaseGenMixin
 from edsl.utilities.remove_edsl_version import remove_edsl_version
+from edsl.utilities.utilities import is_valid_variable_name
 
 if TYPE_CHECKING:
     from edsl.questions.response_validator_abc import ResponseValidatorABC
@@ -56,6 +57,10 @@ class QuestionBase(
     _answering_instructions = None
     _question_presentation = None
 
+    def is_valid_question_name(self) -> bool:
+        """Check if the question name is valid."""
+        return is_valid_variable_name(self.question_name)
+
     @property
     def response_validator(self) -> "ResponseValidatorABC":
         """Return the response validator."""

edsl/questions/question_registry.py

@@ -60,26 +60,25 @@ class Question(metaclass=Meta):
         return q.example()
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(cls, url_or_uuid: Union[str, UUID]):
         """Pull the object from coop."""
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.get(uuid, url, "question")
+        return coop.get(url_or_uuid, "question")
 
     @classmethod
-    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def delete(cls, url_or_uuid: Union[str, UUID]):
         """Delete the object from coop."""
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.delete(uuid, url)
+        return coop.delete(url_or_uuid)
 
     @classmethod
     def patch(
         cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
+        url_or_uuid: Union[str, UUID],
         description: Optional[str] = None,
         value: Optional[Any] = None,
         visibility: Optional[str] = None,
@@ -88,7 +87,7 @@ class Question(metaclass=Meta):
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.patch(uuid, url, description, value, visibility)
+        return coop.patch(url_or_uuid, description, value, visibility)
 
     @classmethod
     def list_question_types(cls):

edsl/results/DatasetExportMixin.py

@@ -505,8 +505,9 @@ class DatasetExportMixin:
 
         from edsl.utilities.PrettyList import PrettyList
 
-        return PrettyList(list_to_return)
-
+        #return PrettyList(list_to_return)
+        return list_to_return
+    
     def html(
         self,
         filename: Optional[str] = None,
@@ -903,6 +904,102 @@ class DatasetExportMixin:
             result.data.pop(field_index)
 
         return result
+    
+    def drop(self, field_name):
+        """
+        Returns a new Dataset with the specified field removed.
+        
+        Args:
+            field_name (str): The name of the field to remove.
+            
+        Returns:
+            Dataset: A new Dataset instance without the specified field.
+            
+        Raises:
+            KeyError: If the field_name doesn't exist in the dataset.
+            
+        Examples:
+            >>> from edsl.results.Dataset import Dataset
+            >>> d = Dataset([{'a': [1, 2, 3]}, {'b': [4, 5, 6]}])
+            >>> d.drop('a')
+            Dataset([{'b': [4, 5, 6]}])
+            
+            >>> d.drop('c')
+            Traceback (most recent call last):
+            ...
+            KeyError: "Field 'c' not found in dataset"
+        """
+        from edsl.results.Dataset import Dataset
+        
+        # Check if field exists in the dataset
+        if field_name not in self.relevant_columns():
+            raise KeyError(f"Field '{field_name}' not found in dataset")
+        
+        # Create a new dataset without the specified field
+        new_data = [entry for entry in self.data if field_name not in entry]
+        return Dataset(new_data)
+
+    def remove_prefix(self):
+        """Returns a new Dataset with the prefix removed from all column names.
+        
+        The prefix is defined as everything before the first dot (.) in the column name.
+        If removing prefixes would result in duplicate column names, an exception is raised.
+        
+        Returns:
+            Dataset: A new Dataset with prefixes removed from column names
+            
+        Raises:
+            ValueError: If removing prefixes would result in duplicate column names
+            
+        Examples:
+            >>> from edsl.results import Results
+            >>> r = Results.example()
+            >>> r.select('how_feeling', 'how_feeling_yesterday').relevant_columns()
+            ['answer.how_feeling', 'answer.how_feeling_yesterday']
+            >>> r.select('how_feeling', 'how_feeling_yesterday').remove_prefix().relevant_columns()
+            ['how_feeling', 'how_feeling_yesterday']
+            
+            >>> from edsl.results.Dataset import Dataset
+            >>> d = Dataset([{'a.x': [1, 2, 3]}, {'b.x': [4, 5, 6]}])
+            >>> d.remove_prefix()
+            Traceback (most recent call last):
+            ...
+            ValueError: Removing prefixes would result in duplicate column names: ['x']
+        """
+        from edsl.results.Dataset import Dataset
+        
+        # Get all column names
+        columns = self.relevant_columns()
+        
+        # Extract the unprefixed names
+        unprefixed = {}
+        duplicates = set()
+        
+        for col in columns:
+            if '.' in col:
+                unprefixed_name = col.split('.', 1)[1]
+                if unprefixed_name in unprefixed:
+                    duplicates.add(unprefixed_name)
+                unprefixed[unprefixed_name] = col
+            else:
+                # For columns without a prefix, keep them as is
+                unprefixed[col] = col
+        
+        # Check for duplicates
+        if duplicates:
+            raise ValueError(f"Removing prefixes would result in duplicate column names: {sorted(list(duplicates))}")
+        
+        # Create a new dataset with unprefixed column names
+        new_data = []
+        for entry in self.data:
+            key, values = list(entry.items())[0]
+            if '.' in key:
+                new_key = key.split('.', 1)[1]
+            else:
+                new_key = key
+            new_data.append({new_key: values})
+        
+        return Dataset(new_data)
 
 
 if __name__ == "__main__":

edsl/results/Results.py

@@ -1379,6 +1379,65 @@ class Results(UserList, Mixins, Base):
             raise ResultsError(f"Failed to fetch remote results: {str(e)}")
 
 
+    def spot_issues(self, models: Optional[ModelList] = None) -> Results:
+        """Run a survey to spot issues and suggest improvements for prompts that had no model response, returning a new Results object.
+        Future version: Allow user to optionally pass a list of questions to review, regardless of whether they had a null model response.
+        """
+        from edsl.questions import QuestionFreeText, QuestionDict
+        from edsl.surveys import Survey
+        from edsl.scenarios import Scenario, ScenarioList
+        from edsl.language_models import Model, ModelList
+        import pandas as pd
+
+        df = self.select("agent.*", "scenario.*", "answer.*", "raw_model_response.*", "prompt.*").to_pandas()
+        scenario_list = []
+
+        for _, row in df.iterrows():
+            for col in df.columns:
+                if col.endswith("_raw_model_response") and pd.isna(row[col]):
+                    q = col.split("_raw_model_response")[0].replace("raw_model_response.", "")
+
+                    s = Scenario({
+                        "original_question": q,
+                        "original_agent_index": row["agent.agent_index"],
+                        "original_scenario_index": row["scenario.scenario_index"],
+                        "original_prompts": f"User prompt: {row[f'prompt.{q}_user_prompt']}\nSystem prompt: {row[f'prompt.{q}_system_prompt']}"
+                    })
+                    
+                    scenario_list.append(s)
+
+        sl = ScenarioList(set(scenario_list))
+
+        q1 = QuestionFreeText(
+            question_name = "issues",
+            question_text = """
+            The following prompts generated a bad or null response: '{{ original_prompts }}'
+            What do you think was the likely issue(s)?
+            """
+        )
+
+        q2 = QuestionDict(
+            question_name = "revised",
+            question_text = """
+            The following prompts generated a bad or null response: '{{ original_prompts }}'
+            You identified the issue(s) as '{{ issues.answer }}'.
+            Please revise the prompts to address the issue(s).
+            """,
+            answer_keys = ["revised_user_prompt", "revised_system_prompt"]
+        )
+
+        survey = Survey(questions = [q1, q2])
+
+        if models is not None:
+            if not isinstance(models, ModelList):
+                raise ResultsError("models must be a ModelList")
+            results = survey.by(sl).by(models).run()
+        else:
+            results = survey.by(sl).run() # use the default model
+
+        return results
+
+
 def main():  # pragma: no cover
     """Call the OpenAI API credits."""
     from edsl.results.Results import Results

edsl/scenarios/FileStore.py

@@ -11,6 +11,10 @@ from edsl.utilities.remove_edsl_version import remove_edsl_version
 from edsl.scenarios.file_methods import FileMethods
 from typing import Union
 from uuid import UUID
+import time
+from typing import Dict, Any, IO, Optional, List, Union, Literal
+
+
 
 class FileStore(Scenario):
     __documentation__ = "https://docs.expectedparrot.com/en/latest/filestore.html"
@@ -30,7 +34,7 @@ class FileStore(Scenario):
             path = kwargs["filename"]
 
         # Check if path is a URL and handle download
-        if path and (path.startswith('http://') or path.startswith('https://')):
+        if path and (path.startswith("http://") or path.startswith("https://")):
             temp_filestore = self.from_url(path, mime_type=mime_type)
             path = temp_filestore._path
             mime_type = temp_filestore.mime_type
@@ -91,6 +95,102 @@ class FileStore(Scenario):
         else:
             print(f"Example for {example_type} is not supported.")
 
+    @classmethod
+    async def _async_screenshot(
+        cls,
+        url: str,
+        full_page: bool = True,
+        wait_until: Literal[
+            "load", "domcontentloaded", "networkidle", "commit"
+        ] = "networkidle",
+        download_path: Optional[str] = None,
+    ) -> "FileStore":
+        """Async version of screenshot functionality"""
+        try:
+            from playwright.async_api import async_playwright
+        except ImportError:
+            raise ImportError(
+                "Screenshot functionality requires additional dependencies.\n"
+                "Install them with: pip install 'edsl[screenshot]'"
+            )
+
+        if download_path is None:
+            download_path = os.path.join(
+                os.getcwd(), f"screenshot_{int(time.time())}.png"
+            )
+
+        async with async_playwright() as p:
+            browser = await p.chromium.launch()
+            page = await browser.new_page()
+            await page.goto(url, wait_until=wait_until)
+            await page.screenshot(path=download_path, full_page=full_page)
+            await browser.close()
+
+        return cls(download_path, mime_type="image/png")
+
+    @classmethod
+    def from_url_screenshot(cls, url: str, **kwargs) -> "FileStore":
+        """Synchronous wrapper for screenshot functionality"""
+        import asyncio
+
+        try:
+            # Try using get_event_loop first (works in regular Python)
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            # If we're in IPython/Jupyter, create a new loop
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        try:
+            return loop.run_until_complete(cls._async_screenshot(url, **kwargs))
+        finally:
+            if not loop.is_running():
+                loop.close()
+
+    @classmethod
+    def batch_screenshots(cls, urls: List[str], **kwargs) -> "ScenarioList":
+        """
+        Take screenshots of multiple URLs concurrently.
+        Args:
+            urls: List of URLs to screenshot
+            **kwargs: Additional arguments passed to screenshot function (full_page, wait_until, etc.)
+        Returns:
+            ScenarioList containing FileStore objects with their corresponding URLs
+        """
+        from edsl import ScenarioList
+
+        try:
+            # Try using get_event_loop first (works in regular Python)
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            # If we're in IPython/Jupyter, create a new loop
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        # Create tasks for all screenshots
+        tasks = [cls._async_screenshot(url, **kwargs) for url in urls]
+
+        try:
+            # Run all screenshots concurrently
+            results = loop.run_until_complete(
+                asyncio.gather(*tasks, return_exceptions=True)
+            )
+
+            # Filter out any errors and log them
+            successful_results = []
+            for url, result in zip(urls, results):
+                if isinstance(result, Exception):
+                    print(f"Failed to screenshot {url}: {result}")
+                else:
+                    successful_results.append(
+                        Scenario({"url": url, "screenshot": result})
+                    )
+
+            return ScenarioList(successful_results)
+        finally:
+            if not loop.is_running():
+                loop.close()
+
     @property
     def size(self) -> int:
         if self.base64_string != None:
@@ -273,12 +373,11 @@ class FileStore(Scenario):
         # raise TypeError("No text method found for this file type.")
 
     def push(
-        self, 
-        description: Optional[str] = None, 
+        self,
+        description: Optional[str] = None,
         alias: Optional[str] = None,
         visibility: Optional[str] = "unlisted",
         expected_parrot_url: Optional[str] = None,
-
     ) -> dict:
         """
         Push the object to Coop.
@@ -286,20 +385,26 @@ class FileStore(Scenario):
         :param visibility: The visibility of the object to push.
         """
         scenario_version = Scenario.from_dict(self.to_dict())
+
         if description is None:
             description = "File: " + self.path
-        info = scenario_version.push(description=description, visibility=visibility, expected_parrot_url=expected_parrot_url, alias=alias)
+        info = scenario_version.push(
+            description=description,
+            visibility=visibility,
+            expected_parrot_url=expected_parrot_url,
+            alias=alias,
+        )
         return info
 
     @classmethod
     def pull(cls, url_or_uuid: Union[str, UUID]) -> "FileStore":
         """
         Pull a FileStore object from Coop.
-        
+
         Args:
             url_or_uuid: Either a UUID string or a URL pointing to the object
             expected_parrot_url: Optional URL for the Parrot server
-        
+
         Returns:
             FileStore: The pulled FileStore object
         """

edsl/scenarios/ScenarioList.py

@@ -1156,6 +1156,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         
         return scenario_list
 
+    @classmethod
     def from_wikipedia(cls, url: str, table_index: int = 0):
         """
         Extracts a table from a Wikipedia page.
@@ -1672,6 +1673,135 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         
         return ScenarioList(result)
 
+    def create_comparisons(
+        self, 
+        bidirectional: bool = False, 
+        num_options: int = 2,
+        option_prefix: str = "option_",
+        use_alphabet: bool = False
+    ) -> ScenarioList:
+        """Create a new ScenarioList with comparisons between scenarios.
+        
+        Each scenario in the result contains multiple original scenarios as dictionaries,
+        allowing for side-by-side comparison.
+        
+        Args:
+            bidirectional (bool): If True, include both (A,B) and (B,A) comparisons.
+                If False, only include (A,B) where A comes before B in the original list.
+            num_options (int): Number of scenarios to include in each comparison.
+                Default is 2 for pairwise comparisons.
+            option_prefix (str): Prefix for the keys in the resulting scenarios.
+                Default is "option_", resulting in keys like "option_1", "option_2", etc.
+                Ignored if use_alphabet is True.
+            use_alphabet (bool): If True, use letters as keys (A, B, C, etc.) instead of
+                the option_prefix with numbers.
+        
+        Returns:
+            ScenarioList: A new ScenarioList where each scenario contains multiple original
+                scenarios as dictionaries.
+        
+        Example:
+            >>> s = ScenarioList([
+            ...     Scenario({'id': 1, 'text': 'Option A'}),
+            ...     Scenario({'id': 2, 'text': 'Option B'}),
+            ...     Scenario({'id': 3, 'text': 'Option C'})
+            ... ])
+            >>> s.create_comparisons(use_alphabet=True)
+            ScenarioList([Scenario({'A': {'id': 1, 'text': 'Option A'}, 'B': {'id': 2, 'text': 'Option B'}}), Scenario({'A': {'id': 1, 'text': 'Option A'}, 'B': {'id': 3, 'text': 'Option C'}}), Scenario({'A': {'id': 2, 'text': 'Option B'}, 'B': {'id': 3, 'text': 'Option C'}})])
+            >>> s.create_comparisons(num_options=3, use_alphabet=True)
+            ScenarioList([Scenario({'A': {'id': 1, 'text': 'Option A'}, 'B': {'id': 2, 'text': 'Option B'}, 'C': {'id': 3, 'text': 'Option C'}})])
+        """
+        from itertools import combinations, permutations
+        import string
+        
+        if num_options < 2:
+            raise ValueError("num_options must be at least 2")
+        
+        if num_options > len(self):
+            raise ValueError(f"num_options ({num_options}) cannot exceed the number of scenarios ({len(self)})")
+        
+        if use_alphabet and num_options > 26:
+            raise ValueError("When using alphabet labels, num_options cannot exceed 26 (the number of letters in the English alphabet)")
+        
+        # Convert each scenario to a dictionary
+        scenario_dicts = [scenario.to_dict(add_edsl_version=False) for scenario in self]
+        
+        # Generate combinations or permutations based on bidirectional flag
+        if bidirectional:
+            # For bidirectional, use permutations to get all ordered arrangements
+            if num_options == 2:
+                # For pairwise, we can use permutations with r=2
+                scenario_groups = permutations(scenario_dicts, 2)
+            else:
+                # For more than 2 options with bidirectional=True, 
+                # we need all permutations of the specified size
+                scenario_groups = permutations(scenario_dicts, num_options)
+        else:
+            # For unidirectional, use combinations to get unordered groups
+            scenario_groups = combinations(scenario_dicts, num_options)
+        
+        # Create new scenarios with the combinations
+        result = []
+        for group in scenario_groups:
+            new_scenario = {}
+            for i, scenario_dict in enumerate(group):
+                if use_alphabet:
+                    # Use uppercase letters (A, B, C, etc.)
+                    key = string.ascii_uppercase[i]
+                else:
+                    # Use the option prefix with numbers (option_1, option_2, etc.)
+                    key = f"{option_prefix}{i+1}"
+                new_scenario[key] = scenario_dict
+            result.append(Scenario(new_scenario))
+        
+        return ScenarioList(result)
+
+    @classmethod
+    def from_parquet(cls, filepath: str) -> ScenarioList:
+        """Create a ScenarioList from a Parquet file.
+        
+        Args:
+            filepath (str): Path to the Parquet file
+            
+        Returns:
+            ScenarioList: A ScenarioList containing the data from the Parquet file
+            
+        Example:
+        >>> import pandas as pd
+        >>> import tempfile
+        >>> df = pd.DataFrame({'name': ['Alice', 'Bob'], 'age': [30, 25]})
+        >>> # The following would create and read a parquet file if dependencies are installed:
+        >>> # with tempfile.NamedTemporaryFile(suffix='.parquet', delete=False) as f:
+        >>> #     df.to_parquet(f.name)
+        >>> #     scenario_list = ScenarioList.from_parquet(f.name)
+        >>> # Instead, we'll demonstrate the equivalent result:
+        >>> scenario_list = ScenarioList.from_pandas(df)
+        >>> len(scenario_list)
+        2
+        >>> scenario_list[0]['name']
+        'Alice'
+        """
+        import pandas as pd
+        
+        try:
+            # Try to read the Parquet file with pandas
+            df = pd.read_parquet(filepath)
+        except ImportError as e:
+            # Handle missing dependencies with a helpful error message
+            if "pyarrow" in str(e) or "fastparquet" in str(e):
+                raise ImportError(
+                    "Missing dependencies for Parquet support. Please install either pyarrow or fastparquet:\n"
+                    "  pip install pyarrow\n"
+                    "  or\n"
+                    "  pip install fastparquet"
+                ) from e
+            else:
+                raise
+        
+        # Convert the DataFrame to a ScenarioList
+        return cls.from_pandas(df)
+
+
 
 if __name__ == "__main__":
     import doctest

edsl/study/Study.py

@@ -504,12 +504,12 @@ class Study:
             )
 
     @classmethod
-    def pull(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def pull(cls, url_or_uuid: Union[str, UUID]):
         """Pull the object from coop."""
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.get(uuid, url, "study")
+        return coop.get(url_or_uuid, "study")
 
     def __repr__(self):
         return f"""Study(name = "{self.name}", description = "{self.description}", objects = {self.objects}, cache = {self.cache}, filename = "{self.filename}", coop = {self.coop}, use_study_cache = {self.use_study_cache}, overwrite_on_change = {self.overwrite_on_change})"""

edsl/surveys/Survey.py

@@ -172,6 +172,13 @@ class Survey(SurveyExportMixin, Base):
 
         self._seed = None
 
+        # Cache the InstructionCollection
+        self._cached_instruction_collection = None
+
+    def question_names_valid(self) -> bool:
+        """Check if the question names are valid."""
+        return all(q.is_valid_question_name() for q in self.questions)
+
     def draw(self) -> "Survey":
         """Return a new survey with a randomly selected permutation of the options."""
         if self._seed is None:  # only set once
@@ -205,28 +212,16 @@ class Survey(SurveyExportMixin, Base):
     # region: Survey instruction handling
     @property
     def _relevant_instructions_dict(self) -> InstructionCollection:
-        """Return a dictionary with keys as question names and values as instructions that are relevant to the question.
-
-        >>> s = Survey.example(include_instructions=True)
-        >>> s._relevant_instructions_dict
-        {'q0': [Instruction(name="attention", text="Please pay attention!")], 'q1': [Instruction(name="attention", text="Please pay attention!")], 'q2': [Instruction(name="attention", text="Please pay attention!")]}
-
-        """
-        return InstructionCollection(
-            self._instruction_names_to_instructions, self.questions
-        )
+        """Return a dictionary with keys as question names and values as instructions that are relevant to the question."""
+        if self._cached_instruction_collection is None:
+            self._cached_instruction_collection = InstructionCollection(
+                self._instruction_names_to_instructions, self.questions
+            )
+        return self._cached_instruction_collection
 
     def _relevant_instructions(self, question: QuestionBase) -> dict:
-        """This should be a dictionry with keys as question names and values as instructions that are relevant to the question.
-
-        :param question: The question to get the relevant instructions for.
-
-        # Did the instruction come before the question and was it not modified by a change instruction?
-
-        """
-        return InstructionCollection(
-            self._instruction_names_to_instructions, self.questions
-        )[question]
+        """Return instructions that are relevant to the question."""
+        return self._relevant_instructions_dict[question]
 
     def show_flow(self, filename: Optional[str] = None) -> None:
         """Show the flow of the survey."""