incant package - incant 23.2.0.dev0 documentation

Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# incant package

## Module contents

class incant.Hook(predicate: Callable[[Parameter], bool], factory: Tuple[Callable[[Parameter], Callable], Literal['sync', 'async'] | None] | None)

  Bases: `object`

  factory: Tuple[Callable[[Parameter], Callable], Literal['sync', 'async'] | None] | None
  classmethod for_name(name: str, hook: Callable | None) → Hook
  classmethod for_type(type: Any, hook: Callable | None) → Hook

    Register by exact type (subclasses won’t match).

  predicate: Callable[[Parameter], bool]

exception incant.IncantError

  Bases: `Exception`

  An Incant error.

class incant.Incanter(hook_factory_registry: List[Hook] = _Nothing.NOTHING)

  Bases: `object`

  A registry of _hooks_, used for function composition.

  Hooks use predicate functions to define rules of how they bind to function arguments.

  async acompose_and_call(fn: Callable[[...], Awaitable[R]], *args, **kwargs) → R

    Compose fn as async and call it with the given parameters.

  adapt(fn: Callable[[...], R], *args: Callable[[Parameter], bool], **kwargs: Callable[[Parameter], bool]) → Callable[[...], R]

    Adapt fn for incantation.

    Args and kwargs shape the signature of the produced function.

  async aincant(fn: Callable[[...], Awaitable[R]], *args, **kwargs) → R

    Invoke async fn the best way we can.

  async ainvoke(fn: Callable[[...], Awaitable[R]], *args, **kwargs) → R

    Compose fn as async and call it with the given parameters.

  compose(fn: Callable[[...], R], hooks: Sequence[Hook] = (), is_async: bool | None = None, forced_deps: Sequence[Callable | Tuple[Callable, Literal['sync', 'async']]] = ()) → Callable[[...], R]

    Compose fn with its satisfied dependencies, potentially creating a new function.

    Parameters:

      forced_deps – A sequence of dependencies that will be used even if fn doesn’t require them explicitly.

  compose_and_call(fn: Callable[[...], R], *args, **kwargs) → R

    Compose fn and call it with the given parameters.

  hook_factory_registry: List[Hook]
  incant(fn: Callable[[...], R], *args, **kwargs) → R

    Invoke fn the best way we can.

  invoke(fn: Callable[[...], R], *args, **kwargs) → R

    Compose fn and call it with the given parameters.

  register_by_name(fn: Callable | None = None, *, name: str | None = None, is_ctx_manager: Literal['sync', 'async'] | None = None)

    Register a factory to be injected by name. Can also be used as a decorator.

    If the name is not provided, the name of the factory will be used.

  register_by_type(fn: Callable | Type, type: Type | None = None, is_ctx_manager: Literal['sync', 'async'] | None = None)

    Register a factory to be injected by type. Can also be used as a decorator.

    If the type is not provided, the return annotation from the factory will be used.

  register_hook(predicate: Callable[[Parameter], bool], factory: Callable, is_ctx_manager: Literal['sync', 'async'] | None = None) → None

    Register a hook to be used for function composition.

    Parameters:

      - predicate – A predicate function, should return True if this hook should be used to fulfill a function parameter.

      - factory – The function that will be called to fulfil a function parameter.

      - is_ctx_manager – Is the factory a context manager?

  register_hook_factory(predicate: Callable[[Parameter], bool], hook_factory: Callable[[Parameter], Callable], is_ctx_manager: Literal['sync', 'async'] | None = None) → None

class incant.Override(name: str | None = None, annotation: ~typing.Any = <object object>)

  Bases: `object`

  annotation: Any
  name: str | None