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

edsl/Base.py

@@ -64,17 +64,26 @@ class PersistenceMixin:
     @classmethod
     def pull(
         cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
-        expected_parrot_url: Optional[str] = None,
+        url_or_uuid: Optional[Union[str, UUID]] = None,
+        #expected_parrot_url: Optional[str] = None,
     ):
-        """Pull the object from coop."""
+        """Pull the 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
+        """
         from edsl.coop import Coop
         from edsl.coop.utils import ObjectRegistry
 
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
-        coop = Coop(url=expected_parrot_url)
-        return coop.get(uuid, url, object_type)
+        coop = Coop()
+
+        # Determine if input is URL or UUID
+        if url_or_uuid and ("http://" in str(url_or_uuid) or "https://" in str(url_or_uuid)):
+            return coop.get(url=url_or_uuid, expected_object_type=object_type)
+        else:
+            return coop.get(uuid=url_or_uuid, expected_object_type=object_type)
 
     @classmethod
     def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):

edsl/__version__.py

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

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

@@ -4,17 +4,19 @@ import requests
 
 from typing import Any, Optional, Union, Literal, TypedDict
 from uuid import UUID
-from collections import UserDict, defaultdict
 
 import edsl
-from pathlib import Path
 
 from edsl.config import CONFIG
 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 +287,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:
@@ -307,7 +338,7 @@ class Coop(CoopFunctionsMixin):
 
         try:
             response = self._send_server_request(
-                uri="api/v0/edsl-settings", method="GET", timeout=5
+                uri="api/v0/edsl-settings", method="GET", timeout=20
             )
             self._resolve_server_response(response, check_api_key=False)
             return response.json()
@@ -361,22 +392,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 +454,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 +479,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 +590,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 +602,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)
@@ -820,6 +864,40 @@ class Coop(CoopFunctionsMixin):
             "usd": response_json.get("cost_in_usd"),
         }
 
+    ################
+    # PROJECTS
+    ################
+    def create_project(
+        self,
+        survey: Survey,
+        project_name: str,
+        survey_description: Optional[str] = None,
+        survey_alias: Optional[str] = None,
+        survey_visibility: Optional[VisibilityType] = "unlisted",
+    ):
+        """
+        Create a survey object on Coop, then create a project from the survey.
+        """
+        survey_details = self.create(
+            object=survey,
+            description=survey_description,
+            alias=survey_alias,
+            visibility=survey_visibility,
+        )
+        survey_uuid = survey_details.get("uuid")
+        response = self._send_server_request(
+            uri=f"api/v0/projects/create-from-survey",
+            method="POST",
+            payload={"project_name": project_name, "survey_uuid": str(survey_uuid)},
+        )
+        self._resolve_server_response(response)
+        response_json = response.json()
+        return {
+            "name": response_json.get("project_name"),
+            "uuid": response_json.get("uuid"),
+            "url": f"{self.url}/home/projects/{response_json.get('uuid')}",
+        }
+
     ################
     # DUNDER METHODS
     ################

edsl/enums.py

@@ -67,6 +67,7 @@ class InferenceServiceType(EnumWithChecks):
     TOGETHER = "together"
     PERPLEXITY = "perplexity"
     DEEPSEEK = "deepseek"
+    GROK = "grok"
 
 
 # unavoidable violation of the DRY principle but it is necessary
@@ -86,6 +87,7 @@ InferenceServiceLiteral = Literal[
     "together",
     "perplexity",
     "deepseek",
+    "grok",
 ]
 
 available_models_urls = {
@@ -97,7 +99,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",
@@ -110,6 +111,7 @@ service_to_api_keyname = {
     InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
     InferenceServiceType.PERPLEXITY.value: "PERPLEXITY_API_KEY",
     InferenceServiceType.DEEPSEEK.value: "DEEPSEEK_API_KEY",
+    InferenceServiceType.GROK.value: "XAI_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/AnthropicService.py

@@ -17,6 +17,8 @@ class AnthropicService(InferenceServiceABC):
     output_token_name = "output_tokens"
     model_exclude_list = []
 
+    available_models_url = 'https://docs.anthropic.com/en/docs/about-claude/models'
+
     @classmethod
     def get_model_list(cls, api_key: str = None):
 

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/inference_services/GoogleService.py

@@ -39,6 +39,8 @@ class GoogleService(InferenceServiceABC):
 
     model_exclude_list = []
 
+    available_models_url = 'https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models'
+
     @classmethod
     def get_model_list(cls):
         model_list = []

edsl/inference_services/GrokService.py

@@ -0,0 +1,11 @@
+from typing import Any, List
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class GrokService(OpenAIService):
+    """Openai service class."""
+
+    _inference_service_ = "grok"
+    _env_key_name_ = "XAI_API_KEY"
+    _base_url_ = "https://api.x.ai/v1"
+    _models_list_cache: List[str] = []

edsl/inference_services/InferenceServiceABC.py

@@ -23,6 +23,7 @@ class InferenceServiceABC(ABC):
             "usage_sequence",
             "input_token_name",
             "output_token_name",
+            #"available_models_url",
         ]
         for attr in must_have_attributes:
             if not hasattr(cls, attr):

edsl/inference_services/OpenAIService.py

@@ -84,6 +84,7 @@ class OpenAIService(InferenceServiceABC):
 
     @classmethod
     def get_model_list(cls, api_key=None):
+        # breakpoint()
         if api_key is None:
             api_key = os.getenv(cls._env_key_name_)
         raw_list = cls.sync_client(api_key).models.list()

edsl/inference_services/TestService.py

@@ -28,6 +28,7 @@ class TestService(InferenceServiceABC):
     model_exclude_list = []
     input_token_name = "prompt_tokens"
     output_token_name = "completion_tokens"
+    available_models_url = None
 
     @classmethod
     def available(cls) -> list[str]:

edsl/inference_services/registry.py

@@ -14,6 +14,7 @@ from edsl.inference_services.TestService import TestService
 from edsl.inference_services.TogetherAIService import TogetherAIService
 from edsl.inference_services.PerplexityService import PerplexityService
 from edsl.inference_services.DeepSeekService import DeepSeekService
+from edsl.inference_services.GrokService import GrokService
 
 try:
     from edsl.inference_services.MistralAIService import MistralAIService
@@ -35,6 +36,7 @@ services = [
     TogetherAIService,
     PerplexityService,
     DeepSeekService,
+    GrokService,
 ]
 
 if mistral_available: