edsl 0.1.54__py3-none-any.whl → 0.1.56__py3-none-any.whl

edsl/coop/coop_jobs_objects.py

@@ -0,0 +1,59 @@
+import json
+from typing import List
+
+from .coop_objects import CoopObjects
+
+
+class CoopJobsObjects(CoopObjects):
+    """ScenarioList of remote inference job objects returned by the .list() method.
+
+    This class provides specialized functionality for working with remote inference
+    jobs, allowing bulk fetching of jobs.
+    """
+
+    def fetch(self) -> List:
+        """Fetch each job's details using remote_inference_get and deserialize them.
+
+        Returns:
+            list: A list of Jobs objects
+
+        Example:
+            >>> jobs = coop.remote_inference_list()  # Get list of remote jobs
+            >>> job_objects = jobs.fetch()  # Returns list of Jobs objects
+        """
+        from ..coop import Coop
+        from ..jobs import Jobs
+
+        c = Coop()
+        job_details = [
+            c.remote_inference_get(obj["uuid"], include_json_string=True)
+            for obj in self
+        ]
+
+        # Deserialize each job from its JSON string
+        return [
+            Jobs.from_dict(json.loads(details["job_json_string"]))
+            for details in job_details
+        ]
+
+    def fetch_results(self) -> List:
+        """Fetch each job's results using the results_uuid.
+
+        Returns:
+            list: A list of Results objects
+
+        Example:
+            >>> jobs = coop.remote_inference_list()  # Get list of remote jobs
+            >>> results = jobs.fetch_results()  # Returns list of Results objects
+        """
+        from ..coop import Coop
+
+        c = Coop()
+        results = []
+
+        for obj in self:
+            if obj.get("results_uuid"):
+                result = c.get(obj["results_uuid"])
+                results.append(result)
+
+        return results

edsl/coop/coop_objects.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from typing import Optional, List
+from ..scenarios import ScenarioList
+
+
+class CoopObjects(ScenarioList, ABC):
+    """Base class for Coop object collections.
+
+    This abstract class extends ScenarioList to provide common functionality
+    for working with collections of Coop objects.
+    """
+
+    def __init__(
+        self, data: Optional[list] = None, codebook: Optional[dict[str, str]] = None
+    ):
+        super().__init__(data, codebook)
+
+    @abstractmethod
+    def fetch(self) -> List:
+        """Fetch each object in the list and return them as EDSL objects.
+
+        Returns:
+            list: A list of instantiated EDSL objects
+
+        Example:
+            >>> objects = coop.list("some_type")
+            >>> fetched_objects = objects.fetch()  # Returns list of appropriate objects
+        """
+        pass

edsl/coop/coop_regular_objects.py

@@ -0,0 +1,26 @@
+from typing import List
+
+from .coop_objects import CoopObjects
+
+
+class CoopRegularObjects(CoopObjects):
+    """ScenarioList of regular Coop objects returned by the .list() method.
+
+    This class provides specialized functionality for working with regular
+    Coop objects like questions, surveys, scenarios, etc.
+    """
+
+    def fetch(self) -> List:
+        """Fetch each object in the list and return them as EDSL objects.
+
+        Returns:
+            list: A list of EDSL objects (e.g., Survey, Question, etc.)
+
+        Example:
+            >>> objects = coop.list("survey")
+            >>> surveys = objects.fetch()  # Returns list of Survey objects
+        """
+        from ..coop import Coop
+
+        c = Coop()
+        return [c.get(obj["uuid"]) for obj in self]

edsl/coop/utils.py

