import pywikibot as pwb
from pywikibot import pagegenerators as pg

help(pwb.page)
#help(str) # Hife für Strings
#help(pg.PetScanPageGenerator)
Help on package pywikibot.tools in pywikibot:

NAME
    pywikibot.tools - Miscellaneous helper functions (not wiki-dependent).

PACKAGE CONTENTS
    _logging
    chars
    djvu
    formatter
    ip

CLASSES
    builtins.IndexError(builtins.LookupError)
        CombinedError(builtins.KeyError, builtins.IndexError)
    builtins.KeyError(builtins.LookupError)
        CombinedError(builtins.KeyError, builtins.IndexError)
    builtins.dict(builtins.object)
        FrozenDict
    builtins.list(builtins.object)
        ThreadList
    builtins.module(builtins.object)
        ModuleDeprecationWrapper
    builtins.object
        ComparableMixin
        ContextManagerWrapper
        LazyRegex
            DeprecatedRegex
        NotImplementedClass
        SelfCallMixin
            SelfCallDict(SelfCallMixin, builtins.dict)
            SelfCallString(SelfCallMixin, builtins.str)
        UnicodeMixin
            DotReadableDict
        classproperty
    builtins.str(builtins.object)
        EmptyDefault(builtins.str, collections.abc.Mapping)
    builtins.tuple(builtins.object)
        ArgSpec
    collections.abc.Iterator(collections.abc.Iterable)
        IteratorNextMixin
            DequeGenerator(IteratorNextMixin, collections.deque)
    collections.abc.Mapping(collections.abc.Collection)
        EmptyDefault(builtins.str, collections.abc.Mapping)
    distutils.version.Version(builtins.object)
        MediaWikiVersion
    threading.Thread(builtins.object)
        ThreadedGenerator
    warnings.catch_warnings(builtins.object)
        suppress_warnings
    
    class ArgSpec(builtins.tuple)
     |  ArgSpec(args, varargs, keywords, defaults)
     |  
     |  Method resolution order:
     |      ArgSpec
     |      builtins.tuple
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getnewargs__(self)
     |      Return self as a plain tuple.  Used by copy and pickle.
     |  
     |  __repr__(self)
     |      Return a nicely formatted representation string
     |  
     |  _asdict(self)
     |      Return a new OrderedDict which maps field names to their values.
     |  
     |  _replace(_self, **kwds)
     |      Return a new ArgSpec object replacing specified fields with new values
     |  
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |  
     |  _make(iterable, new=<built-in method __new__ of type object at 0x9e1000>, len=<built-in function len>) from builtins.type
     |      Make a new ArgSpec object from a sequence or iterable
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(_cls, args, varargs, keywords, defaults)
     |      Create new instance of ArgSpec(args, varargs, keywords, defaults)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  args
     |      Alias for field number 0
     |  
     |  varargs
     |      Alias for field number 1
     |  
     |  keywords
     |      Alias for field number 2
     |  
     |  defaults
     |      Alias for field number 3
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  _fields = ('args', 'varargs', 'keywords', 'defaults')
     |  
     |  _source = "from builtins import property as _property, tupl..._itemget...
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.tuple:
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(self, key, /)
     |      Return self[key].
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __hash__(self, /)
     |      Return hash(self).
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.n
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __rmul__(self, value, /)
     |      Return self*value.
     |  
     |  count(...)
     |      T.count(value) -> integer -- return number of occurrences of value
     |  
     |  index(...)
     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
    
    class CombinedError(builtins.KeyError, builtins.IndexError)
     |  An error that gets caught by both KeyError and IndexError.
     |  
     |  Method resolution order:
     |      CombinedError
     |      builtins.KeyError
     |      builtins.IndexError
     |      builtins.LookupError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.KeyError:
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.IndexError:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |  
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __reduce__(...)
     |      helper for pickle
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |  
     |  __setstate__(...)
     |  
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |  
     |  __cause__
     |      exception cause
     |  
     |  __context__
     |      exception context
     |  
     |  __dict__
     |  
     |  __suppress_context__
     |  
     |  __traceback__
     |  
     |  args
    
    class ComparableMixin(builtins.object)
     |  Mixin class to allow comparing to other objects which are comparable.
     |  
     |  Methods defined here:
     |  
     |  __eq__(self, other)
     |      Compare if self is equal to other.
     |  
     |  __ge__(self, other)
     |      Compare if self is greater equals other.
     |  
     |  __gt__(self, other)
     |      Compare if self is greater than other.
     |  
     |  __le__(self, other)
     |      Compare if self is less equals other.
     |  
     |  __lt__(self, other)
     |      Compare if self is less than other.
     |  
     |  __ne__(self, other)
     |      Compare if self is not equal to other.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __hash__ = None
    
    class ContextManagerWrapper(builtins.object)
     |  Wraps an object in a context manager.
     |  
     |  It is redirecting all access to the wrapped object and executes 'close' when
     |  used as a context manager in with-statements. In such statements the value
     |  set via 'as' is directly the wrapped object. For example:
     |  
     |  >>> class Wrapper(object):
     |  ...     def close(self): pass
     |  >>> an_object = Wrapper()
     |  >>> wrapped = ContextManagerWrapper(an_object)
     |  >>> with wrapped as another_object:
     |  ...      assert another_object is an_object
     |  
     |  It does not subclass the object though, so isinstance checks will fail
     |  outside a with-statement.
     |  
     |  Methods defined here:
     |  
     |  __enter__(self)
     |      Enter a context manager and use the wrapped object directly.
     |  
     |  __exit__(self, exc_type, exc_value, traceback)
     |      Call close on the wrapped object when exiting a context manager.
     |  
     |  __getattr__(self, name)
     |      Get the attribute from the wrapped object.
     |  
     |  __init__(self, wrapped)
     |      Create a new wrapper.
     |  
     |  __setattr__(self, name, value)
     |      Set the attribute in the wrapped object.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class DeprecatedRegex(LazyRegex)
     |  Regex object that issues a deprecation notice.
     |  
     |  Method resolution order:
     |      DeprecatedRegex
     |      LazyRegex
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getattr__(self, attr)
     |      Issue deprecation warning.
     |  
     |  __init__(self, pattern, flags=0, name=None, instead=None)
     |      Constructor.
     |      
     |      If name is None, the regex pattern will be used as part of
     |      the deprecation warning.
     |      
     |      @param name: name of the object that is deprecated
     |      @type name: str or None
     |      @param instead: if provided, will be used to specify the replacement
     |          of the deprecated name
     |      @type instead: str
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from LazyRegex:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  flags
     |      Get flags property.
     |  
     |  raw
     |      Get raw property.
    
    class DequeGenerator(IteratorNextMixin, collections.deque)
     |  A generator that allows items to be added during generating.
     |  
     |  Method resolution order:
     |      DequeGenerator
     |      IteratorNextMixin
     |      collections.abc.Iterator
     |      collections.abc.Iterable
     |      collections.deque
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __next__(self)
     |      Python 3 iterator method.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __abstractmethods__ = frozenset()
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from IteratorNextMixin:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.Iterator:
     |  
     |  __iter__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from collections.abc.Iterator:
     |  
     |  __subclasshook__(C) from abc.ABCMeta
     |      Abstract classes can override this to customize issubclass().
     |      
     |      This is invoked early on by abc.ABCMeta.__subclasscheck__().
     |      It should return True, False or NotImplemented.  If it returns
     |      NotImplemented, the normal algorithm is used.  Otherwise, it
     |      overrides the normal algorithm (and the outcome is cached).
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.deque:
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __bool__(self, /)
     |      self != 0
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __copy__(...)
     |      Return a shallow copy of a deque.
     |  
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(self, key, /)
     |      Return self[key].
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __iadd__(self, value, /)
     |      Implement self+=value.
     |  
     |  __imul__(self, value, /)
     |      Implement self*=value.
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.n
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __reduce__(...)
     |      Return state information for pickling.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __reversed__(...)
     |      D.__reversed__() -- return a reverse iterator over the deque
     |  
     |  __rmul__(self, value, /)
     |      Return self*value.
     |  
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |  
     |  __sizeof__(...)
     |      D.__sizeof__() -- size of D in memory, in bytes
     |  
     |  append(...)
     |      Add an element to the right side of the deque.
     |  
     |  appendleft(...)
     |      Add an element to the left side of the deque.
     |  
     |  clear(...)
     |      Remove all elements from the deque.
     |  
     |  copy(...)
     |      Return a shallow copy of a deque.
     |  
     |  count(...)
     |      D.count(value) -> integer -- return number of occurrences of value
     |  
     |  extend(...)
     |      Extend the right side of the deque with elements from the iterable
     |  
     |  extendleft(...)
     |      Extend the left side of the deque with elements from the iterable
     |  
     |  index(...)
     |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
     |  
     |  insert(...)
     |      D.insert(index, object) -- insert object before index
     |  
     |  pop(...)
     |      Remove and return the rightmost element.
     |  
     |  popleft(...)
     |      Remove and return the leftmost element.
     |  
     |  remove(...)
     |      D.remove(value) -- remove first occurrence of value.
     |  
     |  reverse(...)
     |      D.reverse() -- reverse *IN PLACE*
     |  
     |  rotate(...)
     |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from collections.deque:
     |  
     |  maxlen
     |      maximum size of a deque or None if unbounded
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from collections.deque:
     |  
     |  __hash__ = None
    
    class DotReadableDict(UnicodeMixin)
     |  Parent class of Revision() and FileInfo().
     |  
     |  Provide:
     |  - __getitem__(), __unicode__() and __repr__().
     |  
     |  Method resolution order:
     |      DotReadableDict
     |      UnicodeMixin
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getitem__(self, key)
     |      Give access to class values by key.
     |      
     |      Revision class may also give access to its values by keys
     |      e.g. revid parameter may be assigned by revision['revid']
     |      as well as revision.revid. This makes formatting strings with
     |      % operator easier.
     |  
     |  __repr__(self)
     |      Return a more complete string representation.
     |  
     |  __unicode__(self)
     |      Return string representation.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from UnicodeMixin:
     |  
     |  __str__(self)
     |      Return the unicode representation as the str representation.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from UnicodeMixin:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class EmptyDefault(builtins.str, collections.abc.Mapping)
     |  A default for a not existing siteinfo property.
     |  
     |  It should be chosen if there is no better default known. It acts like an
     |  empty collections, so it can be iterated through it savely if treated as a
     |  list, tuple, set or dictionary. It is also basically an empty string.
     |  
     |  Accessing a value via __getitem__ will result in an combined KeyError and
     |  IndexError.
     |  
     |  Method resolution order:
     |      EmptyDefault
     |      builtins.str
     |      collections.abc.Mapping
     |      collections.abc.Collection
     |      collections.abc.Sized
     |      collections.abc.Iterable
     |      collections.abc.Container
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getitem__(self, key)
     |      Raise always a L{CombinedError}.
     |  
     |  __init__(self)
     |      Initialise the default as an empty string.
     |  
     |  __iter__ = _empty_iter(self)
     |  
     |  iteritems = _empty_iter(self)
     |  
     |  iterkeys = _empty_iter(self)
     |  
     |  itervalues = _empty_iter(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __abstractmethods__ = frozenset()
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.str:
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __format__(...)
     |      S.__format__(format_spec) -> str
     |      
     |      Return a formatted version of S as described by format_spec.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getnewargs__(...)
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __hash__(self, /)
     |      Return hash(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mod__(self, value, /)
     |      Return self%value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.n
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __rmod__(self, value, /)
     |      Return value%self.
     |  
     |  __rmul__(self, value, /)
     |      Return self*value.
     |  
     |  __sizeof__(...)
     |      S.__sizeof__() -> size of S in memory, in bytes
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  capitalize(...)
     |      S.capitalize() -> str
     |      
     |      Return a capitalized version of S, i.e. make the first character
     |      have upper case and the rest lower case.
     |  
     |  casefold(...)
     |      S.casefold() -> str
     |      
     |      Return a version of S suitable for caseless comparisons.
     |  
     |  center(...)
     |      S.center(width[, fillchar]) -> str
     |      
     |      Return S centered in a string of length width. Padding is
     |      done using the specified fill character (default is a space)
     |  
     |  count(...)
     |      S.count(sub[, start[, end]]) -> int
     |      
     |      Return the number of non-overlapping occurrences of substring sub in
     |      string S[start:end].  Optional arguments start and end are
     |      interpreted as in slice notation.
     |  
     |  encode(...)
     |      S.encode(encoding='utf-8', errors='strict') -> bytes
     |      
     |      Encode S using the codec registered for encoding. Default encoding
     |      is 'utf-8'. errors may be given to set a different error
     |      handling scheme. Default is 'strict' meaning that encoding errors raise
     |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
     |      'xmlcharrefreplace' as well as any other name registered with
     |      codecs.register_error that can handle UnicodeEncodeErrors.
     |  
     |  endswith(...)
     |      S.endswith(suffix[, start[, end]]) -> bool
     |      
     |      Return True if S ends with the specified suffix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      suffix can also be a tuple of strings to try.
     |  
     |  expandtabs(...)
     |      S.expandtabs(tabsize=8) -> str
     |      
     |      Return a copy of S where all tab characters are expanded using spaces.
     |      If tabsize is not given, a tab size of 8 characters is assumed.
     |  
     |  find(...)
     |      S.find(sub[, start[, end]]) -> int
     |      
     |      Return the lowest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Return -1 on failure.
     |  
     |  format(...)
     |      S.format(*args, **kwargs) -> str
     |      
     |      Return a formatted version of S, using substitutions from args and kwargs.
     |      The substitutions are identified by braces ('{' and '}').
     |  
     |  format_map(...)
     |      S.format_map(mapping) -> str
     |      
     |      Return a formatted version of S, using substitutions from mapping.
     |      The substitutions are identified by braces ('{' and '}').
     |  
     |  index(...)
     |      S.index(sub[, start[, end]]) -> int
     |      
     |      Return the lowest index in S where substring sub is found, 
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Raises ValueError when the substring is not found.
     |  
     |  isalnum(...)
     |      S.isalnum() -> bool
     |      
     |      Return True if all characters in S are alphanumeric
     |      and there is at least one character in S, False otherwise.
     |  
     |  isalpha(...)
     |      S.isalpha() -> bool
     |      
     |      Return True if all characters in S are alphabetic
     |      and there is at least one character in S, False otherwise.
     |  
     |  isdecimal(...)
     |      S.isdecimal() -> bool
     |      
     |      Return True if there are only decimal characters in S,
     |      False otherwise.
     |  
     |  isdigit(...)
     |      S.isdigit() -> bool
     |      
     |      Return True if all characters in S are digits
     |      and there is at least one character in S, False otherwise.
     |  
     |  isidentifier(...)
     |      S.isidentifier() -> bool
     |      
     |      Return True if S is a valid identifier according
     |      to the language definition.
     |      
     |      Use keyword.iskeyword() to test for reserved identifiers
     |      such as "def" and "class".
     |  
     |  islower(...)
     |      S.islower() -> bool
     |      
     |      Return True if all cased characters in S are lowercase and there is
     |      at least one cased character in S, False otherwise.
     |  
     |  isnumeric(...)
     |      S.isnumeric() -> bool
     |      
     |      Return True if there are only numeric characters in S,
     |      False otherwise.
     |  
     |  isprintable(...)
     |      S.isprintable() -> bool
     |      
     |      Return True if all characters in S are considered
     |      printable in repr() or S is empty, False otherwise.
     |  
     |  isspace(...)
     |      S.isspace() -> bool
     |      
     |      Return True if all characters in S are whitespace
     |      and there is at least one character in S, False otherwise.
     |  
     |  istitle(...)
     |      S.istitle() -> bool
     |      
     |      Return True if S is a titlecased string and there is at least one
     |      character in S, i.e. upper- and titlecase characters may only
     |      follow uncased characters and lowercase characters only cased ones.
     |      Return False otherwise.
     |  
     |  isupper(...)
     |      S.isupper() -> bool
     |      
     |      Return True if all cased characters in S are uppercase and there is
     |      at least one cased character in S, False otherwise.
     |  
     |  join(...)
     |      S.join(iterable) -> str
     |      
     |      Return a string which is the concatenation of the strings in the
     |      iterable.  The separator between elements is S.
     |  
     |  ljust(...)
     |      S.ljust(width[, fillchar]) -> str
     |      
     |      Return S left-justified in a Unicode string of length width. Padding is
     |      done using the specified fill character (default is a space).
     |  
     |  lower(...)
     |      S.lower() -> str
     |      
     |      Return a copy of the string S converted to lowercase.
     |  
     |  lstrip(...)
     |      S.lstrip([chars]) -> str
     |      
     |      Return a copy of the string S with leading whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  partition(...)
     |      S.partition(sep) -> (head, sep, tail)
     |      
     |      Search for the separator sep in S, and return the part before it,
     |      the separator itself, and the part after it.  If the separator is not
     |      found, return S and two empty strings.
     |  
     |  replace(...)
     |      S.replace(old, new[, count]) -> str
     |      
     |      Return a copy of S with all occurrences of substring
     |      old replaced by new.  If the optional argument count is
     |      given, only the first count occurrences are replaced.
     |  
     |  rfind(...)
     |      S.rfind(sub[, start[, end]]) -> int
     |      
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Return -1 on failure.
     |  
     |  rindex(...)
     |      S.rindex(sub[, start[, end]]) -> int
     |      
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Raises ValueError when the substring is not found.
     |  
     |  rjust(...)
     |      S.rjust(width[, fillchar]) -> str
     |      
     |      Return S right-justified in a string of length width. Padding is
     |      done using the specified fill character (default is a space).
     |  
     |  rpartition(...)
     |      S.rpartition(sep) -> (head, sep, tail)
     |      
     |      Search for the separator sep in S, starting at the end of S, and return
     |      the part before it, the separator itself, and the part after it.  If the
     |      separator is not found, return two empty strings and S.
     |  
     |  rsplit(...)
     |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
     |      
     |      Return a list of the words in S, using sep as the
     |      delimiter string, starting at the end of the string and
     |      working to the front.  If maxsplit is given, at most maxsplit
     |      splits are done. If sep is not specified, any whitespace string
     |      is a separator.
     |  
     |  rstrip(...)
     |      S.rstrip([chars]) -> str
     |      
     |      Return a copy of the string S with trailing whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  split(...)
     |      S.split(sep=None, maxsplit=-1) -> list of strings
     |      
     |      Return a list of the words in S, using sep as the
     |      delimiter string.  If maxsplit is given, at most maxsplit
     |      splits are done. If sep is not specified or is None, any
     |      whitespace string is a separator and empty strings are
     |      removed from the result.
     |  
     |  splitlines(...)
     |      S.splitlines([keepends]) -> list of strings
     |      
     |      Return a list of the lines in S, breaking at line boundaries.
     |      Line breaks are not included in the resulting list unless keepends
     |      is given and true.
     |  
     |  startswith(...)
     |      S.startswith(prefix[, start[, end]]) -> bool
     |      
     |      Return True if S starts with the specified prefix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      prefix can also be a tuple of strings to try.
     |  
     |  strip(...)
     |      S.strip([chars]) -> str
     |      
     |      Return a copy of the string S with leading and trailing
     |      whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  swapcase(...)
     |      S.swapcase() -> str
     |      
     |      Return a copy of S with uppercase characters converted to lowercase
     |      and vice versa.
     |  
     |  title(...)
     |      S.title() -> str
     |      
     |      Return a titlecased version of S, i.e. words start with title case
     |      characters, all remaining cased characters have lower case.
     |  
     |  translate(...)
     |      S.translate(table) -> str
     |      
     |      Return a copy of the string S in which each character has been mapped
     |      through the given translation table. The table must implement
     |      lookup/indexing via __getitem__, for instance a dictionary or list,
     |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
     |      this operation raises LookupError, the character is left untouched.
     |      Characters mapped to None are deleted.
     |  
     |  upper(...)
     |      S.upper() -> str
     |      
     |      Return a copy of S converted to uppercase.
     |  
     |  zfill(...)
     |      S.zfill(width) -> str
     |      
     |      Pad a numeric string S with zeros on the left, to fill a field
     |      of the specified width. The string S is never truncated.
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.str:
     |  
     |  maketrans(x, y=None, z=None, /)
     |      Return a translation table usable for str.translate().
     |      
     |      If there is only one argument, it must be a dictionary mapping Unicode
     |      ordinals (integers) or characters to Unicode ordinals, strings or None.
     |      Character keys will be then converted to ordinals.
     |      If there are two arguments, they must be strings of equal length, and
     |      in the resulting dictionary, each character in x will be mapped to the
     |      character at the same position in y. If there is a third argument, it
     |      must be a string, whose characters will be mapped to None in the result.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.Mapping:
     |  
     |  get(self, key, default=None)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |  
     |  items(self)
     |      D.items() -> a set-like object providing a view on D's items
     |  
     |  keys(self)
     |      D.keys() -> a set-like object providing a view on D's keys
     |  
     |  values(self)
     |      D.values() -> an object providing a view on D's values
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from collections.abc.Mapping:
     |  
     |  __reversed__ = None
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from collections.abc.Collection:
     |  
     |  __subclasshook__(C) from abc.ABCMeta
     |      Abstract classes can override this to customize issubclass().
     |      
     |      This is invoked early on by abc.ABCMeta.__subclasscheck__().
     |      It should return True, False or NotImplemented.  If it returns
     |      NotImplemented, the normal algorithm is used.  Otherwise, it
     |      overrides the normal algorithm (and the outcome is cached).
    
    class FrozenDict(builtins.dict)
     |  Frozen dict, preventing write after initialisation.
     |  
     |  Raises TypeError if write attempted.
     |  
     |  Method resolution order:
     |      FrozenDict
     |      builtins.dict
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, data=None, error=None)
     |      Constructor.
     |      
     |      @param data: mapping to freeze
     |      @type data: mapping
     |      @param error: error message
     |      @type error: basestring
     |  
     |  __setitem__ = update(self, *args, **kwargs)
     |  
     |  update(self, *args, **kwargs)
     |      Prevent updates.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.dict:
     |  
     |  __contains__(self, key, /)
     |      True if D has a key k, else False.
     |  
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |  
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |  
     |  copy(...)
     |      D.copy() -> a shallow copy of D
     |  
     |  fromkeys(iterable, value=None, /) from builtins.type
     |      Returns a new dict with keys from iterable and values equal to value.
     |  
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |  
     |  items(...)
     |      D.items() -> a set-like object providing a view on D's items
     |  
     |  keys(...)
     |      D.keys() -> a set-like object providing a view on D's keys
     |  
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |  
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty.
     |  
     |  setdefault(...)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |  
     |  values(...)
     |      D.values() -> an object providing a view on D's values
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from builtins.dict:
     |  
     |  __hash__ = None
    
    class IteratorNextMixin(collections.abc.Iterator)
     |  Backwards compatibility for Iterators.
     |  
     |  Method resolution order:
     |      IteratorNextMixin
     |      collections.abc.Iterator
     |      collections.abc.Iterable
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  __abstractmethods__ = frozenset({'__next__'})
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.Iterator:
     |  
     |  __iter__(self)
     |  
     |  __next__(self)
     |      Return the next item from the iterator. When exhausted, raise StopIteration
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from collections.abc.Iterator:
     |  
     |  __subclasshook__(C) from abc.ABCMeta
     |      Abstract classes can override this to customize issubclass().
     |      
     |      This is invoked early on by abc.ABCMeta.__subclasscheck__().
     |      It should return True, False or NotImplemented.  If it returns
     |      NotImplemented, the normal algorithm is used.  Otherwise, it
     |      overrides the normal algorithm (and the outcome is cached).
    
    class LazyRegex(builtins.object)
     |  Regex object that obtains and compiles the regex on usage.
     |  
     |  Instances behave like the object created using L{re.compile}.
     |  
     |  Methods defined here:
     |  
     |  __getattr__(self, attr)
     |      Compile the regex and delegate all attribute to the regex.
     |  
     |  __init__(self, pattern, flags=0)
     |      Constructor.
     |      
     |      @param pattern: L{re} regex pattern
     |      @type pattern: str or callable
     |      @param flags: L{re.compile} flags
     |      @type flags: int
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  flags
     |      Get flags property.
     |  
     |  raw
     |      Get raw property.
    
    class MediaWikiVersion(distutils.version.Version)
     |  Version object to allow comparing 'wmf' versions with normal ones.
     |  
     |  The version mainly consist of digits separated by periods. After that is a
     |  suffix which may only be 'wmf<number>', 'alpha', 'beta<number>' or
     |  '-rc.<number>' (the - and . are optional). They are considered from old to
     |  new in that order with a version number without suffix is considered the
     |  newest. This secondary difference is stored in an internal _dev_version
     |  attribute.
     |  
     |  Two versions are equal if their normal version and dev version are equal. A
     |  version is greater if the normal version or dev version is greater. For
     |  example:
     |  
     |      1.24 < 1.24.1 < 1.25wmf1 < 1.25alpha < 1.25beta1 < 1.25beta2
     |      < 1.25-rc-1 < 1.25-rc.2 < 1.25
     |  
     |  Any other suffixes are considered invalid.
     |  
     |  Method resolution order:
     |      MediaWikiVersion
     |      distutils.version.Version
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __str__(self)
     |      Return version number with optional suffix.
     |  
     |  parse(self, vstring)
     |      Parse version string.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |  
     |  from_generator(generator) from builtins.type
     |      Create instance using the generator string.
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  MEDIAWIKI_VERSION = re.compile('^(\\d+(?:\\.\\d+)+)(-?wmf\\.?(\\d+)|al...
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from distutils.version.Version:
     |  
     |  __eq__(self, other)
     |      Return self==value.
     |  
     |  __ge__(self, other)
     |      Return self>=value.
     |  
     |  __gt__(self, other)
     |      Return self>value.
     |  
     |  __init__(self, vstring=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __le__(self, other)
     |      Return self<=value.
     |  
     |  __lt__(self, other)
     |      Return self<value.
     |  
     |  __repr__(self)
     |      Return repr(self).
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from distutils.version.Version:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from distutils.version.Version:
     |  
     |  __hash__ = None
    
    class ModuleDeprecationWrapper(builtins.module)
     |  A wrapper for a module to deprecate classes or variables of it.
     |  
     |  Method resolution order:
     |      ModuleDeprecationWrapper
     |      builtins.module
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getattr__(self, attr)
     |      Return the attribute with a deprecation warning if required.
     |  
     |  __init__(self, module)
     |      Initialise the wrapper.
     |      
     |      It will automatically overwrite the module with this instance in
     |      C{sys.modules}.
     |      
     |      @param module: The module name or instance
     |      @type module: str or module
     |  
     |  __setattr__(self, attr, value)
     |      Set the value of the wrapped module.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.module:
     |  
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     |  __dir__(...)
     |      __dir__() -> list
     |      specialized dir() implementation
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.module:
     |  
     |  __dict__
    
    class NotImplementedClass(builtins.object)
     |  No implementation is available.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, *args, **kwargs)
     |      Constructor.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class SelfCallDict(SelfCallMixin, builtins.dict)
     |  Dict with SelfCallMixin.
     |  
     |  Method resolution order:
     |      SelfCallDict
     |      SelfCallMixin
     |      builtins.dict
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from SelfCallMixin:
     |  
     |  __call__(self)
     |      Do nothing and just return itself.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.dict:
     |  
     |  __contains__(self, key, /)
     |      True if D has a key k, else False.
     |  
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |  
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |  
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |  
     |  copy(...)
     |      D.copy() -> a shallow copy of D
     |  
     |  fromkeys(iterable, value=None, /) from builtins.type
     |      Returns a new dict with keys from iterable and values equal to value.
     |  
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |  
     |  items(...)
     |      D.items() -> a set-like object providing a view on D's items
     |  
     |  keys(...)
     |      D.keys() -> a set-like object providing a view on D's keys
     |  
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |  
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty.
     |  
     |  setdefault(...)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |  
     |  update(...)
     |      D.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(...)
     |      D.values() -> an object providing a view on D's values
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from builtins.dict:
     |  
     |  __hash__ = None
    
    class SelfCallMixin(builtins.object)
     |  Return self when called.
     |  
     |  When '_own_desc' is defined it'll also issue a deprecation warning using
     |  issue_deprecation_warning('Calling ' + _own_desc, 'it directly').
     |  
     |  Methods defined here:
     |  
     |  __call__(self)
     |      Do nothing and just return itself.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class SelfCallString(SelfCallMixin, builtins.str)
     |  Unicode string with SelfCallMixin.
     |  
     |  Method resolution order:
     |      SelfCallString
     |      SelfCallMixin
     |      builtins.str
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from SelfCallMixin:
     |  
     |  __call__(self)
     |      Do nothing and just return itself.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.str:
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __format__(...)
     |      S.__format__(format_spec) -> str
     |      
     |      Return a formatted version of S as described by format_spec.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(self, key, /)
     |      Return self[key].
     |  
     |  __getnewargs__(...)
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __hash__(self, /)
     |      Return hash(self).
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mod__(self, value, /)
     |      Return self%value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.n
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __rmod__(self, value, /)
     |      Return value%self.
     |  
     |  __rmul__(self, value, /)
     |      Return self*value.
     |  
     |  __sizeof__(...)
     |      S.__sizeof__() -> size of S in memory, in bytes
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  capitalize(...)
     |      S.capitalize() -> str
     |      
     |      Return a capitalized version of S, i.e. make the first character
     |      have upper case and the rest lower case.
     |  
     |  casefold(...)
     |      S.casefold() -> str
     |      
     |      Return a version of S suitable for caseless comparisons.
     |  
     |  center(...)
     |      S.center(width[, fillchar]) -> str
     |      
     |      Return S centered in a string of length width. Padding is
     |      done using the specified fill character (default is a space)
     |  
     |  count(...)
     |      S.count(sub[, start[, end]]) -> int
     |      
     |      Return the number of non-overlapping occurrences of substring sub in
     |      string S[start:end].  Optional arguments start and end are
     |      interpreted as in slice notation.
     |  
     |  encode(...)
     |      S.encode(encoding='utf-8', errors='strict') -> bytes
     |      
     |      Encode S using the codec registered for encoding. Default encoding
     |      is 'utf-8'. errors may be given to set a different error
     |      handling scheme. Default is 'strict' meaning that encoding errors raise
     |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
     |      'xmlcharrefreplace' as well as any other name registered with
     |      codecs.register_error that can handle UnicodeEncodeErrors.
     |  
     |  endswith(...)
     |      S.endswith(suffix[, start[, end]]) -> bool
     |      
     |      Return True if S ends with the specified suffix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      suffix can also be a tuple of strings to try.
     |  
     |  expandtabs(...)
     |      S.expandtabs(tabsize=8) -> str
     |      
     |      Return a copy of S where all tab characters are expanded using spaces.
     |      If tabsize is not given, a tab size of 8 characters is assumed.
     |  
     |  find(...)
     |      S.find(sub[, start[, end]]) -> int
     |      
     |      Return the lowest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Return -1 on failure.
     |  
     |  format(...)
     |      S.format(*args, **kwargs) -> str
     |      
     |      Return a formatted version of S, using substitutions from args and kwargs.
     |      The substitutions are identified by braces ('{' and '}').
     |  
     |  format_map(...)
     |      S.format_map(mapping) -> str
     |      
     |      Return a formatted version of S, using substitutions from mapping.
     |      The substitutions are identified by braces ('{' and '}').
     |  
     |  index(...)
     |      S.index(sub[, start[, end]]) -> int
     |      
     |      Return the lowest index in S where substring sub is found, 
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Raises ValueError when the substring is not found.
     |  
     |  isalnum(...)
     |      S.isalnum() -> bool
     |      
     |      Return True if all characters in S are alphanumeric
     |      and there is at least one character in S, False otherwise.
     |  
     |  isalpha(...)
     |      S.isalpha() -> bool
     |      
     |      Return True if all characters in S are alphabetic
     |      and there is at least one character in S, False otherwise.
     |  
     |  isdecimal(...)
     |      S.isdecimal() -> bool
     |      
     |      Return True if there are only decimal characters in S,
     |      False otherwise.
     |  
     |  isdigit(...)
     |      S.isdigit() -> bool
     |      
     |      Return True if all characters in S are digits
     |      and there is at least one character in S, False otherwise.
     |  
     |  isidentifier(...)
     |      S.isidentifier() -> bool
     |      
     |      Return True if S is a valid identifier according
     |      to the language definition.
     |      
     |      Use keyword.iskeyword() to test for reserved identifiers
     |      such as "def" and "class".
     |  
     |  islower(...)
     |      S.islower() -> bool
     |      
     |      Return True if all cased characters in S are lowercase and there is
     |      at least one cased character in S, False otherwise.
     |  
     |  isnumeric(...)
     |      S.isnumeric() -> bool
     |      
     |      Return True if there are only numeric characters in S,
     |      False otherwise.
     |  
     |  isprintable(...)
     |      S.isprintable() -> bool
     |      
     |      Return True if all characters in S are considered
     |      printable in repr() or S is empty, False otherwise.
     |  
     |  isspace(...)
     |      S.isspace() -> bool
     |      
     |      Return True if all characters in S are whitespace
     |      and there is at least one character in S, False otherwise.
     |  
     |  istitle(...)
     |      S.istitle() -> bool
     |      
     |      Return True if S is a titlecased string and there is at least one
     |      character in S, i.e. upper- and titlecase characters may only
     |      follow uncased characters and lowercase characters only cased ones.
     |      Return False otherwise.
     |  
     |  isupper(...)
     |      S.isupper() -> bool
     |      
     |      Return True if all cased characters in S are uppercase and there is
     |      at least one cased character in S, False otherwise.
     |  
     |  join(...)
     |      S.join(iterable) -> str
     |      
     |      Return a string which is the concatenation of the strings in the
     |      iterable.  The separator between elements is S.
     |  
     |  ljust(...)
     |      S.ljust(width[, fillchar]) -> str
     |      
     |      Return S left-justified in a Unicode string of length width. Padding is
     |      done using the specified fill character (default is a space).
     |  
     |  lower(...)
     |      S.lower() -> str
     |      
     |      Return a copy of the string S converted to lowercase.
     |  
     |  lstrip(...)
     |      S.lstrip([chars]) -> str
     |      
     |      Return a copy of the string S with leading whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  partition(...)
     |      S.partition(sep) -> (head, sep, tail)
     |      
     |      Search for the separator sep in S, and return the part before it,
     |      the separator itself, and the part after it.  If the separator is not
     |      found, return S and two empty strings.
     |  
     |  replace(...)
     |      S.replace(old, new[, count]) -> str
     |      
     |      Return a copy of S with all occurrences of substring
     |      old replaced by new.  If the optional argument count is
     |      given, only the first count occurrences are replaced.
     |  
     |  rfind(...)
     |      S.rfind(sub[, start[, end]]) -> int
     |      
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Return -1 on failure.
     |  
     |  rindex(...)
     |      S.rindex(sub[, start[, end]]) -> int
     |      
     |      Return the highest index in S where substring sub is found,
     |      such that sub is contained within S[start:end].  Optional
     |      arguments start and end are interpreted as in slice notation.
     |      
     |      Raises ValueError when the substring is not found.
     |  
     |  rjust(...)
     |      S.rjust(width[, fillchar]) -> str
     |      
     |      Return S right-justified in a string of length width. Padding is
     |      done using the specified fill character (default is a space).
     |  
     |  rpartition(...)
     |      S.rpartition(sep) -> (head, sep, tail)
     |      
     |      Search for the separator sep in S, starting at the end of S, and return
     |      the part before it, the separator itself, and the part after it.  If the
     |      separator is not found, return two empty strings and S.
     |  
     |  rsplit(...)
     |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
     |      
     |      Return a list of the words in S, using sep as the
     |      delimiter string, starting at the end of the string and
     |      working to the front.  If maxsplit is given, at most maxsplit
     |      splits are done. If sep is not specified, any whitespace string
     |      is a separator.
     |  
     |  rstrip(...)
     |      S.rstrip([chars]) -> str
     |      
     |      Return a copy of the string S with trailing whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  split(...)
     |      S.split(sep=None, maxsplit=-1) -> list of strings
     |      
     |      Return a list of the words in S, using sep as the
     |      delimiter string.  If maxsplit is given, at most maxsplit
     |      splits are done. If sep is not specified or is None, any
     |      whitespace string is a separator and empty strings are
     |      removed from the result.
     |  
     |  splitlines(...)
     |      S.splitlines([keepends]) -> list of strings
     |      
     |      Return a list of the lines in S, breaking at line boundaries.
     |      Line breaks are not included in the resulting list unless keepends
     |      is given and true.
     |  
     |  startswith(...)
     |      S.startswith(prefix[, start[, end]]) -> bool
     |      
     |      Return True if S starts with the specified prefix, False otherwise.
     |      With optional start, test S beginning at that position.
     |      With optional end, stop comparing S at that position.
     |      prefix can also be a tuple of strings to try.
     |  
     |  strip(...)
     |      S.strip([chars]) -> str
     |      
     |      Return a copy of the string S with leading and trailing
     |      whitespace removed.
     |      If chars is given and not None, remove characters in chars instead.
     |  
     |  swapcase(...)
     |      S.swapcase() -> str
     |      
     |      Return a copy of S with uppercase characters converted to lowercase
     |      and vice versa.
     |  
     |  title(...)
     |      S.title() -> str
     |      
     |      Return a titlecased version of S, i.e. words start with title case
     |      characters, all remaining cased characters have lower case.
     |  
     |  translate(...)
     |      S.translate(table) -> str
     |      
     |      Return a copy of the string S in which each character has been mapped
     |      through the given translation table. The table must implement
     |      lookup/indexing via __getitem__, for instance a dictionary or list,
     |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
     |      this operation raises LookupError, the character is left untouched.
     |      Characters mapped to None are deleted.
     |  
     |  upper(...)
     |      S.upper() -> str
     |      
     |      Return a copy of S converted to uppercase.
     |  
     |  zfill(...)
     |      S.zfill(width) -> str
     |      
     |      Pad a numeric string S with zeros on the left, to fill a field
     |      of the specified width. The string S is never truncated.
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.str:
     |  
     |  maketrans(x, y=None, z=None, /)
     |      Return a translation table usable for str.translate().
     |      
     |      If there is only one argument, it must be a dictionary mapping Unicode
     |      ordinals (integers) or characters to Unicode ordinals, strings or None.
     |      Character keys will be then converted to ordinals.
     |      If there are two arguments, they must be strings of equal length, and
     |      in the resulting dictionary, each character in x will be mapped to the
     |      character at the same position in y. If there is a third argument, it
     |      must be a string, whose characters will be mapped to None in the result.
    
    class ThreadList(builtins.list)
     |  A simple threadpool class to limit the number of simultaneous threads.
     |  
     |  Any threading.Thread object can be added to the pool using the append()
     |  method. If the maximum number of simultaneous threads has not been reached,
     |  the Thread object will be started immediately; if not, the append() call
     |  will block until the thread is able to start.
     |  
     |  >>> pool = ThreadList(limit=10)
     |  >>> def work():
     |  ...     time.sleep(1)
     |  ...
     |  >>> for x in range(20):
     |  ...     pool.append(threading.Thread(target=work))
     |  ...
     |  
     |  Method resolution order:
     |      ThreadList
     |      builtins.list
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, limit=128, *args)
     |      Constructor.
     |  
     |  active_count(self)
     |      Return the number of alive threads, and delete all non-alive ones.
     |  
     |  append(self, thd)
     |      Add a thread to the pool and start it.
     |  
     |  stop_all(self)
     |      Stop all threads the pool.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.list:
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __delitem__(self, key, /)
     |      Delete self[key].
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __iadd__(self, value, /)
     |      Implement self+=value.
     |  
     |  __imul__(self, value, /)
     |      Implement self*=value.
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __len__(self, /)
     |      Return len(self).
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.n
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __reversed__(...)
     |      L.__reversed__() -- return a reverse iterator over the list
     |  
     |  __rmul__(self, value, /)
     |      Return self*value.
     |  
     |  __setitem__(self, key, value, /)
     |      Set self[key] to value.
     |  
     |  __sizeof__(...)
     |      L.__sizeof__() -- size of L in memory, in bytes
     |  
     |  clear(...)
     |      L.clear() -> None -- remove all items from L
     |  
     |  copy(...)
     |      L.copy() -> list -- a shallow copy of L
     |  
     |  count(...)
     |      L.count(value) -> integer -- return number of occurrences of value
     |  
     |  extend(...)
     |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
     |  
     |  index(...)
     |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
     |  
     |  insert(...)
     |      L.insert(index, object) -- insert object before index
     |  
     |  pop(...)
     |      L.pop([index]) -> item -- remove and return item at index (default last).
     |      Raises IndexError if list is empty or index is out of range.
     |  
     |  remove(...)
     |      L.remove(value) -> None -- remove first occurrence of value.
     |      Raises ValueError if the value is not present.
     |  
     |  reverse(...)
     |      L.reverse() -- reverse *IN PLACE*
     |  
     |  sort(...)
     |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from builtins.list:
     |  
     |  __hash__ = None
    
    class ThreadedGenerator(threading.Thread)
     |  Look-ahead generator class.
     |  
     |  Runs a generator in a separate thread and queues the results; can
     |  be called like a regular generator.
     |  
     |  Subclasses should override self.generator, I{not} self.run
     |  
     |  Important: the generator thread will stop itself if the generator's
     |  internal queue is exhausted; but, if the calling program does not use
     |  all the generated values, it must call the generator's stop() method to
     |  stop the background thread. Example usage:
     |  
     |  >>> gen = ThreadedGenerator(target=range, args=(20,))
     |  >>> try:
     |  ...     data = list(gen)
     |  ... finally:
     |  ...     gen.stop()
     |  >>> data
     |  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
     |  
     |  Method resolution order:
     |      ThreadedGenerator
     |      threading.Thread
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, group=None, target=None, name='GeneratorThread', args=(), kwargs=None, qsize=65536)
     |      Constructor. Takes same keyword arguments as threading.Thread.
     |      
     |      target must be a generator function (or other callable that returns
     |      an iterable object).
     |      
     |      @param qsize: The size of the lookahead queue. The larger the qsize,
     |      the more values will be computed in advance of use (which can eat
     |      up memory and processor time).
     |      @type qsize: int
     |  
     |  __iter__(self)
     |      Iterate results from the queue.
     |  
     |  run(self)
     |      Run the generator and store the results on the queue.
     |  
     |  stop(self)
     |      Stop the background thread.
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from threading.Thread:
     |  
     |  __repr__(self)
     |      Return repr(self).
     |  
     |  getName(self)
     |  
     |  isAlive = is_alive(self)
     |      Return whether the thread is alive.
     |      
     |      This method returns True just before the run() method starts until just
     |      after the run() method terminates. The module function enumerate()
     |      returns a list of all alive threads.
     |  
     |  isDaemon(self)
     |  
     |  is_alive(self)
     |      Return whether the thread is alive.
     |      
     |      This method returns True just before the run() method starts until just
     |      after the run() method terminates. The module function enumerate()
     |      returns a list of all alive threads.
     |  
     |  join(self, timeout=None)
     |      Wait until the thread terminates.
     |      
     |      This blocks the calling thread until the thread whose join() method is
     |      called terminates -- either normally or through an unhandled exception
     |      or until the optional timeout occurs.
     |      
     |      When the timeout argument is present and not None, it should be a
     |      floating point number specifying a timeout for the operation in seconds
     |      (or fractions thereof). As join() always returns None, you must call
     |      isAlive() after join() to decide whether a timeout happened -- if the
     |      thread is still alive, the join() call timed out.
     |      
     |      When the timeout argument is not present or None, the operation will
     |      block until the thread terminates.
     |      
     |      A thread can be join()ed many times.
     |      
     |      join() raises a RuntimeError if an attempt is made to join the current
     |      thread as that would cause a deadlock. It is also an error to join() a
     |      thread before it has been started and attempts to do so raises the same
     |      exception.
     |  
     |  setDaemon(self, daemonic)
     |  
     |  setName(self, name)
     |  
     |  start(self)
     |      Start the thread's activity.
     |      
     |      It must be called at most once per thread object. It arranges for the
     |      object's run() method to be invoked in a separate thread of control.
     |      
     |      This method will raise a RuntimeError if called more than once on the
     |      same thread object.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from threading.Thread:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  daemon
     |      A boolean value indicating whether this thread is a daemon thread.
     |      
     |      This must be set before start() is called, otherwise RuntimeError is
     |      raised. Its initial value is inherited from the creating thread; the
     |      main thread is not a daemon thread and therefore all threads created in
     |      the main thread default to daemon = False.
     |      
     |      The entire Python program exits when no alive non-daemon threads are
     |      left.
     |  
     |  ident
     |      Thread identifier of this thread or None if it has not been started.
     |      
     |      This is a nonzero integer. See the thread.get_ident() function. Thread
     |      identifiers may be recycled when a thread exits and another thread is
     |      created. The identifier is available even after the thread has exited.
     |  
     |  name
     |      A string used for identification purposes only.
     |      
     |      It has no semantics. Multiple threads may be given the same name. The
     |      initial name is set by the constructor.
    
    class UnicodeMixin(builtins.object)
     |  Mixin class to add __str__ method in Python 2 or 3.
     |  
     |  Methods defined here:
     |  
     |  __str__(self)
     |      Return the unicode representation as the str representation.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class classproperty(builtins.object)
     |  Metaclass to accesss a class method as a property.
     |  
     |  This class may be used as a decorator::
     |  
     |      class Foo(object):
     |  
     |          _bar = 'baz'  # a class property
     |  
     |          @classproperty
     |          def bar(cls):  # a class property method
     |              return cls._bar
     |  
     |  Foo.bar gives 'baz'.
     |  
     |  Methods defined here:
     |  
     |  __get__(self, instance, owner)
     |      Get the attribute of the owner class by its method.
     |  
     |  __init__(self, cls_method)
     |      Hold the class method.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class suppress_warnings(warnings.catch_warnings)
     |  A decorator/context manager that temporarily suppresses warnings.
     |  
     |  Those suppressed warnings that do not match the parameters will be raised
     |  shown upon exit.
     |  
     |  Method resolution order:
     |      suppress_warnings
     |      warnings.catch_warnings
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __call__(self, func)
     |      Decorate func to suppress warnings.
     |  
     |  __enter__(self)
     |      Catch all warnings and store them in `self.log`.
     |  
     |  __exit__(self, exc_type, exc_val, exc_tb)
     |      Stop logging warnings and show those that do not match to params.
     |  
     |  __init__(self, message='', category=<class 'Warning'>, filename='')
     |      Initialize the object.
     |      
     |      The parameter semantics are similar to those of
     |      `warnings.filterwarnings`.
     |      
     |      @param message: A string containing a regular expression that the start
     |          of the warning message must match. (case-insensitive)
     |      @type message: str
     |      @param category: A class (a subclass of Warning) of which the warning
     |          category must be a subclass in order to match.
     |      @type category: Warning
     |      @param filename: A string containing a regular expression that the
     |          start of the path to the warning module must match.
     |          (case-sensitive)
     |      @type filename: str
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from warnings.catch_warnings:
     |  
     |  __repr__(self)
     |      Return repr(self).
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from warnings.catch_warnings:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

