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

edsl/coop/coop.py

@@ -273,6 +273,118 @@ class Coop(CoopFunctionsMixin):
 
         return user_stable_version < server_stable_version
 
+    def check_for_updates(self, silent: bool = False) -> Optional[dict]:
+        """
+        Check if there's a newer version of EDSL available.
+
+        Args:
+            silent: If True, don't print any messages to console
+
+        Returns:
+            dict with version info if update is available, None otherwise
+        """
+        try:
+            # Use the new /version/updates endpoint
+            response = self._send_server_request(
+                uri="version/updates", method="GET", timeout=5
+            )
+
+            data = response.json()
+
+            # Extract version information from the response
+            current_version = data.get("current")  # Latest version in use
+            guid_message = data.get("guid_message", "")  # Message about updates
+            force_update = (
+                "force update" in guid_message.lower() if guid_message else False
+            )
+            # Check if update is needed
+            if current_version and self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=current_version,
+            ):
+                update_data = {
+                    "current_version": self._edsl_version,
+                    "latest_version": current_version,
+                    "guid_message": guid_message,
+                    "force_update": force_update,
+                    "update_command": "pip install --upgrade edsl",
+                }
+
+                if not silent:
+                    print("\n" + "=" * 60)
+                    print("📦 EDSL Update Available!")
+                    print(f"Your version: {self._edsl_version}")
+                    print(f"Latest version: {current_version}")
+
+                    # Display the guid message if present
+                    if guid_message:
+                        print(f"\n{guid_message}")
+
+                    # Prompt user for update
+                    prompt_message = "\nDo you want to update now? [Y/n] "
+                    if force_update:
+                        prompt_message = "\n⚠️  FORCE UPDATE REQUIRED - Do you want to update now? [Y/n] "
+
+                    print(prompt_message, end="")
+
+                    try:
+                        user_input = input().strip().lower()
+                        if user_input in ["", "y", "yes"]:
+                            # Actually run the update
+                            print("\nUpdating EDSL...")
+                            import subprocess
+                            import sys
+
+                            try:
+                                # Run pip install --upgrade edsl
+                                result = subprocess.run(
+                                    [
+                                        sys.executable,
+                                        "-m",
+                                        "pip",
+                                        "install",
+                                        "--upgrade",
+                                        "edsl",
+                                    ],
+                                    capture_output=True,
+                                    text=True,
+                                )
+
+                                if result.returncode == 0:
+                                    print(
+                                        "✅ Update successful! Please restart your application."
+                                    )
+                                else:
+                                    print(f"❌ Update failed: {result.stderr}")
+                                    print(
+                                        "You can try updating manually with: pip install --upgrade edsl"
+                                    )
+                            except Exception as e:
+                                print(f"❌ Update failed: {str(e)}")
+                                print(
+                                    "You can try updating manually with: pip install --upgrade edsl"
+                                )
+                        else:
+                            print(
+                                "\nUpdate skipped. You can update later with: pip install --upgrade edsl"
+                            )
+
+                        print("=" * 60 + "\n")
+
+                    except (EOFError, KeyboardInterrupt):
+                        print(
+                            "\nUpdate skipped. You can update later with: pip install --upgrade edsl"
+                        )
+                        print("=" * 60 + "\n")
+
+                return update_data
+
+        except Exception:
+            # Silently fail if we can't check for updates
+            pass
+
+        return None
+
     def _resolve_server_response(
         self, response: requests.Response, check_api_key: bool = True
     ) -> None:
