flwr-nightly 1.13.0.dev20241021__py3-none-any.whl → 1.13.0.dev20241023__py3-none-any.whl

flwr/server/superlink/{state/state.py → linkstate/linkstate.py}

@@ -12,19 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Abstract base class State."""
+"""Abstract base class LinkState."""
 
 
 import abc
 from typing import Optional
 from uuid import UUID
 
-from flwr.common.typing import Run, UserConfig
+from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 
-class State(abc.ABC):  # pylint: disable=R0904
-    """Abstract State."""
+class LinkState(abc.ABC):  # pylint: disable=R0904
+    """Abstract LinkState."""
 
     @abc.abstractmethod
     def store_task_ins(self, task_ins: TaskIns) -> Optional[UUID]:
@@ -32,8 +32,8 @@ class State(abc.ABC):  # pylint: disable=R0904
 
         Usually, the Driver API calls this to schedule instructions.
 
-        Stores the value of the `task_ins` in the state and, if successful, returns the
-        `task_id` (UUID) of the `task_ins`. If, for any reason,
+        Stores the value of the `task_ins` in the link state and, if successful,
+        returns the `task_id` (UUID) of the `task_ins`. If, for any reason,
         storing the `task_ins` fails, `None` is returned.
 
         Constraints
@@ -130,11 +130,11 @@ class State(abc.ABC):  # pylint: disable=R0904
     def create_node(
         self, ping_interval: float, public_key: Optional[bytes] = None
     ) -> int:
-        """Create, store in state, and return `node_id`."""
+        """Create, store in the link state, and return `node_id`."""
 
     @abc.abstractmethod
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Remove `node_id` from state."""
+        """Remove `node_id` from the link state."""
 
     @abc.abstractmethod
     def get_nodes(self, run_id: int) -> set[int]:
@@ -178,11 +178,59 @@ class State(abc.ABC):  # pylint: disable=R0904
             - `fab_version`: The version of the FAB used in the specified run.
         """
 
+    @abc.abstractmethod
+    def get_run_status(self, run_ids: set[int]) -> dict[int, RunStatus]:
+        """Retrieve the statuses for the specified runs.
+
+        Parameters
+        ----------
+        run_ids : set[int]
+            A set of run identifiers for which to retrieve statuses.
+
+        Returns
+        -------
+        dict[int, RunStatus]
+            A dictionary mapping each valid run ID to its corresponding status.
+
+        Notes
+        -----
+        Only valid run IDs that exist in the State will be included in the returned
+        dictionary. If a run ID is not found, it will be omitted from the result.
+        """
+
+    @abc.abstractmethod
+    def update_run_status(self, run_id: int, new_status: RunStatus) -> bool:
+        """Update the status of the run with the specified `run_id`.
+
+        Parameters
+        ----------
+        run_id : int
+            The identifier of the run.
+        new_status : RunStatus
+            The new status to be assigned to the run.
+
+        Returns
+        -------
+        bool
+            True if the status update is successful; False otherwise.
+        """
+
+    @abc.abstractmethod
+    def get_pending_run_id(self) -> Optional[int]:
+        """Get the `run_id` of a run with `Status.PENDING` status.
+
+        Returns
+        -------
+        Optional[int]
+            The `run_id` of a `Run` that is pending to be started; None if
+            there is no Run pending.
+        """
+
     @abc.abstractmethod
     def store_server_private_public_key(
         self, private_key: bytes, public_key: bytes
     ) -> None:
-        """Store `server_private_key` and `server_public_key` in state."""
+        """Store `server_private_key` and `server_public_key` in the link state."""
 
     @abc.abstractmethod
     def get_server_private_key(self) -> Optional[bytes]:
@@ -194,11 +242,11 @@ class State(abc.ABC):  # pylint: disable=R0904
 
     @abc.abstractmethod
     def store_node_public_keys(self, public_keys: set[bytes]) -> None:
-        """Store a set of `node_public_keys` in state."""
+        """Store a set of `node_public_keys` in the link state."""
 
     @abc.abstractmethod
     def store_node_public_key(self, public_key: bytes) -> None:
-        """Store a `node_public_key` in state."""
+        """Store a `node_public_key` in the link state."""
 
     @abc.abstractmethod
     def get_node_public_keys(self) -> set[bytes]:

flwr/server/superlink/{state/state_factory.py → linkstate/linkstate_factory.py}

@@ -20,13 +20,13 @@ from typing import Optional
 
 from flwr.common.logger import log
 
-from .in_memory_state import InMemoryState
-from .sqlite_state import SqliteState
-from .state import State
+from .in_memory_linkstate import InMemoryLinkState
+from .linkstate import LinkState
+from .sqlite_linkstate import SqliteLinkState
 
 
-class StateFactory:
-    """Factory class that creates State instances.
+class LinkStateFactory:
+    """Factory class that creates LinkState instances.
 
     Parameters
     ----------
@@ -39,19 +39,19 @@ class StateFactory:
 
     def __init__(self, database: str) -> None:
         self.database = database
-        self.state_instance: Optional[State] = None
+        self.state_instance: Optional[LinkState] = None
 
-    def state(self) -> State:
+    def state(self) -> LinkState:
         """Return a State instance and create it, if necessary."""
         # InMemoryState
         if self.database == ":flwr-in-memory-state:":
             if self.state_instance is None:
-                self.state_instance = InMemoryState()
+                self.state_instance = InMemoryLinkState()
             log(DEBUG, "Using InMemoryState")
             return self.state_instance
 
         # SqliteState
-        state = SqliteState(self.database)
+        state = SqliteLinkState(self.database)
         state.initialize()
         log(DEBUG, "Using SqliteState")
         return state

flwr/server/superlink/{state/sqlite_state.py → linkstate/sqlite_linkstate.py}

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""SQLite based implemenation of server state."""
+"""SQLite based implemenation of the link state."""
 
 # pylint: disable=too-many-lines
 
