flwr-nightly 1.8.0.dev20240315__py3-none-any.whl → 1.15.0.dev20250114__py3-none-any.whl

flwr/common/retry_invoker.py

@@ -18,20 +18,19 @@
 import itertools
 import random
 import time
+from collections.abc import Generator, Iterable
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from logging import INFO, WARN
+from typing import Any, Callable, Optional, Union, cast
+
+import grpc
+
+from flwr.common.constant import MAX_RETRY_DELAY
+from flwr.common.logger import log
+from flwr.common.typing import RunNotRunningException
+from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
+from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
+from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
 
 
 def exponential(
@@ -49,6 +48,11 @@ def exponential(
         Factor by which the delay is multiplied after each retry.
     max_delay: Optional[float] (default: None)
         The maximum delay duration between two consecutive retries.
+
+    Returns
+    -------
+    Generator[float, None, None]
+        A generator for the delay between 2 retries.
     """
     delay = base_delay if max_delay is None else min(base_delay, max_delay)
     while True:
@@ -67,6 +71,11 @@ def constant(
     ----------
     interval: Union[float, Iterable[float]] (default: 1)
         A constant value to yield or an iterable of such values.
+
+    Returns
+    -------
+    Generator[float, None, None]
+        A generator for the delay between 2 retries.
     """
     if not isinstance(interval, Iterable):
         interval = itertools.repeat(interval)
@@ -84,6 +93,11 @@ def full_jitter(max_value: float) -> float:
     ----------
     max_value : float
         The upper limit for the randomized value.
+
+    Returns
+    -------
+    float
+        A random float that is less than max_value.
     """
     return random.uniform(0, max_value)
 
@@ -93,8 +107,8 @@ class RetryState:
     """State for callbacks in RetryInvoker."""
 
     target: Callable[..., Any]
-    args: Tuple[Any, ...]
-    kwargs: Dict[str, Any]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
     tries: int
     elapsed_time: float
     exception: Optional[Exception] = None
@@ -107,7 +121,7 @@ class RetryInvoker:
 
     Parameters
     ----------
-    wait_factory: Callable[[], Generator[float, None, None]]
+    wait_gen_factory: Callable[[], Generator[float, None, None]]
         A generator yielding successive wait times in seconds. If the generator
         is finite, the giveup event will be triggered when the generator raises
         `StopIteration`.
@@ -129,12 +143,12 @@ class RetryInvoker:
         data class object detailing the invocation.
     on_giveup: Optional[Callable[[RetryState], None]] (default: None)
         A callable to be executed in the event that `max_tries` or `max_time` is
-        exceeded, `should_giveup` returns True, or `wait_factory()` generator raises
+        exceeded, `should_giveup` returns True, or `wait_gen_factory()` generator raises
         `StopInteration`. The parameter is a data class object detailing the
         invocation.
     jitter: Optional[Callable[[float], float]] (default: full_jitter)
-        A function of the value yielded by `wait_factory()` returning the actual time
-        to wait. This function helps distribute wait times stochastically to avoid
+        A function of the value yielded by `wait_gen_factory()` returning the actual
+        time to wait. This function helps distribute wait times stochastically to avoid
         timing collisions across concurrent clients. Wait times are jittered by
         default using the `full_jitter` function. To disable jittering, pass
         `jitter=None`.
@@ -142,6 +156,13 @@ class RetryInvoker:
         A function accepting an exception instance, returning whether or not
         to give up prematurely before other give-up conditions are evaluated.
         If set to None, the strategy is to never give up prematurely.
+    wait_function: Optional[Callable[[float], None]] (default: None)
+        A function that defines how to wait between retry attempts. It accepts
+        one argument, the wait time in seconds, allowing the use of various waiting
+        mechanisms (e.g., asynchronous waits or event-based synchronization) suitable
+        for different execution environments. If set to `None`, the `wait_function`
+        defaults to `time.sleep`, which is ideal for synchronous operations. Custom
+        functions should manage execution flow to prevent blocking or interference.
 
     Examples
     --------
@@ -159,8 +180,8 @@ class RetryInvoker:
     # pylint: disable-next=too-many-arguments
     def __init__(
         self,
-        wait_factory: Callable[[], Generator[float, None, None]],
-        recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]],
+        wait_gen_factory: Callable[[], Generator[float, None, None]],
+        recoverable_exceptions: Union[type[Exception], tuple[type[Exception], ...]],
         max_tries: Optional[int],
         max_time: Optional[float],
         *,
@@ -169,8 +190,9 @@ class RetryInvoker:
         on_giveup: Optional[Callable[[RetryState], None]] = None,
         jitter: Optional[Callable[[float], float]] = full_jitter,
         should_giveup: Optional[Callable[[Exception], bool]] = None,
+        wait_function: Optional[Callable[[float], None]] = None,
     ) -> None:
-        self.wait_factory = wait_factory
+        self.wait_gen_factory = wait_gen_factory
         self.recoverable_exceptions = recoverable_exceptions
         self.max_tries = max_tries
         self.max_time = max_time
@@ -179,6 +201,9 @@ class RetryInvoker:
         self.on_giveup = on_giveup
         self.jitter = jitter
         self.should_giveup = should_giveup
+        if wait_function is None:
+            wait_function = time.sleep
+        self.wait_function = wait_function
 
     # pylint: disable-next=too-many-locals
     def invoke(
@@ -212,13 +237,13 @@ class RetryInvoker:
         Raises
         ------
         Exception
-            If the number of tries exceeds `max_tries`, if the total time
-            exceeds `max_time`, if `wait_factory()` generator raises `StopInteration`,
+            If the number of tries exceeds `max_tries`, if the total time exceeds
+            `max_time`, if `wait_gen_factory()` generator raises `StopInteration`,
             or if the `should_giveup` returns True for a raised exception.
 
         Notes
         -----
-        The time between retries is determined by the provided `wait_factory()`
+        The time between retries is determined by the provided `wait_gen_factory()`
         generator and can optionally be jittered using the `jitter` function.
         The recoverable exceptions that trigger a retry, as well as conditions to
         stop retries, are also determined by the class's initialization parameters.
@@ -231,13 +256,13 @@ class RetryInvoker:
                 handler(cast(RetryState, ref_state[0]))
 
         try_cnt = 0
-        wait_generator = self.wait_factory()
-        start = time.time()
-        ref_state: List[Optional[RetryState]] = [None]
+        wait_generator = self.wait_gen_factory()
+        start = time.monotonic()
+        ref_state: list[Optional[RetryState]] = [None]
 
         while True:
             try_cnt += 1
-            elapsed_time = time.time() - start
+            elapsed_time = time.monotonic() - start
             state = RetryState(
                 target=target,
                 args=args,
@@ -250,6 +275,7 @@ class RetryInvoker:
             try:
                 ret = target(*args, **kwargs)
             except self.recoverable_exceptions as err:
+                state.exception = err
                 # Check if giveup event should be triggered
                 max_tries_exceeded = try_cnt == self.max_tries
                 max_time_exceeded = (
@@ -282,8 +308,75 @@ class RetryInvoker:
                 try_call_event_handler(self.on_backoff)
 
                 # Sleep
-                time.sleep(wait_time)
+                self.wait_function(state.actual_wait)
             else:
                 # Trigger success event
                 try_call_event_handler(self.on_success)
                 return ret
+
+
+def _make_simple_grpc_retry_invoker() -> RetryInvoker:
+    """Create a simple gRPC retry invoker."""
+
+    def _on_sucess(retry_state: RetryState) -> None:
+        if retry_state.tries > 1:
+            log(
+                INFO,
+                "Connection successful after %.2f seconds and %s tries.",
+                retry_state.elapsed_time,
+                retry_state.tries,
+            )
+
+    def _on_backoff(retry_state: RetryState) -> None:
+        if retry_state.tries == 1:
+            log(WARN, "Connection attempt failed, retrying...")
+        else:
+            log(
+                WARN,
+                "Connection attempt failed, retrying in %.2f seconds",
+                retry_state.actual_wait,
+            )
+
+    def _on_giveup(retry_state: RetryState) -> None:
+        if retry_state.tries > 1:
+            log(
+                WARN,
+                "Giving up reconnection after %.2f seconds and %s tries.",
+                retry_state.elapsed_time,
+                retry_state.tries,
+            )
+
+    def _should_giveup_fn(e: Exception) -> bool:
+        if e.code() == grpc.StatusCode.PERMISSION_DENIED:  # type: ignore
+            raise RunNotRunningException
+        if e.code() == grpc.StatusCode.UNAVAILABLE:  # type: ignore
+            return False
+        return True
+
+    return RetryInvoker(
+        wait_gen_factory=lambda: exponential(max_delay=MAX_RETRY_DELAY),
+        recoverable_exceptions=grpc.RpcError,
+        max_tries=None,
+        max_time=None,
+        on_success=_on_sucess,
+        on_backoff=_on_backoff,
+        on_giveup=_on_giveup,
+        should_giveup=_should_giveup_fn,
+    )
+
+
+def _wrap_stub(
+    stub: Union[ServerAppIoStub, ClientAppIoStub, SimulationIoStub],
+    retry_invoker: RetryInvoker,
+) -> None:
+    """Wrap a gRPC stub with a retry invoker."""
+
+    def make_lambda(original_method: Any) -> Any:
+        return lambda *args, **kwargs: retry_invoker.invoke(
+            original_method, *args, **kwargs
+        )
+
+    for method_name in vars(stub):
+        method = getattr(stub, method_name)
+        if callable(method):
+            setattr(stub, method_name, make_lambda(method))

flwr/common/secure_aggregation/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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/common/secure_aggregation/crypto/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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/common/secure_aggregation/crypto/shamir.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.
@@ -17,20 +17,20 @@
 
 import pickle
 from concurrent.futures import ThreadPoolExecutor
-from typing import List, Tuple, cast
+from typing import cast
 
 from Crypto.Protocol.SecretSharing import Shamir
 from Crypto.Util.Padding import pad, unpad
 
 
-def create_shares(secret: bytes, threshold: int, num: int) -> List[bytes]:
+def create_shares(secret: bytes, threshold: int, num: int) -> list[bytes]:
     """Return list of shares (bytes)."""
     secret_padded = pad(secret, 16)
     secret_padded_chunk = [
         (threshold, num, secret_padded[i : i + 16])
         for i in range(0, len(secret_padded), 16)
     ]
-    share_list: List[List[Tuple[int, bytes]]] = [[] for _ in range(num)]
+    share_list: list[list[tuple[int, bytes]]] = [[] for _ in range(num)]
 
     with ThreadPoolExecutor(max_workers=10) as executor:
         for chunk_shares in executor.map(
@@ -43,22 +43,22 @@ def create_shares(secret: bytes, threshold: int, num: int) -> List[bytes]:
     return [pickle.dumps(shares) for shares in share_list]
 
 
-def _shamir_split(threshold: int, num: int, chunk: bytes) -> List[Tuple[int, bytes]]:
+def _shamir_split(threshold: int, num: int, chunk: bytes) -> list[tuple[int, bytes]]:
     return Shamir.split(threshold, num, chunk, ssss=False)
 
 
 # Reconstructing secret with PyCryptodome
-def combine_shares(share_list: List[bytes]) -> bytes:
+def combine_shares(share_list: list[bytes]) -> bytes:
     """Reconstruct secret from shares."""
-    unpickled_share_list: List[List[Tuple[int, bytes]]] = [
-        cast(List[Tuple[int, bytes]], pickle.loads(share)) for share in share_list
+    unpickled_share_list: list[list[tuple[int, bytes]]] = [
+        cast(list[tuple[int, bytes]], pickle.loads(share)) for share in share_list
     ]
 
     chunk_num = len(unpickled_share_list[0])
     secret_padded = bytearray(0)
-    chunk_shares_list: List[List[Tuple[int, bytes]]] = []
+    chunk_shares_list: list[list[tuple[int, bytes]]] = []
     for i in range(chunk_num):
-        chunk_shares: List[Tuple[int, bytes]] = []
+        chunk_shares: list[tuple[int, bytes]] = []
         for share in unpickled_share_list:
             chunk_shares.append(share[i])
         chunk_shares_list.append(chunk_shares)
@@ -71,5 +71,5 @@ def combine_shares(share_list: List[bytes]) -> bytes:
     return bytes(secret)
 
 
-def _shamir_combine(shares: List[Tuple[int, bytes]]) -> bytes:
+def _shamir_combine(shares: list[tuple[int, bytes]]) -> bytes:
     return Shamir.combine(shares, ssss=False)

flwr/common/secure_aggregation/crypto/symmetric_encryption.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.
@@ -16,16 +16,17 @@
 
 
 import base64
-from typing import Tuple, cast
+from typing import cast
 
+from cryptography.exceptions import InvalidSignature
 from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives import hashes, hmac, serialization
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
 
 def generate_key_pairs() -> (
-    Tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
+    tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
 ):
     """Generate private and public key pairs with Cryptography."""
     private_key = ec.generate_private_key(ec.SECP384R1())
@@ -98,3 +99,66 @@ def decrypt(key: bytes, ciphertext: bytes) -> bytes:
     # The input key must be url safe
     fernet = Fernet(key)
     return fernet.decrypt(ciphertext)
+
+
+def compute_hmac(key: bytes, message: bytes) -> bytes:
+    """Compute hmac of a message using key as hash."""
+    computed_hmac = hmac.HMAC(key, hashes.SHA256())
+    computed_hmac.update(message)
+    return computed_hmac.finalize()
+
+
+def verify_hmac(key: bytes, message: bytes, hmac_value: bytes) -> bool:
+    """Verify hmac of a message using key as hash."""
+    computed_hmac = hmac.HMAC(key, hashes.SHA256())
+    computed_hmac.update(message)
+    try:
+        computed_hmac.verify(hmac_value)
+        return True
+    except InvalidSignature:
+        return False
+
+
+def sign_message(private_key: ec.EllipticCurvePrivateKey, message: bytes) -> bytes:
+    """Sign a message using the provided EC private key.
+
+    Parameters
+    ----------
+    private_key : ec.EllipticCurvePrivateKey
+        The EC private key to sign the message with.
+    message : bytes
+        The message to be signed.
+
+    Returns
+    -------
+    bytes
+        The signature of the message.
+    """
+    signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
+    return signature
+
+
+def verify_signature(
+    public_key: ec.EllipticCurvePublicKey, message: bytes, signature: bytes
+) -> bool:
+    """Verify a signature against a message using the provided EC public key.
+
+    Parameters
+    ----------
+    public_key : ec.EllipticCurvePublicKey
+        The EC public key to verify the signature.
+    message : bytes
+        The original message.
+    signature : bytes
+        The signature to verify.
+
+    Returns
+    -------
+    bool
+        True if the signature is valid, False otherwise.
+    """
+    try:
+        public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
+        return True
+    except InvalidSignature:
+        return False

flwr/common/secure_aggregation/ndarrays_arithmetic.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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,51 +15,51 @@
 """Utility functions for performing operations on Numpy NDArrays."""
 
 
-from typing import Any, List, Tuple, Union
+from typing import Any, Union
 
 import numpy as np
 from numpy.typing import DTypeLike, NDArray
 
 
-def factor_combine(factor: int, parameters: List[NDArray[Any]]) -> List[NDArray[Any]]:
+def factor_combine(factor: int, parameters: list[NDArray[Any]]) -> list[NDArray[Any]]:
     """Combine factor with parameters."""
     return [np.array([factor])] + parameters
 
 
 def factor_extract(
-    parameters: List[NDArray[Any]],
-) -> Tuple[int, List[NDArray[Any]]]:
+    parameters: list[NDArray[Any]],
+) -> tuple[int, list[NDArray[Any]]]:
     """Extract factor from parameters."""
     return parameters[0][0], parameters[1:]
 
 
-def get_parameters_shape(parameters: List[NDArray[Any]]) -> List[Tuple[int, ...]]:
+def get_parameters_shape(parameters: list[NDArray[Any]]) -> list[tuple[int, ...]]:
     """Get dimensions of each NDArray in parameters."""
     return [arr.shape for arr in parameters]
 
 
 def get_zero_parameters(
-    dimensions_list: List[Tuple[int, ...]], dtype: DTypeLike = np.int64
-) -> List[NDArray[Any]]:
+    dimensions_list: list[tuple[int, ...]], dtype: DTypeLike = np.int64
+) -> list[NDArray[Any]]:
     """Generate zero parameters based on the dimensions list."""
     return [np.zeros(dimensions, dtype=dtype) for dimensions in dimensions_list]
 
 
 def parameters_addition(
-    parameters1: List[NDArray[Any]], parameters2: List[NDArray[Any]]
-) -> List[NDArray[Any]]:
+    parameters1: list[NDArray[Any]], parameters2: list[NDArray[Any]]
+) -> list[NDArray[Any]]:
     """Add two parameters."""
     return [parameters1[idx] + parameters2[idx] for idx in range(len(parameters1))]
 
 
 def parameters_subtraction(
-    parameters1: List[NDArray[Any]], parameters2: List[NDArray[Any]]
-) -> List[NDArray[Any]]:
+    parameters1: list[NDArray[Any]], parameters2: list[NDArray[Any]]
+) -> list[NDArray[Any]]:
     """Subtract parameters from the other parameters."""
     return [parameters1[idx] - parameters2[idx] for idx in range(len(parameters1))]
 
 
-def parameters_mod(parameters: List[NDArray[Any]], divisor: int) -> List[NDArray[Any]]:
+def parameters_mod(parameters: list[NDArray[Any]], divisor: int) -> list[NDArray[Any]]:
     """Take mod of parameters with an integer divisor."""
     if bin(divisor).count("1") == 1:
         msk = divisor - 1
@@ -68,14 +68,14 @@ def parameters_mod(parameters: List[NDArray[Any]], divisor: int) -> List[NDArray
 
 
 def parameters_multiply(
-    parameters: List[NDArray[Any]], multiplier: Union[int, float]
-) -> List[NDArray[Any]]:
+    parameters: list[NDArray[Any]], multiplier: Union[int, float]
+) -> list[NDArray[Any]]:
     """Multiply parameters by an integer/float multiplier."""
     return [parameters[idx] * multiplier for idx in range(len(parameters))]
 
 
 def parameters_divide(
-    parameters: List[NDArray[Any]], divisor: Union[int, float]
-) -> List[NDArray[Any]]:
+    parameters: list[NDArray[Any]], divisor: Union[int, float]
+) -> list[NDArray[Any]]:
     """Divide weight by an integer/float divisor."""
     return [parameters[idx] / divisor for idx in range(len(parameters))]

flwr/common/secure_aggregation/quantization.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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,7 +15,7 @@
 """Utility functions for model quantization."""
 
 
-from typing import List, cast
+from typing import cast
 
 import numpy as np
 
@@ -30,10 +30,10 @@ def _stochastic_round(arr: NDArrayFloat) -> NDArrayInt:
 
 
 def quantize(
-    parameters: List[NDArrayFloat], clipping_range: float, target_range: int
-) -> List[NDArrayInt]:
+    parameters: list[NDArrayFloat], clipping_range: float, target_range: int
+) -> list[NDArrayInt]:
     """Quantize float Numpy arrays to integer Numpy arrays."""
-    quantized_list: List[NDArrayInt] = []
+    quantized_list: list[NDArrayInt] = []
     quantizer = target_range / (2 * clipping_range)
     for arr in parameters:
         # Stochastic quantization
@@ -49,12 +49,12 @@ def quantize(
 
 # Dequantize parameters to range [-clipping_range, clipping_range]
 def dequantize(
-    quantized_parameters: List[NDArrayInt],
+    quantized_parameters: list[NDArrayInt],
     clipping_range: float,
     target_range: int,
-) -> List[NDArrayFloat]:
+) -> list[NDArrayFloat]:
     """Dequantize integer Numpy arrays to float Numpy arrays."""
-    reverse_quantized_list: List[NDArrayFloat] = []
+    reverse_quantized_list: list[NDArrayFloat] = []
     quantizer = (2 * clipping_range) / target_range
     shift = -clipping_range
     for arr in quantized_parameters:

flwr/common/secure_aggregation/secaggplus_constants.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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/common/secure_aggregation/secaggplus_utils.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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,8 +15,6 @@
 """Utility functions for the SecAgg/SecAgg+ protocol."""
 
 
-from typing import List, Tuple
-
 import numpy as np
 
 from flwr.common.typing import NDArrayInt
@@ -45,8 +43,8 @@ def share_keys_plaintext_concat(
     """
     return b"".join(
         [
-            int.to_bytes(src_node_id, 8, "little", signed=True),
-            int.to_bytes(dst_node_id, 8, "little", signed=True),
+            int.to_bytes(src_node_id, 8, "little", signed=False),
+            int.to_bytes(dst_node_id, 8, "little", signed=False),
             int.to_bytes(len(b_share), 4, "little"),
             b_share,
             sk_share,
@@ -54,7 +52,7 @@ def share_keys_plaintext_concat(
     )
 
 
-def share_keys_plaintext_separate(plaintext: bytes) -> Tuple[int, int, bytes, bytes]:
+def share_keys_plaintext_separate(plaintext: bytes) -> tuple[int, int, bytes, bytes]:
     """Retrieve arguments from bytes.
 
     Parameters
@@ -74,8 +72,8 @@ def share_keys_plaintext_separate(plaintext: bytes) -> Tuple[int, int, bytes, by
         the secret key share of the source sent to the destination.
     """
     src, dst, mark = (
-        int.from_bytes(plaintext[:8], "little", signed=True),
-        int.from_bytes(plaintext[8:16], "little", signed=True),
+        int.from_bytes(plaintext[:8], "little", signed=False),
+        int.from_bytes(plaintext[8:16], "little", signed=False),
         int.from_bytes(plaintext[16:20], "little"),
     )
     ret = (src, dst, plaintext[20 : 20 + mark], plaintext[20 + mark :])
@@ -83,8 +81,8 @@ def share_keys_plaintext_separate(plaintext: bytes) -> Tuple[int, int, bytes, by
 
 
 def pseudo_rand_gen(
-    seed: bytes, num_range: int, dimensions_list: List[Tuple[int, ...]]
-) -> List[NDArrayInt]:
+    seed: bytes, num_range: int, dimensions_list: list[tuple[int, ...]]
+) -> list[NDArrayInt]:
     """Seeded pseudo-random number generator for noise generation with Numpy."""
     assert len(seed) & 0x3 == 0
     seed32 = 0
@@ -95,8 +93,8 @@ def pseudo_rand_gen(
     output = []
     for dimension in dimensions_list:
         if len(dimension) == 0:
-            arr = np.array(gen.randint(0, num_range - 1), dtype=int)
+            arr = np.array(gen.randint(0, num_range - 1), dtype=np.int64)
         else:
-            arr = gen.randint(0, num_range - 1, dimension)
+            arr = gen.randint(0, num_range - 1, dimension, dtype=np.int64)
         output.append(arr)
     return output