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

edsl/scenarios/FileStore.py

@@ -327,38 +327,6 @@ class FileStore(Scenario):
 
         return ConstructDownloadLink(self).create_link(custom_filename, style)
 
-    def to_pandas(self):
-        """
-        Convert the file content to a pandas DataFrame if supported by the file handler.
-
-        Returns:
-            pandas.DataFrame: The data from the file as a DataFrame
-
-        Raises:
-            AttributeError: If the file type's handler doesn't support pandas conversion
-        """
-        handler = FileMethods.get_handler(self.suffix)
-        if handler and hasattr(handler, "to_pandas"):
-            return handler(self.path).to_pandas()
-        raise AttributeError(
-            f"Converting {self.suffix} files to pandas DataFrame is not supported"
-        )
-
-    def __getattr__(self, name):
-        """
-        Delegate pandas DataFrame methods to the underlying DataFrame if this is a CSV file
-        """
-        if self.suffix == "csv":
-            # Get the pandas DataFrame
-            df = self.to_pandas()
-            # Check if the requested attribute exists in the DataFrame
-            if hasattr(df, name):
-                return getattr(df, name)
-        # If not a CSV or attribute doesn't exist in DataFrame, raise AttributeError
-        raise AttributeError(
-            f"'{self.__class__.__name__}' object has no attribute '{name}'"
-        )
-
 
 class CSVFileStore(FileStore):
     @classmethod

edsl/scenarios/ScenarioList.py

@@ -45,7 +45,7 @@ from edsl.utilities.naming_utilities import sanitize_string
 from edsl.utilities.is_valid_variable_name import is_valid_variable_name
 from edsl.exceptions.scenarios import ScenarioError
 
-from edsl.scenarios.directory_scanner import DirectoryScanner
+from edsl.scenarios.DirectoryScanner import DirectoryScanner
 
 
 class ScenarioListMixin(ScenarioListPdfMixin, ScenarioListExportMixin):
@@ -661,7 +661,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> s.select('a')
         ScenarioList([Scenario({'a': 1}), Scenario({'a': 1})])
         """
-        from edsl.scenarios.scenario_selector import ScenarioSelector
+        from edsl.scenarios.ScenarioSelector import ScenarioSelector
 
         return ScenarioSelector(self).select(*fields)
 
@@ -840,25 +840,10 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
         """
         sl = self.duplicate()
-        if len(values) != len(sl):
-            raise ScenarioError(
-                f"Length of values ({len(values)}) does not match length of ScenarioList ({len(sl)})"
-            )
         for i, value in enumerate(values):
             sl[i][name] = value
         return sl
 
-    @classmethod
-    def create_empty_scenario_list(cls, n: int) -> ScenarioList:
-        """Create an empty ScenarioList with n scenarios.
-
-        Example:
-
-        >>> ScenarioList.create_empty_scenario_list(3)
-        ScenarioList([Scenario({}), Scenario({}), Scenario({})])
-        """
-        return ScenarioList([Scenario({}) for _ in range(n)])
-
     def add_value(self, name: str, value: Any) -> ScenarioList:
         """Add a value to all scenarios in a ScenarioList.
 
@@ -1237,7 +1222,7 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         >>> s3 == ScenarioList([Scenario({'age': 30, 'location': 'New York', 'name': 'Alice'}), Scenario({'age': 25, 'location': None, 'name': 'Bob'})])
         True
         """
-        from edsl.scenarios.scenario_join import ScenarioJoin
+        from edsl.scenarios.ScenarioJoin import ScenarioJoin
 
         sj = ScenarioJoin(self, other)
         return sj.left_join(by)
@@ -1259,7 +1244,6 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
         else:
             data = self
         d = {"scenarios": [s.to_dict(add_edsl_version=add_edsl_version) for s in data]}
-
         if add_edsl_version:
             from edsl import __version__
 
@@ -1312,22 +1296,10 @@ class ScenarioList(Base, UserList, ScenarioListMixin):
 
     @classmethod
     def from_nested_dict(cls, data: dict) -> ScenarioList:
-        """Create a `ScenarioList` from a nested dictionary.
-
-        >>> data = {"headline": ["Armistice Signed, War Over: Celebrations Erupt Across City"], "date": ["1918-11-11"], "author": ["Jane Smith"]}
-        >>> ScenarioList.from_nested_dict(data)
-        ScenarioList([Scenario({'headline': 'Armistice Signed, War Over: Celebrations Erupt Across City', 'date': '1918-11-11', 'author': 'Jane Smith'})])
-
-        """
-        length_of_first_list = len(next(iter(data.values())))
-        s = ScenarioList.create_empty_scenario_list(n=length_of_first_list)
-
-        if any(len(v) != length_of_first_list for v in data.values()):
-            raise ValueError(
-                "All lists in the dictionary must be of the same length.",
-            )
-        for key, list_of_values in data.items():
-            s = s.add_list(key, list_of_values)
+        """Create a `ScenarioList` from a nested dictionary."""
+        s = ScenarioList()
+        for key, value in data.items():
+            s.add_list(key, value)
         return s
 
     def code(self) -> str:

