edsl 0.1.29.dev3__py3-none-any.whl → 0.1.29.dev5__py3-none-any.whl

edsl/conjure/InputData.py

@@ -1,5 +1,4 @@
-import functools
-
+import base64
 from abc import ABC, abstractmethod
 from typing import Dict, Callable, Optional, List, Generator, Tuple, Union
 from collections import namedtuple
@@ -52,6 +51,7 @@ class InputDataABC(
         config: Optional[dict] = None,
         naming_function: Optional[Callable] = sanitize_string,
         raw_data: Optional[List] = None,
+        binary: Optional[str] = None,
         question_names: Optional[List[str]] = None,
         question_texts: Optional[List[str]] = None,
         answer_codebook: Optional[Dict] = None,
@@ -83,6 +83,15 @@ class InputDataABC(
         self.config = config
         self.naming_function = naming_function
 
+        if binary is not None:
+            self.binary = binary        
+        else:
+            try:
+                with open(self.datafile_name, 'rb') as file:
+                    self.binary = base64.b64encode(file.read()).decode()
+            except FileNotFoundError:
+                self.binary = None
+
         def default_repair_func(x):
             return (
                 x.replace("#", "_num")
@@ -118,6 +127,14 @@ class InputDataABC(
         if order_options:
             self.order_options()
 
+    @property
+    def download_link(self):
+        from IPython.display import HTML
+        actual_file_name = self.datafile_name.split("/")[-1]
+        download_link =f'<a href="data:text/plain;base64,{self.binary}" download="{actual_file_name}">Download {self.datafile_name}</a>'
+        return HTML(download_link)
+
+
     @abstractmethod
     def get_question_texts(self) -> List[str]:
         """Get the text of the questions
@@ -151,7 +168,7 @@ class InputDataABC(
         """
         raise NotImplementedError
 
-    def rename_questions(self, rename_dict: Dict[str, str]) -> "InputData":
+    def rename_questions(self, rename_dict: Dict[str, str], ignore_missing = False) -> "InputData":
         """Rename a question.
 
         >>> id = InputDataABC.example()
@@ -160,10 +177,10 @@ class InputDataABC(
 
         """
         for old_name, new_name in rename_dict.items():
-            self.rename(old_name, new_name)
+            self.rename(old_name, new_name, ignore_missing = ignore_missing)
         return self
 
-    def rename(self, old_name, new_name) -> "InputData":
+    def rename(self, old_name, new_name, ignore_missing = False) -> "InputData":
         """Rename a question.
 
         >>> id = InputDataABC.example()
@@ -171,13 +188,19 @@ class InputDataABC(
         ['evening', 'feeling']
 
         """
+        if old_name not in self.question_names:
+            if ignore_missing:
+                return self
+            else:
+                raise ValueError(f"Question {old_name} not found.")
+            
         idx = self.question_names.index(old_name)
         self.question_names[idx] = new_name
         self.answer_codebook[new_name] = self.answer_codebook.pop(old_name, {})
 
         return self
 
-    def _drop_question(self, question_name):
+    def _drop_question(self, question_name, ignore_missing=False):
         """Drop a question
 
         >>> id = InputDataABC.example()
@@ -185,6 +208,11 @@ class InputDataABC(
         ['feeling']
 
         """
+        if question_name not in self.question_names:
+            if ignore_missing:
+                return self
+            else:
+                raise ValueError(f"Question {question_name} not found.")
         idx = self.question_names.index(question_name)
         self._question_names.pop(idx)
         self._question_texts.pop(idx)
@@ -206,7 +234,7 @@ class InputDataABC(
             self._drop_question(qn)
         return self
 
-    def keep(self, *question_names_to_keep) -> "InputDataABC":
+    def keep(self, *question_names_to_keep, ignore_missing = False) -> "InputDataABC":
         """Keep a question.
 
         >>> id = InputDataABC.example()
@@ -217,7 +245,7 @@ class InputDataABC(
         all_question_names = self._question_names[:]
         for qn in all_question_names:
             if qn not in question_names_to_keep:
-                self._drop_question(qn)
+                self._drop_question(qn, ignore_missing = ignore_missing)
         return self
 
     def modify_question_type(
@@ -284,6 +312,7 @@ class InputDataABC(
             "raw_data": self.raw_data,
             "question_names": self.question_names,
             "question_texts": self.question_texts,
+            "binary": self.binary,
             "answer_codebook": self.answer_codebook,
             "question_types": self.question_types,
         }

edsl/coop/coop.py

@@ -5,8 +5,14 @@ import requests
 from typing import Any, Optional, Union, Literal
 from uuid import UUID
 import edsl
-from edsl import CONFIG, CacheEntry
-from edsl.coop.utils import EDSLObject, ObjectRegistry, ObjectType, VisibilityType
+from edsl import CONFIG, CacheEntry, Jobs
+from edsl.coop.utils import (
+    EDSLObject,
+    ObjectRegistry,
+    ObjectType,
+    RemoteJobStatus,
+    VisibilityType,
+)
 
 
 class Coop:
@@ -494,6 +500,40 @@ class Coop:
     ################
     # Remote Inference
     ################
+    def remote_inference_create(
+        self,
+        job: Jobs,
+        description: Optional[str] = None,
+        status: RemoteJobStatus = "queued",
+        visibility: Optional[VisibilityType] = "unlisted",
+    ) -> dict:
+        """
+        Send a remote inference job to the server.
+        """
+        response = self._send_server_request(
+            uri="api/v0/remote-inference",
+            method="POST",
+            payload={
+                "json_string": json.dumps(
+                    job.to_dict(),
+                    default=self._json_handle_none,
+                ),
+                "description": description,
+                "status": status,
+                "visibility": visibility,
+                "version": self._edsl_version,
+            },
+        )
+        self._resolve_server_response(response)
+        response_json = response.json()
+        return {
+            "uuid": response_json.get("jobs_uuid"),
+            "description": response_json.get("description"),
+            "status": response_json.get("status"),
+            "visibility": response_json.get("visibility"),
+            "version": self._edsl_version,
+        }
+
     def remote_inference_get(self, job_uuid: str) -> dict:
         """
         Get the results of a remote inference job.
@@ -508,13 +548,34 @@ class Coop:
         return {
             "jobs_uuid": data.get("jobs_uuid"),
             "results_uuid": data.get("results_uuid"),
-            "results_url": "TO BE ADDED",
+            "results_url": f"{self.url}/content/{data.get('results_uuid')}",
             "status": data.get("status"),
             "reason": data.get("reason"),
             "price": data.get("price"),
             "version": data.get("version"),
         }
 
+    def remote_inference_cost(
+        self,
+        job: Jobs,
+    ) -> dict:
+        """
+        Get the cost of a remote inference job.
+        """
+        response = self._send_server_request(
+            uri="api/v0/remote-inference/cost",
+            method="POST",
+            payload={
+                "json_string": json.dumps(
+                    job.to_dict(),
+                    default=self._json_handle_none,
+                ),
+            },
+        )
+        self._resolve_server_response(response)
+        response_json = response.json()
+        return response_json.get("cost")
+
     ################
     # Remote Errors
     ################
@@ -705,18 +766,10 @@ if __name__ == "__main__":
     ##############
     from edsl.jobs import Jobs
 
-    # check jobs on server (should be an empty list)
-    coop.get_all("job")
-    for job in coop.get_all("job"):
-        coop.delete(object_type="job", uuid=job.get("uuid"))
-    # post a job
-    response = coop.create(Jobs.example())
-    # get job and results
-    coop.remote_inference_get(response.get("uuid"))
-    coop.get(
-        object_type="results",
-        uuid=coop.remote_inference_get(response.get("uuid")).get("results_uuid"),
-    )
+    job = Jobs.example()
+    coop.remote_inference_cost(job)
+    results = coop.remote_inference_create(job)
+    coop.remote_inference_get(results.get("uuid"))
 
     ##############
     # D. Errors

edsl/coop/utils.py

@@ -55,6 +55,8 @@ ObjectPage = Literal[
     "studies",
 ]
 
+RemoteJobStatus = Literal["queued", "running", "completed", "failed"]
+
 VisibilityType = Literal[
     "private",
     "public",

edsl/jobs/Jobs.py

@@ -312,10 +312,6 @@ class Jobs(Base):
         # if no agents, models, or scenarios are set, set them to defaults
         self.agents = self.agents or [Agent()]
         self.models = self.models or [Model()]
-        # if remote, set all the models to remote
-        if hasattr(self, "remote") and self.remote:
-            for model in self.models:
-                model.remote = True
         self.scenarios = self.scenarios or [Scenario()]
         for agent, scenario, model in product(self.agents, self.scenarios, self.models):
             yield Interview(
@@ -368,7 +364,7 @@ class Jobs(Base):
         if self.verbose:
             print(message)
 
-    def _check_parameters(self, strict=False, warn = True) -> None:
+    def _check_parameters(self, strict=False, warn=True) -> None:
         """Check if the parameters in the survey and scenarios are consistent.
 
         >>> from edsl import QuestionFreeText
@@ -413,15 +409,13 @@ class Jobs(Base):
         progress_bar: bool = False,
         stop_on_exception: bool = False,
         cache: Union[Cache, bool] = None,
-        remote: bool = (
-            False if os.getenv("DEFAULT_RUN_MODE", "local") == "local" else True
-        ),
         check_api_keys: bool = False,
         sidecar_model: Optional[LanguageModel] = None,
         batch_mode: Optional[bool] = None,
         verbose: bool = False,
         print_exceptions=True,
         remote_cache_description: Optional[str] = None,
+        remote_inference_description: Optional[str] = None,
     ) -> Results:
         """
         Runs the Job: conducts Interviews and returns their results.
@@ -431,11 +425,11 @@ class Jobs(Base):
         :param progress_bar: shows a progress bar
         :param stop_on_exception: stops the job if an exception is raised
         :param cache: a cache object to store results
-        :param remote: run the job remotely
         :param check_api_keys: check if the API keys are valid
         :param batch_mode: run the job in batch mode i.e., no expecation of interaction with the user
         :param verbose: prints messages
         :param remote_cache_description: specifies a description for this group of entries in the remote cache
+        :param remote_inference_description: specifies a description for the remote inference job
         """
         from edsl.coop.coop import Coop
 
@@ -446,21 +440,33 @@ class Jobs(Base):
                 "Batch mode is deprecated. Please update your code to not include 'batch_mode' in the 'run' method."
             )
 
-        self.remote = remote
         self.verbose = verbose
 
         try:
             coop = Coop()
-            remote_cache = coop.edsl_settings["remote_caching"]
+            user_edsl_settings = coop.edsl_settings
+            remote_cache = user_edsl_settings["remote_caching"]
+            remote_inference = user_edsl_settings["remote_inference"]
         except Exception:
             remote_cache = False
+            remote_inference = False
 
-        if self.remote:
-            ## TODO: This should be a coop check
-            if os.getenv("EXPECTED_PARROT_API_KEY", None) is None:
-                raise MissingRemoteInferenceError()
+        if remote_inference:
+            self._output("Remote inference activated. Sending job to server...")
+            if remote_cache:
+                self._output(
+                    "Remote caching activated. The remote cache will be used for this job."
+                )
 
-        if not self.remote:
+            remote_job_data = coop.remote_inference_create(
+                self,
+                description=remote_inference_description,
+                status="queued",
+            )
+            self._output("Job sent!")
+            self._output(remote_job_data)
+            return remote_job_data
+        else:
             if check_api_keys:
                 for model in self.models + [Model()]:
                     if not model.has_valid_api_key():

edsl/jobs/interviews/InterviewTaskBuildingMixin.py

@@ -44,6 +44,7 @@ class InterviewTaskBuildingMixin:
             scenario=self.scenario,
             model=self.model,
             debug=debug,
+            survey=self.survey,
             memory_plan=self.survey.memory_plan,
             current_answers=self.answers,
             iteration=self.iteration,

edsl/notebooks/Notebook.py

@@ -56,6 +56,36 @@ class Notebook(Base):
 
         self.name = name or self.default_name
 
+    @classmethod
+    def from_script(cls, path: str, name: Optional[str] = None) -> "Notebook":
+        # Read the script file
+        with open(path, 'r') as script_file:
+            script_content = script_file.read()
+        
+        # Create a new Jupyter notebook
+        nb = nbformat.v4.new_notebook()
+        
+        # Add the script content to the first cell
+        first_cell = nbformat.v4.new_code_cell(script_content)
+        nb.cells.append(first_cell)
+        
+        # Create a Notebook instance with the notebook data
+        notebook_instance = cls(nb)
+        
+        return notebook_instance
+    
+    @classmethod
+    def from_current_script(cls) -> "Notebook":
+        import inspect
+        import os
+        # Get the path to the current file
+        current_frame = inspect.currentframe()
+        caller_frame = inspect.getouterframes(current_frame, 2)
+        current_file_path = os.path.abspath(caller_frame[1].filename)
+        
+        # Use from_script to create the notebook
+        return cls.from_script(current_file_path)
+
     def __eq__(self, other):
         """
         Check if two Notebooks are equal.

edsl/prompts/Prompt.py

@@ -1,12 +1,16 @@
-"""Class for creating prompts to be used in a survey."""
-
 from __future__ import annotations
 from typing import Optional
 from abc import ABC
 from typing import Any, List
 
 from rich.table import Table
-from jinja2 import Template, Environment, meta, TemplateSyntaxError
+from jinja2 import Template, Environment, meta, TemplateSyntaxError, Undefined
+
+
+class PreserveUndefined(Undefined):
+    def __str__(self):
+        return "{{ " + self._undefined_name + " }}"
+
 
 from edsl.exceptions.prompts import TemplateRenderError
 from edsl.prompts.prompt_config import (
@@ -35,6 +39,10 @@ class PromptBase(
 
         return data_to_html(self.to_dict())
 
+    def __len__(self):
+        """Return the length of the prompt text."""
+        return len(self.text)
+
     @classmethod
     def prompt_attributes(cls) -> List[str]:
         """Return the prompt class attributes."""
@@ -75,10 +83,10 @@ class PromptBase(
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt("How are you?")
         >>> p + p2
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
 
         >>> p + "How are you?"
-        Prompt(text='Hello, {{person}}How are you?')
+        Prompt(text=\"""Hello, {{person}}How are you?\""")
         """
         if isinstance(other_prompt, str):
             return self.__class__(self.text + other_prompt)
@@ -114,7 +122,7 @@ class PromptBase(
         Example:
         >>> p = Prompt("Hello, {{person}}")
         >>> p
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
         """
         return f'Prompt(text="""{self.text}""")'
 
@@ -137,7 +145,7 @@ class PromptBase(
         :param template: The template to find the variables in.
 
         """
-        env = Environment()
+        env = Environment(undefined=PreserveUndefined)
         ast = env.parse(template)
         return list(meta.find_undeclared_variables(ast))
 
@@ -186,13 +194,16 @@ class PromptBase(
 
         >>> p = Prompt("Hello, {{person}}")
         >>> p.render({"person": "John"})
-        'Hello, John'
+        Prompt(text=\"""Hello, John\""")
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Horton"})
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Horton\""")
 
         >>> p.render({"person": "Mr. {{last_name}}", "last_name": "Ho{{letter}}ton"}, max_nesting = 1)
-        'Hello, Mr. Horton'
+        Prompt(text=\"""Hello, Mr. Ho{{ letter }}ton\""")
+
+        >>> p.render({"person": "Mr. {{last_name}}"})
+        Prompt(text=\"""Hello, Mr. {{ last_name }}\""")
         """
         new_text = self._render(
             self.text, primary_replacement, **additional_replacements
@@ -216,12 +227,13 @@ class PromptBase(
         >>> codebook = {"age": "Age"}
         >>> p = Prompt("You are an agent named {{ name }}. {{ codebook['age']}}: {{ age }}")
         >>> p.render({"name": "John", "age": 44}, codebook=codebook)
-        'You are an agent named John. Age: 44'
+        Prompt(text=\"""You are an agent named John. Age: 44\""")
         """
+        env = Environment(undefined=PreserveUndefined)
         try:
             previous_text = None
             for _ in range(MAX_NESTING):
-                rendered_text = Template(text).render(
+                rendered_text = env.from_string(text).render(
                     primary_replacement, **additional_replacements
                 )
                 if rendered_text == previous_text:
@@ -258,7 +270,7 @@ class PromptBase(
         >>> p = Prompt("Hello, {{person}}")
         >>> p2 = Prompt.from_dict(p.to_dict())
         >>> p2
-        Prompt(text='Hello, {{person}}')
+        Prompt(text=\"""Hello, {{person}}\""")
 
         """
         class_name = data["class_name"]
@@ -290,6 +302,12 @@ class Prompt(PromptBase):
     component_type = ComponentTypes.GENERIC
 
 
+if __name__ == "__main__":
+    print("Running doctests...")
+    import doctest
+
+    doctest.testmod()
+
 from edsl.prompts.library.question_multiple_choice import *
 from edsl.prompts.library.agent_instructions import *
 from edsl.prompts.library.agent_persona import *
@@ -302,9 +320,3 @@ from edsl.prompts.library.question_numerical import *
 from edsl.prompts.library.question_rank import *
 from edsl.prompts.library.question_extract import *
 from edsl.prompts.library.question_list import *
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

edsl/questions/QuestionBase.py

@@ -173,15 +173,16 @@ class QuestionBase(
     def add_model_instructions(
         self, *, instructions: str, model: Optional[str] = None
     ) -> None:
-        """Add model-specific instructions for the question.
+        """Add model-specific instructions for the question that override the default instructions.
 
         :param instructions: The instructions to add. This is typically a jinja2 template.
         :param model: The language model for this instruction.
 
         >>> from edsl.questions import QuestionFreeText
         >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
-        >>> q.add_model_instructions(instructions = "Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
-
+        >>> q.add_model_instructions(instructions = "{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}", model = "gpt3")
+        >>> q.get_instructions(model = "gpt3")
+        Prompt(text=\"""{{question_text}}. Answer in valid JSON like so {'answer': 'comment: <>}\""")
         """
         from edsl import Model
 
@@ -201,6 +202,13 @@ class QuestionBase(
         """Get the mathcing question-answering instructions for the question.
 
         :param model: The language model to use.
+
+        >>> from edsl import QuestionFreeText
+        >>> QuestionFreeText.example().get_instructions()
+        Prompt(text=\"""You are being asked the following question: {{question_text}}
+        Return a valid JSON formatted like this:
+        {"answer": "<put free text answer here>"}
+        \""")
         """
         from edsl.prompts.Prompt import Prompt
 
@@ -293,7 +301,16 @@ class QuestionBase(
         print_json(json.dumps(self.to_dict()))
 
     def __call__(self, just_answer=True, model=None, agent=None, **kwargs):
-        """Call the question."""
+        """Call the question.
+
+        >>> from edsl.language_models import LanguageModel
+        >>> m = LanguageModel.example(canned_response = "Yo, what's up?", test_model = True)
+        >>> from edsl import QuestionFreeText
+        >>> q = QuestionFreeText(question_name = "color", question_text = "What is your favorite color?")
+        >>> q(model = m)
+        "Yo, what's up?"
+
+        """
         survey = self.to_survey()
         results = survey(model=model, agent=agent, **kwargs)
         if just_answer:
@@ -304,7 +321,6 @@ class QuestionBase(
     async def run_async(self, just_answer=True, model=None, agent=None, **kwargs):
         """Call the question."""
         survey = self.to_survey()
-        ## asyncio.run(survey.async_call());
         results = await survey.run_async(model=model, agent=agent, **kwargs)
         if just_answer:
             return results.select(f"answer.{self.question_name}").first()
@@ -383,29 +399,34 @@ class QuestionBase(
         s = Survey([self, other])
         return s
 
-    def to_survey(self):
+    def to_survey(self) -> "Survey":
         """Turn a single question into a survey."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s
 
-    def run(self, *args, **kwargs):
+    def run(self, *args, **kwargs) -> "Results":
         """Turn a single question into a survey and run it."""
         from edsl.surveys.Survey import Survey
 
         s = self.to_survey()
         return s.run(*args, **kwargs)
 
-    def by(self, *args):
-        """Turn a single question into a survey and run it."""
+    def by(self, *args) -> "Jobs":
+        """Turn a single question into a survey and then a Job."""
         from edsl.surveys.Survey import Survey
 
         s = Survey([self])
         return s.by(*args)
 
-    def human_readable(self):
-        """Print the question in a human readable format."""
+    def human_readable(self) -> str:
+        """Print the question in a human readable format.
+
+        >>> from edsl.questions import QuestionFreeText
+        >>> QuestionFreeText.example().human_readable()
+        'Question Type: free_text\\nQuestion: How are you?'
+        """
         lines = []
         lines.append(f"Question Type: {self.question_type}")
         lines.append(f"Question: {self.question_text}")

edsl/questions/settings.py

@@ -8,5 +8,5 @@ class Settings:
     MAX_EXPRESSION_CONSTRAINT_LENGTH = 1000
     MAX_NUM_OPTIONS = 200
     MIN_NUM_OPTIONS = 2
-    MAX_OPTION_LENGTH = 1000
+    MAX_OPTION_LENGTH = 10000
     MAX_QUESTION_LENGTH = 100000

edsl/results/Dataset.py

@@ -77,6 +77,28 @@ class Dataset(UserList, ResultsExportMixin):
             return list(d.values())[0]
 
         return get_values(self.data[0])[0]
+    
+    def select(self, *keys):
+        """Return a new dataset with only the selected keys.
+
+        :param keys: The keys to select.
+
+        >>> d = Dataset([{'a.b':[1,2,3,4]}, {'c.d':[5,6,7,8]}])
+        >>> d.select('a.b')
+        Dataset([{'a.b': [1, 2, 3, 4]}])
+
+        >>> d.select('a.b', 'c.d')
+        Dataset([{'a.b': [1, 2, 3, 4]}, {'c.d': [5, 6, 7, 8]}])
+        """
+        if isinstance(keys, str):
+            keys = [keys]
+
+        new_data = []
+        for observation in self.data:
+            observation_key = list(observation.keys())[0]
+            if observation_key in keys:
+                new_data.append(observation)
+        return Dataset(new_data)
 
     def _repr_html_(self) -> str:
         """Return an HTML representation of the dataset."""
@@ -222,6 +244,15 @@ class Dataset(UserList, ResultsExportMixin):
             new_data.append({key: new_values})
 
         return Dataset(new_data)
+    
+    @classmethod
+    def example(self):
+        """Return an example dataset.
+
+        >>> Dataset.example()
+        Dataset([{'a': [1, 2, 3, 4]}, {'b': [4, 3, 2, 1]}])
+        """
+        return Dataset([{'a':[1,2,3,4]}, {'b':[4,3,2,1]}])
 
 
 if __name__ == "__main__":