flwr 1.15.2__py3-none-any.whl → 1.16.0__py3-none-any.whl

flwr/server/superlink/linkstate/utils.py

@@ -15,21 +15,17 @@
 """Utility functions for State."""
 
 
-from logging import ERROR
 from os import urandom
-from typing import Optional, Union
+from typing import Optional
 from uuid import UUID, uuid4
 
-from flwr.common import ConfigsRecord, Context, log, now, serde
+from flwr.common import ConfigsRecord, Context, Error, Message, Metadata, now, serde
 from flwr.common.constant import SUPERLINK_NODE_ID, ErrorCode, Status, SubStatus
 from flwr.common.typing import RunStatus
 
 # pylint: disable=E0611
-from flwr.proto.error_pb2 import Error
 from flwr.proto.message_pb2 import Context as ProtoContext
-from flwr.proto.node_pb2 import Node
 from flwr.proto.recordset_pb2 import ConfigsRecord as ProtoConfigsRecord
-from flwr.proto.task_pb2 import Task, TaskIns, TaskRes
 
 # pylint: enable=E0611
 
@@ -235,165 +231,141 @@ def has_valid_sub_status(status: RunStatus) -> bool:
     return status.sub_status == ""
 
 
-def create_taskres_for_unavailable_taskins(taskins_id: Union[str, UUID]) -> TaskRes:
-    """Generate a TaskRes with a TaskIns unavailable error.
-
-    Parameters
-    ----------
-    taskins_id : Union[str, UUID]
-        The ID of the unavailable TaskIns.
-
-    Returns
-    -------
-    TaskRes
-        A TaskRes with an error code MESSAGE_UNAVAILABLE to indicate that the
-        inquired TaskIns ID cannot be found (due to non-existence or expiration).
-    """
+def create_message_error_unavailable_res_message(ins_metadata: Metadata) -> Message:
+    """Generate an error Message that the SuperLink returns carrying the specified
+    error."""
     current_time = now().timestamp()
