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

flwr/common/serde_utils.py

@@ -0,0 +1,175 @@
+# 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.
+# ==============================================================================
+"""Utils for serde."""
+
+from collections.abc import MutableMapping
+from typing import Any, TypeVar, cast
+
+from google.protobuf.message import Message as GrpcMessage
+
+# pylint: disable=E0611
+from flwr.proto.error_pb2 import Error as ProtoError
+from flwr.proto.message_pb2 import Metadata as ProtoMetadata
+from flwr.proto.recorddict_pb2 import (
+    BoolList,
+    BytesList,
+    DoubleList,
+    SintList,
+    StringList,
+    UintList,
+)
+
+from ..app.error import Error
+from ..app.metadata import Metadata
+from .constant import INT64_MAX_VALUE
+from .record.typeddict import TypedDict
+
+# pylint: enable=E0611
+
+_type_to_field: dict[type, str] = {
+    float: "double",
+    int: "sint64",
+    bool: "bool",
+    str: "string",
+    bytes: "bytes",
+}
+_list_type_to_class_and_field: dict[type, tuple[type[GrpcMessage], str]] = {
+    float: (DoubleList, "double_list"),
+    int: (SintList, "sint_list"),
+    bool: (BoolList, "bool_list"),
+    str: (StringList, "string_list"),
+    bytes: (BytesList, "bytes_list"),
+}
+T = TypeVar("T")
+
+
+def _is_uint64(value: Any) -> bool:
+    """Check if a value is uint64."""
+    return isinstance(value, int) and value > INT64_MAX_VALUE
+
+
+def _record_value_to_proto(
+    value: Any, allowed_types: list[type], proto_class: type[T]
+) -> T:
+    """Serialize `*RecordValue` to ProtoBuf.
+
+    Note: `bool` MUST be put in the front of allowd_types if it exists.
+    """
+    arg = {}
+    for t in allowed_types:
+        # Single element
+        # Note: `isinstance(False, int) == True`.
+        if isinstance(value, t):
+            fld = _type_to_field[t]
+            if t is int and _is_uint64(value):
+                fld = "uint64"
+            arg[fld] = value
+            return proto_class(**arg)
+        # List
+        if isinstance(value, list) and all(isinstance(item, t) for item in value):
+            list_class, fld = _list_type_to_class_and_field[t]
+            # Use UintList if any element is of type `uint64`.
+            if t is int and any(_is_uint64(v) for v in value):
+                list_class, fld = UintList, "uint_list"
+            arg[fld] = list_class(vals=value)
+            return proto_class(**arg)
+    # Invalid types
+    raise TypeError(
+        f"The type of the following value is not allowed "
+        f"in '{proto_class.__name__}':\n{value}"
+    )
+
+
+def _record_value_from_proto(value_proto: GrpcMessage) -> Any:
+    """Deserialize `*RecordValue` from ProtoBuf."""
+    value_field = cast(str, value_proto.WhichOneof("value"))
+    if value_field.endswith("list"):
+        value = list(getattr(value_proto, value_field).vals)
+    else:
+        value = getattr(value_proto, value_field)
+    return value
+
+
+def record_value_dict_to_proto(
+    value_dict: TypedDict[str, Any],
+    allowed_types: list[type],
+    value_proto_class: type[T],
+) -> dict[str, T]:
+    """Serialize the record value dict to ProtoBuf.
+
+    This function will preserve the order of the keys in the input dictionary.
+
+    Note: `bool` MUST be put in the front of allowd_types if it exists.
+    """
+    # Move bool to the front
+    if bool in allowed_types and allowed_types[0] != bool:
+        allowed_types.remove(bool)
+        allowed_types.insert(0, bool)
+
+    def proto(_v: Any) -> T:
+        return _record_value_to_proto(_v, allowed_types, value_proto_class)
+
+    return {k: proto(v) for k, v in value_dict.items()}
+
+
+def record_value_dict_from_proto(
+    value_dict_proto: MutableMapping[str, Any]
+) -> dict[str, Any]:
+    """Deserialize the record value dict from ProtoBuf."""
+    return {k: _record_value_from_proto(v) for k, v in value_dict_proto.items()}
+
+
+def error_to_proto(error: Error) -> ProtoError:
+    """Serialize Error to ProtoBuf."""
+    reason = error.reason if error.reason else ""
+    return ProtoError(code=error.code, reason=reason)
+
+
+def error_from_proto(error_proto: ProtoError) -> Error:
+    """Deserialize Error from ProtoBuf."""
+    reason = error_proto.reason if len(error_proto.reason) > 0 else None
+    return Error(code=error_proto.code, reason=reason)
+
+
+def metadata_to_proto(metadata: Metadata) -> ProtoMetadata:
+    """Serialize `Metadata` to ProtoBuf."""
+    proto = ProtoMetadata(  # pylint: disable=E1101
+        run_id=metadata.run_id,
+        message_id=metadata.message_id,
+        src_node_id=metadata.src_node_id,
+        dst_node_id=metadata.dst_node_id,
+        reply_to_message_id=metadata.reply_to_message_id,
+        group_id=metadata.group_id,
+        ttl=metadata.ttl,
+        message_type=metadata.message_type,
+        created_at=metadata.created_at,
+    )
+    return proto
+
+
+def metadata_from_proto(metadata_proto: ProtoMetadata) -> Metadata:
+    """Deserialize `Metadata` from ProtoBuf."""
+    metadata = Metadata(
+        run_id=metadata_proto.run_id,
+        message_id=metadata_proto.message_id,
+        src_node_id=metadata_proto.src_node_id,
+        dst_node_id=metadata_proto.dst_node_id,
+        reply_to_message_id=metadata_proto.reply_to_message_id,
+        group_id=metadata_proto.group_id,
+        created_at=metadata_proto.created_at,
+        ttl=metadata_proto.ttl,
+        message_type=metadata_proto.message_type,
+    )
+    return metadata