FUNCTIONS
    add_decorated_full_name(obj, stacklevel=1)
        Extract full object name, including class, and store in __full_name__.
        
        This must be done on all decorators that are chained together, otherwise
        the second decorator will have the wrong full name.
        
        @param obj: A object being decorated
        @type obj: object
        @param stacklevel: level to use
        @type stacklevel: int
    
    add_full_name(obj)
        A decorator to add __full_name__ to the function being decorated.
        
        This should be done for all decorators used in pywikibot, as any
        decorator that does not add __full_name__ will prevent other
        decorators in the same chain from being able to obtain it.
        
        This can be used to monkey-patch decorators in other modules.
        e.g.
        <xyz>.foo = add_full_name(<xyz>.foo)
        
        @param obj: The function to decorate
        @type obj: callable
        @return: decorating function
        @rtype: function
    
    compute_file_hash(filename, sha='sha1', bytes_to_read=None)
        Compute file hash.
        
        Result is expressed as hexdigest().
        
        @param filename: filename path
        @type filename: basestring
        
        @param func: hashing function among the following in hashlib:
            md5(), sha1(), sha224(), sha256(), sha384(), and sha512()
            function name shall be passed as string, e.g. 'sha1'.
        @type filename: basestring
        
        @param bytes_to_read: only the first bytes_to_read will be considered;
            if file size is smaller, the whole file will be considered.
        @type bytes_to_read: None or int
    
    concat_options(message, line_length, options)
        Concatenate options.
    
    deprecate_arg(old_arg, new_arg)
        Decorator to declare old_arg deprecated and replace it with new_arg.
    
    deprecated = outer_wrapper(*outer_args, **outer_kwargs)
        Outer wrapper.
        
        The outer wrapper may be the replacement function if the decorated
        decorator was called without arguments, or the replacement decorator
        if the decorated decorator was called without arguments.
        
        @param outer_args: args
        @type outer_args: list
        @param outer_kwargs: kwargs
        @type outer_kwargs: dict
    
    deprecated_args(**arg_pairs)
        Decorator to declare multiple args deprecated.
        
        @param arg_pairs: Each entry points to the new argument name. With True or
            None it drops the value and prints a warning. If False it just drops
            the value.
    
    empty_iterator()
        An iterator which does nothing.
    
    file_mode_checker(filename, mode=384)
        Check file mode and update it, if needed.
        
        @param filename: filename path
        @type filename: basestring
        @param mode: requested file mode
        @type mode: int
    
    filter_unique(iterable, container=None, key=None, add=None)
        Yield unique items from an iterable, omitting duplicates.
        
        By default, to provide uniqueness, it puts the generated items into
        the keys of a dict created as a local variable, each with a value of True.
        It only yields items which are not already present in the local dict.
        
        For large collections, this is not memory efficient, as a strong reference
        to every item is kept in a local dict which can not be cleared.
        
        Also, the local dict cant be re-used when chaining unique operations on
        multiple generators.
        
        To avoid these issues, it is advisable for the caller to provide their own
        container and set the key parameter to be the function L{hash}, or use a
        L{weakref} as the key.
        
        The container can be any object that supports __contains__.
        If the container is a set or dict, the method add or __setitem__ will be
        used automatically. Any other method may be provided explicitly using the
        add parameter.
        
        Beware that key=id is only useful for cases where id() is not unique.
        
        Note: This is not thread safe.
        
        @param iterable: the source iterable
        @type iterable: collections.Iterable
        @param container: storage of seen items
        @type container: type
        @param key: function to convert the item to a key
        @type key: callable
        @param add: function to add an item to the container
        @type add: callable
    
    first_lower(string)
        Return a string with the first character uncapitalized.
        
        Empty strings are supported. The original string is not changed.
    
    first_upper(string)
        Return a string with the first character capitalized.
        
        Empty strings are supported. The original string is not changed.
        
        Warning: Python 2 and 3 capitalize "ß" differently. MediaWiki does
        not capitalize ß at the beginning. See T179115.
    
    get_wrapper_depth(wrapper)
        Return depth of wrapper function.
    
    getargspec(func)
        Python 3 implementation using inspect.signature.
    
    has_module(module)
        Check whether a module can be imported.
    
    intersect_generators(genlist)
        Intersect generators listed in genlist.
        
        Yield items only if they are yielded by all generators in genlist.
        Threads (via ThreadedGenerator) are used in order to run generators
        in parallel, so that items can be yielded before generators are
        exhausted.
        
        Threads are stopped when they are either exhausted or Ctrl-C is pressed.
        Quitting before all generators are finished is attempted if
        there is no more chance of finding an item in all queues.
        
        @param genlist: list of page generators
        @type genlist: list
    
    islice_with_ellipsis(iterable, *args, **kwargs)
        Generator which yields the first n elements of the iterable.
        
        If more elements are available and marker is True, it returns an extra
        string marker as continuation mark.
        
        Function takes the
        and the additional keyword marker.
        
        @param iterable: the iterable to work on
        @type iterable: iterable
        @param args: same args as:
            - C{itertools.islice(iterable, stop)}
            - C{itertools.islice(iterable, start, stop[, step])}
        @keyword marker: element to yield if iterable still contains elements
            after showing the required number.
            Default value: '…'
            No other kwargs are considered.
        @type marker: str
    
    issue_deprecation_warning(name, instead, depth, warning_class=None)
        Issue a deprecation warning.
    
    itergroup(iterable, size)
        Make an iterator that returns lists of (up to) size items from iterable.
        
        Example:
        
        >>> i = itergroup(range(25), 10)
        >>> print(next(i))
        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        >>> print(next(i))
        [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
        >>> print(next(i))
        [20, 21, 22, 23, 24]
        >>> print(next(i))
        Traceback (most recent call last):
         ...
        StopIteration
    
    manage_wrapping(wrapper, obj)
        Add attributes to wrapper and wrapped functions.
    
    merge_unique_dicts(*args, **kwargs)
        Return a merged dict and making sure that the original dicts had unique keys.
        
        The positional arguments are the dictionaries to be merged. It is also
        possible to define an additional dict using the keyword arguments.
    
    normalize_username(username)
        Normalize the username.
    
    open_archive(filename, mode='rb', use_extension=True)
        Open a file and uncompress it if needed.
        
        This function supports bzip2, gzip and 7zip as compression containers. It
        uses the packages available in the standard library for bzip2 and gzip so
        they are always available. 7zip is only available when a 7za program is
        available and only supports reading from it.
        
        The compression is either selected via the magic number or file ending.
        
        @param filename: The filename.
        @type filename: str
        @param use_extension: Use the file extension instead of the magic number
            to determine the type of compression (default True). Must be True when
            writing or appending.
        @type use_extension: bool
        @param mode: The mode in which the file should be opened. It may either be
            'r', 'rb', 'a', 'ab', 'w' or 'wb'. All modes open the file in binary
            mode. It defaults to 'rb'.
        @type mode: string
        @raises ValueError: When 7za is not available or the opening mode is unknown
            or it tries to write a 7z archive.
        @raises FileNotFoundError: When the filename doesn't exist and it tries
            to read from it or it tries to determine the compression algorithm (or
            IOError on Python 2).
        @raises OSError: When it's not a 7z archive but the file extension is 7z.
            It is also raised by bz2 when its content is invalid. gzip does not
            immediately raise that error but only on reading it.
        @return: A file-like object returning the uncompressed data in binary mode.
            Before Python 2.7 the GzipFile object and before 2.7.1 the BZ2File are
            wrapped in a ContextManagerWrapper with its advantages/disadvantages.
        @rtype: file-like object
    
    open_compressed(filename, use_extension=False)
        DEPRECATED: Open a file and uncompress it if needed.
    
    py2_encode_utf_8(func)
        Decorator to optionally encode the string result of a function on Python 2.x.
    
    redirect_func(target, source_module=None, target_module=None, old_name=None, class_name=None)
        Return a function which can be used to redirect to 'target'.
        
        It also acts like marking that function deprecated and copies all
        parameters.
        
        @param target: The targeted function which is to be executed.
        @type target: callable
        @param source_module: The module of the old function. If '.' defaults
            to target_module. If 'None' (default) it tries to guess it from the
            executing function.
        @type source_module: basestring
        @param target_module: The module of the target function. If
            'None' (default) it tries to get it from the target. Might not work
            with nested classes.
        @type target_module: basestring
        @param old_name: The old function name. If None it uses the name of the
            new function.
        @type old_name: basestring
        @param class_name: The name of the class. It's added to the target and
            source module (separated by a '.').
        @type class_name: basestring
        @return: A new function which adds a warning prior to each execution.
        @rtype: callable
    
    remove_last_args(arg_names)
        Decorator to declare all args additionally provided deprecated.
        
        All positional arguments appearing after the normal arguments are marked
        deprecated. It marks also all keyword arguments present in arg_names as
        deprecated. Any arguments (positional or keyword) which are not present in
        arg_names are forwarded. For example a call with 3 parameters and the
        original function requests one and arg_names contain one name will result
        in an error, because the function got called with 2 parameters.
        
        The decorated function may not use C{*args} or C{**kwargs}.
        
        @param arg_names: The names of all arguments.
        @type arg_names: iterable; for the most explanatory message it should
            retain the given order (so not a set for example).
    
    signature(obj)
        Safely return function Signature object (PEP 362).
        
        inspect.signature was introduced in 3.3, however backports are available.
        In Python 3.3, it does not support all types of callables, and should
        not be relied upon. Python 3.4 works correctly.
        
        Any exception calling inspect.signature is ignored and None is returned.
        
        @param obj: Function to inspect
        @type obj: callable
        @rtype: inpect.Signature or None
    
    warn(...)
        Issue a warning, or maybe ignore it or raise an exception.

DATA
    EMPTY_DEFAULT = ''
    PY2 = False
    PYTHON_VERSION = (3, 6, 3)
    StringTypes = (<class 'str'>,)
    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...
    basestring = (<class 'str'>,)
    unicode_literals = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', ...

FILE
    /srv/paws/pwb/pywikibot/tools/__init__.py