woob.core.ouiboube

Deprecated since version 3.0: Please use woob.core.woob instead.

class WoobBase(modules_path: Optional[str] = None, storage: Optional[IStorage] = None, scheduler: Optional[IScheduler] = None)

Bases: object

Woob class to load modules from a specific path, without deal with woob remote repositories.

It provides methods to build backends or call methods on all loaded backends.

You should use this class when you want to build an application using Woob as a library, without using the standard modules nor the automatic module download and update machanism. When using WoobBase, you have to explicitely provide module paths and deal yourself with backend configuration.

Parameters

• modules_path (str) – path to directory containing modules.

• storage (woob.tools.storage.IStorage) – provide a storage where backends can save data

• scheduler (woob.core.scheduler.IScheduler) – what scheduler to use; default is woob.core.scheduler.Scheduler

VERSION = '3.4'

deinit()

Call this method when you stop using Woob, to properly unload all correctly.

build_modules_loader() → ModulesLoader

Build the module loader for the current application.

This can be overridden by children to avoid overriding an already existing modules loader.

Return type

ModulesLoader

build_backend(module_name: str, params: Optional[dict] = None, storage: Optional[IStorage] = None, name: Optional[str] = None, nofail: bool = False, logger: Logger = None) → Module

Create a backend.

It does not load it into the Woob object, so you are responsible for deinitialization and calls.

Parameters

• module_name – name of module

• params (dict) – parameters to give to backend

• storage (woob.tools.storage.IStorage) – storage to use

• name (str) – name of backend

• nofail (bool) – if true, this call can’t fail

• logger (logging.Logger) – logger to use

Return type

woob.tools.backend.Module

exception LoadError(backend_name: str, exception: Exception)

Bases: Exception

Raised when a backend is unabled to load.

Parameters

• backend_name – name of backend we can’t load

• exception – exception object

load_backend(module_name: str, name: str, params: Optional[dict] = None, storage: IStorage = None, nofail: bool = False)

Load a backend.

Parameters

• module_name (str:) – name of module to load

• name (str) – name of instance

• params (dict) – parameters to give to backend

• storage (woob.tools.storage.IStorage) – storage to use

• nofail (bool) – if true, this call can’t fail

Return type

woob.tools.backend.Module

unload_backends(names: Optional[List[str]] = None) → Dict[str, Module]

Unload backends.

Parameters

names (list) – if specified, only unload that backends

get_backend(name: str, **kwargs) → Module

Get a backend from its name.

Parameters

• name (str) – name of backend to get

• default (whatever you want) – if specified, get this value when the backend is not found

Raises

KeyError if not found.

count_backends() → int

Get number of loaded backends.

iter_backends(caps: Optional[List[Capability]] = None, module: Optional[str] = None)

Iter on each backends.

Note: each backend is locked when it is returned.

Parameters

• caps (tuple[woob.capabilities.base.Capability]) – optional list of capabilities to select backends

• module (str) – optional name of module

Return type

iter[woob.tools.backend.Module]

do(function: Union[Callable, str], *args, **kwargs) → BackendsCall

Do calls on loaded backends with specified arguments, in separated threads.

This function has two modes:

• If function is a string, it calls the method with this name on each backends with the specified arguments;

• If function is a callable, it calls it in a separated thread with the locked backend instance at first arguments, and *args and **kwargs.

Parameters

• function (str) – backend’s method name, or a callable object

• backends (list[str]) – list of backends to iterate on

• caps (list[woob.capabilities.base.Capability]) – iterate on backends which implement this caps

Return type

A woob.core.bcall.BackendsCall object (iterable)

schedule(interval: int, function: Callable, *args) → Optional[int]

Schedule an event.

Parameters

• interval (int) – delay before calling the function

• function (callabale) – function to call

• args – arguments to give to function

Returns

an event identificator

repeat(interval: int, function: Callable, *args) → Optional[int]

Repeat a call to a function

Parameters

• interval (int) – interval between two calls

• function (callable) – function to call

• args – arguments to give to function

Returns

an event identificator

cancel(ev: int) → bool

Cancel an event

Parameters

ev – the event identificator

want_stop() → None

Plan to stop the scheduler.

loop()

Run the scheduler loop

load_or_install_module(module_name: str) → Module

Load a backend, but can’t install it

class Woob(workdir: Optional[str] = None, datadir: Optional[str] = None, backends_filename: Optional[str] = None, scheduler: Optional[IScheduler] = None, storage: Optional[IStorage] = None)

Bases: WoobBase

The main class of Woob, used to manage backends, modules repositories and call methods on all loaded backends.

Parameters

• workdir (str) – optional parameter to set path of the working directory

• datadir (str) – optional parameter to set path of the data directory

• backends_filename (str) – name of the backends file, where configuration of backends is stored

• storage (woob.tools.storage.IStorage) – provide a storage where backends can save data

BACKENDS_FILENAME = 'backends'

build_modules_loader() → RepositoryModulesLoader

Build the module loader for the current application.

Return type

ModulesLoader

update(progress: ~woob.core.repositories.IProgress = <PrintProgress>)

Update modules from repositories.

Parameters

progress (IProgress) – object notified when there is a progress

build_backend(module_name: str, params: Optional[Dict[str, str]] = None, storage: Optional[IStorage] = None, name: Optional[str] = None, nofail: Optional[bool] = False) → Module

Create a single backend which is not listed in configuration.

Parameters

• module_name (str) – name of module

• params (dict) – parameters to give to backend

• storage (woob.tools.storage.IStorage) – storage to use

• name (str) – name of backend

• nofail (bool) – if true, this call can’t fail

Return type

woob.tools.backend.Module

load_backends(caps: Optional[List[Union[Capability, str]]] = None, names: Optional[List[str]] = None, modules: Optional[List[str]] = None, exclude: Optional[List[str]] = None, storage: Optional[IStorage] = None, errors: Optional[List[LoadError]] = None) → Dict[str, Module]

Load backends listed in config file.

Parameters

• caps (tuple[woob.capabilities.base.Capability]) – load backends which implement all of specified caps

• names (tuple[str]) – load backends in list

• modules (tuple[str]) – load backends which module is in list

• exclude (tuple[str]) – do not load backends in list

• storage (woob.tools.storage.IStorage) – use this storage if specified

• errors (list[LoadError]) – if specified, store every errors in this list

Returns

loaded backends

Return type

dict[str, woob.tools.backend.Module]

load_or_install_module(module_name: str) → Module

Load a backend, and install it if not done before

exception VersionsMismatchError

Bases: ConfigError

Weboob

alias of Woob

WebNip

alias of WoobBase