def register_account(klass, account):
        """
        Register an account on website

        This is a static method, it would be called even if the backend is
        instancied.

        @param account  an Account object which describe the account to create
        """
        browser = None
        bday, bmonth, byear = account.properties['birthday'].get().split('/', 2)
        while not browser:
            try:
                browser = klass.BROWSER(account.properties['username'].get())
                browser.register(password=   account.properties['password'].get(),
                                 sex=        (0 if account.properties['sex'].get() == 'm' else 1),
                                 birthday_d= int(bday),
                                 birthday_m= int(bmonth),
                                 birthday_y= int(byear),
                                 zipcode=    account.properties['zipcode'].get(),
                                 country=    account.properties['country'].get(),
                                 godfather=  account.properties['godfather'].get())
            except CaptchaError:
                getLogger('aum').info('Unable to resolve captcha. Retrying...')
                browser = None

 def ICON(klass):
     try:
         import xdg.IconTheme
     except ImportError:
         getLogger(klass.NAME).debug(u'Python xdg module was not found. Please install it to read icon files.')
     else:
         return xdg.IconTheme.getIconPath(klass.NAME)

    def __init__(self, weboob, name, config, storage, logger=None):
        self.logger = getLogger(name, parent=logger)
        self.weboob = weboob
        self.name = name
        self.lock = RLock()

        # Private fields (which start with '_')
        self._private_config = dict([(key, value) for key, value in config.iteritems() if key.startswith('_')])

        # Configuration of backend
        self.config = {}
        for name, field in self.CONFIG.iteritems():
            value = config.get(name, None)

            if value is None:
                if field.required:
                    raise BaseBackend.ConfigError('Backend(%s): Configuration error: Missing parameter "%s" (%s)' % (self.name, name, field.description))
                value = field.default

            try:
                field.set_value(value)
            except ValueError, v:
                raise BaseBackend.ConfigError('Backend(%s): Configuration error for field "%s": %s' % (self.name, name, v))

            # field.value is a property which converts string to right type (bool/int/float)
            self.config[name] = field.value

 def print_debug(self, value):
     logger = getLogger('b2filters')
     result = ''
     outputvalue = value
     if isinstance(value, list):
         from lxml import etree
         outputvalue = ''
         first = True
         for element in value:
             if first:
                 first = False
             else:
                 outputvalue += ', '
             if isinstance(element, etree.ElementBase):
                 outputvalue += "%s" % etree.tostring(element, encoding=unicode)
             else:
                 outputvalue += "%r" % element
     if self._obj is not None:
         result += "%s" % self._obj._random_id
     if self._key is not None:
         result += ".%s" % self._key
     name = str(self)
     result += " %s(%r" % (name, outputvalue)
     for arg in self.__dict__:
         if arg.startswith('_') or arg == u"selector":
             continue
         if arg == u'default' and getattr(self, arg) == _NO_DEFAULT:
             continue
         result += ", %s=%r" % (arg, getattr(self, arg))
     result += u')'
     logger.log(DEBUG_FILTERS, result)
     res = function(self, value)
     return res

 def __init__(self, option_parser=None):
     self.logger = getLogger(self.APPNAME)
     self.weboob = self.create_weboob()
     if self.CONFDIR is None:
         self.CONFDIR = self.weboob.workdir
     self.config = None
     self.options = None
     self.condition = None
     if option_parser is None:
         self._parser = OptionParser(self.SYNOPSIS, version=self._get_optparse_version())
     else:
         self._parser = option_parser
     if self.DESCRIPTION:
         self._parser.description = self.DESCRIPTION
     app_options = OptionGroup(self._parser, '%s Options' % self.APPNAME.capitalize())
     self.add_application_options(app_options)
     if len(app_options.option_list) > 0:
         self._parser.add_option_group(app_options)
     self._parser.add_option('-b', '--backends', help='what backend(s) to enable (comma separated)')
     self._parser.add_option('-e', '--exclude-backends', help='what backend(s) to exclude (comma separated)')
     self._parser.add_option('-I', '--insecure', action='store_true', help='do not validate SSL')
     logging_options = OptionGroup(self._parser, 'Logging Options')
     logging_options.add_option('-d', '--debug', action='store_true', help='display debug messages')
     logging_options.add_option('-q', '--quiet', action='store_true', help='display only error messages')
     logging_options.add_option('-v', '--verbose', action='store_true', help='display info messages')
     logging_options.add_option('--logging-file', action='store', type='string', dest='logging_file', help='file to save logs')
     logging_options.add_option('-a', '--save-responses', action='store_true', help='save every response')
     self._parser.add_option_group(logging_options)
     self._parser.add_option('--shell-completion', action='store_true', help=optparse.SUPPRESS_HELP)

 def __init__(self, option_parser=None):
     self.logger = getLogger(self.APPNAME)
     self.weboob = self.create_weboob()
     self.config = None
     self.options = None
     if option_parser is None:
         self._parser = OptionParser(self.SYNOPSIS, version=self._get_optparse_version())
     else:
         self._parser = option_parser
     if self.DESCRIPTION:
         self._parser.description = self.DESCRIPTION
     app_options = OptionGroup(self._parser, "%s Options" % self.APPNAME.capitalize())
     self.add_application_options(app_options)
     if len(app_options.option_list) > 0:
         self._parser.add_option_group(app_options)
     self._parser.add_option("-b", "--backends", help="what backend(s) to enable (comma separated)")
     logging_options = OptionGroup(self._parser, "Logging Options")
     logging_options.add_option("-d", "--debug", action="store_true", help="display debug messages")
     logging_options.add_option("-q", "--quiet", action="store_true", help="display only error messages")
     logging_options.add_option("-v", "--verbose", action="store_true", help="display info messages")
     logging_options.add_option(
         "--logging-file", action="store", type="string", dest="logging_file", help="file to save logs"
     )
     logging_options.add_option("-a", "--save-responses", action="store_true", help="save every response")
     self._parser.add_option_group(logging_options)
     self._parser.add_option("--shell-completion", action="store_true", help=optparse.SUPPRESS_HELP)

 def __init__(self, browser, document, url='', groups=None, group_dict=None, logger=None):
     self.browser = browser
     self.document = document
     self.url = url
     self.groups = groups
     self.group_dict = group_dict
     self.logger = getLogger('page', logger)

 def __init__(self, option_parser=None):
     super(Application, self).__init__()
     self.encoding = self.guess_encoding()
     self.logger = getLogger(self.APPNAME)
     self.weboob = self.create_weboob()
     if self.CONFDIR is None:
         self.CONFDIR = self.weboob.workdir
     self.config = None
     self.options = None
     self.condition = None
     self.storage = None
     if option_parser is None:
         self._parser = OptionParser(self.SYNOPSIS, version=self._get_optparse_version())
     else:
         self._parser = option_parser
     if self.DESCRIPTION:
         self._parser.description = self.DESCRIPTION
     app_options = OptionGroup(self._parser, '%s Options' % self.APPNAME.capitalize())
     self.add_application_options(app_options)
     if len(app_options.option_list) > 0:
         self._parser.add_option_group(app_options)
     self._parser.add_option('-b', '--backends', help='what backend(s) to enable (comma separated)')
     self._parser.add_option('-e', '--exclude-backends', help='what backend(s) to exclude (comma separated)')
     self._parser.add_option('-I', '--insecure', action='store_true', help='do not validate SSL')
     self._parser.add_option('--nss', action='store_true', help='Use NSS instead of OpenSSL')
     logging_options = OptionGroup(self._parser, 'Logging Options')
     logging_options.add_option('-d', '--debug', action='count', help='display debug messages. Set up it twice to more verbosity', default=0)
     logging_options.add_option('-q', '--quiet', action='store_true', help='display only error messages')
     logging_options.add_option('-v', '--verbose', action='store_true', help='display info messages')
     logging_options.add_option('--logging-file', action='store', type='string', dest='logging_file', help='file to save logs')
     logging_options.add_option('-a', '--save-responses', action='store_true', help='save every response')
     logging_options.add_option('--export-session', action='store_true', help='log browser session cookies after login')
     self._parser.add_option_group(logging_options)
     self._parser.add_option('--shell-completion', action='store_true', help=optparse.SUPPRESS_HELP)
     self._is_default_count = True

    def __init__(self, workdir, datadir, version):
        self.logger = getLogger('repositories')
        self.version = version
        WeboobBrowser.set_version(version)

        self.workdir = workdir
        self.datadir = datadir
        self.sources_list = os.path.join(self.workdir, self.SOURCES_LIST)
        self.modules_dir = os.path.join(self.datadir, self.MODULES_DIR)
        self.repos_dir = os.path.join(self.datadir, self.REPOS_DIR)
        self.keyrings_dir = os.path.join(self.datadir, self.KEYRINGS_DIR)
        self.icons_dir = os.path.join(self.datadir, self.ICONS_DIR)

        self.create_dir(self.datadir)
        self.create_dir(self.modules_dir)
        self.create_dir(self.repos_dir)
        self.create_dir(self.keyrings_dir)
        self.create_dir(self.icons_dir)

        self.versions = Versions(self.modules_dir)

        self.repositories = []

        if not os.path.exists(self.sources_list):
            with open(self.sources_list, 'w') as f:
                f.write(DEFAULT_SOURCES_LIST)
            self.update()
        else:
            self.load()

    def __init__(self, backends, condition, function, *args, **kwargs):
        """
        @param backends  list of backends to call.
        @param condition  a IResultsCondition object. Can be None.
        @param function  backends' method name, or callable object.
        @param args, kwargs  arguments given to called functions.
        """
        self.logger = getLogger('bcall')
        # Store if a backend is finished
        self.backends = {}
        for backend in backends:
            self.backends[backend.name] = False
        # Condition
        self.condition = condition
        # Global mutex on object
        self.mutex = RLock()
        # Event set when every backends have give their data
        self.finish_event = Event()
        # Event set when there are new responses
        self.response_event = Event()
        # Waiting responses
        self.responses = []
        # Errors
        self.errors = []
        # Threads
        self.threads = []

        # Create jobs for each backend
        with self.mutex:
            for backend in backends:
                self.logger.debug('Creating a new thread for %s' % backend)
                self.threads.append(Timer(0, self._caller, (backend, function, args, kwargs)).start())
            if not backends:
                self.finish_event.set()

    def __init__(self, sched, storage, browser):
        self._sched = sched
        self._storage = storage
        self._browser = browser
        self._logger = getLogger('walker', browser.logger)

        self._view_cron = None

    def __init__(self, backends, function, *args, **kwargs):
        """
        :param backends: List of backends to call
        :type backends: list[:class:`BaseBackend`]
        :param function: backends' method name, or callable object.
        :type function: :class:`str` or :class:`callable`
        """
        self.logger = getLogger('bcall')
        # Store if a backend is finished
        self.backends = {}
        for backend in backends:
            self.backends[backend.name] = False
        # Global mutex on object
        self.mutex = RLock()
        # Event set when every backends have give their data
        self.finish_event = Event()
        # Event set when there are new responses
        self.response_event = Event()
        # Waiting responses
        self.responses = []
        # Errors
        self.errors = []
        # Threads
        self.threads = []

        # Create jobs for each backend
        with self.mutex:
            for backend in backends:
                self.threads.append(Timer(0, self._caller, (backend, function, args, kwargs)).start())
            if not backends:
                self.finish_event.set()

    def __init__(self, workdir=WORKDIR, backends_filename=None, scheduler=None, storage=None):
        self.logger = getLogger('weboob')
        self.workdir = workdir
        self.backend_instances = {}

        # Scheduler
        if scheduler is None:
            scheduler = Scheduler()
        self.scheduler = scheduler

        # Create WORKDIR
        if not os.path.exists(self.workdir):
            os.mkdir(self.workdir, 0700)
        elif not os.path.isdir(self.workdir):
            self.logger.warning(u'"%s" is not a directory' % self.workdir)

        # Backends loader
        self.modules_loader = ModulesLoader()

        # Backend instances config
        if not backends_filename:
            backends_filename = os.path.join(self.workdir, self.BACKENDS_FILENAME)
        elif not backends_filename.startswith('/'):
            backends_filename = os.path.join(self.workdir, backends_filename)
        self.backends_config = BackendsConfig(backends_filename)

        # Storage
        self.storage = storage

    def __init__(self, sched, storage, browser):
        super(ProfilesWalker, self).__init__()
        self._sched = sched
        self._storage = storage
        self._browser = browser
        self._logger = getLogger('walker', browser.logger)
        self._last_position_update = None

        self._view_cron = None

    def __init__(self, sched, storage, browser):
        self.sched = sched
        self.storage = storage
        self.browser = browser
        self.logger = getLogger('queriesqueue', browser.logger)

        self.queue = storage.get('queries_queue', 'queue', default=[])

        self.check_cron = None

    def __init__(self, logger=None, proxy=None, responses_dirname=None):
        self.logger = getLogger('browser', logger)
        self.PROXIES = proxy
        self._setup_session(self.PROFILE)
        self.url = None
        self.response = None

        self.responses_dirname = responses_dirname
        self.responses_count = 1

 def __init__(self, package):
     self.logger = getLogger("backend")
     self.package = package
     self.klass = None
     for attrname in dir(self.package):
         attr = getattr(self.package, attrname)
         if isinstance(attr, type) and issubclass(attr, BaseBackend) and attr != BaseBackend:
             self.klass = attr
     if not self.klass:
         raise ImportError("%s is not a backend (no BaseBackend class found)" % package)

    def __init__(self, sched, storage, browser):
        super(QueriesQueue, self).__init__()
        self._sched = sched
        self._storage = storage
        self._browser = browser
        self._logger = getLogger('queriesqueue', browser.logger)

        self._queue = storage.get('queries_queue', 'queue', default=[])

        self._check_cron = None

    def __init__(self, script, logger=None):
        try:
            import execjs
        except ImportError:
            raise ImportError('Please install PyExecJS')

        self.runner = execjs.get()
        self.logger = getLogger('js', logger)

        self.ctx = self.runner.compile(self.HEADER + script)

 def __init__(self, package):
     self.logger = getLogger('backend')
     self.package = package
     self.klass = None
     for attrname in dir(self.package):
         attr = getattr(self.package, attrname)
         if isinstance(attr, type) and issubclass(attr, Module) and attr != Module:
             self.klass = attr
     if not self.klass:
         raise ImportError('%s is not a backend (no Module class found)' % package)