opengris-scaler 1.12.28__cp313-cp313-musllinux_1_2_x86_64.whl

scaler/utility/graph/topological_sorter.py

@@ -0,0 +1,11 @@
+import logging
+
+try:
+    from scaler.utility.graph.topological_sorter_graphblas import TopologicalSorter
+
+    logging.info("using GraphBLAS for calculate graph")
+except ImportError as e:
+    assert isinstance(e, Exception)
+    from graphlib import TopologicalSorter  # type: ignore[assignment, no-redef]
+
+    assert isinstance(TopologicalSorter, object)

scaler/utility/graph/topological_sorter_graphblas.py

@@ -0,0 +1,174 @@
+import collections
+import graphlib
+import itertools
+from typing import Generic, Hashable, Iterable, List, Mapping, Optional, Tuple, TypeVar
+
+from bidict import bidict
+
+try:
+    import graphblas as gb
+    import numpy as np  # noqa
+except ImportError:
+    raise ImportError("Please use 'pip install python-graphblas' to have graph blas support")
+
+GraphKeyType = TypeVar("GraphKeyType", bound=Hashable)
+
+
+class TopologicalSorter(Generic[GraphKeyType]):
+    """
+    Implements graphlib's TopologicalSorter, but the graph handling is backed by GraphBLAS
+    Reference: https://github.com/python/cpython/blob/4a3ea1fdd890e5e2ec26540dc3c958a52fba6556/Lib/graphlib.py
+    """
+
+    def __init__(self, graph: Optional[Mapping[GraphKeyType, Iterable[GraphKeyType]]] = None):
+        # the layout of the matrix is (in-vertex, out-vertex)
+        self._matrix = gb.Matrix(gb.dtypes.BOOL)
+        self._key_to_id: bidict[GraphKeyType, int] = bidict()
+
+        self._graph_matrix_mask: Optional[np.ndarray] = None
+        self._visited_vertices_mask: Optional[np.ndarray] = None
+        self._ready_nodes: Optional[List[GraphKeyType]] = None
+
+        self._n_done = 0
+        self._n_visited = 0
+
+        if graph is not None:
+            self.merge_graph(graph)
+
+    def add(self, node: GraphKeyType, *predecessors: GraphKeyType) -> None:
+        self.merge_graph({node: predecessors})
+
+    def merge_graph(self, graph: Mapping[GraphKeyType, Iterable[GraphKeyType]]) -> None:
+        if self._ready_nodes is not None:
+            raise ValueError("nodes cannot be added after a call to prepare()")
+
+        # cache old dim to compare later when resizing matrix
+        old_dim = len(self._key_to_id)
+
+        # maintain iterable copies for iterable predecessors
+        graph_iterable_copy = {}
+
+        # update key to id mappings
+        for node, predecessors in graph.items():
+            if node not in self._key_to_id:
+                self._key_to_id[node] = len(self._key_to_id)
+
+            # copy iterator if predecessors is an iterable
+            if isinstance(predecessors, collections.abc.Iterable):
+                predecessors, graph_iterable_copy[node] = itertools.tee(predecessors)
+
+            for pred in predecessors:
+                if pred not in self._key_to_id:
+                    self._key_to_id[pred] = len(self._key_to_id)
+
+        # resize at once as it is faster
+        if old_dim != len(self._key_to_id):
+            self._matrix.resize(len(self._key_to_id), len(self._key_to_id))
+
+        # update matrix
+        for node, predecessors in graph.items():
+            if node in graph_iterable_copy:
+                predecessors = graph_iterable_copy[node]
+
+            for pred in predecessors:
+                self._matrix[self._key_to_id[node], self._key_to_id[pred]] = True
+
+    def prepare(self) -> None:
+        if self._ready_nodes is not None:
+            raise ValueError("cannot prepare() more than once")
+
+        self._graph_matrix_mask = np.ones(len(self._key_to_id), bool)
+        self._visited_vertices_mask = np.zeros(len(self._key_to_id), bool)
+
+        self._ready_nodes = self._get_zero_degree_keys()
+        for node in self._ready_nodes:
+            self._visited_vertices_mask[self._key_to_id[node]] = True
+        self._n_visited += len(self._ready_nodes)
+
+        if self._has_cycle():
+            raise graphlib.CycleError("cycle detected")
+
+    def get_ready(self) -> Tuple[GraphKeyType, ...]:
+        if self._ready_nodes is None:
+            raise ValueError("prepare() must be called first")
+
+        result = tuple(self._ready_nodes)
+        self._ready_nodes.clear()
+        return result
+
+    def is_active(self) -> bool:
+        if self._ready_nodes is None:
+            raise ValueError("prepare() must be called first")
+        return self._n_done < self._n_visited or bool(self._ready_nodes)
+
+    def __bool__(self) -> bool:
+        return self.is_active()
+
+    def done(self, *nodes: GraphKeyType) -> None:
+        if self._ready_nodes is None:
+            raise ValueError("prepare() must be called first")
+
+        for node in nodes:
+            if node not in self._key_to_id:
+                raise ValueError(f"node {node!r} was not added using add()")
+
+            _id = self._key_to_id[node]
+
+            if not self._visited_vertices_mask[_id]:
+                raise ValueError(f"node {node!r} is not ready")
+
+            if not self._graph_matrix_mask[_id]:
+                raise ValueError(f"node {node!r} is already done")
+
+            self._graph_matrix_mask[_id] = False
+        self._n_done += len(nodes)
+
+        new_ready_nodes = self._get_zero_degree_keys()
+        for node in new_ready_nodes:
+            self._visited_vertices_mask[self._key_to_id[node]] = True
+        self._ready_nodes.extend(new_ready_nodes)
+        self._n_visited += len(new_ready_nodes)
+
+    def static_order(self) -> Iterable[GraphKeyType]:
+        self.prepare()
+        while self.is_active():
+            node_group = self.get_ready()
+            yield from node_group
+            self.done(*node_group)
+
+    def _has_cycle(self) -> bool:
+        """
+        Detect cycle using trace(A^n) != 0.
+        https://arxiv.org/pdf/1610.01200.pdf
+
+        :return: True if cycle is found, otherwise False
+        """
+        matrix_n = gb.Vector.from_dense(np.ones(len(self._key_to_id), bool), missing_value=False).diag()
+        for _ in range(len(self._key_to_id)):
+            # use LOR_PAIR to compute matrix multiplication over boolean matrices
+            matrix_n << gb.semiring.lor_pair(matrix_n @ self._matrix)
+            # check diagonal for any truthy values
+            if matrix_n.diag().reduce(gb.monoid.lor):
+                return True
+        return False
+
+    def _get_zero_degree_keys(self) -> List[GraphKeyType]:
+        ids = self._get_mask_diff(self._visited_vertices_mask, self._get_zero_degree_mask(self._get_masked_matrix()))
+        return [self._key_to_id.inverse[_id] for _id in ids]
+
+    def _get_masked_matrix(self) -> gb.Matrix:
+        # convert vector mask to matrix diagonal and then perform matrix multiplication to mask matrix
+        # https://github.com/DrTimothyAldenDavis/GraphBLAS/issues/48#issuecomment-858596341
+        return gb.semiring.lor_pair(
+            self._matrix @ gb.Vector.from_dense(self._graph_matrix_mask, missing_value=False).diag()
+        )
+
+    @classmethod
+    def _get_zero_degree_mask(cls, masked_matrix: gb.Matrix) -> np.ndarray:
+        degrees = masked_matrix.reduce_rowwise(gb.monoid.lor)
+        indices, _ = degrees.to_coo(indices=True, values=False, sort=False)
+        return np.logical_not(np.in1d(np.arange(masked_matrix.nrows), indices))  # type: ignore[attr-defined]
+
+    @staticmethod
+    def _get_mask_diff(old_mask: np.ndarray, new_mask: np.ndarray) -> List[int]:
+        return np.argwhere(old_mask != new_mask).ravel().tolist()

