diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 0000000000..a9eef2804f --- /dev/null +++ b/tests/README.md @@ -0,0 +1,93 @@ +# Synthetic Performance Tests + +This directory contains synthetic Python workloads used to stress-test Pyrefly indexing and type-solving throughput. + +## Structure + +- `perf/scale_test/`: Generated "synthetic enterprise" package with dense type annotations, deep inheritance, and import meshes. + +## Scale Test Goals + +The scale test workload is designed to apply pressure to: + +1. Deep recursive solving paths in inheritance hierarchies. +2. Generic and protocol-heavy type relationships. +3. Inter-module dependency graph construction. +4. File-volume and line-volume indexing throughput. + +## Generator + +The scale test modules are produced by: + +- `perf/scale_test/generate_stress_test.py` + +Requirements: + +- Python 3.12+ available as `python3` (macOS/Linux) or `py -3` (Windows). +- Run commands from the repository root. + +Optional virtual environment setup: + +```bash +python3 -m venv .venv +source .venv/bin/activate +python3 -m pip install --upgrade pip +``` + +Windows PowerShell equivalent: + +```powershell +py -3 -m venv .venv +.\.venv\Scripts\Activate.ps1 +py -3 -m pip install --upgrade pip +``` + +Run from repository root: + +```bash +python3 tests/perf/scale_test/generate_stress_test.py --core-only +``` + +Windows PowerShell equivalent: + +```powershell +py -3 tests/perf/scale_test/generate_stress_test.py --core-only +``` + +Generate full suite (default: 120 modules, min 520 lines each): + +```bash +python3 tests/perf/scale_test/generate_stress_test.py +``` + +Windows PowerShell equivalent: + +```powershell +py -3 tests/perf/scale_test/generate_stress_test.py +``` + +Customize generation: + +```bash +python3 tests/perf/scale_test/generate_stress_test.py \ + --module-count 150 \ + --min-lines 700 +``` + +Windows PowerShell equivalent: + +```powershell +py -3 tests/perf/scale_test/generate_stress_test.py --module-count 150 --min-lines 700 +``` + +## Expected Core Outputs + +Running with `--core-only` emits the initial five baseline modules: + +- `base_types.py` +- `data_layer.py` +- `service_mesh.py` +- `domain_models.py` +- `orchestration.py` + +All generated files are valid Python and intentionally large to provide stable stress-testing inputs. diff --git a/tests/perf/scale_test/__init__.py b/tests/perf/scale_test/__init__.py new file mode 100644 index 0000000000..87075031ea --- /dev/null +++ b/tests/perf/scale_test/__init__.py @@ -0,0 +1,15 @@ +"""Synthetic enterprise stress-test package for Pyrefly.""" + +from . import base_types +from . import data_layer +from . import service_mesh +from . import domain_models +from . import orchestration + +__all__ = [ + "base_types", + "data_layer", + "service_mesh", + "domain_models", + "orchestration" +] diff --git a/tests/perf/scale_test/base_types.py b/tests/perf/scale_test/base_types.py new file mode 100644 index 0000000000..05d8efc87f --- /dev/null +++ b/tests/perf/scale_test/base_types.py @@ -0,0 +1,2640 @@ +"""base_types module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +import tests.perf.scale_test.orchestration as upstream_1 +import tests.perf.scale_test.data_layer as downstream_1 +import tests.perf.scale_test.domain_models as upstream_2 +import tests.perf.scale_test.service_mesh as downstream_2 +import tests.perf.scale_test.service_mesh as upstream_3 +import tests.perf.scale_test.domain_models as downstream_3 +import tests.perf.scale_test.data_layer as upstream_4 +import tests.perf.scale_test.orchestration as downstream_4 + +# Circular import mesh for indexer stress tests. +_MESH_IMPORTS = (upstream_1, downstream_1, upstream_2, downstream_2, upstream_3, downstream_3, upstream_4, downstream_4,) +_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] for module in _MESH_IMPORTS) + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + + +class BaseTypesProtocol0(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_0" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode0(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol1(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_1" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode1(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol2(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_2" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode2(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol3(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_3" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode3(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol4(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_4" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode4(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol5(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_5" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode5(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol6(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_6" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode6(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol7(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_7" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode7(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol8(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_8" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode8(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol9(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_9" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode9(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol10(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_10" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode10(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol11(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_11" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode11(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol12(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_12" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode12(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol13(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_13" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode13(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol14(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_14" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode14(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol15(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_15" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode15(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol16(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_16" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode16(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class BaseTypesProtocol17(Protocol[T, U]): + label: ClassVar[str] = "base_types_protocol_17" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class BaseTypesGenericNode17(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + + +class BaseTypesRoot0(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain0Level1(BaseTypesRoot0[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level2(BaseTypesChain0Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level3(BaseTypesChain0Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level4(BaseTypesChain0Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level5(BaseTypesChain0Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level6(BaseTypesChain0Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level7(BaseTypesChain0Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain0Level8(BaseTypesChain0Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot1(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain1Level1(BaseTypesRoot1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level2(BaseTypesChain1Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level3(BaseTypesChain1Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level4(BaseTypesChain1Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level5(BaseTypesChain1Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level6(BaseTypesChain1Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level7(BaseTypesChain1Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain1Level8(BaseTypesChain1Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot2(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain2Level1(BaseTypesRoot2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level2(BaseTypesChain2Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level3(BaseTypesChain2Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level4(BaseTypesChain2Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level5(BaseTypesChain2Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level6(BaseTypesChain2Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level7(BaseTypesChain2Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain2Level8(BaseTypesChain2Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot3(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain3Level1(BaseTypesRoot3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level2(BaseTypesChain3Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level3(BaseTypesChain3Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level4(BaseTypesChain3Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level5(BaseTypesChain3Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level6(BaseTypesChain3Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level7(BaseTypesChain3Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain3Level8(BaseTypesChain3Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot4(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain4Level1(BaseTypesRoot4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level2(BaseTypesChain4Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level3(BaseTypesChain4Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level4(BaseTypesChain4Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level5(BaseTypesChain4Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level6(BaseTypesChain4Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level7(BaseTypesChain4Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain4Level8(BaseTypesChain4Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot5(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain5Level1(BaseTypesRoot5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level2(BaseTypesChain5Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level3(BaseTypesChain5Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level4(BaseTypesChain5Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level5(BaseTypesChain5Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level6(BaseTypesChain5Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level7(BaseTypesChain5Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain5Level8(BaseTypesChain5Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot6(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain6Level1(BaseTypesRoot6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level2(BaseTypesChain6Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level3(BaseTypesChain6Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level4(BaseTypesChain6Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level5(BaseTypesChain6Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level6(BaseTypesChain6Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level7(BaseTypesChain6Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain6Level8(BaseTypesChain6Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot7(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain7Level1(BaseTypesRoot7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level2(BaseTypesChain7Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level3(BaseTypesChain7Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level4(BaseTypesChain7Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level5(BaseTypesChain7Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level6(BaseTypesChain7Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level7(BaseTypesChain7Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain7Level8(BaseTypesChain7Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesRoot8(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class BaseTypesChain8Level1(BaseTypesRoot8[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level2(BaseTypesChain8Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level3(BaseTypesChain8Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level4(BaseTypesChain8Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level5(BaseTypesChain8Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level6(BaseTypesChain8Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level7(BaseTypesChain8Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class BaseTypesChain8Level8(BaseTypesChain8Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + + +class BaseTypesService0(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService1(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService2(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService3(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService4(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService5(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService6(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService7(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService8(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService9(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService10(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService11(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService12(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService13(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService14(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService15(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService16(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService17(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService18(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService19(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService20(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class BaseTypesService21(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + + +def build_base_types_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="base_types", + ordinal=1071, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + +def run_base_types_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + +__all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_base_types_descriptor", + "run_base_types_pipeline", +] diff --git a/tests/perf/scale_test/data_layer.py b/tests/perf/scale_test/data_layer.py new file mode 100644 index 0000000000..57cddbdee4 --- /dev/null +++ b/tests/perf/scale_test/data_layer.py @@ -0,0 +1,2640 @@ +"""data_layer module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +import tests.perf.scale_test.base_types as upstream_1 +import tests.perf.scale_test.service_mesh as downstream_1 +import tests.perf.scale_test.orchestration as upstream_2 +import tests.perf.scale_test.domain_models as downstream_2 +import tests.perf.scale_test.domain_models as upstream_3 +import tests.perf.scale_test.orchestration as downstream_3 +import tests.perf.scale_test.service_mesh as upstream_4 +import tests.perf.scale_test.base_types as downstream_4 + +# Circular import mesh for indexer stress tests. +_MESH_IMPORTS = (upstream_1, downstream_1, upstream_2, downstream_2, upstream_3, downstream_3, upstream_4, downstream_4,) +_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] for module in _MESH_IMPORTS) + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + + +class DataLayerProtocol0(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_0" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode0(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol1(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_1" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode1(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol2(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_2" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode2(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol3(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_3" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode3(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol4(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_4" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode4(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol5(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_5" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode5(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol6(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_6" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode6(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol7(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_7" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode7(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol8(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_8" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode8(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol9(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_9" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode9(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol10(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_10" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode10(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol11(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_11" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode11(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol12(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_12" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode12(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol13(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_13" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode13(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol14(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_14" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode14(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol15(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_15" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode15(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol16(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_16" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode16(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DataLayerProtocol17(Protocol[T, U]): + label: ClassVar[str] = "data_layer_protocol_17" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DataLayerGenericNode17(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + + +class DataLayerRoot0(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain0Level1(DataLayerRoot0[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level2(DataLayerChain0Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level3(DataLayerChain0Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level4(DataLayerChain0Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level5(DataLayerChain0Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level6(DataLayerChain0Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level7(DataLayerChain0Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain0Level8(DataLayerChain0Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot1(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain1Level1(DataLayerRoot1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level2(DataLayerChain1Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level3(DataLayerChain1Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level4(DataLayerChain1Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level5(DataLayerChain1Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level6(DataLayerChain1Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level7(DataLayerChain1Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain1Level8(DataLayerChain1Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot2(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain2Level1(DataLayerRoot2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level2(DataLayerChain2Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level3(DataLayerChain2Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level4(DataLayerChain2Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level5(DataLayerChain2Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level6(DataLayerChain2Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level7(DataLayerChain2Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain2Level8(DataLayerChain2Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot3(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain3Level1(DataLayerRoot3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level2(DataLayerChain3Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level3(DataLayerChain3Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level4(DataLayerChain3Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level5(DataLayerChain3Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level6(DataLayerChain3Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level7(DataLayerChain3Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain3Level8(DataLayerChain3Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot4(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain4Level1(DataLayerRoot4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level2(DataLayerChain4Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level3(DataLayerChain4Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level4(DataLayerChain4Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level5(DataLayerChain4Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level6(DataLayerChain4Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level7(DataLayerChain4Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain4Level8(DataLayerChain4Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot5(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain5Level1(DataLayerRoot5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level2(DataLayerChain5Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level3(DataLayerChain5Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level4(DataLayerChain5Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level5(DataLayerChain5Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level6(DataLayerChain5Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level7(DataLayerChain5Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain5Level8(DataLayerChain5Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot6(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain6Level1(DataLayerRoot6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level2(DataLayerChain6Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level3(DataLayerChain6Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level4(DataLayerChain6Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level5(DataLayerChain6Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level6(DataLayerChain6Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level7(DataLayerChain6Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain6Level8(DataLayerChain6Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot7(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain7Level1(DataLayerRoot7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level2(DataLayerChain7Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level3(DataLayerChain7Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level4(DataLayerChain7Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level5(DataLayerChain7Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level6(DataLayerChain7Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level7(DataLayerChain7Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain7Level8(DataLayerChain7Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerRoot8(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DataLayerChain8Level1(DataLayerRoot8[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level2(DataLayerChain8Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level3(DataLayerChain8Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level4(DataLayerChain8Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level5(DataLayerChain8Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level6(DataLayerChain8Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level7(DataLayerChain8Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DataLayerChain8Level8(DataLayerChain8Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + + +class DataLayerService0(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService1(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService2(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService3(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService4(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService5(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService6(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService7(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService8(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService9(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService10(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService11(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService12(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService13(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService14(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService15(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService16(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService17(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService18(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService19(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService20(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DataLayerService21(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + + +def build_data_layer_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="data_layer", + ordinal=1046, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + +def run_data_layer_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + +__all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_data_layer_descriptor", + "run_data_layer_pipeline", +] diff --git a/tests/perf/scale_test/domain_models.py b/tests/perf/scale_test/domain_models.py new file mode 100644 index 0000000000..baae9b4538 --- /dev/null +++ b/tests/perf/scale_test/domain_models.py @@ -0,0 +1,2640 @@ +"""domain_models module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +import tests.perf.scale_test.service_mesh as upstream_1 +import tests.perf.scale_test.orchestration as downstream_1 +import tests.perf.scale_test.data_layer as upstream_2 +import tests.perf.scale_test.base_types as downstream_2 +import tests.perf.scale_test.base_types as upstream_3 +import tests.perf.scale_test.data_layer as downstream_3 +import tests.perf.scale_test.orchestration as upstream_4 +import tests.perf.scale_test.service_mesh as downstream_4 + +# Circular import mesh for indexer stress tests. +_MESH_IMPORTS = (upstream_1, downstream_1, upstream_2, downstream_2, upstream_3, downstream_3, upstream_4, downstream_4,) +_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] for module in _MESH_IMPORTS) + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + + +class DomainModelsProtocol0(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_0" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode0(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol1(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_1" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode1(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol2(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_2" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode2(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol3(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_3" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode3(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol4(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_4" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode4(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol5(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_5" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode5(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol6(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_6" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode6(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol7(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_7" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode7(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol8(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_8" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode8(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol9(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_9" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode9(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol10(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_10" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode10(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol11(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_11" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode11(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol12(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_12" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode12(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol13(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_13" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode13(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol14(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_14" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode14(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol15(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_15" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode15(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol16(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_16" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode16(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class DomainModelsProtocol17(Protocol[T, U]): + label: ClassVar[str] = "domain_models_protocol_17" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class DomainModelsGenericNode17(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + + +class DomainModelsRoot0(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain0Level1(DomainModelsRoot0[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level2(DomainModelsChain0Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level3(DomainModelsChain0Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level4(DomainModelsChain0Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level5(DomainModelsChain0Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level6(DomainModelsChain0Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level7(DomainModelsChain0Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain0Level8(DomainModelsChain0Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot1(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain1Level1(DomainModelsRoot1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level2(DomainModelsChain1Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level3(DomainModelsChain1Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level4(DomainModelsChain1Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level5(DomainModelsChain1Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level6(DomainModelsChain1Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level7(DomainModelsChain1Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain1Level8(DomainModelsChain1Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot2(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain2Level1(DomainModelsRoot2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level2(DomainModelsChain2Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level3(DomainModelsChain2Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level4(DomainModelsChain2Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level5(DomainModelsChain2Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level6(DomainModelsChain2Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level7(DomainModelsChain2Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain2Level8(DomainModelsChain2Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot3(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain3Level1(DomainModelsRoot3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level2(DomainModelsChain3Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level3(DomainModelsChain3Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level4(DomainModelsChain3Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level5(DomainModelsChain3Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level6(DomainModelsChain3Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level7(DomainModelsChain3Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain3Level8(DomainModelsChain3Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot4(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain4Level1(DomainModelsRoot4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level2(DomainModelsChain4Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level3(DomainModelsChain4Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level4(DomainModelsChain4Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level5(DomainModelsChain4Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level6(DomainModelsChain4Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level7(DomainModelsChain4Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain4Level8(DomainModelsChain4Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot5(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain5Level1(DomainModelsRoot5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level2(DomainModelsChain5Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level3(DomainModelsChain5Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level4(DomainModelsChain5Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level5(DomainModelsChain5Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level6(DomainModelsChain5Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level7(DomainModelsChain5Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain5Level8(DomainModelsChain5Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot6(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain6Level1(DomainModelsRoot6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level2(DomainModelsChain6Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level3(DomainModelsChain6Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level4(DomainModelsChain6Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level5(DomainModelsChain6Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level6(DomainModelsChain6Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level7(DomainModelsChain6Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain6Level8(DomainModelsChain6Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot7(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain7Level1(DomainModelsRoot7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level2(DomainModelsChain7Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level3(DomainModelsChain7Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level4(DomainModelsChain7Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level5(DomainModelsChain7Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level6(DomainModelsChain7Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level7(DomainModelsChain7Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain7Level8(DomainModelsChain7Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsRoot8(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class DomainModelsChain8Level1(DomainModelsRoot8[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level2(DomainModelsChain8Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level3(DomainModelsChain8Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level4(DomainModelsChain8Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level5(DomainModelsChain8Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level6(DomainModelsChain8Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level7(DomainModelsChain8Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class DomainModelsChain8Level8(DomainModelsChain8Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + + +class DomainModelsService0(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService1(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService2(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService3(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService4(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService5(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService6(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService7(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService8(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService9(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService10(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService11(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService12(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService13(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService14(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService15(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService16(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService17(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService18(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService19(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService20(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class DomainModelsService21(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + + +def build_domain_models_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="domain_models", + ordinal=1371, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + +def run_domain_models_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + +__all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_domain_models_descriptor", + "run_domain_models_pipeline", +] diff --git a/tests/perf/scale_test/generate_stress_test.py b/tests/perf/scale_test/generate_stress_test.py new file mode 100644 index 0000000000..1d63706455 --- /dev/null +++ b/tests/perf/scale_test/generate_stress_test.py @@ -0,0 +1,542 @@ +#!/usr/bin/env python3 +"""Generate a synthetic enterprise Python codebase for Pyrefly scale testing. + +This script creates a large, strongly-typed module graph that is intended +to stress test: + +1. Recursive class hierarchy solving in the type engine. +2. Generic and protocol-heavy constraint resolution. +3. Import graph indexing and dependency traversal. +4. Throughput on large file counts and large module sizes. + +The generated modules are deterministic and valid Python code. +""" + +from __future__ import annotations + +import argparse +from pathlib import Path +from textwrap import dedent + +DEFAULT_MODULE_COUNT = 120 +MIN_LINE_COUNT = 520 +CORE_MODULES = [ + "base_types", + "data_layer", + "service_mesh", + "domain_models", + "orchestration", +] + + +HEADER_TEMPLATE = '''\ +"""{module_name} module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +{import_block} + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + +''' + + +def _import_block( + module_name: str, + module_names: list[str], + depth: int = 4, +) -> str: + """Build interconnected import block for mesh-like dependency traversal.""" + index = module_names.index(module_name) + imports: list[str] = [] + aliases: list[str] = [] + for offset in range(1, depth + 1): + prev_name = module_names[(index - offset) % len(module_names)] + next_name = module_names[(index + offset) % len(module_names)] + prev_alias = f"upstream_{offset}" + next_alias = f"downstream_{offset}" + imports.append( + f"import tests.perf.scale_test.{prev_name} as {prev_alias}") + imports.append( + f"import tests.perf.scale_test.{next_name} as {next_alias}") + aliases.extend([prev_alias, next_alias]) + if imports: + imports.append("") + imports.append("# Circular import mesh for indexer stress tests.") + imports.append("_MESH_IMPORTS = (" + ", ".join(aliases) + ",)") + imports.append( + "_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] " + "for module in _MESH_IMPORTS)" + ) + return "\n".join(imports) + return "" + + +def _protocol_section(module_name: str, section_size: int) -> str: + """Generate protocol and generic abstraction section.""" + lines: list[str] = [] + root_name = module_name.title().replace("_", "") + for i in range(section_size): + lines.append( + dedent( + f''' + class {root_name}Protocol{i}(Protocol[T, U]): + label: ClassVar[str] = "{module_name}_protocol_{i}" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + + class {root_name}GenericNode{i}(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + ''' + ).strip() + ) + return "\n\n".join(lines) + + +def _inheritance_section( + module_name: str, + chain_count: int, + depth: int = 8, +) -> str: + """Generate deep inheritance chains between 5 and 10 levels.""" + lines: list[str] = [] + root = module_name.title().replace("_", "") + for chain in range(chain_count): + previous = f"{root}Root{chain}" + lines.append( + dedent( + f''' + class {previous}(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + ''' + ).strip() + ) + for level in range(1, depth + 1): + current = f"{root}Chain{chain}Level{level}" + lines.append( + dedent( + f''' + class {current}({previous}[T]): + def project(self) -> T: + candidate = super().project() + return candidate + ''' + ).strip() + ) + previous = current + return "\n\n".join(lines) + + +def _services_section(module_name: str, section_size: int) -> str: + """Generate typed service interfaces and implementations.""" + lines: list[str] = [] + root = module_name.title().replace("_", "") + for i in range(section_size): + lines.append( + dedent( + f''' + class {root}Service{i}(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + ''' + ).strip() + ) + return "\n\n".join(lines) + + +def _entrypoint_section(module_name: str) -> str: + """Generate deterministic public API entry points for each module.""" + ordinal = sum(ord(ch) for ch in module_name) % 10000 + return dedent( + f''' + def build_{module_name}_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="{module_name}", + ordinal={ordinal}, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + + def run_{module_name}_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], + ) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + + __all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_{module_name}_descriptor", + "run_{module_name}_pipeline", + ] + ''' + ).strip() + + +def _render_module( + module_name: str, + module_names: list[str], + min_lines: int, +) -> str: + """Render a module and pad it to the minimum target line count.""" + sections: list[str] = [] + sections.append( + HEADER_TEMPLATE.format( + module_name=module_name, + import_block=_import_block(module_name, module_names), + ).strip() + ) + sections.append(_protocol_section(module_name, section_size=18)) + sections.append(_inheritance_section(module_name, chain_count=9, depth=8)) + sections.append(_services_section(module_name, section_size=22)) + sections.append(_entrypoint_section(module_name)) + + module_body = "\n\n\n".join(sections).strip() + "\n" + lines = module_body.splitlines() + + if len(lines) < min_lines: + filler_index = 0 + while len(lines) < min_lines: + lines.extend( + [ + "", + f"def _filler_symbol_{filler_index}(value: int) -> int:", + ' """Filler function for deterministic file size."""', + f" return value + {filler_index}", + ] + ) + filler_index += 1 + + return "\n".join(lines) + "\n" + + +def _build_module_names(module_count: int) -> list[str]: + """Construct module names with core modules first.""" + if module_count < len(CORE_MODULES): + raise ValueError( + "module_count must be >= " + f"{len(CORE_MODULES)} to include core modules" + ) + names = list(CORE_MODULES) + for i in range(module_count - len(CORE_MODULES)): + names.append(f"generated_module_{i:03d}") + return names + + +def generate_modules( + output_dir: Path, + module_count: int, + min_lines: int, + core_only: bool, +) -> list[Path]: + """Generate synthetic enterprise modules in the output directory. + + Args: + output_dir: Destination directory for generated modules. + module_count: Number of modules to generate. + min_lines: Minimum line count for each generated module. + core_only: When true, emit only the first five core modules. + + Returns: + Paths to generated module files. + """ + output_dir.mkdir(parents=True, exist_ok=True) + module_names = _build_module_names(module_count) + selected_names = CORE_MODULES if core_only else module_names + dependency_names = selected_names if core_only else module_names + + written: list[Path] = [] + for module_name in selected_names: + destination = output_dir / f"{module_name}.py" + destination.write_text( + _render_module(module_name, dependency_names, min_lines=min_lines), + encoding="utf-8", + ) + written.append(destination) + + init_file = output_dir / "__init__.py" + exports = "\n".join(f"from . import {name}" for name in selected_names) + all_exports = ",\n ".join(f'"{name}"' for name in selected_names) + init_file.write_text( + ( + '"""Synthetic enterprise stress-test package for Pyrefly."""\n\n' + + exports + + "\n\n" + + "__all__ = [\n " + + all_exports + + "\n]\n" + ), + encoding="utf-8", + ) + + return written + + +def parse_args() -> argparse.Namespace: + """Parse command-line arguments.""" + parser = argparse.ArgumentParser( + description="Generate synthetic enterprise stress-test Python modules." + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("tests/perf/scale_test"), + help="Directory where modules are generated.", + ) + parser.add_argument( + "--module-count", + type=int, + default=DEFAULT_MODULE_COUNT, + help="Total number of modules to generate.", + ) + parser.add_argument( + "--min-lines", + type=int, + default=MIN_LINE_COUNT, + help="Minimum line count per generated file.", + ) + parser.add_argument( + "--core-only", + action="store_true", + help="Generate only the five core modules.", + ) + return parser.parse_args() + + +def main() -> None: + """Generate modules and print a concise summary.""" + args = parse_args() + written = generate_modules( + output_dir=args.output_dir, + module_count=args.module_count, + min_lines=args.min_lines, + core_only=args.core_only, + ) + print( + f"Generated {len(written)} module(s) in {args.output_dir} " + f"with minimum {args.min_lines} lines each." + ) + + +if __name__ == "__main__": + main() diff --git a/tests/perf/scale_test/orchestration.py b/tests/perf/scale_test/orchestration.py new file mode 100644 index 0000000000..89cc75c3f1 --- /dev/null +++ b/tests/perf/scale_test/orchestration.py @@ -0,0 +1,2640 @@ +"""orchestration module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +import tests.perf.scale_test.domain_models as upstream_1 +import tests.perf.scale_test.base_types as downstream_1 +import tests.perf.scale_test.service_mesh as upstream_2 +import tests.perf.scale_test.data_layer as downstream_2 +import tests.perf.scale_test.data_layer as upstream_3 +import tests.perf.scale_test.service_mesh as downstream_3 +import tests.perf.scale_test.base_types as upstream_4 +import tests.perf.scale_test.domain_models as downstream_4 + +# Circular import mesh for indexer stress tests. +_MESH_IMPORTS = (upstream_1, downstream_1, upstream_2, downstream_2, upstream_3, downstream_3, upstream_4, downstream_4,) +_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] for module in _MESH_IMPORTS) + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + + +class OrchestrationProtocol0(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_0" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode0(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol1(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_1" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode1(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol2(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_2" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode2(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol3(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_3" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode3(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol4(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_4" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode4(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol5(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_5" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode5(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol6(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_6" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode6(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol7(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_7" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode7(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol8(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_8" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode8(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol9(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_9" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode9(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol10(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_10" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode10(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol11(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_11" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode11(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol12(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_12" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode12(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol13(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_13" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode13(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol14(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_14" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode14(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol15(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_15" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode15(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol16(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_16" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode16(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class OrchestrationProtocol17(Protocol[T, U]): + label: ClassVar[str] = "orchestration_protocol_17" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class OrchestrationGenericNode17(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + + +class OrchestrationRoot0(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain0Level1(OrchestrationRoot0[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level2(OrchestrationChain0Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level3(OrchestrationChain0Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level4(OrchestrationChain0Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level5(OrchestrationChain0Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level6(OrchestrationChain0Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level7(OrchestrationChain0Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain0Level8(OrchestrationChain0Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot1(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain1Level1(OrchestrationRoot1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level2(OrchestrationChain1Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level3(OrchestrationChain1Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level4(OrchestrationChain1Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level5(OrchestrationChain1Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level6(OrchestrationChain1Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level7(OrchestrationChain1Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain1Level8(OrchestrationChain1Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot2(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain2Level1(OrchestrationRoot2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level2(OrchestrationChain2Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level3(OrchestrationChain2Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level4(OrchestrationChain2Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level5(OrchestrationChain2Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level6(OrchestrationChain2Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level7(OrchestrationChain2Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain2Level8(OrchestrationChain2Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot3(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain3Level1(OrchestrationRoot3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level2(OrchestrationChain3Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level3(OrchestrationChain3Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level4(OrchestrationChain3Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level5(OrchestrationChain3Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level6(OrchestrationChain3Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level7(OrchestrationChain3Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain3Level8(OrchestrationChain3Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot4(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain4Level1(OrchestrationRoot4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level2(OrchestrationChain4Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level3(OrchestrationChain4Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level4(OrchestrationChain4Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level5(OrchestrationChain4Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level6(OrchestrationChain4Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level7(OrchestrationChain4Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain4Level8(OrchestrationChain4Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot5(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain5Level1(OrchestrationRoot5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level2(OrchestrationChain5Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level3(OrchestrationChain5Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level4(OrchestrationChain5Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level5(OrchestrationChain5Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level6(OrchestrationChain5Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level7(OrchestrationChain5Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain5Level8(OrchestrationChain5Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot6(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain6Level1(OrchestrationRoot6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level2(OrchestrationChain6Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level3(OrchestrationChain6Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level4(OrchestrationChain6Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level5(OrchestrationChain6Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level6(OrchestrationChain6Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level7(OrchestrationChain6Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain6Level8(OrchestrationChain6Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot7(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain7Level1(OrchestrationRoot7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level2(OrchestrationChain7Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level3(OrchestrationChain7Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level4(OrchestrationChain7Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level5(OrchestrationChain7Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level6(OrchestrationChain7Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level7(OrchestrationChain7Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain7Level8(OrchestrationChain7Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationRoot8(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class OrchestrationChain8Level1(OrchestrationRoot8[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level2(OrchestrationChain8Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level3(OrchestrationChain8Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level4(OrchestrationChain8Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level5(OrchestrationChain8Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level6(OrchestrationChain8Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level7(OrchestrationChain8Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class OrchestrationChain8Level8(OrchestrationChain8Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + + +class OrchestrationService0(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService1(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService2(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService3(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService4(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService5(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService6(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService7(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService8(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService9(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService10(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService11(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService12(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService13(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService14(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService15(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService16(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService17(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService18(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService19(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService20(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class OrchestrationService21(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + + +def build_orchestration_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="orchestration", + ordinal=1413, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + +def run_orchestration_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + +__all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_orchestration_descriptor", + "run_orchestration_pipeline", +] diff --git a/tests/perf/scale_test/service_mesh.py b/tests/perf/scale_test/service_mesh.py new file mode 100644 index 0000000000..9c5a8be280 --- /dev/null +++ b/tests/perf/scale_test/service_mesh.py @@ -0,0 +1,2640 @@ +"""service_mesh module for synthetic enterprise scale testing. + +This file is auto-generated by generate_stress_test.py. + +The module intentionally includes: +- Deep inheritance chains. +- Protocol and Generic-heavy APIs. +- Nested Callable, Union, and Mapping type signatures. +- Interconnected imports to form a dense dependency graph. + +The purpose is to stress Pyrefly's indexing and type-solving performance. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import ( + Any, + Callable, + ClassVar, + Concatenate, + cast, + Generic, + Mapping, + MutableMapping, + ParamSpec, + Protocol, + Sequence, + TypeVar, + TypeVarTuple, + Union, + Unpack, + runtime_checkable, +) + +import tests.perf.scale_test.data_layer as upstream_1 +import tests.perf.scale_test.domain_models as downstream_1 +import tests.perf.scale_test.base_types as upstream_2 +import tests.perf.scale_test.orchestration as downstream_2 +import tests.perf.scale_test.orchestration as upstream_3 +import tests.perf.scale_test.base_types as downstream_3 +import tests.perf.scale_test.domain_models as upstream_4 +import tests.perf.scale_test.data_layer as downstream_4 + +# Circular import mesh for indexer stress tests. +_MESH_IMPORTS = (upstream_1, downstream_1, upstream_2, downstream_2, upstream_3, downstream_3, upstream_4, downstream_4,) +_MESH_NAMES = tuple(module.__name__.rsplit('.', maxsplit=1)[-1] for module in _MESH_IMPORTS) + +T = TypeVar("T") +U = TypeVar("U") +K = TypeVar("K") +V = TypeVar("V") +P = ParamSpec("P") +Ts = TypeVarTuple("Ts") +R = TypeVar("R") +PayloadT = TypeVar("PayloadT", bound="PayloadProtocol") + + +@runtime_checkable +class PayloadProtocol(Protocol): + identity: str + + def to_mapping(self) -> Mapping[str, Any]: + ... + + +@runtime_checkable +class RepositoryProtocol(Protocol[T]): + def load(self, key: str) -> T: + ... + + def save(self, key: str, value: T) -> None: + ... + + +class CallableFallback(Generic[K, V]): + def __init__(self, factory: Callable[[K], V]) -> None: + self.factory = factory + + def __call__(self, key: K) -> V: + return self.factory(key) + + +class GenericEnvelope(Generic[T, U]): + def __init__(self, payload: T, metadata: U) -> None: + self.payload = payload + self.metadata = metadata + + def map_payload(self, mapper: Callable[[T], V]) -> "GenericEnvelope[V, U]": + return GenericEnvelope(mapper(self.payload), self.metadata) + + def fold( + self, + combiner: Callable[[T, U], V], + ) -> V: + return combiner(self.payload, self.metadata) + + def apply_callable( + self, + fn: Callable[Concatenate[T, P], R], + *args: P.args, + **kwargs: P.kwargs, + ) -> R: + return fn(self.payload, *args, **kwargs) + + +def _variadic_payload(*items: Unpack[Ts]) -> tuple[Unpack[Ts]]: + return items + + +@dataclass +class ModuleDescriptor: + name: str + ordinal: int + upstream: str + downstream: str + + +def _chain_transform( + value: Union[str, int, float], + steps: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + """Apply a chain of transformations to a value. + + Args: + value: Initial value to be transformed. + steps: Ordered transformation callables. + + Returns: + The final transformed value after all functions are applied. + """ + current: Union[str, int, float] = value + for step in steps: + current = step(current) + return current + + +class ServiceMeshProtocol0(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_0" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode0(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol1(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_1" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode1(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol2(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_2" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode2(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol3(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_3" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode3(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol4(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_4" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode4(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol5(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_5" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode5(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol6(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_6" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode6(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol7(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_7" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode7(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol8(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_8" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode8(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol9(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_9" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode9(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol10(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_10" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode10(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol11(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_11" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode11(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol12(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_12" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode12(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol13(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_13" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode13(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol14(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_14" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode14(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol15(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_15" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode15(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol16(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_16" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode16(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + +class ServiceMeshProtocol17(Protocol[T, U]): + label: ClassVar[str] = "service_mesh_protocol_17" + + def evaluate( + self, + payload: T, + metadata: U, + callback: Callable[[Union[T, U]], Union[T, U]], + ) -> Union[T, U]: + ... + + def evaluate_variadic( + self, + callback: Callable[[tuple[Unpack[Ts]]], Union[T, U]], + *items: Unpack[Ts], + ) -> Union[T, U]: + ... + + +class ServiceMeshGenericNode17(Generic[T, U]): + def __init__( + self, + key: str, + value: T, + metadata: U, + ) -> None: + self.key = key + self.value = value + self.metadata = metadata + + def pipeline( + self, + stages: Sequence[ + Callable[[Union[T, U]], Union[T, U]] + ], + ) -> Union[T, U]: + state: Union[T, U] = self.value + for stage in stages: + state = stage(state) + return state + + def variadic_pipeline( + self, + callback: Callable[Concatenate[T, P], U], + *args: P.args, + **kwargs: P.kwargs, + ) -> U: + return callback(self.value, *args, **kwargs) + + +class ServiceMeshRoot0(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain0Level1(ServiceMeshRoot0[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level2(ServiceMeshChain0Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level3(ServiceMeshChain0Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level4(ServiceMeshChain0Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level5(ServiceMeshChain0Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level6(ServiceMeshChain0Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level7(ServiceMeshChain0Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain0Level8(ServiceMeshChain0Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot1(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain1Level1(ServiceMeshRoot1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level2(ServiceMeshChain1Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level3(ServiceMeshChain1Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level4(ServiceMeshChain1Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level5(ServiceMeshChain1Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level6(ServiceMeshChain1Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level7(ServiceMeshChain1Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain1Level8(ServiceMeshChain1Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot2(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain2Level1(ServiceMeshRoot2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level2(ServiceMeshChain2Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level3(ServiceMeshChain2Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level4(ServiceMeshChain2Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level5(ServiceMeshChain2Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level6(ServiceMeshChain2Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level7(ServiceMeshChain2Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain2Level8(ServiceMeshChain2Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot3(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain3Level1(ServiceMeshRoot3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level2(ServiceMeshChain3Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level3(ServiceMeshChain3Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level4(ServiceMeshChain3Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level5(ServiceMeshChain3Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level6(ServiceMeshChain3Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level7(ServiceMeshChain3Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain3Level8(ServiceMeshChain3Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot4(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain4Level1(ServiceMeshRoot4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level2(ServiceMeshChain4Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level3(ServiceMeshChain4Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level4(ServiceMeshChain4Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level5(ServiceMeshChain4Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level6(ServiceMeshChain4Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level7(ServiceMeshChain4Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain4Level8(ServiceMeshChain4Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot5(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain5Level1(ServiceMeshRoot5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level2(ServiceMeshChain5Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level3(ServiceMeshChain5Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level4(ServiceMeshChain5Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level5(ServiceMeshChain5Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level6(ServiceMeshChain5Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level7(ServiceMeshChain5Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain5Level8(ServiceMeshChain5Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot6(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain6Level1(ServiceMeshRoot6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level2(ServiceMeshChain6Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level3(ServiceMeshChain6Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level4(ServiceMeshChain6Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level5(ServiceMeshChain6Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level6(ServiceMeshChain6Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level7(ServiceMeshChain6Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain6Level8(ServiceMeshChain6Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot7(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain7Level1(ServiceMeshRoot7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level2(ServiceMeshChain7Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level3(ServiceMeshChain7Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level4(ServiceMeshChain7Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level5(ServiceMeshChain7Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level6(ServiceMeshChain7Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level7(ServiceMeshChain7Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain7Level8(ServiceMeshChain7Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshRoot8(Generic[T]): + def __init__(self, payload: T) -> None: + self.payload = payload + + def project(self) -> T: + return self.payload + +class ServiceMeshChain8Level1(ServiceMeshRoot8[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level2(ServiceMeshChain8Level1[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level3(ServiceMeshChain8Level2[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level4(ServiceMeshChain8Level3[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level5(ServiceMeshChain8Level4[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level6(ServiceMeshChain8Level5[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level7(ServiceMeshChain8Level6[T]): + def project(self) -> T: + candidate = super().project() + return candidate + +class ServiceMeshChain8Level8(ServiceMeshChain8Level7[T]): + def project(self) -> T: + candidate = super().project() + return candidate + + +class ServiceMeshService0(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService1(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService2(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService3(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService4(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService5(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService6(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService7(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService8(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService9(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService10(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService11(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService12(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService13(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService14(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService15(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService16(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService17(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService18(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService19(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService20(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + +class ServiceMeshService21(Generic[K, V]): + def __init__(self, storage: MutableMapping[K, V]) -> None: + self.storage = storage + + def transact( + self, + key: K, + fallback: Union[V, CallableFallback[K, V]], + mutator: Callable[[Union[V, K]], Union[V, K]], + ) -> V: + if key in self.storage: + current: Union[V, K] = self.storage[key] + elif isinstance(fallback, CallableFallback): + current = fallback(key) + else: + current = fallback + next_value = mutator(current) + if isinstance(next_value, type(key)): + raise TypeError( + "Mutator returned key-like value" + ) + resolved_value = cast(V, next_value) + self.storage[key] = resolved_value + return resolved_value + + def compose( + self, + operators: Sequence[ + Callable[[Mapping[K, V]], Mapping[K, V]] + ], + ) -> Mapping[K, V]: + result: Mapping[K, V] = dict(self.storage) + for operator in operators: + result = operator(result) + return result + + def run_with_context( + self, + key: K, + callback: Callable[Concatenate[K, P], V], + *args: P.args, + **kwargs: P.kwargs, + ) -> V: + value = callback(key, *args, **kwargs) + self.storage[key] = value + return value + + def vectorize( + self, + *items: Unpack[Ts], + ) -> tuple[Unpack[Ts]]: + return items + + +def build_service_mesh_descriptor() -> ModuleDescriptor: + return ModuleDescriptor( + name="service_mesh", + ordinal=1277, + upstream="tests.perf.scale_test", + downstream="tests.perf.scale_test", + ) + + +def run_service_mesh_pipeline( + payload: Union[str, int, float], + actions: Sequence[ + Callable[[Union[str, int, float]], Union[str, int, float]] + ], +) -> Union[str, int, float]: + return _chain_transform(payload, actions) + + +__all__ = [ + "PayloadProtocol", + "RepositoryProtocol", + "CallableFallback", + "GenericEnvelope", + "ModuleDescriptor", + "build_service_mesh_descriptor", + "run_service_mesh_pipeline", +]