edsl 0.1.46__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,36 +77,27 @@ class PersistenceMixin:
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
         coop = Coop()
 
-        # Determine if input is URL or UUID
-        if "www" in url_or_uuid:
-            url_or_uuid = url_or_uuid.replace("www", "api")
-        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
@@ -116,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.46"
+__version__ = "0.1.47"

edsl/coop/coop.py

@@ -287,19 +287,25 @@ class Coop(CoopFunctionsMixin):
         if value is None:
             return "null"
 
+    @staticmethod
+    def _is_url(url_or_uuid: Union[str, UUID]) -> bool:
+        return "http://" in str(url_or_uuid) or "https://" in str(url_or_uuid)
+
     def _resolve_uuid_or_alias(
-        self, uuid: Union[str, UUID] = None, url: str = None
+        self, url_or_uuid: Union[str, UUID]
     ) -> tuple[Optional[str], Optional[str], Optional[str]]:
         """
         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)
+        - For content/uuid URLs: returns (uuid, None, None)
+        - For content/username/alias URLs: returns (None, username, alias)
         """
-        if not url and not uuid:
+        if not url_or_uuid:
             raise CoopNoUUIDError("No uuid or url provided for the object.")
 
-        if not uuid and url:
+        if self._is_url(url_or_uuid):
+            url = str(url_or_uuid)
+
             parts = (
                 url.replace("http://", "")
                 .replace("https://", "")
@@ -326,7 +332,8 @@ class Coop(CoopFunctionsMixin):
                     f"Invalid URL format. The URL must end with /content/<uuid> or /content/<username>/<alias>: {url}"
                 )
 
-        return str(uuid), None, None
+        uuid = str(url_or_uuid)
+        return uuid, None, None
 
     @property
     def edsl_settings(self) -> dict:
@@ -348,6 +355,15 @@ class Coop(CoopFunctionsMixin):
     ################
     # Objects
     ################
+    def _get_alias_url(self, owner_username: str, alias: str) -> Union[str, None]:
+        """
+        Get the URL of an object by its owner username and alias.
+        """
+        if owner_username and alias:
+            return f"{self.url}/content/{owner_username}/{alias}"
+        else:
+            return None
+
     def create(
         self,
         object: EDSLObject,
@@ -368,7 +384,9 @@ class Coop(CoopFunctionsMixin):
                 "json_string": json.dumps(
                     object.to_dict(),
                     default=self._json_handle_none,
-                ),
+                )
+                if object_type != "scenario"
+                else "",
                 "object_type": object_type,
                 "visibility": visibility,
                 "version": self._edsl_version,
@@ -376,19 +394,38 @@ class Coop(CoopFunctionsMixin):
         )
         self._resolve_server_response(response)
         response_json = response.json()
+
+        if object_type == "scenario":
+            json_data = json.dumps(
+                object.to_dict(),
+                default=self._json_handle_none,
+            )
+            headers = {"Content-Type": "application/json"}
+            if response_json.get("upload_signed_url"):
+                signed_url = response_json.get("upload_signed_url")
+            else:
+                raise Exception("No signed url provided received")
+
+            response = requests.put(
+                signed_url, data=json_data.encode(), headers=headers
+            )
+        owner_username = response_json.get("owner_username")
+        object_alias = response_json.get("alias")
+
         return {
             "description": response_json.get("description"),
             "object_type": object_type,
             "url": f"{self.url}/content/{response_json.get('uuid')}",
+            "alias_url": self._get_alias_url(owner_username, object_alias),
             "uuid": response_json.get("uuid"),
             "version": self._edsl_version,
             "visibility": response_json.get("visibility"),
+            "upload_signed_url": response_json.get("upload_signed_url", None),
         }
 
     def get(
         self,
-        uuid: Union[str, UUID] = None,
-        url: str = None,
+        url_or_uuid: Union[str, UUID],
         expected_object_type: Optional[ObjectType] = None,
     ) -> EDSLObject:
         """
@@ -396,13 +433,13 @@ class Coop(CoopFunctionsMixin):
         - 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 (can be content/uuid or content/username/alias format).
-        :param expected_object_type: the expected type of the object.
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
+        :param expected_object_type: The expected type of the object.
 
         :return: the object instance.
         """
-        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(uuid, url)
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(url_or_uuid)
 
         if obj_uuid:
             response = self._send_server_request(
@@ -419,6 +456,10 @@ class Coop(CoopFunctionsMixin):
 
         self._resolve_server_response(response)
         json_string = response.json().get("json_string")
+        if "load_from:" in json_string[0:12]:
+            load_link = json_string.split("load_from:")[1]
+            object_data = requests.get(load_link)
+            json_string = object_data.text
         object_type = response.json().get("object_type")
         if expected_object_type and object_type != expected_object_type:
             raise Exception(f"Expected {expected_object_type=} but got {object_type=}")
@@ -437,28 +478,51 @@ class Coop(CoopFunctionsMixin):
             params={"type": object_type},
         )
         self._resolve_server_response(response)
-        objects = [
-            {
-                "object": edsl_class.from_dict(json.loads(o.get("json_string"))),
+        objects = []
+        for o in response.json():
+            json_string = o.get("json_string")
+            ## check if load from bucket needed.
+            if "load_from:" in json_string[0:12]:
+                load_link = json_string.split("load_from:")[1]
+                object_data = requests.get(load_link)
+                json_string = object_data.text
+
+            json_string = json.loads(json_string)
+            object = {
+                "object": edsl_class.from_dict(json_string),
                 "uuid": o.get("uuid"),
                 "version": o.get("version"),
                 "description": o.get("description"),
                 "visibility": o.get("visibility"),
                 "url": f"{self.url}/content/{o.get('uuid')}",
+                "alias_url": self._get_alias_url(
+                    o.get("owner_username"), o.get("alias")
+                ),
             }
-            for o in response.json()
-        ]
+            objects.append(object)
+
         return objects
 
-    def delete(self, uuid: Union[str, UUID] = None, url: str = None) -> dict:
+    def delete(self, url_or_uuid: Union[str, UUID]) -> dict:
         """
         Delete an object from the server.
+
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
         """
-        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
+        obj_uuid, owner_username, alias = self._resolve_uuid_or_alias(url_or_uuid)
+
+        if obj_uuid:
+            uri = "api/v0/object"
+            params = {"uuid": obj_uuid}
+        else:
+            uri = "api/v0/object/alias"
+            params = {"owner_username": owner_username, "alias": alias}
+
         response = self._send_server_request(
-            uri=f"api/v0/object",
+            uri=uri,
             method="DELETE",
-            params={"uuid": obj_uuid},
+            params=params,
         )
 
         self._resolve_server_response(response)
@@ -466,8 +530,7 @@ class Coop(CoopFunctionsMixin):
 
     def patch(
         self,
-        uuid: Union[str, UUID] = None,
-        url: str = None,
+        url_or_uuid: Union[str, UUID],
         description: Optional[str] = None,
         alias: Optional[str] = None,
         value: Optional[EDSLObject] = None,
@@ -475,15 +538,35 @@ class Coop(CoopFunctionsMixin):
     ) -> dict:
         """
         Change the attributes of an uploaded object
-        - Only supports visibility for now
-        """
-        if description is None and visibility is None and value is None:
+
+        :param url_or_uuid: The UUID or URL of the object.
+            URLs can be in the form content/uuid or content/username/alias.
+        :param description: Optional new description
+        :param alias: Optional new alias
+        :param value: Optional new object value
+        :param visibility: Optional new visibility setting
+        """
+        if (
+            description is None
+            and visibility is None
+            and value is None
+            and alias is None
+        ):
             raise Exception("Nothing to patch.")
-        obj_uuid, _, _ = self._resolve_uuid_or_alias(uuid, url)
+
+        obj_uuid, owner_username, obj_alias = self._resolve_uuid_or_alias(url_or_uuid)
+
+        if obj_uuid:
+            uri = "api/v0/object"
+            params = {"uuid": obj_uuid}
+        else:
+            uri = "api/v0/object/alias"
+            params = {"owner_username": owner_username, "alias": obj_alias}
+
         response = self._send_server_request(
-            uri=f"api/v0/object",
+            uri=uri,
             method="PATCH",
-            params={"uuid": obj_uuid},
+            params=params,
             payload={
                 "description": description,
                 "alias": alias,
@@ -1187,27 +1270,25 @@ def main():
     ##############
     # .. create and manipulate an object through the Coop client
     response = coop.create(QuestionMultipleChoice.example())
-    coop.get(uuid=response.get("uuid"))
-    coop.get(uuid=response.get("uuid"), expected_object_type="question")
-    coop.get(url=response.get("url"))
+    coop.get(response.get("uuid"))
+    coop.get(response.get("uuid"), expected_object_type="question")
+    coop.get(response.get("url"))
     coop.create(QuestionMultipleChoice.example())
     coop.get_all("question")
-    coop.patch(uuid=response.get("uuid"), visibility="private")
-    coop.patch(uuid=response.get("uuid"), description="hey")
-    coop.patch(uuid=response.get("uuid"), value=QuestionFreeText.example())
-    # coop.patch(uuid=response.get("uuid"), value=Survey.example()) - should throw error
-    coop.get(uuid=response.get("uuid"))
-    coop.delete(uuid=response.get("uuid"))
+    coop.patch(response.get("uuid"), visibility="private")
+    coop.patch(response.get("uuid"), description="hey")
+    coop.patch(response.get("uuid"), value=QuestionFreeText.example())
+    # coop.patch(response.get("uuid"), value=Survey.example()) - should throw error
+    coop.get(response.get("uuid"))
+    coop.delete(response.get("uuid"))
 
     # .. create and manipulate an object through the class
     response = QuestionMultipleChoice.example().push()
-    QuestionMultipleChoice.pull(uuid=response.get("uuid"))
-    QuestionMultipleChoice.pull(url=response.get("url"))
-    QuestionMultipleChoice.patch(uuid=response.get("uuid"), visibility="private")
-    QuestionMultipleChoice.patch(uuid=response.get("uuid"), description="hey")
-    QuestionMultipleChoice.patch(
-        uuid=response.get("uuid"), value=QuestionFreeText.example()
-    )
+    QuestionMultipleChoice.pull(response.get("uuid"))
+    QuestionMultipleChoice.pull(response.get("url"))
+    QuestionMultipleChoice.patch(response.get("uuid"), visibility="private")
+    QuestionMultipleChoice.patch(response.get("uuid"), description="hey")
+    QuestionMultipleChoice.patch(response.get("uuid"), value=QuestionFreeText.example())
     QuestionMultipleChoice.pull(response.get("uuid"))
     QuestionMultipleChoice.delete(response.get("uuid"))
 
@@ -1230,7 +1311,7 @@ def main():
         # 1. Delete existing objects
         existing_objects = coop.get_all(object_type)
         for item in existing_objects:
-            coop.delete(uuid=item.get("uuid"))
+            coop.delete(item.get("uuid"))
         # 2. Create new objects
         example = cls.example()
         response_1 = coop.create(example)
@@ -1244,21 +1325,21 @@ def main():
         assert len(objects) == 4
         # 4. Try to retrieve an item that does not exist
         try:
-            coop.get(uuid=uuid4())
+            coop.get(uuid4())
         except Exception as e:
             print(e)
         # 5. Try to retrieve all test objects by their uuids
         for response in [response_1, response_2, response_3, response_4]:
-            coop.get(uuid=response.get("uuid"))
+            coop.get(response.get("uuid"))
         # 6. Change visibility of all objects
         for item in objects:
-            coop.patch(uuid=item.get("uuid"), visibility="private")
+            coop.patch(item.get("uuid"), visibility="private")
         # 6. Change description of all objects
         for item in objects:
-            coop.patch(uuid=item.get("uuid"), description="hey")
+            coop.patch(item.get("uuid"), description="hey")
         # 7. Delete all objects
         for item in objects:
-            coop.delete(uuid=item.get("uuid"))
+            coop.delete(item.get("uuid"))
         assert len(coop.get_all(object_type)) == 0
 
     ##############
@@ -1291,4 +1372,4 @@ def main():
     coop.remote_inference_cost(job)
     job_coop_object = coop.remote_inference_create(job)
     job_coop_results = coop.remote_inference_get(job_coop_object.get("uuid"))
-    coop.get(uuid=job_coop_results.get("results_uuid"))
+    coop.get(job_coop_results.get("results_uuid"))

edsl/data/Cache.py

@@ -173,6 +173,7 @@ class Cache(Base):
         user_prompt: str,
         response: dict,
         iteration: int,
+        service: str,
     ) -> str:
         """
         Add a new key-value pair to the cache.
@@ -204,6 +205,7 @@ class Cache(Base):
             user_prompt=user_prompt,
             output=json.dumps(response),
             iteration=iteration,
+            service=service,
         )
         key = entry.key
         self.new_entries[key] = entry