scaler/utility/identifiers.py

@@ -0,0 +1,107 @@
+import abc
+import hashlib
+import uuid
+from typing import Optional
+
+
+class Identifier(bytes, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __repr__(self) -> str:
+        raise NotImplementedError()
+
+
+class ClientID(Identifier):
+    def __repr__(self) -> str:
+        return f"ClientID({self.decode()})"
+
+    @staticmethod
+    def generate_client_id(name: Optional[str] = None) -> "ClientID":
+        unique_client_tag = uuid.uuid4().bytes.hex()
+
+        if name is None:
+            return ClientID(f"Client|{unique_client_tag}".encode())
+        else:
+            return ClientID(f"Client|{name}|{unique_client_tag}".encode())
+
+
+class WorkerID(Identifier):
+    def __repr__(self) -> str:
+        return f"WorkerID({self.decode()})"
+
+    def is_valid(self) -> bool:
+        return self != _INVALID_WORKER_ID
+
+    @staticmethod
+    def invalid_worker_id() -> "WorkerID":
+        return _INVALID_WORKER_ID
+
+    @staticmethod
+    def generate_worker_id(name: str) -> "WorkerID":
+        unique_worker_tag = uuid.uuid4().bytes.hex()
+        return WorkerID(f"Worker|{name}|{unique_worker_tag}".encode())
+
+
+_INVALID_WORKER_ID = WorkerID(b"")
+
+
+class ProcessorID(Identifier):
+    def __repr__(self) -> str:
+        return f"ProcessorID({self.hex()})"
+
+    @staticmethod
+    def generate_processor_id() -> "ProcessorID":
+        return ProcessorID(uuid.uuid4().bytes)
+
+
+class TaskID(Identifier):
+    def __repr__(self) -> str:
+        return f"TaskID({self.hex()})"
+
+    @staticmethod
+    def generate_task_id() -> "TaskID":
+        return TaskID(uuid.uuid4().bytes)
+
+
+class ObjectID(bytes):
+    SERIALIZER_TAG = hashlib.md5(b"serializer").digest()
+
+    """
+    Scaler 32-bytes object IDs.
+
+    Object ID are built from 2x16-bytes parts:
+
+    - the first 16-bytes uniquely identify the owner of the object (i.e. the Scaler client's hash);
+    - the second 16-bytes uniquely identify the object's content.
+    """
+
+    def __new__(cls, value: bytes):
+        if len(value) != 32:
+            raise ValueError("Scaler object ID must be 32 bytes.")
+
+        return super().__new__(cls, value)
+
+    @staticmethod
+    def generate_object_id(owner: ClientID) -> "ObjectID":
+        owner_hash = hashlib.md5(owner).digest()
+        unique_object_tag = uuid.uuid4().bytes
+        return ObjectID(owner_hash + unique_object_tag)
+
+    @staticmethod
+    def generate_serializer_object_id(owner: ClientID) -> "ObjectID":
+        owner_hash = hashlib.md5(owner).digest()
+        return ObjectID(owner_hash + ObjectID.SERIALIZER_TAG)
+
+    def owner_hash(self) -> bytes:
+        return self[:16]
+
+    def object_tag(self) -> bytes:
+        return self[16:]
+
+    def is_serializer(self) -> bool:
+        return self.object_tag() == ObjectID.SERIALIZER_TAG
+
+    def is_owner(self, owner: ClientID) -> bool:
+        return hashlib.md5(owner).digest() == self.owner_hash()
+
+    def __repr__(self) -> str:
+        return f"ObjectID(owner_hash={self.owner_hash().hex()}, object_tag={self.object_tag().hex()})"

scaler/utility/logging/decorators.py

@@ -0,0 +1,25 @@
+import functools
+import inspect
+import logging
+import typing
+
+from scaler.utility.logging.scoped_logger import ScopedLogger
+
+
+def log_function(level_number: int = 2, logging_level: int = logging.INFO) -> typing.Callable:
+    def decorator(func: typing.Callable) -> typing.Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with ScopedLogger(
+                f"execute {func.__name__} at {get_caller_location(level_number)}", logging_level=logging_level
+            ):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def get_caller_location(stack_level: int):
+    caller = inspect.getframeinfo(inspect.stack()[stack_level][0])
+    return f"{caller.filename}:{caller.lineno}"

scaler/utility/logging/scoped_logger.py

@@ -0,0 +1,33 @@
+import datetime
+import logging
+import time
+from typing import Optional
+
+
+class ScopedLogger:
+    def __init__(self, message: str, logging_level=logging.INFO):
+        self.timer = TimedLogger(message=message, logging_level=logging_level)
+
+    def __enter__(self):
+        self.timer.begin()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.timer.end()
+
+
+class TimedLogger:
+    def __init__(self, message: str, logging_level=logging.INFO):
+        self.message = message
+        self.logging_level = logging_level
+        self.timer: Optional[int] = None
+
+    def begin(self):
+        self.timer = time.perf_counter_ns()
+        logging.log(self.logging_level, f"beginning {self.message}")
+
+    def end(self):
+        elapsed = time.perf_counter_ns() - self.timer
+        offset = datetime.timedelta(
+            seconds=int(elapsed / 1e9), milliseconds=int(elapsed % 1e9 / 1e6), microseconds=int(elapsed % 1e6 / 1e3)
+        )
+        logging.log(self.logging_level, f"completed {self.message} in {offset}")

scaler/utility/logging/utility.py

@@ -0,0 +1,183 @@
+import dataclasses
+import enum
+import logging
+import logging.config
+import logging.handlers
+import os
+import typing
+
+from scaler.config.defaults import DEFAULT_LOGGING_PATHS
+
+
+class LogType(enum.Enum):
+    Screen = enum.auto()
+    File = enum.auto()
+
+
+@dataclasses.dataclass
+class LogPath:
+    log_type: LogType
+    path: str
+
+
+class LoggingLevel(enum.Enum):
+    CRITICAL = logging.CRITICAL
+    ERROR = logging.ERROR
+    WARNING = logging.WARNING
+    INFO = logging.INFO
+    DEBUG = logging.DEBUG
+    NOTSET = logging.NOTSET
+
+
+def setup_logger(
+    log_paths: typing.Tuple[str, ...] = DEFAULT_LOGGING_PATHS,
+    logging_config_file: typing.Optional[str] = None,
+    logging_level: str = LoggingLevel.INFO.name,
+):
+    if not log_paths and not logging_config_file:
+        return
+
+    if isinstance(log_paths, str):
+        log_paths = (log_paths,)
+
+    if logging_config_file is not None:
+        print(f"use logging config file: {logging_config_file}")
+        logging.config.fileConfig(logging_config_file, disable_existing_loggers=True)
+        return
+
+    resolved_log_paths = [LogPath(log_type=__detect_log_types(file_name), path=file_name) for file_name in log_paths]
+    __logging_config(log_paths=resolved_log_paths, logging_level=logging_level)
+    logging.info(f"logging to {log_paths}")
+
+
+def __detect_log_types(file_name: str) -> LogType:
+    if file_name in {"-", "/dev/stdout"}:
+        return LogType.Screen
+
+    return LogType.File
+
+
+def __format(name) -> str:
+    if not name:
+        return ""
+
+    return "%({name})s".format(name=name)
+
+
+def __generate_log_config() -> typing.Dict:
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,  # this fixes the problem
+        "formatters": {
+            "standard": {
+                "format": "[{levelname}]{asctime}: {message}".format(
+                    levelname=__format("levelname"), asctime=__format("asctime"), message=__format("message")
+                ),
+                "datefmt": "%Y-%m-%d %H:%M:%S%z",
+            },
+            "verbose": {
+                "format": "[{levelname}]{asctime}:{module}:{funcName}:{lineno}: {message}".format(
+                    levelname=__format("levelname"),
+                    asctime=__format("asctime"),
+                    module=__format("module"),
+                    funcName=__format("funcName"),
+                    lineno=__format("lineno"),
+                    message=__format("message"),
+                ),
+                "datefmt": "%Y-%m-%d %H:%M:%S%z",
+            },
+        },
+        "handlers": {},
+        "loggers": {"": {"handlers": [], "level": "DEBUG", "propagate": True}},
+    }
+
+
+def __logging_config(log_paths: typing.List[LogPath], logging_level: str = LoggingLevel.INFO.name):
+    logging.addLevelName(logging.INFO, "INFO")
+    logging.addLevelName(logging.WARNING, "WARN")
+    logging.addLevelName(logging.ERROR, "EROR")
+    logging.addLevelName(logging.DEBUG, "DEBG")
+    logging.addLevelName(logging.CRITICAL, "CTIC")
+
+    config = __generate_log_config()
+    handlers = config["handlers"]
+    root_loggers = config["loggers"][""]["handlers"]
+
+    for log_path in log_paths:
+        if log_path.log_type == LogType.Screen:
+            handlers["console"] = __create_stdout_handler(logging_level)
+            root_loggers.append("console")
+            continue
+
+        elif log_path.log_type == LogType.File:
+            handlers[log_path.path] = __create_time_rotating_file_handler(logging_level, log_path.path)
+            root_loggers.append(log_path.path)
+            continue
+
+        raise TypeError(f"Unsupported LogPath: {log_path}")
+
+    logging.config.dictConfig(config)
+
+
+def __create_stdout_handler(logging_level: str):
+    return {
+        "class": "logging.StreamHandler",
+        "level": logging_level,
+        "formatter": "standard",
+        "stream": "ext://sys.stdout",
+    }
+
+
+def __create_time_rotating_file_handler(logging_level: str, file_path: str):
+    return {
+        "class": "logging.handlers.TimedRotatingFileHandler",
+        "level": logging_level,
+        "formatter": "verbose",
+        "filename": os.path.expandvars(os.path.expanduser(file_path)),
+        "when": "midnight",
+    }
+
+
+def __create_size_rotating_file_handler(log_path) -> typing.Dict:
+    return {
+        "class": "logging.handlers.RotatingFileHandler",
+        "level": "INFO",
+        "formatter": "verbose",
+        "filename": os.path.expandvars(os.path.expanduser(log_path)),
+        "maxBytes": 10485760,
+        "backupCount": 20,
+        "encoding": "utf8",
+    }
+
+
+def __parse_logging_level(value):
+    return LoggingLevel(value).value
+
+
+def get_logger_info(logger: logging.Logger) -> typing.Tuple[str, str, typing.Tuple[str, ...]]:
+    """
+    Retrieves the format string, level string, and all active log paths from a logger's handlers.
+    """
+    log_level_str = logging.getLevelName(logger.getEffectiveLevel())
+    log_format_str = ""
+    log_paths: typing.List[str] = []
+
+    if logger.hasHandlers():
+        first_handler = logger.handlers[0]
+        if first_handler.formatter:
+            log_format_str = getattr(first_handler.formatter, "_fmt", "")
+
+        for handler in logger.handlers:
+            if isinstance(handler, logging.handlers.BaseRotatingHandler):
+                log_paths.append(handler.baseFilename)
+            elif isinstance(handler, logging.StreamHandler) and hasattr(handler.stream, "name"):
+                if "stdout" in handler.stream.name:
+                    log_paths.append("/dev/stdout")
+                elif "stderr" in handler.stream.name:
+                    log_paths.append("/dev/stderr")
+
+    # If no specific path was found, default to stdout
+    if not log_paths:
+        log_paths.append("/dev/stdout")
+
+    return log_format_str, log_level_str, tuple(log_paths)