@@ -30,20 +30,23 @@ from flwr.common.constant import (
     MESSAGE_TTL_TOLERANCE,
     NODE_ID_NUM_BYTES,
     RUN_ID_NUM_BYTES,
+    Status,
 )
-from flwr.common.typing import Run, UserConfig
+from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.recordset_pb2 import RecordSet  # pylint: disable=E0611
 from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
 from flwr.server.utils.validator import validate_task_ins_or_res
 
-from .state import State
+from .linkstate import LinkState
 from .utils import (
     convert_sint64_to_uint64,
     convert_sint64_values_in_dict_to_uint64,
     convert_uint64_to_sint64,
     convert_uint64_values_in_dict_to_sint64,
     generate_rand_int_from_bytes,
+    has_valid_sub_status,
+    is_valid_transition,
     make_node_unavailable_taskres,
 )
 
@@ -79,7 +82,13 @@ CREATE TABLE IF NOT EXISTS run(
     fab_id                TEXT,
     fab_version           TEXT,
     fab_hash              TEXT,
-    override_config       TEXT
+    override_config       TEXT,
+    pending_at            TEXT,
+    starting_at           TEXT,
+    running_at            TEXT,
+    finished_at           TEXT,
+    sub_status            TEXT,
+    details               TEXT
 );
 """
 
@@ -126,14 +135,14 @@ CREATE TABLE IF NOT EXISTS task_res(
 DictOrTuple = Union[tuple[Any, ...], dict[str, Any]]
 
 
-class SqliteState(State):  # pylint: disable=R0904
-    """SQLite-based state implementation."""
+class SqliteLinkState(LinkState):  # pylint: disable=R0904
+    """SQLite-based LinkState implementation."""
 
     def __init__(
         self,
         database_path: str,
     ) -> None:
-        """Initialize an SqliteState.
+        """Initialize an SqliteLinkState.
 
         Parameters
         ----------
@@ -183,7 +192,7 @@ class SqliteState(State):  # pylint: disable=R0904
     ) -> list[dict[str, Any]]:
         """Execute a SQL query."""
         if self.conn is None:
-            raise AttributeError("State is not initialized.")
+            raise AttributeError("LinkState is not initialized.")
 
         if data is None:
             data = []
@@ -216,9 +225,9 @@ class SqliteState(State):  # pylint: disable=R0904
 
         Usually, the Driver API calls this to schedule instructions.
 
-        Stores the value of the task_ins in the state and, if successful, returns the
-        task_id (UUID) of the task_ins. If, for any reason, storing the task_ins fails,
-        `None` is returned.
+        Stores the value of the task_ins in the link state and, if successful,
+        returns the task_id (UUID) of the task_ins. If, for any reason, storing
+        the task_ins fails, `None` is returned.
 
         Constraints
         -----------
@@ -645,7 +654,7 @@ class SqliteState(State):  # pylint: disable=R0904
         """
 
         if self.conn is None:
-            raise AttributeError("State not intitialized")
+            raise AttributeError("LinkState not intitialized")
 
         with self.conn:
             self.conn.execute(query_1, data)
@@ -656,7 +665,7 @@ class SqliteState(State):  # pylint: disable=R0904
     def create_node(
         self, ping_interval: float, public_key: Optional[bytes] = None
     ) -> int:
-        """Create, store in state, and return `node_id`."""
+        """Create, store in the link state, and return `node_id`."""
         # Sample a random uint64 as node_id
         uint64_node_id = generate_rand_int_from_bytes(NODE_ID_NUM_BYTES)
 
@@ -706,7 +715,7 @@ class SqliteState(State):  # pylint: disable=R0904
             params += (public_key,)  # type: ignore
 
         if self.conn is None:
-            raise AttributeError("State is not initialized.")
+            raise AttributeError("LinkState is not initialized.")
 
         try:
             with self.conn:
@@ -773,26 +782,16 @@ class SqliteState(State):  # pylint: disable=R0904
         if self.query(query, (sint64_run_id,))[0]["COUNT(*)"] == 0:
             query = (
                 "INSERT INTO run "
-                "(run_id, fab_id, fab_version, fab_hash, override_config)"
-                "VALUES (?, ?, ?, ?, ?);"
+                "(run_id, fab_id, fab_version, fab_hash, override_config, pending_at, "
+                "starting_at, running_at, finished_at, sub_status, details)"
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
             )
             if fab_hash:
-                self.query(
-                    query,
-                    (sint64_run_id, "", "", fab_hash, json.dumps(override_config)),
-                )
-            else:
-                self.query(
-                    query,
-                    (
-                        sint64_run_id,
-                        fab_id,
-                        fab_version,
-                        "",
-                        json.dumps(override_config),
-                    ),
-                )
-            # Note: we need to return the uint64 value of the run_id
+                fab_id, fab_version = "", ""
+            override_config_json = json.dumps(override_config)
+            data = [sint64_run_id, fab_id, fab_version, fab_hash, override_config_json]
+            data += [now().isoformat(), "", "", "", "", ""]
+            self.query(query, tuple(data))
             return uint64_run_id
         log(ERROR, "Unexpected run creation failure.")
         return 0
@@ -800,7 +799,7 @@ class SqliteState(State):  # pylint: disable=R0904
     def store_server_private_public_key(
         self, private_key: bytes, public_key: bytes
     ) -> None:
-        """Store `server_private_key` and `server_public_key` in state."""
+        """Store `server_private_key` and `server_public_key` in the link state."""
         query = "SELECT COUNT(*) FROM credential"
         count = self.query(query)[0]["COUNT(*)"]
         if count < 1:
@@ -833,13 +832,13 @@ class SqliteState(State):  # pylint: disable=R0904
         return public_key
 
     def store_node_public_keys(self, public_keys: set[bytes]) -> None:
-        """Store a set of `node_public_keys` in state."""
+        """Store a set of `node_public_keys` in the link state."""
         query = "INSERT INTO public_key (public_key) VALUES (?)"
         data = [(key,) for key in public_keys]
         self.query(query, data)
 
     def store_node_public_key(self, public_key: bytes) -> None:
-        """Store a `node_public_key` in state."""
+        """Store a `node_public_key` in the link state."""
         query = "INSERT INTO public_key (public_key) VALUES (:public_key)"
         self.query(query, {"public_key": public_key})
 