edsl/scenarios/handlers/csv.py

@@ -36,14 +36,3 @@ class CsvMethods(FileMethods):
         with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as f:
             df.to_csv(f.name, index=False)
         return f.name
-
-    def to_pandas(self):
-        """
-        Convert the CSV file to a pandas DataFrame.
-
-        Returns:
-            pandas.DataFrame: The data from the CSV as a DataFrame
-        """
-        import pandas as pd
-
-        return pd.read_csv(self.path)

edsl/surveys/Survey.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 import re
-import random
 
 from typing import (
     Any,
@@ -116,7 +115,6 @@ class Survey(SurveyExportMixin, Base):
         rule_collection: Optional["RuleCollection"] = None,
         question_groups: Optional["QuestionGroupType"] = None,
         name: Optional[str] = None,
-        questions_to_randomize: Optional[List[str]] = None,
     ):
         """Create a new survey.
 
@@ -165,33 +163,6 @@ class Survey(SurveyExportMixin, Base):
 
             warnings.warn("name parameter to a survey is deprecated.")
 
-        if questions_to_randomize is not None:
-            self.questions_to_randomize = questions_to_randomize
-        else:
-            self.questions_to_randomize = []
-
-        self._seed = None
-
-    def draw(self) -> "Survey":
-        """Return a new survey with a randomly selected permutation of the options."""
-        if self._seed is None:  # only set once
-            self._seed = hash(self)
-            random.seed(self._seed)
-
-        if len(self.questions_to_randomize) == 0:
-            return self
-
-        new_questions = []
-        for question in self.questions:
-            if question.question_name in self.questions_to_randomize:
-                new_questions.append(question.draw())
-            else:
-                new_questions.append(question.duplicate())
-
-        d = self.to_dict()
-        d["questions"] = [q.to_dict() for q in new_questions]
-        return Survey.from_dict(d)
-
     def _process_raw_questions(self, questions: Optional[List["QuestionType"]]) -> list:
         """Process the raw questions passed to the survey."""
         handler = InstructionHandler(self)
@@ -345,9 +316,7 @@ class Survey(SurveyExportMixin, Base):
         >>> s.to_dict(add_edsl_version = False).keys()
         dict_keys(['questions', 'memory_plan', 'rule_collection', 'question_groups'])
         """
-        from edsl import __version__
-
-        d = {
+        return {
             "questions": [
                 q.to_dict(add_edsl_version=add_edsl_version)
                 for q in self._recombined_questions_and_instructions()
@@ -358,13 +327,6 @@ class Survey(SurveyExportMixin, Base):
             ),
             "question_groups": self.question_groups,
         }
-        if self.questions_to_randomize != []:
-            d["questions_to_randomize"] = self.questions_to_randomize
-
-        if add_edsl_version:
-            d["edsl_version"] = __version__
-            d["edsl_class_name"] = "Survey"
-        return d
 
     @classmethod
     @remove_edsl_version
@@ -408,16 +370,11 @@ class Survey(SurveyExportMixin, Base):
             get_class(q_dict).from_dict(q_dict) for q_dict in data["questions"]
         ]
         memory_plan = MemoryPlan.from_dict(data["memory_plan"])
-        if "questions_to_randomize" in data:
-            questions_to_randomize = data["questions_to_randomize"]
-        else:
-            questions_to_randomize = None
         survey = cls(
             questions=questions,
             memory_plan=memory_plan,
             rule_collection=RuleCollection.from_dict(data["rule_collection"]),
             question_groups=data["question_groups"],
-            questions_to_randomize=questions_to_randomize,
         )
         return survey
 
@@ -913,7 +870,6 @@ class Survey(SurveyExportMixin, Base):
         agent: Optional["Agent"] = None,
         cache: Optional["Cache"] = None,
         disable_remote_inference: bool = False,
