Merge remote-tracking branch 'origin/main' into autoscaling

Author: ianmkenney

alchemiscale/compute/api.py

@@ -327,7 +327,7 @@ def retrieve_task_transformation(
 
     if protocoldagresultref_sk:
         protocoldagresultref = n4js.get_gufe(protocoldagresultref_sk)
-        pdr_sk = ScopedKey(gufe_key=protocoldagresultref.obj_key, **sk.scope.dict())
+        pdr_sk = ScopedKey(gufe_key=protocoldagresultref.obj_key, **sk.scope.to_dict())
 
         # we keep this as a string to avoid useless deserialization/reserialization here
         try:

alchemiscale/compute/client.py

@@ -72,7 +72,7 @@ def query_taskhubs(
             taskhubs = []
 
         for scope in scopes:
-            params = dict(return_gufe=return_gufe, **scope.dict())
+            params = dict(return_gufe=return_gufe, **scope.to_dict())
             if return_gufe:
                 taskhubs.update(self._query_resource("/taskhubs", params=params))
             else:
@@ -104,7 +104,7 @@ def claim_tasks(
     ):
         """Claim Tasks from TaskHubs within a list of Scopes."""
         data = dict(
-            scopes=[scope.dict() for scope in scopes],
+            scopes=[scope.to_dict() for scope in scopes],
             compute_service_id=str(compute_service_id),
             count=count,
             protocols=protocols,

alchemiscale/interface/api.py

@@ -1136,7 +1136,7 @@ def get_protocoldagresult(
             detail=str(e),
         )
 
-    pdr_sk = ScopedKey(gufe_key=protocoldagresultref.obj_key, **sk.scope.dict())
+    pdr_sk = ScopedKey(gufe_key=protocoldagresultref.obj_key, **sk.scope.to_dict())
 
     # we leave each ProtocolDAGResult in string form to avoid
     # deserializing/reserializing here; just passing through to client

alchemiscale/interface/client.py

@@ -84,7 +84,7 @@ def get_scoped_key(self, obj: GufeTokenizable, scope: Scope) -> ScopedKey:
         )
 
         if scope.specific():
-            return ScopedKey(gufe_key=obj.key, **scope.dict())
+            return ScopedKey(gufe_key=obj.key, **scope.to_dict())
         else:
             raise ValueError(
                 "Scope for a ScopedKey must be specific; it cannot contain wildcards."
@@ -143,11 +143,11 @@ def create_network(
 
         state = NetworkStateEnum(state)
 
-        sk = ScopedKey(gufe_key=network.key, **scope.dict())
+        sk = ScopedKey(gufe_key=network.key, **scope.to_dict())
 
         def post():
             keyed_chain = KeyedChain.gufe_to_keyed_chain_rep(network)
-            data = dict(network=keyed_chain, scope=scope.dict(), state=state.value)
+            data = dict(network=keyed_chain, scope=scope.to_dict(), state=state.value)
             return self._post_resource("/networks", data, compress=compress)
 
         if visualize:
@@ -286,7 +286,7 @@ def query_networks(
         if isinstance(state, NetworkStateEnum):
             state = state.value
 
-        params = dict(name=name, **scope.dict(), state=state)
+        params = dict(name=name, **scope.to_dict(), state=state)
 
         return self._query_resource("/networks", params=params)
 
@@ -304,7 +304,7 @@ def query_transformations(
         if scope is None:
             scope = Scope()
 
-        params = dict(name=name, **scope.dict())
+        params = dict(name=name, **scope.to_dict())
 
         return self._query_resource("/transformations", params=params)
 
@@ -322,7 +322,7 @@ def query_chemicalsystems(
         if scope is None:
             scope = Scope()
 
-        params = dict(name=name, **scope.dict())
+        params = dict(name=name, **scope.to_dict())
 
         return self._query_resource("/chemicalsystems", params=params)
 
@@ -723,7 +723,7 @@ def create_tasks(
 
         """
         if extends:
-            extends = extends.dict()
+            extends = extends.to_dict()
 
         data = dict(extends=extends, count=count)
         task_sks = self._post_resource(f"/transformations/{transformation}/tasks", data)
@@ -801,7 +801,7 @@ def query_tasks(
         if scope is None:
             scope = Scope()
 
-        params = dict(status=status, **scope.dict())
+        params = dict(status=status, **scope.to_dict())
 
         return self._query_resource("/tasks", params=params)
 
@@ -1139,7 +1139,7 @@ def action_tasks(
             will be returned in its place.
 
         """
-        data = dict(tasks=[t.dict() for t in tasks], weight=weight)
+        data = dict(tasks=[t.to_dict() for t in tasks], weight=weight)
         actioned_sks = self._post_resource(f"/networks/{network}/tasks/action", data)
 
         return [ScopedKey.from_str(i) if i is not None else None for i in actioned_sks]
@@ -1169,7 +1169,7 @@ def cancel_tasks(
             be returned in its place.
 
         """
-        data = dict(tasks=[t.dict() for t in tasks])
+        data = dict(tasks=[t.to_dict() for t in tasks])
         canceled_sks = self._post_resource(f"/networks/{network}/tasks/cancel", data)
 
         return [ScopedKey.from_str(i) if i is not None else None for i in canceled_sks]
@@ -1246,7 +1246,7 @@ async def _set_task_status(
         self, tasks: list[ScopedKey], status: TaskStatusEnum
     ) -> list[ScopedKey | None]:
         """Set the statuses for many Tasks"""
-        data = dict(tasks=[t.dict() for t in tasks], status=status.value)
+        data = dict(tasks=[t.to_dict() for t in tasks], status=status.value)
         tasks_updated = await self._post_resource_async(
             "/bulk/tasks/status/set", data=data
         )
@@ -1290,7 +1290,7 @@ def set_tasks_status(
 
     async def _get_task_status(self, tasks: list[ScopedKey]) -> list[TaskStatusEnum]:
         """Get the statuses for many Tasks"""
-        data = dict(tasks=[t.dict() for t in tasks])
+        data = dict(tasks=[t.to_dict() for t in tasks])
         statuses = await self._post_resource_async("/bulk/tasks/status/get", data=data)
         return statuses
 
@@ -1319,7 +1319,7 @@ def get_tasks_status(
     async def _set_task_priority(
         self, tasks: list[ScopedKey], priority: int
     ) -> list[ScopedKey | None]:
-        data = dict(tasks=[t.dict() for t in tasks], priority=priority)
+        data = dict(tasks=[t.to_dict() for t in tasks], priority=priority)
         tasks_updated = await self._post_resource_async(
             "/bulk/tasks/priority/set", data=data
         )
@@ -1360,7 +1360,7 @@ def set_tasks_priority(
 
     async def _get_task_priority(self, tasks: list[ScopedKey]) -> list[int]:
         """Get the priority for many Tasks"""
-        data = dict(tasks=[t.dict() for t in tasks])
+        data = dict(tasks=[t.to_dict() for t in tasks])
         priorities = await self._post_resource_async(
             "/bulk/tasks/priority/get", data=data
         )

alchemiscale/models.py

@@ -120,6 +120,9 @@ def specific(self) -> bool:
         """Return `True` if this Scope has no unspecified elements."""
         return all(self.to_tuple())
 
+    def to_dict(self) -> dict:
+        return self.model_dump()
+
 
 class InvalidGufeKeyError(ValueError): ...
 
@@ -208,7 +211,7 @@ def qualname(self):
         return self.gufe_key.split("-")[0]
 
     def to_dict(self):
-        return self.dict()
+        return self.model_dump()
 
     @classmethod
     def from_dict(cls, d):

alchemiscale/security/models.py

@@ -25,6 +25,9 @@ class CredentialedEntity(BaseModel):
     hashed_key: str
     expires: datetime.datetime | None = None
 
+    def to_dict(self):
+        return self.model_dump()
+
 
 class ScopedIdentity(BaseModel):
     identifier: str

alchemiscale/storage/models.py

@@ -46,7 +46,7 @@ def from_now(cls, identifier: ComputeServiceID):
         )
 
     def to_dict(self):
-        dct = self.dict()
+        dct = self.model_dump()
         dct["identifier"] = str(self.identifier)
 
         return dct

alchemiscale/storage/statestore.py

@@ -362,7 +362,9 @@ def process_keyed_dict(gufe_key, kd):
                         node[key] = value
 
             node["_gufe_key"] = str(gufe_key)
-            node["_scoped_key"] = str(ScopedKey(gufe_key=str(gufe_key), **scope.dict()))
+            node["_scoped_key"] = str(
+                ScopedKey(gufe_key=str(gufe_key), **scope.to_dict())
+            )
             node.update(
                 {
                     "_org": scope.org,
@@ -379,7 +381,7 @@ def process_keyed_dict(gufe_key, kd):
             add_previous_node(gufe_key, node)
 
         subgraph = Subgraph(None, relationships)
-        scoped_key = ScopedKey(gufe_key=node["_gufe_key"], **scope.dict())
+        scoped_key = ScopedKey(gufe_key=node["_gufe_key"], **scope.to_dict())
         return subgraph, node, scoped_key
 
     def _subgraph_to_gufe(
@@ -3848,7 +3850,7 @@ def create_credentialed_entity(self, entity: CredentialedEntity):
         then this will overwrite its properties, including credential.
 
         """
-        node = Node("CredentialedEntity", entity.__class__.__name__, **entity.dict())
+        node = Node("CredentialedEntity", entity.__class__.__name__, **entity.to_dict())
 
         with self.transaction() as tx:
             merge_subgraph(

alchemiscale/tests/integration/compute/client/test_compute_client.py

@@ -237,7 +237,7 @@ def test_get_task_transformation(
         # register compute service id
         compute_client.register(compute_service_id)
 
-        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.dict())
+        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.to_dict())
 
         taskhub_sk = n4js_preloaded.get_taskhub(an_sk)
 
@@ -271,8 +271,8 @@ def test_set_task_result(
         # register compute service id
         compute_client.register(compute_service_id)
 
-        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.dict())
-        tf_sk = ScopedKey(gufe_key=transformation.key, **scope_test.dict())
+        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.to_dict())
+        tf_sk = ScopedKey(gufe_key=transformation.key, **scope_test.to_dict())
         taskhub_sk = n4js_preloaded.get_taskhub(an_sk)
 
         # claim our first task
@@ -322,8 +322,8 @@ def test_set_task_result_legacy(
         # register compute service id
         compute_client.register(compute_service_id)
 
-        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.dict())
-        tf_sk = ScopedKey(gufe_key=transformation.key, **scope_test.dict())
+        an_sk = ScopedKey(gufe_key=network_tyk2.key, **scope_test.to_dict())
+        tf_sk = ScopedKey(gufe_key=transformation.key, **scope_test.to_dict())
         taskhub_sk = n4js_preloaded.get_taskhub(an_sk)
 
         # claim our first task
@@ -424,7 +424,7 @@ def test_set_task_result_failure(
         # register compute service id
         compute_client.register(compute_service_id)
 
-        tf_sk = ScopedKey(gufe_key=transformation_failure.key, **scope_test.dict())
+        tf_sk = ScopedKey(gufe_key=transformation_failure.key, **scope_test.to_dict())
 
         # add a network with a transformation that will always fail
         an_sk, taskhub_sk, _ = n4js_preloaded.assemble_network(

alchemiscale/tests/integration/interface/client/test_client.py

@@ -212,7 +212,7 @@ def test_check_exists(
 
         # check that an AlchemicalNetwork that doesn't exist shows as not existing
         an_sk_nonexistent = ScopedKey(
-            gufe_key=GufeKey("AlchemicalNetwork-lol"), **scope_test.dict()
+            gufe_key=GufeKey("AlchemicalNetwork-lol"), **scope_test.to_dict()
         )
         assert not user_client.check_exists(an_sk_nonexistent)