-    return TaskRes(
-        task_id=str(uuid4()),
-        group_id="",  # Unknown group ID
-        run_id=0,  # Unknown run ID
-        task=Task(
-            # This function is only called by SuperLink, and thus it's the producer.
-            producer=Node(node_id=SUPERLINK_NODE_ID),
-            consumer=Node(node_id=SUPERLINK_NODE_ID),
-            created_at=current_time,
-            ttl=0,
-            ancestry=[str(taskins_id)],
-            task_type="",  # Unknown message type
-            error=Error(
-                code=ErrorCode.MESSAGE_UNAVAILABLE,
-                reason=MESSAGE_UNAVAILABLE_ERROR_REASON,
-            ),
-        ),
+    ttl = max(ins_metadata.ttl - (current_time - ins_metadata.created_at), 0)
+    metadata = Metadata(
+        run_id=ins_metadata.run_id,
+        message_id=str(uuid4()),
+        src_node_id=SUPERLINK_NODE_ID,
+        dst_node_id=SUPERLINK_NODE_ID,
+        reply_to_message=ins_metadata.message_id,
+        group_id=ins_metadata.group_id,
+        message_type=ins_metadata.message_type,
+        ttl=ttl,
     )
 
+    return Message(
+        metadata=metadata,
+        error=Error(
+            code=ErrorCode.REPLY_MESSAGE_UNAVAILABLE,
+            reason=REPLY_MESSAGE_UNAVAILABLE_ERROR_REASON,
+        ),
+    )
 
-def create_taskres_for_unavailable_taskres(ref_taskins: TaskIns) -> TaskRes:
-    """Generate a TaskRes with a reply message unavailable error from a TaskIns.
 
-    Parameters
-    ----------
-    ref_taskins : TaskIns
-        The reference TaskIns object.
+def create_message_error_unavailable_ins_message(reply_to_message: UUID) -> Message:
+    """Error to indicate that the enquired Message had expired before reply arrived or
+    that it isn't found."""
+    metadata = Metadata(
+        run_id=0,  # Unknown
+        message_id=str(uuid4()),
+        src_node_id=SUPERLINK_NODE_ID,
+        dst_node_id=SUPERLINK_NODE_ID,
+        reply_to_message=str(reply_to_message),
+        group_id="",  # Unknown
+        message_type="",  # Unknown
+        ttl=0,
+    )
 
-    Returns
-    -------
-    TaskRes
-        The generated TaskRes with an error code REPLY_MESSAGE_UNAVAILABLE_ERROR_REASON,
-        indicating that the original TaskRes has expired.
-    """
-    current_time = now().timestamp()
-    ttl = ref_taskins.task.ttl - (current_time - ref_taskins.task.created_at)
-    if ttl < 0:
-        log(ERROR, "Creating TaskRes for TaskIns that exceeds its TTL.")
-        ttl = 0
-    return TaskRes(
-        task_id=str(uuid4()),
-        group_id=ref_taskins.group_id,
-        run_id=ref_taskins.run_id,
-        task=Task(
-            # This function is only called by SuperLink, and thus it's the producer.
-            producer=Node(node_id=SUPERLINK_NODE_ID),
-            consumer=Node(node_id=SUPERLINK_NODE_ID),
-            created_at=current_time,
-            ttl=ttl,
-            ancestry=[ref_taskins.task_id],
-            task_type=ref_taskins.task.task_type,
-            error=Error(
-                code=ErrorCode.REPLY_MESSAGE_UNAVAILABLE,
-                reason=REPLY_MESSAGE_UNAVAILABLE_ERROR_REASON,
-            ),
+    return Message(
+        metadata=metadata,
+        error=Error(
+            code=ErrorCode.MESSAGE_UNAVAILABLE,
+            reason=MESSAGE_UNAVAILABLE_ERROR_REASON,
         ),
     )
 
 
-def has_expired(task_ins_or_res: Union[TaskIns, TaskRes], current_time: float) -> bool:
-    """Check if the TaskIns/TaskRes has expired."""
-    return task_ins_or_res.task.ttl + task_ins_or_res.task.created_at < current_time
+def message_ttl_has_expired(message_metadata: Metadata, current_time: float) -> bool:
+    """Check if the Message has expired."""
+    return message_metadata.ttl + message_metadata.created_at < current_time
 
 
-def verify_taskins_ids(
-    inquired_taskins_ids: set[UUID],
-    found_taskins_dict: dict[UUID, TaskIns],
+def verify_message_ids(
+    inquired_message_ids: set[UUID],
+    found_message_ins_dict: dict[UUID, Message],
     current_time: Optional[float] = None,
     update_set: bool = True,
-) -> dict[UUID, TaskRes]:
-    """Verify found TaskIns and generate error TaskRes for invalid ones.
+) -> dict[UUID, Message]:
+    """Verify found Messages and generate error Messages for invalid ones.
 
     Parameters
     ----------
-    inquired_taskins_ids : set[UUID]
-        Set of TaskIns IDs for which to generate error TaskRes if invalid.
-    found_taskins_dict : dict[UUID, TaskIns]
-        Dictionary containing all found TaskIns indexed by their IDs.
+    inquired_message_ids : set[UUID]
+        Set of Message IDs for which to generate error Message if invalid.
+    found_message_ins_dict : dict[UUID, Message]
+        Dictionary containing all found Message indexed by their IDs.
     current_time : Optional[float] (default: None)
         The current time to check for expiration. If set to `None`, the current time
         will automatically be set to the current timestamp using `now().timestamp()`.
     update_set : bool (default: True)
-        If True, the `inquired_taskins_ids` will be updated to remove invalid ones,
+        If True, the `inquired_message_ids` will be updated to remove invalid ones,
         by default True.
 
     Returns
     -------
-    dict[UUID, TaskRes]
-        A dictionary of error TaskRes indexed by the corresponding TaskIns ID.
+    dict[UUID, Message]
+        A dictionary of error Message indexed by the corresponding ID of the message
+        they are a reply of.
     """
     ret_dict = {}
     current = current_time if current_time else now().timestamp()