@@ -45,6 +45,9 @@ RemoteJobStatus = Literal[
     "running",
     "completed",
     "failed",
+    "cancelled",
+    "cancelling",
+    "partial_failed",
 ]
 
 VisibilityType = Literal[
@@ -57,18 +60,18 @@ VisibilityType = Literal[
 class ObjectRegistry:
     """
     Registry that maps between EDSL class types and their cloud storage object types.
-    
+
     This utility class maintains a bidirectional mapping between EDSL Python classes
     (like Survey, Agent, Results) and their corresponding object type identifiers
     used in the cloud storage system. It enables the proper serialization,
     deserialization, and type checking for objects stored in Expected Parrot's
     cloud services.
-    
+
     The registry is used by the Coop client to:
     1. Determine the correct object type when uploading EDSL objects
     2. Instantiate the correct class when downloading objects
     3. Validate that retrieved objects match expected types
-    
+
     Attributes:
         objects (list): List of mappings between object types and EDSL classes
         object_type_to_edsl_class (dict): Maps object type strings to EDSL classes
@@ -88,7 +91,7 @@ class ObjectRegistry:
         {"object_type": "scenario_list", "edsl_class": ScenarioList},
         {"object_type": "survey", "edsl_class": Survey},
     ]
-    
+
     # Create mappings for efficient lookups
     object_type_to_edsl_class = {o["object_type"]: o["edsl_class"] for o in objects}
     edsl_class_to_object_type = {
@@ -99,19 +102,19 @@ class ObjectRegistry:
     def get_object_type_by_edsl_class(cls, edsl_object: EDSLObject) -> ObjectType:
         """
         Get the object type identifier for an EDSL class or instance.
-        
+
         This method determines the appropriate object type string for a given EDSL class
         or instance, which is needed when storing the object in the cloud.
-        
+
         Parameters:
             edsl_object (EDSLObject): An EDSL class (type) or instance
-            
+
         Returns:
             ObjectType: The corresponding object type string (e.g., "survey", "agent")
-            
+
         Raises:
             ValueError: If no mapping exists for the provided object
-            
+
         Notes:
             - Special handling for Question classes, which all map to "question"
             - Works with both class types and instances
@@ -121,15 +124,16 @@ class ObjectRegistry:
             edsl_class_name = edsl_object.__name__
         else:
             edsl_class_name = type(edsl_object).__name__
-            
+
         # Special handling for question classes
         if edsl_class_name.startswith("Question"):
             edsl_class_name = "QuestionBase"
-            
+
         # Look up the object type
         object_type = cls.edsl_class_to_object_type.get(edsl_class_name)
         if object_type is None:
             from .exceptions import CoopValueError
+
             raise CoopValueError(f"Object type not found for {edsl_object=}")
         return object_type
 
@@ -137,22 +141,23 @@ class ObjectRegistry:
     def get_edsl_class_by_object_type(cls, object_type: ObjectType) -> EDSLObject:
         """
         Get the EDSL class for a given object type identifier.
-        
+
         This method returns the appropriate EDSL class for a given object type string,
         which is needed when retrieving objects from the cloud.
-        
+
         Parameters:
             object_type (ObjectType): The object type string (e.g., "survey", "agent")
-            
+
         Returns:
             EDSLObject: The corresponding EDSL class
-            
+
         Raises:
             ValueError: If no mapping exists for the provided object type
         """
         EDSL_class = cls.object_type_to_edsl_class.get(object_type)
         if EDSL_class is None:
             from .exceptions import CoopValueError
+
             raise CoopValueError(f"EDSL class not found for {object_type=}")
         return EDSL_class
 
@@ -164,18 +169,18 @@ class ObjectRegistry:
     ) -> dict:
         """
         Get a filtered registry of EDSL classes.
-        
+
         This method returns a dictionary of EDSL classes, optionally excluding
         classes that are already registered elsewhere or explicitly excluded.
-        
+
         Parameters:
             subclass_registry (dict, optional): Dictionary of classes to exclude
                 because they are already registered elsewhere
             exclude_classes (list, optional): List of class names to explicitly exclude
-            
+
         Returns:
             dict: Dictionary mapping class names to EDSL classes
-            
+
         Notes:
             - This method is useful for building registries of classes that
               can be serialized and stored in the cloud