@@ -868,6 +867,94 @@ class SqliteState(State):  # pylint: disable=R0904
         log(ERROR, "`run_id` does not exist.")
         return None
 
+    def get_run_status(self, run_ids: set[int]) -> dict[int, RunStatus]:
+        """Retrieve the statuses for the specified runs."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_run_ids = (convert_uint64_to_sint64(run_id) for run_id in set(run_ids))
+        query = f"SELECT * FROM run WHERE run_id IN ({','.join(['?'] * len(run_ids))});"
+        rows = self.query(query, tuple(sint64_run_ids))
+
+        return {
+            # Restore uint64 run IDs
+            convert_sint64_to_uint64(row["run_id"]): RunStatus(
+                status=determine_run_status(row),
+                sub_status=row["sub_status"],
+                details=row["details"],
+            )
+            for row in rows
+        }
+
+    def update_run_status(self, run_id: int, new_status: RunStatus) -> bool:
+        """Update the status of the run with the specified `run_id`."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_run_id = convert_uint64_to_sint64(run_id)
+        query = "SELECT * FROM run WHERE run_id = ?;"
+        rows = self.query(query, (sint64_run_id,))
+
+        # Check if the run_id exists
+        if not rows:
+            log(ERROR, "`run_id` is invalid")
+            return False
+
+        # Check if the status transition is valid
+        row = rows[0]
+        current_status = RunStatus(
+            status=determine_run_status(row),
+            sub_status=row["sub_status"],
+            details=row["details"],
+        )
+        if not is_valid_transition(current_status, new_status):
+            log(
+                ERROR,
+                'Invalid status transition: from "%s" to "%s"',
+                current_status.status,
+                new_status.status,
+            )
+            return False
+
+        # Check if the sub-status is valid
+        if not has_valid_sub_status(current_status):
+            log(
+                ERROR,
+                'Invalid sub-status "%s" for status "%s"',
+                current_status.sub_status,
+                current_status.status,
+            )
+            return False
+
+        # Update the status
+        query = "UPDATE run SET %s= ?, sub_status = ?, details = ? "
+        query += "WHERE run_id = ?;"
+
+        timestamp_fld = ""
+        if new_status.status == Status.STARTING:
+            timestamp_fld = "starting_at"
+        elif new_status.status == Status.RUNNING:
+            timestamp_fld = "running_at"
+        elif new_status.status == Status.FINISHED:
+            timestamp_fld = "finished_at"
+
+        data = (
+            now().isoformat(),
+            new_status.sub_status,
+            new_status.details,
+            sint64_run_id,
+        )
+        self.query(query % timestamp_fld, data)
+        return True
+
+    def get_pending_run_id(self) -> Optional[int]:
+        """Get the `run_id` of a run with `Status.PENDING` status, if any."""
+        pending_run_id = None
+
+        # Fetch all runs with unset `starting_at` (i.e. they are in PENDING status)
+        query = "SELECT * FROM run WHERE starting_at = '' LIMIT 1;"
+        rows = self.query(query)
+        if rows:
+            pending_run_id = convert_sint64_to_uint64(rows[0]["run_id"])
+
+        return pending_run_id
+
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""
         sint64_node_id = convert_uint64_to_sint64(node_id)
@@ -1023,3 +1110,17 @@ def dict_to_task_res(task_dict: dict[str, Any]) -> TaskRes:
         ),
     )
     return result
+
+
+def determine_run_status(row: dict[str, Any]) -> str:
+    """Determine the status of the run based on timestamp fields."""
+    if row["pending_at"]:
+        if row["starting_at"]:
+            if row["running_at"]:
+                if row["finished_at"]:
+                    return Status.FINISHED
+                return Status.RUNNING
+            return Status.STARTING
+        return Status.PENDING
+    run_id = convert_sint64_to_uint64(row["run_id"])
+    raise sqlite3.IntegrityError(f"The run {run_id} does not have a valid status.")

flwr/server/superlink/{state → linkstate}/utils.py

@@ -21,7 +21,8 @@ from os import urandom
 from uuid import uuid4
 
 from flwr.common import log