-    for taskins_id in list(inquired_taskins_ids):
-        # Generate error TaskRes if the task_ins doesn't exist or has expired
-        taskins = found_taskins_dict.get(taskins_id)
-        if taskins is None or has_expired(taskins, current):
+    for message_id in list(inquired_message_ids):
+        # Generate error message if the inquired message doesn't exist or has expired
+        message_ins = found_message_ins_dict.get(message_id)
+        if message_ins is None or message_ttl_has_expired(
+            message_ins.metadata, current
+        ):
             if update_set:
-                inquired_taskins_ids.remove(taskins_id)
-            taskres = create_taskres_for_unavailable_taskins(taskins_id)
-            ret_dict[taskins_id] = taskres
+                inquired_message_ids.remove(message_id)
+            message_res = create_message_error_unavailable_ins_message(message_id)
+            ret_dict[message_id] = message_res
     return ret_dict
 
 
-def verify_found_taskres(
-    inquired_taskins_ids: set[UUID],
-    found_taskins_dict: dict[UUID, TaskIns],
-    found_taskres_list: list[TaskRes],
+def verify_found_message_replies(
+    inquired_message_ids: set[UUID],
+    found_message_ins_dict: dict[UUID, Message],
+    found_message_res_list: list[Message],
     current_time: Optional[float] = None,
     update_set: bool = True,
-) -> dict[UUID, TaskRes]:
-    """Verify found TaskRes and generate error TaskRes for invalid ones.
+) -> dict[UUID, Message]:
+    """Verify found Message replies and generate error Message for invalid ones.
 
     Parameters
     ----------
-    inquired_taskins_ids : set[UUID]
-        Set of TaskIns IDs for which to generate error TaskRes if invalid.
-    found_taskins_dict : dict[UUID, TaskIns]
-        Dictionary containing all found TaskIns indexed by their IDs.
-    found_taskres_list : dict[TaskIns, TaskRes]
-        List of found TaskRes to be verified.
+    inquired_message_ids : set[UUID]
+        Set of Message IDs for which to generate error Message if invalid.
+    found_message_ins_dict : dict[UUID, Message]
+        Dictionary containing all found instruction Messages indexed by their IDs.
+    found_message_res_list : dict[Message, Message]
+        List of found Message to be verified.
     current_time : Optional[float] (default: None)
         The current time to check for expiration. If set to `None`, the current time
         will automatically be set to the current timestamp using `now().timestamp()`.
     update_set : bool (default: True)
-        If True, the `inquired_taskins_ids` will be updated to remove ones
-        that have a TaskRes, by default True.
+        If True, the `inquired_message_ids` will be updated to remove ones
+        that have a reply Message, by default True.
 
     Returns
     -------
-    dict[UUID, TaskRes]
-        A dictionary of TaskRes indexed by the corresponding TaskIns ID.
+    dict[UUID, Message]
+        A dictionary of Message indexed by the corresponding Message ID.
     """
-    ret_dict: dict[UUID, TaskRes] = {}
+    ret_dict: dict[UUID, Message] = {}
     current = current_time if current_time else now().timestamp()
-    for taskres in found_taskres_list:
-        taskins_id = UUID(taskres.task.ancestry[0])
+    for message_res in found_message_res_list:
+        message_ins_id = UUID(message_res.metadata.reply_to_message)
         if update_set:
-            inquired_taskins_ids.remove(taskins_id)
-        # Check if the TaskRes has expired
-        if has_expired(taskres, current):
-            # No need to insert the error TaskRes
-            taskres = create_taskres_for_unavailable_taskres(
-                found_taskins_dict[taskins_id]
+            inquired_message_ids.remove(message_ins_id)
+        # Check if the reply Message has expired
+        if message_ttl_has_expired(message_res.metadata, current):
+            # No need to insert the error Message
+            message_res = create_message_error_unavailable_res_message(
+                found_message_ins_dict[message_ins_id].metadata
             )
-            taskres.task.delivered_at = now().isoformat()
-        ret_dict[taskins_id] = taskres
+        ret_dict[message_ins_id] = message_res
     return ret_dict

flwr/server/utils/__init__.py

@@ -16,9 +16,9 @@
 
 
 from .tensorboard import tensorboard as tensorboard
-from .validator import validate_task_ins_or_res as validate_task_ins_or_res
+from .validator import validate_message as validate_message
 
 __all__ = [
     "tensorboard",
-    "validate_task_ins_or_res",
+    "validate_message",
 ]

flwr/server/utils/validator.py

@@ -16,93 +16,78 @@
 
 
 import time
-from typing import Union
 
+from flwr.common import Message
 from flwr.common.constant import SUPERLINK_NODE_ID
-from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 
-# pylint: disable-next=too-many-branches,too-many-statements
-def validate_task_ins_or_res(tasks_ins_res: Union[TaskIns, TaskRes]) -> list[str]:
-    """Validate a TaskIns or TaskRes."""
+# pylint: disable-next=too-many-branches
+def validate_message(message: Message, is_reply_message: bool) -> list[str]:
+    """Validate a Message."""
     validation_errors = []
+    metadata = message.metadata
 
-    if tasks_ins_res.task_id != "":
-        validation_errors.append("non-empty `task_id`")
-
-    if not tasks_ins_res.HasField("task"):
-        validation_errors.append("`task` does not set field `task`")
+    if metadata.message_id != "":
+        validation_errors.append("non-empty `metadata.message_id`")
 
     # Created/delivered/TTL/Pushed
     if (
-        tasks_ins_res.task.created_at < 1711497600.0
-    ):  # unix timestamp of 27 March 2024 00h:00m:00s UTC
+        metadata.created_at < 1740700800.0
+    ):  # unix timestamp of 28 February 2025 00h:00m:00s UTC
         validation_errors.append(
-            "`created_at` must be a float that records the unix timestamp "
+            "`metadata.created_at` must be a float that records the unix timestamp "
             "in seconds when the message was created."
         )
-    if tasks_ins_res.task.delivered_at != "":
-        validation_errors.append("`delivered_at` must be an empty str")
-    if tasks_ins_res.task.ttl <= 0:
-        validation_errors.append("`ttl` must be higher than zero")
+    if metadata.delivered_at != "":
+        validation_errors.append("`metadata.delivered_at` must be an empty str")
+    if metadata.ttl <= 0:
+        validation_errors.append("`metadata.ttl` must be higher than zero")
 
     # Verify TTL and created_at time
     current_time = time.time()
-    if tasks_ins_res.task.created_at + tasks_ins_res.task.ttl <= current_time:
-        validation_errors.append("Task TTL has expired")
-
-    # TaskIns specific
-    if isinstance(tasks_ins_res, TaskIns):
-        # Task producer
-        if not tasks_ins_res.task.HasField("producer"):
-            validation_errors.append("`producer` does not set field `producer`")
-        if tasks_ins_res.task.producer.node_id != SUPERLINK_NODE_ID:
-            validation_errors.append(f"`producer.node_id` is not {SUPERLINK_NODE_ID}")
-
-        # Task consumer
-        if not tasks_ins_res.task.HasField("consumer"):
-            validation_errors.append("`consumer` does not set field `consumer`")
-        if tasks_ins_res.task.consumer.node_id == SUPERLINK_NODE_ID:
-            validation_errors.append("consumer MUST provide a valid `node_id`")
+    if metadata.created_at + metadata.ttl <= current_time:
+        validation_errors.append("Message TTL has expired")
 
-        # Content check
-        if tasks_ins_res.task.task_type == "":
-            validation_errors.append("`task_type` MUST be set")
-        if not (
-            tasks_ins_res.task.HasField("recordset")
-            ^ tasks_ins_res.task.HasField("error")
-        ):
-            validation_errors.append("Either `recordset` or `error` MUST be set")
+    # Source node is set and is not zero
+    if not metadata.src_node_id:
+        validation_errors.append("`metadata.src_node_id` is not set.")
 
-        # Ancestors
-        if len(tasks_ins_res.task.ancestry) != 0:
-            validation_errors.append("`ancestry` is not empty")
+    # Destination node is set and is not zero
+    if not metadata.dst_node_id:
+        validation_errors.append("`metadata.dst_node_id` is not set.")
 
-    # TaskRes specific
-    if isinstance(tasks_ins_res, TaskRes):
-        # Task producer
-        if not tasks_ins_res.task.HasField("producer"):
-            validation_errors.append("`producer` does not set field `producer`")
-        if tasks_ins_res.task.producer.node_id == SUPERLINK_NODE_ID:
-            validation_errors.append("producer MUST provide a valid `node_id`")
+    # Message type
+    if metadata.message_type == "":
+        validation_errors.append("`metadata.message_type` MUST be set")
 
-        # Task consumer
-        if not tasks_ins_res.task.HasField("consumer"):
-            validation_errors.append("`consumer` does not set field `consumer`")
-        if tasks_ins_res.task.consumer.node_id != SUPERLINK_NODE_ID:
-            validation_errors.append(f"consumer is not {SUPERLINK_NODE_ID}")
-
-        # Content check
-        if tasks_ins_res.task.task_type == "":
-            validation_errors.append("`task_type` MUST be set")
-        if not (
-            tasks_ins_res.task.HasField("recordset")
-            ^ tasks_ins_res.task.HasField("error")
-        ):
-            validation_errors.append("Either `recordset` or `error` MUST be set")
+    # Content
+    if not message.has_content() != message.has_error():
+        validation_errors.append(
+            "Either message `content` or `error` MUST be set (but not both)"
+        )
 
-        # Ancestors
-        if len(tasks_ins_res.task.ancestry) == 0:
-            validation_errors.append("`ancestry` is empty")
+    # Link respose to original message
+    if not is_reply_message:
+        if metadata.reply_to_message != "":
+            validation_errors.append("`metadata.reply_to_message` MUST not be set.")
+        if metadata.src_node_id != SUPERLINK_NODE_ID:
+            validation_errors.append(
+                f"`metadata.src_node_id` is not {SUPERLINK_NODE_ID} (SuperLink node ID)"
+            )
+        if metadata.dst_node_id == SUPERLINK_NODE_ID:
+            validation_errors.append(
+                f"`metadata.dst_node_id` is {SUPERLINK_NODE_ID} (SuperLink node ID)"
+            )
+    else:
+        if metadata.reply_to_message == "":
+            validation_errors.append("`metadata.reply_to_message` MUST be set.")
+        if metadata.src_node_id == SUPERLINK_NODE_ID:
+            validation_errors.append(
+                f"`metadata.src_node_id` is {SUPERLINK_NODE_ID} (SuperLink node ID)"
+            )
+        if metadata.dst_node_id != SUPERLINK_NODE_ID:
+            validation_errors.append(
+                f"`metadata.dst_node_id` is not {SUPERLINK_NODE_ID} (SuperLink node ID)"
+            )
 
     return validation_errors

flwr/server/workflow/default_workflows.py

@@ -64,10 +64,13 @@ class DefaultWorkflow:
             )
 
         # Start the thread updating nodes
-        thread, f_stop = start_update_client_manager_thread(
+        thread, f_stop, c_done = start_update_client_manager_thread(
             driver, context.client_manager
         )
 
+        # Wait until the node registration done
+        c_done.wait()
+
         # Initialize parameters
         log(INFO, "[INIT]")
         default_init_params_workflow(driver, context)

flwr/server/workflow/secure_aggregation/secaggplus_workflow.py

@@ -367,7 +367,7 @@ class SecAggPlusWorkflow:
 
         # Send setup configuration to clients
         cfgs_record = ConfigsRecord(sa_params_dict)  # type: ignore
-        content = RecordSet(configs_records={RECORD_KEY_CONFIGS: cfgs_record})
+        content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
 
         def make(nid: int) -> Message:
             return driver.create_message(
@@ -417,7 +417,7 @@ class SecAggPlusWorkflow:
                 {str(nid): state.nid_to_publickeys[nid] for nid in neighbours}
             )
             cfgs_record[Key.STAGE] = Stage.SHARE_KEYS
-            content = RecordSet(configs_records={RECORD_KEY_CONFIGS: cfgs_record})
+            content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
             return driver.create_message(
                 content=content,
                 message_type=MessageType.TRAIN,
@@ -566,7 +566,7 @@ class SecAggPlusWorkflow:
                 Key.DEAD_NODE_ID_LIST: list(neighbours & dead_nids),
             }
             cfgs_record = ConfigsRecord(cfgs_dict)  # type: ignore
-            content = RecordSet(configs_records={RECORD_KEY_CONFIGS: cfgs_record})
+            content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
             return driver.create_message(
                 content=content,
                 message_type=MessageType.TRAIN,

flwr/superexec/app.py

@@ -16,26 +16,12 @@
 
 
 import argparse
-import sys
-from logging import INFO
 
-from flwr.common import log
 from flwr.common.object_ref import load_app, validate
 
 from .executor import Executor
 
 
-def run_superexec() -> None:
-    """Run Flower SuperExec."""
-    log(INFO, "Starting Flower SuperExec")
-
-    sys.exit(
-        "Manually launching the SuperExec is deprecated. Since `flwr 1.13.0` "
-        "the executor service runs in the SuperLink. Launching it manually is not "
-        "recommended."
-    )
-
-
 def load_executor(
     args: argparse.Namespace,
 ) -> Executor:

flwr/superexec/exec_servicer.py

@@ -120,7 +120,7 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
             run_status = state.get_run_status({run_id})[run_id]
             if run_status.status == Status.FINISHED:
                 log(INFO, "All logs for run ID `%s` returned", request.run_id)
-                context.cancel()
+                break
 
             time.sleep(LOG_STREAM_INTERVAL)  # Sleep briefly to avoid busy waiting
 
@@ -163,10 +163,10 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
         )
 
         if update_success:
-            task_ids: set[UUID] = state.get_task_ids_from_run_id(request.run_id)
+            message_ids: set[UUID] = state.get_message_ids_from_run_id(request.run_id)
 
-            # Delete TaskIns and TaskRes for the `run_id`
-            state.delete_tasks(task_ids)
+            # Delete Messages and their replies for the `run_id`
+            state.delete_messages(message_ids)
 
         return StopRunResponse(success=update_success)
 

flwr/superexec/exec_user_auth_interceptor.py

@@ -77,9 +77,11 @@ class ExecUserAuthInterceptor(grpc.ServerInterceptor):  # type: ignore
         ) -> Response:
             call = method_handler.unary_unary or method_handler.unary_stream
             metadata = context.invocation_metadata()
-            if isinstance(
-                request, (GetLoginDetailsRequest, GetAuthTokensRequest)
-            ) or self.auth_plugin.validate_tokens_in_metadata(metadata):
+            if isinstance(request, (GetLoginDetailsRequest, GetAuthTokensRequest)):
+                return call(request, context)  # type: ignore
+
+            valid_tokens, _ = self.auth_plugin.validate_tokens_in_metadata(metadata)
+            if valid_tokens:
                 return call(request, context)  # type: ignore
 
             tokens = self.auth_plugin.refresh_tokens(context.invocation_metadata())

{flwr-1.15.2.dist-info → flwr-1.16.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: flwr
-Version: 1.15.2
+Version: 1.16.0
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning
 Author: The Flower Authors
 Author-email: hello@flower.ai
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.9.2,<4.0.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -16,12 +16,12 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -32,7 +32,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: rest
 Provides-Extra: simulation
-Requires-Dist: cryptography (>=43.0.1,<44.0.0)
+Requires-Dist: cryptography (>=44.0.1,<45.0.0)
 Requires-Dist: grpcio (>=1.62.3,<2.0.0,!=1.65.0)
 Requires-Dist: iterators (>=0.0.2,<0.0.3)
 Requires-Dist: numpy (>=1.26.0,<3.0.0)