flwr/common/telemetry.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Flower Labs GmbH. All Rights Reserved.
+# 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.
@@ -124,7 +124,7 @@ class EventType(str, Enum):
     # This method combined with auto() will set the property value to
     # the property name e.g.
     # `START_CLIENT = auto()` becomes `START_CLIENT = "START_CLIENT"`
-    # The type signature is not compatible with mypy, pylint and flake8
+    # The type signature is not compatible with mypy and pylint
     # so each of those needs to be disabled for this line.
     # pylint: disable-next=no-self-argument,arguments-differ,line-too-long
     def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> Any:  # type: ignore # noqa: E501

flwr/common/typing.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# 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.
@@ -230,6 +230,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
     running_at: str
     finished_at: str
     status: RunStatus
+    flwr_aid: str
 
     @classmethod
     def create_empty(cls, run_id: int) -> "Run":
@@ -245,6 +246,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
             running_at="",
             finished_at="",
             status=RunStatus(status="", sub_status="", details=""),
+            flwr_aid="",
         )
 
 
@@ -289,11 +291,11 @@ class UserAuthCredentials:
 
 
 @dataclass
-class UserInfo:
+class AccountInfo:
     """User information for event log."""
 
-    user_id: Optional[str]
-    user_name: Optional[str]
+    flwr_aid: Optional[str]
+    account_name: Optional[str]
 
 
 @dataclass

flwr/common/version.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Flower Labs GmbH. All Rights Reserved.
+# 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.

flwr/compat/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+# ==============================================================================
+"""Compatibility package containing deprecated legacy components."""

flwr/compat/client/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+# ==============================================================================
+"""Legacy components previously located in ``flwr.client``."""

flwr/{client → compat/client}/app.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# 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.
@@ -15,38 +15,30 @@
 """Flower client app."""
 
 
