edsl 0.1.61__py3-none-any.whl → 0.1.62__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.61"
+__version__ = "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/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/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/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/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/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/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/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/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":
         """

edsl/scenarios/scenario.py

@@ -280,6 +280,18 @@ class Scenario(Base, UserDict):
 
         target = self if inplace else Scenario()
 
+        # First check if this Scenario itself has a base64_string (e.g., from FileStore.to_dict())
+        if "base64_string" in self and isinstance(self.get("base64_string"), str):
+            # This is likely a Scenario created from FileStore.to_dict()
+            if inplace:
+                self["base64_string"] = "offloaded"
+            else:
+                # Copy all keys to target
+                for k, v in self.items():
+                    target[k] = v
+                target["base64_string"] = "offloaded"
+            return target
+
         for key, value in self.items():
             if isinstance(value, FileStore):
                 file_store_dict = value.to_dict()
@@ -297,6 +309,227 @@ class Scenario(Base, UserDict):
 
         return target
 
+    def save_to_gcs_bucket(self, signed_url_or_dict) -> dict:
+        """
+        Saves FileStore objects contained within this Scenario to a Google Cloud Storage bucket.
+
+        This method finds all FileStore objects in the Scenario and uploads them to GCS using
+        the provided signed URL(s). If the Scenario itself was created from a FileStore (has
+        base64_string as a top-level key), it uploads that content directly.
+
+        Args:
+            signed_url_or_dict: Either:
+                - str: Single signed URL (for single FileStore or Scenario from FileStore)
+                - dict: Mapping of scenario keys to signed URLs for multiple FileStore objects
+                        e.g., {"video": "signed_url_1", "image": "signed_url_2"}
+
+        Returns:
+            dict: Summary of upload operations performed
+
+        Raises:
+            ValueError: If no uploadable content found or content is offloaded
+            requests.RequestException: If any upload fails
+        """
+        from edsl.scenarios import FileStore
+        import requests
+        import base64
+
+        upload_results = []
+
+        # Case 1: This Scenario was created from a FileStore (has direct base64_string)
+        if "base64_string" in self and isinstance(self.get("base64_string"), str):
+            if self["base64_string"] == "offloaded":
+                raise ValueError("File content is offloaded. Cannot upload to GCS.")
+
+            # For single FileStore scenario, expect string URL
+            if isinstance(signed_url_or_dict, dict):
+                raise ValueError(
+                    "For Scenario created from FileStore, provide a single signed URL string, not a dictionary."
+                )
+
+            signed_url = signed_url_or_dict
+
+            # Get file info from Scenario keys
+            mime_type = self.get("mime_type", "application/octet-stream")
+            suffix = self.get("suffix", "")
+
+            # Decode and upload
+            try:
+                file_content = base64.b64decode(self["base64_string"])
+            except Exception as e:
+                raise ValueError(f"Failed to decode base64 content: {e}")
+
+            headers = {
+                "Content-Type": mime_type,
+                "Content-Length": str(len(file_content)),
+            }
+
+            response = requests.put(signed_url, data=file_content, headers=headers)
+            response.raise_for_status()
+
+            upload_results.append(
+                {
+                    "type": "scenario_filestore_content",
+                    "status": "success",
+                    "status_code": response.status_code,
+                    "file_size": len(file_content),
+                    "mime_type": mime_type,
+                    "file_extension": suffix,
+                }
+            )
+
+        # Case 2: Find FileStore objects in Scenario values
+        else:
+            # Collect all FileStore keys first
+            filestore_keys = [
+                key for key, value in self.items() if isinstance(value, FileStore)
+            ]
+
+            if not filestore_keys:
+                raise ValueError("No FileStore objects found in Scenario to upload.")
+
+            # Handle URL parameter
+            if isinstance(signed_url_or_dict, str):
+                # Single URL provided for multiple FileStore objects - this will cause overwrites
+                if len(filestore_keys) > 1:
+                    raise ValueError(
+                        f"Multiple FileStore objects found ({filestore_keys}) but only one signed URL provided. "
+                        f"Provide a dictionary mapping keys to URLs to avoid overwrites: "
+                        f"{{'{filestore_keys[0]}': 'url1', '{filestore_keys[1]}': 'url2', ...}}"
+                    )
+
+                # Single FileStore object, single URL is fine
+                url_mapping = {filestore_keys[0]: signed_url_or_dict}
+
+            elif isinstance(signed_url_or_dict, dict):
+                # Dictionary of URLs provided
+                missing_keys = set(filestore_keys) - set(signed_url_or_dict.keys())
+                if missing_keys:
+                    raise ValueError(
+                        f"Missing signed URLs for FileStore keys: {list(missing_keys)}"
+                    )
+
+                extra_keys = set(signed_url_or_dict.keys()) - set(filestore_keys)
+                if extra_keys:
+                    raise ValueError(
+                        f"Signed URLs provided for non-FileStore keys: {list(extra_keys)}"
+                    )
+
+                url_mapping = signed_url_or_dict
+
+            else:
+                raise ValueError(
+                    "signed_url_or_dict must be either a string or a dictionary"
+                )
+
+            # Upload each FileStore object
+            for key, value in self.items():
+                if isinstance(value, FileStore):
+                    try:
+                        result = value.save_to_gcs_bucket(url_mapping[key])
+                        result["scenario_key"] = key
+                        result["type"] = "filestore_object"
+                        upload_results.append(result)
+                    except Exception as e:
+                        upload_results.append(
+                            {
+                                "scenario_key": key,
+                                "type": "filestore_object",
+                                "status": "error",
+                                "error": str(e),
+                            }
+                        )
+
+        return {
+            "total_uploads": len(upload_results),
+            "successful_uploads": len(
+                [r for r in upload_results if r.get("status") == "success"]
+            ),
+            "failed_uploads": len(
+                [r for r in upload_results if r.get("status") == "error"]
+            ),
+            "upload_details": upload_results,
+        }
+
+    def get_filestore_info(self) -> dict:
+        """
+        Returns information about FileStore objects present in this Scenario.
+
+        This method is useful for determining how many signed URLs need to be generated
+        and what file extensions/types are present before calling save_to_gcs_bucket().
+
+        Returns:
+            dict: Information about FileStore objects containing:
+                - total_count: Total number of FileStore objects
+                - filestore_keys: List of scenario keys that contain FileStore objects
+                - file_extensions: Dictionary mapping keys to file extensions
+                - file_types: Dictionary mapping keys to MIME types
+                - is_filestore_scenario: Boolean indicating if this Scenario was created from a FileStore
+                - summary: Human-readable summary of files
+
+
+        """
+        from edsl.scenarios import FileStore
+
+        # Check if this Scenario was created from a FileStore
+        is_filestore_scenario = "base64_string" in self and isinstance(
+            self.get("base64_string"), str
+        )
+
+        if is_filestore_scenario:
+            # Single FileStore scenario
+            return {
+                "total_count": 1,
+                "filestore_keys": ["filestore_content"],
+                "file_extensions": {"filestore_content": self.get("suffix", "")},
+                "file_types": {
+                    "filestore_content": self.get(
+                        "mime_type", "application/octet-stream"
+                    )
+                },
+                "is_filestore_scenario": True,
+                "summary": f"Single FileStore content with extension '{self.get('suffix', 'unknown')}'",
+            }
+
+        # Regular Scenario with FileStore objects as values
+        filestore_info = {}
+        file_extensions = {}
+        file_types = {}
+
+        for key, value in self.items():
+            if isinstance(value, FileStore):
+                filestore_info[key] = {
+                    "extension": getattr(value, "suffix", ""),
+                    "mime_type": getattr(
+                        value, "mime_type", "application/octet-stream"
+                    ),
+                    "binary": getattr(value, "binary", True),
+                    "path": getattr(value, "path", "unknown"),
+                }
+                file_extensions[key] = getattr(value, "suffix", "")
+                file_types[key] = getattr(
+                    value, "mime_type", "application/octet-stream"
+                )
+
+        # Generate summary
+        if filestore_info:
+            ext_summary = [f"{key}({ext})" for key, ext in file_extensions.items()]
+            summary = (
+                f"{len(filestore_info)} FileStore objects: {', '.join(ext_summary)}"
+            )
+        else:
+            summary = "No FileStore objects found"
+
+        return {
+            "total_count": len(filestore_info),
+            "filestore_keys": list(filestore_info.keys()),
+            "file_extensions": file_extensions,
+            "file_types": file_types,
+            "is_filestore_scenario": False,
+            "detailed_info": filestore_info,
+            "summary": summary,
+        }
+
     def to_dict(
         self, add_edsl_version: bool = True, offload_base64: bool = False
     ) -> dict:

edsl/scenarios/scenario_source.py

@@ -1334,7 +1334,6 @@ class DelimitedFileSource(Source):
         header_counts = defaultdict(lambda: 0)
         new_header = []
         for h in header:
-            print(header_counts)
             if header_counts[h] >= 1:
                 new_header.append(f"{h}_{header_counts[h]}")
                 warnings.warn(

{edsl-0.1.61.dist-info → edsl-0.1.62.dist-info}/METADATA

@@ -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.61.dist-info → edsl-0.1.62.dist-info}/RECORD

@@ -1,13 +1,13 @@
 edsl/__init__.py,sha256=EkpMsEKqKRbN9Qqcn_y8CjX8OjlWFyhxslLrt3SJY0Q,4827
 edsl/__init__original.py,sha256=PzMzANf98PrSleSThXT4anNkeVqZMdw0tfFonzsoiGk,4446
-edsl/__version__.py,sha256=CjOPJsj7rCFM2zpom_253GmmHGb2RQ8NuZwsEg0ZmF0,23
+edsl/__version__.py,sha256=cwSKWX9cG1qs0I6C99TSkty5QpTa10uiqSeiXnsoOg0,23
 edsl/agents/__init__.py,sha256=AyhfXjygRHT1Pd9w16lcu5Bu0jnBmMPz86aKP1uRL3Y,93
 edsl/agents/agent.py,sha256=scTDLrvO5NAUQD9vGVzrPep9-wVcQoNbnQ0GoB5FgH4,58123
 edsl/agents/agent_list.py,sha256=EV-O1G0Atn1iwpNR78WXLJ-h_kAFpO74LyzCMe_5zLw,26916
 edsl/agents/descriptors.py,sha256=TfFQWJqhqTWyH89DkNmK6qtH3xV2fUyW9FbI5KnZXv0,4592
 edsl/agents/exceptions.py,sha256=7KMAtAHKqlkVkd_iVZC_mWXQnzDPV0V_n2iXaGAQgzc,5661
 edsl/base/__init__.py,sha256=h119NxrAJOV92jnX7ussXNjKFXqzySVGOjMG3G7Zkzc,992
-edsl/base/base_class.py,sha256=qR3-op-tu_Tgwhxc8HJpzIXDHnd2ZFaJOQltRvHN5Ls,50999
+edsl/base/base_class.py,sha256=09icKXkd8J1mDpP1TLpFZvPVCp8YUiY4MOSW-eu3omU,51306
 edsl/base/base_exception.py,sha256=gwk4mNoS3TBe6446NiQeSrUrjUqjlB3_fcDFgV90Dms,7644
 edsl/base/data_transfer_models.py,sha256=JpEnlgdQ5_URixzZUr7MJuAY4U6obPo0rWfzDl39WNg,3934
 edsl/base/enums.py,sha256=46mqtWjeiL6NTsN8j-zGfY8QNOVXO4sVb1p1MjmD1N4,6613
@@ -40,12 +40,12 @@ edsl/conversation/exceptions.py,sha256=DoUCg-ymqGOjOl0cpGT8-sNRVsr3SEwdxGAKtdeZ2
 edsl/conversation/mug_negotiation.py,sha256=do3PTykM6A2cDGOcsohlevRgLpCICoPx8B0WIYe6hy8,2518
 edsl/conversation/next_speaker_utilities.py,sha256=bqr5JglCd6bdLc9IZ5zGOAsmN2F4ERiubSMYvZIG7qk,3629
 edsl/coop/__init__.py,sha256=DU2w1Nu8q6tMAa3xoPC722RrvGhmB_UgUUBJDUywsKY,1542
-edsl/coop/coop.py,sha256=fOBquOYwC3aY5fKSgcjXWp7r4UW6f8s8fv80cYcT6_8,124267
+edsl/coop/coop.py,sha256=p6oBuot318sku3BqUXwQAYKwxHB3viarnloMdut5Nug,135375
 edsl/coop/coop_functions.py,sha256=d31kddfj9MVZaMhqwUvkSIBwrdCTQglIvFWVfUr4NuE,688
-edsl/coop/coop_jobs_objects.py,sha256=_OFPVLKswXY9mKl9b3Y7gxlUhaMZ7GULx5OqyANpecU,1701
+edsl/coop/coop_jobs_objects.py,sha256=Xx6YF1Uk97d3RRhNDe7kN6BA9DXzYn_TWENd6DhZgms,1738
 edsl/coop/coop_objects.py,sha256=_cEspdAxh7BT672poxb0HsjU-QZ4Kthg-tKDvZ6I_v0,859
 edsl/coop/coop_prolific_filters.py,sha256=gSQI25tg2f-ouj3Gh_yMl4ppzMnGYt13kPRg-ICKZ64,6489
-edsl/coop/coop_regular_objects.py,sha256=indDQPeesQjHEX_CkICpJPI7o-R8KX66m9DOR9Z48w8,772
+edsl/coop/coop_regular_objects.py,sha256=kKKHapF1xWx8jzgmFcY66HOr2cIqjYMcBI71Vq3nNN0,836
 edsl/coop/ep_key_handling.py,sha256=X0tskEaYKsRIbFUijaCL69uHYpLJcLbYFITzAu3PGJE,7872
 edsl/coop/exceptions.py,sha256=EY3eNTeJM15VzFnag93hgmiqn4pR3Y-6nS9ixKGIhM8,8874
 edsl/coop/price_fetcher.py,sha256=uvEPgKaSRsFq-ouRl5W9aksawUkJg9Lo7ucSePecwa4,4735
@@ -134,7 +134,7 @@ edsl/jobs/decorators.py,sha256=0Eot9pFPsWmQIJAafNd0f5hdb9RUAFp_hGMmSUTJ_C8,3272
 edsl/jobs/exceptions.py,sha256=5lktTya2VgiBR5Bd977tG2xHdrMjDqhPhQO17O6jIdc,7220
 edsl/jobs/fetch_invigilator.py,sha256=nzXAIulvOvuDpRDEN5TDNmEfikUEwrnS_XCtnYG2uPQ,2795
 edsl/jobs/html_table_job_logger.py,sha256=2ErAIi_Dgv_Y3l-AZ2bPUJO_X8hSrPfeFT9lEjt8X4g,34762
-edsl/jobs/jobs.py,sha256=y7krV7TwVFMho0x13Pwu_MrBUdMXFfyCqCImZRGRtZU,45393
+edsl/jobs/jobs.py,sha256=lQf16XEeDYAoUjbM8AWqEvHT7-S5sKwqIBMcweeY5oI,45393
 edsl/jobs/jobs_checks.py,sha256=bfPJ3hQ4qvRBhyte4g-4J8zExJxJr3nlLHmtVmFPJcQ,5390
 edsl/jobs/jobs_component_constructor.py,sha256=9956UURv3eo-cURNPd4EV8wAQsY-AlEtQRmBu1nCOH8,6982
 edsl/jobs/jobs_interview_constructor.py,sha256=8nIhhwBQWH_aZ9ZWjvRgOL0y2y6juRTb3pVngQ9Cs8g,2017
@@ -143,7 +143,7 @@ edsl/jobs/jobs_remote_inference_logger.py,sha256=4I3DjIzxfWHjWBr7o_JPhj9f8M4LuuP
 edsl/jobs/jobs_runner_status.py,sha256=gW8EA-BAKpBvahqRipzomALEAQizd24aRW8G2y7faLQ,11905
 edsl/jobs/jobs_status_enums.py,sha256=8Kgtr-ffcGGniQ2x5gCOqwURb_HaBWmYcWbUB_KTCY0,214
 edsl/jobs/progress_bar_manager.py,sha256=d8wuZf7SHq3LCA36JIv1sfYymyHFOUsYRSRlRpR6K04,2832
-edsl/jobs/remote_inference.py,sha256=lBPVzctPDxHgwhlgucXnEmB5k4EHsNfzcjoBumcTPqk,24150
+edsl/jobs/remote_inference.py,sha256=yRwFabzuBLrwDkKdEdy8PweHKi7-FnShF7t-5-2aTqI,24156
 edsl/jobs/results_exceptions_handler.py,sha256=VCtnd60xwdFznzGhtXPbxLmyVf3kIjR2419LUJdFjEQ,3053
 edsl/key_management/__init__.py,sha256=JiOJ71Ly9aw-tVYbWZu-qRjsW4QETYMQ9IJjsKgW1DQ,1274
 edsl/key_management/exceptions.py,sha256=dDtoDh1UL52BUBrAlCIc_McgtZCAQkUx6onoSz26qeM,2158
@@ -180,7 +180,7 @@ edsl/plugins/plugin_manager.py,sha256=ifuJLgcySmLvGOc8ka8tSj-3d6ju0NknEK22pLF1L8
 edsl/plugins/plugins_registry.py,sha256=stAaq6vkuurHc3ViHrLj5g2VomMpsLD9ufa-k-HHfgk,5165
 edsl/prompts/__init__.py,sha256=4UREcqKC6SIfYykwZbaCeXI5hEil0u2x5GQKasn_NLU,653
 edsl/prompts/exceptions.py,sha256=AcQCy8JGmS8ODCvRtu4aCH14OEI-oYxF0tX-ZAZ3Puk,4460
-edsl/prompts/prompt.py,sha256=mFCOAEHHKJ5RGMRtdkTlNMmRmsem-XligJjRVlO-PbY,14221
+edsl/prompts/prompt.py,sha256=V_duf2qzvBd_fPZLD2bt1WelAfJQT8H3bJ8WoysqkXI,14537
 edsl/questions/ExceptionExplainer.py,sha256=BgM80FRPJjS_TrY6XaVmlT666MzY9DEagviGQj9-WEQ,2868
 edsl/questions/HTMLQuestion.py,sha256=lx3Sysm6fMZmFc9hifnkGslt7ZBpDEvziM9-IJFMJLU,3238
 edsl/questions/Quick.py,sha256=HRLT2Lmhd1Gj4ggkrpCMYhzeWsRwlQaigu2EzdiXb5Q,1717
@@ -218,7 +218,7 @@ edsl/questions/question_multiple_choice.py,sha256=uTWZ0FGE8czIxmiZ_6mvc8KR5efpat
 edsl/questions/question_multiple_choice_with_other.py,sha256=J0_3V5SfetQzqqVMgTIZ5TUwiY4X-bMCogSqquG0tzQ,23624
 edsl/questions/question_numerical.py,sha256=2b41BzrjcwnrVw98pDWjEQIw7Ge75chlgbbS2Jr25Wg,17549
 edsl/questions/question_rank.py,sha256=6oihp85lujt0EAoc7ZxZZf-3p8m-hqGBqSbJCRDUarM,23195
-edsl/questions/question_registry.py,sha256=oEG29JjO9gji8qZz_Eqr1Oi3XAOTPhWudtWWDIfPvl0,6324
+edsl/questions/question_registry.py,sha256=YsuwHKwBpcYtt-XM8EfprF0lo_79QSJ36abUnAE6ZtE,6328
 edsl/questions/question_top_k.py,sha256=zAscGTBQisYX2jV9l3MCLz1PjziMqBlz81gybc-dot4,3233
 edsl/questions/question_yes_no.py,sha256=nF0RowcQucROyagcaCUi-yOveS8jfoiyOAlgjOfVnc8,2689
 edsl/questions/register_questions_meta.py,sha256=Ykf0zdVaOolI3YOVdEuVwCd3JByiggV008nBfgnBMfI,2697
@@ -291,7 +291,7 @@ edsl/scenarios/directory_scanner.py,sha256=xv-3HHRPsyGa8m6mHpqLjK-UBC-nhG9gz3VC5
 edsl/scenarios/document_chunker.py,sha256=EpB0V0oxLzpKntl00Qa3VZNPS7sg9aXdYyqKxhFFzTM,7680
 edsl/scenarios/exceptions.py,sha256=FeORBm90UthKHDp7cE8I7KJgyA3-pFKNpoivZRr8ifc,10636
 edsl/scenarios/file_methods.py,sha256=LkN7mZsadRaiNhvKPP_jY7OhUMEsfhEEFY-hpnwdplM,2794
-edsl/scenarios/file_store.py,sha256=YmcI9DcHwbTmsYk5RARpAHRuwjfM2RAL3kVjh5WnCn0,32910
+edsl/scenarios/file_store.py,sha256=s4FpEHAjykaI1qd32cXOnv95jX2EIy01AHiELtwZCto,35376
 edsl/scenarios/handlers/__init__.py,sha256=_-A6vXzQPKga7fDyteDt1QPA6lDwmgERJKG8SrdhYxQ,965
 edsl/scenarios/handlers/csv_file_store.py,sha256=kXOms0ph5JJj6jSbpfQ-SZjuT4vvSRhq5AGpv1L4TPQ,1369
 edsl/scenarios/handlers/docx_file_store.py,sha256=KSKAAUIWF2K5xr92nx7UGQ9djgtDX4ke-Eyik8QAdlQ,2155
@@ -309,7 +309,7 @@ edsl/scenarios/handlers/sql_file_store.py,sha256=wa_Qw1-bk-tHhtQrp1IAxSAROygEQ5F
 edsl/scenarios/handlers/sqlite_file_store.py,sha256=rwsfxD5G_XNEa-aRCx6A83lW0i2OiS51EzYsJeTE7ps,4936
 edsl/scenarios/handlers/txt_file_store.py,sha256=oGMqm2X_dWTt0W2e2zDung2i_A_z2mMmm4rrQImnVtU,980
 edsl/scenarios/handlers/webm_file_store.py,sha256=UG3sPwsxbZAjM1H9rbpdkvXMrS3iRbaaN-4VNGh3JX8,3659
-edsl/scenarios/scenario.py,sha256=3LQhJ8QSVaatuV2DZOJwJDRgrwyx2zmOE0B-7AIVTtI,39184
+edsl/scenarios/scenario.py,sha256=W1wWo-wh5hfUb42C8YHRq8Qu2spvgL2clp64bupIPYk,48840
 edsl/scenarios/scenario_join.py,sha256=1r_czZctN7JKbw38bQolKdz0kBaMqhWzo8IsxzHK1TY,5409
 edsl/scenarios/scenario_list.py,sha256=tPpFyNDTiMEkl59DA8VTBgGBDt67f1E8Od5qHMXULzM,88787
 edsl/scenarios/scenario_list_gc_test.py,sha256=VaZBg_GjfSaM92Gj3eiSt3aQ_rECDfD339ZCTqryfdc,4676
@@ -317,7 +317,7 @@ edsl/scenarios/scenario_list_memory_test.py,sha256=l_PeTJkh0MYQoRLIiFOI8hmzEyjf8
 edsl/scenarios/scenario_list_pdf_tools.py,sha256=sehQro5PzJ7Y4Ck9VJ8HTxKN8HSbk3aDipVYuxaJbdI,7686
 edsl/scenarios/scenario_list_source_refactor.md,sha256=LFbkxOgc7eWtsX1zQlfYwqWW4pLJNTTXPP7zsyB3iQY,1554
 edsl/scenarios/scenario_selector.py,sha256=7Hm4DitY7X6tKTAofhMMHIFkZf6qXFSminL2wBrUJ2w,6037
-edsl/scenarios/scenario_source.py,sha256=AIsSmpCg3cVDRp4rDYmqJ_ViH77BxbqOJbZYwfpgPTg,73244
+edsl/scenarios/scenario_source.py,sha256=Uua3bOHCyuYjbnt5dj388iNHqNX99vCyCUhuqCA7Wmg,73211
 edsl/scenarios/tests/test_scenario_list_sources.py,sha256=2JBxBn-l_X22WPTKxMTlU10swkfN1DF6c_2-BONEy_E,2135
 edsl/surveys/__init__.py,sha256=04hdYqBBdb9jtZVkZffbFszr0yzXVPPFiI-XhgZRLu0,327
 edsl/surveys/base.py,sha256=XJHGEbbsH6hlYYkmI4isVLD8guLz8BdhR-eQRL78mc4,1115
@@ -384,8 +384,8 @@ edsl/utilities/restricted_python.py,sha256=248N2p5EWHDSpcK1G-q7DUoJeWy4sB6aO-RV0
 edsl/utilities/template_loader.py,sha256=SCAcnTnxNQ67MNSkmfz7F-S_u2peyGn2j1oRIqi1wfg,870
 edsl/utilities/utilities.py,sha256=irHheAGOnl_6RwI--Hi9StVzvsHcWCqB48PWsWJQYOw,12045
 edsl/utilities/wikipedia.py,sha256=I3Imbz3fzbaoA0ZLDsWUO2YpP_ovvaqtu-yd2Ye1BB0,6933
-edsl-0.1.61.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
-edsl-0.1.61.dist-info/METADATA,sha256=dqV7wxOSMV-w2g7YfKnQV7GkvZB5WQ8ia7WFkV33UZ4,12076
-edsl-0.1.61.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-edsl-0.1.61.dist-info/entry_points.txt,sha256=JnG7xqMtHaQu9BU-yPATxdyCeA48XJpuclnWCqMfIMU,38
-edsl-0.1.61.dist-info/RECORD,,
+edsl-0.1.62.dist-info/LICENSE,sha256=_qszBDs8KHShVYcYzdMz3HNMtH-fKN_p5zjoVAVumFc,1111
+edsl-0.1.62.dist-info/METADATA,sha256=4I8R2M4qeuE3YMXvGNls3yNSvjWnHmx6jkIxZdR8azo,12076
+edsl-0.1.62.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+edsl-0.1.62.dist-info/entry_points.txt,sha256=JnG7xqMtHaQu9BU-yPATxdyCeA48XJpuclnWCqMfIMU,38
+edsl-0.1.62.dist-info/RECORD,,