def test_callable_with_paramspec(): P = ParamSpec("P") func_type = Callable[P, None] strategy = st.from_type(func_type) with pytest.raises( InvalidArgument, match= "Hypothesis can't yet construct a strategy for instances of a Callable type", ): strategy.example() with pytest.raises(InvalidArgument, match="Cannot register generic type"): st.register_type_strategy(func_type, st.none())
import functools from typing import Callable from typing import ParamSpec from typing import TypeVar P = ParamSpec('P') R = TypeVar('R') def prints_hi(f: Callable[P, R]) -> Callable[P, R]: @functools.wraps(f) def prints_hi_inner(*args: P.args, **kwargs: P.kwargs) -> R: print('ohai') return f(*args, **kwargs) return prints_hi_inner @prints_hi def hello(name: str) -> int: print(f'hello hello {name}') return 5 x = hello('anthony') print(x)
from __future__ import annotations from collections.abc import Iterable from functools import wraps from inspect import Parameter, signature from subprocess import CalledProcessError from typing import TYPE_CHECKING from .processing import identity from core.runner import subprocess_run if TYPE_CHECKING: from collections.abc import Callable, Collection, Mapping from typing import Any, cast, Optional, ParamSpec, TypeVar _P = ParamSpec("_P") _R = TypeVar("_R") def command( executable: Iterable[str], flag_overrides: Optional[Mapping[str, str]] = None, flag_repeats: Optional[Collection[str]] = None, processing: Callable[[str], _R] = identity, check_returncode: bool = True ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]: flag_overrides = flag_overrides or {} flag_repeats = flag_repeats or set() def decorator(function: Callable[_P, _R]) -> Callable[_P, _R]: @wraps(function) def decorated(*args: _P.args, **kwargs: _P.kwargs) -> _R:
# This sample tests error conditions for ParamSpec (PEP 612). from typing import Any, Callable, List, ParamSpec, Protocol, Tuple, cast TParams = ParamSpec("TParams") # This should generate an error because ParamSpecs # can't be used as a type annotation. def foo(a: TParams) -> int: return 1 a = 3 # This should generate an error. b = cast(TParams, a) foo(1) def func1(x: Callable[TParams, Any]): # This should generate an error. c: List[TParams] = [] d: Callable[TParams, int] # This should generate an error. e: Callable[TParams, TParams] # This should generate an error.
# This sample tests the type checker's handling of ParamSpec # and Concatenate as described in PEP 612. from typing import Callable, Concatenate, ParamSpec, TypeVar P = ParamSpec("P") R = TypeVar("R") class Request: ... def with_request(f: Callable[Concatenate[Request, P], R]) -> Callable[P, R]: def inner(*args: P.args, **kwargs: P.kwargs) -> R: return f(Request(), *args, **kwargs) return inner @with_request def takes_int_str(request: Request, x: int, y: str) -> int: # use request return x + 7 takes_int_str(1, "A") # This should generate an error because the first arg # is the incorrect type. takes_int_str("B", "A")
from sdcm.wait import exponential_retry LOGGER = logging.getLogger(__name__) INSTANCE_PROVISION_ON_DEMAND = 'on_demand' INSTANCE_PROVISION_SPOT_FLEET = 'spot_fleet' INSTANCE_PROVISION_SPOT_LOW_PRICE = 'spot_low_price' INSTANCE_PROVISION_SPOT_DURATION = 'spot_duration' SPOT_CNT_LIMIT = 20 SPOT_FLEET_LIMIT = 50 SPOT_TERMINATION_CHECK_OVERHEAD = 15 LOCAL_CMD_RUNNER = LocalCmdRunner() EBS_VOLUME = "attached" INSTANCE_STORE = "instance_store" P = ParamSpec("P") # pylint: disable=invalid-name R = TypeVar("R") # pylint: disable=invalid-name # pylint: disable=too-many-lines class AWSCluster(cluster.BaseCluster): # pylint: disable=too-many-instance-attributes,abstract-method, """ Cluster of Node objects, started on Amazon EC2. """ def __init__(self, ec2_ami_id, ec2_subnet_id, ec2_security_group_ids, # pylint: disable=too-many-arguments services, credentials, cluster_uuid=None, ec2_instance_type='c5.xlarge', ec2_ami_username='******', ec2_user_data='', ec2_block_device_mappings=None,
# This sample tests the handling of class specialization expressions # that provide signatures for ParamSpecs. from typing import Any, Callable, Concatenate, Generic, Literal, ParamSpec, TypeVar T = TypeVar("T") P1 = ParamSpec("P1") P2 = ParamSpec("P2") class X(Generic[T, P1]): f: Callable[P1, int] x: T def x1(x: X[int, P2]) -> str: ... def x2(x: X[int, Concatenate[int, P2]]) -> str: ... def X3(x: X[int, [int, bool]]) -> str: ... def x4(x: X[int, ...]) -> str: ...
signature, ) from typing import ( TypeVar, Callable, ) from .exceptions import ( PrototypeError, ) if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec # pragma: no cover Parameters = ParamSpec("Parameters") ReturnType = TypeVar("ReturnType") # noinspection PyTypeHints def prototype( proto: Callable[Parameters, ReturnType], /, *, runtime: bool = True, ) -> Callable[Parameters, ReturnType]: """ Prototype decorator acts like a type protection shield that validates the parameters specification and return type annotation of the function against given prototype.
# This sample tests error conditions for ParamSpec (PEP 612). from typing import Callable, List, ParamSpec, Tuple, cast TParams = ParamSpec("TParams") # This should generate an error because ParamSpecs # can't be used as a type annotation. def foo(a: TParams) -> int: return 1 a = 3 # This should generate an error. b = cast(TParams, a) # This should generate an error. foo(1) # This should generate an error. c: List[TParams] = [] d: Callable[TParams, int] # This should generate an error. e: Callable[TParams, TParams] # This should generate an error. f: Callable[[TParams], int]
# Copyright (c) 2022 Tulir Asokan # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. from __future__ import annotations from typing import Any import functools from mautrix import __optional_imports__ if __optional_imports__: from typing import Awaitable, Callable, ParamSpec Param = ParamSpec("Param") Func = Callable[Param, Awaitable[Any]] def async_getter_lock(fn: Func) -> Func: """ A utility decorator for locking async getters that have caches (preventing race conditions between cache check and e.g. async database actions). The class must have an ```_async_get_locks`` defaultdict that contains :class:`asyncio.Lock`s (see example for exact definition). Non-cache-affecting arguments should be only passed as keyword args. Args: fn: The function to decorate.
# This sample tests a complicated combination of ParamSpec usage. # pyright: strict from typing import Any, Callable, Concatenate, ParamSpec, Protocol, TypeVar _Fn = TypeVar("_Fn", bound=Callable[..., Any]) _Ret = TypeVar("_Ret") _Args = ParamSpec("_Args") _Self = TypeVar("_Self", bound="_GenerativeType") def decorator( target: Callable[Concatenate[_Fn, _Args], _Ret] ) -> Callable[[_Fn], Callable[_Args, _Ret]]: ... class _GenerativeType(Protocol): def _generate(self: "_Self") -> "_Self": ... def generative( fn: Callable[Concatenate[_Self, _Args], None] ) -> Callable[Concatenate[_Self, _Args], _Self]: @decorator def _generative( fn: Callable[Concatenate[_Self, _Args], None], self: _Self,
# This sample tests ParamSpec (PEP 612) behavior. from typing import ( Awaitable, Callable, Generic, Optional, ParamSpec, TypeVar, Union, overload, ) Ps = ParamSpec("Ps") R = TypeVar("R") async def log_to_database(): ... def add_logging(f: Callable[Ps, R]) -> Callable[Ps, Awaitable[R]]: async def inner(*args: Ps.args, **kwargs: Ps.kwargs) -> R: await log_to_database() return f(*args, **kwargs) return inner @add_logging def foo(x: int, y: str) -> int:
class BaseMixin: @pytest.fixture(autouse=True) def use_bot(self, bot: SpellBot) -> None: self.bot = bot @pytest.fixture(autouse=True) def use_settings(self, settings: Settings) -> None: self.settings = settings @pytest.fixture(autouse=True) def use_factories(self, factories: Factories) -> None: self.factories = factories CogT = TypeVar("CogT", bound=commands.Cog) CogCallbackP = ParamSpec("CogCallbackP") class InteractionMixin(BaseMixin): interaction: discord.Interaction @pytest.fixture(autouse=True, name="interaction") def use_interaction( self, interaction: discord.Interaction) -> discord.Interaction: self.interaction = interaction return self.interaction @pytest.fixture def add_guild(self, factories: Factories) -> Callable[..., Guild]: return factories.guild.create
sprite_idx: float = _default() @dataclass class _LayerPolyOutput: vs_out: 'out_t'[_VS_OUT] = _out_t_default() @dataclass class _poly(_LayerUniform): ... _buffer_type = _frag | _poly _NamedFnP = ParamSpec('_NamedFnP') _NamedFnR = TypeVar('_NamedFnR') _NamedFnStage = Literal['frag', 'poly', 'any'] def lib( stage: _NamedFnStage ) -> Callable[[Callable[_NamedFnP, _NamedFnR]], Callable[_NamedFnP, _NamedFnR]]: def deco( f: Callable[_NamedFnP, _NamedFnR]) -> Callable[_NamedFnP, _NamedFnR]: def wrapper(_stage: _NamedFnStage = stage, *args: _NamedFnP.args, **kwargs: _NamedFnP.kwargs) -> _NamedFnR: return f(*args, **kwargs)