-import multiprocessing
-import os
-import sys
-import threading
 import time
 from contextlib import AbstractContextManager
 from logging import ERROR, INFO, WARN
-from os import urandom
 from pathlib import Path
-from typing import Callable, Optional, Union, cast
+from typing import Callable, Optional, Union
 
-import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 from grpc import RpcError
 
+from flwr.app.error import Error
 from flwr.cli.config_utils import get_fab_metadata
 from flwr.cli.install import install_from_fab
 from flwr.client.client import Client
 from flwr.client.client_app import ClientApp, LoadClientAppError
-from flwr.client.clientapp.app import flwr_clientapp
-from flwr.client.nodestate.nodestate_factory import NodeStateFactory
+from flwr.client.grpc_adapter_client.connection import grpc_adapter
+from flwr.client.grpc_rere_client.connection import grpc_request_response
+from flwr.client.message_handler.message_handler import handle_control_message
+from flwr.client.numpy_client import NumPyClient
+from flwr.client.run_info_store import DeprecatedRunInfoStore
 from flwr.client.typing import ClientFnExt
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
 from flwr.common.address import parse_address
 from flwr.common.constant import (
-    CLIENT_OCTET,
-    CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
-    ISOLATION_MODE_PROCESS,
-    ISOLATION_MODE_SUBPROCESS,
     MAX_RETRY_DELAY,
-    RUN_ID_NUM_BYTES,
-    SERVER_OCTET,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_BIDI,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -55,20 +47,11 @@ from flwr.common.constant import (
     ErrorCode,
 )
 from flwr.common.exit import ExitCode, flwr_exit
-from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log, warn_deprecated_feature
-from flwr.common.message import Error
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
-from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
-
-from .clientapp.clientappio_servicer import ClientAppInputs, ClientAppIoServicer
-from .grpc_adapter_client.connection import grpc_adapter
-from .grpc_client.connection import grpc_connection
-from .grpc_rere_client.connection import grpc_request_response
-from .message_handler.message_handler import handle_control_message
-from .numpy_client import NumPyClient
-from .run_info_store import DeprecatedRunInfoStore
+from flwr.compat.client.grpc_client.connection import grpc_connection
+from flwr.supernode.nodestate import NodeStateFactory
 
 
 def _check_actionable_client(
@@ -158,33 +141,33 @@ def start_client(
 
     Examples
     --------
-    Starting a gRPC client with an insecure server connection:
-
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using system certificates:
-
-    >>> def client_fn(context: Context):
-    >>>     return FlowerClient().to_client()
-    >>>
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>>     insecure=False,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using provided certificates:
-
-    >>> from pathlib import Path
-    >>>
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
-    >>> )
+    Starting a gRPC client with an insecure server connection::
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+        )
+
+    Starting a TLS-enabled gRPC client using system certificates::
+
+        def client_fn(context: Context):
+            return FlowerClient().to_client()
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+            insecure=False,
+        )
+
+    Starting a TLS-enabled gRPC client using provided certificates::
+
+        from pathlib import Path
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+            root_certificates=Path("/crts/root.pem").read_bytes(),
+        )
     """
     msg = (
         "flwr.client.start_client() is deprecated."
@@ -236,8 +219,6 @@ def start_client_internal(
     max_retries: Optional[int] = None,
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
-    isolation: Optional[str] = None,
-    clientappio_api_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -290,17 +271,6 @@ def start_client_internal(
         If set to None, there is no limit to the total time.
     flwr_path: Optional[Path] (default: None)
         The fully resolved path containing installed Flower Apps.
-    isolation : Optional[str] (default: None)
-        Isolation mode for `ClientApp`. Possible values are `subprocess` and
-        `process`. Defaults to `None`, which runs the `ClientApp` in the same process
-        as the SuperNode. If `subprocess`, the `ClientApp` runs in a subprocess started
-        by the SueprNode and communicates using gRPC at the address
-        `clientappio_api_address`. If `process`, the `ClientApp` runs in a separate
-        isolated process and communicates using gRPC at the address
-        `clientappio_api_address`.
-    clientappio_api_address : Optional[str]
-        (default: `CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS`)
-        The SuperNode gRPC server address.
     """
     if insecure is None:
         insecure = root_certificates is None
