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

edsl/__init__.py

@@ -21,7 +21,6 @@ from edsl.questions import QuestionFunctional
 from edsl.questions import QuestionLikertFive
 from edsl.questions import QuestionList
 from edsl.questions import QuestionMatrix
-from edsl.questions import QuestionDict
 from edsl.questions import QuestionLinearScale
 from edsl.questions import QuestionNumerical
 from edsl.questions import QuestionYesNo

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.40"
+__version__ = "0.1.40.dev2"

edsl/agents/Agent.py

@@ -906,7 +906,7 @@ class Agent(Base):
         {'traits': {'age': 10, 'hair': 'brown', 'height': 5.5}, 'instruction': 'Have fun.', 'edsl_version': '...', 'edsl_class_name': 'Agent'}
         """
         d = {}
-        d["traits"] = copy.deepcopy(dict(self._traits))
+        d["traits"] = copy.deepcopy(self.traits)
         if self.name:
             d["name"] = self.name
         if self.set_instructions:

edsl/agents/Invigilator.py

@@ -48,14 +48,13 @@ class InvigilatorAI(InvigilatorBase):
         """Store the response in the invigilator, in case it is needed later because of validation failure."""
         self.raw_model_response = agent_response_dict.model_outputs.response
         self.generated_tokens = agent_response_dict.edsl_dict.generated_tokens
-        self.cache_key = agent_response_dict.model_outputs.cache_key
 
-    async def async_answer_question(self) -> EDSLResultObjectInput:
+    async def async_answer_question(self) -> AgentResponseDict:
         """Answer a question using the AI model.
 
         >>> i = InvigilatorAI.example()
         """
-        agent_response_dict: AgentResponseDict = await self.async_get_agent_response()
+        agent_response_dict = await self.async_get_agent_response()
         self.store_response(agent_response_dict)
         return self._extract_edsl_result_entry_and_validate(agent_response_dict)
 

edsl/coop/coop.py

@@ -111,13 +111,13 @@ class Coop(CoopFunctionsMixin):
         url = f"{self.api_url}/{uri}"
         method = method.upper()
         if payload is None:
-            timeout = 40
+            timeout = 20
         elif (
             method.upper() == "POST"
             and "json_string" in payload
             and payload.get("json_string") is not None
         ):
-            timeout = max(40, (len(payload.get("json_string", "")) // (1024 * 1024)))
+            timeout = max(20, (len(payload.get("json_string", "")) // (1024 * 1024)))
         try:
             if method in ["GET", "DELETE"]:
                 response = requests.request(
@@ -533,7 +533,6 @@ class Coop(CoopFunctionsMixin):
             uri="api/v0/remote-cache/many",
             method="POST",
             payload=payload,
-            timeout=40,
         )
         self._resolve_server_response(response)
         response_json = response.json()
@@ -564,7 +563,6 @@ class Coop(CoopFunctionsMixin):
             uri="api/v0/remote-cache/get-many",
             method="POST",
             payload={"keys": exclude_keys},
-            timeout=40,
         )
         self._resolve_server_response(response)
         return [
@@ -583,7 +581,6 @@ class Coop(CoopFunctionsMixin):
             uri="api/v0/remote-cache/get-diff",
             method="POST",
             payload={"keys": client_cacheentry_keys},
-            timeout=40,
         )
         self._resolve_server_response(response)
         response_json = response.json()

edsl/data/Cache.py

@@ -535,13 +535,6 @@ class Cache(Base):
         """
         return html
 
-    def subset(self, keys: list[str]) -> Cache:
-        """
-        Return a subset of the Cache with the specified keys.
-        """
-        new_data = {k: v for k, v in self.data.items() if k in keys}
-        return Cache(data=new_data)
-
     def view(self) -> None:
         """View the Cache in a new browser tab."""
         import tempfile

edsl/data/RemoteCacheSync.py

@@ -112,18 +112,18 @@ class RemoteCacheSync(AbstractContextManager):
         missing_count = len(diff.client_missing_entries)
 
         if missing_count == 0:
-        #     self._output("No new entries to add to local cache.")
+            self._output("No new entries to add to local cache.")
             return
 