scaler/utility/many_to_many_dict.py

@@ -0,0 +1,123 @@
+from typing import Dict, Generic, Iterable, Set, Tuple, TypeVar
+
+KeyT = TypeVar("KeyT")
+ValueT = TypeVar("ValueT")
+
+LeftKeyT = TypeVar("LeftKeyT")
+RightKeyT = TypeVar("RightKeyT")
+
+
+class ManyToManyDict(Generic[LeftKeyT, RightKeyT]):
+    def __init__(self):
+        self._left_key_to_right_key_set: _KeyValueDictSet[LeftKeyT, RightKeyT] = _KeyValueDictSet()
+        self._right_key_to_left_key_set: _KeyValueDictSet[RightKeyT, LeftKeyT] = _KeyValueDictSet()
+
+    def left_keys(self):
+        return self._left_key_to_right_key_set.keys()
+
+    def right_keys(self):
+        return self._right_key_to_left_key_set.keys()
+
+    def add(self, left_key: LeftKeyT, right_key: RightKeyT):
+        self._left_key_to_right_key_set.add(left_key, right_key)
+        self._right_key_to_left_key_set.add(right_key, left_key)
+
+    def remove(self, left_key: LeftKeyT, right_key: RightKeyT):
+        self._left_key_to_right_key_set.remove_value(left_key, right_key)
+        self._right_key_to_left_key_set.remove_value(right_key, left_key)
+
+    def has_left_key(self, left_key: LeftKeyT) -> bool:
+        return left_key in self._left_key_to_right_key_set
+
+    def has_right_key(self, right_key: RightKeyT) -> bool:
+        return right_key in self._right_key_to_left_key_set
+
+    def has_key_pair(self, left_key: LeftKeyT, right_key: RightKeyT) -> bool:
+        return (
+            self.has_left_key(left_key)
+            and self.has_right_key(right_key)
+            and right_key in self._left_key_to_right_key_set.get_values(left_key)
+            and left_key in self._right_key_to_left_key_set.get_values(right_key)
+        )
+
+    def left_key_items(self) -> Iterable[Tuple[LeftKeyT, Set[RightKeyT]]]:
+        return self._left_key_to_right_key_set.items()
+
+    def right_key_items(self) -> Iterable[Tuple[RightKeyT, Set[LeftKeyT]]]:
+        return self._right_key_to_left_key_set.items()
+
+    def get_left_items(self, right_key: RightKeyT) -> Set[LeftKeyT]:
+        if right_key not in self._right_key_to_left_key_set:
+            raise ValueError(f"cannot find {right_key=} in ManyToManyDict")
+
+        return self._right_key_to_left_key_set.get_values(right_key)
+
+    def get_right_items(self, left_key: LeftKeyT) -> Set[RightKeyT]:
+        if left_key not in self._left_key_to_right_key_set:
+            raise ValueError(f"cannot find {left_key=} in ManyToManyDict")
+
+        return self._left_key_to_right_key_set.get_values(left_key)
+
+    def remove_left_key(self, left_key: LeftKeyT) -> Set[RightKeyT]:
+        if left_key not in self._left_key_to_right_key_set:
+            raise KeyError(f"cannot find {left_key=} in ManyToManyDict")
+
+        right_keys = self._left_key_to_right_key_set.remove_key(left_key)
+        for right_key in right_keys:
+            self._right_key_to_left_key_set.remove_value(right_key, left_key)
+
+        return right_keys
+
+    def remove_right_key(self, right_key: RightKeyT) -> Set[LeftKeyT]:
+        if right_key not in self._right_key_to_left_key_set:
+            raise ValueError(f"cannot find {right_key=} in ManyToManyDict")
+
+        left_keys = self._right_key_to_left_key_set.remove_key(right_key)
+        for left_key in left_keys:
+            self._left_key_to_right_key_set.remove_value(left_key, right_key)
+
+        return left_keys
+
+
+class _KeyValueDictSet(Generic[KeyT, ValueT]):
+    def __init__(self):
+        self._key_to_value_set: Dict[KeyT, Set[ValueT]] = dict()
+
+    def __contains__(self, key) -> bool:
+        return key in self._key_to_value_set
+
+    def keys(self):
+        return self._key_to_value_set.keys()
+
+    def values(self):
+        return self._key_to_value_set.values()
+
+    def items(self):
+        return self._key_to_value_set.items()
+
+    def add(self, key: KeyT, value: ValueT):
+        if key not in self._key_to_value_set:
+            self._key_to_value_set[key] = set()
+
+        self._key_to_value_set[key].add(value)
+
+    def get_values(self, key: KeyT) -> Set[ValueT]:
+        if key not in self._key_to_value_set:
+            raise ValueError(f"cannot find {key=} in KeyValueSet")
+
+        return self._key_to_value_set[key]
+
+    def remove_key(self, key: KeyT) -> Set[ValueT]:
+        if key not in self._key_to_value_set:
+            raise KeyError(f"cannot find {key=} in KeyValueSet")
+
+        values = self._key_to_value_set.pop(key)
+        return values
+
+    def remove_value(self, key: KeyT, value: ValueT):
+        if key not in self._key_to_value_set:
+            raise KeyError(f"cannot find {key=} in KeyValueSet")
+
+        self._key_to_value_set[key].remove(value)
+        if not self._key_to_value_set[key]:
+            self._key_to_value_set.pop(key)

scaler/utility/metadata/profile_result.py

@@ -0,0 +1,31 @@
+import dataclasses
+import struct
+from typing import Optional
+
+from scaler.protocol.python.message import TaskResult
+
+
+@dataclasses.dataclass
+class ProfileResult:
+    duration_s: float = dataclasses.field(default=0.0)
+    memory_peak: int = dataclasses.field(default=0)
+    cpu_time_s: float = dataclasses.field(default=0.0)
+
+    FORMAT = "!fQf"  # duration, memory peak, CPU time
+
+    def serialize(self) -> bytes:
+        return struct.pack(self.FORMAT, self.duration_s, self.memory_peak, self.cpu_time_s)
+
+    @staticmethod
+    def deserialize(data: bytes) -> "ProfileResult":
+        return ProfileResult(*struct.unpack(ProfileResult.FORMAT, data))
+
+
+def retrieve_profiling_result_from_task_result(task_result: TaskResult) -> Optional[ProfileResult]:
+    if task_result.metadata == b"":
+        return None
+
+    try:
+        return ProfileResult.deserialize(task_result.metadata)
+    except struct.error:
+        raise ValueError(f"unexpected metadata value (expected {ProfileResult.__name__}).")