@@ -326,18 +296,6 @@ def start_client_internal(
 
         load_client_app_fn = _load_client_app
 
-    if isolation:
-        if clientappio_api_address is None:
-            raise ValueError(
-                f"`clientappio_api_address` required when `isolation` is "
-                f"{ISOLATION_MODE_SUBPROCESS} or {ISOLATION_MODE_PROCESS}",
-            )
-        _clientappio_grpc_server, clientappio_servicer = run_clientappio_api_grpc(
-            address=clientappio_api_address,
-            certificates=None,
-        )
-    clientappio_api_address = cast(str, clientappio_api_address)
-
     # At this point, only `load_client_app_fn` should be used
     # Both `client` and `client_fn` must not be used directly
 
@@ -388,7 +346,6 @@ def start_client_internal(
     run_info_store: Optional[DeprecatedRunInfoStore] = None
     state_factory = NodeStateFactory()
     state = state_factory.state()
-    mp_spawn_context = multiprocessing.get_context("spawn")
 
     runs: dict[int, Run] = {}
 
@@ -473,9 +430,8 @@ def start_client_internal(
                     run: Run = runs[run_id]
                     if get_fab is not None and run.fab_hash:
                         fab = get_fab(run.fab_hash, run_id)
-                        if not isolation:
-                            # If `ClientApp` runs in the same process, install the FAB
-                            install_from_fab(fab.content, flwr_path, True)
+                        # If `ClientApp` runs in the same process, install the FAB
+                        install_from_fab(fab.content, flwr_path, True)
                         fab_id, fab_version = get_fab_metadata(fab.content)
                     else:
                         fab = None
@@ -502,73 +458,13 @@ def start_client_internal(
 
                     # Handle app loading and task message
                     try:
-                        if isolation:
-                            # Two isolation modes:
-                            # 1. `subprocess`: SuperNode is starting the ClientApp
-                            #    process as a subprocess.
-                            # 2. `process`: ClientApp process gets started separately
-                            #    (via `flwr-clientapp`), for example, in a separate
-                            #    Docker container.
-
-                            # Generate SuperNode token
-                            token = int.from_bytes(urandom(RUN_ID_NUM_BYTES), "little")
-
-                            # Mode 1: SuperNode starts ClientApp as subprocess
-                            start_subprocess = isolation == ISOLATION_MODE_SUBPROCESS
-
-                            # Share Message and Context with servicer
-                            clientappio_servicer.set_inputs(
-                                clientapp_input=ClientAppInputs(
-                                    message=message,
-                                    context=context,
-                                    run=run,
-                                    fab=fab,
-                                    token=token,
-                                ),
-                                token_returned=start_subprocess,
-                            )
-
-                            if start_subprocess:
-                                _octet, _colon, _port = (
-                                    clientappio_api_address.rpartition(":")
-                                )
-                                io_address = (
-                                    f"{CLIENT_OCTET}:{_port}"
-                                    if _octet == SERVER_OCTET
-                                    else clientappio_api_address
-                                )
-                                # Start ClientApp subprocess
-                                command = [
-                                    "flwr-clientapp",
-                                    "--clientappio-api-address",
-                                    io_address,
-                                    "--token",
-                                    str(token),
-                                ]
-                                command.append("--insecure")
-
-                                proc = mp_spawn_context.Process(
-                                    target=_run_flwr_clientapp,
-                                    args=(command, os.getpid()),
-                                    daemon=True,
-                                )
-                                proc.start()
-                                proc.join()
-                            else:
-                                # Wait for output to become available
-                                while not clientappio_servicer.has_outputs():
-                                    time.sleep(0.1)
-
-                            outputs = clientappio_servicer.get_outputs()
-                            reply_message, context = outputs.message, outputs.context
-                        else:
-                            # Load ClientApp instance
-                            client_app: ClientApp = load_client_app_fn(
-                                fab_id, fab_version, run.fab_hash
-                            )
+                        # Load ClientApp instance
+                        client_app: ClientApp = load_client_app_fn(
+                            fab_id, fab_version, run.fab_hash
+                        )
 
-                            # Execute ClientApp
-                            reply_message = client_app(message=message, context=context)
+                        # Execute ClientApp
+                        reply_message = client_app(message=message, context=context)
                     except Exception as ex:  # pylint: disable=broad-exception-caught
 
                         # Legacy grpc-bidi
@@ -684,30 +580,30 @@ def start_numpy_client(
 
     Examples
     --------
-    Starting a gRPC client with an insecure server connection:
-
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>> )
-
-    Starting an SSL-enabled gRPC client using system certificates:
-
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>>     insecure=False,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using provided certificates:
-
-    >>> from pathlib import Path
-    >>>
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
-    >>> )
+    Starting a gRPC client with an insecure server connection::
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+        )
+
+    Starting a TLS-enabled gRPC client using system certificates::
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+            insecure=False,
+        )
+
+    Starting a TLS-enabled gRPC client using provided certificates::
+
+        from pathlib import Path
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+            root_certificates=Path("/crts/root.pem").read_bytes(),
+        )
     """
     mssg = (
         "flwr.client.start_numpy_client() is deprecated. \n\tInstead, use "
@@ -781,7 +677,7 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
         try:
             from requests.exceptions import ConnectionError as RequestsConnectionError
 
-            from .rest_client.connection import http_request_response
+            from flwr.client.rest_client.connection import http_request_response
         except ModuleNotFoundError:
             flwr_exit(ExitCode.COMMON_MISSING_EXTRA_REST)
         if server_address[:4] != "http":
@@ -792,46 +688,10 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
     elif transport == TRANSPORT_TYPE_GRPC_ADAPTER:
         connection, error_type = grpc_adapter, RpcError
     elif transport == TRANSPORT_TYPE_GRPC_BIDI:
-        connection, error_type = grpc_connection, RpcError
+        connection, error_type = grpc_connection, RpcError  # type: ignore[assignment]
     else:
         raise ValueError(
             f"Unknown transport type: {transport} (possible: {TRANSPORT_TYPES})"
         )
 
     return connection, address, error_type
-
-
-def _run_flwr_clientapp(args: list[str], main_pid: int) -> None:
-    # Monitor the main process in case of SIGKILL
-    def main_process_monitor() -> None:
-        while True:
-            time.sleep(1)
-            if os.getppid() != main_pid:
-                os.kill(os.getpid(), 9)
-
-    threading.Thread(target=main_process_monitor, daemon=True).start()
-
-    # Run the command
-    sys.argv = args
-    flwr_clientapp()
-
-
-def run_clientappio_api_grpc(
-    address: str,
-    certificates: Optional[tuple[bytes, bytes, bytes]],
-) -> tuple[grpc.Server, ClientAppIoServicer]:
-    """Run ClientAppIo API gRPC server."""
-    clientappio_servicer: grpc.Server = ClientAppIoServicer()
-    clientappio_add_servicer_to_server_fn = add_ClientAppIoServicer_to_server
-    clientappio_grpc_server = generic_create_grpc_server(
-        servicer_and_add_fn=(
-            clientappio_servicer,
-            clientappio_add_servicer_to_server_fn,
-        ),
-        server_address=address,
-        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
-        certificates=certificates,
-    )
-    log(INFO, "Starting Flower ClientAppIo gRPC server on %s", address)
-    clientappio_grpc_server.start()
-    return clientappio_grpc_server, clientappio_servicer

flwr/{client → compat/client}/grpc_client/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# 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.