flwr-nightly 1.5.0.dev20230608__py3-none-any.whl → 1.5.0.dev20230615__py3-none-any.whl

flwr/server/app.py

@@ -66,8 +66,8 @@ DATABASE = ":flwr-in-memory-state:"
 class ServerConfig:
     """Flower server config.
 
-    All attributes have default values which allows users to configure
-    just the ones they care about.
+    All attributes have default values which allows users to configure just the ones
+    they care about.
     """
 
     num_rounds: int = 1
@@ -236,7 +236,6 @@ def run_fl(
 
 def run_driver_api() -> None:
     """Run Flower server (Driver API)."""
-
     log(INFO, "Starting Flower server (Driver API)")
     event(EventType.RUN_DRIVER_API_ENTER)
     args = _parse_args_driver().parse_args()
@@ -270,7 +269,6 @@ def run_driver_api() -> None:
 
 def run_fleet_api() -> None:
     """Run Flower server (Fleet API)."""
-
     log(INFO, "Starting Flower server (Fleet API)")
     event(EventType.RUN_FLEET_API_ENTER)
     args = _parse_args_fleet().parse_args()
@@ -352,7 +350,6 @@ def run_fleet_api() -> None:
 # pylint: disable=too-many-branches
 def run_server() -> None:
     """Run Flower server (Driver API and Fleet API)."""
-
     log(INFO, "Starting Flower server")
     event(EventType.RUN_SERVER_ENTER)
     args = _parse_args_server().parse_args()
@@ -462,10 +459,9 @@ def _register_exit_handlers(
     ) -> None:
         """Exit handler to be registered with signal.signal.
 
-        When called will reset signal handler to original signal handler
-        from default_handlers.
+        When called will reset signal handler to original signal handler from
+        default_handlers.
         """
-
         # Reset to default handler
         signal(signalnum, default_handlers[signalnum])
 
@@ -498,7 +494,6 @@ def _run_driver_api_grpc(
     state_factory: StateFactory,
 ) -> grpc.Server:
     """Run Driver API (gRPC, request-response)."""
-
     # Create Driver API gRPC server
     driver_servicer: grpc.Server = DriverServicer(
         state_factory=state_factory,
@@ -522,7 +517,6 @@ def _run_fleet_api_grpc_bidi(
     state_factory: StateFactory,
 ) -> grpc.Server:
     """Run Fleet API (gRPC, bidirectional streaming)."""
-
     # DriverClientManager
     driver_client_manager = DriverClientManager(
         state_factory=state_factory,
@@ -551,7 +545,6 @@ def _run_fleet_api_grpc_rere(
     state_factory: StateFactory,
 ) -> grpc.Server:
     """Run Fleet API (gRPC, request-response)."""
-
     # Create Fleet API gRPC server
     fleet_servicer = FleetServicer(
         state=state_factory.state(),

flwr/server/client_manager.py

@@ -92,6 +92,13 @@ class SimpleClientManager(ClientManager):
         self._cv = threading.Condition()
 
     def __len__(self) -> int:
+        """Return the number of available clients.
+
+        Returns
+        -------
+        num_available : int
+            The number of currently available clients.
+        """
         return len(self.clients)
 
     def num_available(self) -> int:

flwr/server/client_proxy.py

@@ -48,7 +48,7 @@ class ClientProxy(ABC):
         ins: GetPropertiesIns,
         timeout: Optional[float],
     ) -> GetPropertiesRes:
-        """Returns the client's properties."""
+        """Return the client's properties."""
 
     @abstractmethod
     def get_parameters(

flwr/server/criterion.py

@@ -21,8 +21,7 @@ from .client_proxy import ClientProxy
 
 
 class Criterion(ABC):
-    """Abstract class which allows subclasses to implement criterion
-    sampling."""
+    """Abstract class which allows subclasses to implement criterion sampling."""
 
     @abstractmethod
     def select(self, client: ClientProxy) -> bool:

flwr/server/fleet/grpc_bidi/flower_service_servicer.py

@@ -78,7 +78,9 @@ class FlowerServiceServicer(transport_pb2_grpc.FlowerServiceServicer):
         request_iterator: Iterator[ClientMessage],
         context: grpc.ServicerContext,
     ) -> Iterator[ServerMessage]:
-        """Invoked by each gRPC client which participates in the network.
+        """Facilitate bi-directional streaming of messages between server and client.
+
+        Invoked by each gRPC client which participates in the network.
 
         Protocol:
         - The first message is sent from the server to the client

flwr/server/fleet/grpc_bidi/grpc_bridge.py

@@ -80,8 +80,7 @@ class GrpcBridge:
     def _transition(self, next_status: Status) -> None:
         """Validate status transition and set next status.
 
-        The caller of the transition method will have to aquire
-        conditional variable.
+        The caller of the transition method will have to aquire conditional variable.
         """
         if next_status == Status.CLOSED:
             self._status = next_status

flwr/server/fleet/grpc_bidi/grpc_client_proxy.py

@@ -40,7 +40,7 @@ class GrpcClientProxy(ClientProxy):
         ins: common.GetPropertiesIns,
         timeout: Optional[float],
     ) -> common.GetPropertiesRes:
-        """Requests client's set of internal properties."""
+        """Request client's set of internal properties."""
         get_properties_msg = serde.get_properties_ins_to_proto(ins)
         res_wrapper: ResWrapper = self.bridge.request(
             ins_wrapper=InsWrapper(

flwr/server/fleet/grpc_bidi/grpc_server.py

@@ -130,7 +130,6 @@ def start_grpc_server(  # pylint: disable=too-many-arguments
     >>>     ),
     >>> )
     """
-
     servicer = FlowerServiceServicer(client_manager)
     add_servicer_to_server_fn = add_FlowerServiceServicer_to_server
 
@@ -160,7 +159,7 @@ def generic_create_grpc_server(  # pylint: disable=too-many-arguments
     keepalive_time_ms: int = 210000,
     certificates: Optional[Tuple[bytes, bytes, bytes]] = None,
 ) -> grpc.Server:
-    """Generic function to create a gRPC server with a single servicer.
+    """Create a gRPC server with a single servicer.
 
     Parameters
     ----------
@@ -210,7 +209,6 @@ def generic_create_grpc_server(  # pylint: disable=too-many-arguments
     server : grpc.Server
         A non-running instance of a gRPC server.
     """
-
     # Deconstruct tuple into servicer and function
     servicer, add_servicer_to_server_fn = servicer_and_add_fn
 

flwr/server/fleet/grpc_bidi/ins_scheduler.py

@@ -123,7 +123,6 @@ def _call_client_proxy(
     client_proxy: ClientProxy, server_message: ServerMessage, timeout: Optional[float]
 ) -> ClientMessage:
     """."""
-
     # pylint: disable=too-many-locals
 
     field = server_message.WhichOneof("msg")

flwr/server/fleet/message_handler/message_handler.py

@@ -31,7 +31,6 @@ from flwr.server.state import State
 
 def pull_task_ins(request: PullTaskInsRequest, state: State) -> PullTaskInsResponse:
     """Pull TaskIns handler."""
-
     # Get node_id if client node is not anonymous
     node = request.node  # pylint: disable=no-member
     node_id: Optional[int] = None if node.anonymous else node.node_id
@@ -48,7 +47,6 @@ def pull_task_ins(request: PullTaskInsRequest, state: State) -> PullTaskInsRespo
 
 def push_task_res(request: PushTaskResRequest, state: State) -> PushTaskResResponse:
     """Push TaskRes handler."""
-
     # pylint: disable=no-member
     task_res: TaskRes = request.task_res_list[0]
     # pylint: enable=no-member

flwr/server/history.py

@@ -73,6 +73,21 @@ class History:
             self.metrics_centralized[key].append((server_round, metrics[key]))
 
     def __repr__(self) -> str:
+        """Create a representation of History.
+
+        The representation consists of the following data (for each round) if present:
+
+        * distributed loss.
+        * centralized loss.
+        * distributed training metrics.
+        * distributed evaluation metrics.
+        * centralized metrics.
+
+        Returns
+        -------
+        representation : str
+            The string representation of the history object.
+        """
         rep = ""
         if self.losses_distributed:
             rep += "History (loss, distributed):\n" + reduce(

flwr/server/server.py

@@ -161,7 +161,6 @@ class Server:
         Tuple[Optional[float], Dict[str, Scalar], EvaluateResultsAndFailures]
     ]:
         """Validate current global model on a number of clients."""
-
         # Get clients and their respective instructions from strategy
         client_instructions = self.strategy.configure_evaluate(
             server_round=server_round,
@@ -210,7 +209,6 @@ class Server:
         Tuple[Optional[Parameters], Dict[str, Scalar], FitResultsAndFailures]
     ]:
         """Perform a single round of federated averaging."""
-
         # Get clients and their respective instructions from strategy
         client_instructions = self.strategy.configure_fit(
             server_round=server_round,
@@ -266,7 +264,6 @@ class Server:
 
     def _get_initial_parameters(self, timeout: Optional[float]) -> Parameters:
         """Get initial parameters from one of the available clients."""
-
         # Server-side parameter initialization
         parameters: Optional[Parameters] = self.strategy.initialize_parameters(
             client_manager=self._client_manager
@@ -366,7 +363,6 @@ def _handle_finished_future_after_fit(
     failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
 ) -> None:
     """Convert finished future into either a result or a failure."""
-
     # Check if there was an exception
     failure = future.exception()
     if failure is not None:
@@ -428,7 +424,6 @@ def _handle_finished_future_after_evaluate(
     failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
 ) -> None:
     """Convert finished future into either a result or a failure."""
-
     # Check if there was an exception
     failure = future.exception()
     if failure is not None:

flwr/server/state/in_memory_state.py

@@ -36,7 +36,6 @@ class InMemoryState(State):
 
     def store_task_ins(self, task_ins: TaskIns) -> Optional[UUID]:
         """Store one TaskIns."""
-
         # Validate task
         errors = validate_task_ins_or_res(task_ins)
         if any(errors):
@@ -61,7 +60,6 @@ class InMemoryState(State):
         self, node_id: Optional[int], limit: Optional[int]
     ) -> List[TaskIns]:
         """Get all TaskIns that have not been delivered yet."""
-
         if limit is not None and limit < 1:
             raise AssertionError("`limit` must be >= 1")
 
@@ -94,7 +92,6 @@ class InMemoryState(State):
 
     def store_task_res(self, task_res: TaskRes) -> Optional[UUID]:
         """Store one TaskRes."""
-
         # Validate task
         errors = validate_task_ins_or_res(task_res)
         if any(errors):
@@ -117,7 +114,6 @@ class InMemoryState(State):
 
     def get_task_res(self, task_ids: Set[UUID], limit: Optional[int]) -> List[TaskRes]:
         """Get all TaskRes that have not been delivered yet."""
-
         if limit is not None and limit < 1:
             raise AssertionError("`limit` must be >= 1")
 
@@ -142,7 +138,6 @@ class InMemoryState(State):
 
     def delete_tasks(self, task_ids: Set[UUID]) -> None:
         """Delete all delivered TaskIns/TaskRes pairs."""
-
         task_ins_to_be_deleted: Set[UUID] = set()
         task_res_to_be_deleted: Set[UUID] = set()
 
@@ -163,9 +158,17 @@ class InMemoryState(State):
             del self.task_res_store[task_id]
 
     def num_task_ins(self) -> int:
+        """Calculate the number of task_ins in store.
+
+        This includes delivered but not yet deleted task_ins.
+        """
         return len(self.task_ins_store)
 
     def num_task_res(self) -> int:
+        """Calculate the number of task_res in store.
+
+        This includes delivered but not yet deleted task_res.
+        """
         return len(self.task_res_store)
 
     def register_node(self, node_id: int) -> None:

flwr/server/state/sqlite_state.py

@@ -390,7 +390,7 @@ class SqliteState(State):
         return result
 
     def num_task_ins(self) -> int:
-        """Number of task_ins in store.
+        """Calculate the number of task_ins in store.
 
         This includes delivered but not yet deleted task_ins.
         """
@@ -401,7 +401,7 @@ class SqliteState(State):
         return num
 
     def num_task_res(self) -> int:
-        """Number of task_res in store.
+        """Calculate the number of task_res in store.
 
         This includes delivered but not yet deleted task_res.
         """
@@ -469,10 +469,9 @@ def dict_factory(
     cursor: sqlite3.Cursor,
     row: sqlite3.Row,
 ) -> Dict[str, Any]:
-    """Used to turn SQLite results into dicts.
+    """Turn SQLite results into dicts.
 
-    Less efficent for retrival of large amounts of data but easier to
-    use.
+    Less efficent for retrival of large amounts of data but easier to use.
     """
     fields = [column[0] for column in cursor.description]
     return dict(zip(fields, row))

flwr/server/state/state.py

@@ -109,14 +109,14 @@ class State(abc.ABC):
 
     @abc.abstractmethod
     def num_task_ins(self) -> int:
-        """Number of task_ins in store.
+        """Calculate the number of task_ins in store.
 
         This includes delivered but not yet deleted task_ins.
         """
 
     @abc.abstractmethod
     def num_task_res(self) -> int:
-        """Number of task_res in store.
+        """Calculate the number of task_res in store.
 
         This includes delivered but not yet deleted task_res.
         """

flwr/server/state/state_factory.py

@@ -34,7 +34,6 @@ class StateFactory:
 
     def state(self) -> State:
         """Return a State instance and create it, if necessary."""
-
         # InMemoryState
         if self.database == ":flwr-in-memory-state:":
             if self.state_instance is None:

flwr/server/strategy/dpfedavg_adaptive.py

@@ -74,7 +74,6 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
     ) -> List[Tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
-
         additional_config = {"dpfedavg_adaptive_clip_enabled": True}
 
         client_instructions = super().configure_fit(
@@ -114,6 +113,7 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
         results: List[Tuple[ClientProxy, FitRes]],
         failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
     ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        """Aggregate training results as in DPFedAvgFixed and update clip norms."""
         if failures:
             return None, {}
         new_global_model = super().aggregate_fit(server_round, results, failures)

flwr/server/strategy/dpfedavg_fixed.py

@@ -67,13 +67,34 @@ class DPFedAvgFixed(Strategy):
     def initialize_parameters(
         self, client_manager: ClientManager
     ) -> Optional[Parameters]:
+        """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
     ) -> List[Tuple[ClientProxy, FitIns]]:
-        """Configure the next round of training."""
-
+        """Configure the next round of training incorporating Differential Privacy (DP).
+
+        Configuration of the next training round includes information related to DP,
+        such as clip norm and noise stddev.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning.
+        parameters : Parameters
+            The current (global) model parameters.
+        client_manager : ClientManager
+            The client manager which holds all currently connected clients.
+
+        Returns
+        -------
+        fit_configuration : List[Tuple[ClientProxy, FitIns]]
+            A list of tuples. Each tuple in the list identifies a `ClientProxy` and the
+            `FitIns` for this particular `ClientProxy`. If a particular `ClientProxy`
+            is not included in this list, it means that this `ClientProxy`
+            will not participate in the next round of federated learning.
+        """
         additional_config = {"dpfedavg_clip_norm": self.clip_norm}
         if not self.server_side_noising:
             additional_config[
@@ -92,6 +113,26 @@ class DPFedAvgFixed(Strategy):
     def configure_evaluate(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
     ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+        """Configure the next round of evaluation using the specified strategy.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning.
+        parameters : Parameters
+            The current (global) model parameters.
+        client_manager : ClientManager
+            The client manager which holds all currently connected clients.
+
+        Returns
+        -------
+        evaluate_configuration : List[Tuple[ClientProxy, EvaluateIns]]
+            A list of tuples. Each tuple in the list identifies a `ClientProxy` and the
+            `EvaluateIns` for this particular `ClientProxy`. If a particular
+            `ClientProxy` is not included in this list, it means that this
+            `ClientProxy` will not participate in the next round of federated
+            evaluation.
+        """
         return self.strategy.configure_evaluate(
             server_round, parameters, client_manager
         )
@@ -102,6 +143,7 @@ class DPFedAvgFixed(Strategy):
         results: List[Tuple[ClientProxy, FitRes]],
         failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
     ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        """Aggregate training results using unweighted aggregation."""
         if failures:
             return None, {}
         # Forcing unweighted aggregation, as in https://arxiv.org/abs/1905.03871.
@@ -122,9 +164,11 @@ class DPFedAvgFixed(Strategy):
         results: List[Tuple[ClientProxy, EvaluateRes]],
         failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
     ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        """Aggregate evaluation losses using the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     def evaluate(
         self, server_round: int, parameters: Parameters
     ) -> Optional[Tuple[float, Dict[str, Scalar]]]:
+        """Evaluate model parameters using an evaluation function from the strategy."""
         return self.strategy.evaluate(server_round, parameters)

flwr/server/strategy/fedadagrad.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Adaptive Federated Optimization using Adagrad (FedAdagrad) [Reddi et al.,
-2020] strategy.
+"""Adaptive Federated Optimization using Adagrad (FedAdagrad) [Reddi et al., 2020]
+strategy.
 
 Paper: arxiv.org/abs/2003.00295
 """
@@ -39,8 +39,8 @@ from .fedopt import FedOpt
 
 # flake8: noqa: E501
 class FedAdagrad(FedOpt):
-    """Adaptive Federated Optimization using Adagrad (FedAdagrad) [Reddi et
-    al., 2020] strategy.
+    """Adaptive Federated Optimization using Adagrad (FedAdagrad) [Reddi et al., 2020]
+    strategy.
 
     Paper: https://arxiv.org/abs/2003.00295
     """

flwr/server/strategy/fedadam.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Adaptive Federated Optimization using Adam (FedAdam) [Reddi et al., 2020]
-strategy.
+"""Adaptive Federated Optimization using Adam (FedAdam) [Reddi et al., 2020] strategy.
 
 Paper: arxiv.org/abs/2003.00295
 """
@@ -39,8 +38,8 @@ from .fedopt import FedOpt
 
 # flake8: noqa: E501
 class FedAdam(FedOpt):
-    """Adaptive Federated Optimization using Adam (FedAdam) [Reddi et al.,
-    2020] strategy.
+    """Adaptive Federated Optimization using Adam (FedAdam) [Reddi et al., 2020]
+    strategy.
 
     Paper: https://arxiv.org/abs/2003.00295
     """

flwr/server/strategy/fedavg.py

@@ -135,8 +135,7 @@ class FedAvg(Strategy):
         return rep
 
     def num_fit_clients(self, num_available_clients: int) -> Tuple[int, int]:
-        """Return the sample size and the required number of available
-        clients."""
+        """Return the sample size and the required number of available clients."""
         num_clients = int(num_available_clients * self.fraction_fit)
         return max(num_clients, self.min_fit_clients), self.min_available_clients
 

flwr/server/strategy/fedavg_android.py

@@ -109,8 +109,7 @@ class FedAvgAndroid(Strategy):
         return rep
 
     def num_fit_clients(self, num_available_clients: int) -> Tuple[int, int]:
-        """Return the sample size and the required number of available
-        clients."""
+        """Return the sample size and the required number of available clients."""
         num_clients = int(num_available_clients * self.fraction_fit)
         return max(num_clients, self.min_fit_clients), self.min_available_clients
 

flwr/server/strategy/fedopt.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Adaptive Federated Optimization (FedOpt) [Reddi et al., 2020] abstract
-strategy.
+"""Adaptive Federated Optimization (FedOpt) [Reddi et al., 2020] abstract strategy.
 
 Paper: arxiv.org/abs/2003.00295
 """

flwr/server/strategy/fedxgb_nn_avg.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Federated XGBoost in the horizontal setting based on building Neural Network
-and averaging on prediction outcomes [Ma et al., 2023].
+"""Federated XGBoost in the horizontal setting based on building Neural Network and
+averaging on prediction outcomes [Ma et al., 2023].
 
 Paper: Coming
 """

flwr/server/strategy/fedyogi.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Adaptive Federated Optimization using Yogi (FedYogi) [Reddi et al., 2020]
-strategy.
+"""Adaptive Federated Optimization using Yogi (FedYogi) [Reddi et al., 2020] strategy.
 
 Paper: arxiv.org/abs/2003.00295
 """
@@ -39,8 +38,8 @@ from .fedopt import FedOpt
 
 # flake8: noqa: E501
 class FedYogi(FedOpt):
-    """Adaptive Federated Optimization using Yogi (FedYogi) [Reddi et al.,
-    2020] strategy.
+    """Adaptive Federated Optimization using Yogi (FedYogi) [Reddi et al., 2020]
+    strategy.
 
     Paper: https://arxiv.org/abs/2003.00295
     """

flwr/server/strategy/qfedavg.py

@@ -96,8 +96,7 @@ class QFedAvg(FedAvg):
         return rep
 
     def num_fit_clients(self, num_available_clients: int) -> Tuple[int, int]:
-        """Return the sample size and the required number of available
-        clients."""
+        """Return the sample size and the required number of available clients."""
         num_clients = int(num_available_clients * self.fraction_fit)
         return max(num_clients, self.min_fit_clients), self.min_available_clients
 

flwr/server/utils/tensorboard.py

@@ -73,8 +73,7 @@ def tensorboard(logdir: str) -> Callable[[Strategy], Strategy]:
         """Return overloaded Strategy Wrapper."""
 
         class TBWrapper(strategy_class):  # type: ignore
-            """Strategy wrapper which hooks into some methods for TensorBoard
-            logging."""
+            """Strategy wrapper that hooks into some methods for TensorBoard logging."""
 
             def aggregate_evaluate(
                 self,
@@ -82,8 +81,7 @@ def tensorboard(logdir: str) -> Callable[[Strategy], Strategy]:
                 results: List[Tuple[ClientProxy, EvaluateRes]],
                 failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
             ) -> Tuple[Optional[float], Dict[str, Scalar]]:
-                """Hooks into aggregate_evaluate for TensorBoard logging
-                purpose."""
+                """Hooks into aggregate_evaluate for TensorBoard logging purpose."""
                 # Execute decorated function and extract results for logging
                 # They will be returned at the end of this function but also
                 # used for logging

flwr/server/utils/validator.py

@@ -23,7 +23,6 @@ from flwr.proto.task_pb2 import TaskIns, TaskRes
 # pylint: disable-next=too-many-branches
 def validate_task_ins_or_res(tasks_ins_res: Union[TaskIns, TaskRes]) -> List[str]:
     """Validate a TaskIns or TaskRes."""
-
     validation_errors = []
 
     if tasks_ins_res.task_id != "":

flwr/simulation/app.py

@@ -129,7 +129,6 @@ def start_simulation(  # pylint: disable=too-many-arguments
     hist : flwr.server.history.History
         Object containing metrics from training.
     """
-
     # pylint: disable-msg=too-many-locals
     event(
         EventType.START_SIMULATION_ENTER,
@@ -172,15 +171,15 @@ def start_simulation(  # pylint: disable=too-many-arguments
         }
 
     # Shut down Ray if it has already been initialized (unless asked not to)
-    if ray.is_initialized() and not keep_initialised:
-        ray.shutdown()
+    if ray.is_initialized() and not keep_initialised:  # type: ignore
+        ray.shutdown()  # type: ignore
 
     # Initialize Ray
-    ray.init(**ray_init_args)
+    ray.init(**ray_init_args)  # type: ignore
     log(
         INFO,
         "Flower VCE: Ray initialized with resources: %s",
-        ray.cluster_resources(),
+        ray.cluster_resources(),  # type: ignore
     )
 
     # Register one RayClientProxy object for each client with the ClientManager