@@ -280,18 +392,35 @@ class Coop(CoopFunctionsMixin):
         Check the response from the server and raise errors as appropriate.
         """
         # Get EDSL version from header
-        # breakpoint()
-        # Commented out as currently unused
-        # server_edsl_version = response.headers.get("X-EDSL-Version")
-
-        # if server_edsl_version:
-        #     if self._user_version_is_outdated(
-        #         user_version_str=self._edsl_version,
-        #         server_version_str=server_edsl_version,
-        #     ):
-        #         print(
-        #             "Please upgrade your EDSL version to access our latest features. Open your terminal and run `pip install --upgrade edsl`"
-        #         )
+        server_edsl_version = response.headers.get("X-EDSL-Version")
+
+        if server_edsl_version:
+            if self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=server_edsl_version,
+            ):
+                # Get additional info from server if available
+                update_info = response.headers.get("X-EDSL-Update-Info", "")
+
+                print("\n" + "=" * 60)
+                print("📦 EDSL Update Available!")
+                print(f"Your version: {self._edsl_version}")
+                print(f"Latest version: {server_edsl_version}")
+                if update_info:
+                    print(f"Update info: {update_info}")
+                print(
+                    "\nYour version is out of date - can we update to latest version? [Y/n]"
+                )
+
+                try:
+                    user_input = input().strip().lower()
+                    if user_input in ["", "y", "yes"]:
+                        print("To update, run: pip install --upgrade edsl")
+                        print("=" * 60 + "\n")
+                except (EOFError, KeyboardInterrupt):
+                    # Handle non-interactive environments
+                    print("To update, run: pip install --upgrade edsl")
+                    print("=" * 60 + "\n")
         if response.status_code >= 400:
             try:
                 message = str(response.json().get("detail"))
@@ -598,7 +727,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 +1074,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 +1194,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 +1347,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 +1583,159 @@ 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 +2775,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 +3177,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 +3249,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 +3549,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/dataset/dataset.py

@@ -1017,6 +1017,53 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         # Save the document
         doc.save(output_file)
 
+    def unique(self) -> "Dataset":
+        """
+        Remove duplicate rows from the dataset.
+        
+        Returns:
+            A new Dataset with duplicate rows removed.
+            
+        Examples:
+            >>> d = Dataset([{'a': [1, 2, 3, 1]}, {'b': [4, 5, 6, 4]}])
+            >>> d.unique().data
+            [{'a': [1, 2, 3]}, {'b': [4, 5, 6]}]
+            
+            >>> d = Dataset([{'x': ['a', 'b', 'a']}, {'y': [1, 2, 1]}])
+            >>> d.unique().data
+            [{'x': ['a', 'b']}, {'y': [1, 2]}]
+            
+            >>> # Dataset with a single column
+            >>> Dataset([{'value': [1, 2, 3, 2, 1, 3]}]).unique().data
+            [{'value': [1, 2, 3]}]
+        """
+        # Convert data to tuples for each row to make them hashable
+        rows = []
+        for i in range(len(self)):
+            row = tuple(entry[list(entry.keys())[0]][i] for entry in self.data)
+            rows.append(row)
+        
+        # Keep track of unique rows and their indices
+        unique_rows = []
+        indices = []
+        
+        # Use a set to track seen rows
+        seen = set()
+        for i, row in enumerate(rows):
+            if row not in seen:
+                seen.add(row)
+                unique_rows.append(row)
+                indices.append(i)
+        
+        # Create a new dataset with only the unique rows
+        new_data = []
+        for entry in self.data:
+            key, values = list(entry.items())[0]
+            new_values = [values[i] for i in indices]
+            new_data.append({key: new_values})
+            
+        return Dataset(new_data)
+
     def expand(self, field: str, number_field: bool = False) -> "Dataset":
         """
         Expand a field containing lists into multiple rows.
@@ -1086,47 +1133,6 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         
         return Dataset(new_data)
 
-    def unique(self) -> "Dataset":
-        """Return a new dataset with only unique observations.
-        
-        Examples:
-            >>> d = Dataset([{'a': [1, 2, 2, 3]}, {'b': [4, 5, 5, 6]}])
-            >>> d.unique().data
-            [{'a': [1, 2, 3]}, {'b': [4, 5, 6]}]
-            
-            >>> d = Dataset([{'x': ['a', 'a', 'b']}, {'y': [1, 1, 2]}])
-            >>> d.unique().data
-            [{'x': ['a', 'b']}, {'y': [1, 2]}]
-        """
-        # Get all column names and values
-        headers, data = self._tabular()
-        
-        # Create a list of unique rows
-        unique_rows = []
-        seen = set()
-        
-        for row in data:
-            # Convert the row to a hashable representation for comparison
-            # We need to handle potential unhashable types
-            try:
-                row_key = tuple(map(lambda x: str(x) if isinstance(x, (list, dict)) else x, row))
-                if row_key not in seen:
-                    seen.add(row_key)
-                    unique_rows.append(row)
-            except:
-                # Fallback for complex objects: compare based on string representation
-                row_str = str(row)
-                if row_str not in seen:
-                    seen.add(row_str)
-                    unique_rows.append(row)
-        
-        # Create a new dataset with unique combinations
-        new_data = []
-        for i, header in enumerate(headers):
-            values = [row[i] for row in unique_rows]
-            new_data.append({header: values})
-        
-        return Dataset(new_data)
 
 
 if __name__ == "__main__":