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

flwr/simulation/ray_transport/ray_client_proxy.py

@@ -23,7 +23,7 @@ from flwr import common
 from flwr.client import ClientFnExt
 from flwr.client.client_app import ClientApp
 from flwr.client.run_info_store import DeprecatedRunInfoStore
-from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
+from flwr.common import DEFAULT_TTL, Message, Metadata, RecordDict, now
 from flwr.common.constant import (
     NUM_PARTITIONS_KEY,
     PARTITION_ID_KEY,
@@ -31,15 +31,16 @@ from flwr.common.constant import (
     MessageTypeLegacy,
 )
 from flwr.common.logger import log
-from flwr.common.recordset_compat import (
-    evaluateins_to_recordset,
-    fitins_to_recordset,
-    getparametersins_to_recordset,
-    getpropertiesins_to_recordset,
-    recordset_to_evaluateres,
-    recordset_to_fitres,
-    recordset_to_getparametersres,
-    recordset_to_getpropertiesres,
+from flwr.common.message import make_message
+from flwr.common.recorddict_compat import (
+    evaluateins_to_recorddict,
+    fitins_to_recorddict,
+    getparametersins_to_recorddict,
+    getpropertiesins_to_recorddict,
+    recorddict_to_evaluateres,
+    recorddict_to_fitres,
+    recorddict_to_getparametersres,
+    recorddict_to_getpropertiesres,
 )
 from flwr.server.client_proxy import ClientProxy
 from flwr.simulation.ray_transport.ray_actor import VirtualClientEngineActorPool
@@ -109,23 +110,24 @@ class RayActorClientProxy(ClientProxy):
 
         return out_mssg
 
-    def _wrap_recordset_in_message(
+    def _wrap_recorddict_in_message(
         self,
-        recordset: RecordSet,
+        recorddict: RecordDict,
         message_type: str,
         timeout: Optional[float],
         group_id: Optional[int],
     ) -> Message:
-        """Wrap a RecordSet inside a Message."""
-        return Message(
-            content=recordset,
+        """Wrap a RecordDict inside a Message."""
+        return make_message(
+            content=recorddict,
             metadata=Metadata(
                 run_id=0,
                 message_id="",
                 group_id=str(group_id) if group_id is not None else "",
                 src_node_id=0,
                 dst_node_id=self.node_id,
-                reply_to_message="",
+                reply_to_message_id="",
+                created_at=now().timestamp(),
                 ttl=timeout if timeout else DEFAULT_TTL,
                 message_type=message_type,
             ),
@@ -138,9 +140,9 @@ class RayActorClientProxy(ClientProxy):
         group_id: Optional[int],
     ) -> common.GetPropertiesRes:
         """Return client's properties."""
-        recordset = getpropertiesins_to_recordset(ins)
-        message = self._wrap_recordset_in_message(
-            recordset,
+        recorddict = getpropertiesins_to_recorddict(ins)
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageTypeLegacy.GET_PROPERTIES,
             timeout=timeout,
             group_id=group_id,
@@ -148,7 +150,7 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_getpropertiesres(message_out.content)
+        return recorddict_to_getpropertiesres(message_out.content)
 
     def get_parameters(
         self,
@@ -157,9 +159,9 @@ class RayActorClientProxy(ClientProxy):
         group_id: Optional[int],
     ) -> common.GetParametersRes:
         """Return the current local model parameters."""
-        recordset = getparametersins_to_recordset(ins)
-        message = self._wrap_recordset_in_message(
-            recordset,
+        recorddict = getparametersins_to_recorddict(ins)
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageTypeLegacy.GET_PARAMETERS,
             timeout=timeout,
             group_id=group_id,
@@ -167,17 +169,17 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_getparametersres(message_out.content, keep_input=False)
+        return recorddict_to_getparametersres(message_out.content, keep_input=False)
 
     def fit(
         self, ins: common.FitIns, timeout: Optional[float], group_id: Optional[int]
     ) -> common.FitRes:
         """Train model parameters on the locally held dataset."""
-        recordset = fitins_to_recordset(
+        recorddict = fitins_to_recorddict(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
-        message = self._wrap_recordset_in_message(
-            recordset,
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageType.TRAIN,
             timeout=timeout,
             group_id=group_id,
@@ -185,17 +187,17 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_fitres(message_out.content, keep_input=False)
+        return recorddict_to_fitres(message_out.content, keep_input=False)
 
     def evaluate(
         self, ins: common.EvaluateIns, timeout: Optional[float], group_id: Optional[int]
     ) -> common.EvaluateRes:
         """Evaluate model parameters on the locally held dataset."""
-        recordset = evaluateins_to_recordset(
+        recorddict = evaluateins_to_recorddict(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
-        message = self._wrap_recordset_in_message(
-            recordset,
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageType.EVALUATE,
             timeout=timeout,
             group_id=group_id,
@@ -203,7 +205,7 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_evaluateres(message_out.content)
+        return recorddict_to_evaluateres(message_out.content)
 
     def reconnect(
         self,

flwr/simulation/run_simulation.py

@@ -30,7 +30,7 @@ from typing import Any, Optional
 from flwr.cli.config_utils import load_and_validate
 from flwr.cli.utils import get_sha256_hash
 from flwr.client import ClientApp
-from flwr.common import Context, EventType, RecordSet, event, log, now
+from flwr.common import Context, EventType, RecordDict, 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, Status
 from flwr.common.logger import (
@@ -39,7 +39,7 @@ from flwr.common.logger import (
     warn_deprecated_feature_with_example,
 )
 from flwr.common.typing import Run, RunStatus, UserConfig
-from flwr.server.driver import Driver, InMemoryDriver
+from flwr.server.grid import Grid, InMemoryGrid
 from flwr.server.run_serverapp import run as _run
 from flwr.server.server_app import ServerApp
 from flwr.server.superlink.fleet import vce
@@ -168,7 +168,7 @@ def run_simulation(
         messages sent by the `ServerApp`.
 
     num_supernodes : int
-        Number of nodes that run a ClientApp. They can be sampled by a Driver in the
+        Number of nodes that run a ClientApp. They can be sampled by a Grid in the
         ServerApp and receive a Message describing what the ClientApp should perform.
 
     backend_name : str (default: ray)
@@ -180,7 +180,7 @@ def run_simulation(
         for values parsed to initialisation of backend, `client_resources`
         to define the resources for clients, and `actor` to define the actor
         parameters. Values supported in <value> are those included by
-        `flwr.common.typing.ConfigsRecordValues`.
+        `flwr.common.typing.ConfigRecordValues`.
 
     enable_tf_gpu_growth : bool (default: False)
         A boolean to indicate whether to enable GPU growth on the main thread. This is
@@ -225,7 +225,7 @@ def run_serverapp_th(
     server_app_attr: Optional[str],
     server_app: Optional[ServerApp],
     server_app_run_config: UserConfig,
-    driver: Driver,
+    grid: Grid,
     app_dir: str,
     f_stop: threading.Event,
     has_exception: threading.Event,
@@ -239,7 +239,7 @@ def run_serverapp_th(
         tf_gpu_growth: bool,
         stop_event: threading.Event,
         exception_event: threading.Event,
-        _driver: Driver,
+        _grid: Grid,
         _server_app_dir: str,
         _server_app_run_config: UserConfig,
         _server_app_attr: Optional[str],
@@ -260,13 +260,13 @@ def run_serverapp_th(
                 run_id=run_id,
                 node_id=0,
                 node_config={},
-                state=RecordSet(),
+                state=RecordDict(),
                 run_config=_server_app_run_config,
             )
 
             # Run ServerApp
             updated_context = _run(
-                driver=_driver,
+                grid=_grid,
                 context=context,
                 server_app_dir=_server_app_dir,
                 server_app_attr=_server_app_attr,
@@ -291,7 +291,7 @@ def run_serverapp_th(
             enable_tf_gpu_growth,
             f_stop,
             has_exception,
-            driver,
+            grid,
             app_dir,
             server_app_run_config,
             server_app_attr,
@@ -333,7 +333,7 @@ def _main_loop(
         run_id=run.run_id,
         node_id=0,
         node_config=UserConfig(),
-        state=RecordSet(),
+        state=RecordDict(),
         run_config=UserConfig(),
     )
     try:
@@ -347,9 +347,9 @@ def _main_loop(
         if server_app_run_config is None:
             server_app_run_config = {}
 
-        # Initialize Driver
-        driver = InMemoryDriver(state_factory=state_factory)
-        driver.set_run(run_id=run.run_id)
+        # Initialize Grid
+        grid = InMemoryGrid(state_factory=state_factory)
+        grid.set_run(run_id=run.run_id)
         output_context_queue: Queue[Context] = Queue()
 
         # Get and run ServerApp thread
@@ -357,7 +357,7 @@ def _main_loop(
             server_app_attr=server_app_attr,
             server_app=server_app,
             server_app_run_config=server_app_run_config,
-            driver=driver,
+            grid=grid,
             app_dir=app_dir,
             f_stop=f_stop,
             has_exception=server_app_thread_has_exception,
@@ -546,7 +546,7 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         default="{}",
         help='A JSON formatted stream, e.g \'{"<keyA>":<value>, "<keyB>":<value>}\' to '
         "configure a backend. Values supported in <value> are those included by "
-        "`flwr.common.typing.ConfigsRecordValues`. ",
+        "`flwr.common.typing.ConfigRecordValues`. ",
     )
     parser.add_argument(
         "--enable-tf-gpu-growth",

flwr/superexec/deployment.py

@@ -23,7 +23,7 @@ from typing import Optional
 from typing_extensions import override
 
 from flwr.cli.config_utils import get_fab_metadata
-from flwr.common import ConfigsRecord, Context, RecordSet
+from flwr.common import ConfigRecord, Context, RecordDict
 from flwr.common.constant import (
     SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS,
     Status,
@@ -141,7 +141,7 @@ class DeploymentEngine(Executor):
         fab_id, fab_version = get_fab_metadata(fab.content)
 
         run_id = self.linkstate.create_run(
-            fab_id, fab_version, fab_hash, override_config, ConfigsRecord()
+            fab_id, fab_version, fab_hash, override_config, ConfigRecord()
         )
         return run_id
 
@@ -149,7 +149,7 @@ class DeploymentEngine(Executor):
         """Register a Context for a Run."""
         # Create an empty context for the Run
         context = Context(
-            run_id=run_id, node_id=0, node_config={}, state=RecordSet(), run_config={}
+            run_id=run_id, node_id=0, node_config={}, state=RecordDict(), run_config={}
         )
 
         # Register the context at the LinkState
@@ -160,7 +160,7 @@ class DeploymentEngine(Executor):
         self,
         fab_file: bytes,
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> Optional[int]:
         """Start run using the Flower Deployment Engine."""
         run_id = None

flwr/superexec/exec_event_log_interceptor.py

@@ -0,0 +1,135 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flower Exec API event log interceptor."""
+
+
+from collections.abc import Iterator
+from typing import Any, Callable, Union, cast
+
+import grpc
+from google.protobuf.message import Message as GrpcMessage
+
+from flwr.common.event_log_plugin.event_log_plugin import EventLogWriterPlugin
+from flwr.common.typing import LogEntry
+
+from .exec_user_auth_interceptor import shared_user_info
+
+
+class ExecEventLogInterceptor(grpc.ServerInterceptor):  # type: ignore
+    """Exec API interceptor for logging events."""
+
+    def __init__(self, log_plugin: EventLogWriterPlugin) -> None:
+        self.log_plugin = log_plugin
+
+    def intercept_service(
+        self,
+        continuation: Callable[[Any], Any],
+        handler_call_details: grpc.HandlerCallDetails,
+    ) -> grpc.RpcMethodHandler:
+        """Flower server interceptor logging logic.
+
+        Intercept all unary-unary/unary-stream calls from users and log the event.
+        Continue RPC call if event logger is enabled on the SuperLink, else, terminate
+        RPC call by setting context to abort.
+        """
+        # One of the method handlers in
+        # `flwr.superexec.exec_servicer.ExecServicer`
+        method_handler: grpc.RpcMethodHandler = continuation(handler_call_details)
+        method_name: str = handler_call_details.method
+        return self._generic_event_log_unary_method_handler(method_handler, method_name)
+
+    def _generic_event_log_unary_method_handler(
+        self, method_handler: grpc.RpcMethodHandler, method_name: str
+    ) -> grpc.RpcMethodHandler:
+        def _generic_method_handler(
+            request: GrpcMessage,
+            context: grpc.ServicerContext,
+        ) -> Union[GrpcMessage, Iterator[GrpcMessage], BaseException]:
+            log_entry: LogEntry
+            # Log before call
+            log_entry = self.log_plugin.compose_log_before_event(
+                request=request,
+                context=context,
+                user_info=shared_user_info.get(),
+                method_name=method_name,
+            )
+            self.log_plugin.write_log(log_entry)
+
+            # For unary-unary calls, log after the call immediately
+            if method_handler.unary_unary:
+                unary_response, error = None, None
+                try:
+                    unary_response = cast(
+                        GrpcMessage, method_handler.unary_unary(request, context)
+                    )
+                except BaseException as e:
+                    error = e
+                    raise
+                finally:
+                    log_entry = self.log_plugin.compose_log_after_event(
+                        request=request,
+                        context=context,
+                        user_info=shared_user_info.get(),
+                        method_name=method_name,
+                        response=unary_response or error,
+                    )
+                    self.log_plugin.write_log(log_entry)
+                return unary_response
+
+            # For unary-stream calls, wrap the response iterator and write the event log
+            # after iteration completes
+            if method_handler.unary_stream:
+                response_iterator = cast(
+                    Iterator[GrpcMessage],
+                    method_handler.unary_stream(request, context),
+                )
+
+                def response_wrapper() -> Iterator[GrpcMessage]:
+                    stream_response, error = None, None
+                    try:
+                        # pylint: disable=use-yield-from
+                        for stream_response in response_iterator:
+                            yield stream_response
+                    except BaseException as e:
+                        error = e
+                        raise
+                    finally:
+                        # This block is executed after the client has consumed
+                        # the entire stream, or if iteration is interrupted
+                        log_entry = self.log_plugin.compose_log_after_event(
+                            request=request,
+                            context=context,
+                            user_info=shared_user_info.get(),
+                            method_name=method_name,
+                            response=stream_response or error,
+                        )
+                        self.log_plugin.write_log(log_entry)
+
+                return response_wrapper()
+
+            raise RuntimeError()  # This line is unreachable
+
+        if method_handler.unary_unary:
+            message_handler = grpc.unary_unary_rpc_method_handler
+        elif method_handler.unary_stream:
+            message_handler = grpc.unary_stream_rpc_method_handler
+        else:
+            # If the method type is not `unary_unary` or `unary_stream`, raise an error
+            raise NotImplementedError("This RPC method type is not supported.")
+        return message_handler(
+            _generic_method_handler,
+            request_deserializer=method_handler.request_deserializer,
+            response_serializer=method_handler.response_serializer,
+        )

flwr/superexec/exec_grpc.py

@@ -15,7 +15,6 @@
 """SuperExec gRPC API."""
 
 
-from collections.abc import Sequence
 from logging import INFO
 from typing import Optional
 
@@ -23,12 +22,14 @@ import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.event_log_plugin import EventLogWriterPlugin
 from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.common.typing import UserConfig
 from flwr.proto.exec_pb2_grpc import add_ExecServicer_to_server
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
+from flwr.superexec.exec_event_log_interceptor import ExecEventLogInterceptor
 from flwr.superexec.exec_user_auth_interceptor import ExecUserAuthInterceptor
 
 from .exec_servicer import ExecServicer
@@ -44,6 +45,7 @@ def run_exec_api_grpc(
     certificates: Optional[tuple[bytes, bytes, bytes]],
     config: UserConfig,
     auth_plugin: Optional[ExecAuthPlugin] = None,
+    event_log_plugin: Optional[EventLogWriterPlugin] = None,
 ) -> grpc.Server:
     """Run Exec API (gRPC, request-response)."""
     executor.set_config(config)
@@ -54,16 +56,20 @@ def run_exec_api_grpc(
         executor=executor,
         auth_plugin=auth_plugin,
     )
-    interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
+    interceptors: list[grpc.ServerInterceptor] = []
     if auth_plugin is not None:
-        interceptors = [ExecUserAuthInterceptor(auth_plugin)]
+        interceptors.append(ExecUserAuthInterceptor(auth_plugin))
+    # Event log interceptor must be added after user auth interceptor
+    if event_log_plugin is not None:
+        interceptors.append(ExecEventLogInterceptor(event_log_plugin))
+        log(INFO, "Flower event logging enabled")
     exec_add_servicer_to_server_fn = add_ExecServicer_to_server
     exec_grpc_server = generic_create_grpc_server(
         servicer_and_add_fn=(exec_servicer, exec_add_servicer_to_server_fn),
         server_address=address,
         max_message_length=GRPC_MAX_MESSAGE_LENGTH,
         certificates=certificates,
-        interceptors=interceptors,
+        interceptors=interceptors or None,
     )
 
     if auth_plugin is None:

flwr/superexec/exec_servicer.py

@@ -28,7 +28,7 @@ from flwr.common.auth_plugin import ExecAuthPlugin
 from flwr.common.constant import LOG_STREAM_INTERVAL, Status, SubStatus
 from flwr.common.logger import log
 from flwr.common.serde import (
-    configs_record_from_proto,
+    config_record_from_proto,
     run_to_proto,
     user_config_from_proto,
 )
@@ -79,7 +79,7 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
         run_id = self.executor.start_run(
             request.fab.content,
             user_config_from_proto(request.override_config),
-            configs_record_from_proto(request.federation_options),
+            config_record_from_proto(request.federation_options),
         )
 
         if run_id is None:

flwr/superexec/exec_user_auth_interceptor.py

@@ -15,11 +15,13 @@
 """Flower Exec API interceptor."""
 
 
-from typing import Any, Callable, Union
+import contextvars
+from typing import Any, Callable, Union, cast
 
 import grpc
 
 from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.typing import UserInfo
 from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
     GetAuthTokensRequest,
     GetAuthTokensResponse,
@@ -43,6 +45,11 @@ Response = Union[
 ]
 
 
+shared_user_info: contextvars.ContextVar[UserInfo] = contextvars.ContextVar(
+    "user_info", default=UserInfo(user_id=None, user_name=None)
+)
+
+
 class ExecUserAuthInterceptor(grpc.ServerInterceptor):  # type: ignore
     """Exec API interceptor for user authentication."""
 
@@ -77,13 +84,22 @@ class ExecUserAuthInterceptor(grpc.ServerInterceptor):  # type: ignore
         ) -> Response:
             call = method_handler.unary_unary or method_handler.unary_stream
             metadata = context.invocation_metadata()
+
+            # Intercept GetLoginDetails and GetAuthTokens requests, and return
+            # the response without authentication
             if isinstance(request, (GetLoginDetailsRequest, GetAuthTokensRequest)):
                 return call(request, context)  # type: ignore
 
-            valid_tokens, _ = self.auth_plugin.validate_tokens_in_metadata(metadata)
+            # For other requests, check if the user is authenticated
+            valid_tokens, user_info = self.auth_plugin.validate_tokens_in_metadata(
+                metadata
+            )
             if valid_tokens:
+                # Store user info in contextvars for authenticated users
+                shared_user_info.set(cast(UserInfo, user_info))
                 return call(request, context)  # type: ignore
 
+            # If the user is not authenticated, refresh tokens
             tokens = self.auth_plugin.refresh_tokens(context.invocation_metadata())
             if tokens is not None:
                 context.send_initial_metadata(tokens)

flwr/superexec/executor.py

@@ -20,7 +20,7 @@ from dataclasses import dataclass, field
 from subprocess import Popen
 from typing import Optional
 
-from flwr.common import ConfigsRecord
+from flwr.common import ConfigRecord
 from flwr.common.typing import UserConfig
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
@@ -73,7 +73,7 @@ class Executor(ABC):
         self,
         fab_file: bytes,
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> Optional[int]:
         """Start a run using the given Flower FAB ID and version.
 
@@ -86,7 +86,7 @@ class Executor(ABC):
             The Flower App Bundle file bytes.
         override_config: UserConfig
             The config overrides dict sent by the user (using `flwr run`).
-        federation_options: ConfigsRecord
+        federation_options: ConfigRecord
             The federation options sent by the user (using `flwr run`).
 
         Returns

flwr/superexec/simulation.py

@@ -22,7 +22,7 @@ from typing import Optional
 from typing_extensions import override
 
 from flwr.cli.config_utils import get_fab_metadata
-from flwr.common import ConfigsRecord, Context, RecordSet
+from flwr.common import ConfigRecord, Context, RecordDict
 from flwr.common.logger import log
 from flwr.common.typing import Fab, UserConfig
 from flwr.server.superlink.ffs import Ffs
@@ -76,7 +76,7 @@ class SimulationEngine(Executor):
         self,
         fab_file: bytes,
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> Optional[int]:
         """Start run using the Flower Simulation Engine."""
         try:
@@ -104,7 +104,7 @@ class SimulationEngine(Executor):
                 run_id=run_id,
                 node_id=0,
                 node_config={},
-                state=RecordSet(),
+                state=RecordDict(),
                 run_config={},
             )
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr
-Version: 1.16.0
+Version: 1.17.0
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -63,7 +63,7 @@ Description-Content-Type: text/markdown
     <a href="https://flower.ai/">Website</a> |
     <a href="https://flower.ai/blog">Blog</a> |
     <a href="https://flower.ai/docs/">Docs</a> |
-    <a href="https://flower.ai/conf/flower-summit-2022">Conference</a> |
+    <a href="https://flower.ai/events/flower-ai-summit-2025">Summit</a> |
     <a href="https://flower.ai/join-slack">Slack</a>
     <br /><br />
 </p>