-        # self._output(
-        #     f"Updating local cache with {missing_count:,} new "
-        #     f"{'entry' if missing_count == 1 else 'entries'} from remote..."
-        # )
+        self._output(
+            f"Updating local cache with {missing_count:,} new "
+            f"{'entry' if missing_count == 1 else 'entries'} from remote..."
+        )
 
         self.cache.add_from_dict(
             {entry.key: entry for entry in diff.client_missing_entries}
         )
-        # self._output("Local cache updated!")
+        self._output("Local cache updated!")
 
     def _get_entries_to_upload(self, diff: CacheDifference) -> CacheEntriesList:
         """Determines which entries need to be uploaded to remote cache."""
@@ -154,23 +154,23 @@ class RemoteCacheSync(AbstractContextManager):
         upload_count = len(entries_to_upload)
 
         if upload_count > 0:
-            # self._output(
-            #     f"Updating remote cache with {upload_count:,} new "
-            #     f"{'entry' if upload_count == 1 else 'entries'}..."
-            # )
+            self._output(
+                f"Updating remote cache with {upload_count:,} new "
+                f"{'entry' if upload_count == 1 else 'entries'}..."
+            )
 
             self.coop.remote_cache_create_many(
                 entries_to_upload,
                 visibility="private",
                 description=self.remote_cache_description,
             )
-            # self._output("Remote cache updated!")
-        # else:
-            # self._output("No new entries to add to remote cache.")
+            self._output("Remote cache updated!")
+        else:
+            self._output("No new entries to add to remote cache.")
 
-        # self._output(
-            # f"There are {len(self.cache.keys()):,} entries in the local cache."
-        # )
+        self._output(
+            f"There are {len(self.cache.keys()):,} entries in the local cache."
+        )
 
 
 if __name__ == "__main__":

edsl/jobs/AnswerQuestionFunctionConstructor.py

@@ -139,7 +139,7 @@ class AnswerQuestionFunctionConstructor:
         *,
         question: "QuestionBase",
         task=None,
