a_sync.a_sync.modifiers package

Subpackages

Submodules

a_sync.a_sync.modifiers.limiter module

a_sync.a_sync.modifiers.limiter.apply_rate_limit(coro_fn=None, runs_per_minute=None)[source]
Parameters:
Return type:

Callable[[Callable[[~P], Awaitable[T]]], Callable[[~P], Awaitable[T]]] | Callable[[~P], Awaitable[T]]

a_sync.a_sync.modifiers.manager module

class a_sync.a_sync.modifiers.manager.ModifierManager[source]

Bases: Dict[str, Any]

__getitem__(modifier_key)[source]

x.__getitem__(y) <==> x[y]

Parameters:

modifier_key (str)

__init__(modifiers)[source]
Parameters:

modifiers (ModifierKwargs)

Return type:

None

__iter__()[source]

Implement iter(self).

Return type:

Iterator[str]

apply_async_modifiers(coro_fn)[source]
Parameters:

coro_fn (Callable[[~P], Awaitable[T]])

Return type:

Callable[[~P], Awaitable[T]]

apply_sync_modifiers(function)[source]
Parameters:

function (Callable[[~P], T])

Return type:

Callable[[~P], T]

clear() → None.  Remove all items from D.
copy() → a shallow copy of D
fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items[source]
Return type:

ItemsView[str, Any]

keys() → a set-like object providing a view on D's keys[source]
Return type:

KeysView[str]

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from dict/iterable E and F.

If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values[source]
Return type:

ValuesView[Any]

_modifiers
cache_type: Literal['memory', None]
cache_typed: bool
default: Literal['sync', 'async', None]
executor: Executor
ram_cache_maxsize: int | None
ram_cache_ttl: int | None
runs_per_minute: int | None
semaphore: Semaphore | int | None
property use_cache: bool
property use_limiter: bool
property use_semaphore: bool

a_sync.a_sync.modifiers.semaphores module

a_sync.a_sync.modifiers.semaphores.apply_semaphore(coro_fn=None, semaphore=None)[source]
Parameters:
Return type:

Callable[[Callable[[~P], Awaitable[T]]], Callable[[~P], Awaitable[T]]] | Callable[[~P], Awaitable[T]]

Module contents

a_sync.a_sync.modifiers.apply_class_defined_modifiers(attrs_from_metaclass)[source]
Parameters:

attrs_from_metaclass (dict)

a_sync.a_sync.modifiers.get_modifiers_from(thing)[source]
Parameters:

thing (dict | type | object)

Return type:

ModifierKwargs