adaptix.provider package#

Module contents#

exception adaptix.provider.CannotProvide(
message: str = '',
*,
is_terminal: bool = False,
is_demonstrative: bool = False,
)#

Bases: Exception

exception adaptix.provider.AggregateCannotProvide(
message: str,
exceptions: Sequence[CannotProvide],
*,
is_terminal: bool = False,
is_demonstrative: bool = False,
)#

Bases: ExceptionGroup[CannotProvide], CannotProvide

derive(
excs: Sequence[CannotProvide],
) → AggregateCannotProvide#
derive_upcasting(
excs: Sequence[CannotProvide],
) → CannotProvide#

Same as method derive but allow passing an empty sequence

classmethod make(
message: str,
exceptions: Sequence[CannotProvide],
*,
is_terminal: bool = False,
is_demonstrative: bool = False,
) → CannotProvide#
class adaptix.provider.Mediator#

Bases: ABC, Generic[V]

Mediator is an object that gives provider access to other providers and that stores the state of the current search.

Mediator is a proxy to providers of retort.

abstract provide(
request: Request[T],
) → T#

Get response of sent request.

Parameters:

request – A request instance

Returns:

Result of the request processing

Raises:

CannotProvide – A provider able to process the request does not be found

abstract provide_from_next() → V#

Forward current request to providers that placed after current provider at the recipe.

final delegating_provide(
request: Request[T],
error_describer: Callable[[CannotProvide], str] | None = None,
) → T#
final mandatory_provide(
request: Request[T],
error_describer: Callable[[CannotProvide], str] | None = None,
) → T#
final mandatory_provide_by_iterable(
requests: Iterable[Request[T]],
error_describer: Callable[[], str] | None = None,
) → Iterable[T]#
class adaptix.provider.Provider#

Bases: ABC

An object that can process Request instances

abstract apply_provider(
mediator: Mediator[T],
request: Request[T],
) → T#

Handle request instance and return a value of type required by request. Behavior must be the same during the provider object lifetime

Raises:

CannotProvide – provider cannot process passed request

class adaptix.provider.Request#

Bases: Generic[T]

An object that contains data to be processed by Provider.

Generic argument indicates which object should be returned after request processing.

Request must always be a hashable object

class adaptix.provider.Chain(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)#

Bases: Enum

FIRST = 'FIRST'#
LAST = 'LAST'#
class adaptix.provider.LocStackPattern(
stack: Tuple[LocStackChecker, ...],
)#

Bases: object

property ANY: AnyLocStackChecker#
generic_arg(
pos: int,
pred: str | Pattern | type | Any | LocStackChecker | LocStackPattern,
) → Pat#
build_loc_stack_checker() → LocStackChecker#
adaptix.provider.create_loc_stack_checker(
pred: str | Pattern | type | Any | LocStackChecker | LocStackPattern,
) → LocStackChecker#