-        disable_remote_cache: bool = False,
         **kwargs,
     ):
         """Run the survey with default model, taking the required survey as arguments.
@@ -923,7 +879,7 @@ class Survey(SurveyExportMixin, Base):
         >>> def f(scenario, agent_traits): return "yes" if scenario["period"] == "morning" else "no"
         >>> q = QuestionFunctional(question_name = "q0", func = f)
         >>> s = Survey([q])
-        >>> async def test_run_async(): result = await s.run_async(period="morning", disable_remote_inference = True, disable_remote_cache=True); print(result.select("answer.q0").first())
+        >>> async def test_run_async(): result = await s.run_async(period="morning", disable_remote_inference = True); print(result.select("answer.q0").first())
         >>> asyncio.run(test_run_async())
         yes
         >>> import asyncio
@@ -931,23 +887,20 @@ class Survey(SurveyExportMixin, Base):
         >>> def f(scenario, agent_traits): return "yes" if scenario["period"] == "morning" else "no"
         >>> q = QuestionFunctional(question_name = "q0", func = f)
         >>> s = Survey([q])
-        >>> async def test_run_async(): result = await s.run_async(period="evening", disable_remote_inference = True, disable_remote_cache = True); print(result.select("answer.q0").first())
-        >>> results = asyncio.run(test_run_async())
+        >>> async def test_run_async(): result = await s.run_async(period="evening", disable_remote_inference = True); print(result.select("answer.q0").first())
+        >>> asyncio.run(test_run_async())
         no
         """
         # TODO: temp fix by creating a cache
         if cache is None:
             from edsl.data import Cache
+
             c = Cache()
         else:
             c = cache
-
-        
-
-        jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs).using(c)
+        jobs: "Jobs" = self.get_job(model=model, agent=agent, **kwargs)
         return await jobs.run_async(
-            disable_remote_inference=disable_remote_inference,
-            disable_remote_cache=disable_remote_cache,
+            cache=c, disable_remote_inference=disable_remote_inference
         )
 
     def run(self, *args, **kwargs) -> "Results":
@@ -965,12 +918,6 @@ class Survey(SurveyExportMixin, Base):
 
         return Jobs(survey=self).run(*args, **kwargs)
 
-    def using(self, obj: Union["Cache", "KeyLookup", "BucketCollection"]) -> "Jobs":
-        """Turn the survey into a Job and appends the arguments to the Job."""
-        from edsl.jobs.Jobs import Jobs
-
-        return Jobs(survey=self).using(obj)
-
     def duplicate(self):
         """Duplicate the survey.
 
@@ -1139,7 +1086,7 @@ class Survey(SurveyExportMixin, Base):
         # questions_string = ", ".join([repr(q) for q in self._questions])
         questions_string = ", ".join([repr(q) for q in self.raw_passed_questions or []])
         # question_names_string = ", ".join([repr(name) for name in self.question_names])
-        return f"Survey(questions=[{questions_string}], memory_plan={self.memory_plan}, rule_collection={self.rule_collection}, question_groups={self.question_groups}, questions_to_randomize={self.questions_to_randomize})"
+        return f"Survey(questions=[{questions_string}], memory_plan={self.memory_plan}, rule_collection={self.rule_collection}, question_groups={self.question_groups})"
 
     def _summary(self) -> dict:
         return {
@@ -1225,7 +1172,7 @@ class Survey(SurveyExportMixin, Base):
 
     def get_job(self, model=None, agent=None, **kwargs):
         if model is None:
-            from edsl.language_models.model import Model
+            from edsl.language_models.registry import Model
 
             model = Model()
 
@@ -1246,24 +1193,26 @@ def main():
 
     def example_survey():
         """Return an example survey."""
-        from edsl import QuestionMultipleChoice, QuestionList, QuestionNumerical, Survey
+        from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
+        from edsl.surveys.Survey import Survey
 
         q0 = QuestionMultipleChoice(
+            question_text="Do you like school?",
+            question_options=["yes", "no"],
             question_name="q0",
-            question_text="What is the capital of France?",
-            question_options=["London", "Paris", "Rome", "Boston", "I don't know"]
         )
-        q1 = QuestionList(
+        q1 = QuestionMultipleChoice(
+            question_text="Why not?",
+            question_options=["killer bees in cafeteria", "other"],
             question_name="q1",
-            question_text="Name some cities in France.",
-            max_list_items = 5
         )
-        q2 = QuestionNumerical(
+        q2 = QuestionMultipleChoice(
+            question_text="Why?",
+            question_options=["**lack*** of killer bees in cafeteria", "other"],
             question_name="q2",
-            question_text="What is the population of {{ q0.answer }}?"
         )
         s = Survey(questions=[q0, q1, q2])
-        s = s.add_rule(q0, "q0 == 'Paris'", q2)
+        s = s.add_rule(q0, "q0 == 'yes'", q2)
         return s
 
     s = example_survey()

{edsl-0.1.39.dist-info → edsl-0.1.39.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.39
+Version: 0.1.39.dev2
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT