edsl 0.1.42__py3-none-any.whl → 0.1.43__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.42"
+__version__ = "0.1.43"

edsl/agents/Invigilator.py

@@ -156,7 +156,7 @@ class InvigilatorAI(InvigilatorBase):
                         self.question.question_options = new_question_options
 
                 question_with_validators = self.question.render(
-                    self.scenario | prior_answers_dict
+                    self.scenario | prior_answers_dict | {'agent':self.agent.traits}
                 )
                 question_with_validators.use_code = self.question.use_code
             else:

edsl/agents/PromptConstructor.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING
+from typing import Dict, Any, Optional, Set, Union, TYPE_CHECKING, Literal
 from functools import cached_property
+from multiprocessing import Pool, freeze_support, get_context
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+import time
+import logging
 
 from edsl.prompts.Prompt import Prompt
 
@@ -22,6 +26,7 @@ if TYPE_CHECKING:
     from edsl.questions.QuestionBase import QuestionBase
     from edsl.scenarios.Scenario import Scenario
 
+logger = logging.getLogger(__name__)
 
 class BasePlaceholder:
     """Base class for placeholder values when a question is not yet answered."""
@@ -242,31 +247,97 @@ class PromptConstructor:
             question_name, self.current_answers
         )
 
-    def get_prompts(self) -> Dict[str, Prompt]:
-        """Get both prompts for the LLM call.
-
-        >>> from edsl import QuestionFreeText
-        >>> from edsl.agents.InvigilatorBase import InvigilatorBase
-        >>> q = QuestionFreeText(question_text="How are you today?", question_name="q_new")
-        >>> i = InvigilatorBase.example(question = q)
-        >>> i.get_prompts()
-        {'user_prompt': ..., 'system_prompt': ...}
-        """
-        prompts = self.prompt_plan.get_prompts(
-            agent_instructions=self.agent_instructions_prompt,
-            agent_persona=self.agent_persona_prompt,
-            question_instructions=Prompt(self.question_instructions_prompt),
-            prior_question_memory=self.prior_question_memory_prompt,
-        )
-        if self.question_file_keys:
+    def get_prompts(self, parallel: Literal["thread", "process", None] = None) -> Dict[str, Any]:
+        """Get the prompts for the question."""
+        start = time.time()
+        
+        # Build all the components
+        instr_start = time.time()
+        agent_instructions = self.agent_instructions_prompt
+        instr_end = time.time()
+        logger.debug(f"Time taken for agent instructions: {instr_end - instr_start:.4f}s")
+        
+        persona_start = time.time()
+        agent_persona = self.agent_persona_prompt
+        persona_end = time.time()
+        logger.debug(f"Time taken for agent persona: {persona_end - persona_start:.4f}s")
+        
+        q_instr_start = time.time()
+        question_instructions = self.question_instructions_prompt
+        q_instr_end = time.time()
+        logger.debug(f"Time taken for question instructions: {q_instr_end - q_instr_start:.4f}s")
+        
+        memory_start = time.time()
+        prior_question_memory = self.prior_question_memory_prompt
+        memory_end = time.time()
+        logger.debug(f"Time taken for prior question memory: {memory_end - memory_start:.4f}s")
+
+        # Get components dict
+        components = {
+            "agent_instructions": agent_instructions.text,
+            "agent_persona": agent_persona.text,
+            "question_instructions": question_instructions.text,
+            "prior_question_memory": prior_question_memory.text,
+        }
+
+        # Use PromptPlan's get_prompts method
+        plan_start = time.time()
+        
+        # Get arranged components first
+        arranged = self.prompt_plan.arrange_components(**components)
+        
+        if parallel == "process":
+            ctx = get_context('fork')
+            with ctx.Pool() as pool:
+                results = pool.map(_process_prompt, [
+                    (arranged["user_prompt"], {}),
+                    (arranged["system_prompt"], {})
+                ])
+                prompts = {
+                    "user_prompt": results[0],
+                    "system_prompt": results[1]
+                }
+            
+        elif parallel == "thread":
+            with ThreadPoolExecutor() as executor:
+                user_prompt_list = arranged["user_prompt"]
+                system_prompt_list = arranged["system_prompt"]
+                
+                # Process both prompt lists in parallel
+                rendered_user = executor.submit(_process_prompt, (user_prompt_list, {}))
+                rendered_system = executor.submit(_process_prompt, (system_prompt_list, {}))
+                
+                prompts = {
+                    "user_prompt": rendered_user.result(),
+                    "system_prompt": rendered_system.result()
+                }
+                
+        else:  # sequential processing
+            prompts = self.prompt_plan.get_prompts(**components)
+
+        plan_end = time.time()
+        logger.debug(f"Time taken for prompt processing: {plan_end - plan_start:.4f}s")
+        
+        # Handle file keys if present
+        if hasattr(self, 'question_file_keys') and self.question_file_keys:
+            files_start = time.time()
             files_list = []
             for key in self.question_file_keys:
                 files_list.append(self.scenario[key])
             prompts["files_list"] = files_list