-    ) -> "EDSLResultObjectInput":
+    ) -> "AgentResponseDict":
 
         from tenacity import (
             retry,

edsl/jobs/Jobs.py

@@ -499,6 +499,7 @@ class Jobs(Base):
             jc.check_api_keys()
 
     async def _execute_with_remote_cache(self, run_job_async: bool) -> Results:
+
         use_remote_cache = self.use_remote_cache()
 
         from edsl.coop.coop import Coop
@@ -507,21 +508,22 @@ class Jobs(Base):
 
         assert isinstance(self.run_config.environment.cache, Cache)
 
-        # with RemoteCacheSync(
-        #     coop=Coop(),
-        #     cache=self.run_config.environment.cache,
-        #     output_func=self._output,
-        #     remote_cache=use_remote_cache,
-        #     remote_cache_description=self.run_config.parameters.remote_cache_description,
-        # ):
-        runner = JobsRunnerAsyncio(self, environment=self.run_config.environment)
-        if run_job_async:
-            results = await runner.run_async(self.run_config.parameters)
-        else:
-            results = runner.run(self.run_config.parameters)
+        with RemoteCacheSync(
+            coop=Coop(),
+            cache=self.run_config.environment.cache,
+            output_func=self._output,
+            remote_cache=use_remote_cache,
+            remote_cache_description=self.run_config.parameters.remote_cache_description,
+        ):
+            runner = JobsRunnerAsyncio(self, environment=self.run_config.environment)
+            if run_job_async:
+                results = await runner.run_async(self.run_config.parameters)
+            else:
+                results = runner.run(self.run_config.parameters)
         return results
 
     def _setup_and_check(self) -> Tuple[RunConfig, Optional[Results]]:
+
         self._prepare_to_run()
         self._check_if_remote_keys_ok()
 
@@ -537,16 +539,12 @@ class Jobs(Base):
         if self.run_config.parameters.n is None:
             return len(self)
         else:
-            return len(self) * self.run_config.parameters.n
+            len(self) * self.run_config.parameters.n
 
     def _run(self, config: RunConfig):
         "Shared code for run and run_async"
         if config.environment.cache is not None:
             self.run_config.environment.cache = config.environment.cache
-        if config.environment.jobs_runner_status is not None:
-            self.run_config.environment.jobs_runner_status = (
-                config.environment.jobs_runner_status
-            )
 
         if config.environment.bucket_collection is not None:
             self.run_config.environment.bucket_collection = (
@@ -648,19 +646,20 @@ class Jobs(Base):
         }
 
     def __len__(self) -> int:
-        """Return the number of interviews that will be conducted for one iteration of this job.
-        An interview is the result of one survey, taken by one agent, with one model, with one scenario.
+        """Return the maximum number of questions that will be asked while running this job.
+        Note that this is the maximum number of questions, not the actual number of questions that will be asked, as some questions may be skipped.
 
         >>> from edsl.jobs import Jobs
         >>> len(Jobs.example())
-        4
+        8
         """
-        number_of_interviews = (
+        number_of_questions = (
             len(self.agents or [1])
             * len(self.scenarios or [1])
             * len(self.models or [1])
+            * len(self.survey)
         )
-        return number_of_interviews
+        return number_of_questions
 
     def to_dict(self, add_edsl_version=True):
         d = {
@@ -811,9 +810,9 @@ def main():
     from edsl.data.Cache import Cache
 
     job = Jobs.example()
-    len(job) == 4
+    len(job) == 8
     results = job.run(cache=Cache())
-    len(results) == 4
+    len(results) == 8
     results
 
 

edsl/jobs/interviews/Interview.py

@@ -213,6 +213,10 @@ class Interview:
     async def async_conduct_interview(
         self,
         run_config: Optional["RunConfig"] = None,
+        #     model_buckets: Optional[ModelBuckets] = None,
+        #     stop_on_exception: bool = False,
+        #     raise_validation_errors: bool = True,
+        #     key_lookup: Optional[KeyLookup] = None,
     ) -> tuple["Answers", List[dict[str, Any]]]:
         """
         Conduct an Interview asynchronously.
@@ -309,7 +313,7 @@ class Interview:
 
         def handle_task(task, invigilator):
             try:
-                result: Answers = task.result()
+                result = task.result()
             except asyncio.CancelledError as e:  # task was cancelled
                 result = invigilator.get_failed_task_result(
                     failure_reason="Task was cancelled."

edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -44,16 +44,7 @@ class JobsRunnerAsyncio:
             data.append(result)
             task_history.add_interview(interview)
 
-        results = Results(survey=self.jobs.survey, task_history=task_history, data=data)
-
-        relevant_cache = results.relevant_cache(self.environment.cache)
-
-        return Results(
-            survey=self.jobs.survey,
-            task_history=task_history,
-            data=data,
-            cache=relevant_cache,
-        )
+        return Results(survey=self.jobs.survey, task_history=task_history, data=data)
 
     def simple_run(self):
         data = asyncio.run(self.run_async())
@@ -102,16 +93,16 @@ class JobsRunnerAsyncio:
 
             self.completed = True
 
-        def run_progress_bar(stop_event, jobs_runner_status) -> None:
+        def run_progress_bar(stop_event) -> None:
             """Runs the progress bar in a separate thread."""
-            jobs_runner_status.update_progress(stop_event)
+            self.jobs_runner_status.update_progress(stop_event)
 
         def set_up_progress_bar(progress_bar: bool, jobs_runner_status):
             progress_thread = None
             if progress_bar and jobs_runner_status.has_ep_api_key():
                 jobs_runner_status.setup()
                 progress_thread = threading.Thread(
-                    target=run_progress_bar, args=(stop_event, jobs_runner_status)
+                    target=run_progress_bar, args=(stop_event,)
                 )
                 progress_thread.start()
             elif progress_bar:
@@ -124,9 +115,8 @@ class JobsRunnerAsyncio:
             survey=self.jobs.survey,
             data=[],
             task_history=TaskHistory(),
-            #           cache=self.environment.cache.new_entries_cache(),
+            cache=self.environment.cache.new_entries_cache(),
         )
-
         stop_event = threading.Event()
         progress_thread = set_up_progress_bar(
             parameters.progress_bar, run_config.environment.jobs_runner_status
@@ -150,9 +140,7 @@ class JobsRunnerAsyncio:
             if exception_to_raise:
                 raise exception_to_raise
 
-            relevant_cache = results.relevant_cache(self.environment.cache)
-            results.cache = relevant_cache
-            # breakpoint()
+            results.cache = self.environment.cache.new_entries_cache()
             results.bucket_collection = self.environment.bucket_collection
 
             from edsl.jobs.results_exceptions_handler import ResultsExceptionsHandler

edsl/jobs/runners/JobsRunnerStatus.py

@@ -148,8 +148,7 @@ class JobsRunnerStatusBase(ABC):
         }
 
         model_queues = {}
-        # for model, bucket in self.jobs_runner.bucket_collection.items():
-        for model, bucket in self.jobs_runner.environment.bucket_collection.items():
+        for model, bucket in self.jobs_runner.bucket_collection.items():
             model_name = model.model
             model_queues[model_name] = {
                 "language_model_name": model_name,

edsl/questions/QuestionBudget.py

@@ -8,7 +8,7 @@ from edsl.questions.descriptors import IntegerDescriptor, QuestionOptionsDescrip
 from edsl.questions.response_validator_abc import ResponseValidatorABC
 
 
-class BudgetResponseValidator(ResponseValidatorABC):
+class BudgewResponseValidator(ResponseValidatorABC):
     valid_examples = []
 
     invalid_examples = []
@@ -64,7 +64,7 @@ class QuestionBudget(QuestionBase):
     budget_sum: int = IntegerDescriptor(none_allowed=False)
     question_options: list[str] = QuestionOptionsDescriptor(q_budget=True)
     _response_model = None
-    response_validator_class = BudgetResponseValidator
+    response_validator_class = BudgewResponseValidator
 
     def __init__(
         self,

edsl/questions/QuestionExtract.py

@@ -50,7 +50,7 @@ def extract_json(text, expected_keys, verbose=False):
 
 def dict_to_pydantic_model(input_dict: Dict[str, Any]) -> Any:
     field_definitions = {
-        key: (type(value), Field(default=value)) for key, value in input_dict.items()
+        key: (str, Field(default=str(value))) for key, value in input_dict.items()
     }
 
     DynamicModel = create_model("DynamicModel", **field_definitions)

edsl/questions/__init__.py

@@ -12,7 +12,6 @@ from edsl.questions.QuestionFreeText import QuestionFreeText
 from edsl.questions.QuestionFunctional import QuestionFunctional
 from edsl.questions.QuestionList import QuestionList
 from edsl.questions.QuestionMatrix import QuestionMatrix
-from edsl.questions.QuestionDict import QuestionDict
 from edsl.questions.QuestionMultipleChoice import QuestionMultipleChoice
 from edsl.questions.QuestionNumerical import QuestionNumerical
 from edsl.questions.QuestionBudget import QuestionBudget

edsl/questions/answer_validator_mixin.py

@@ -324,35 +324,6 @@ class AnswerValidatorMixin:
                     f"Must be one of: {valid_options}"
                 )
 
-    def _validate_answer_dict(self, answer: dict[str, Any]) -> None:
-        """Validate QuestionDict-specific answer.
-
-        Check that answer["answer"]:
-        - is a dictionary
-        - has all required answer_keys as keys
-        """
-        value = answer.get("answer")
-
-        # Check that answer is a dictionary
-        if not isinstance(value, dict):
-            raise QuestionAnswerValidationError(
-                f"Dict answer must be a dictionary mapping values to specified keys (got {value})"
-            )
-
-        # Check that all required answer keys are present
-        required_keys = set(self.answer_keys)
-        provided_keys = set(value.keys())
-
-        if missing_keys := (required_keys - provided_keys):
-            raise QuestionAnswerValidationError(
-                f"Missing required keys: {missing_keys}"
-            )
-
-        if extra_keys := (provided_keys - required_keys):
-            raise QuestionAnswerValidationError(
-                f"Unexpected keys: {extra_keys}"
-            )
-
 
 if __name__ == "__main__":
     pass

edsl/questions/derived/QuestionLinearScale.py

@@ -36,7 +36,7 @@ class QuestionLinearScale(QuestionMultipleChoice):
             question_name=question_name,
             question_text=question_text,
             question_options=question_options,
-            use_code=False,  # question linear scale will have its own code
+            use_code=False,  # question linear scale will have it's own code
             include_comment=include_comment,
         )
         self.question_options = question_options

edsl/questions/descriptors.py

@@ -421,50 +421,6 @@ class QuestionTextDescriptor(BaseDescriptor):
         return None
 
 
-class ValueTypesDescriptor(BaseDescriptor):
-    def validate(self, value, instance):
-        """Validate the value is a list of strings or None."""
-        if value is None:  # Allow None as a valid value
-            return None
-        if not isinstance(value, list):
-            raise QuestionCreationValidationError(
-                f"`value_types` must be a list or None (got {value})."
-            )
-        # Convert all items in the list to strings
-        return [str(item) for item in value]
-
-
-class ValueDescriptionsDescriptor(BaseDescriptor):
-    def validate(self, value, instance):
-        """Validate the value is a list of strings or None."""
-        if value is None:  # Allow None as a valid value
-            return None
-        if not isinstance(value, list):
-            raise QuestionCreationValidationError(
-                f"`value_descriptions` must be a list or None (got {value})."
-            )
-        if not all(isinstance(x, str) for x in value):
-            raise QuestionCreationValidationError(
-                f"`value_descriptions` must be a list of strings (got {value})."
-            )
-        return value
-
-
-class AnswerKeysDescriptor(BaseDescriptor):
-    """Validate that the `answer_keys` attribute is a list of strings or integers."""
-
-    def validate(self, value, instance):
-        """Validate the value is a list of strings or integers."""
-        if not isinstance(value, list):
-            raise QuestionCreationValidationError(
-                f"`answer_keys` must be a list (got {value})."
-            )
-        if not all(isinstance(x, (str, int)) for x in value):
-            raise QuestionCreationValidationError(
-                f"`answer_keys` must be a list of strings or integers (got {value})."
-            )
-
-
 if __name__ == "__main__":
     import doctest
 

edsl/questions/question_registry.py

@@ -96,7 +96,7 @@ class Question(metaclass=Meta):
 
         >>> from edsl import Question
         >>> Question.list_question_types()
-        ['checkbox', 'dict', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'matrix', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
+        ['checkbox', 'extract', 'free_text', 'functional', 'likert_five', 'linear_scale', 'list', 'matrix', 'multiple_choice', 'numerical', 'rank', 'top_k', 'yes_no']
         """
         return [
             q

edsl/results/Result.py

@@ -56,7 +56,6 @@ class Result(Base, UserDict):
         comments_dict: Optional[dict] = None,
         cache_used_dict: Optional[dict[QuestionName, bool]] = None,
         indices: Optional[dict] = None,
-        cache_keys: Optional[dict[QuestionName, str]] = None,
     ):
         """Initialize a Result object.
 
@@ -91,7 +90,6 @@ class Result(Base, UserDict):
             "generated_tokens": generated_tokens or {},
             "comments_dict": comments_dict or {},
             "cache_used_dict": cache_used_dict or {},
-            "cache_keys": cache_keys or {},
         }
         super().__init__(**data)
         self.indices = indices
@@ -165,7 +163,6 @@ class Result(Base, UserDict):
 
     def _construct_sub_dicts(self) -> dict[str, dict]:
         """Construct a dictionary of sub-dictionaries for the Result object."""
-
         sub_dicts_needing_new_keys = {
             "question_text": {},
             "question_options": {},
@@ -184,8 +181,6 @@ class Result(Base, UserDict):
             f"{k}_cache_used": v for k, v in self.data["cache_used_dict"].items()
         }
 
-        cache_keys = {f"{k}_cache_key": v for k, v in self.data["cache_keys"].items()}
-
         d = {
             **self._create_agent_sub_dict(self.data["agent"]),
             **self._create_model_sub_dict(self.data["model"]),
@@ -200,13 +195,11 @@ class Result(Base, UserDict):
             "question_options": sub_dicts_needing_new_keys["question_options"],
             "question_type": sub_dicts_needing_new_keys["question_type"],
             "cache_used": new_cache_dict,
-            "cache_keys": cache_keys,
         }
         if hasattr(self, "indices") and self.indices is not None:
             d["agent"].update({"agent_index": self.indices["agent"]})
             d["scenario"].update({"scenario_index": self.indices["scenario"]})
             d["model"].update({"model_index": self.indices["model"]})
-
         return d
 
     @property
@@ -413,7 +406,6 @@ class Result(Base, UserDict):
             generated_tokens=json_dict.get("generated_tokens", {}),
             comments_dict=json_dict.get("comments_dict", {}),
             cache_used_dict=json_dict.get("cache_used_dict", {}),
-            cache_keys=json_dict.get("cache_keys", {}),
         )
         return result
 