edsl/data/CacheEntry.py

@@ -16,7 +16,7 @@ class CacheEntry(RepresentationMixin):
     """
 
     key_fields = ["model", "parameters", "system_prompt", "user_prompt", "iteration"]
-    all_fields = key_fields + ["timestamp", "output"]
+    all_fields = key_fields + ["timestamp", "output", "service"]
 
     def __init__(
         self,
@@ -28,6 +28,7 @@ class CacheEntry(RepresentationMixin):
         iteration: Optional[int] = None,
         output: str,
         timestamp: Optional[int] = None,
+        service: Optional[str] = None,
     ):
         self.model = model
         self.parameters = parameters
@@ -38,6 +39,7 @@ class CacheEntry(RepresentationMixin):
         self.timestamp = timestamp or int(
             datetime.datetime.now(datetime.timezone.utc).timestamp()
         )
+        self.service = service
         self._check_types()
 
     def _check_types(self):
@@ -59,6 +61,8 @@ class CacheEntry(RepresentationMixin):
         # TODO: should probably be float
         if not isinstance(self.timestamp, int):
             raise TypeError(f"`timestamp` should be an integer")
+        if self.service is not None and not isinstance(self.service, str):
+            raise TypeError("`service` should be either a string or None")
 
     @classmethod
     def gen_key(
@@ -94,6 +98,7 @@ class CacheEntry(RepresentationMixin):
             "output": self.output,
             "iteration": self.iteration,
             "timestamp": self.timestamp,
+            "service": self.service,
         }
         # if add_edsl_version:
         #     from edsl import __version__
@@ -144,7 +149,8 @@ class CacheEntry(RepresentationMixin):
             f"user_prompt={repr(self.user_prompt)}, "
             f"output={repr(self.output)}, "
             f"iteration={self.iteration}, "
-            f"timestamp={self.timestamp})"
+            f"timestamp={self.timestamp}, "
+            f"service={repr(self.service)})"
         )
 
     @classmethod
@@ -164,6 +170,7 @@ class CacheEntry(RepresentationMixin):
             output="The fox says 'hello'",
             iteration=1,
             timestamp=int(datetime.datetime.now(datetime.timezone.utc).timestamp()),
+            service="openai",
         )
 
     @classmethod
@@ -184,6 +191,7 @@ class CacheEntry(RepresentationMixin):
         input = cls.example().to_dict()
         _ = input.pop("timestamp")
         _ = input.pop("output")
+        _ = input.pop("service")
         return input
 
     @classmethod

edsl/inference_services/PerplexityService.py

@@ -29,9 +29,12 @@ class PerplexityService(OpenAIService):
     @classmethod
     def available(cls) -> List[str]:
         return [
-            "llama-3.1-sonar-huge-128k-online",
-            "llama-3.1-sonar-large-128k-online",
-            "llama-3.1-sonar-small-128k-online",
+            "sonar-deep-research",
+            "sonar-reasoning-pro",
+            "sonar-reasoning",
+            "sonar-pro",
+            "sonar",
+            "r1-1776",
         ]
 
     @classmethod
@@ -65,10 +68,10 @@ class PerplexityService(OpenAIService):
             }
 
             def sync_client(self):
-                return cls.sync_client()
+                return cls.sync_client(api_key=self.api_token)
 
             def async_client(self):
-                return cls.async_client()
+                return cls.async_client(api_key=self.api_token)
 
             @classmethod
             def available(cls) -> list[str]:
@@ -149,6 +152,7 @@ class PerplexityService(OpenAIService):
                     # "logprobs": self.logprobs,
                     # "top_logprobs": self.top_logprobs if self.logprobs else None,
                 }
+                print("calling the model", flush=True)
                 try:
                     response = await client.chat.completions.create(**params)
                 except Exception as e:

edsl/jobs/Jobs.py

@@ -119,6 +119,19 @@ class Jobs(Base):
         :param agents: a list of agents
         :param models: a list of models
         :param scenarios: a list of scenarios
+
+
+        >>> from edsl.surveys.Survey import Survey
+        >>> from edsl.questions.QuestionFreeText import QuestionFreeText
+        >>> q = QuestionFreeText(question_name="name", question_text="What is your name?")
+        >>> s = Survey(questions=[q])
+        >>> j = Jobs(survey = s)
+        >>> q = QuestionFreeText(question_name="{{ bad_name }}", question_text="What is your name?")
+        >>> s = Survey(questions=[q])
+        >>> j = Jobs(survey = s)
+        Traceback (most recent call last):
+        ...
+        ValueError: At least some question names are not valid: ['{{ bad_name }}']
         """
         self.run_config = RunConfig(
             environment=RunEnvironment(), parameters=RunParameters()
@@ -129,6 +142,13 @@ class Jobs(Base):
         self.scenarios: ScenarioList = scenarios
         self.models: ModelList = models
 
+        try:
+            assert self.survey.question_names_valid()
+        except Exception as e:
+            invalid_question_names = [q.question_name for q in self.survey.questions if not q.is_valid_question_name()]
+            raise ValueError(f"At least some question names are not valid: {invalid_question_names}")
+        
+
     def add_running_env(self, running_env: RunEnvironment):
         self.run_config.add_environment(running_env)
         return self

edsl/jobs/JobsComponentConstructor.py

@@ -153,7 +153,8 @@ class JobsComponentConstructor:
         For example, if the user passes in 3 agents,
         and there are 2 existing agents, this will create 6 new agents
         >>> from edsl.jobs import Jobs
-        >>> JobsComponentConstructor(Jobs(survey = []))._merge_objects([1,2,3], [4,5,6])
+        >>> from edsl.surveys.Survey import Survey
+        >>> JobsComponentConstructor(Jobs(survey = Survey.example()))._merge_objects([1,2,3], [4,5,6])
         [5, 6, 7, 6, 7, 8, 7, 8, 9]
         """
         new_objects = JobsComponentConstructor._get_empty_container_object(