-from flwr.common.constant import ErrorCode
+from flwr.common.constant import ErrorCode, Status, SubStatus
+from flwr.common.typing import RunStatus
 from flwr.proto.error_pb2 import Error  # pylint: disable=E0611
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
@@ -31,6 +32,17 @@ NODE_UNAVAILABLE_ERROR_REASON = (
     "It exceeds the time limit specified in its last ping."
 )
 
+VALID_RUN_STATUS_TRANSITIONS = {
+    (Status.PENDING, Status.STARTING),
+    (Status.STARTING, Status.RUNNING),
+    (Status.RUNNING, Status.FINISHED),
+}
+VALID_RUN_SUB_STATUSES = {
+    SubStatus.COMPLETED,
+    SubStatus.FAILED,
+    SubStatus.STOPPED,
+}
+
 
 def generate_rand_int_from_bytes(num_bytes: int) -> int:
     """Generate a random unsigned integer from `num_bytes` bytes."""
@@ -146,3 +158,47 @@ def make_node_unavailable_taskres(ref_taskins: TaskIns) -> TaskRes:
             ),
         ),
     )
+
+
+def is_valid_transition(current_status: RunStatus, new_status: RunStatus) -> bool:
+    """Check if a transition between two run statuses is valid.
+
+    Parameters
+    ----------
+    current_status : RunStatus
+        The current status of the run.
+    new_status : RunStatus
+        The new status to transition to.
+
+    Returns
+    -------
+    bool
+        True if the transition is valid, False otherwise.
+    """
+    return (
+        current_status.status,
+        new_status.status,
+    ) in VALID_RUN_STATUS_TRANSITIONS
+
+
+def has_valid_sub_status(status: RunStatus) -> bool:
+    """Check if the 'sub_status' field of the given status is valid.
+
+    Parameters
+    ----------
+    status : RunStatus
+        The status object to be checked.
+
+    Returns
+    -------
+    bool
+        True if the status object has a valid sub-status, False otherwise.
+
+    Notes
+    -----
+    Only an empty string (i.e., "") is considered a valid sub-status for
+    non-finished statuses. The sub-status of a finished status cannot be empty.
+    """
+    if status.status == Status.FINISHED:
+        return status.sub_status in VALID_RUN_SUB_STATUSES
+    return status.sub_status == ""

flwr/simulation/app.py

@@ -36,7 +36,7 @@ from flwr.server.history import History
 from flwr.server.server import Server, init_defaults, run_fl
 from flwr.server.server_config import ServerConfig
 from flwr.server.strategy import Strategy
-from flwr.server.superlink.state.utils import generate_rand_int_from_bytes
+from flwr.server.superlink.linkstate.utils import generate_rand_int_from_bytes
 from flwr.simulation.ray_transport.ray_actor import (
     ClientAppActor,
     VirtualClientEngineActor,

flwr/simulation/ray_transport/ray_client_proxy.py

@@ -22,7 +22,7 @@ from typing import Optional
 from flwr import common
 from flwr.client import ClientFnExt
 from flwr.client.client_app import ClientApp
-from flwr.client.node_state import NodeState
+from flwr.client.run_info_store import DeprecatedRunInfoStore
 from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
 from flwr.common.constant import (
     NUM_PARTITIONS_KEY,
@@ -65,7 +65,7 @@ class RayActorClientProxy(ClientProxy):
 
         self.app_fn = _load_app
         self.actor_pool = actor_pool
-        self.proxy_state = NodeState(
+        self.proxy_state = DeprecatedRunInfoStore(
             node_id=node_id,
             node_config={
                 PARTITION_ID_KEY: str(partition_id),

flwr/simulation/run_simulation.py

@@ -29,23 +29,24 @@ from typing import Any, Optional
 
 from flwr.cli.config_utils import load_and_validate
 from flwr.client import ClientApp
-from flwr.common import EventType, event, log
+from flwr.common import EventType, event, log, now
 from flwr.common.config import get_fused_config_from_dir, parse_config_args
-from flwr.common.constant import RUN_ID_NUM_BYTES
+from flwr.common.constant import RUN_ID_NUM_BYTES, Status
 from flwr.common.logger import (
     set_logger_propagation,
     update_console_handler,
     warn_deprecated_feature,
     warn_deprecated_feature_with_example,
 )
-from flwr.common.typing import Run, UserConfig
+from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.server.driver import Driver, InMemoryDriver
 from flwr.server.run_serverapp import run as run_server_app
 from flwr.server.server_app import ServerApp
 from flwr.server.superlink.fleet import vce
 from flwr.server.superlink.fleet.vce.backend.backend import BackendConfig
-from flwr.server.superlink.state import StateFactory
-from flwr.server.superlink.state.utils import generate_rand_int_from_bytes
+from flwr.server.superlink.linkstate import LinkStateFactory
+from flwr.server.superlink.linkstate.in_memory_linkstate import RunRecord
+from flwr.server.superlink.linkstate.utils import generate_rand_int_from_bytes
 from flwr.simulation.ray_transport.utils import (
     enable_tf_gpu_growth as enable_gpu_growth,
 )
@@ -389,7 +390,7 @@ def _main_loop(
 ) -> None:
     """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
-    state_factory = StateFactory(":flwr-in-memory-state:")
+    state_factory = LinkStateFactory(":flwr-in-memory-state:")
 
     f_stop = threading.Event()
     # A Threading event to indicate if an exception was raised in the ServerApp thread
@@ -399,7 +400,14 @@ def _main_loop(
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
-        state_factory.state().run_ids[run.run_id] = run  # type: ignore
+        init_status = RunStatus(Status.RUNNING, "", "")
+        state_factory.state().run_ids[run.run_id] = RunRecord(  # type: ignore
+            run=run,
+            status=init_status,
+            starting_at=now().isoformat(),
+            running_at=now().isoformat(),
+            finished_at="",
+        )
 
         if server_app_run_config is None:
             server_app_run_config = {}

flwr/superexec/app.py

@@ -27,6 +27,7 @@ from flwr.common.address import parse_address
 from flwr.common.config import parse_config_args
 from flwr.common.constant import EXEC_API_DEFAULT_ADDRESS
 from flwr.common.exit_handlers import register_exit_handlers
+from flwr.common.logger import warn_deprecated_feature
 from flwr.common.object_ref import load_app, validate
 
 from .exec_grpc import run_superexec_api_grpc
@@ -37,6 +38,12 @@ def run_superexec() -> None:
     """Run Flower SuperExec."""
     log(INFO, "Starting Flower SuperExec")
 
+    warn_deprecated_feature(
+        "Manually launching the SuperExec is deprecated. Since `flwr 1.13.0` "
+        "the executor service runs in the SuperLink. Launching it manually is not "
+        "recommended."
+    )
+
     event(EventType.RUN_SUPEREXEC_ENTER)
 
     args = _parse_args_run_superexec().parse_args()
@@ -54,7 +61,7 @@ def run_superexec() -> None:
     # Start SuperExec API
     superexec_server: grpc.Server = run_superexec_api_grpc(
         address=address,
-        executor=_load_executor(args),
+        executor=load_executor(args),
         certificates=certificates,
         config=parse_config_args(
             [args.executor_config] if args.executor_config else args.executor_config
@@ -163,7 +170,7 @@ def _try_obtain_certificates(
     )
 
 
-def _load_executor(
+def load_executor(
     args: argparse.Namespace,
 ) -> Executor:
     """Get the executor plugin."""

flwr/superexec/simulation.py

@@ -29,7 +29,7 @@ from flwr.common.config import unflatten_dict
 from flwr.common.constant import RUN_ID_NUM_BYTES
 from flwr.common.logger import log
 from flwr.common.typing import UserConfig
-from flwr.server.superlink.state.utils import generate_rand_int_from_bytes
+from flwr.server.superlink.linkstate.utils import generate_rand_int_from_bytes
 
 from .executor import Executor, RunTracker
 

{flwr_nightly-1.13.0.dev20241021.dist-info → flwr_nightly-1.13.0.dev20241023.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.13.0.dev20241021
+Version: 1.13.0.dev20241023
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0