@@ -467,12 +459,6 @@ class Result(Base, UserDict):
                 question_results[result.question_name] = result
             return question_results
 
-        def get_cache_keys(model_response_objects) -> dict[str, bool]:
-            cache_keys = {}
-            for result in model_response_objects:
-                cache_keys[result.question_name] = result.cache_key
-            return cache_keys
-
         def get_generated_tokens_dict(answer_key_names) -> dict[str, str]:
             generated_tokens_dict = {
                 k + "_generated_tokens": question_results[k].generated_tokens
@@ -537,7 +523,6 @@ class Result(Base, UserDict):
         generated_tokens_dict = get_generated_tokens_dict(answer_key_names)
         comments_dict = get_comments_dict(answer_key_names)
         answer_dict = {k: extracted_answers[k] for k in answer_key_names}
-        cache_keys = get_cache_keys(model_response_objects)
 
         question_name_to_prompts = get_question_name_to_prompts(model_response_objects)
         prompt_dictionary = get_prompt_dictionary(
@@ -561,7 +546,6 @@ class Result(Base, UserDict):
             comments_dict=comments_dict,
             cache_used_dict=cache_used_dictionary,
             indices=interview.indices,
-            cache_keys=cache_keys,
         )
         result.interview_hash = interview.initial_hash
         return result

edsl/results/Results.py

@@ -90,7 +90,6 @@ class Results(UserList, Mixins, Base):
         "comment",
         "generated_tokens",
         "cache_used",
-        "cache_keys",
     ]
 
     def __init__(
@@ -110,7 +109,6 @@ class Results(UserList, Mixins, Base):
         :param created_columns: A list of strings that are created columns.
         :param job_uuid: A string representing the job UUID.
         :param total_results: An integer representing the total number of results.
-        :cache: A Cache object.
         """
         super().__init__(data)
         from edsl.data.Cache import Cache
@@ -140,16 +138,6 @@ class Results(UserList, Mixins, Base):
         }
         return d
 
-    def _cache_keys(self):
-        cache_keys = []
-        for result in self:
-            cache_keys.extend(list(result["cache_keys"].values()))
-        return cache_keys
-
-    def relevant_cache(self, cache: Cache) -> Cache:
-        cache_keys = self._cache_keys()
-        return cache.subset(cache_keys)
-
     def insert(self, item):
         item_order = getattr(item, "order", None)
         if item_order is not None:
@@ -182,12 +170,12 @@ class Results(UserList, Mixins, Base):
         """
         total_cost = 0
         for result in self:
-            for key in result["raw_model_response"]:
+            for key in result.raw_model_response:
                 if key.endswith("_cost"):
-                    result_cost = result["raw_model_response"][key]
+                    result_cost = result.raw_model_response[key]
 
                     question_name = key.removesuffix("_cost")
-                    cache_used = result["cache_used_dict"][question_name]
+                    cache_used = result.cache_used_dict[question_name]
 
                     if isinstance(result_cost, (int, float)):
                         if include_cached_responses_in_cost:
@@ -361,7 +349,7 @@ class Results(UserList, Mixins, Base):
         self,
         sort: bool = False,
         add_edsl_version: bool = False,
-        include_cache: bool = True,
+        include_cache: bool = False,
         include_task_history: bool = False,
         include_cache_info: bool = True,
     ) -> dict[str, Any]: