edsl 0.1.61__tar.gz → 0.1.62__tar.gz

{edsl-0.1.61 → edsl-0.1.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: edsl
-Version: 0.1.61
+Version: 0.1.62
 Summary: Create and analyze LLM-based surveys
 Home-page: https://www.expectedparrot.com/
 License: MIT

edsl-0.1.62/edsl/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.62"

{edsl-0.1.61 → edsl-0.1.62}/edsl/base/base_class.py

@@ -331,9 +331,17 @@ class PersistenceMixin:
         """
         from edsl.coop import Coop
         from edsl.coop import ObjectRegistry
+        from edsl.jobs import Jobs
 
         coop = Coop(url=expected_parrot_url)
 
+        if issubclass(cls, Jobs):
+            job_data = coop.new_remote_inference_get(
+                str(url_or_uuid), include_json_string=True
+            )
+            job_dict = json.loads(job_data.get("job_json_string"))
+            return cls.from_dict(job_dict)
+
         object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
 
         return coop.pull(url_or_uuid, object_type)

{edsl-0.1.61 → edsl-0.1.62}/edsl/coop/coop.py

@@ -598,7 +598,7 @@ class Coop(CoopFunctionsMixin):
             else:
                 from .exceptions import CoopResponseError
 
-                raise CoopResponseError("No signed url was provided received")
+                raise CoopResponseError("No signed url was provided.")
 
             response = requests.put(
                 signed_url, data=json_data.encode(), headers=headers
@@ -945,18 +945,31 @@ class Coop(CoopFunctionsMixin):
 
         obj_uuid, owner_username, obj_alias = self._resolve_uuid_or_alias(url_or_uuid)
 
-        # If we have a UUID and are updating the value, check the storage format first
-        if obj_uuid and value:
-            # Check if object is in new format (GCS)
-            format_check_response = self._send_server_request(
-                uri="api/v0/object/check-format",
-                method="POST",
-                payload={"object_uuid": str(obj_uuid)},
-            )
-            self._resolve_server_response(format_check_response)
-            format_data = format_check_response.json()
+        # If we're updating the value, we need to check the storage format
+        if value:
+            # If we don't have a UUID but have an alias, get the UUID and format info first
+            if not obj_uuid and owner_username and obj_alias:
+                # Get object info including UUID and format
+                info_response = self._send_server_request(
+                    uri="api/v0/object/alias/info",
+                    method="GET",
+                    params={"owner_username": owner_username, "alias": obj_alias},
+                )
+                self._resolve_server_response(info_response)
+                info_data = info_response.json()
 
-            is_new_format = format_data.get("is_new_format", False)
+                obj_uuid = info_data.get("uuid")
+                is_new_format = info_data.get("is_new_format", False)
+            else:
+                # We have a UUID, check the format
+                format_check_response = self._send_server_request(
+                    uri="api/v0/object/check-format",
+                    method="POST",
+                    payload={"object_uuid": str(obj_uuid)},
+                )
+                self._resolve_server_response(format_check_response)
+                format_data = format_check_response.json()
+                is_new_format = format_data.get("is_new_format", False)
 
             if is_new_format:
                 # Handle new format objects: update metadata first, then upload content
@@ -1052,10 +1065,20 @@ class Coop(CoopFunctionsMixin):
                 f"Failed to upload object to GCS: {gcs_response.status_code}"
             )
 
+        # Step 4: Confirm upload and trigger queue worker processing
+        confirm_response = self._send_server_request(
+            uri="api/v0/object/confirm-upload",
+            method="POST",
+            payload={"object_uuid": str(obj_uuid)},
+        )
+        self._resolve_server_response(confirm_response)
+        confirm_data = confirm_response.json()
+
         return {
             "status": "success",
-            "message": "Object updated successfully (new format - uploaded to GCS)",
+            "message": "Object updated successfully (new format - uploaded to GCS and processing triggered)",
             "object_uuid": str(obj_uuid),
+            "processing_started": confirm_data.get("processing_started", False),
         }
 
     ################
@@ -1195,7 +1218,7 @@ class Coop(CoopFunctionsMixin):
         if not upload_signed_url:
             from .exceptions import CoopResponseError
 
-            raise CoopResponseError("No signed url was provided received")
+            raise CoopResponseError("No signed url was provided.")
 
         response = requests.put(
             upload_signed_url,
@@ -1431,6 +1454,160 @@ class Coop(CoopFunctionsMixin):
             }
         )
 
+    def new_remote_inference_get(
+        self,
+        job_uuid: Optional[str] = None,
+        results_uuid: Optional[str] = None,
+        include_json_string: Optional[bool] = False,
+    ) -> RemoteInferenceResponse:
+        """
+        Get the status and details of a remote inference job.
+
+        This method retrieves the current status and information about a remote job,
+        including links to results if the job has completed successfully.
+
+        Parameters:
+            job_uuid (str, optional): The UUID of the remote job to check
+            results_uuid (str, optional): The UUID of the results associated with the job
+                (can be used if you only have the results UUID)
+            include_json_string (bool, optional): If True, include the json string for the job in the response
+
+        Returns:
+            RemoteInferenceResponse: Information about the job including:
+                job_uuid: The unique identifier for the job
+                results_uuid: The UUID of the results
+                results_url: URL to access the results
+                status: Current status ("queued", "running", "completed", "failed")
+                version: EDSL version used for the job
+                job_json_string: The json string for the job (if include_json_string is True)
+                latest_job_run_details: Metadata about the job status
+                    interview_details: Metadata about the job interview status (for jobs that have reached running status)
+                        total_interviews: The total number of interviews in the job
+                        completed_interviews: The number of completed interviews
+                        interviews_with_exceptions: The number of completed interviews that have exceptions
+                        exception_counters: A list of exception counts for the job
+                            exception_type: The type of exception
+                            inference_service: The inference service
+                            model: The model
+                            question_name: The name of the question
+                            exception_count: The number of exceptions
+                    failure_reason: The reason the job failed (failed jobs only)
+                    failure_description: The description of the failure (failed jobs only)
+                    error_report_uuid: The UUID of the error report (partially failed jobs only)
+                    cost_credits: The cost of the job run in credits
+                    cost_usd: The cost of the job run in USD
+                    expenses: The expenses incurred by the job run
+                        service: The service
+                        model: The model
+                        token_type: The type of token (input or output)
+                        price_per_million_tokens: The price per million tokens
+                        tokens_count: The number of tokens consumed
+                        cost_credits: The cost of the service/model/token type combination in credits
+                        cost_usd: The cost of the service/model/token type combination in USD
+
+        Raises:
+            ValueError: If neither job_uuid nor results_uuid is provided
+            CoopServerResponseError: If there's an error communicating with the server
+
+        Notes:
+            - Either job_uuid or results_uuid must be provided
+            - If both are provided, job_uuid takes precedence
+            - For completed jobs, you can use the results_url to view or download results
+            - For failed jobs, check the latest_error_report_url for debugging information
+
+        Example:
+            >>> job_status = coop.new_remote_inference_get("9f8484ee-b407-40e4-9652-4133a7236c9c")
+            >>> print(f"Job status: {job_status['status']}")
+            >>> if job_status['status'] == 'completed':
+            ...     print(f"Results available at: {job_status['results_url']}")
+        """
+        if job_uuid is None and results_uuid is None:
+            from .exceptions import CoopValueError
+
+            raise CoopValueError("Either job_uuid or results_uuid must be provided.")
+        elif job_uuid is not None:
+            params = {"job_uuid": job_uuid}
+        else:
+            params = {"results_uuid": results_uuid}
+        if include_json_string:
+            params["include_json_string"] = include_json_string
+
+        response = self._send_server_request(
+            uri="api/v0/remote-inference",
+            method="GET",
+            params=params,
+        )
+        self._resolve_server_response(response)
+        data = response.json()
+
+        results_uuid = data.get("results_uuid")
+
+        if results_uuid is None:
+            results_url = None
+        else:
+            results_url = f"{self.url}/content/{results_uuid}"
+
+        latest_job_run_details = data.get("latest_job_run_details", {})
+        if data.get("status") == "partial_failed":
+            latest_error_report_uuid = latest_job_run_details.get("error_report_uuid")
+            if latest_error_report_uuid is None:
+                latest_job_run_details["error_report_url"] = None
+            else:
+                latest_error_report_url = (
+                    f"{self.url}/home/remote-inference/error/{latest_error_report_uuid}"
+                )
+                latest_job_run_details["error_report_url"] = latest_error_report_url
+
+        json_string = data.get("job_json_string")
+
+        # The job has been offloaded to GCS
+        if include_json_string and json_string == "offloaded":
+
+            # Attempt to fetch JSON string from GCS
+            response = self._send_server_request(
+                uri="api/v0/remote-inference/pull",
+                method="POST",
+                payload={"job_uuid": job_uuid},
+            )
+            # Handle any errors in the response
+            self._resolve_server_response(response)
+            if "signed_url" not in response.json():
+                from .exceptions import CoopResponseError
+
+                raise CoopResponseError("No signed url was provided.")
+            signed_url = response.json().get("signed_url")
+
+            if signed_url == "":  # The job is in legacy format
+                job_json = json_string
+
+            try:
+                response = requests.get(signed_url)
+                self._resolve_gcs_response(response)
+                job_json = json.dumps(response.json())
+            except Exception:
+                job_json = json_string
+
+        # If the job is in legacy format, we should already have the JSON string
+        # from the first API call
+        elif include_json_string and not json_string == "offloaded":
+            job_json = json_string
+
+        # If include_json_string is False, we don't need the JSON string at all
+        else:
+            job_json = None
+
+        return RemoteInferenceResponse(
+            **{
+                "job_uuid": data.get("job_uuid"),
+                "results_uuid": results_uuid,
+                "results_url": results_url,
+                "status": data.get("status"),
+                "version": data.get("version"),
+                "job_json_string": job_json,
+                "latest_job_run_details": latest_job_run_details,
+            }
+        )
+
     def _validate_remote_job_status_types(
         self, status: Union[RemoteJobStatus, List[RemoteJobStatus]]
     ) -> List[RemoteJobStatus]:
@@ -2470,7 +2647,7 @@ class Coop(CoopFunctionsMixin):
         if "signed_url" not in response.json():
             from .exceptions import CoopResponseError
 
-            raise CoopResponseError("No signed url was provided received")
+            raise CoopResponseError("No signed url was provided.")
         signed_url = response.json().get("signed_url")
 
         if signed_url == "":  # it is in old format
@@ -2872,6 +3049,53 @@ class Coop(CoopFunctionsMixin):
         self._resolve_server_response(response)
         return response.json()
 
+    def pay_for_service(
+        self,
+        credits_transferred: int,
+        recipient_username: str,
+        service_name: str,
+    ) -> dict:
+        """
+        Pay for a service.
+
+        This method transfers a specified number of credits from the authenticated user's
+        account to another user's account on the Expected Parrot platform.
+
+        Parameters:
+            credits_transferred (int): The number of credits to transfer to the recipient
+            recipient_username (str): The username of the recipient
+            service_name (str): The name of the service to pay for
+
+        Returns:
+            dict: Information about the transfer transaction, including:
+                - success: Whether the transaction was successful
+                - transaction_id: A unique identifier for the transaction
+                - remaining_credits: The number of credits remaining in the sender's account
+
+        Raises:
+            CoopServerResponseError: If there's an error communicating with the server
+                or if the transfer criteria aren't met (e.g., insufficient credits)
+
+        Example:
+            >>> result = coop.pay_for_service(
+            ...     credits_transferred=100,
+            ...     service_name="service_name",
+            ...     recipient_username="friend_username",
+            ... )
+            >>> print(f"Transfer successful! You have {result['remaining_credits']} credits left.")
+        """
+        response = self._send_server_request(
+            uri="api/v0/users/pay-for-service",
+            method="POST",
+            payload={
+                "cost_credits": credits_transferred,
+                "service_name": service_name,
+                "recipient_username": recipient_username,
+            },
+        )
+        self._resolve_server_response(response)
+        return response.json()
+
     def get_balance(self) -> dict:
         """
         Get the current credit balance for the authenticated user.
@@ -2897,6 +3121,29 @@ class Coop(CoopFunctionsMixin):
         self._resolve_server_response(response)
         return response.json()
 
+    def get_profile(self) -> dict:
+        """
+        Get the current user's profile information.
+
+        This method retrieves the authenticated user's profile information from
+        the Expected Parrot platform using their API key.
+
+        Returns:
+            dict: User profile information including:
+                - username: The user's username
+                - email: The user's email address
+
+        Raises:
+            CoopServerResponseError: If there's an error communicating with the server
+
+        Example:
+            >>> profile = coop.get_profile()
+            >>> print(f"Welcome, {profile['username']}!")
+        """
+        response = self._send_server_request(uri="api/v0/users/profile", method="GET")
+        self._resolve_server_response(response)
+        return response.json()
+
     def login_gradio(self, timeout: int = 120, launch: bool = True, **launch_kwargs):
         """
         Start the EDSL auth token login flow inside a **Gradio** application.
@@ -3174,7 +3421,7 @@ def main():
     job = Jobs.example()
     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"))
+    job_coop_results = coop.new_remote_inference_get(job_coop_object.get("uuid"))
     coop.get(job_coop_results.get("results_uuid"))
 
     import streamlit as st

{edsl-0.1.61 → edsl-0.1.62}/edsl/coop/coop_jobs_objects.py

@@ -26,7 +26,7 @@ class CoopJobsObjects(CoopObjects):
 
         c = Coop()
         job_details = [
-            c.remote_inference_get(obj["uuid"], include_json_string=True)
+            c.new_remote_inference_get(obj["uuid"], include_json_string=True)
             for obj in self
         ]
 
@@ -53,7 +53,7 @@ class CoopJobsObjects(CoopObjects):
 
         for obj in self:
             if obj.get("results_uuid"):
-                result = c.get(obj["results_uuid"])
+                result = c.pull(obj["results_uuid"], expected_object_type="results")
                 results.append(result)
 
         return results

{edsl-0.1.61 → edsl-0.1.62}/edsl/coop/coop_regular_objects.py

@@ -23,4 +23,6 @@ class CoopRegularObjects(CoopObjects):
         from ..coop import Coop
 
         c = Coop()
-        return [c.get(obj["uuid"]) for obj in self]
+        return [
+            c.pull(obj["uuid"], expected_object_type=obj["object_type"]) for obj in self
+        ]

{edsl-0.1.61 → edsl-0.1.62}/edsl/jobs/jobs.py

@@ -1120,7 +1120,7 @@ class Jobs(Base):
             raise CoopValueError(
                 "You must specify both a scenario list and a scenario list method to use scenarios with your survey."
             )
-        elif scenario_list_method is "loop":
+        elif scenario_list_method == "loop":
             questions, long_scenario_list = self.survey.to_long_format(self.scenarios)
 
             # Replace the questions with new ones from the loop method

{edsl-0.1.61 → edsl-0.1.62}/edsl/jobs/remote_inference.py

@@ -176,7 +176,7 @@ class JobsRemoteInferenceHandler:
         from ..coop import Coop
 
         coop = Coop()
-        return coop.remote_inference_get(job_uuid)
+        return coop.new_remote_inference_get(job_uuid)
 
     def _construct_remote_job_fetcher(
         self, testing_simulated_response: Optional[Any] = None
@@ -445,9 +445,9 @@ class JobsRemoteInferenceHandler:
             model_cost_dict["input_cost_credits_with_cache"] = converter.usd_to_credits(
                 input_cost_with_cache
             )
-            model_cost_dict[
-                "output_cost_credits_with_cache"
-            ] = converter.usd_to_credits(output_cost_with_cache)
+            model_cost_dict["output_cost_credits_with_cache"] = (
+                converter.usd_to_credits(output_cost_with_cache)
+            )
         return list(expenses_by_model.values())
 
     def _fetch_results_and_log(

{edsl-0.1.61 → edsl-0.1.62}/edsl/prompts/prompt.py

@@ -305,8 +305,13 @@ class Prompt(PersistenceMixin, RepresentationMixin):
         Returns (rendered_text, captured_variables).
         """
         # Combine replacements.
-        all_replacements = {**primary_replacement, **additional_replacements}
-
+        from ..scenarios import Scenario
+        # This fixed Issue 2027 - the scenario prefix  was not being recoginized in the template
+        if isinstance(primary_replacement, Scenario):
+            additional = {'scenario': primary_replacement.to_dict()}
+        else:
+            additional = {}
+        all_replacements = {**primary_replacement, **additional_replacements, **additional}
         # If no replacements and no Jinja variables, just return the text.
         if not all_replacements and not _find_template_variables(text):
             return text, template_vars.get_all()

{edsl-0.1.61 → edsl-0.1.62}/edsl/questions/question_registry.py

@@ -43,6 +43,7 @@ class Question(metaclass=Meta):
         subclass = get_question_classes.get(question_type, None)
         if subclass is None:
             from .exceptions import QuestionValueError
+
             raise QuestionValueError(
                 f"No question registered with question_type {question_type}"
             )
@@ -65,7 +66,7 @@ class Question(metaclass=Meta):
         from ..coop import Coop
 
         coop = Coop()
-        return coop.get(url_or_uuid, "question")
+        return coop.pull(url_or_uuid, "question")
 
     @classmethod
     def delete(cls, url_or_uuid: Union[str, UUID]):
@@ -146,6 +147,7 @@ def get_question_class(question_type):
     q2c = RegisterQuestionsMeta.question_types_to_classes()
     if question_type not in q2c:
         from .exceptions import QuestionValueError
+
         raise QuestionValueError(
             f"The question type, {question_type}, is not recognized. Recognied types are: {q2c.keys()}"
         )
@@ -171,4 +173,5 @@ question_purpose = {
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()

{edsl-0.1.61 → edsl-0.1.62}/edsl/scenarios/file_store.py

@@ -512,6 +512,75 @@ class FileStore(Scenario):
         )
         return info
 
+    def offload(self, inplace=False) -> "FileStore":
+        """
+        Offloads base64-encoded content from the FileStore by replacing 'base64_string'
+        with 'offloaded'. This reduces memory usage.
+
+        Args:
+            inplace (bool): If True, modify the current FileStore. If False, return a new one.
+
+        Returns:
+            FileStore: The modified FileStore (either self or a new instance).
+        """
+        if inplace:
+            if hasattr(self, "base64_string"):
+                self.base64_string = "offloaded"
+            return self
+        else:
+            # Create a copy and offload it
+            file_store_dict = self.to_dict()
+            if "base64_string" in file_store_dict:
+                file_store_dict["base64_string"] = "offloaded"
+            return self.__class__.from_dict(file_store_dict)
+
+    def save_to_gcs_bucket(self, signed_url: str) -> dict:
+        """
+        Saves the FileStore's file content to a Google Cloud Storage bucket using a signed URL.
+
+        Args:
+            signed_url (str): The signed URL for uploading to GCS bucket
+
+        Returns:
+            dict: Response from the GCS upload operation
+
+        Raises:
+            ValueError: If base64_string is offloaded or missing
+            requests.RequestException: If the upload fails
+        """
+        import requests
+        import base64
+
+        # Check if content is available
+        if not hasattr(self, "base64_string") or self.base64_string == "offloaded":
+            raise ValueError(
+                "File content is not available (offloaded or missing). Cannot upload to GCS."
+            )
+
+        # Decode base64 content to bytes
+        try:
+            file_content = base64.b64decode(self.base64_string)
+        except Exception as e:
+            raise ValueError(f"Failed to decode base64 content: {e}")
+
+        # Prepare headers with proper content type
+        headers = {
+            "Content-Type": self.mime_type or "application/octet-stream",
+            "Content-Length": str(len(file_content)),
+        }
+
+        # Upload to GCS using the signed URL
+        response = requests.put(signed_url, data=file_content, headers=headers)
+        response.raise_for_status()
+
+        return {
+            "status": "success",
+            "status_code": response.status_code,
+            "file_size": len(file_content),
+            "mime_type": self.mime_type,
+            "file_extension": self.suffix,
+        }
+
     @classmethod
     def pull(cls, url_or_uuid: Union[str, UUID]) -> "FileStore":
         """