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

edsl/Base.py

@@ -65,13 +65,11 @@ class PersistenceMixin:
     def pull(
         cls,
         url_or_uuid: Optional[Union[str, UUID]] = None,
-        #expected_parrot_url: Optional[str] = None,
     ):
         """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
@@ -79,32 +77,27 @@ class PersistenceMixin:
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
         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)
+        return coop.get(url_or_uuid, expected_object_type=object_type)
 
     @classmethod
-    def delete(cls, uuid: Optional[Union[str, UUID]] = None, url: Optional[str] = None):
+    def delete(cls, url_or_uuid: Union[str, UUID]) -> None:
         """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(
+    def patch_cls(
         cls,
-        uuid: Optional[Union[str, UUID]] = None,
-        url: Optional[str] = None,
+        url_or_uuid: Union[str, UUID],
         description: Optional[str] = None,
-        alias: Optional[str] = None,
         value: Optional[Any] = None,
         visibility: Optional[str] = None,
     ):
         """
-        Patch an uploaded objects attributes.
+        Patch an uploaded object's attributes (class method version).
         - `description` changes the description of the object on Coop
         - `value` changes the value of the object on Coop. **has to be an EDSL object**
         - `visibility` changes the visibility of the object on Coop
@@ -112,7 +105,85 @@ class PersistenceMixin:
         from edsl.coop import Coop
 
         coop = Coop()
-        return coop.patch(uuid, url, description, alias, value, visibility)
+
+        return coop.patch(
+            url_or_uuid=url_or_uuid,
+            description=description,
+            value=value,
+            visibility=visibility,
+        )
+
+    class ClassOrInstanceMethod:
+        """Descriptor that allows a method to be called as both a class method and an instance method."""
+
+        def __init__(self, func):
+            self.func = func
+
+        def __get__(self, obj, objtype=None):
+            if obj is None:
+                # Called as a class method
+                def wrapper(*args, **kwargs):
+                    return self.func(objtype, *args, **kwargs)
+
+                return wrapper
+            else:
+                # Called as an instance method
+                def wrapper(*args, **kwargs):
+                    return self.func(obj, *args, **kwargs)
+
+                return wrapper
+
+    @ClassOrInstanceMethod
+    def patch(
+        self_or_cls,
+        url_or_uuid: Union[str, UUID],
+        description: Optional[str] = None,
+        value: Optional[Any] = None,
+        visibility: Optional[str] = None,
+    ):
+        """
+        Patch an uploaded object's attributes.
+
+        When called as a class method:
+        - Requires explicit `value` parameter
+
+        When called as an instance method:
+        - Uses the instance itself as the `value` parameter
+
+        Parameters:
+        - `id_or_url`: ID or URL of the object to patch
+        - `description`: changes the description of the object on Coop
+        - `value`: changes the value of the object on Coop (required for class method)
+        - `visibility`: changes the visibility of the object on Coop
+        """
+
+        # Check if this is being called as a class method
+        if isinstance(self_or_cls, type):
+            # This is a class method call
+            cls = self_or_cls
+            return cls.patch_cls(
+                url_or_uuid=url_or_uuid,
+                description=description,
+                value=value,
+                visibility=visibility,
+            )
+        else:
+            # This is an instance method call
+            instance = self_or_cls
+            cls_type = instance.__class__
+
+            # Use the instance as the value if not explicitly provided
+            if value is None:
+                value = instance
+            else:
+                pass
+
+            return cls_type.patch_cls(
+                url_or_uuid=url_or_uuid,
+                description=description,
+                value=value,
+                visibility=visibility,
+            )
 
     @classmethod
     def search(cls, query):

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.45"
+__version__ = "0.1.47"

edsl/agents/PromptConstructor.py

@@ -1,20 +1,16 @@
 from __future__ import annotations
 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
 
-from dataclasses import dataclass
-
-from .prompt_helpers import PromptPlan
-from .QuestionTemplateReplacementsBuilder import (
+from edsl.agents.prompt_helpers import PromptPlan
+from edsl.agents.QuestionTemplateReplacementsBuilder import (
     QuestionTemplateReplacementsBuilder,
 )
-from .question_option_processor import QuestionOptionProcessor
+from edsl.agents.question_option_processor import QuestionOptionProcessor
 
 if TYPE_CHECKING:
     from edsl.agents.InvigilatorBase import InvigilatorBase
@@ -146,23 +142,29 @@ class PromptConstructor:
         return self.agent.prompt()
 
     def prior_answers_dict(self) -> dict[str, "QuestionBase"]:
-        """This is a dictionary of prior answers, if they exist."""
+        """This is a dictionary of prior answers, if they exist.
+        
+        >>> from edsl.agents.InvigilatorBase import InvigilatorBase
+        >>> i = InvigilatorBase.example()
+        >>> i.prompt_constructor.prior_answers_dict()
+        {'q0': ..., 'q1': ...}
+        """
         return self._add_answers(
             self.survey.question_names_to_questions(), self.current_answers
         )
 
     @staticmethod
-    def _extract_quetion_and_entry_type(key_entry) -> tuple[str, str]:
+    def _extract_question_and_entry_type(key_entry) -> tuple[str, str]:
         """
         Extracts the question name and type for the current answer dictionary key entry.
 
-        >>> PromptConstructor._extract_quetion_and_entry_type("q0")
+        >>> PromptConstructor._extract_question_and_entry_type("q0")
         ('q0', 'answer')
-        >>> PromptConstructor._extract_quetion_and_entry_type("q0_comment")
+        >>> PromptConstructor._extract_question_and_entry_type("q0_comment")
         ('q0', 'comment')
-        >>> PromptConstructor._extract_quetion_and_entry_type("q0_alternate_generated_tokens")
+        >>> PromptConstructor._extract_question_and_entry_type("q0_alternate_generated_tokens")
         ('q0_alternate', 'generated_tokens')
-        >>> PromptConstructor._extract_quetion_and_entry_type("q0_alt_comment")
+        >>> PromptConstructor._extract_question_and_entry_type("q0_alt_comment")
         ('q0_alt', 'comment')
         """
         split_list = key_entry.rsplit("_", maxsplit=1)
@@ -192,7 +194,7 @@ class PromptConstructor:
         d = defaultdict(dict)
         for key, value in current_answers.items():
             question_name, entry_type = (
-                PromptConstructor._extract_quetion_and_entry_type(key)
+                PromptConstructor._extract_question_and_entry_type(key)
             )
             d[question_name][entry_type] = value
         return dict(d)
@@ -273,99 +275,44 @@ class PromptConstructor:
             question_name, self.current_answers
         )
 
-    def get_prompts(self, parallel: Literal["thread", "process", None] = None) -> Dict[str, Any]:
+    def get_prompts(self) -> 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":
-            pass
-            # 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":
-            pass
-            # 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")
+        prompts = self.prompt_plan.get_prompts(**components)
         
         # 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
 
 
-def _process_prompt(args):
-    """Helper function to process a single prompt list with its replacements."""
-    prompt_list, replacements = args
-    return prompt_list.reduce()
+# def _process_prompt(args):
+#     """Helper function to process a single prompt list with its replacements."""
+#     prompt_list, replacements = args
+#     return prompt_list.reduce()
 
 
 if __name__ == '__main__':
-    freeze_support()
+    import doctest
+    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/agents/QuestionInstructionPromptBuilder.py

@@ -1,8 +1,16 @@
-from typing import Dict, List, Set, Any, Union
+from typing import Dict, List, Set, Any, Union, TYPE_CHECKING
 from warnings import warn
 import logging
 from edsl.prompts.Prompt import Prompt
 
+if TYPE_CHECKING:
+    from edsl.agents.PromptConstructor import PromptConstructor
+    from edsl import Model
+    from edsl import Survey
+    from edsl.questions.QuestionBase import QuestionBase
+    from edsl import Scenario
+    from edsl import Agent
+
 from edsl.agents.QuestionTemplateReplacementsBuilder import (
     QuestionTemplateReplacementsBuilder as QTRB,
 )
@@ -13,23 +21,42 @@ class QuestionInstructionPromptBuilder:
 
     @classmethod
     def from_prompt_constructor(cls, prompt_constructor: "PromptConstructor"):
-        
+
         model = prompt_constructor.model
         survey = prompt_constructor.survey
         question = prompt_constructor.question
-        return cls(prompt_constructor, model, survey, question)
+        scenario = prompt_constructor.scenario
+        prior_answers_dict = prompt_constructor.prior_answers_dict()
+        agent = prompt_constructor.agent
+        return cls(
+            prompt_constructor,
+            model,
+            survey,
+            question,
+            scenario,
+            prior_answers_dict,
+            agent,
+        )
+
+    def __init__(
+        self,
+        prompt_constructor: "PromptConstructor",
+        model: "Model",
+        survey: "Survey",
+        question: "QuestionBase",
+        scenario: "Scenario",
+        prior_answers_dict: Dict[str, Any],
+        agent: "Agent",
+    ):
+
+        self.qtrb = QTRB(scenario, question, prior_answers_dict, agent)
 
-    def __init__(self, prompt_constructor: "PromptConstructor", model:"Model", survey:"Survey", question:"QuestionBase"):
-        self.prompt_constructor = prompt_constructor
         self.model = model
         self.survey = survey
         self.question = question
-
-        self.scenario = prompt_constructor.scenario
-        self.prior_answers_dict = prompt_constructor.prior_answers_dict()
-
-        self.qtrb = QTRB.from_prompt_constructor(self.prompt_constructor)
-
+        self.agent = agent
+        self.scenario = scenario
+        self.prior_answers_dict = prior_answers_dict
 
     def build(self) -> Prompt:
         """Builds the complete question instructions prompt with all necessary components.
@@ -78,19 +105,23 @@ class QuestionInstructionPromptBuilder:
         """
         # Create base prompt
         base_prompt = self._create_base_prompt()
-        
+
         # Enrich with options
-        enriched_prompt = self._enrich_with_question_options(prompt_data=base_prompt, scenario=self.scenario, prior_answers_dict=self.prior_answers_dict)
-        
+        enriched_prompt = self._enrich_with_question_options(
+            prompt_data=base_prompt,
+            scenario=self.scenario,
+            prior_answers_dict=self.prior_answers_dict,
+        )
+
         # Render prompt
         rendered_prompt = self._render_prompt(enriched_prompt)
-        
+
         # Validate template variables
         self._validate_template_variables(rendered_prompt)
-        
+
         # Append survey instructions
         final_prompt = self._append_survey_instructions(rendered_prompt)
-        
+
         return final_prompt
 
     def _create_base_prompt(self) -> Dict[str, Union[Prompt, Dict[str, Any]]]:
@@ -111,7 +142,9 @@ class QuestionInstructionPromptBuilder:
         }
 
     @staticmethod
-    def _process_question_options(question_data: Dict, scenario: 'Scenario', prior_answers_dict: Dict) -> Dict:
+    def _process_question_options(
+        question_data: Dict, scenario: "Scenario", prior_answers_dict: Dict
+    ) -> Dict:
         """Processes and replaces question options in the question data if they exist.
 
         The question_options could be intended to be replaced with data from a scenario or prior answers.
@@ -132,16 +165,18 @@ class QuestionInstructionPromptBuilder:
         """
         if "question_options" in question_data:
             from edsl.agents.question_option_processor import QuestionOptionProcessor
-            
-            question_options = (QuestionOptionProcessor(scenario, prior_answers_dict)
-                                .get_question_options(question_data=question_data)
-            )
+
+            question_options = QuestionOptionProcessor(
+                scenario, prior_answers_dict
+            ).get_question_options(question_data=question_data)
             question_data["question_options"] = question_options
-            
+
         return question_data
 
     @staticmethod
-    def _enrich_with_question_options(prompt_data: Dict, scenario: 'Scenario', prior_answers_dict: Dict) -> Dict:
+    def _enrich_with_question_options(
+        prompt_data: Dict, scenario: "Scenario", prior_answers_dict: Dict
+    ) -> Dict:
         """Enriches the prompt data with processed question options if they exist.
 
         Args:
@@ -152,8 +187,10 @@ class QuestionInstructionPromptBuilder:
         Returns:
             Dict: Enriched prompt data
         """
-        prompt_data["data"] = QuestionInstructionPromptBuilder._process_question_options(
-            prompt_data["data"], scenario, prior_answers_dict
+        prompt_data["data"] = (
+            QuestionInstructionPromptBuilder._process_question_options(
+                prompt_data["data"], scenario, prior_answers_dict
+            )
         )
         return prompt_data
 
@@ -167,10 +204,8 @@ class QuestionInstructionPromptBuilder:
             Prompt: Rendered instructions
         """
         # Build replacement dict
-        replacement_dict = self.qtrb.build_replacement_dict(
-            prompt_data["data"]
-        )
-        
+        replacement_dict = self.qtrb.build_replacement_dict(prompt_data["data"])
+
         # Render with dict
         return prompt_data["prompt"].render(replacement_dict)
 
@@ -200,7 +235,9 @@ class QuestionInstructionPromptBuilder:
         """
         for question_name in self.survey.question_names:
             if question_name in undefined_vars:
-                logging.warning(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.
@@ -227,4 +264,5 @@ class QuestionInstructionPromptBuilder:
 
 if __name__ == "__main__":
     import doctest
-    doctest.testmod()
+
+    doctest.testmod()

edsl/agents/QuestionTemplateReplacementsBuilder.py

@@ -125,6 +125,14 @@ class QuestionTemplateReplacementsBuilder:
     def _scenario_replacements(
         self, replacement_string: str = "<see file {key}>"
     ) -> dict[str, Any]:
+        """
+        >>> from edsl import Scenario
+        >>> from edsl import QuestionFreeText; 
+        >>> q = QuestionFreeText(question_text = "How are you {{ scenario.friend }}?", question_name = "test")
+        >>> s = Scenario({'friend':'john'}) 
+        >>> q.by(s).prompts().select('user_prompt')
+        Dataset([{'user_prompt': [Prompt(text=\"""How are you john?\""")]}])
+        """
         # File references dictionary
         file_refs = {
             key: replacement_string.format(key=key) for key in self.scenario_file_keys()
@@ -134,7 +142,9 @@ class QuestionTemplateReplacementsBuilder:
         scenario_items = {
             k: v for k, v in self.scenario.items() if k not in self.scenario_file_keys()
         }
-        return {**file_refs, **scenario_items}
+        scenario_items_with_prefix = {'scenario': scenario_items}
+        
+        return {**file_refs, **scenario_items, **scenario_items_with_prefix}
 
     @staticmethod
     def _question_data_replacements(
@@ -169,7 +179,7 @@ class QuestionTemplateReplacementsBuilder:
         >>> q = QuestionMultipleChoice(question_text="What do you think of this file: {{ file1 }}, {{ first_name}}", question_name = "q0", question_options = ["good", "bad"])
         >>> qtrb = QuestionTemplateReplacementsBuilder(scenario = s, question = q, prior_answers_dict = {'q0': 'q0'}, agent = "agent")
         >>> qtrb.build_replacement_dict(q.data)
-        {'file1': '<see file file1>', 'first_name': 'John', 'use_code': False, 'include_comment': True, 'question_name': 'q0', 'question_text': 'What do you think of this file: {{ file1 }}, {{ first_name}}', 'question_options': ['good', 'bad'], 'q0': 'q0', 'agent': 'agent'}
+        {'file1': '<see file file1>', 'first_name': 'John', 'scenario': {'first_name': 'John'}, 'use_code': False, 'include_comment': True, 'question_name': 'q0', 'question_text': 'What do you think of this file: {{ file1 }}, {{ first_name}}', 'question_options': ['good', 'bad'], 'q0': 'q0', 'agent': 'agent'}
 
 
         """