+            files_end = time.time()
+            logger.debug(f"Time taken for file key processing: {files_end - files_start:.4f}s")
+        
+        end = time.time()
+        logger.debug(f"Total time in get_prompts: {end - start:.4f}s")
         return prompts
 
 
-if __name__ == "__main__":
-    import doctest
+def _process_prompt(args):
+    """Helper function to process a single prompt list with its replacements."""
+    prompt_list, replacements = args
+    return prompt_list.reduce()
+
 
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+if __name__ == '__main__':
+    freeze_support()

edsl/agents/QuestionInstructionPromptBuilder.py

@@ -1,5 +1,6 @@
 from typing import Dict, List, Set
 from warnings import warn
+import logging
 from edsl.prompts.Prompt import Prompt
 
 from edsl.agents.QuestionTemplateReplacementsBuilder import (
@@ -23,12 +24,44 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Prompt: The fully rendered question instructions
         """
+        import time
+        
+        start = time.time()
+        
+        # Create base prompt
+        base_start = time.time()
         base_prompt = self._create_base_prompt()
+        base_end = time.time()
+        logging.debug(f"Time for base prompt: {base_end - base_start}")
+        
+        # Enrich with options
+        enrich_start = time.time()
         enriched_prompt = self._enrich_with_question_options(base_prompt)
+        enrich_end = time.time()
+        logging.debug(f"Time for enriching with options: {enrich_end - enrich_start}")
+        
+        # Render prompt
+        render_start = time.time()
         rendered_prompt = self._render_prompt(enriched_prompt)
+        render_end = time.time()
+        logging.debug(f"Time for rendering prompt: {render_end - render_start}")
+        
+        # Validate template variables
+        validate_start = time.time()
         self._validate_template_variables(rendered_prompt)
-
-        return self._append_survey_instructions(rendered_prompt)
+        validate_end = time.time()
+        logging.debug(f"Time for template validation: {validate_end - validate_start}")
+        
+        # Append survey instructions
+        append_start = time.time()
+        final_prompt = self._append_survey_instructions(rendered_prompt)
+        append_end = time.time()
+        logging.debug(f"Time for appending survey instructions: {append_end - append_start}")
+        
+        end = time.time()
+        logging.debug(f"Total time in build_question_instructions: {end - start}")
+        
+        return final_prompt
 
     def _create_base_prompt(self) -> Dict:
         """Creates the initial prompt with basic question data.
@@ -50,14 +83,25 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Dict: Enriched prompt data
         """
+        import time
+        
+        start = time.time()
+        
         if "question_options" in prompt_data["data"]:
             from edsl.agents.question_option_processor import QuestionOptionProcessor
-
+            
+            processor_start = time.time()
             question_options = QuestionOptionProcessor(
                 self.prompt_constructor
             ).get_question_options(question_data=prompt_data["data"])
-
+            processor_end = time.time()
+            logging.debug(f"Time to process question options: {processor_end - processor_start}")
+            
             prompt_data["data"]["question_options"] = question_options
+            
+        end = time.time()
+        logging.debug(f"Total time in _enrich_with_question_options: {end - start}")
+        
         return prompt_data
 
     def _render_prompt(self, prompt_data: Dict) -> Prompt:
@@ -69,11 +113,28 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Prompt: Rendered instructions
         """
-
+        import time
+        
+        start = time.time()
+        
+        # Build replacement dict
+        dict_start = time.time()
         replacement_dict = QTRB(self.prompt_constructor).build_replacement_dict(
             prompt_data["data"]
         )
-        return prompt_data["prompt"].render(replacement_dict)
+        dict_end = time.time()
+        logging.debug(f"Time to build replacement dict: {dict_end - dict_start}")
+        
+        # Render with dict
+        render_start = time.time()
+        result = prompt_data["prompt"].render(replacement_dict)
+        render_end = time.time()
+        logging.debug(f"Time to render with dict: {render_end - render_start}")
+        
+        end = time.time()
+        logging.debug(f"Total time in _render_prompt: {end - start}")
+        
+        return result
 
     def _validate_template_variables(self, rendered_prompt: Prompt) -> None:
         """Validates that all template variables have been properly replaced.
@@ -101,9 +162,7 @@ class QuestionInstructionPromptBuilder:
         """
         for question_name in self.survey.question_names:
             if question_name in undefined_vars:
-                print(
-                    f"Question name found in undefined_template_variables: {question_name}"
-                )
+                logging.warning(f"Question name found in undefined_template_variables: {question_name}")
 
     def _append_survey_instructions(self, rendered_prompt: Prompt) -> Prompt:
         """Appends any relevant survey instructions to the rendered prompt.

edsl/agents/prompt_helpers.py

@@ -124,6 +124,6 @@ class PromptPlan:
         """Get both prompts for the LLM call."""
         prompts = self.arrange_components(**kwargs)
         return {
-            "user_prompt": prompts["user_prompt"].reduce(),
-            "system_prompt": prompts["system_prompt"].reduce(),
+            "user_prompt": Prompt("".join(str(p) for p in prompts["user_prompt"])),
+            "system_prompt": Prompt("".join(str(p) for p in prompts["system_prompt"])),
         }

edsl/coop/coop.py

@@ -14,7 +14,11 @@ from edsl.data.CacheEntry import CacheEntry
 from edsl.jobs.Jobs import Jobs
 from edsl.surveys.Survey import Survey
 
-from edsl.exceptions.coop import CoopNoUUIDError, CoopServerResponseError
+from edsl.exceptions.coop import (
+    CoopInvalidURLError,
+    CoopNoUUIDError,
+    CoopServerResponseError,
+)
 from edsl.coop.utils import (
     EDSLObject,
     ObjectRegistry,
@@ -285,17 +289,46 @@ class Coop(CoopFunctionsMixin):
         if value is None:
             return "null"
 
-    def _resolve_uuid(
+    def _resolve_uuid_or_alias(
         self, uuid: Union[str, UUID] = None, url: str = None
-    ) -> Union[str, UUID]:
+    ) -> tuple[Optional[str], Optional[str], Optional[str]]:
         """
-        Resolve the uuid from a uuid or a url.
+        Resolve the uuid or alias information from a uuid or a url.
+        Returns a tuple of (uuid, owner_username, alias)
+        - For content/<uuid> URLs: returns (uuid, None, None)
+        - For content/<username>/<alias> URLs: returns (None, username, alias)
         """
         if not url and not uuid:
             raise CoopNoUUIDError("No uuid or url provided for the object.")
+
         if not uuid and url:
-            uuid = url.split("/")[-1]
-        return uuid
+            parts = (
+                url.replace("http://", "")
+                .replace("https://", "")
+                .rstrip("/")
+                .split("/")
+            )
+
+            # Remove domain
+            parts = parts[1:]
+
+            if len(parts) < 2 or parts[0] != "content":
+                raise CoopInvalidURLError(
+                    f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
+                )
+
+            if len(parts) == 2:
+                obj_uuid = parts[1]
+                return obj_uuid, None, None
+            elif len(parts) == 3:
+                username, alias = parts[1], parts[2]
+                return None, username, alias
+            else:
+                raise CoopInvalidURLError(
+                    f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
+                )
+
+        return str(uuid), None, None
 
     @property
     def edsl_settings(self) -> dict:
@@ -361,22 +394,31 @@ class Coop(CoopFunctionsMixin):
         expected_object_type: Optional[ObjectType] = None,
     ) -> EDSLObject:
         """
-        Retrieve an EDSL object by its uuid or its url.
+        Retrieve an EDSL object by its uuid/url or by owner username and alias.
         - If the object's visibility is private, the user must be the owner.
         - Optionally, check if the retrieved object is of a certain type.
 
         :param uuid: the uuid of the object either in str or UUID format.
-        :param url: the url of the object.
+        :param url: the url of the object (can be content/uuid or content/username/alias format).
         :param expected_object_type: the expected type of the object.
 
         :return: the object instance.
         """
-        uuid = self._resolve_uuid(uuid, url)
-        response = self._send_server_request(
-            uri=f"api/v0/object",
-            method="GET",
-            params={"uuid": uuid},
-        )
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(uuid, url)
+
+        if obj_uuid:
+            response = self._send_server_request(
+                uri=f"api/v0/object",
+                method="GET",
+                params={"uuid": obj_uuid},
+            )
+        else:
+            response = self._send_server_request(
+                uri=f"api/v0/object/alias",
+                method="GET",
+                params={"owner_username": owner_username, "alias": alias},
+            )
+
         self._resolve_server_response(response)
         json_string = response.json().get("json_string")
         object_type = response.json().get("object_type")
@@ -414,12 +456,13 @@ class Coop(CoopFunctionsMixin):
         """
         Delete an object from the server.
         """
-        uuid = self._resolve_uuid(uuid, url)
+        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="DELETE",
-            params={"uuid": uuid},
+            params={"uuid": obj_uuid},
         )
+
         self._resolve_server_response(response)
         return response.json()
 
@@ -438,11 +481,11 @@ class Coop(CoopFunctionsMixin):
         """
         if description is None and visibility is None and value is None:
             raise Exception("Nothing to patch.")
-        uuid = self._resolve_uuid(uuid, url)
+        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
         response = self._send_server_request(
             uri=f"api/v0/object",
             method="PATCH",
-            params={"uuid": uuid},
+            params={"uuid": obj_uuid},
             payload={
                 "description": description,
                 "alias": alias,
@@ -549,6 +592,7 @@ class Coop(CoopFunctionsMixin):
     def remote_cache_get(
         self,
         exclude_keys: Optional[list[str]] = None,
+        select_keys: Optional[list[str]] = None,
     ) -> list[CacheEntry]:
         """
         Get all remote cache entries.
@@ -560,10 +604,12 @@ class Coop(CoopFunctionsMixin):
         """
         if exclude_keys is None:
             exclude_keys = []
+        if select_keys is None:
+            select_keys = []
         response = self._send_server_request(
             uri="api/v0/remote-cache/get-many",
             method="POST",
-            payload={"keys": exclude_keys},
+            payload={"keys": exclude_keys, "selected_keys": select_keys},
             timeout=40,
         )
         self._resolve_server_response(response)

edsl/enums.py

@@ -97,7 +97,6 @@ available_models_urls = {
 
 
 service_to_api_keyname = {
-    InferenceServiceType.BEDROCK.value: "TBD",
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",
     InferenceServiceType.REPLICATE.value: "TBD",
     InferenceServiceType.OPENAI.value: "OPENAI_API_KEY",
@@ -109,7 +108,7 @@ service_to_api_keyname = {
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
     InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
-    InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY",
+    InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY"
 }
 
 

edsl/exceptions/coop.py

@@ -2,6 +2,10 @@ class CoopErrors(Exception):
     pass
 
 
+class CoopInvalidURLError(CoopErrors):
+    pass
+
+
 class CoopNoUUIDError(CoopErrors):
     pass
 

edsl/inference_services/AvailableModelFetcher.py

@@ -136,7 +136,10 @@ class AvailableModelFetcher:
         if not service_models:
             import warnings
 
-            warnings.warn(f"No models found for service {service_name}")
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")  # Ignores the warning
+                warnings.warn(f"No models found for service {service_name}")
+
             return [], service_name
 
         models_list = AvailableModels(

edsl/jobs/Jobs.py

@@ -38,6 +38,7 @@ if TYPE_CHECKING:
     from edsl.language_models.ModelList import ModelList
     from edsl.data.Cache import Cache
     from edsl.language_models.key_management.KeyLookup import KeyLookup
+    from edsl.jobs.JobsRemoteInferenceHandler import JobsRemoteInferenceHandler
 
 VisibilityType = Literal["private", "public", "unlisted"]
 
@@ -407,7 +408,13 @@ class Jobs(Base):
         >>> bc
         BucketCollection(...)
         """
-        return BucketCollection.from_models(self.models)
+        bc = BucketCollection.from_models(self.models)
+        
+        if self.run_config.environment.key_lookup is not None:
+            bc.update_from_key_lookup(
+                self.run_config.environment.key_lookup
+            )
+        return bc
 
     def html(self):
         """Return the HTML representations for each scenario"""
@@ -465,22 +472,47 @@ class Jobs(Base):
 
         return False
 
+    def _start_remote_inference_job(
+        self, job_handler: Optional[JobsRemoteInferenceHandler] = None
+    ) -> Union["Results", None]:
+
+        if job_handler is None:
+            job_handler = self._create_remote_inference_handler()
+            
+        job_info = job_handler.create_remote_inference_job(
+                iterations=self.run_config.parameters.n,
+                remote_inference_description=self.run_config.parameters.remote_inference_description,
+                remote_inference_results_visibility=self.run_config.parameters.remote_inference_results_visibility,
+        )
+        return job_info
+    
+    def _create_remote_inference_handler(self) -> JobsRemoteInferenceHandler:
+
+        from edsl.jobs.JobsRemoteInferenceHandler import JobsRemoteInferenceHandler
+        
+        return JobsRemoteInferenceHandler(
+            self, verbose=self.run_config.parameters.verbose
+        )
+        
     def _remote_results(
         self,
+        config: RunConfig,
     ) -> Union["Results", None]:
         from edsl.jobs.JobsRemoteInferenceHandler import JobsRemoteInferenceHandler
+        from edsl.jobs.JobsRemoteInferenceHandler import RemoteJobInfo
 
-        jh = JobsRemoteInferenceHandler(
-            self, verbose=self.run_config.parameters.verbose
-        )
+        background = config.parameters.background
+
+        jh = self._create_remote_inference_handler()
         if jh.use_remote_inference(self.run_config.parameters.disable_remote_inference):
-            job_info = jh.create_remote_inference_job(
-                iterations=self.run_config.parameters.n,
-                remote_inference_description=self.run_config.parameters.remote_inference_description,
-                remote_inference_results_visibility=self.run_config.parameters.remote_inference_results_visibility,
-            )
-            results = jh.poll_remote_inference_job(job_info)
-            return results
+            job_info: RemoteJobInfo = self._start_remote_inference_job(jh)
+            if background:
+                from edsl.results.Results import Results 
+                results = Results.from_job_info(job_info)
+                return results
+            else:
+                results = jh.poll_remote_inference_job(job_info)
+                return results
         else:
             return None
 
@@ -507,13 +539,6 @@ 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)
@@ -521,19 +546,6 @@ class Jobs(Base):
             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()
-
-    #     # first try to run the job remotely
-    #     results = self._remote_results()
-    #     #breakpoint()
-    #     if results is not None:
-    #         return results
-
-    #     self._check_if_local_keys_ok()
-    #     return None
-
     @property
     def num_interviews(self):
         if self.run_config.parameters.n is None:
@@ -563,7 +575,6 @@ class Jobs(Base):
 
         self.replace_missing_objects()
 
-        # try to run remotely first
         self._prepare_to_run()
         self._check_if_remote_keys_ok()
 
@@ -581,9 +592,9 @@ class Jobs(Base):
             self.run_config.environment.cache = Cache(immediate_write=False)
 
         # first try to run the job remotely
-        if results := self._remote_results():
+        if (results := self._remote_results(config)) is not None:
             return results
-                
+        
         self._check_if_local_keys_ok()
 
         if config.environment.bucket_collection is None:
@@ -591,6 +602,14 @@ class Jobs(Base):
                 self.create_bucket_collection()
             )
 
+        if (
+            self.run_config.environment.key_lookup is not None
+            and self.run_config.environment.bucket_collection is not None
+        ):
+            self.run_config.environment.bucket_collection.update_from_key_lookup(
+                self.run_config.environment.key_lookup
+            )
+
         return None
 
     @with_config
@@ -613,7 +632,7 @@ class Jobs(Base):
         :param key_lookup: A KeyLookup object to manage API keys
         """
         potentially_completed_results = self._run(config)
-        
+
         if potentially_completed_results is not None:
             return potentially_completed_results