SYMBOL INDEX (6756 symbols across 204 files)

FILE: bench.py
  function pr_debug (line 119) | def pr_debug(*args, **kwargs):
  function run_cmd (line 124) | def run_cmd(args):
  function sample_power (line 133) | def sample_power():
  function start_power_thread (line 140) | def start_power_thread(sample_interval=POWER_SAMPLE_INTERVAL):
  function stop_power_thread (line 177) | def stop_power_thread(thread):
  function write_cpu (line 188) | def write_cpu(cpu, node, content):
  function read_file (line 193) | def read_file(node):
  function create_power_stats (line 199) | def create_power_stats(time_ns, samples):
  function get_cpu_freqs (line 215) | def get_cpu_freqs(cpu):
  function init_cpus (line 227) | def init_cpus():
  function check_charging (line 263) | def check_charging(node, charging_value, charging_warned):
  function init_power (line 279) | def init_power():
  function main (line 319) | def main():

FILE: mkbootimg.py
  function filesize (line 27) | def filesize(f):
  function update_sha (line 36) | def update_sha(sha, f):
  function pad_file (line 45) | def pad_file(f, padding):
  function get_number_of_pages (line 50) | def get_number_of_pages(image_size, page_size):
  function get_recovery_dtbo_offset (line 55) | def get_recovery_dtbo_offset(args):
  function write_header_v3 (line 66) | def write_header_v3(args):
  function write_vendor_boot_header (line 84) | def write_vendor_boot_header(args):
  function write_header (line 106) | def write_header(args):
  class ValidateStrLenAction (line 173) | class ValidateStrLenAction(Action):
    method __init__ (line 174) | def __init__(self, option_strings, dest, nargs=None, **kwargs):
    method __call__ (line 181) | def __call__(self, parser, namespace, values, option_string=None):
  function write_padded_file (line 188) | def write_padded_file(f_out, f_in, padding):
  function parse_int (line 195) | def parse_int(x):
  function parse_os_version (line 199) | def parse_os_version(x):
  function parse_os_patch_level (line 216) | def parse_os_patch_level(x):
  function parse_cmdline (line 228) | def parse_cmdline():
  function write_data (line 273) | def write_data(args, pagesize):
  function write_vendor_boot_data (line 284) | def write_vendor_boot_data(args):
  function main (line 289) | def main():

FILE: rd/usr/lib/python3.8/__future__.py
  class _Feature (line 80) | class _Feature:
    method __init__ (line 81) | def __init__(self, optionalRelease, mandatoryRelease, compiler_flag):
    method getOptionalRelease (line 86) | def getOptionalRelease(self):
    method getMandatoryRelease (line 94) | def getMandatoryRelease(self):
    method __repr__ (line 103) | def __repr__(self):

FILE: rd/usr/lib/python3.8/_bootlocale.py
  function getpreferredencoding (line 11) | def getpreferredencoding(do_setlocale=True):
  function getpreferredencoding (line 22) | def getpreferredencoding(do_setlocale=True):
  function getpreferredencoding (line 25) | def getpreferredencoding(do_setlocale=True):
  function getpreferredencoding (line 33) | def getpreferredencoding(do_setlocale=True):

FILE: rd/usr/lib/python3.8/_collections_abc.py
  function _coro (line 58) | async def _coro(): pass
  function _ag (line 64) | async def _ag(): yield
  function _check_methods (line 72) | def _check_methods(C, *methods):
  class Hashable (line 84) | class Hashable(metaclass=ABCMeta):
    method __hash__ (line 89) | def __hash__(self):
    method __subclasshook__ (line 93) | def __subclasshook__(cls, C):
  class Awaitable (line 99) | class Awaitable(metaclass=ABCMeta):
    method __await__ (line 104) | def __await__(self):
    method __subclasshook__ (line 108) | def __subclasshook__(cls, C):
  class Coroutine (line 114) | class Coroutine(Awaitable):
    method send (line 119) | def send(self, value):
    method throw (line 126) | def throw(self, typ, val=None, tb=None):
    method close (line 138) | def close(self):
    method __subclasshook__ (line 149) | def __subclasshook__(cls, C):
  class AsyncIterable (line 158) | class AsyncIterable(metaclass=ABCMeta):
    method __aiter__ (line 163) | def __aiter__(self):
    method __subclasshook__ (line 167) | def __subclasshook__(cls, C):
  class AsyncIterator (line 173) | class AsyncIterator(AsyncIterable):
    method __anext__ (line 178) | async def __anext__(self):
    method __aiter__ (line 182) | def __aiter__(self):
    method __subclasshook__ (line 186) | def __subclasshook__(cls, C):
  class AsyncGenerator (line 192) | class AsyncGenerator(AsyncIterator):
    method __anext__ (line 196) | async def __anext__(self):
    method asend (line 203) | async def asend(self, value):
    method athrow (line 210) | async def athrow(self, typ, val=None, tb=None):
    method aclose (line 222) | async def aclose(self):
    method __subclasshook__ (line 233) | def __subclasshook__(cls, C):
  class Iterable (line 243) | class Iterable(metaclass=ABCMeta):
    method __iter__ (line 248) | def __iter__(self):
    method __subclasshook__ (line 253) | def __subclasshook__(cls, C):
  class Iterator (line 259) | class Iterator(Iterable):
    method __next__ (line 264) | def __next__(self):
    method __iter__ (line 268) | def __iter__(self):
    method __subclasshook__ (line 272) | def __subclasshook__(cls, C):
  class Reversible (line 293) | class Reversible(Iterable):
    method __reversed__ (line 298) | def __reversed__(self):
    method __subclasshook__ (line 303) | def __subclasshook__(cls, C):
  class Generator (line 309) | class Generator(Iterator):
    method __next__ (line 313) | def __next__(self):
    method send (line 320) | def send(self, value):
    method throw (line 327) | def throw(self, typ, val=None, tb=None):
    method close (line 339) | def close(self):
    method __subclasshook__ (line 350) | def __subclasshook__(cls, C):
  class Sized (line 359) | class Sized(metaclass=ABCMeta):
    method __len__ (line 364) | def __len__(self):
    method __subclasshook__ (line 368) | def __subclasshook__(cls, C):
  class Container (line 374) | class Container(metaclass=ABCMeta):
    method __contains__ (line 379) | def __contains__(self, x):
    method __subclasshook__ (line 383) | def __subclasshook__(cls, C):
  class Collection (line 388) | class Collection(Sized, Iterable, Container):
    method __subclasshook__ (line 393) | def __subclasshook__(cls, C):
  class Callable (line 398) | class Callable(metaclass=ABCMeta):
    method __call__ (line 403) | def __call__(self, *args, **kwds):
    method __subclasshook__ (line 407) | def __subclasshook__(cls, C):
  class Set (line 416) | class Set(Collection):
    method __le__ (line 430) | def __le__(self, other):
    method __lt__ (line 440) | def __lt__(self, other):
    method __gt__ (line 445) | def __gt__(self, other):
    method __ge__ (line 450) | def __ge__(self, other):
    method __eq__ (line 460) | def __eq__(self, other):
    method _from_iterable (line 466) | def _from_iterable(cls, it):
    method __and__ (line 474) | def __and__(self, other):
    method isdisjoint (line 481) | def isdisjoint(self, other):
    method __or__ (line 488) | def __or__(self, other):
    method __sub__ (line 496) | def __sub__(self, other):
    method __rsub__ (line 504) | def __rsub__(self, other):
    method __xor__ (line 512) | def __xor__(self, other):
    method _hash (line 521) | def _hash(self):
  class MutableSet (line 556) | class MutableSet(Set):
    method add (line 571) | def add(self, value):
    method discard (line 576) | def discard(self, value):
    method remove (line 580) | def remove(self, value):
    method pop (line 586) | def pop(self):
    method clear (line 596) | def clear(self):
    method __ior__ (line 604) | def __ior__(self, it):
    method __iand__ (line 609) | def __iand__(self, it):
    method __ixor__ (line 614) | def __ixor__(self, it):
    method __isub__ (line 627) | def __isub__(self, it):
  class Mapping (line 641) | class Mapping(Collection):
    method __getitem__ (line 654) | def __getitem__(self, key):
    method get (line 657) | def get(self, key, default=None):
    method __contains__ (line 664) | def __contains__(self, key):
    method keys (line 672) | def keys(self):
    method items (line 676) | def items(self):
    method values (line 680) | def values(self):
    method __eq__ (line 684) | def __eq__(self, other):
  class MappingView (line 694) | class MappingView(Sized):
    method __init__ (line 698) | def __init__(self, mapping):
    method __len__ (line 701) | def __len__(self):
    method __repr__ (line 704) | def __repr__(self):
  class KeysView (line 708) | class KeysView(MappingView, Set):
    method _from_iterable (line 713) | def _from_iterable(self, it):
    method __contains__ (line 716) | def __contains__(self, key):
    method __iter__ (line 719) | def __iter__(self):
  class ItemsView (line 725) | class ItemsView(MappingView, Set):
    method _from_iterable (line 730) | def _from_iterable(self, it):
    method __contains__ (line 733) | def __contains__(self, item):
    method __iter__ (line 742) | def __iter__(self):
  class ValuesView (line 749) | class ValuesView(MappingView, Collection):
    method __contains__ (line 753) | def __contains__(self, value):
    method __iter__ (line 760) | def __iter__(self):
  class MutableMapping (line 767) | class MutableMapping(Mapping):
    method __setitem__ (line 781) | def __setitem__(self, key, value):
    method __delitem__ (line 785) | def __delitem__(self, key):
    method pop (line 790) | def pop(self, key, default=__marker):
    method popitem (line 804) | def popitem(self):
    method clear (line 816) | def clear(self):
    method update (line 824) | def update(self, other=(), /, **kwds):
    method setdefault (line 842) | def setdefault(self, key, default=None):
  class Sequence (line 856) | class Sequence(Reversible, Collection):
    method __getitem__ (line 867) | def __getitem__(self, index):
    method __iter__ (line 870) | def __iter__(self):
    method __contains__ (line 880) | def __contains__(self, value):
    method __reversed__ (line 886) | def __reversed__(self):
    method index (line 890) | def index(self, value, start=0, stop=None):
    method count (line 913) | def count(self, value):
  class ByteString (line 923) | class ByteString(Sequence):
  class MutableSequence (line 936) | class MutableSequence(Sequence):
    method __setitem__ (line 948) | def __setitem__(self, index, value):
    method __delitem__ (line 952) | def __delitem__(self, index):
    method insert (line 956) | def insert(self, index, value):
    method append (line 960) | def append(self, value):
    method clear (line 964) | def clear(self):
    method reverse (line 972) | def reverse(self):
    method extend (line 978) | def extend(self, values):
    method pop (line 985) | def pop(self, index=-1):
    method remove (line 993) | def remove(self, value):
    method __iadd__ (line 999) | def __iadd__(self, values):

FILE: rd/usr/lib/python3.8/_compression.py
  class BaseStream (line 9) | class BaseStream(io.BufferedIOBase):
    method _check_not_closed (line 12) | def _check_not_closed(self):
    method _check_can_read (line 16) | def _check_can_read(self):
    method _check_can_write (line 20) | def _check_can_write(self):
    method _check_can_seek (line 24) | def _check_can_seek(self):
  class DecompressReader (line 33) | class DecompressReader(io.RawIOBase):
    method readable (line 36) | def readable(self):
    method __init__ (line 39) | def __init__(self, fp, decomp_factory, trailing_error=(), **decomp_args):
    method close (line 59) | def close(self):
    method seekable (line 63) | def seekable(self):
    method readinto (line 66) | def readinto(self, b):
    method read (line 72) | def read(self, size=-1):
    method _rewind (line 114) | def _rewind(self):
    method seek (line 120) | def seek(self, offset, whence=io.SEEK_SET):
    method tell (line 150) | def tell(self):

FILE: rd/usr/lib/python3.8/_dummy_thread.py
  function start_new_thread (line 29) | def start_new_thread(function, args, kwargs={}):
  function exit (line 61) | def exit():
  function get_ident (line 65) | def get_ident():
  function allocate_lock (line 74) | def allocate_lock():
  function stack_size (line 78) | def stack_size(size=None):
  function _set_sentinel (line 84) | def _set_sentinel():
  class LockType (line 88) | class LockType(object):
    method __init__ (line 99) | def __init__(self):
    method acquire (line 102) | def acquire(self, waitflag=None, timeout=-1):
    method __exit__ (line 128) | def __exit__(self, typ, val, tb):
    method release (line 131) | def release(self):
    method locked (line 140) | def locked(self):
    method __repr__ (line 143) | def __repr__(self):
  class RLock (line 152) | class RLock(LockType):
    method __init__ (line 160) | def __init__(self):
    method acquire (line 164) | def acquire(self, waitflag=None, timeout=-1):
    method release (line 172) | def release(self):
  function interrupt_main (line 186) | def interrupt_main():

FILE: rd/usr/lib/python3.8/_markupbase.py
  class ParserBase (line 23) | class ParserBase:
    method __init__ (line 27) | def __init__(self):
    method error (line 32) | def error(self, message):
    method reset (line 36) | def reset(self):
    method getpos (line 40) | def getpos(self):
    method updatepos (line 48) | def updatepos(self, i, j):
    method parse_declaration (line 64) | def parse_declaration(self, i):
    method parse_marked_section (line 146) | def parse_marked_section(self, i, report=1):
    method parse_comment (line 168) | def parse_comment(self, i, report=1):
    method _parse_doctype_subset (line 182) | def _parse_doctype_subset(self, i, declstartpos):
    method _parse_doctype_element (line 249) | def _parse_doctype_element(self, i, declstartpos):
    method _parse_doctype_attlist (line 260) | def _parse_doctype_attlist(self, i, declstartpos):
    method _parse_doctype_notation (line 317) | def _parse_doctype_notation(self, i, declstartpos):
    method _parse_doctype_entity (line 340) | def _parse_doctype_entity(self, i, declstartpos):
    method _scan_name (line 376) | def _scan_name(self, i, declstartpos):
    method unknown_decl (line 394) | def unknown_decl(self, data):

FILE: rd/usr/lib/python3.8/_osx_support.py
  function _find_executable (line 29) | def _find_executable(executable, path=None):
  function _read_output (line 55) | def _read_output(commandstring):
  function _find_build_tool (line 74) | def _find_build_tool(toolname):
  function _get_system_version (line 83) | def _get_system_version():
  function _remove_original_values (line 113) | def _remove_original_values(_config_vars):
  function _save_modified_value (line 120) | def _save_modified_value(_config_vars, cv, newvalue):
  function _supports_universal_builds (line 128) | def _supports_universal_builds():
  function _find_appropriate_compiler (line 144) | def _find_appropriate_compiler(_config_vars):
  function _remove_universal_flags (line 206) | def _remove_universal_flags(_config_vars):
  function _remove_unsupported_archs (line 220) | def _remove_unsupported_archs(_config_vars):
  function _override_all_archs (line 260) | def _override_all_archs(_config_vars):
  function _check_for_unavailable_sdk (line 277) | def _check_for_unavailable_sdk(_config_vars):
  function compiler_fixup (line 304) | def compiler_fixup(compiler_so, cc_args):
  function customize_config_vars (line 379) | def customize_config_vars(_config_vars):
  function customize_compiler (line 420) | def customize_compiler(_config_vars):
  function get_platform_osx (line 440) | def get_platform_osx(_config_vars, osname, release, machine):

FILE: rd/usr/lib/python3.8/_py_abc.py
  function get_cache_token (line 4) | def get_cache_token():
  class ABCMeta (line 14) | class ABCMeta(type):
    method __new__ (line 35) | def __new__(mcls, name, bases, namespace, /, **kwargs):
    method register (line 54) | def register(cls, subclass):
    method _dump_registry (line 72) | def _dump_registry(cls, file=None):
    method _abc_registry_clear (line 83) | def _abc_registry_clear(cls):
    method _abc_caches_clear (line 87) | def _abc_caches_clear(cls):
    method __instancecheck__ (line 92) | def __instancecheck__(cls, instance):
    method __subclasscheck__ (line 108) | def __subclasscheck__(cls, subclass):

FILE: rd/usr/lib/python3.8/_pydecimal.py
  class DecimalException (line 192) | class DecimalException(ArithmeticError):
    method handle (line 211) | def handle(self, context, *args):
  class Clamped (line 215) | class Clamped(DecimalException):
  class InvalidOperation (line 227) | class InvalidOperation(DecimalException):
    method handle (line 250) | def handle(self, context, *args):
  class ConversionSyntax (line 256) | class ConversionSyntax(InvalidOperation):
    method handle (line 263) | def handle(self, context, *args):
  class DivisionByZero (line 266) | class DivisionByZero(DecimalException, ZeroDivisionError):
    method handle (line 279) | def handle(self, context, sign, *args):
  class DivisionImpossible (line 282) | class DivisionImpossible(InvalidOperation):
    method handle (line 290) | def handle(self, context, *args):
  class DivisionUndefined (line 293) | class DivisionUndefined(InvalidOperation, ZeroDivisionError):
    method handle (line 301) | def handle(self, context, *args):
  class Inexact (line 304) | class Inexact(DecimalException):
  class InvalidContext (line 316) | class InvalidContext(InvalidOperation):
    method handle (line 327) | def handle(self, context, *args):
  class Rounded (line 330) | class Rounded(DecimalException):
  class Subnormal (line 342) | class Subnormal(DecimalException):
  class Overflow (line 353) | class Overflow(Inexact, Rounded):
    method handle (line 375) | def handle(self, context, sign, *args):
  class Underflow (line 391) | class Underflow(Inexact, Rounded, Subnormal):
  class FloatOperation (line 406) | class FloatOperation(DecimalException, TypeError):
  function getcontext (line 444) | def getcontext():
  function setcontext (line 458) | def setcontext(context):
  function localcontext (line 467) | def localcontext(ctx=None):
  class Decimal (line 513) | class Decimal(object):
    method __new__ (line 522) | def __new__(cls, value="0", context=None):
    method from_float (line 673) | def from_float(cls, f):
    method _isnan (line 717) | def _isnan(self):
    method _isinfinity (line 732) | def _isinfinity(self):
    method _check_nans (line 745) | def _check_nans(self, other=None, context=None):
    method _compare_check_nans (line 777) | def _compare_check_nans(self, other, context):
    method __bool__ (line 810) | def __bool__(self):
    method _cmp (line 817) | def _cmp(self, other):
    method __eq__ (line 881) | def __eq__(self, other, context=None):
    method __lt__ (line 889) | def __lt__(self, other, context=None):
    method __le__ (line 898) | def __le__(self, other, context=None):
    method __gt__ (line 907) | def __gt__(self, other, context=None):
    method __ge__ (line 916) | def __ge__(self, other, context=None):
    method compare (line 925) | def compare(self, other, context=None):
    method __hash__ (line 943) | def __hash__(self):
    method as_tuple (line 969) | def as_tuple(self):
    method as_integer_ratio (line 976) | def as_integer_ratio(self):
    method __repr__ (line 1026) | def __repr__(self):
    method __str__ (line 1031) | def __str__(self, eng=False, context=None):
    method to_eng_string (line 1083) | def to_eng_string(self, context=None):
    method __neg__ (line 1092) | def __neg__(self, context=None):
    method __pos__ (line 1114) | def __pos__(self, context=None):
    method __abs__ (line 1135) | def __abs__(self, round=True, context=None):
    method __add__ (line 1157) | def __add__(self, other, context=None):
    method __sub__ (line 1245) | def __sub__(self, other, context=None):
    method __rsub__ (line 1259) | def __rsub__(self, other, context=None):
    method __mul__ (line 1267) | def __mul__(self, other, context=None):
    method __truediv__ (line 1324) | def __truediv__(self, other, context=None):
    method _divide (line 1383) | def _divide(self, other, context):
    method __rtruediv__ (line 1416) | def __rtruediv__(self, other, context=None):
    method __divmod__ (line 1423) | def __divmod__(self, other, context=None):
    method __rdivmod__ (line 1459) | def __rdivmod__(self, other, context=None):
    method __mod__ (line 1466) | def __mod__(self, other, context=None):
    method __rmod__ (line 1493) | def __rmod__(self, other, context=None):
    method remainder_near (line 1500) | def remainder_near(self, other, context=None):
    method __floordiv__ (line 1575) | def __floordiv__(self, other, context=None):
    method __rfloordiv__ (line 1603) | def __rfloordiv__(self, other, context=None):
    method __float__ (line 1610) | def __float__(self):
    method __int__ (line 1620) | def __int__(self):
    method real (line 1636) | def real(self):
    method imag (line 1640) | def imag(self):
    method conjugate (line 1643) | def conjugate(self):
    method __complex__ (line 1646) | def __complex__(self):
    method _fix_nan (line 1649) | def _fix_nan(self, context):
    method _fix (line 1661) | def _fix(self, context):
    method _round_down (line 1763) | def _round_down(self, prec):
    method _round_up (line 1770) | def _round_up(self, prec):
    method _round_half_up (line 1774) | def _round_half_up(self, prec):
    method _round_half_down (line 1783) | def _round_half_down(self, prec):
    method _round_half_even (line 1790) | def _round_half_even(self, prec):
    method _round_ceiling (line 1798) | def _round_ceiling(self, prec):
    method _round_floor (line 1805) | def _round_floor(self, prec):
    method _round_05up (line 1812) | def _round_05up(self, prec):
    method __round__ (line 1830) | def __round__(self, n=None):
    method __floor__ (line 1892) | def __floor__(self):
    method __ceil__ (line 1907) | def __ceil__(self):
    method fma (line 1922) | def fma(self, other, third, context=None):
    method _power_modulo (line 1966) | def _power_modulo(self, other, modulo, context=None):
    method _power_exact (line 2051) | def _power_exact(self, other, p):
    method __pow__ (line 2288) | def __pow__(self, other, modulo=None, context=None):
    method __rpow__ (line 2504) | def __rpow__(self, other, context=None):
    method normalize (line 2511) | def normalize(self, context=None):
    method quantize (line 2536) | def quantize(self, exp, rounding=None, context=None):
    method same_quantum (line 2597) | def same_quantum(self, other, context=None):
    method _rescale (line 2612) | def _rescale(self, exp, rounding):
    method _round (line 2646) | def _round(self, places, rounding):
    method to_integral_exact (line 2669) | def to_integral_exact(self, rounding=None, context=None):
    method to_integral_value (line 2698) | def to_integral_value(self, rounding=None, context=None):
    method sqrt (line 2717) | def sqrt(self, context=None):
    method max (line 2816) | def max(self, other, context=None):
    method min (line 2858) | def min(self, other, context=None):
    method _isinteger (line 2892) | def _isinteger(self):
    method _iseven (line 2901) | def _iseven(self):
    method adjusted (line 2907) | def adjusted(self):
    method canonical (line 2915) | def canonical(self):
    method compare_signal (line 2923) | def compare_signal(self, other, context=None):
    method compare_total (line 2935) | def compare_total(self, other, context=None):
    method compare_total_mag (line 3008) | def compare_total_mag(self, other, context=None):
    method copy_abs (line 3019) | def copy_abs(self):
    method copy_negate (line 3023) | def copy_negate(self):
    method copy_sign (line 3030) | def copy_sign(self, other, context=None):
    method exp (line 3036) | def exp(self, context=None):
    method is_canonical (line 3111) | def is_canonical(self):
    method is_finite (line 3119) | def is_finite(self):
    method is_infinite (line 3127) | def is_infinite(self):
    method is_nan (line 3131) | def is_nan(self):
    method is_normal (line 3135) | def is_normal(self, context=None):
    method is_qnan (line 3143) | def is_qnan(self):
    method is_signed (line 3147) | def is_signed(self):
    method is_snan (line 3151) | def is_snan(self):
    method is_subnormal (line 3155) | def is_subnormal(self, context=None):
    method is_zero (line 3163) | def is_zero(self):
    method _ln_exp_bound (line 3167) | def _ln_exp_bound(self):
    method ln (line 3192) | def ln(self, context=None):
    method _log10_exp_bound (line 3242) | def _log10_exp_bound(self):
    method log10 (line 3272) | def log10(self, context=None):
    method logb (line 3323) | def logb(self, context=None):
    method _islogical (line 3353) | def _islogical(self):
    method _fill_logical (line 3367) | def _fill_logical(self, context, opa, opb):
    method logical_and (line 3380) | def logical_and(self, other, context=None):
    method logical_invert (line 3397) | def logical_invert(self, context=None):
    method logical_or (line 3404) | def logical_or(self, other, context=None):
    method logical_xor (line 3421) | def logical_xor(self, other, context=None):
    method max_mag (line 3438) | def max_mag(self, other, context=None):
    method min_mag (line 3468) | def min_mag(self, other, context=None):
    method next_minus (line 3498) | def next_minus(self, context=None):
    method next_plus (line 3521) | def next_plus(self, context=None):
    method next_toward (line 3544) | def next_toward(self, other, context=None):
    method number_class (line 3590) | def number_class(self, context=None):
    method radix (line 3632) | def radix(self):
    method rotate (line 3636) | def rotate(self, other, context=None):
    method scaleb (line 3669) | def scaleb(self, other, context=None):
    method shift (line 3694) | def shift(self, other, context=None):
    method __reduce__ (line 3733) | def __reduce__(self):
    method __copy__ (line 3736) | def __copy__(self):
    method __deepcopy__ (line 3741) | def __deepcopy__(self, memo):
    method __format__ (line 3748) | def __format__(self, specifier, context=None, _localeconv=None):
  function _dec_from_triple (line 3830) | def _dec_from_triple(sign, coefficient, exponent, special=False):
  class _ContextManager (line 3854) | class _ContextManager(object):
    method __init__ (line 3860) | def __init__(self, new_context):
    method __enter__ (line 3862) | def __enter__(self):
    method __exit__ (line 3866) | def __exit__(self, t, v, tb):
  class Context (line 3869) | class Context(object):
    method __init__ (line 3888) | def __init__(self, prec=None, rounding=None, Emin=None, Emax=None,
    method _set_integer_check (line 3924) | def _set_integer_check(self, name, value, vmin, vmax):
    method _set_signal_dict (line 3938) | def _set_signal_dict(self, name, d):
    method __setattr__ (line 3949) | def __setattr__(self, name, value):
    method __delattr__ (line 3974) | def __delattr__(self, name):
    method __reduce__ (line 3978) | def __reduce__(self):
    method __repr__ (line 3985) | def __repr__(self):
    method clear_flags (line 3998) | def clear_flags(self):
    method clear_traps (line 4003) | def clear_traps(self):
    method _shallow_copy (line 4008) | def _shallow_copy(self):
    method copy (line 4015) | def copy(self):
    method _raise_error (line 4024) | def _raise_error(self, condition, explanation = None, *args):
    method _ignore_all_flags (line 4046) | def _ignore_all_flags(self):
    method _ignore_flags (line 4050) | def _ignore_flags(self, *flags):
    method _regard_flags (line 4057) | def _regard_flags(self, *flags):
    method Etiny (line 4067) | def Etiny(self):
    method Etop (line 4071) | def Etop(self):
    method _set_rounding (line 4075) | def _set_rounding(self, type):
    method create_decimal (line 4094) | def create_decimal(self, num='0'):
    method create_decimal_from_float (line 4111) | def create_decimal_from_float(self, f):
    method abs (line 4129) | def abs(self, a):
    method add (line 4150) | def add(self, a, b):
    method _apply (line 4171) | def _apply(self, a):
    method canonical (line 4174) | def canonical(self, a):
    method compare (line 4187) | def compare(self, a, b):
    method compare_signal (line 4223) | def compare_signal(self, a, b):
    method compare_total (line 4258) | def compare_total(self, a, b):
    method compare_total_mag (line 4287) | def compare_total_mag(self, a, b):
    method copy_abs (line 4295) | def copy_abs(self, a):
    method copy_decimal (line 4308) | def copy_decimal(self, a):
    method copy_negate (line 4321) | def copy_negate(self, a):
    method copy_sign (line 4334) | def copy_sign(self, a, b):
    method divide (line 4358) | def divide(self, a, b):
    method divide_int (line 4395) | def divide_int(self, a, b):
    method divmod (line 4418) | def divmod(self, a, b):
    method exp (line 4439) | def exp(self, a):
    method fma (line 4463) | def fma(self, a, b, c):
    method is_canonical (line 4486) | def is_canonical(self, a):
    method is_finite (line 4499) | def is_finite(self, a):
    method is_infinite (line 4521) | def is_infinite(self, a):
    method is_nan (line 4536) | def is_nan(self, a):
    method is_normal (line 4552) | def is_normal(self, a):
    method is_qnan (line 4575) | def is_qnan(self, a):
    method is_signed (line 4590) | def is_signed(self, a):
    method is_snan (line 4607) | def is_snan(self, a):
    method is_subnormal (line 4623) | def is_subnormal(self, a):
    method is_zero (line 4645) | def is_zero(self, a):
    method ln (line 4662) | def ln(self, a):
    method log10 (line 4684) | def log10(self, a):
    method logb (line 4712) | def logb(self, a):
    method logical_and (line 4738) | def logical_and(self, a, b):
    method logical_invert (line 4765) | def logical_invert(self, a):
    method logical_or (line 4784) | def logical_or(self, a, b):
    method logical_xor (line 4811) | def logical_xor(self, a, b):
    method max (line 4838) | def max(self, a, b):
    method max_mag (line 4865) | def max_mag(self, a, b):
    method min (line 4882) | def min(self, a, b):
    method min_mag (line 4909) | def min_mag(self, a, b):
    method minus (line 4926) | def minus(self, a):
    method multiply (line 4943) | def multiply(self, a, b):
    method next_minus (line 4975) | def next_minus(self, a):
    method next_plus (line 4995) | def next_plus(self, a):
    method next_toward (line 5015) | def next_toward(self, a, b):
    method normalize (line 5050) | def normalize(self, a):
    method number_class (line 5074) | def number_class(self, a):
    method plus (line 5124) | def plus(self, a):
    method power (line 5141) | def power(self, a, b, modulo=None):
    method quantize (line 5221) | def quantize(self, a, b):
    method radix (line 5279) | def radix(self):
    method remainder (line 5287) | def remainder(self, a, b):
    method remainder_near (line 5325) | def remainder_near(self, a, b):
    method rotate (line 5359) | def rotate(self, a, b):
    method same_quantum (line 5388) | def same_quantum(self, a, b):
    method scaleb (line 5412) | def scaleb (self, a, b):
    method shift (line 5431) | def shift(self, a, b):
    method sqrt (line 5461) | def sqrt(self, a):
    method subtract (line 5493) | def subtract(self, a, b):
    method to_eng_string (line 5516) | def to_eng_string(self, a):
    method to_sci_string (line 5544) | def to_sci_string(self, a):
    method to_integral_exact (line 5552) | def to_integral_exact(self, a):
    method to_integral_value (line 5582) | def to_integral_value(self, a):
  class _WorkRep (line 5614) | class _WorkRep(object):
    method __init__ (line 5620) | def __init__(self, value=None):
    method __repr__ (line 5635) | def __repr__(self):
  function _normalize (line 5640) | def _normalize(op1, op2, prec = 0):
  function _decimal_lshift_exact (line 5672) | def _decimal_lshift_exact(n, e):
  function _sqrt_nearest (line 5693) | def _sqrt_nearest(n, a):
  function _rshift_nearest (line 5708) | def _rshift_nearest(x, shift):
  function _div_nearest (line 5716) | def _div_nearest(a, b):
  function _ilog (line 5724) | def _ilog(x, M, L = 8):
  function _dlog10 (line 5772) | def _dlog10(c, e, p):
  function _dlog (line 5806) | def _dlog(c, e, p):
  class _Log10Memoize (line 5850) | class _Log10Memoize(object):
    method __init__ (line 5854) | def __init__(self):
    method getdigits (line 5857) | def getdigits(self, p):
  function _iexp (line 5887) | def _iexp(x, M, L=8):
  function _dexp (line 5924) | def _dexp(c, e, p):
  function _dpower (line 5960) | def _dpower(xc, xe, yc, ye, p):
  function _log10_lb (line 6002) | def _log10_lb(c, correction = {
  function _convert_other (line 6013) | def _convert_other(other, raiseit=False, allow_float=False):
  function _convert_for_comparison (line 6032) | def _convert_for_comparison(self, other, equality_op=False):
  function _parse_format_specifier (line 6173) | def _parse_format_specifier(format_spec, _localeconv=None):
  function _format_align (line 6253) | def _format_align(sign, body, spec):
  function _group_lengths (line 6280) | def _group_lengths(grouping):
  function _insert_thousands_sep (line 6303) | def _insert_thousands_sep(digits, spec, min_width=1):
  function _format_sign (line 6340) | def _format_sign(is_negative, spec):
  function _format_number (line 6350) | def _format_number(is_negative, intpart, fracpart, exp, spec):

FILE: rd/usr/lib/python3.8/_pyio.py
  function open (line 41) | def open(file, mode="r", buffering=-1, encoding=None, errors=None,
  function _open_code_with_warning (line 259) | def _open_code_with_warning(path):
  class DocDescriptor (line 281) | class DocDescriptor:
    method __get__ (line 284) | def __get__(self, obj, typ=None):
  class OpenWrapper (line 290) | class OpenWrapper:
    method __new__ (line 300) | def __new__(cls, *args, **kwargs):
  class UnsupportedOperation (line 309) | class UnsupportedOperation(OSError, ValueError):
  class IOBase (line 313) | class IOBase(metaclass=abc.ABCMeta):
    method _unsupported (line 348) | def _unsupported(self, name):
    method seek (line 355) | def seek(self, pos, whence=0):
    method tell (line 371) | def tell(self):
    method truncate (line 375) | def truncate(self, pos=None):
    method flush (line 385) | def flush(self):
    method close (line 395) | def close(self):
    method __del__ (line 406) | def __del__(self):
    method seekable (line 433) | def seekable(self):
    method _checkSeekable (line 441) | def _checkSeekable(self, msg=None):
    method readable (line 448) | def readable(self):
    method _checkReadable (line 455) | def _checkReadable(self, msg=None):
    method writable (line 462) | def writable(self):
    method _checkWritable (line 469) | def _checkWritable(self, msg=None):
    method closed (line 477) | def closed(self):
    method _checkClosed (line 484) | def _checkClosed(self, msg=None):
    method __enter__ (line 493) | def __enter__(self):  # That's a forward reference
    method __exit__ (line 498) | def __exit__(self, *args):
    method fileno (line 506) | def fileno(self):
    method isatty (line 513) | def isatty(self):
    method readline (line 523) | def readline(self, size=-1):
    method __iter__ (line 565) | def __iter__(self):
    method __next__ (line 569) | def __next__(self):
    method readlines (line 575) | def readlines(self, hint=None):
    method writelines (line 593) | def writelines(self, lines):
  class RawIOBase (line 606) | class RawIOBase(IOBase):
    method read (line 620) | def read(self, size=-1):
    method readall (line 637) | def readall(self):
    method readinto (line 651) | def readinto(self, b):
    method write (line 659) | def write(self, b):
  class BufferedIOBase (line 672) | class BufferedIOBase(IOBase):
    method read (line 689) | def read(self, size=-1):
    method read1 (line 709) | def read1(self, size=-1):
    method readinto (line 715) | def readinto(self, b):
    method readinto1 (line 729) | def readinto1(self, b):
    method _readinto (line 740) | def _readinto(self, b, read1):
    method write (line 755) | def write(self, b):
    method detach (line 766) | def detach(self):
  class _BufferedIOMixin (line 778) | class _BufferedIOMixin(BufferedIOBase):
    method __init__ (line 787) | def __init__(self, raw):
    method seek (line 792) | def seek(self, pos, whence=0):
    method tell (line 798) | def tell(self):
    method truncate (line 804) | def truncate(self, pos=None):
    method flush (line 818) | def flush(self):
    method close (line 823) | def close(self):
    method detach (line 831) | def detach(self):
    method seekable (line 841) | def seekable(self):
    method raw (line 845) | def raw(self):
    method closed (line 849) | def closed(self):
    method name (line 853) | def name(self):
    method mode (line 857) | def mode(self):
    method __getstate__ (line 860) | def __getstate__(self):
    method __repr__ (line 863) | def __repr__(self):
    method fileno (line 875) | def fileno(self):
    method isatty (line 878) | def isatty(self):
  class BytesIO (line 882) | class BytesIO(BufferedIOBase):
    method __init__ (line 890) | def __init__(self, initial_bytes=None):
    method __getstate__ (line 897) | def __getstate__(self):
    method getvalue (line 902) | def getvalue(self):
    method getbuffer (line 909) | def getbuffer(self):
    method close (line 916) | def close(self):
    method read (line 921) | def read(self, size=-1):
    method read1 (line 942) | def read1(self, size=-1):
    method write (line 947) | def write(self, b):
    method seek (line 966) | def seek(self, pos, whence=0):
    method tell (line 987) | def tell(self):
    method truncate (line 992) | def truncate(self, pos=None):
    method readable (line 1009) | def readable(self):
    method writable (line 1014) | def writable(self):
    method seekable (line 1019) | def seekable(self):
  class BufferedReader (line 1025) | class BufferedReader(_BufferedIOMixin):
    method __init__ (line 1036) | def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
    method readable (line 1049) | def readable(self):
    method _reset_read_buf (line 1052) | def _reset_read_buf(self):
    method read (line 1056) | def read(self, size=None):
    method _read_unlocked (line 1069) | def _read_unlocked(self, n=None):
    method peek (line 1121) | def peek(self, size=0):
    method _peek_unlocked (line 1131) | def _peek_unlocked(self, n=0):
    method read1 (line 1142) | def read1(self, size=-1):
    method _readinto (line 1160) | def _readinto(self, buf, read1):
    method tell (line 1206) | def tell(self):
    method seek (line 1209) | def seek(self, pos, whence=0):
  class BufferedWriter (line 1219) | class BufferedWriter(_BufferedIOMixin):
    method __init__ (line 1228) | def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
    method writable (line 1239) | def writable(self):
    method write (line 1242) | def write(self, b):
    method truncate (line 1270) | def truncate(self, pos=None):
    method flush (line 1277) | def flush(self):
    method _flush_unlocked (line 1281) | def _flush_unlocked(self):
    method tell (line 1298) | def tell(self):
    method seek (line 1301) | def seek(self, pos, whence=0):
    method close (line 1308) | def close(self):
  class BufferedRWPair (line 1324) | class BufferedRWPair(BufferedIOBase):
    method __init__ (line 1340) | def __init__(self, reader, writer, buffer_size=DEFAULT_BUFFER_SIZE):
    method read (line 1354) | def read(self, size=-1):
    method readinto (line 1359) | def readinto(self, b):
    method write (line 1362) | def write(self, b):
    method peek (line 1365) | def peek(self, size=0):
    method read1 (line 1368) | def read1(self, size=-1):
    method readinto1 (line 1371) | def readinto1(self, b):
    method readable (line 1374) | def readable(self):
    method writable (line 1377) | def writable(self):
    method flush (line 1380) | def flush(self):
    method close (line 1383) | def close(self):
    method isatty (line 1389) | def isatty(self):
    method closed (line 1393) | def closed(self):
  class BufferedRandom (line 1397) | class BufferedRandom(BufferedWriter, BufferedReader):
    method __init__ (line 1406) | def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
    method seek (line 1411) | def seek(self, pos, whence=0):
    method tell (line 1428) | def tell(self):
    method truncate (line 1434) | def truncate(self, pos=None):
    method read (line 1440) | def read(self, size=None):
    method readinto (line 1446) | def readinto(self, b):
    method peek (line 1450) | def peek(self, size=0):
    method read1 (line 1454) | def read1(self, size=-1):
    method readinto1 (line 1458) | def readinto1(self, b):
    method write (line 1462) | def write(self, b):
  class FileIO (line 1471) | class FileIO(RawIOBase):
    method __init__ (line 1480) | def __init__(self, file, mode='r', closefd=True, opener=None):
    method __del__ (line 1601) | def __del__(self):
    method __getstate__ (line 1608) | def __getstate__(self):
    method __repr__ (line 1611) | def __repr__(self):
    method _checkReadable (line 1625) | def _checkReadable(self):
    method _checkWritable (line 1629) | def _checkWritable(self, msg=None):
    method read (line 1633) | def read(self, size=None):
    method readall (line 1649) | def readall(self):
    method readinto (line 1684) | def readinto(self, b):
    method write (line 1692) | def write(self, b):
    method seek (line 1706) | def seek(self, pos, whence=SEEK_SET):
    method tell (line 1722) | def tell(self):
    method truncate (line 1729) | def truncate(self, size=None):
    method close (line 1742) | def close(self):
    method seekable (line 1755) | def seekable(self):
    method readable (line 1767) | def readable(self):
    method writable (line 1772) | def writable(self):
    method fileno (line 1777) | def fileno(self):
    method isatty (line 1782) | def isatty(self):
    method closefd (line 1788) | def closefd(self):
    method mode (line 1793) | def mode(self):
  class TextIOBase (line 1814) | class TextIOBase(IOBase):
    method read (line 1822) | def read(self, size=-1):
    method write (line 1832) | def write(self, s):
    method truncate (line 1836) | def truncate(self, pos=None):
    method readline (line 1840) | def readline(self):
    method detach (line 1847) | def detach(self):
    method encoding (line 1857) | def encoding(self):
    method newlines (line 1862) | def newlines(self):
    method errors (line 1872) | def errors(self):
  class IncrementalNewlineDecoder (line 1881) | class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
    method __init__ (line 1888) | def __init__(self, decoder, translate, errors='strict'):
    method decode (line 1895) | def decode(self, input, final=False):
    method getstate (line 1926) | def getstate(self):
    method setstate (line 1937) | def setstate(self, state):
    method reset (line 1943) | def reset(self):
    method newlines (line 1954) | def newlines(self):
  class TextIOWrapper (line 1966) | class TextIOWrapper(TextIOBase):
    method __init__ (line 1999) | def __init__(self, buffer, encoding=None, errors=None, newline=None,
    method _check_newline (line 2039) | def _check_newline(self, newline):
    method _configure (line 2045) | def _configure(self, encoding=None, errors=None, newline=None,
    method __repr__ (line 2081) | def __repr__(self):
    method encoding (line 2099) | def encoding(self):
    method errors (line 2103) | def errors(self):
    method line_buffering (line 2107) | def line_buffering(self):
    method write_through (line 2111) | def write_through(self):
    method buffer (line 2115) | def buffer(self):
    method reconfigure (line 2118) | def reconfigure(self, *,
    method seekable (line 2159) | def seekable(self):
    method readable (line 2164) | def readable(self):
    method writable (line 2167) | def writable(self):
    method flush (line 2170) | def flush(self):
    method close (line 2174) | def close(self):
    method closed (line 2182) | def closed(self):
    method name (line 2186) | def name(self):
    method fileno (line 2189) | def fileno(self):
    method isatty (line 2192) | def isatty(self):
    method write (line 2195) | def write(self, s):
    method _get_encoder (line 2218) | def _get_encoder(self):
    method _get_decoder (line 2223) | def _get_decoder(self):
    method _set_decoded_chars (line 2234) | def _set_decoded_chars(self, chars):
    method _get_decoded_chars (line 2239) | def _get_decoded_chars(self, n=None):
    method _rewind_decoded_chars (line 2249) | def _rewind_decoded_chars(self, n):
    method _read_chunk (line 2255) | def _read_chunk(self):
    method _pack_cookie (line 2297) | def _pack_cookie(self, position, dec_flags=0,
    method _unpack_cookie (line 2307) | def _unpack_cookie(self, bigint):
    method tell (line 2314) | def tell(self):
    method truncate (line 2413) | def truncate(self, pos=None):
    method detach (line 2419) | def detach(self):
    method seek (line 2427) | def seek(self, cookie, whence=0):
    method read (line 2502) | def read(self, size=None):
    method __next__ (line 2530) | def __next__(self):
    method readline (line 2539) | def readline(self, size=None):
    method newlines (line 2633) | def newlines(self):
  class StringIO (line 2637) | class StringIO(TextIOWrapper):
    method __init__ (line 2644) | def __init__(self, initial_value="", newline="\n"):
    method getvalue (line 2660) | def getvalue(self):
    method __repr__ (line 2670) | def __repr__(self):
    method errors (line 2676) | def errors(self):
    method encoding (line 2680) | def encoding(self):
    method detach (line 2683) | def detach(self):

FILE: rd/usr/lib/python3.8/_sitebuiltins.py
  class Quitter (line 13) | class Quitter(object):
    method __init__ (line 14) | def __init__(self, name, eof):
    method __repr__ (line 17) | def __repr__(self):
    method __call__ (line 19) | def __call__(self, code=None):
  class _Printer (line 29) | class _Printer(object):
    method __init__ (line 35) | def __init__(self, name, data, files=(), dirs=()):
    method __setup (line 44) | def __setup(self):
    method __repr__ (line 60) | def __repr__(self):
    method __call__ (line 67) | def __call__(self):
  class _Helper (line 88) | class _Helper(object):
    method __repr__ (line 98) | def __repr__(self):
    method __call__ (line 101) | def __call__(self, *args, **kwds):

FILE: rd/usr/lib/python3.8/_strptime.py
  function _getlang (line 26) | def _getlang():
  class LocaleTime (line 30) | class LocaleTime(object):
    method __init__ (line 49) | def __init__(self):
    method __calc_weekday (line 80) | def __calc_weekday(self):
    method __calc_month (line 88) | def __calc_month(self):
    method __calc_am_pm (line 95) | def __calc_am_pm(self):
    method __calc_date_time (line 107) | def __calc_date_time(self):
    method __calc_timezone (line 152) | def __calc_timezone(self):
  class TimeRE (line 170) | class TimeRE(dict):
    method __init__ (line 173) | def __init__(self, locale_time=None):
    method __seqToRE (line 219) | def __seqToRE(self, to_convert, directive):
    method pattern (line 238) | def pattern(self, format):
    method compile (line 261) | def compile(self, format):
  function _calc_julian_from_U_or_W (line 272) | def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_start...
  function _calc_julian_from_V (line 293) | def _calc_julian_from_V(iso_year, iso_week, iso_weekday):
  function _strptime (line 309) | def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
  function _strptime_time (line 559) | def _strptime_time(data_string, format="%a %b %d %H:%M:%S %Y"):
  function _strptime_datetime (line 565) | def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):

FILE: rd/usr/lib/python3.8/_threading_local.py
  class _localimpl (line 146) | class _localimpl:
    method __init__ (line 150) | def __init__(self):
    method get_dict (line 158) | def get_dict(self):
    method create_dict (line 164) | def create_dict(self):
  function _patch (line 191) | def _patch(self):
  class local (line 204) | class local:
    method __new__ (line 207) | def __new__(cls, /, *args, **kw):
    method __getattribute__ (line 221) | def __getattribute__(self, name):
    method __setattr__ (line 225) | def __setattr__(self, name, value):
    method __delattr__ (line 233) | def __delattr__(self, name):

FILE: rd/usr/lib/python3.8/_weakrefset.py
  class _IterationGuard (line 10) | class _IterationGuard:
    method __init__ (line 16) | def __init__(self, weakcontainer):
    method __enter__ (line 20) | def __enter__(self):
    method __exit__ (line 26) | def __exit__(self, e, t, b):
  class WeakSet (line 35) | class WeakSet:
    method __init__ (line 36) | def __init__(self, data=None):
    method _commit_removals (line 52) | def _commit_removals(self):
    method __iter__ (line 58) | def __iter__(self):
    method __len__ (line 67) | def __len__(self):
    method __contains__ (line 70) | def __contains__(self, item):
    method __reduce__ (line 77) | def __reduce__(self):
    method add (line 81) | def add(self, item):
    method clear (line 86) | def clear(self):
    method copy (line 91) | def copy(self):
    method pop (line 94) | def pop(self):
    method remove (line 106) | def remove(self, item):
    method discard (line 111) | def discard(self, item):
    method update (line 116) | def update(self, other):
    method __ior__ (line 122) | def __ior__(self, other):
    method difference (line 126) | def difference(self, other):
    method difference_update (line 132) | def difference_update(self, other):
    method __isub__ (line 134) | def __isub__(self, other):
    method intersection (line 143) | def intersection(self, other):
    method intersection_update (line 147) | def intersection_update(self, other):
    method __iand__ (line 149) | def __iand__(self, other):
    method issubset (line 155) | def issubset(self, other):
    method __lt__ (line 159) | def __lt__(self, other):
    method issuperset (line 162) | def issuperset(self, other):
    method __gt__ (line 166) | def __gt__(self, other):
    method __eq__ (line 169) | def __eq__(self, other):
    method symmetric_difference (line 174) | def symmetric_difference(self, other):
    method symmetric_difference_update (line 180) | def symmetric_difference_update(self, other):
    method __ixor__ (line 182) | def __ixor__(self, other):
    method union (line 191) | def union(self, other):
    method isdisjoint (line 195) | def isdisjoint(self, other):
    method __repr__ (line 198) | def __repr__(self):

FILE: rd/usr/lib/python3.8/abc.py
  function abstractmethod (line 7) | def abstractmethod(funcobj):
  class abstractclassmethod (line 28) | class abstractclassmethod(classmethod):
    method __init__ (line 36) | def __init__(self, callable):
  class abstractstaticmethod (line 41) | class abstractstaticmethod(staticmethod):
    method __init__ (line 49) | def __init__(self, callable):
  class abstractproperty (line 54) | class abstractproperty(property):
  class ABCMeta (line 71) | class ABCMeta(type):
    method __new__ (line 84) | def __new__(mcls, name, bases, namespace, **kwargs):
    method register (line 89) | def register(cls, subclass):
    method __instancecheck__ (line 96) | def __instancecheck__(cls, instance):
    method __subclasscheck__ (line 100) | def __subclasscheck__(cls, subclass):
    method _dump_registry (line 104) | def _dump_registry(cls, file=None):
    method _abc_registry_clear (line 116) | def _abc_registry_clear(cls):
    method _abc_caches_clear (line 120) | def _abc_caches_clear(cls):
  class ABC (line 125) | class ABC(metaclass=ABCMeta):

FILE: rd/usr/lib/python3.8/aifc.py
  class Error (line 143) | class Error(Exception):
  function _read_long (line 148) | def _read_long(file):
  function _read_ulong (line 154) | def _read_ulong(file):
  function _read_short (line 160) | def _read_short(file):
  function _read_ushort (line 166) | def _read_ushort(file):
  function _read_string (line 172) | def _read_string(file):
  function _read_float (line 184) | def _read_float(f): # 10 bytes
  function _write_short (line 201) | def _write_short(f, x):
  function _write_ushort (line 204) | def _write_ushort(f, x):
  function _write_long (line 207) | def _write_long(f, x):
  function _write_ulong (line 210) | def _write_ulong(f, x):
  function _write_string (line 213) | def _write_string(f, s):
  function _write_float (line 221) | def _write_float(f, x):
  class Aifc_read (line 270) | class Aifc_read:
    method initfp (line 308) | def initfp(self, file):
    method __init__ (line 348) | def __init__(self, f):
    method __enter__ (line 360) | def __enter__(self):
    method __exit__ (line 363) | def __exit__(self, *args):
    method getfp (line 369) | def getfp(self):
    method rewind (line 372) | def rewind(self):
    method close (line 376) | def close(self):
    method tell (line 382) | def tell(self):
    method getnchannels (line 385) | def getnchannels(self):
    method getnframes (line 388) | def getnframes(self):
    method getsampwidth (line 391) | def getsampwidth(self):
    method getframerate (line 394) | def getframerate(self):
    method getcomptype (line 397) | def getcomptype(self):
    method getcompname (line 400) | def getcompname(self):
    method getparams (line 406) | def getparams(self):
    method getmarkers (line 411) | def getmarkers(self):
    method getmark (line 416) | def getmark(self, id):
    method setpos (line 422) | def setpos(self, pos):
    method readframes (line 428) | def readframes(self, nframes):
    method _alaw2lin (line 449) | def _alaw2lin(self, data):
    method _ulaw2lin (line 453) | def _ulaw2lin(self, data):
    method _adpcm2lin (line 457) | def _adpcm2lin(self, data):
    method _read_comm_chunk (line 465) | def _read_comm_chunk(self, chunk):
    method _readmark (line 507) | def _readmark(self, chunk):
  class Aifc_write (line 527) | class Aifc_write:
    method __init__ (line 559) | def __init__(self, f):
    method initfp (line 575) | def initfp(self, file):
    method __del__ (line 592) | def __del__(self):
    method __enter__ (line 595) | def __enter__(self):
    method __exit__ (line 598) | def __exit__(self, *args):
    method aiff (line 604) | def aiff(self):
    method aifc (line 609) | def aifc(self):
    method setnchannels (line 614) | def setnchannels(self, nchannels):
    method getnchannels (line 621) | def getnchannels(self):
    method setsampwidth (line 626) | def setsampwidth(self, sampwidth):
    method getsampwidth (line 633) | def getsampwidth(self):
    method setframerate (line 638) | def setframerate(self, framerate):
    method getframerate (line 645) | def getframerate(self):
    method setnframes (line 650) | def setnframes(self, nframes):
    method getnframes (line 655) | def getnframes(self):
    method setcomptype (line 658) | def setcomptype(self, comptype, compname):
    method getcomptype (line 667) | def getcomptype(self):
    method getcompname (line 670) | def getcompname(self):
    method setparams (line 678) | def setparams(self, params):
    method getparams (line 691) | def getparams(self):
    method setmark (line 697) | def setmark(self, id, pos, name):
    method getmark (line 710) | def getmark(self, id):
    method getmarkers (line 716) | def getmarkers(self):
    method tell (line 721) | def tell(self):
    method writeframesraw (line 724) | def writeframesraw(self, data):
    method writeframes (line 735) | def writeframes(self, data):
    method close (line 741) | def close(self):
    method _lin2alaw (line 766) | def _lin2alaw(self, data):
    method _lin2ulaw (line 770) | def _lin2ulaw(self, data):
    method _lin2adpcm (line 774) | def _lin2adpcm(self, data):
    method _ensure_header_written (line 781) | def _ensure_header_written(self, datasize):
    method _init_compression (line 797) | def _init_compression(self):
    method _write_header (line 805) | def _write_header(self, initlength):
    method _write_form_length (line 856) | def _write_form_length(self, datalength):
    method _patchheader (line 869) | def _patchheader(self):
    method _writemarkers (line 891) | def _writemarkers(self):
  function open (line 910) | def open(f, mode=None):
  function openfp (line 923) | def openfp(f, mode=None):

FILE: rd/usr/lib/python3.8/antigravity.py
  function geohash (line 7) | def geohash(latitude, longitude, datedow):

FILE: rd/usr/lib/python3.8/argparse.py
  class _AttributeHolder (line 107) | class _AttributeHolder(object):
    method __repr__ (line 116) | def __repr__(self):
    method _get_kwargs (line 131) | def _get_kwargs(self):
    method _get_args (line 134) | def _get_args(self):
  function _copy_items (line 138) | def _copy_items(items):
  class HelpFormatter (line 154) | class HelpFormatter(object):
    method __init__ (line 161) | def __init__(self,
    method _indent (line 191) | def _indent(self):
    method _dedent (line 195) | def _dedent(self):
    class _Section (line 200) | class _Section(object):
      method __init__ (line 202) | def __init__(self, formatter, parent, heading=None):
      method format_help (line 208) | def format_help(self):
    method _add_item (line 231) | def _add_item(self, func, args):
    method start_section (line 237) | def start_section(self, heading):
    method end_section (line 243) | def end_section(self):
    method add_text (line 247) | def add_text(self, text):
    method add_usage (line 251) | def add_usage(self, usage, actions, groups, prefix=None):
    method add_argument (line 256) | def add_argument(self, action):
    method add_arguments (line 274) | def add_arguments(self, actions):
    method format_help (line 281) | def format_help(self):
    method _join_parts (line 288) | def _join_parts(self, part_strings):
    method _format_usage (line 293) | def _format_usage(self, usage, actions, groups, prefix):
    method _format_actions_usage (line 389) | def _format_actions_usage(self, actions, groups):
    method _format_text (line 492) | def _format_text(self, text):
    method _format_action (line 499) | def _format_action(self, action):
    method _format_action_invocation (line 546) | def _format_action_invocation(self, action):
    method _metavar_formatter (line 570) | def _metavar_formatter(self, action, default_metavar):
    method _format_args (line 586) | def _format_args(self, action, default_metavar):
    method _expand_help (line 610) | def _expand_help(self, action):
    method _iter_indented_subactions (line 623) | def _iter_indented_subactions(self, action):
    method _split_lines (line 633) | def _split_lines(self, text, width):
    method _fill_text (line 640) | def _fill_text(self, text, width, indent):
    method _get_help_string (line 647) | def _get_help_string(self, action):
    method _get_default_metavar_for_optional (line 650) | def _get_default_metavar_for_optional(self, action):
    method _get_default_metavar_for_positional (line 653) | def _get_default_metavar_for_positional(self, action):
  class RawDescriptionHelpFormatter (line 657) | class RawDescriptionHelpFormatter(HelpFormatter):
    method _fill_text (line 664) | def _fill_text(self, text, width, indent):
  class RawTextHelpFormatter (line 668) | class RawTextHelpFormatter(RawDescriptionHelpFormatter):
    method _split_lines (line 675) | def _split_lines(self, text, width):
  class ArgumentDefaultsHelpFormatter (line 679) | class ArgumentDefaultsHelpFormatter(HelpFormatter):
    method _get_help_string (line 686) | def _get_help_string(self, action):
  class MetavarTypeHelpFormatter (line 696) | class MetavarTypeHelpFormatter(HelpFormatter):
    method _get_default_metavar_for_optional (line 704) | def _get_default_metavar_for_optional(self, action):
    method _get_default_metavar_for_positional (line 707) | def _get_default_metavar_for_positional(self, action):
  function _get_action_name (line 716) | def _get_action_name(argument):
  class ArgumentError (line 729) | class ArgumentError(Exception):
    method __init__ (line 736) | def __init__(self, argument, message):
    method __str__ (line 740) | def __str__(self):
  class ArgumentTypeError (line 749) | class ArgumentTypeError(Exception):
  class Action (line 758) | class Action(_AttributeHolder):
    method __init__ (line 809) | def __init__(self,
    method _get_kwargs (line 831) | def _get_kwargs(self):
    method __call__ (line 845) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreAction (line 849) | class _StoreAction(Action):
    method __init__ (line 851) | def __init__(self,
    method __call__ (line 880) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreConstAction (line 884) | class _StoreConstAction(Action):
    method __init__ (line 886) | def __init__(self,
    method __call__ (line 903) | def __call__(self, parser, namespace, values, option_string=None):
  class _StoreTrueAction (line 907) | class _StoreTrueAction(_StoreConstAction):
    method __init__ (line 909) | def __init__(self,
  class _StoreFalseAction (line 924) | class _StoreFalseAction(_StoreConstAction):
    method __init__ (line 926) | def __init__(self,
  class _AppendAction (line 941) | class _AppendAction(Action):
    method __init__ (line 943) | def __init__(self,
    method __call__ (line 972) | def __call__(self, parser, namespace, values, option_string=None):
  class _AppendConstAction (line 979) | class _AppendConstAction(Action):
    method __init__ (line 981) | def __init__(self,
    method __call__ (line 999) | def __call__(self, parser, namespace, values, option_string=None):
  class _CountAction (line 1006) | class _CountAction(Action):
    method __init__ (line 1008) | def __init__(self,
    method __call__ (line 1022) | def __call__(self, parser, namespace, values, option_string=None):
  class _HelpAction (line 1029) | class _HelpAction(Action):
    method __init__ (line 1031) | def __init__(self,
    method __call__ (line 1043) | def __call__(self, parser, namespace, values, option_string=None):
  class _VersionAction (line 1048) | class _VersionAction(Action):
    method __init__ (line 1050) | def __init__(self,
    method __call__ (line 1064) | def __call__(self, parser, namespace, values, option_string=None):
  class _SubParsersAction (line 1074) | class _SubParsersAction(Action):
    class _ChoicesPseudoAction (line 1076) | class _ChoicesPseudoAction(Action):
      method __init__ (line 1078) | def __init__(self, name, aliases, help):
    method __init__ (line 1086) | def __init__(self,
    method add_parser (line 1109) | def add_parser(self, name, **kwargs):
    method _get_subactions (line 1132) | def _get_subactions(self):
    method __call__ (line 1135) | def __call__(self, parser, namespace, values, option_string=None):
  class _ExtendAction (line 1167) | class _ExtendAction(_AppendAction):
    method __call__ (line 1168) | def __call__(self, parser, namespace, values, option_string=None):
  class FileType (line 1178) | class FileType(object):
    method __init__ (line 1195) | def __init__(self, mode='r', bufsize=-1, encoding=None, errors=None):
    method __call__ (line 1201) | def __call__(self, string):
    method __repr__ (line 1221) | def __repr__(self):
  class Namespace (line 1233) | class Namespace(_AttributeHolder):
    method __init__ (line 1240) | def __init__(self, **kwargs):
    method __eq__ (line 1244) | def __eq__(self, other):
    method __contains__ (line 1249) | def __contains__(self, key):
  class _ActionsContainer (line 1253) | class _ActionsContainer(object):
    method __init__ (line 1255) | def __init__(self,
    method register (line 1308) | def register(self, registry_name, value, object):
    method _registry_get (line 1312) | def _registry_get(self, registry_name, value, default=None):
    method set_defaults (line 1318) | def set_defaults(self, **kwargs):
    method get_default (line 1327) | def get_default(self, dest):
    method add_argument (line 1337) | def add_argument(self, *args, **kwargs):
    method add_argument_group (line 1388) | def add_argument_group(self, *args, **kwargs):
    method add_mutually_exclusive_group (line 1393) | def add_mutually_exclusive_group(self, **kwargs):
    method _add_action (line 1398) | def _add_action(self, action):
    method _remove_action (line 1419) | def _remove_action(self, action):
    method _add_container_actions (line 1422) | def _add_container_actions(self, container):
    method _get_positional_kwargs (line 1462) | def _get_positional_kwargs(self, dest, **kwargs):
    method _get_optional_kwargs (line 1478) | def _get_optional_kwargs(self, *args, **kwargs):
    method _pop_action_class (line 1514) | def _pop_action_class(self, kwargs, default=None):
    method _get_handler (line 1518) | def _get_handler(self):
    method _check_conflict (line 1527) | def _check_conflict(self, action):
    method _handle_conflict_error (line 1541) | def _handle_conflict_error(self, action, conflicting_actions):
    method _handle_conflict_resolve (line 1550) | def _handle_conflict_resolve(self, action, conflicting_actions):
  class _ArgumentGroup (line 1565) | class _ArgumentGroup(_ActionsContainer):
    method __init__ (line 1567) | def __init__(self, container, title=None, description=None, **kwargs):
    method _add_action (line 1589) | def _add_action(self, action):
    method _remove_action (line 1594) | def _remove_action(self, action):
  class _MutuallyExclusiveGroup (line 1599) | class _MutuallyExclusiveGroup(_ArgumentGroup):
    method __init__ (line 1601) | def __init__(self, container, required=False):
    method _add_action (line 1606) | def _add_action(self, action):
    method _remove_action (line 1614) | def _remove_action(self, action):
  class ArgumentParser (line 1619) | class ArgumentParser(_AttributeHolder, _ActionsContainer):
    method __init__ (line 1638) | def __init__(self,
    method _get_kwargs (line 1702) | def _get_kwargs(self):
    method add_subparsers (line 1716) | def add_subparsers(self, **kwargs):
    method _add_action (line 1747) | def _add_action(self, action):
    method _get_optional_actions (line 1754) | def _get_optional_actions(self):
    method _get_positional_actions (line 1759) | def _get_positional_actions(self):
    method parse_args (line 1767) | def parse_args(self, args=None, namespace=None):
    method parse_known_args (line 1774) | def parse_known_args(self, args=None, namespace=None):
    method _parse_known_args (line 1809) | def _parse_known_args(self, arg_strings, namespace):
    method _read_args_from_files (line 2055) | def _read_args_from_files(self, arg_strings):
    method convert_arg_line_to_args (line 2081) | def convert_arg_line_to_args(self, arg_line):
    method _match_argument (line 2084) | def _match_argument(self, action, arg_strings_pattern):
    method _match_arguments_partial (line 2106) | def _match_arguments_partial(self, actions, arg_strings_pattern):
    method _parse_optional (line 2122) | def _parse_optional(self, arg_string):
    method _get_option_tuples (line 2180) | def _get_option_tuples(self, option_string):
    method _get_nargs_pattern (line 2225) | def _get_nargs_pattern(self, action):
    method parse_intermixed_args (line 2274) | def parse_intermixed_args(self, args=None, namespace=None):
    method parse_known_intermixed_args (line 2281) | def parse_known_intermixed_args(self, args=None, namespace=None):
    method _get_values (line 2358) | def _get_values(self, action, arg_strings):
    method _get_value (line 2414) | def _get_value(self, action, arg_string):
    method _check_value (line 2440) | def _check_value(self, action, value):
    method format_usage (line 2451) | def format_usage(self):
    method format_help (line 2457) | def format_help(self):
    method _get_formatter (line 2480) | def _get_formatter(self):
    method print_usage (line 2486) | def print_usage(self, file=None):
    method print_help (line 2491) | def print_help(self, file=None):
    method _print_message (line 2496) | def _print_message(self, message, file=None):
    method exit (line 2505) | def exit(self, status=0, message=None):
    method error (line 2510) | def error(self, message):

FILE: rd/usr/lib/python3.8/ast.py
  function parse (line 30) | def parse(source, filename='<unknown>', mode='exec', *,
  function literal_eval (line 51) | def literal_eval(node_or_string):
  function dump (line 102) | def dump(node, annotate_fields=True, include_attributes=False):
  function copy_location (line 141) | def copy_location(new_node, old_node):
  function fix_missing_locations (line 153) | def fix_missing_locations(node):
  function increment_lineno (line 188) | def increment_lineno(node, n=1):
  function iter_fields (line 202) | def iter_fields(node):
  function iter_child_nodes (line 214) | def iter_child_nodes(node):
  function get_docstring (line 228) | def get_docstring(node, clean=True):
  function _splitlines_no_ff (line 254) | def _splitlines_no_ff(source):
  function _pad_whitespace (line 279) | def _pad_whitespace(source):
  function get_source_segment (line 290) | def get_source_segment(source, node, *, padded=False):
  function walk (line 325) | def walk(node):
  class NodeVisitor (line 339) | class NodeVisitor(object):
    method visit (line 359) | def visit(self, node):
    method generic_visit (line 365) | def generic_visit(self, node):
    method visit_Constant (line 375) | def visit_Constant(self, node):
  class NodeTransformer (line 397) | class NodeTransformer(NodeVisitor):
    method generic_visit (line 433) | def generic_visit(self, node):
  function _getter (line 459) | def _getter(self):
  function _setter (line 462) | def _setter(self, value):
  class _ABC (line 468) | class _ABC(type):
    method __instancecheck__ (line 470) | def __instancecheck__(cls, inst):
  function _new (line 485) | def _new(cls, *args, **kwargs):
  class Num (line 497) | class Num(Constant, metaclass=_ABC):
  class Str (line 501) | class Str(Constant, metaclass=_ABC):
  class Bytes (line 505) | class Bytes(Constant, metaclass=_ABC):
  class NameConstant (line 509) | class NameConstant(Constant, metaclass=_ABC):
  class Ellipsis (line 512) | class Ellipsis(Constant, metaclass=_ABC):
    method __new__ (line 515) | def __new__(cls, *args, **kwargs):

FILE: rd/usr/lib/python3.8/asynchat.py
  class async_chat (line 52) | class async_chat(asyncore.dispatcher):
    method __init__ (line 67) | def __init__(self, sock=None, map=None):
    method collect_incoming_data (line 81) | def collect_incoming_data(self, data):
    method _collect_incoming_data (line 84) | def _collect_incoming_data(self, data):
    method _get_data (line 87) | def _get_data(self):
    method found_terminator (line 92) | def found_terminator(self):
    method set_terminator (line 95) | def set_terminator(self, term):
    method get_terminator (line 106) | def get_terminator(self):
    method handle_read (line 114) | def handle_read(self):
    method handle_write (line 186) | def handle_write(self):
    method handle_close (line 189) | def handle_close(self):
    method push (line 192) | def push(self, data):
    method push_with_producer (line 204) | def push_with_producer(self, producer):
    method readable (line 208) | def readable(self):
    method writable (line 216) | def writable(self):
    method close_when_done (line 220) | def close_when_done(self):
    method initiate_send (line 224) | def initiate_send(self):
    method discard_buffers (line 264) | def discard_buffers(self):
  class simple_producer (line 271) | class simple_producer:
    method __init__ (line 273) | def __init__(self, data, buffer_size=512):
    method more (line 277) | def more(self):
  function find_prefix_at_end (line 303) | def find_prefix_at_end(haystack, needle):

FILE: rd/usr/lib/python3.8/asyncore.py
  function _strerror (line 68) | def _strerror(err):
  class ExitNow (line 76) | class ExitNow(Exception):
  function read (line 81) | def read(obj):
  function write (line 89) | def write(obj):
  function _exception (line 97) | def _exception(obj):
  function readwrite (line 105) | def readwrite(obj, flags):
  function poll (line 125) | def poll(timeout=0.0, map=None):
  function poll2 (line 164) | def poll2(timeout=0.0, map=None):
  function loop (line 192) | def loop(timeout=30.0, use_poll=False, map=None, count=None):
  class dispatcher (line 210) | class dispatcher:
    method __init__ (line 220) | def __init__(self, sock=None, map=None):
    method __repr__ (line 252) | def __repr__(self):
    method add_channel (line 265) | def add_channel(self, map=None):
    method del_channel (line 271) | def del_channel(self, map=None):
    method create_socket (line 280) | def create_socket(self, family=socket.AF_INET, type=socket.SOCK_STREAM):
    method set_socket (line 286) | def set_socket(self, sock, map=None):
    method set_reuse_addr (line 291) | def set_reuse_addr(self):
    method readable (line 308) | def readable(self):
    method writable (line 311) | def writable(self):
    method listen (line 318) | def listen(self, num):
    method bind (line 324) | def bind(self, addr):
    method connect (line 328) | def connect(self, address):
    method accept (line 342) | def accept(self):
    method send (line 356) | def send(self, data):
    method recv (line 369) | def recv(self, buffer_size):
    method close (line 387) | def close(self):
    method log (line 403) | def log(self, message):
    method log_info (line 406) | def log_info(self, message, type='info'):
    method handle_read_event (line 410) | def handle_read_event(self):
    method handle_connect_event (line 422) | def handle_connect_event(self):
    method handle_write_event (line 430) | def handle_write_event(self):
    method handle_expt_event (line 441) | def handle_expt_event(self):
    method handle_error (line 456) | def handle_error(self):
    method handle_expt (line 476) | def handle_expt(self):
    method handle_read (line 479) | def handle_read(self):
    method handle_write (line 482) | def handle_write(self):
    method handle_connect (line 485) | def handle_connect(self):
    method handle_accept (line 488) | def handle_accept(self):
    method handle_accepted (line 493) | def handle_accepted(self, sock, addr):
    method handle_close (line 497) | def handle_close(self):
  class dispatcher_with_send (line 506) | class dispatcher_with_send(dispatcher):
    method __init__ (line 508) | def __init__(self, sock=None, map=None):
    method initiate_send (line 512) | def initiate_send(self):
    method handle_write (line 517) | def handle_write(self):
    method writable (line 520) | def writable(self):
    method send (line 523) | def send(self, data):
  function compact_traceback (line 533) | def compact_traceback():
  function close_all (line 553) | def close_all(map=None, ignore_all=False):
  class file_wrapper (line 585) | class file_wrapper:
    method __init__ (line 590) | def __init__(self, fd):
    method __del__ (line 593) | def __del__(self):
    method recv (line 599) | def recv(self, *args):
    method send (line 602) | def send(self, *args):
    method getsockopt (line 605) | def getsockopt(self, level, optname, buflen=None):
    method close (line 616) | def close(self):
    method fileno (line 623) | def fileno(self):
  class file_dispatcher (line 626) | class file_dispatcher(dispatcher):
    method __init__ (line 628) | def __init__(self, fd, map=None):
    method set_file (line 639) | def set_file(self, fd):

FILE: rd/usr/lib/python3.8/base64.py
  function _bytes_from_decode_data (line 34) | def _bytes_from_decode_data(s):
  function b64encode (line 51) | def b64encode(s, altchars=None):
  function b64decode (line 65) | def b64decode(s, altchars=None, validate=False):
  function standard_b64encode (line 90) | def standard_b64encode(s):
  function standard_b64decode (line 97) | def standard_b64decode(s):
  function urlsafe_b64encode (line 111) | def urlsafe_b64encode(s):
  function urlsafe_b64decode (line 120) | def urlsafe_b64decode(s):
  function b32encode (line 142) | def b32encode(s):
  function b32decode (line 180) | def b32decode(s, casefold=False, map01=None):
  function b16encode (line 247) | def b16encode(s):
  function b16decode (line 253) | def b16decode(s, casefold=False):
  function _85encode (line 279) | def _85encode(b, chars, chars2, pad=False, foldnuls=False, foldspaces=Fa...
  function a85encode (line 303) | def a85encode(b, *, foldspaces=False, wrapcol=0, pad=False, adobe=False):
  function a85decode (line 344) | def a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r...
  function b85encode (line 422) | def b85encode(b, pad=False):
  function b85decode (line 436) | def b85decode(b):
  function encode (line 484) | def encode(input, output):
  function decode (line 499) | def decode(input, output):
  function _input_type_check (line 508) | def _input_type_check(s):
  function encodebytes (line 524) | def encodebytes(s):
  function encodestring (line 534) | def encodestring(s):
  function decodebytes (line 543) | def decodebytes(s):
  function decodestring (line 548) | def decodestring(s):
  function main (line 558) | def main():
  function test (line 584) | def test():

FILE: rd/usr/lib/python3.8/bdb.py
  class BdbQuit (line 13) | class BdbQuit(Exception):
  class Bdb (line 17) | class Bdb:
    method __init__ (line 31) | def __init__(self, skip=None):
    method canonic (line 37) | def canonic(self, filename):
    method reset (line 54) | def reset(self):
    method trace_dispatch (line 61) | def trace_dispatch(self, frame, event, arg):
    method dispatch_line (line 104) | def dispatch_line(self, frame):
    method dispatch_call (line 116) | def dispatch_call(self, frame, arg):
    method dispatch_return (line 138) | def dispatch_return(self, frame, arg):
    method dispatch_exception (line 160) | def dispatch_exception(self, frame, arg):
    method is_skipped_module (line 191) | def is_skipped_module(self, module_name):
    method stop_here (line 200) | def stop_here(self, frame):
    method break_here (line 215) | def break_here(self, frame):
    method do_clear (line 242) | def do_clear(self, arg):
    method break_anywhere (line 249) | def break_anywhere(self, frame):
    method user_call (line 257) | def user_call(self, frame, argument_list):
    method user_line (line 261) | def user_line(self, frame):
    method user_return (line 265) | def user_return(self, frame, return_value):
    method user_exception (line 269) | def user_exception(self, frame, exc_info):
    method _set_stopinfo (line 273) | def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
    method set_until (line 290) | def set_until(self, frame, lineno=None):
    method set_step (line 298) | def set_step(self):
    method set_next (line 310) | def set_next(self, frame):
    method set_return (line 314) | def set_return(self, frame):
    method set_trace (line 321) | def set_trace(self, frame=None):
    method set_continue (line 336) | def set_continue(self):
    method set_quit (line 351) | def set_quit(self):
    method set_break (line 368) | def set_break(self, filename, lineno, temporary=False, cond=None,
    method _prune_breaks (line 386) | def _prune_breaks(self, filename, lineno):
    method clear_break (line 399) | def clear_break(self, filename, lineno):
    method clear_bpbynumber (line 416) | def clear_bpbynumber(self, arg):
    method clear_all_file_breaks (line 429) | def clear_all_file_breaks(self, filename):
    method clear_all_breaks (line 444) | def clear_all_breaks(self):
    method get_bpbynumber (line 457) | def get_bpbynumber(self, arg):
    method get_break (line 477) | def get_break(self, filename, lineno):
    method get_breaks (line 483) | def get_breaks(self, filename, lineno):
    method get_file_breaks (line 493) | def get_file_breaks(self, filename):
    method get_all_breaks (line 504) | def get_all_breaks(self):
    method get_stack (line 511) | def get_stack(self, f, t):
    method format_stack_entry (line 534) | def format_stack_entry(self, frame_lineno, lprefix=': '):
    method run (line 565) | def run(self, cmd, globals=None, locals=None):
    method runeval (line 587) | def runeval(self, expr, globals=None, locals=None):
    method runctx (line 607) | def runctx(self, cmd, globals, locals):
    method runcall (line 614) | def runcall(*args, **kwds):
  function set_trace (line 648) | def set_trace():
  class Breakpoint (line 653) | class Breakpoint:
    method __init__ (line 680) | def __init__(self, file, line, temporary=False, cond=None, funcname=No...
    method deleteMe (line 700) | def deleteMe(self):
    method enable (line 714) | def enable(self):
    method disable (line 718) | def disable(self):
    method bpprint (line 722) | def bpprint(self, out=None):
    method bpformat (line 732) | def bpformat(self):
    method __str__ (line 762) | def __str__(self):
  function checkfuncname (line 769) | def checkfuncname(b, frame):
  function effective (line 803) | def effective(file, line, frame):
  class Tdb (line 851) | class Tdb(Bdb):
    method user_call (line 852) | def user_call(self, frame, args):
    method user_line (line 856) | def user_line(self, frame):
    method user_return (line 863) | def user_return(self, frame, retval):
    method user_exception (line 865) | def user_exception(self, frame, exc_stuff):
  function foo (line 869) | def foo(n):
  function bar (line 874) | def bar(a):
  function test (line 878) | def test():

FILE: rd/usr/lib/python3.8/binhex.py
  class Error (line 31) | class Error(Exception):
  class FInfo (line 47) | class FInfo:
    method __init__ (line 48) | def __init__(self):
  function getfileinfo (line 53) | def getfileinfo(name):
  class openrsrc (line 66) | class openrsrc:
    method __init__ (line 67) | def __init__(self, *args):
    method read (line 70) | def read(self, *args):
    method write (line 73) | def write(self, *args):
    method close (line 76) | def close(self):
  class _Hqxcoderengine (line 79) | class _Hqxcoderengine:
    method __init__ (line 82) | def __init__(self, ofp):
    method write (line 88) | def write(self, data):
    method _flush (line 99) | def _flush(self, force):
    method close (line 110) | def close(self):
  class _Rlecoderengine (line 117) | class _Rlecoderengine:
    method __init__ (line 120) | def __init__(self, ofp):
    method write (line 124) | def write(self, data):
    method close (line 132) | def close(self):
  class BinHex (line 139) | class BinHex:
    method __init__ (line 140) | def __init__(self, name_finfo_dlen_rlen, ofp):
    method _writeinfo (line 163) | def _writeinfo(self, name, finfo):
    method _write (line 182) | def _write(self, data):
    method _writecrc (line 186) | def _writecrc(self):
    method write (line 196) | def write(self, data):
    method close_data (line 202) | def close_data(self):
    method write_rsrc (line 208) | def write_rsrc(self, data):
    method close (line 216) | def close(self):
  function binhex (line 233) | def binhex(inp, out):
  class _Hqxdecoderengine (line 254) | class _Hqxdecoderengine:
    method __init__ (line 257) | def __init__(self, ifp):
    method read (line 261) | def read(self, totalwtd):
    method close (line 293) | def close(self):
  class _Rledecoderengine (line 296) | class _Rledecoderengine:
    method __init__ (line 299) | def __init__(self, ifp):
    method read (line 305) | def read(self, wtd):
    method _fill (line 312) | def _fill(self, wtd):
    method close (line 347) | def close(self):
  class HexBin (line 350) | class HexBin:
    method __init__ (line 351) | def __init__(self, ifp):
    method _read (line 373) | def _read(self, len):
    method _checkcrc (line 378) | def _checkcrc(self):
    method _readheader (line 388) | def _readheader(self):
    method read (line 408) | def read(self, *n):
    method close_data (line 422) | def close_data(self):
    method read_rsrc (line 430) | def read_rsrc(self, *n):
    method close (line 443) | def close(self):
  function hexbin (line 454) | def hexbin(inp, out):

FILE: rd/usr/lib/python3.8/bisect.py
  function insort_right (line 3) | def insort_right(a, x, lo=0, hi=None):
  function bisect_right (line 15) | def bisect_right(a, x, lo=0, hi=None):
  function insort_left (line 36) | def insort_left(a, x, lo=0, hi=None):
  function bisect_left (line 49) | def bisect_left(a, x, lo=0, hi=None):

FILE: rd/usr/lib/python3.8/bz2.py
  class BZ2File (line 30) | class BZ2File(_compression.BaseStream):
    method __init__ (line 41) | def __init__(self, filename, mode="r", buffering=_sentinel, compressle...
    method close (line 112) | def close(self):
    method closed (line 138) | def closed(self):
    method fileno (line 142) | def fileno(self):
    method seekable (line 147) | def seekable(self):
    method readable (line 151) | def readable(self):
    method writable (line 156) | def writable(self):
    method peek (line 161) | def peek(self, n=0):
    method read (line 174) | def read(self, size=-1):
    method read1 (line 184) | def read1(self, size=-1):
    method readinto (line 197) | def readinto(self, b):
    method readline (line 206) | def readline(self, size=-1):
    method readlines (line 221) | def readlines(self, size=-1):
    method write (line 236) | def write(self, data):
    method writelines (line 250) | def writelines(self, seq):
    method seek (line 261) | def seek(self, offset, whence=io.SEEK_SET):
    method tell (line 280) | def tell(self):
  function open (line 289) | def open(filename, mode="rb", compresslevel=9,
  function compress (line 330) | def compress(data, compresslevel=9):
  function decompress (line 341) | def decompress(data):

FILE: rd/usr/lib/python3.8/cProfile.py
  function run (line 15) | def run(statement, filename=None, sort=-1):
  function runctx (line 18) | def runctx(statement, globals, locals, filename=None, sort=-1):
  class Profile (line 27) | class Profile(_lsprof.Profiler):
    method print_stats (line 40) | def print_stats(self, sort=-1):
    method dump_stats (line 44) | def dump_stats(self, file):
    method create_stats (line 50) | def create_stats(self):
    method snapshot_stats (line 54) | def snapshot_stats(self):
    method run (line 92) | def run(self, cmd):
    method runctx (line 97) | def runctx(self, cmd, globals, locals):
    method runcall (line 106) | def runcall(*args, **kw):
    method __enter__ (line 129) | def __enter__(self):
    method __exit__ (line 133) | def __exit__(self, *exc_info):
  function label (line 138) | def label(code):
  function main (line 146) | def main():

FILE: rd/usr/lib/python3.8/calendar.py
  class IllegalMonthError (line 24) | class IllegalMonthError(ValueError):
    method __init__ (line 25) | def __init__(self, month):
    method __str__ (line 27) | def __str__(self):
  class IllegalWeekdayError (line 31) | class IllegalWeekdayError(ValueError):
    method __init__ (line 32) | def __init__(self, weekday):
    method __str__ (line 34) | def __str__(self):
  class _localized_month (line 50) | class _localized_month:
    method __init__ (line 55) | def __init__(self, format):
    method __getitem__ (line 58) | def __getitem__(self, i):
    method __len__ (line 65) | def __len__(self):
  class _localized_day (line 69) | class _localized_day:
    method __init__ (line 74) | def __init__(self, format):
    method __getitem__ (line 77) | def __getitem__(self, i):
    method __len__ (line 84) | def __len__(self):
  function isleap (line 100) | def isleap(year):
  function leapdays (line 105) | def leapdays(y1, y2):
  function weekday (line 113) | def weekday(year, month, day):
  function monthrange (line 120) | def monthrange(year, month):
  function _monthlen (line 130) | def _monthlen(year, month):
  function _prevmonth (line 134) | def _prevmonth(year, month):
  function _nextmonth (line 141) | def _nextmonth(year, month):
  class Calendar (line 148) | class Calendar(object):
    method __init__ (line 154) | def __init__(self, firstweekday=0):
    method getfirstweekday (line 157) | def getfirstweekday(self):
    method setfirstweekday (line 160) | def setfirstweekday(self, firstweekday):
    method iterweekdays (line 165) | def iterweekdays(self):
    method itermonthdates (line 173) | def itermonthdates(self, year, month):
    method itermonthdays (line 182) | def itermonthdays(self, year, month):
    method itermonthdays2 (line 194) | def itermonthdays2(self, year, month):
    method itermonthdays3 (line 202) | def itermonthdays3(self, year, month):
    method itermonthdays4 (line 220) | def itermonthdays4(self, year, month):
    method monthdatescalendar (line 228) | def monthdatescalendar(self, year, month):
    method monthdays2calendar (line 236) | def monthdays2calendar(self, year, month):
    method monthdayscalendar (line 246) | def monthdayscalendar(self, year, month):
    method yeardatescalendar (line 254) | def yeardatescalendar(self, year, width=3):
    method yeardays2calendar (line 267) | def yeardays2calendar(self, year, width=3):
    method yeardayscalendar (line 280) | def yeardayscalendar(self, year, width=3):
  class TextCalendar (line 293) | class TextCalendar(Calendar):
    method prweek (line 299) | def prweek(self, theweek, width):
    method formatday (line 305) | def formatday(self, day, weekday, width):
    method formatweek (line 315) | def formatweek(self, theweek, width):
    method formatweekday (line 321) | def formatweekday(self, day, width):
    method formatweekheader (line 331) | def formatweekheader(self, width):
    method formatmonthname (line 337) | def formatmonthname(self, theyear, themonth, width, withyear=True):
    method prmonth (line 346) | def prmonth(self, theyear, themonth, w=0, l=0):
    method formatmonth (line 352) | def formatmonth(self, theyear, themonth, w=0, l=0):
    method formatyear (line 368) | def formatyear(self, theyear, w=2, l=1, c=6, m=3):
    method pryear (line 405) | def pryear(self, theyear, w=0, l=0, c=6, m=3):
  class HTMLCalendar (line 410) | class HTMLCalendar(Calendar):
    method formatday (line 436) | def formatday(self, day, weekday):
    method formatweek (line 446) | def formatweek(self, theweek):
    method formatweekday (line 453) | def formatweekday(self, day):
    method formatweekheader (line 460) | def formatweekheader(self):
    method formatmonthname (line 467) | def formatmonthname(self, theyear, themonth, withyear=True):
    method formatmonth (line 478) | def formatmonth(self, theyear, themonth, withyear=True):
    method formatyear (line 498) | def formatyear(self, theyear, width=3):
    method formatyearpage (line 522) | def formatyearpage(self, theyear, width=3, css='calendar.css', encodin...
  class different_locale (line 546) | class different_locale:
    method __init__ (line 547) | def __init__(self, locale):
    method __enter__ (line 550) | def __enter__(self):
    method __exit__ (line 554) | def __exit__(self, *args):
  class LocaleTextCalendar (line 558) | class LocaleTextCalendar(TextCalendar):
    method __init__ (line 566) | def __init__(self, firstweekday=0, locale=None):
    method formatweekday (line 572) | def formatweekday(self, day, width):
    method formatmonthname (line 581) | def formatmonthname(self, theyear, themonth, width, withyear=True):
  class LocaleHTMLCalendar (line 589) | class LocaleHTMLCalendar(HTMLCalendar):
    method __init__ (line 596) | def __init__(self, firstweekday=0, locale=None):
    method formatweekday (line 602) | def formatweekday(self, day):
    method formatmonthname (line 607) | def formatmonthname(self, theyear, themonth, withyear=True):
  function setfirstweekday (line 620) | def setfirstweekday(firstweekday):
  function format (line 640) | def format(cols, colwidth=_colwidth, spacing=_spacing):
  function formatstring (line 645) | def formatstring(cols, colwidth=_colwidth, spacing=_spacing):
  function timegm (line 655) | def timegm(tuple):
  function main (line 665) | def main(args):

FILE: rd/usr/lib/python3.8/cgi.py
  function initlog (line 56) | def initlog(*allargs):
  function dolog (line 91) | def dolog(fmt, *args):
  function nolog (line 95) | def nolog(*allargs):
  function closelog (line 99) | def closelog():
  function parse (line 118) | def parse(fp=None, environ=os.environ, keep_blank_values=0, strict_parsi...
  function parse_multipart (line 184) | def parse_multipart(fp, pdict, encoding="utf-8", errors="replace"):
  function _parseparam (line 211) | def _parseparam(s):
  function parse_header (line 223) | def parse_header(line):
  class MiniFieldStorage (line 247) | class MiniFieldStorage:
    method __init__ (line 261) | def __init__(self, name, value):
    method __repr__ (line 267) | def __repr__(self):
  class FieldStorage (line 272) | class FieldStorage:
    method __init__ (line 315) | def __init__(self, fp=None, headers=None, outerboundary=b'',
    method __del__ (line 479) | def __del__(self):
    method __enter__ (line 485) | def __enter__(self):
    method __exit__ (line 488) | def __exit__(self, *args):
    method __repr__ (line 491) | def __repr__(self):
    method __iter__ (line 496) | def __iter__(self):
    method __getattr__ (line 499) | def __getattr__(self, name):
    method __getitem__ (line 512) | def __getitem__(self, key):
    method getvalue (line 526) | def getvalue(self, key, default=None):
    method getfirst (line 537) | def getfirst(self, key, default=None):
    method getlist (line 548) | def getlist(self, key):
    method keys (line 559) | def keys(self):
    method __contains__ (line 565) | def __contains__(self, key):
    method __len__ (line 571) | def __len__(self):
    method __bool__ (line 575) | def __bool__(self):
    method read_urlencoded (line 580) | def read_urlencoded(self):
    method read_multi (line 598) | def read_multi(self, environ, keep_blank_values, strict_parsing):
    method read_single (line 667) | def read_single(self):
    method read_binary (line 678) | def read_binary(self):
    method read_lines (line 695) | def read_lines(self):
    method __write (line 706) | def __write(self, line):
    method read_lines_to_eof (line 721) | def read_lines_to_eof(self):
    method read_lines_to_outerboundary (line 731) | def read_lines_to_outerboundary(self):
    method skip_lines (line 781) | def skip_lines(self):
    method make_file (line 803) | def make_file(self):
  function test (line 837) | def test(environ=os.environ):
  function print_exception (line 876) | def print_exception(type=None, value=None, tb=None, limit=None):
  function print_environ (line 890) | def print_environ(environ=os.environ):
  function print_form (line 901) | def print_form(form):
  function print_directory (line 917) | def print_directory():
  function print_arguments (line 929) | def print_arguments():
  function print_environ_usage (line 936) | def print_environ_usage():
  function valid_boundary (line 983) | def valid_boundary(s):

FILE: rd/usr/lib/python3.8/cgitb.py
  function reset (line 35) | def reset():
  function small (line 46) | def small(text):
  function strong (line 52) | def strong(text):
  function grey (line 58) | def grey(text):
  function lookup (line 64) | def lookup(name, frame, locals):
  function scanvars (line 80) | def scanvars(reader, frame, locals):
  function html (line 101) | def html(einfo, context=5):
  function text (line 192) | def text(einfo, context=5):
  class Hook (line 258) | class Hook:
    method __init__ (line 261) | def __init__(self, display=1, logdir=None, context=5, file=None,
    method __call__ (line 269) | def __call__(self, etype, evalue, etb):
    method handle (line 272) | def handle(self, info=None):
  function enable (line 314) | def enable(display=1, logdir=None, context=5, format="html"):

FILE: rd/usr/lib/python3.8/chunk.py
  class Chunk (line 51) | class Chunk:
    method __init__ (line 52) | def __init__(self, file, align=True, bigendian=True, inclheader=False):
    method getname (line 78) | def getname(self):
    method getsize (line 82) | def getsize(self):
    method close (line 86) | def close(self):
    method isatty (line 93) | def isatty(self):
    method seek (line 98) | def seek(self, pos, whence=0):
    method tell (line 117) | def tell(self):
    method read (line 122) | def read(self, size=-1):
    method skip (line 145) | def skip(self):

FILE: rd/usr/lib/python3.8/cmd.py
  class Cmd (line 52) | class Cmd:
    method __init__ (line 76) | def __init__(self, completekey='tab', stdin=None, stdout=None):
    method cmdloop (line 98) | def cmdloop(self, intro=None):
    method precmd (line 150) | def precmd(self, line):
    method postcmd (line 157) | def postcmd(self, stop, line):
    method preloop (line 161) | def preloop(self):
    method postloop (line 165) | def postloop(self):
    method parseline (line 172) | def parseline(self, line):
    method onecmd (line 192) | def onecmd(self, line):
    method emptyline (line 219) | def emptyline(self):
    method default (line 229) | def default(self, line):
    method completedefault (line 238) | def completedefault(self, *ignored):
    method completenames (line 247) | def completenames(self, text, *ignored):
    method complete (line 251) | def complete(self, text, state):
    method get_names (line 281) | def get_names(self):
    method complete_help (line 286) | def complete_help(self, *args):
    method do_help (line 292) | def do_help(self, arg):
    method print_topics (line 338) | def print_topics(self, header, cmds, cmdlen, maxcol):
    method columnize (line 346) | def columnize(self, list, displaywidth=80):

FILE: rd/usr/lib/python3.8/code.py
  class InteractiveInterpreter (line 15) | class InteractiveInterpreter:
    method __init__ (line 24) | def __init__(self, locals=None):
    method runsource (line 38) | def runsource(self, source, filename="<input>", symbol="single"):
    method runcode (line 77) | def runcode(self, code):
    method showsyntaxerror (line 96) | def showsyntaxerror(self, filename=None):
    method showtraceback (line 131) | def showtraceback(self):
    method write (line 152) | def write(self, data):
  class InteractiveConsole (line 162) | class InteractiveConsole(InteractiveInterpreter):
    method __init__ (line 170) | def __init__(self, locals=None, filename="<console>"):
    method resetbuffer (line 184) | def resetbuffer(self):
    method interact (line 188) | def interact(self, banner=None, exitmsg=None):
    method push (line 242) | def push(self, line):
    method raw_input (line 263) | def raw_input(self, prompt=""):
  function interact (line 278) | def interact(banner=None, readfunc=None, local=None, exitmsg=None):

FILE: rd/usr/lib/python3.8/codecs.py
  class CodecInfo (line 83) | class CodecInfo(tuple):
    method __new__ (line 94) | def __new__(cls, encode, decode, streamreader=None, streamwriter=None,
    method __repr__ (line 109) | def __repr__(self):
  class Codec (line 114) | class Codec:
    method encode (line 138) | def encode(self, input, errors='strict'):
    method decode (line 157) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 180) | class IncrementalEncoder(object):
    method __init__ (line 186) | def __init__(self, errors='strict'):
    method encode (line 197) | def encode(self, input, final=False):
    method reset (line 203) | def reset(self):
    method getstate (line 208) | def getstate(self):
    method setstate (line 214) | def setstate(self, state):
  class BufferedIncrementalEncoder (line 220) | class BufferedIncrementalEncoder(IncrementalEncoder):
    method __init__ (line 226) | def __init__(self, errors='strict'):
    method _buffer_encode (line 231) | def _buffer_encode(self, input, errors, final):
    method encode (line 236) | def encode(self, input, final=False):
    method reset (line 244) | def reset(self):
    method getstate (line 248) | def getstate(self):
    method setstate (line 251) | def setstate(self, state):
  class IncrementalDecoder (line 254) | class IncrementalDecoder(object):
    method __init__ (line 260) | def __init__(self, errors='strict'):
    method decode (line 270) | def decode(self, input, final=False):
    method reset (line 276) | def reset(self):
    method getstate (line 281) | def getstate(self):
    method setstate (line 295) | def setstate(self, state):
  class BufferedIncrementalDecoder (line 303) | class BufferedIncrementalDecoder(IncrementalDecoder):
    method __init__ (line 309) | def __init__(self, errors='strict'):
    method _buffer_decode (line 314) | def _buffer_decode(self, input, errors, final):
    method decode (line 319) | def decode(self, input, final=False):
    method reset (line 327) | def reset(self):
    method getstate (line 331) | def getstate(self):
    method setstate (line 335) | def setstate(self, state):
  class StreamWriter (line 346) | class StreamWriter(Codec):
    method __init__ (line 348) | def __init__(self, stream, errors='strict'):
    method write (line 373) | def write(self, object):
    method writelines (line 380) | def writelines(self, list):
    method reset (line 387) | def reset(self):
    method seek (line 399) | def seek(self, offset, whence=0):
    method __getattr__ (line 404) | def __getattr__(self, name,
    method __enter__ (line 411) | def __enter__(self):
    method __exit__ (line 414) | def __exit__(self, type, value, tb):
  class StreamReader (line 419) | class StreamReader(Codec):
    method __init__ (line 423) | def __init__(self, stream, errors='strict'):
    method decode (line 448) | def decode(self, input, errors='strict'):
    method read (line 451) | def read(self, size=-1, chars=-1, firstline=False):
    method readline (line 531) | def readline(self, size=None, keepends=True):
    method readlines (line 606) | def readlines(self, sizehint=None, keepends=True):
    method reset (line 621) | def reset(self):
    method seek (line 634) | def seek(self, offset, whence=0):
    method __next__ (line 642) | def __next__(self):
    method __iter__ (line 650) | def __iter__(self):
    method __getattr__ (line 653) | def __getattr__(self, name,
    method __enter__ (line 660) | def __enter__(self):
    method __exit__ (line 663) | def __exit__(self, type, value, tb):
  class StreamReaderWriter (line 668) | class StreamReaderWriter:
    method __init__ (line 681) | def __init__(self, stream, Reader, Writer, errors='strict'):
    method read (line 699) | def read(self, size=-1):
    method readline (line 703) | def readline(self, size=None):
    method readlines (line 707) | def readlines(self, sizehint=None):
    method __next__ (line 711) | def __next__(self):
    method __iter__ (line 716) | def __iter__(self):
    method write (line 719) | def write(self, data):
    method writelines (line 723) | def writelines(self, list):
    method reset (line 727) | def reset(self):
    method seek (line 732) | def seek(self, offset, whence=0):
    method __getattr__ (line 738) | def __getattr__(self, name,
    method __enter__ (line 747) | def __enter__(self):
    method __exit__ (line 750) | def __exit__(self, type, value, tb):
  class StreamRecoder (line 755) | class StreamRecoder:
    method __init__ (line 775) | def __init__(self, stream, encode, decode, Reader, Writer,
    method read (line 803) | def read(self, size=-1):
    method readline (line 809) | def readline(self, size=None):
    method readlines (line 818) | def readlines(self, sizehint=None):
    method __next__ (line 824) | def __next__(self):
    method __iter__ (line 831) | def __iter__(self):
    method write (line 834) | def write(self, data):
    method writelines (line 839) | def writelines(self, list):
    method reset (line 845) | def reset(self):
    method seek (line 850) | def seek(self, offset, whence=0):
    method __getattr__ (line 856) | def __getattr__(self, name,
    method __enter__ (line 863) | def __enter__(self):
    method __exit__ (line 866) | def __exit__(self, type, value, tb):
  function open (line 871) | def open(filename, mode='r', encoding=None, errors='strict', buffering=-1):
  function EncodedFile (line 919) | def EncodedFile(file, data_encoding, file_encoding=None, errors='strict'):
  function getencoder (line 957) | def getencoder(encoding):
  function getdecoder (line 967) | def getdecoder(encoding):
  function getincrementalencoder (line 977) | def getincrementalencoder(encoding):
  function getincrementaldecoder (line 991) | def getincrementaldecoder(encoding):
  function getreader (line 1005) | def getreader(encoding):
  function getwriter (line 1015) | def getwriter(encoding):
  function iterencode (line 1025) | def iterencode(iterator, encoding, errors='strict', **kwargs):
  function iterdecode (line 1043) | def iterdecode(iterator, encoding, errors='strict', **kwargs):
  function make_identity_dict (line 1063) | def make_identity_dict(rng):
  function make_encoding_map (line 1073) | def make_encoding_map(decoding_map):

FILE: rd/usr/lib/python3.8/codeop.py
  function _maybe_compile (line 69) | def _maybe_compile(compiler, source, filename, symbol):
  function _compile (line 108) | def _compile(source, filename, symbol):
  function compile_command (line 111) | def compile_command(source, filename="<input>", symbol="single"):
  class Compile (line 132) | class Compile:
    method __init__ (line 137) | def __init__(self):
    method __call__ (line 140) | def __call__(self, source, filename, symbol):
  class CommandCompiler (line 147) | class CommandCompiler:
    method __init__ (line 154) | def __init__(self,):
    method __call__ (line 157) | def __call__(self, source, filename="<input>", symbol="single"):

FILE: rd/usr/lib/python3.8/collections/__init__.py
  function __getattr__ (line 42) | def __getattr__(name):
  class _OrderedDictKeysView (line 61) | class _OrderedDictKeysView(_collections_abc.KeysView):
    method __reversed__ (line 63) | def __reversed__(self):
  class _OrderedDictItemsView (line 66) | class _OrderedDictItemsView(_collections_abc.ItemsView):
    method __reversed__ (line 68) | def __reversed__(self):
  class _OrderedDictValuesView (line 72) | class _OrderedDictValuesView(_collections_abc.ValuesView):
    method __reversed__ (line 74) | def __reversed__(self):
  class _Link (line 78) | class _Link(object):
  class OrderedDict (line 81) | class OrderedDict(dict):
    method __init__ (line 96) | def __init__(self, other=(), /, **kwds):
    method __setitem__ (line 109) | def __setitem__(self, key, value,
    method __delitem__ (line 123) | def __delitem__(self, key, dict_delitem=dict.__delitem__):
    method __iter__ (line 136) | def __iter__(self):
    method __reversed__ (line 145) | def __reversed__(self):
    method clear (line 154) | def clear(self):
    method popitem (line 161) | def popitem(self, last=True):
    method move_to_end (line 184) | def move_to_end(self, key, last=True):
    method __sizeof__ (line 209) | def __sizeof__(self):
    method keys (line 220) | def keys(self):
    method items (line 224) | def items(self):
    method values (line 228) | def values(self):
    method pop (line 236) | def pop(self, key, default=__marker):
    method setdefault (line 250) | def setdefault(self, key, default=None):
    method __repr__ (line 261) | def __repr__(self):
    method __reduce__ (line 267) | def __reduce__(self):
    method copy (line 274) | def copy(self):
    method fromkeys (line 279) | def fromkeys(cls, iterable, value=None):
    method __eq__ (line 287) | def __eq__(self, other):
  function namedtuple (line 313) | def namedtuple(typename, field_names, *, rename=False, defaults=None, mo...
  function _count_elements (line 478) | def _count_elements(mapping, iterable):
  class Counter (line 489) | class Counter(dict):
    method __init__ (line 540) | def __init__(self, iterable=None, /, **kwds):
    method __missing__ (line 554) | def __missing__(self, key):
    method most_common (line 559) | def most_common(self, n=None):
    method elements (line 572) | def elements(self):
    method fromkeys (line 597) | def fromkeys(cls, iterable, v=None):
    method update (line 608) | def update(self, iterable=None, /, **kwds):
    method subtract (line 641) | def subtract(self, iterable=None, /, **kwds):
    method copy (line 668) | def copy(self):
    method __reduce__ (line 672) | def __reduce__(self):
    method __delitem__ (line 675) | def __delitem__(self, elem):
    method __repr__ (line 680) | def __repr__(self):
    method __add__ (line 706) | def __add__(self, other):
    method __sub__ (line 725) | def __sub__(self, other):
    method __or__ (line 744) | def __or__(self, other):
    method __and__ (line 764) | def __and__(self, other):
    method __pos__ (line 781) | def __pos__(self):
    method __neg__ (line 789) | def __neg__(self):
    method _keep_positive (line 800) | def _keep_positive(self):
    method __iadd__ (line 807) | def __iadd__(self, other):
    method __isub__ (line 820) | def __isub__(self, other):
    method __ior__ (line 833) | def __ior__(self, other):
    method __iand__ (line 848) | def __iand__(self, other):
  class ChainMap (line 868) | class ChainMap(_collections_abc.MutableMapping):
    method __init__ (line 882) | def __init__(self, *maps):
    method __missing__ (line 889) | def __missing__(self, key):
    method __getitem__ (line 892) | def __getitem__(self, key):
    method get (line 900) | def get(self, key, default=None):
    method __len__ (line 903) | def __len__(self):
    method __iter__ (line 906) | def __iter__(self):
    method __contains__ (line 912) | def __contains__(self, key):
    method __bool__ (line 915) | def __bool__(self):
    method __repr__ (line 919) | def __repr__(self):
    method fromkeys (line 923) | def fromkeys(cls, iterable, *args):
    method copy (line 927) | def copy(self):
    method new_child (line 933) | def new_child(self, m=None):                # like Django's Context.pu...
    method parents (line 942) | def parents(self):                          # like Django's Context.pop()
    method __setitem__ (line 946) | def __setitem__(self, key, value):
    method __delitem__ (line 949) | def __delitem__(self, key):
    method popitem (line 955) | def popitem(self):
    method pop (line 962) | def pop(self, key, *args):
    method clear (line 969) | def clear(self):
  class UserDict (line 978) | class UserDict(_collections_abc.MutableMapping):
    method __init__ (line 981) | def __init__(*args, **kwargs):
    method __len__ (line 1004) | def __len__(self): return len(self.data)
    method __getitem__ (line 1005) | def __getitem__(self, key):
    method __setitem__ (line 1011) | def __setitem__(self, key, item): self.data[key] = item
    method __delitem__ (line 1012) | def __delitem__(self, key): del self.data[key]
    method __iter__ (line 1013) | def __iter__(self):
    method __contains__ (line 1017) | def __contains__(self, key):
    method __repr__ (line 1021) | def __repr__(self): return repr(self.data)
    method __copy__ (line 1022) | def __copy__(self):
    method copy (line 1029) | def copy(self):
    method fromkeys (line 1043) | def fromkeys(cls, iterable, value=None):
  class UserList (line 1055) | class UserList(_collections_abc.MutableSequence):
    method __init__ (line 1057) | def __init__(self, initlist=None):
    method __repr__ (line 1067) | def __repr__(self): return repr(self.data)
    method __lt__ (line 1068) | def __lt__(self, other): return self.data <  self.__cast(other)
    method __le__ (line 1069) | def __le__(self, other): return self.data <= self.__cast(other)
    method __eq__ (line 1070) | def __eq__(self, other): return self.data == self.__cast(other)
    method __gt__ (line 1071) | def __gt__(self, other): return self.data >  self.__cast(other)
    method __ge__ (line 1072) | def __ge__(self, other): return self.data >= self.__cast(other)
    method __cast (line 1073) | def __cast(self, other):
    method __contains__ (line 1075) | def __contains__(self, item): return item in self.data
    method __len__ (line 1076) | def __len__(self): return len(self.data)
    method __getitem__ (line 1077) | def __getitem__(self, i):
    method __setitem__ (line 1082) | def __setitem__(self, i, item): self.data[i] = item
    method __delitem__ (line 1083) | def __delitem__(self, i): del self.data[i]
    method __add__ (line 1084) | def __add__(self, other):
    method __radd__ (line 1090) | def __radd__(self, other):
    method __iadd__ (line 1096) | def __iadd__(self, other):
    method __mul__ (line 1104) | def __mul__(self, n):
    method __imul__ (line 1107) | def __imul__(self, n):
    method __copy__ (line 1110) | def __copy__(self):
    method append (line 1116) | def append(self, item): self.data.append(item)
    method insert (line 1117) | def insert(self, i, item): self.data.insert(i, item)
    method pop (line 1118) | def pop(self, i=-1): return self.data.pop(i)
    method remove (line 1119) | def remove(self, item): self.data.remove(item)
    method clear (line 1120) | def clear(self): self.data.clear()
    method copy (line 1121) | def copy(self): return self.__class__(self)
    method count (line 1122) | def count(self, item): return self.data.count(item)
    method index (line 1123) | def index(self, item, *args): return self.data.index(item, *args)
    method reverse (line 1124) | def reverse(self): self.data.reverse()
    method sort (line 1125) | def sort(self, /, *args, **kwds): self.data.sort(*args, **kwds)
    method extend (line 1126) | def extend(self, other):
  class UserString (line 1138) | class UserString(_collections_abc.Sequence):
    method __init__ (line 1139) | def __init__(self, seq):
    method __str__ (line 1146) | def __str__(self): return str(self.data)
    method __repr__ (line 1147) | def __repr__(self): return repr(self.data)
    method __int__ (line 1148) | def __int__(self): return int(self.data)
    method __float__ (line 1149) | def __float__(self): return float(self.data)
    method __complex__ (line 1150) | def __complex__(self): return complex(self.data)
    method __hash__ (line 1151) | def __hash__(self): return hash(self.data)
    method __getnewargs__ (line 1152) | def __getnewargs__(self):
    method __eq__ (line 1155) | def __eq__(self, string):
    method __lt__ (line 1159) | def __lt__(self, string):
    method __le__ (line 1163) | def __le__(self, string):
    method __gt__ (line 1167) | def __gt__(self, string):
    method __ge__ (line 1171) | def __ge__(self, string):
    method __contains__ (line 1176) | def __contains__(self, char):
    method __len__ (line 1181) | def __len__(self): return len(self.data)
    method __getitem__ (line 1182) | def __getitem__(self, index): return self.__class__(self.data[index])
    method __add__ (line 1183) | def __add__(self, other):
    method __radd__ (line 1189) | def __radd__(self, other):
    method __mul__ (line 1193) | def __mul__(self, n):
    method __mod__ (line 1196) | def __mod__(self, args):
    method __rmod__ (line 1198) | def __rmod__(self, template):
    method capitalize (line 1201) | def capitalize(self): return self.__class__(self.data.capitalize())
    method casefold (line 1202) | def casefold(self):
    method center (line 1204) | def center(self, width, *args):
    method count (line 1206) | def count(self, sub, start=0, end=_sys.maxsize):
    method encode (line 1210) | def encode(self, encoding='utf-8', errors='strict'):
    method endswith (line 1214) | def endswith(self, suffix, start=0, end=_sys.maxsize):
    method expandtabs (line 1216) | def expandtabs(self, tabsize=8):
    method find (line 1218) | def find(self, sub, start=0, end=_sys.maxsize):
    method format (line 1222) | def format(self, /, *args, **kwds):
    method format_map (line 1224) | def format_map(self, mapping):
    method index (line 1226) | def index(self, sub, start=0, end=_sys.maxsize):
    method isalpha (line 1228) | def isalpha(self): return self.data.isalpha()
    method isalnum (line 1229) | def isalnum(self): return self.data.isalnum()
    method isascii (line 1230) | def isascii(self): return self.data.isascii()
    method isdecimal (line 1231) | def isdecimal(self): return self.data.isdecimal()
    method isdigit (line 1232) | def isdigit(self): return self.data.isdigit()
    method isidentifier (line 1233) | def isidentifier(self): return self.data.isidentifier()
    method islower (line 1234) | def islower(self): return self.data.islower()
    method isnumeric (line 1235) | def isnumeric(self): return self.data.isnumeric()
    method isprintable (line 1236) | def isprintable(self): return self.data.isprintable()
    method isspace (line 1237) | def isspace(self): return self.data.isspace()
    method istitle (line 1238) | def istitle(self): return self.data.istitle()
    method isupper (line 1239) | def isupper(self): return self.data.isupper()
    method join (line 1240) | def join(self, seq): return self.data.join(seq)
    method ljust (line 1241) | def ljust(self, width, *args):
    method lower (line 1243) | def lower(self): return self.__class__(self.data.lower())
    method lstrip (line 1244) | def lstrip(self, chars=None): return self.__class__(self.data.lstrip(c...
    method partition (line 1246) | def partition(self, sep):
    method replace (line 1248) | def replace(self, old, new, maxsplit=-1):
    method rfind (line 1254) | def rfind(self, sub, start=0, end=_sys.maxsize):
    method rindex (line 1258) | def rindex(self, sub, start=0, end=_sys.maxsize):
    method rjust (line 1260) | def rjust(self, width, *args):
    method rpartition (line 1262) | def rpartition(self, sep):
    method rstrip (line 1264) | def rstrip(self, chars=None):
    method split (line 1266) | def split(self, sep=None, maxsplit=-1):
    method rsplit (line 1268) | def rsplit(self, sep=None, maxsplit=-1):
    method splitlines (line 1270) | def splitlines(self, keepends=False): return self.data.splitlines(keep...
    method startswith (line 1271) | def startswith(self, prefix, start=0, end=_sys.maxsize):
    method strip (line 1273) | def strip(self, chars=None): return self.__class__(self.data.strip(cha...
    method swapcase (line 1274) | def swapcase(self): return self.__class__(self.data.swapcase())
    method title (line 1275) | def title(self): return self.__class__(self.data.title())
    method translate (line 1276) | def translate(self, *args):
    method upper (line 1278) | def upper(self): return self.__class__(self.data.upper())
    method zfill (line 1279) | def zfill(self, width): return self.__class__(self.data.zfill(width))

FILE: rd/usr/lib/python3.8/colorsys.py
  function rgb_to_yiq (line 40) | def rgb_to_yiq(r, g, b):
  function yiq_to_rgb (line 46) | def yiq_to_rgb(y, i, q):
  function rgb_to_hls (line 75) | def rgb_to_hls(r, g, b):
  function hls_to_rgb (line 98) | def hls_to_rgb(h, l, s):
  function _v (line 108) | def _v(m1, m2, hue):
  function rgb_to_hsv (line 124) | def rgb_to_hsv(r, g, b):
  function hsv_to_rgb (line 143) | def hsv_to_rgb(h, s, v):

FILE: rd/usr/lib/python3.8/compileall.py
  function _walk_dir (line 23) | def _walk_dir(dir, ddir=None, maxlevels=10, quiet=0):
  function compile_dir (line 50) | def compile_dir(dir, maxlevels=10, ddir=None, force=False, rx=None,
  function _compile_file_tuple (line 101) | def _compile_file_tuple(file_and_dfile, **kwargs):
  function compile_file (line 106) | def compile_file(fullname, ddir=None, force=False, rx=None, quiet=0,
  function compile_path (line 192) | def compile_path(skip_curdir=1, maxlevels=0, force=False, quiet=0,
  function main (line 226) | def main():

FILE: rd/usr/lib/python3.8/configparser.py
  class Error (line 168) | class Error(Exception):
    method __init__ (line 171) | def __init__(self, msg=''):
    method __repr__ (line 175) | def __repr__(self):
  class NoSectionError (line 181) | class NoSectionError(Error):
    method __init__ (line 184) | def __init__(self, section):
  class DuplicateSectionError (line 190) | class DuplicateSectionError(Error):
    method __init__ (line 198) | def __init__(self, section, source=None, lineno=None):
  class DuplicateOptionError (line 216) | class DuplicateOptionError(Error):
    method __init__ (line 223) | def __init__(self, section, option, source=None, lineno=None):
  class NoOptionError (line 243) | class NoOptionError(Error):
    method __init__ (line 246) | def __init__(self, option, section):
  class InterpolationError (line 254) | class InterpolationError(Error):
    method __init__ (line 257) | def __init__(self, option, section, msg):
  class InterpolationMissingOptionError (line 264) | class InterpolationMissingOptionError(InterpolationError):
    method __init__ (line 267) | def __init__(self, option, section, rawval, reference):
  class InterpolationSyntaxError (line 276) | class InterpolationSyntaxError(InterpolationError):
  class InterpolationDepthError (line 284) | class InterpolationDepthError(InterpolationError):
    method __init__ (line 287) | def __init__(self, option, section, rawval):
  class ParsingError (line 297) | class ParsingError(Error):
    method __init__ (line 300) | def __init__(self, source=None, filename=None):
    method filename (line 316) | def filename(self):
    method filename (line 326) | def filename(self, value):
    method append (line 335) | def append(self, lineno, line):
  class MissingSectionHeaderError (line 340) | class MissingSectionHeaderError(ParsingError):
    method __init__ (line 343) | def __init__(self, filename, lineno, line):
  class Interpolation (line 360) | class Interpolation:
    method before_get (line 363) | def before_get(self, parser, section, option, value, defaults):
    method before_set (line 366) | def before_set(self, parser, section, option, value):
    method before_read (line 369) | def before_read(self, parser, section, option, value):
    method before_write (line 372) | def before_write(self, parser, section, option, value):
  class BasicInterpolation (line 376) | class BasicInterpolation(Interpolation):
    method before_get (line 393) | def before_get(self, parser, section, option, value, defaults):
    method before_set (line 398) | def before_set(self, parser, section, option, value):
    method _interpolate_some (line 406) | def _interpolate_some(self, parser, option, accum, rest, section, map,
  class ExtendedInterpolation (line 448) | class ExtendedInterpolation(Interpolation):
    method before_get (line 454) | def before_get(self, parser, section, option, value, defaults):
    method before_set (line 459) | def before_set(self, parser, section, option, value):
    method _interpolate_some (line 467) | def _interpolate_some(self, parser, option, accum, rest, section, map,
  class LegacyInterpolation (line 522) | class LegacyInterpolation(Interpolation):
    method before_get (line 528) | def before_get(self, parser, section, option, value, vars):
    method before_set (line 548) | def before_set(self, parser, section, option, value):
    method _interpolation_replace (line 552) | def _interpolation_replace(match, parser):
  class RawConfigParser (line 560) | class RawConfigParser(MutableMapping):
    method __init__ (line 601) | def __init__(self, defaults=None, dict_type=_default_dict,
    method defaults (line 641) | def defaults(self):
    method sections (line 644) | def sections(self):
    method add_section (line 649) | def add_section(self, section):
    method has_section (line 663) | def has_section(self, section):
    method options (line 670) | def options(self, section):
    method read (line 679) | def read(self, filenames, encoding=None):
    method read_file (line 705) | def read_file(self, f, source=None):
    method read_string (line 720) | def read_string(self, string, source='<string>'):
    method read_dict (line 725) | def read_dict(self, dictionary, source='<dict>'):
    method readfp (line 756) | def readfp(self, fp, filename=None):
    method get (line 765) | def get(self, section, option, *, raw=False, vars=None, fallback=_UNSET):
    method _get (line 802) | def _get(self, section, conv, option, **kwargs):
    method _get_conv (line 805) | def _get_conv(self, section, option, conv, *, raw=False, vars=None,
    method getint (line 816) | def getint(self, section, option, *, raw=False, vars=None,
    method getfloat (line 821) | def getfloat(self, section, option, *, raw=False, vars=None,
    method getboolean (line 826) | def getboolean(self, section, option, *, raw=False, vars=None,
    method items (line 831) | def items(self, section=_UNSET, raw=False, vars=None):
    method popitem (line 861) | def popitem(self):
    method optionxform (line 874) | def optionxform(self, optionstr):
    method has_option (line 877) | def has_option(self, section, option):
    method set (line 891) | def set(self, section, option, value=None):
    method write (line 905) | def write(self, fp, space_around_delimiters=True):
    method _write_section (line 922) | def _write_section(self, fp, section_name, section_items, delimiter):
    method remove_option (line 935) | def remove_option(self, section, option):
    method remove_section (line 950) | def remove_section(self, section):
    method __getitem__ (line 958) | def __getitem__(self, key):
    method __setitem__ (line 963) | def __setitem__(self, key, value):
    method __delitem__ (line 976) | def __delitem__(self, key):
    method __contains__ (line 983) | def __contains__(self, key):
    method __len__ (line 986) | def __len__(self):
    method __iter__ (line 989) | def __iter__(self):
    method _read (line 993) | def _read(self, fp, fpname):
    method _join_multiline_values (line 1115) | def _join_multiline_values(self):
    method _read_defaults (line 1127) | def _read_defaults(self, defaults):
    method _handle_error (line 1133) | def _handle_error(self, exc, fpname, lineno, line):
    method _unify_values (line 1139) | def _unify_values(self, section, vars):
    method _convert_to_boolean (line 1159) | def _convert_to_boolean(self, value):
    method _validate_value_types (line 1166) | def _validate_value_types(self, *, section="", option="", value=""):
    method converters (line 1188) | def converters(self):
  class ConfigParser (line 1192) | class ConfigParser(RawConfigParser):
    method set (line 1197) | def set(self, section, option, value=None):
    method add_section (line 1203) | def add_section(self, section):
    method _read_defaults (line 1210) | def _read_defaults(self, defaults):
  class SafeConfigParser (line 1224) | class SafeConfigParser(ConfigParser):
    method __init__ (line 1227) | def __init__(self, *args, **kwargs):
  class SectionProxy (line 1237) | class SectionProxy(MutableMapping):
    method __init__ (line 1240) | def __init__(self, parser, name):
    method __repr__ (line 1249) | def __repr__(self):
    method __getitem__ (line 1252) | def __getitem__(self, key):
    method __setitem__ (line 1257) | def __setitem__(self, key, value):
    method __delitem__ (line 1261) | def __delitem__(self, key):
    method __contains__ (line 1266) | def __contains__(self, key):
    method __len__ (line 1269) | def __len__(self):
    method __iter__ (line 1272) | def __iter__(self):
    method _options (line 1275) | def _options(self):
    method parser (line 1282) | def parser(self):
    method name (line 1287) | def name(self):
    method get (line 1291) | def get(self, option, fallback=None, *, raw=False, vars=None,
  class ConverterMapping (line 1307) | class ConverterMapping(MutableMapping):
    method __init__ (line 1317) | def __init__(self, parser):
    method __getitem__ (line 1326) | def __getitem__(self, key):
    method __setitem__ (line 1329) | def __setitem__(self, key, value):
    method __delitem__ (line 1345) | def __delitem__(self, key):
    method __iter__ (line 1359) | def __iter__(self):
    method __len__ (line 1362) | def __len__(self):

FILE: rd/usr/lib/python3.8/contextlib.py
  class AbstractContextManager (line 15) | class AbstractContextManager(abc.ABC):
    method __enter__ (line 19) | def __enter__(self):
    method __exit__ (line 24) | def __exit__(self, exc_type, exc_value, traceback):
    method __subclasshook__ (line 29) | def __subclasshook__(cls, C):
  class AbstractAsyncContextManager (line 35) | class AbstractAsyncContextManager(abc.ABC):
    method __aenter__ (line 39) | async def __aenter__(self):
    method __aexit__ (line 44) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __subclasshook__ (line 49) | def __subclasshook__(cls, C):
  class ContextDecorator (line 56) | class ContextDecorator(object):
    method _recreate_cm (line 59) | def _recreate_cm(self):
    method __call__ (line 71) | def __call__(self, func):
  class _GeneratorContextManagerBase (line 79) | class _GeneratorContextManagerBase:
    method __init__ (line 82) | def __init__(self, func, args, kwds):
  class _GeneratorContextManager (line 97) | class _GeneratorContextManager(_GeneratorContextManagerBase,
    method _recreate_cm (line 102) | def _recreate_cm(self):
    method __enter__ (line 108) | def __enter__(self):
    method __exit__ (line 117) | def __exit__(self, type, value, traceback):
  class _AsyncGeneratorContextManager (line 165) | class _AsyncGeneratorContextManager(_GeneratorContextManagerBase,
    method __aenter__ (line 169) | async def __aenter__(self):
    method __aexit__ (line 175) | async def __aexit__(self, typ, value, traceback):
  function contextmanager (line 211) | def contextmanager(func):
  function asynccontextmanager (line 244) | def asynccontextmanager(func):
  class closing (line 277) | class closing(AbstractContextManager):
    method __init__ (line 294) | def __init__(self, thing):
    method __enter__ (line 296) | def __enter__(self):
    method __exit__ (line 298) | def __exit__(self, *exc_info):
  class _RedirectStream (line 302) | class _RedirectStream(AbstractContextManager):
    method __init__ (line 306) | def __init__(self, new_target):
    method __enter__ (line 311) | def __enter__(self):
    method __exit__ (line 316) | def __exit__(self, exctype, excinst, exctb):
  class redirect_stdout (line 320) | class redirect_stdout(_RedirectStream):
  class redirect_stderr (line 336) | class redirect_stderr(_RedirectStream):
  class suppress (line 342) | class suppress(AbstractContextManager):
    method __init__ (line 353) | def __init__(self, *exceptions):
    method __enter__ (line 356) | def __enter__(self):
    method __exit__ (line 359) | def __exit__(self, exctype, excinst, exctb):
  class _BaseExitStack (line 372) | class _BaseExitStack:
    method _create_exit_wrapper (line 376) | def _create_exit_wrapper(cm, cm_exit):
    method _create_cb_wrapper (line 380) | def _create_cb_wrapper(callback, /, *args, **kwds):
    method __init__ (line 385) | def __init__(self):
    method pop_all (line 388) | def pop_all(self):
    method push (line 395) | def push(self, exit):
    method enter_context (line 415) | def enter_context(self, cm):
    method callback (line 429) | def callback(*args, **kwds):
    method _push_cm_exit (line 458) | def _push_cm_exit(self, cm, cm_exit):
    method _push_exit_callback (line 463) | def _push_exit_callback(self, callback, is_sync=True):
  class ExitStack (line 468) | class ExitStack(_BaseExitStack, AbstractContextManager):
    method __enter__ (line 479) | def __enter__(self):
    method __exit__ (line 482) | def __exit__(self, *exc_details):
    method close (line 531) | def close(self):
  class AsyncExitStack (line 537) | class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager):
    method _create_async_exit_wrapper (line 551) | def _create_async_exit_wrapper(cm, cm_exit):
    method _create_async_cb_wrapper (line 555) | def _create_async_cb_wrapper(callback, /, *args, **kwds):
    method enter_async_context (line 560) | async def enter_async_context(self, cm):
    method push_async_exit (line 572) | def push_async_exit(self, exit):
    method push_async_callback (line 590) | def push_async_callback(*args, **kwds):
    method aclose (line 619) | async def aclose(self):
    method _push_async_cm_exit (line 623) | def _push_async_cm_exit(self, cm, cm_exit):
    method __aenter__ (line 629) | async def __aenter__(self):
    method __aexit__ (line 632) | async def __aexit__(self, *exc_details):
  class nullcontext (line 686) | class nullcontext(AbstractContextManager):
    method __init__ (line 697) | def __init__(self, enter_result=None):
    method __enter__ (line 700) | def __enter__(self):
    method __exit__ (line 703) | def __exit__(self, *excinfo):

FILE: rd/usr/lib/python3.8/copy.py
  class Error (line 55) | class Error(Exception):
  function copy (line 66) | def copy(x):
  function _copy_immutable (line 107) | def _copy_immutable(x):
  function deepcopy (line 128) | def deepcopy(x, memo=None, _nil=[]):
  function _deepcopy_atomic (line 182) | def _deepcopy_atomic(x, memo):
  function _deepcopy_list (line 200) | def _deepcopy_list(x, memo, deepcopy=deepcopy):
  function _deepcopy_tuple (line 209) | def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
  function _deepcopy_dict (line 226) | def _deepcopy_dict(x, memo, deepcopy=deepcopy):
  function _deepcopy_method (line 236) | def _deepcopy_method(x, memo): # Copy instance methods
  function _keep_alive (line 242) | def _keep_alive(x, memo):
  function _reconstruct (line 258) | def _reconstruct(x, memo, func, args,

FILE: rd/usr/lib/python3.8/copyreg.py
  function pickle (line 12) | def pickle(ob_type, pickle_function, constructor_ob=None):
  function constructor (line 22) | def constructor(object):
  function pickle_complex (line 34) | def pickle_complex(c):
  function _reconstructor (line 41) | def _reconstructor(cls, base, state):
  function _reduce_ex (line 54) | def _reduce_ex(self, proto):
  function __newobj__ (line 90) | def __newobj__(cls, *args):
  function __newobj_ex__ (line 93) | def __newobj_ex__(cls, args, kwargs):
  function _slotnames (line 99) | def _slotnames(cls):
  function add_extension (line 165) | def add_extension(module, name, code):
  function remove_extension (line 183) | def remove_extension(module, name, code):
  function clear_extension_cache (line 195) | def clear_extension_cache():

FILE: rd/usr/lib/python3.8/crypt.py
  class _Method (line 22) | class _Method(_namedtuple('_Method', 'name ident salt_chars total_size')):
    method __repr__ (line 27) | def __repr__(self):
  function mksalt (line 31) | def mksalt(method=None, *, rounds=None):
  function crypt (line 69) | def crypt(word, salt=None):
  function _add_method (line 87) | def _add_method(name, *args, rounds=None):

FILE: rd/usr/lib/python3.8/csv.py
  class Dialect (line 23) | class Dialect:
    method __init__ (line 42) | def __init__(self):
    method _validate (line 47) | def _validate(self):
  class excel (line 54) | class excel(Dialect):
  class excel_tab (line 64) | class excel_tab(excel):
  class unix_dialect (line 69) | class unix_dialect(Dialect):
  class DictReader (line 80) | class DictReader:
    method __init__ (line 81) | def __init__(self, f, fieldnames=None, restkey=None, restval=None,
    method __iter__ (line 90) | def __iter__(self):
    method fieldnames (line 94) | def fieldnames(self):
    method fieldnames (line 104) | def fieldnames(self, value):
    method __next__ (line 107) | def __next__(self):
  class DictWriter (line 130) | class DictWriter:
    method __init__ (line 131) | def __init__(self, f, fieldnames, restval="", extrasaction="raise",
    method writeheader (line 141) | def writeheader(self):
    method _dict_to_list (line 145) | def _dict_to_list(self, rowdict):
    method writerow (line 153) | def writerow(self, rowdict):
    method writerows (line 156) | def writerows(self, rowdicts):
  class Sniffer (line 165) | class Sniffer:
    method __init__ (line 170) | def __init__(self):
    method sniff (line 175) | def sniff(self, sample, delimiters=None):
    method _guess_quote_and_delimiter (line 204) | def _guess_quote_and_delimiter(self, data, delimiters):
    method _guess_delimiter (line 280) | def _guess_delimiter(self, data, delimiters):
    method has_header (line 383) | def has_header(self, sample):

FILE: rd/usr/lib/python3.8/curses/__init__.py
  function initscr (line 25) | def initscr():
  function start_color (line 42) | def start_color():
  function wrapper (line 63) | def wrapper(*args, **kwds):

FILE: rd/usr/lib/python3.8/curses/ascii.py
  function _ctoi (line 48) | def _ctoi(c):
  function isalnum (line 54) | def isalnum(c): return isalpha(c) or isdigit(c)
  function isalpha (line 55) | def isalpha(c): return isupper(c) or islower(c)
  function isascii (line 56) | def isascii(c): return 0 <= _ctoi(c) <= 127          # ?
  function isblank (line 57) | def isblank(c): return _ctoi(c) in (9, 32)
  function iscntrl (line 58) | def iscntrl(c): return 0 <= _ctoi(c) <= 31 or _ctoi(c) == 127
  function isdigit (line 59) | def isdigit(c): return 48 <= _ctoi(c) <= 57
  function isgraph (line 60) | def isgraph(c): return 33 <= _ctoi(c) <= 126
  function islower (line 61) | def islower(c): return 97 <= _ctoi(c) <= 122
  function isprint (line 62) | def isprint(c): return 32 <= _ctoi(c) <= 126
  function ispunct (line 63) | def ispunct(c): return isgraph(c) and not isalnum(c)
  function isspace (line 64) | def isspace(c): return _ctoi(c) in (9, 10, 11, 12, 13, 32)
  function isupper (line 65) | def isupper(c): return 65 <= _ctoi(c) <= 90
  function isxdigit (line 66) | def isxdigit(c): return isdigit(c) or \
  function isctrl (line 68) | def isctrl(c): return 0 <= _ctoi(c) < 32
  function ismeta (line 69) | def ismeta(c): return _ctoi(c) > 127
  function ascii (line 71) | def ascii(c):
  function ctrl (line 77) | def ctrl(c):
  function alt (line 83) | def alt(c):
  function unctrl (line 89) | def unctrl(c):

FILE: rd/usr/lib/python3.8/curses/has_key.py
  function has_key (line 162) | def has_key(ch):

FILE: rd/usr/lib/python3.8/curses/textpad.py
  function rectangle (line 6) | def rectangle(win, uly, ulx, lry, lrx):
  class Textbox (line 19) | class Textbox:
    method __init__ (line 43) | def __init__(self, win, insert_mode=False):
    method _update_max_yx (line 51) | def _update_max_yx(self):
    method _end_of_line (line 56) | def _end_of_line(self, y):
    method _insert_printable_char (line 70) | def _insert_printable_char(self, ch):
    method do_command (line 95) | def do_command(self, ch):
    method gather (line 160) | def gather(self):
    method edit (line 177) | def edit(self, validate=None):
  function test_editbox (line 191) | def test_editbox(stdscr):

FILE: rd/usr/lib/python3.8/dataclasses.py
  class FrozenInstanceError (line 155) | class FrozenInstanceError(AttributeError): pass
  class _HAS_DEFAULT_FACTORY_CLASS (line 160) | class _HAS_DEFAULT_FACTORY_CLASS:
    method __repr__ (line 161) | def __repr__(self):
  class _MISSING_TYPE (line 167) | class _MISSING_TYPE:
  class _FIELD_BASE (line 176) | class _FIELD_BASE:
    method __init__ (line 177) | def __init__(self, name):
    method __repr__ (line 179) | def __repr__(self):
  class _InitVarMeta (line 202) | class _InitVarMeta(type):
    method __getitem__ (line 203) | def __getitem__(self, params):
  class InitVar (line 206) | class InitVar(metaclass=_InitVarMeta):
    method __init__ (line 209) | def __init__(self, type):
    method __repr__ (line 212) | def __repr__(self):
  class Field (line 231) | class Field:
    method __init__ (line 244) | def __init__(self, default, default_factory, init, repr, hash, compare,
    method __repr__ (line 259) | def __repr__(self):
    method __set_name__ (line 281) | def __set_name__(self, owner, name):
  class _DataclassParams (line 289) | class _DataclassParams:
    method __init__ (line 298) | def __init__(self, init, repr, eq, order, unsafe_hash, frozen):
    method __repr__ (line 306) | def __repr__(self):
  function field (line 320) | def field(*, default=MISSING, default_factory=MISSING, init=True, repr=T...
  function _tuple_str (line 342) | def _tuple_str(obj_name, fields):
  function _recursive_repr (line 356) | def _recursive_repr(user_function):
  function _create_fn (line 375) | def _create_fn(name, args, body, *, globals=None, locals=None,
  function _field_assign (line 402) | def _field_assign(frozen, name, value, self_name):
  function _field_init (line 414) | def _field_init(f, frozen, globals, self_name):
  function _init_param (line 468) | def _init_param(f):
  function _init_fn (line 487) | def _init_fn(fields, frozen, has_post_init, self_name, globals):
  function _repr_fn (line 537) | def _repr_fn(fields, globals):
  function _frozen_get_del_attr (line 548) | def _frozen_get_del_attr(cls, fields, globals):
  function _cmp_fn (line 573) | def _cmp_fn(name, op, self_tuple, other_tuple, globals):
  function _hash_fn (line 587) | def _hash_fn(fields, globals):
  function _is_classvar (line 595) | def _is_classvar(a_type, typing):
  function _is_initvar (line 603) | def _is_initvar(a_type, dataclasses):
  function _is_type (line 610) | def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
  function _get_field (line 669) | def _get_field(cls, a_name, a_type):
  function _set_new_attribute (line 751) | def _set_new_attribute(cls, name, value):
  function _hash_set_none (line 765) | def _hash_set_none(cls, fields, globals):
  function _hash_add (line 768) | def _hash_add(cls, fields, globals):
  function _hash_exception (line 772) | def _hash_exception(cls, fields, globals):
  function _process_class (line 807) | def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
  function dataclass (line 996) | def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
  function fields (line 1022) | def fields(class_or_instance):
  function _is_dataclass_instance (line 1040) | def _is_dataclass_instance(obj):
  function is_dataclass (line 1045) | def is_dataclass(obj):
  function asdict (line 1052) | def asdict(obj, *, dict_factory=dict):
  function _asdict_inner (line 1076) | def _asdict_inner(obj, dict_factory):
  function astuple (line 1117) | def astuple(obj, *, tuple_factory=tuple):
  function _astuple_inner (line 1141) | def _astuple_inner(obj, tuple_factory):
  function make_dataclass (line 1168) | def make_dataclass(cls_name, fields, *, bases=(), namespace=None, init=T...
  function replace (line 1234) | def replace(*args, **changes):

FILE: rd/usr/lib/python3.8/datetime.py
  function _cmp (line 11) | def _cmp(x, y):
  function _is_leap (line 37) | def _is_leap(year):
  function _days_before_year (line 41) | def _days_before_year(year):
  function _days_in_month (line 46) | def _days_in_month(year, month):
  function _days_before_month (line 53) | def _days_before_month(year, month):
  function _ymd2ord (line 58) | def _ymd2ord(year, month, day):
  function _ord2ymd (line 83) | def _ord2ymd(n):
  function _build_struct_time (line 151) | def _build_struct_time(y, m, d, hh, mm, ss, dstflag):
  function _format_time (line 156) | def _format_time(hh, mm, ss, us, timespec='auto'):
  function _format_offset (line 177) | def _format_offset(off):
  function _wrap_strftime (line 196) | def _wrap_strftime(object, format, timetuple):
  function _parse_isoformat_date (line 260) | def _parse_isoformat_date(dtstr):
  function _parse_hh_mm_ss_ff (line 276) | def _parse_hh_mm_ss_ff(tstr):
  function _parse_isoformat_time (line 315) | def _parse_isoformat_time(tstr):
  function _check_tzname (line 356) | def _check_tzname(name):
  function _check_utc_offset (line 367) | def _check_utc_offset(name, offset):
  function _check_int_field (line 379) | def _check_int_field(value):
  function _check_date_fields (line 411) | def _check_date_fields(year, month, day):
  function _check_time_fields (line 424) | def _check_time_fields(hour, minute, second, microsecond, fold):
  function _check_tzinfo_arg (line 441) | def _check_tzinfo_arg(tz):
  function _cmperror (line 445) | def _cmperror(x, y):
  function _divide_and_round (line 449) | def _divide_and_round(a, b):
  class timedelta (line 469) | class timedelta:
    method __new__ (line 488) | def __new__(cls, days=0, seconds=0, microseconds=0,
    method __repr__ (line 589) | def __repr__(self):
    method __str__ (line 603) | def __str__(self):
    method total_seconds (line 615) | def total_seconds(self):
    method days (line 622) | def days(self):
    method seconds (line 627) | def seconds(self):
    method microseconds (line 632) | def microseconds(self):
    method __add__ (line 636) | def __add__(self, other):
    method __sub__ (line 647) | def __sub__(self, other):
    method __rsub__ (line 656) | def __rsub__(self, other):
    method __neg__ (line 661) | def __neg__(self):
    method __pos__ (line 668) | def __pos__(self):
    method __abs__ (line 671) | def __abs__(self):
    method __mul__ (line 677) | def __mul__(self, other):
    method _to_microseconds (line 692) | def _to_microseconds(self):
    method __floordiv__ (line 696) | def __floordiv__(self, other):
    method __truediv__ (line 705) | def __truediv__(self, other):
    method __mod__ (line 717) | def __mod__(self, other):
    method __divmod__ (line 723) | def __divmod__(self, other):
    method __eq__ (line 732) | def __eq__(self, other):
    method __le__ (line 738) | def __le__(self, other):
    method __lt__ (line 744) | def __lt__(self, other):
    method __ge__ (line 750) | def __ge__(self, other):
    method __gt__ (line 756) | def __gt__(self, other):
    method _cmp (line 762) | def _cmp(self, other):
    method __hash__ (line 766) | def __hash__(self):
    method __bool__ (line 771) | def __bool__(self):
    method _getstate (line 778) | def _getstate(self):
    method __reduce__ (line 781) | def __reduce__(self):
  class date (line 789) | class date:
    method __new__ (line 819) | def __new__(cls, year, month=None, day=None):
    method fromtimestamp (line 854) | def fromtimestamp(cls, t):
    method today (line 860) | def today(cls):
    method fromordinal (line 866) | def fromordinal(cls, n):
    method fromisoformat (line 876) | def fromisoformat(cls, date_string):
    method fromisocalendar (line 888) | def fromisocalendar(cls, year, week, day):
    method __repr__ (line 924) | def __repr__(self):
    method ctime (line 946) | def ctime(self):
    method strftime (line 954) | def strftime(self, fmt):
    method __format__ (line 958) | def __format__(self, fmt):
    method isoformat (line 965) | def isoformat(self):
    method year (line 980) | def year(self):
    method month (line 985) | def month(self):
    method day (line 990) | def day(self):
    method timetuple (line 997) | def timetuple(self):
    method toordinal (line 1002) | def toordinal(self):
    method replace (line 1010) | def replace(self, year=None, month=None, day=None):
    method __eq__ (line 1022) | def __eq__(self, other):
    method __le__ (line 1027) | def __le__(self, other):
    method __lt__ (line 1032) | def __lt__(self, other):
    method __ge__ (line 1037) | def __ge__(self, other):
    method __gt__ (line 1042) | def __gt__(self, other):
    method _cmp (line 1047) | def _cmp(self, other):
    method __hash__ (line 1053) | def __hash__(self):
    method __add__ (line 1061) | def __add__(self, other):
    method __sub__ (line 1072) | def __sub__(self, other):
    method weekday (line 1082) | def weekday(self):
    method isoweekday (line 1088) | def isoweekday(self):
    method isocalendar (line 1093) | def isocalendar(self):
    method _getstate (line 1123) | def _getstate(self):
    method __setstate (line 1127) | def __setstate(self, string):
    method __reduce__ (line 1131) | def __reduce__(self):
  class tzinfo (line 1141) | class tzinfo:
    method tzname (line 1148) | def tzname(self, dt):
    method utcoffset (line 1152) | def utcoffset(self, dt):
    method dst (line 1156) | def dst(self, dt):
    method fromutc (line 1164) | def fromutc(self, dt):
    method __reduce__ (line 1193) | def __reduce__(self):
  class time (line 1211) | class time:
    method __new__ (line 1236) | def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=Non...
    method hour (line 1277) | def hour(self):
    method minute (line 1282) | def minute(self):
    method second (line 1287) | def second(self):
    method microsecond (line 1292) | def microsecond(self):
    method tzinfo (line 1297) | def tzinfo(self):
    method fold (line 1302) | def fold(self):
    method __eq__ (line 1309) | def __eq__(self, other):
    method __le__ (line 1315) | def __le__(self, other):
    method __lt__ (line 1321) | def __lt__(self, other):
    method __ge__ (line 1327) | def __ge__(self, other):
    method __gt__ (line 1333) | def __gt__(self, other):
    method _cmp (line 1339) | def _cmp(self, other, allow_mixed=False):
    method __hash__ (line 1367) | def __hash__(self):
    method _tzstr (line 1390) | def _tzstr(self):
    method __repr__ (line 1395) | def __repr__(self):
    method isoformat (line 1414) | def isoformat(self, timespec='auto'):
    method fromisoformat (line 1433) | def fromisoformat(cls, time_string):
    method strftime (line 1444) | def strftime(self, fmt):
    method __format__ (line 1455) | def __format__(self, fmt):
    method utcoffset (line 1464) | def utcoffset(self):
    method tzname (line 1473) | def tzname(self):
    method dst (line 1486) | def dst(self):
    method replace (line 1501) | def replace(self, hour=None, minute=None, second=None, microsecond=None,
    method _getstate (line 1520) | def _getstate(self, protocol=3):
    method __setstate (line 1533) | def __setstate(self, string, tzinfo):
    method __reduce_ex__ (line 1546) | def __reduce_ex__(self, protocol):
    method __reduce__ (line 1549) | def __reduce__(self):
  class datetime (line 1558) | class datetime(date):
    method __new__ (line 1566) | def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
    method hour (line 1603) | def hour(self):
    method minute (line 1608) | def minute(self):
    method second (line 1613) | def second(self):
    method microsecond (line 1618) | def microsecond(self):
    method tzinfo (line 1623) | def tzinfo(self):
    method fold (line 1628) | def fold(self):
    method _fromtimestamp (line 1632) | def _fromtimestamp(cls, t, utc, tz):
    method fromtimestamp (line 1676) | def fromtimestamp(cls, t, tz=None):
    method utcfromtimestamp (line 1686) | def utcfromtimestamp(cls, t):
    method now (line 1691) | def now(cls, tz=None):
    method utcnow (line 1697) | def utcnow(cls):
    method combine (line 1703) | def combine(cls, date, time, tzinfo=True):
    method fromisoformat (line 1716) | def fromisoformat(cls, date_string):
    method timetuple (line 1740) | def timetuple(self):
    method _mktime (line 1753) | def _mktime(self):
    method timestamp (line 1788) | def timestamp(self):
    method utctimetuple (line 1796) | def utctimetuple(self):
    method date (line 1805) | def date(self):
    method time (line 1809) | def time(self):
    method timetz (line 1813) | def timetz(self):
    method replace (line 1818) | def replace(self, year=None, month=None, day=None, hour=None,
    method _local_timezone (line 1843) | def _local_timezone(self):
    method astimezone (line 1855) | def astimezone(self, tz=None):
    method ctime (line 1882) | def ctime(self):
    method isoformat (line 1892) | def isoformat(self, sep='T', timespec='auto'):
    method __repr__ (line 1918) | def __repr__(self):
    method __str__ (line 1937) | def __str__(self):
    method strptime (line 1942) | def strptime(cls, date_string, format):
    method utcoffset (line 1947) | def utcoffset(self):
    method tzname (line 1956) | def tzname(self):
    method dst (line 1969) | def dst(self):
    method __eq__ (line 1986) | def __eq__(self, other):
    method __le__ (line 1994) | def __le__(self, other):
    method __lt__ (line 2002) | def __lt__(self, other):
    method __ge__ (line 2010) | def __ge__(self, other):
    method __gt__ (line 2018) | def __gt__(self, other):
    method _cmp (line 2026) | def _cmp(self, other, allow_mixed=False):
    method __add__ (line 2063) | def __add__(self, other):
    method __sub__ (line 2084) | def __sub__(self, other):
    method __hash__ (line 2108) | def __hash__(self):
    method _getstate (line 2125) | def _getstate(self, protocol=3):
    method __setstate (line 2140) | def __setstate(self, string, tzinfo):
    method __reduce_ex__ (line 2155) | def __reduce_ex__(self, protocol):
    method __reduce__ (line 2158) | def __reduce__(self):
  function _isoweek1monday (line 2167) | def _isoweek1monday(year):
  class timezone (line 2179) | class timezone(tzinfo):
    method __new__ (line 2184) | def __new__(cls, offset, name=_Omitted):
    method _create (line 2200) | def _create(cls, offset, name=None):
    method __getinitargs__ (line 2206) | def __getinitargs__(self):
    method __eq__ (line 2212) | def __eq__(self, other):
    method __hash__ (line 2217) | def __hash__(self):
    method __repr__ (line 2220) | def __repr__(self):
    method __str__ (line 2240) | def __str__(self):
    method utcoffset (line 2243) | def utcoffset(self, dt):
    method tzname (line 2249) | def tzname(self, dt):
    method dst (line 2257) | def dst(self, dt):
    method fromutc (line 2263) | def fromutc(self, dt):
    method _name_from_offset (line 2276) | def _name_from_offset(delta):

FILE: rd/usr/lib/python3.8/dbm/__init__.py
  class error (line 38) | class error(Exception):
  function open (line 53) | def open(file, flag='r', mode=0o666):
  function whichdb (line 98) | def whichdb(filename):

FILE: rd/usr/lib/python3.8/dbm/dumb.py
  class _Database (line 35) | class _Database(collections.abc.MutableMapping):
    method __init__ (line 48) | def __init__(self, filebasename, mode, flag='c'):
    method _create (line 73) | def _create(self, flag):
    method _update (line 92) | def _update(self, flag):
    method _commit (line 112) | def _commit(self):
    method _verify_open (line 139) | def _verify_open(self):
    method __getitem__ (line 143) | def __getitem__(self, key):
    method _addval (line 157) | def _addval(self, val):
    method _setval (line 171) | def _setval(self, pos, val):
    method _addkey (line 180) | def _addkey(self, key, pos_and_siz_pair):
    method __setitem__ (line 186) | def __setitem__(self, key, val):
    method __delitem__ (line 223) | def __delitem__(self, key):
    method keys (line 238) | def keys(self):
    method items (line 244) | def items(self):
    method __contains__ (line 248) | def __contains__(self, key):
    method iterkeys (line 259) | def iterkeys(self):
    method __len__ (line 266) | def __len__(self):
    method close (line 272) | def close(self):
    method _chmod (line 280) | def _chmod(self, file):
    method __enter__ (line 283) | def __enter__(self):
    method __exit__ (line 286) | def __exit__(self, *args):
  function open (line 290) | def open(file, flag='c', mode=0o666):

FILE: rd/usr/lib/python3.8/dis.py
  function _try_compile (line 30) | def _try_compile(source, name):
  function dis (line 43) | def dis(x=None, *, file=None, depth=None):
  function distb (line 88) | def distb(tb=None, *, file=None):
  function pretty_flags (line 114) | def pretty_flags(flags):
  function _get_code_object (line 128) | def _get_code_object(x):
  function code_info (line 151) | def code_info(x):
  function _format_code_info (line 155) | def _format_code_info(co):
  function show_code (line 187) | def show_code(co, *, file=None):
  class Instruction (line 209) | class Instruction(_Instruction):
    method _disassemble (line 223) | def _disassemble(self, lineno_width=3, mark_as_current=False, offset_w...
  function get_instructions (line 261) | def get_instructions(x, *, first_line=None):
  function _get_const_info (line 283) | def _get_const_info(const_index, const_list):
  function _get_name_info (line 295) | def _get_name_info(name_index, name_list):
  function _get_instructions_bytes (line 311) | def _get_instructions_bytes(code, varnames=None, names=None, constants=N...
  function disassemble (line 365) | def disassemble(co, lasti=-1, *, file=None):
  function _disassemble_recursive (line 372) | def _disassemble_recursive(co, *, file=None, depth=None):
  function _disassemble_bytes (line 383) | def _disassemble_bytes(code, lasti=-1, varnames=None, names=None,
  function _disassemble_str (line 413) | def _disassemble_str(source, **kwargs):
  function _unpack_opargs (line 419) | def _unpack_opargs(code):
  function findlabels (line 430) | def findlabels(code):
  function findlinestarts (line 449) | def findlinestarts(code):
  class Bytecode (line 479) | class Bytecode:
    method __init__ (line 487) | def __init__(self, x, *, first_line=None, current_offset=None):
    method __iter__ (line 500) | def __iter__(self):
    method __repr__ (line 507) | def __repr__(self):
    method from_traceback (line 512) | def from_traceback(cls, tb):
    method info (line 518) | def info(self):
    method dis (line 522) | def dis(self):
  function _test (line 540) | def _test():

FILE: rd/usr/lib/python3.8/encodings/__init__.py
  class CodecRegistryError (line 40) | class CodecRegistryError(LookupError, SystemError):
  function normalize_encoding (line 43) | def normalize_encoding(encoding):
  function search_function (line 70) | def search_function(encoding):
  function _alias_mbcs (line 158) | def _alias_mbcs(encoding):

FILE: rd/usr/lib/python3.8/encodings/ascii.py
  class Codec (line 13) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 20) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 21) | def encode(self, input, final=False):
  class IncrementalDecoder (line 24) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 25) | def decode(self, input, final=False):
  class StreamWriter (line 28) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 31) | class StreamReader(Codec,codecs.StreamReader):
  class StreamConverter (line 34) | class StreamConverter(StreamWriter,StreamReader):
  function getregentry (line 41) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/base64_codec.py
  function base64_encode (line 13) | def base64_encode(input, errors='strict'):
  function base64_decode (line 17) | def base64_decode(input, errors='strict'):
  class Codec (line 21) | class Codec(codecs.Codec):
    method encode (line 22) | def encode(self, input, errors='strict'):
    method decode (line 24) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 27) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 28) | def encode(self, input, final=False):
  class IncrementalDecoder (line 32) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 33) | def decode(self, input, final=False):
  class StreamWriter (line 37) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 40) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 45) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/big5.py
  class Codec (line 12) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 16) | class IncrementalEncoder(mbc.MultibyteIncrementalEncoder,
  class IncrementalDecoder (line 20) | class IncrementalDecoder(mbc.MultibyteIncrementalDecoder,
  class StreamReader (line 24) | class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):
  class StreamWriter (line 27) | class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
  function getregentry (line 30) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/bz2_codec.py
  function bz2_encode (line 15) | def bz2_encode(input, errors='strict'):
  function bz2_decode (line 19) | def bz2_decode(input, errors='strict'):
  class Codec (line 23) | class Codec(codecs.Codec):
    method encode (line 24) | def encode(self, input, errors='strict'):
    method decode (line 26) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 29) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 30) | def __init__(self, errors='strict'):
    method encode (line 35) | def encode(self, input, final=False):
    method reset (line 42) | def reset(self):
  class IncrementalDecoder (line 45) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method __init__ (line 46) | def __init__(self, errors='strict'):
    method decode (line 51) | def decode(self, input, final=False):
    method reset (line 57) | def reset(self):
  class StreamWriter (line 60) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 63) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 68) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/charmap.py
  class Codec (line 17) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 24) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 25) | def __init__(self, errors='strict', mapping=None):
    method encode (line 29) | def encode(self, input, final=False):
  class IncrementalDecoder (line 32) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method __init__ (line 33) | def __init__(self, errors='strict', mapping=None):
    method decode (line 37) | def decode(self, input, final=False):
  class StreamWriter (line 40) | class StreamWriter(Codec,codecs.StreamWriter):
    method __init__ (line 42) | def __init__(self,stream,errors='strict',mapping=None):
    method encode (line 46) | def encode(self,input,errors='strict'):
  class StreamReader (line 49) | class StreamReader(Codec,codecs.StreamReader):
    method __init__ (line 51) | def __init__(self,stream,errors='strict',mapping=None):
    method decode (line 55) | def decode(self,input,errors='strict'):
  function getregentry (line 60) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/gbk.py
  class Codec (line 12) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 16) | class IncrementalEncoder(mbc.MultibyteIncrementalEncoder,
  class IncrementalDecoder (line 20) | class IncrementalDecoder(mbc.MultibyteIncrementalDecoder,
  class StreamReader (line 24) | class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):
  class StreamWriter (line 27) | class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
  function getregentry (line 30) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/hex_codec.py
  function hex_encode (line 13) | def hex_encode(input, errors='strict'):
  function hex_decode (line 17) | def hex_decode(input, errors='strict'):
  class Codec (line 21) | class Codec(codecs.Codec):
    method encode (line 22) | def encode(self, input, errors='strict'):
    method decode (line 24) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 27) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 28) | def encode(self, input, final=False):
  class IncrementalDecoder (line 32) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 33) | def decode(self, input, final=False):
  class StreamWriter (line 37) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 40) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 45) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/hz.py
  class Codec (line 12) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 16) | class IncrementalEncoder(mbc.MultibyteIncrementalEncoder,
  class IncrementalDecoder (line 20) | class IncrementalDecoder(mbc.MultibyteIncrementalDecoder,
  class StreamReader (line 24) | class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):
  class StreamWriter (line 27) | class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
  function getregentry (line 30) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/idna.py
  function nameprep (line 14) | def nameprep(label):
  function ToASCII (line 62) | def ToASCII(label):
  function ToUnicode (line 105) | def ToUnicode(label):
  class Codec (line 146) | class Codec(codecs.Codec):
    method encode (line 147) | def encode(self, input, errors='strict'):
    method decode (line 184) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 218) | class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
    method _buffer_encode (line 219) | def _buffer_encode(self, input, errors, final):
  class IncrementalDecoder (line 253) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
    method _buffer_decode (line 254) | def _buffer_decode(self, input, errors, final):
  class StreamWriter (line 292) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 295) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 300) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/iso8859_1.py
  class Codec (line 9) | class Codec(codecs.Codec):
    method encode (line 11) | def encode(self,input,errors='strict'):
    method decode (line 14) | def decode(self,input,errors='strict'):
  class IncrementalEncoder (line 17) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 18) | def encode(self, input, final=False):
  class IncrementalDecoder (line 21) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 22) | def decode(self, input, final=False):
  class StreamWriter (line 25) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 28) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 33) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/latin_1.py
  class Codec (line 13) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 20) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 21) | def encode(self, input, final=False):
  class IncrementalDecoder (line 24) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 25) | def decode(self, input, final=False):
  class StreamWriter (line 28) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 31) | class StreamReader(Codec,codecs.StreamReader):
  class StreamConverter (line 34) | class StreamConverter(StreamWriter,StreamReader):
  function getregentry (line 41) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/mbcs.py
  function decode (line 20) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 23) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 24) | def encode(self, input, final=False):
  class IncrementalDecoder (line 27) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 30) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 33) | class StreamReader(codecs.StreamReader):
  function getregentry (line 38) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/oem.py
  function decode (line 14) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 17) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 18) | def encode(self, input, final=False):
  class IncrementalDecoder (line 21) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 24) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 27) | class StreamReader(codecs.StreamReader):
  function getregentry (line 32) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/quopri_codec.py
  function quopri_encode (line 10) | def quopri_encode(input, errors='strict'):
  function quopri_decode (line 17) | def quopri_decode(input, errors='strict'):
  class Codec (line 24) | class Codec(codecs.Codec):
    method encode (line 25) | def encode(self, input, errors='strict'):
    method decode (line 27) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 30) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 31) | def encode(self, input, final=False):
  class IncrementalDecoder (line 34) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 35) | def decode(self, input, final=False):
  class StreamWriter (line 38) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 41) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 46) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/raw_unicode_escape.py
  class Codec (line 13) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 20) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 21) | def encode(self, input, final=False):
  class IncrementalDecoder (line 24) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 25) | def decode(self, input, final=False):
  class StreamWriter (line 28) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 31) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 36) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/rot_13.py
  class Codec (line 13) | class Codec(codecs.Codec):
    method encode (line 14) | def encode(self, input, errors='strict'):
    method decode (line 17) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 20) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 21) | def encode(self, input, final=False):
  class IncrementalDecoder (line 24) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 25) | def decode(self, input, final=False):
  class StreamWriter (line 28) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 31) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 36) | def getregentry():
  function rot13 (line 108) | def rot13(infile, outfile):

FILE: rd/usr/lib/python3.8/encodings/undefined.py
  class Codec (line 16) | class Codec(codecs.Codec):
    method encode (line 18) | def encode(self,input,errors='strict'):
    method decode (line 21) | def decode(self,input,errors='strict'):
  class IncrementalEncoder (line 24) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 25) | def encode(self, input, final=False):
  class IncrementalDecoder (line 28) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 29) | def decode(self, input, final=False):
  class StreamWriter (line 32) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 35) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 40) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/unicode_escape.py
  class Codec (line 13) | class Codec(codecs.Codec):
  class IncrementalEncoder (line 20) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 21) | def encode(self, input, final=False):
  class IncrementalDecoder (line 24) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 25) | def decode(self, input, final=False):
  class StreamWriter (line 28) | class StreamWriter(Codec,codecs.StreamWriter):
  class StreamReader (line 31) | class StreamReader(Codec,codecs.StreamReader):
  function getregentry (line 36) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_16.py
  function decode (line 15) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 18) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 19) | def __init__(self, errors='strict'):
    method encode (line 23) | def encode(self, input, final=False):
    method reset (line 33) | def reset(self):
    method getstate (line 37) | def getstate(self):
    method setstate (line 44) | def setstate(self, state):
  class IncrementalDecoder (line 53) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
    method __init__ (line 54) | def __init__(self, errors='strict'):
    method _buffer_decode (line 58) | def _buffer_decode(self, input, errors, final):
    method reset (line 71) | def reset(self):
    method getstate (line 75) | def getstate(self):
    method setstate (line 89) | def setstate(self, state):
  class StreamWriter (line 104) | class StreamWriter(codecs.StreamWriter):
    method __init__ (line 105) | def __init__(self, stream, errors='strict'):
    method reset (line 109) | def reset(self):
    method encode (line 113) | def encode(self, input, errors='strict'):
  class StreamReader (line 124) | class StreamReader(codecs.StreamReader):
    method reset (line 126) | def reset(self):
    method decode (line 133) | def decode(self, input, errors='strict'):
  function getregentry (line 146) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_16_be.py
  function decode (line 15) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 18) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 19) | def encode(self, input, final=False):
  class IncrementalDecoder (line 22) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 25) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 28) | class StreamReader(codecs.StreamReader):
  function getregentry (line 33) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_16_le.py
  function decode (line 15) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 18) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 19) | def encode(self, input, final=False):
  class IncrementalDecoder (line 22) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 25) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 28) | class StreamReader(codecs.StreamReader):
  function getregentry (line 33) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_32.py
  function decode (line 10) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 13) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 14) | def __init__(self, errors='strict'):
    method encode (line 18) | def encode(self, input, final=False):
    method reset (line 28) | def reset(self):
    method getstate (line 32) | def getstate(self):
    method setstate (line 39) | def setstate(self, state):
  class IncrementalDecoder (line 48) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
    method __init__ (line 49) | def __init__(self, errors='strict'):
    method _buffer_decode (line 53) | def _buffer_decode(self, input, errors, final):
    method reset (line 66) | def reset(self):
    method getstate (line 70) | def getstate(self):
    method setstate (line 84) | def setstate(self, state):
  class StreamWriter (line 99) | class StreamWriter(codecs.StreamWriter):
    method __init__ (line 100) | def __init__(self, stream, errors='strict'):
    method reset (line 104) | def reset(self):
    method encode (line 108) | def encode(self, input, errors='strict'):
  class StreamReader (line 119) | class StreamReader(codecs.StreamReader):
    method reset (line 121) | def reset(self):
    method decode (line 128) | def decode(self, input, errors='strict'):
  function getregentry (line 141) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_32_be.py
  function decode (line 10) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 13) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 14) | def encode(self, input, final=False):
  class IncrementalDecoder (line 17) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 20) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 23) | class StreamReader(codecs.StreamReader):
  function getregentry (line 28) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_32_le.py
  function decode (line 10) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 13) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 14) | def encode(self, input, final=False):
  class IncrementalDecoder (line 17) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 20) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 23) | class StreamReader(codecs.StreamReader):
  function getregentry (line 28) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_7.py
  function decode (line 11) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 14) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 15) | def encode(self, input, final=False):
  class IncrementalDecoder (line 18) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 21) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 24) | class StreamReader(codecs.StreamReader):
  function getregentry (line 29) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_8.py
  function decode (line 15) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 18) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 19) | def encode(self, input, final=False):
  class IncrementalDecoder (line 22) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
  class StreamWriter (line 25) | class StreamWriter(codecs.StreamWriter):
  class StreamReader (line 28) | class StreamReader(codecs.StreamReader):
  function getregentry (line 33) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/utf_8_sig.py
  function encode (line 14) | def encode(input, errors='strict'):
  function decode (line 18) | def decode(input, errors='strict'):
  class IncrementalEncoder (line 26) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 27) | def __init__(self, errors='strict'):
    method encode (line 31) | def encode(self, input, final=False):
    method reset (line 39) | def reset(self):
    method getstate (line 43) | def getstate(self):
    method setstate (line 46) | def setstate(self, state):
  class IncrementalDecoder (line 49) | class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
    method __init__ (line 50) | def __init__(self, errors='strict'):
    method _buffer_decode (line 54) | def _buffer_decode(self, input, errors, final):
    method reset (line 71) | def reset(self):
    method getstate (line 75) | def getstate(self):
    method setstate (line 80) | def setstate(self, state):
  class StreamWriter (line 85) | class StreamWriter(codecs.StreamWriter):
    method reset (line 86) | def reset(self):
    method encode (line 93) | def encode(self, input, errors='strict'):
  class StreamReader (line 97) | class StreamReader(codecs.StreamReader):
    method reset (line 98) | def reset(self):
    method decode (line 105) | def decode(self, input, errors='strict'):
  function getregentry (line 121) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/uu_codec.py
  function uu_encode (line 16) | def uu_encode(input, errors='strict', filename='<data>', mode=0o666):
  function uu_decode (line 37) | def uu_decode(input, errors='strict'):
  class Codec (line 70) | class Codec(codecs.Codec):
    method encode (line 71) | def encode(self, input, errors='strict'):
    method decode (line 74) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 77) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method encode (line 78) | def encode(self, input, final=False):
  class IncrementalDecoder (line 81) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method decode (line 82) | def decode(self, input, final=False):
  class StreamWriter (line 85) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 88) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 93) | def getregentry():

FILE: rd/usr/lib/python3.8/encodings/zlib_codec.py
  function zlib_encode (line 13) | def zlib_encode(input, errors='strict'):
  function zlib_decode (line 17) | def zlib_decode(input, errors='strict'):
  class Codec (line 21) | class Codec(codecs.Codec):
    method encode (line 22) | def encode(self, input, errors='strict'):
    method decode (line 24) | def decode(self, input, errors='strict'):
  class IncrementalEncoder (line 27) | class IncrementalEncoder(codecs.IncrementalEncoder):
    method __init__ (line 28) | def __init__(self, errors='strict'):
    method encode (line 33) | def encode(self, input, final=False):
    method reset (line 40) | def reset(self):
  class IncrementalDecoder (line 43) | class IncrementalDecoder(codecs.IncrementalDecoder):
    method __init__ (line 44) | def __init__(self, errors='strict'):
    method decode (line 49) | def decode(self, input, final=False):
    method reset (line 56) | def reset(self):
  class StreamWriter (line 59) | class StreamWriter(Codec, codecs.StreamWriter):
  class StreamReader (line 62) | class StreamReader(Codec, codecs.StreamReader):
  function getregentry (line 67) | def getregentry():

FILE: rd/usr/lib/python3.8/enum.py
  function _is_descriptor (line 12) | def _is_descriptor(obj):
  function _is_dunder (line 20) | def _is_dunder(name):
  function _is_sunder (line 28) | def _is_sunder(name):
  function _make_class_unpicklable (line 36) | def _make_class_unpicklable(cls):
  class auto (line 44) | class auto:
  class _EnumDict (line 51) | class _EnumDict(dict):
    method __init__ (line 58) | def __init__(self):
    method __setitem__ (line 65) | def __setitem__(self, key, value):
  class EnumMeta (line 122) | class EnumMeta(type):
    method __prepare__ (line 125) | def __prepare__(metacls, cls, bases):
    method __new__ (line 134) | def __new__(metacls, cls, bases, classdict):
    method __bool__ (line 277) | def __bool__(self):
    method __call__ (line 283) | def __call__(cls, value, names=None, *, module=None, qualname=None, ty...
    method __contains__ (line 313) | def __contains__(cls, member):
    method __delattr__ (line 320) | def __delattr__(cls, attr):
    method __dir__ (line 328) | def __dir__(self):
    method __getattr__ (line 332) | def __getattr__(cls, name):
    method __getitem__ (line 348) | def __getitem__(cls, name):
    method __iter__ (line 351) | def __iter__(cls):
    method __len__ (line 354) | def __len__(cls):
    method __members__ (line 358) | def __members__(cls):
    method __repr__ (line 367) | def __repr__(cls):
    method __reversed__ (line 370) | def __reversed__(cls):
    method __setattr__ (line 373) | def __setattr__(cls, name, value):
    method _create_ (line 386) | def _create_(cls, class_name, names, *, module=None, qualname=None, ty...
    method _convert_ (line 439) | def _convert_(cls, name, module, filter, source=None):
    method _convert (line 472) | def _convert(cls, *args, **kwargs):
    method _get_mixins_ (line 479) | def _get_mixins_(bases):
    method _find_new_ (line 511) | def _find_new_(classdict, member_type, first_enum):
  class Enum (line 556) | class Enum(metaclass=EnumMeta):
    method __new__ (line 562) | def __new__(cls, value):
    method _generate_next_value_ (line 602) | def _generate_next_value_(name, start, count, last_values):
    method _missing_ (line 612) | def _missing_(cls, value):
    method __repr__ (line 615) | def __repr__(self):
    method __str__ (line 619) | def __str__(self):
    method __dir__ (line 622) | def __dir__(self):
    method __format__ (line 631) | def __format__(self, format_spec):
    method __hash__ (line 646) | def __hash__(self):
    method __reduce_ex__ (line 649) | def __reduce_ex__(self, proto):
    method name (line 660) | def name(self):
    method value (line 665) | def value(self):
  class IntEnum (line 670) | class IntEnum(int, Enum):
  function _reduce_ex_by_name (line 674) | def _reduce_ex_by_name(self, proto):
  class Flag (line 677) | class Flag(Enum):
    method _generate_next_value_ (line 680) | def _generate_next_value_(name, start, count, last_values):
    method _missing_ (line 700) | def _missing_(cls, value):
    method _create_pseudo_member_ (line 710) | def _create_pseudo_member_(cls, value):
    method __contains__ (line 729) | def __contains__(self, other):
    method __repr__ (line 736) | def __repr__(self):
    method __str__ (line 747) | def __str__(self):
    method __bool__ (line 760) | def __bool__(self):
    method __or__ (line 763) | def __or__(self, other):
    method __and__ (line 768) | def __and__(self, other):
    method __xor__ (line 773) | def __xor__(self, other):
    method __invert__ (line 778) | def __invert__(self):
  class IntFlag (line 787) | class IntFlag(int, Flag):
    method _missing_ (line 791) | def _missing_(cls, value):
    method _create_pseudo_member_ (line 798) | def _create_pseudo_member_(cls, value):
    method __or__ (line 827) | def __or__(self, other):
    method __and__ (line 833) | def __and__(self, other):
    method __xor__ (line 838) | def __xor__(self, other):
    method __invert__ (line 847) | def __invert__(self):
  function _high_bit (line 852) | def _high_bit(value):
  function unique (line 856) | def unique(enumeration):
  function _decompose (line 869) | def _decompose(flag, value):
  function _power_of_two (line 904) | def _power_of_two(value):

FILE: rd/usr/lib/python3.8/filecmp.py
  function clear_cache (line 25) | def clear_cache():
  function cmp (line 29) | def cmp(f1, f2, shallow=True):
  function _sig (line 68) | def _sig(st):
  function _do_cmp (line 73) | def _do_cmp(f1, f2):
  class dircmp (line 86) | class dircmp:
    method __init__ (line 120) | def __init__(self, a, b, ignore=None, hide=None): # Initialize
    method phase0 (line 132) | def phase0(self): # Compare everything except common subdirectories
    method phase1 (line 140) | def phase1(self): # Compute common names
    method phase2 (line 147) | def phase2(self): # Distinguish files, directories, funnies
    method phase3 (line 182) | def phase3(self): # Find out differences between common files
    method phase4 (line 186) | def phase4(self): # Find out differences between common subdirectories
    method phase4_closure (line 196) | def phase4_closure(self): # Recursively call phase4() on subdirectories
    method report (line 201) | def report(self): # Print a report on the differences between a and b
    method report_partial_closure (line 226) | def report_partial_closure(self): # Print reports on self and on subdirs
    method report_full_closure (line 232) | def report_full_closure(self): # Report on self and subdirs recursively
    method __getattr__ (line 244) | def __getattr__(self, attr):
  function cmpfiles (line 250) | def cmpfiles(a, b, common, shallow=True):
  function _cmp (line 277) | def _cmp(a, b, sh, abs=abs, cmp=cmp):
  function _filter (line 286) | def _filter(flist, skip):
  function demo (line 292) | def demo():

FILE: rd/usr/lib/python3.8/fileinput.py
  function input (line 83) | def input(files=None, inplace=False, backup="", *, mode="r", openhook=No...
  function close (line 96) | def close():
  function nextfile (line 104) | def nextfile():
  function filename (line 118) | def filename():
  function lineno (line 127) | def lineno():
  function filelineno (line 137) | def filelineno():
  function fileno (line 147) | def fileno():
  function isfirstline (line 156) | def isfirstline():
  function isstdin (line 165) | def isstdin():
  class FileInput (line 174) | class FileInput:
    method __init__ (line 187) | def __init__(self, files=None, inplace=False, backup="", *,
    method __del__ (line 228) | def __del__(self):
    method close (line 231) | def close(self):
    method __enter__ (line 237) | def __enter__(self):
    method __exit__ (line 240) | def __exit__(self, type, value, traceback):
    method __iter__ (line 243) | def __iter__(self):
    method __next__ (line 246) | def __next__(self):
    method __getitem__ (line 257) | def __getitem__(self, i):
    method nextfile (line 272) | def nextfile(self):
    method readline (line 302) | def readline(self):
    method _readline (line 313) | def _readline(self):
    method filename (line 370) | def filename(self):
    method lineno (line 373) | def lineno(self):
    method filelineno (line 376) | def filelineno(self):
    method fileno (line 379) | def fileno(self):
    method isfirstline (line 388) | def isfirstline(self):
    method isstdin (line 391) | def isstdin(self):
  function hook_compressed (line 395) | def hook_compressed(filename, mode):
  function hook_encoded (line 407) | def hook_encoded(encoding, errors=None):
  function _test (line 413) | def _test():

FILE: rd/usr/lib/python3.8/fnmatch.py
  function fnmatch (line 19) | def fnmatch(name, pat):
  function _compile_pattern (line 39) | def _compile_pattern(pat):
  function filter (line 48) | def filter(names, pat):
  function fnmatchcase (line 64) | def fnmatchcase(name, pat):
  function translate (line 74) | def translate(pat):

FILE: rd/usr/lib/python3.8/formatter.py
  class NullFormatter (line 30) | class NullFormatter:
    method __init__ (line 41) | def __init__(self, writer=None):
    method end_paragraph (line 45) | def end_paragraph(self, blankline): pass
    method add_line_break (line 46) | def add_line_break(self): pass
    method add_hor_rule (line 47) | def add_hor_rule(self, *args, **kw): pass
    method add_label_data (line 48) | def add_label_data(self, format, counter, blankline=None): pass
    method add_flowing_data (line 49) | def add_flowing_data(self, data): pass
    method add_literal_data (line 50) | def add_literal_data(self, data): pass
    method flush_softspace (line 51) | def flush_softspace(self): pass
    method push_alignment (line 52) | def push_alignment(self, align): pass
    method pop_alignment (line 53) | def pop_alignment(self): pass
    method push_font (line 54) | def push_font(self, x): pass
    method pop_font (line 55) | def pop_font(self): pass
    method push_margin (line 56) | def push_margin(self, margin): pass
    method pop_margin (line 57) | def pop_margin(self): pass
    method set_spacing (line 58) | def set_spacing(self, spacing): pass
    method push_style (line 59) | def push_style(self, *styles): pass
    method pop_style (line 60) | def pop_style(self, n=1): pass
    method assert_line_data (line 61) | def assert_line_data(self, flag=1): pass
  class AbstractFormatter (line 64) | class AbstractFormatter:
    method __init__ (line 78) | def __init__(self, writer):
    method end_paragraph (line 93) | def end_paragraph(self, blankline):
    method add_line_break (line 104) | def add_line_break(self):
    method add_hor_rule (line 111) | def add_hor_rule(self, *args, **kw):
    method add_label_data (line 118) | def add_label_data(self, format, counter, blankline = None):
    method format_counter (line 130) | def format_counter(self, format, counter):
    method format_letter (line 145) | def format_letter(self, case, counter):
    method format_roman (line 156) | def format_roman(self, case, counter):
    method add_flowing_data (line 180) | def add_flowing_data(self, data):
    method add_literal_data (line 200) | def add_literal_data(self, data):
    method flush_softspace (line 209) | def flush_softspace(self):
    method push_alignment (line 216) | def push_alignment(self, align):
    method pop_alignment (line 224) | def pop_alignment(self):
    method push_font (line 234) | def push_font(self, font):
    method pop_font (line 250) | def pop_font(self):
    method push_margin (line 259) | def push_margin(self, margin):
    method pop_margin (line 266) | def pop_margin(self):
    method set_spacing (line 276) | def set_spacing(self, spacing):
    method push_style (line 280) | def push_style(self, *styles):
    method pop_style (line 289) | def pop_style(self, n=1):
    method assert_line_data (line 293) | def assert_line_data(self, flag=1):
  class NullWriter (line 298) | class NullWriter:
    method __init__ (line 306) | def __init__(self): pass
    method flush (line 307) | def flush(self): pass
    method new_alignment (line 308) | def new_alignment(self, align): pass
    method new_font (line 309) | def new_font(self, font): pass
    method new_margin (line 310) | def new_margin(self, margin, level): pass
    method new_spacing (line 311) | def new_spacing(self, spacing): pass
    method new_styles (line 312) | def new_styles(self, styles): pass
    method send_paragraph (line 313) | def send_paragraph(self, blankline): pass
    method send_line_break (line 314) | def send_line_break(self): pass
    method send_hor_rule (line 315) | def send_hor_rule(self, *args, **kw): pass
    method send_label_data (line 316) | def send_label_data(self, data): pass
    method send_flowing_data (line 317) | def send_flowing_data(self, data): pass
    method send_literal_data (line 318) | def send_literal_data(self, data): pass
  class AbstractWriter (line 321) | class AbstractWriter(NullWriter):
    method new_alignment (line 329) | def new_alignment(self, align):
    method new_font (line 332) | def new_font(self, font):
    method new_margin (line 335) | def new_margin(self, margin, level):
    method new_spacing (line 338) | def new_spacing(self, spacing):
    method new_styles (line 341) | def new_styles(self, styles):
    method send_paragraph (line 344) | def send_paragraph(self, blankline):
    method send_line_break (line 347) | def send_line_break(self):
    method send_hor_rule (line 350) | def send_hor_rule(self, *args, **kw):
    method send_label_data (line 353) | def send_label_data(self, data):
    method send_flowing_data (line 356) | def send_flowing_data(self, data):
    method send_literal_data (line 359) | def send_literal_data(self, data):
  class DumbWriter (line 363) | class DumbWriter(NullWriter):
    method __init__ (line 372) | def __init__(self, file=None, maxcol=72):
    method reset (line 378) | def reset(self):
    method send_paragraph (line 382) | def send_paragraph(self, blankline):
    method send_line_break (line 387) | def send_line_break(self):
    method send_hor_rule (line 392) | def send_hor_rule(self, *args, **kw):
    method send_literal_data (line 399) | def send_literal_data(self, data):
    method send_flowing_data (line 409) | def send_flowing_data(self, data):
  function test (line 430) | def test(file = None):

FILE: rd/usr/lib/python3.8/fractions.py
  function gcd (line 17) | def gcd(a, b):
  function _gcd (line 32) | def _gcd(a, b):
  class Fraction (line 60) | class Fraction(numbers.Rational):
    method __new__ (line 84) | def __new__(cls, numerator=0, denominator=None, *, _normalize=True):
    method from_float (line 194) | def from_float(cls, f):
    method from_decimal (line 208) | def from_decimal(cls, dec):
    method as_integer_ratio (line 219) | def as_integer_ratio(self):
    method limit_denominator (line 227) | def limit_denominator(self, max_denominator=1000000):
    method numerator (line 283) | def numerator(a):
    method denominator (line 287) | def denominator(a):
    method __repr__ (line 290) | def __repr__(self):
    method __str__ (line 295) | def __str__(self):
    method _operator_fallbacks (line 302) | def _operator_fallbacks(monomorphic_operator, fallback_operator):
    method _add (line 409) | def _add(a, b):
    method _sub (line 417) | def _sub(a, b):
    method _mul (line 425) | def _mul(a, b):
    method _div (line 431) | def _div(a, b):
    method _floordiv (line 438) | def _floordiv(a, b):
    method _divmod (line 444) | def _divmod(a, b):
    method _mod (line 452) | def _mod(a, b):
    method __pow__ (line 459) | def __pow__(a, b):
    method __rpow__ (line 489) | def __rpow__(b, a):
    method __pos__ (line 503) | def __pos__(a):
    method __neg__ (line 507) | def __neg__(a):
    method __abs__ (line 511) | def __abs__(a):
    method __trunc__ (line 515) | def __trunc__(a):
    method __floor__ (line 522) | def __floor__(a):
    method __ceil__ (line 526) | def __ceil__(a):
    method __round__ (line 531) | def __round__(self, ndigits=None):
    method __hash__ (line 556) | def __hash__(self):
    method __eq__ (line 578) | def __eq__(a, b):
    method _richcmp (line 599) | def _richcmp(self, other, op):
    method __lt__ (line 621) | def __lt__(a, b):
    method __gt__ (line 625) | def __gt__(a, b):
    method __le__ (line 629) | def __le__(a, b):
    method __ge__ (line 633) | def __ge__(a, b):
    method __bool__ (line 637) | def __bool__(a):
    method __reduce__ (line 645) | def __reduce__(self):
    method __copy__ (line 648) | def __copy__(self):
    method __deepcopy__ (line 653) | def __deepcopy__(self, memo):

FILE: rd/usr/lib/python3.8/ftplib.py
  class Error (line 57) | class Error(Exception): pass
  class error_reply (line 58) | class error_reply(Error): pass          # unexpected [123]xx reply
  class error_temp (line 59) | class error_temp(Error): pass           # 4xx errors
  class error_perm (line 60) | class error_perm(Error): pass           # 5xx errors
  class error_proto (line 61) | class error_proto(Error): pass          # response does not begin with [...
  class FTP (line 74) | class FTP:
    method __init__ (line 112) | def __init__(self, host='', user='', passwd='', acct='',
    method __enter__ (line 121) | def __enter__(self):
    method __exit__ (line 125) | def __exit__(self, *args):
    method connect (line 135) | def connect(self, host='', port=0, timeout=-999, source_address=None):
    method getwelcome (line 159) | def getwelcome(self):
    method set_debuglevel (line 166) | def set_debuglevel(self, level):
    method set_pasv (line 175) | def set_pasv(self, val):
    method sanitize (line 182) | def sanitize(self, s):
    method putline (line 189) | def putline(self, line):
    method putcmd (line 199) | def putcmd(self, line):
    method getline (line 205) | def getline(self):
    method getmultiline (line 223) | def getmultiline(self):
    method getresp (line 237) | def getresp(self):
    method voidresp (line 251) | def voidresp(self):
    method abort (line 258) | def abort(self):
    method sendcmd (line 272) | def sendcmd(self, cmd):
    method voidcmd (line 277) | def voidcmd(self, cmd):
    method sendport (line 282) | def sendport(self, host, port):
    method sendeprt (line 292) | def sendeprt(self, host, port):
    method makeport (line 305) | def makeport(self):
    method makepasv (line 318) | def makepasv(self):
    method ntransfercmd (line 325) | def ntransfercmd(self, cmd, rest=None):
    method transfercmd (line 380) | def transfercmd(self, cmd, rest=None):
    method login (line 384) | def login(self, user = '', passwd = '', acct = ''):
    method retrbinary (line 410) | def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
    method retrlines (line 436) | def retrlines(self, cmd, callback = None):
    method storbinary (line 471) | def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):
    method storlines (line 500) | def storlines(self, cmd, fp, callback=None):
    method acct (line 531) | def acct(self, password):
    method nlst (line 536) | def nlst(self, *args):
    method dir (line 545) | def dir(self, *args):
    method mlsd (line 560) | def mlsd(self, path="", facts=[]):
    method rename (line 588) | def rename(self, fromname, toname):
    method delete (line 595) | def delete(self, filename):
    method cwd (line 603) | def cwd(self, dirname):
    method size (line 616) | def size(self, filename):
    method mkd (line 624) | def mkd(self, dirname):
    method rmd (line 633) | def rmd(self, dirname):
    method pwd (line 637) | def pwd(self):
    method quit (line 646) | def quit(self):
    method close (line 652) | def close(self):
  class FTP_TLS (line 672) | class FTP_TLS(FTP):
    method __init__ (line 707) | def __init__(self, host='', user='', passwd='', acct='', keyfile=None,
    method login (line 730) | def login(self, user='', passwd='', acct='', secure=True):
    method auth (line 735) | def auth(self):
    method ccc (line 748) | def ccc(self):
    method prot_p (line 756) | def prot_p(self):
    method prot_c (line 772) | def prot_c(self):
    method ntransfercmd (line 780) | def ntransfercmd(self, cmd, rest=None):
    method abort (line 787) | def abort(self):
  function parse150 (line 802) | def parse150(resp):
  function parse227 (line 822) | def parse227(resp):
  function parse229 (line 842) | def parse229(resp, peer):
  function parse257 (line 864) | def parse257(resp):
  function print_line (line 887) | def print_line(line):
  function ftpcp (line 892) | def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  function test (line 914) | def test():

FILE: rd/usr/lib/python3.8/functools.py
  function update_wrapper (line 34) | def update_wrapper(wrapper,
  function wraps (line 64) | def wraps(wrapped,
  function _gt_from_lt (line 88) | def _gt_from_lt(self, other, NotImplemented=NotImplemented):
  function _le_from_lt (line 95) | def _le_from_lt(self, other, NotImplemented=NotImplemented):
  function _ge_from_lt (line 100) | def _ge_from_lt(self, other, NotImplemented=NotImplemented):
  function _ge_from_le (line 107) | def _ge_from_le(self, other, NotImplemented=NotImplemented):
  function _lt_from_le (line 114) | def _lt_from_le(self, other, NotImplemented=NotImplemented):
  function _gt_from_le (line 121) | def _gt_from_le(self, other, NotImplemented=NotImplemented):
  function _lt_from_gt (line 128) | def _lt_from_gt(self, other, NotImplemented=NotImplemented):
  function _ge_from_gt (line 135) | def _ge_from_gt(self, other, NotImplemented=NotImplemented):
  function _le_from_gt (line 140) | def _le_from_gt(self, other, NotImplemented=NotImplemented):
  function _le_from_ge (line 147) | def _le_from_ge(self, other, NotImplemented=NotImplemented):
  function _gt_from_ge (line 154) | def _gt_from_ge(self, other, NotImplemented=NotImplemented):
  function _lt_from_ge (line 161) | def _lt_from_ge(self, other, NotImplemented=NotImplemented):
  function total_ordering (line 183) | def total_ordering(cls):
  function cmp_to_key (line 201) | def cmp_to_key(mycmp):
  function reduce (line 232) | def reduce(function, sequence, initial=_initial_missing):
  class partial (line 270) | class partial:
    method __new__ (line 277) | def __new__(cls, func, /, *args, **keywords):
    method __call__ (line 293) | def __call__(self, /, *args, **keywords):
    method __repr__ (line 298) | def __repr__(self):
    method __reduce__ (line 307) | def __reduce__(self):
    method __setstate__ (line 311) | def __setstate__(self, state):
  class partialmethod (line 341) | class partialmethod(object):
    method __init__ (line 349) | def __init__(*args, **keywords):
    method __repr__ (line 385) | def __repr__(self):
    method _make_unbound_method (line 396) | def _make_unbound_method(self):
    method __get__ (line 404) | def __get__(self, obj, cls=None):
    method __isabstractmethod__ (line 424) | def __isabstractmethod__(self):
  function _unwrap_partial (line 429) | def _unwrap_partial(func):
  class _HashedSeq (line 440) | class _HashedSeq(list):
    method __init__ (line 449) | def __init__(self, tup, hash=hash):
    method __hash__ (line 453) | def __hash__(self):
  function _make_key (line 456) | def _make_key(args, kwds, typed,
  function lru_cache (line 487) | def lru_cache(maxsize=128, typed=False):
  function _lru_cache_wrapper (line 531) | def _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo):
  function _c3_merge (line 657) | def _c3_merge(sequences):
  function _c3_mro (line 684) | def _c3_mro(cls, abcs=None):
  function _compose_mro (line 729) | def _compose_mro(cls, types):
  function _find_impl (line 770) | def _find_impl(cls, registry):
  function singledispatch (line 796) | def singledispatch(func):
  class singledispatchmethod (line 888) | class singledispatchmethod:
    method __init__ (line 895) | def __init__(self, func):
    method register (line 902) | def register(self, cls, method=None):
    method __get__ (line 909) | def __get__(self, obj, cls=None):
    method __isabstractmethod__ (line 920) | def __isabstractmethod__(self):
  class cached_property (line 931) | class cached_property:
    method __init__ (line 932) | def __init__(self, func):
    method __set_name__ (line 938) | def __set_name__(self, owner, name):
    method __get__ (line 947) | def __get__(self, instance, owner=None):

FILE: rd/usr/lib/python3.8/genericpath.py
  function exists (line 16) | def exists(path):
  function isfile (line 27) | def isfile(path):
  function isdir (line 39) | def isdir(s):
  function getsize (line 48) | def getsize(filename):
  function getmtime (line 53) | def getmtime(filename):
  function getatime (line 58) | def getatime(filename):
  function getctime (line 63) | def getctime(filename):
  function commonprefix (line 69) | def commonprefix(m):
  function samestat (line 87) | def samestat(s1, s2):
  function samefile (line 94) | def samefile(f1, f2):
  function sameopenfile (line 107) | def sameopenfile(fp1, fp2):
  function _splitext (line 121) | def _splitext(p, sep, altsep, extsep):
  function _check_arg_types (line 144) | def _check_arg_types(funcname, *args):

FILE: rd/usr/lib/python3.8/getopt.py
  function _ (line 41) | def _(s): return s
  class GetoptError (line 43) | class GetoptError(Exception):
    method __init__ (line 46) | def __init__(self, msg, opt=''):
    method __str__ (line 51) | def __str__(self):
  function getopt (line 56) | def getopt(args, shortopts, longopts = []):
  function gnu_getopt (line 99) | def gnu_getopt(args, shortopts, longopts = []):
  function do_longs (line 149) | def do_longs(opts, opt, longopts, args):
  function long_has_args (line 171) | def long_has_args(opt, longopts):
  function do_shorts (line 192) | def do_shorts(opts, optstring, shortopts, args):
  function short_has_arg (line 207) | def short_has_arg(opt, shortopts):

FILE: rd/usr/lib/python3.8/getpass.py
  class GetPassWarning (line 26) | class GetPassWarning(UserWarning): pass
  function unix_getpass (line 29) | def unix_getpass(prompt='Password: ', stream=None):
  function win_getpass (line 97) | def win_getpass(prompt='Password: ', stream=None):
  function fallback_getpass (line 120) | def fallback_getpass(prompt='Password: ', stream=None):
  function _raw_input (line 129) | def _raw_input(prompt="", stream=None, input=None):
  function getuser (line 154) | def getuser():

FILE: rd/usr/lib/python3.8/gettext.py
  function _tokenize (line 87) | def _tokenize(plural):
  function _error (line 98) | def _error(value):
  function _parse (line 115) | def _parse(tokens, priority=-1):
  function _as_int (line 164) | def _as_int(n):
  function c2py (line 176) | def c2py(plural):
  function _expand_lang (line 212) | def _expand_lang(loc):
  class NullTranslations (line 254) | class NullTranslations:
    method __init__ (line 255) | def __init__(self, fp=None):
    method _parse (line 263) | def _parse(self, fp):
    method add_fallback (line 266) | def add_fallback(self, fallback):
    method gettext (line 272) | def gettext(self, message):
    method lgettext (line 277) | def lgettext(self, message):
    method ngettext (line 290) | def ngettext(self, msgid1, msgid2, n):
    method lngettext (line 298) | def lngettext(self, msgid1, msgid2, n):
    method pgettext (line 315) | def pgettext(self, context, message):
    method npgettext (line 320) | def npgettext(self, context, msgid1, msgid2, n):
    method info (line 328) | def info(self):
    method charset (line 331) | def charset(self):
    method output_charset (line 334) | def output_charset(self):
    method set_output_charset (line 340) | def set_output_charset(self, charset):
    method install (line 346) | def install(self, names=None):
  class GNUTranslations (line 356) | class GNUTranslations(NullTranslations):
    method _get_versions (line 368) | def _get_versions(self, version):
    method _parse (line 372) | def _parse(self, fp):
    method lgettext (line 461) | def lgettext(self, message):
    method lngettext (line 475) | def lngettext(self, msgid1, msgid2, n):
    method gettext (line 492) | def gettext(self, message):
    method ngettext (line 501) | def ngettext(self, msgid1, msgid2, n):
    method pgettext (line 513) | def pgettext(self, context, message):
    method npgettext (line 523) | def npgettext(self, context, msgid1, msgid2, n):
  function find (line 538) | def find(domain, localedir=None, languages=None, all=False):
  function translation (line 579) | def translation(domain, localedir=None, languages=None,
  function install (line 622) | def install(domain, localedir=None, codeset=_unspecified, names=None):
  function textdomain (line 636) | def textdomain(domain=None):
  function bindtextdomain (line 643) | def bindtextdomain(domain, localedir=None):
  function bind_textdomain_codeset (line 650) | def bind_textdomain_codeset(domain, codeset=None):
  function dgettext (line 660) | def dgettext(domain, message):
  function ldgettext (line 667) | def ldgettext(domain, message):
  function dngettext (line 684) | def dngettext(domain, msgid1, msgid2, n):
  function ldngettext (line 694) | def ldngettext(domain, msgid1, msgid2, n):
  function dpgettext (line 716) | def dpgettext(domain, context, message):
  function dnpgettext (line 724) | def dnpgettext(domain, context, msgid1, msgid2, n):
  function gettext (line 735) | def gettext(message):
  function lgettext (line 738) | def lgettext(message):
  function ngettext (line 747) | def ngettext(msgid1, msgid2, n):
  function lngettext (line 750) | def lngettext(msgid1, msgid2, n):
  function pgettext (line 760) | def pgettext(context, message):
  function npgettext (line 764) | def npgettext(context, msgid1, msgid2, n):

FILE: rd/usr/lib/python3.8/glob.py
  function glob (line 10) | def glob(pathname, *, recursive=False):
  function iglob (line 23) | def iglob(pathname, *, recursive=False):
  function _iglob (line 41) | def _iglob(pathname, recursive, dironly):
  function _glob1 (line 81) | def _glob1(dirname, pattern, dironly):
  function _glob0 (line 87) | def _glob0(dirname, basename, dironly):
  function glob0 (line 100) | def glob0(dirname, pattern):
  function glob1 (line 103) | def glob1(dirname, pattern):
  function _glob2 (line 109) | def _glob2(dirname, pattern, dironly):
  function _iterdir (line 116) | def _iterdir(dirname, dironly):
  function _rlistdir (line 134) | def _rlistdir(dirname, dironly):
  function has_magic (line 147) | def has_magic(s):
  function _ishidden (line 154) | def _ishidden(path):
  function _isrecursive (line 157) | def _isrecursive(pattern):
  function escape (line 163) | def escape(pathname):

FILE: rd/usr/lib/python3.8/gzip.py
  function open (line 25) | def open(filename, mode="rb", compresslevel=_COMPRESS_LEVEL_BEST,
  function write32u (line 69) | def write32u(output, value):
  class _PaddedFile (line 74) | class _PaddedFile:
    method __init__ (line 79) | def __init__(self, f, prepend=b''):
    method read (line 85) | def read(self, size):
    method prepend (line 98) | def prepend(self, prepend=b''):
    method seek (line 107) | def seek(self, off):
    method seekable (line 112) | def seekable(self):
  class BadGzipFile (line 116) | class BadGzipFile(OSError):
  class GzipFile (line 120) | class GzipFile(_compression.BaseStream):
    method __init__ (line 133) | def __init__(self, filename=None, mode=None,
    method filename (line 207) | def filename(self):
    method mtime (line 215) | def mtime(self):
    method __repr__ (line 219) | def __repr__(self):
    method _init_write (line 223) | def _init_write(self, filename):
    method _write_gzip_header (line 231) | def _write_gzip_header(self, compresslevel):
    method write (line 263) | def write(self,data):
    method read (line 287) | def read(self, size=-1):
    method read1 (line 294) | def read1(self, size=-1):
    method peek (line 307) | def peek(self, n):
    method closed (line 315) | def closed(self):
    method close (line 318) | def close(self):
    method flush (line 337) | def flush(self,zlib_mode=zlib.Z_SYNC_FLUSH):
    method fileno (line 344) | def fileno(self):
    method rewind (line 352) | def rewind(self):
    method readable (line 359) | def readable(self):
    method writable (line 362) | def writable(self):
    method seekable (line 365) | def seekable(self):
    method seek (line 368) | def seek(self, offset, whence=io.SEEK_SET):
    method readline (line 388) | def readline(self, size=-1):
  class _GzipReader (line 393) | class _GzipReader(_compression.DecompressReader):
    method __init__ (line 394) | def __init__(self, fp):
    method _init_read (line 401) | def _init_read(self):
    method _read_exact (line 405) | def _read_exact(self, n):
    method _read_gzip_header (line 421) | def _read_gzip_header(self):
    method read (line 454) | def read(self, size=-1):
    method _add_read_data (line 505) | def _add_read_data(self, data):
    method _read_eof (line 509) | def _read_eof(self):
    method _rewind (line 530) | def _rewind(self):
  function compress (line 534) | def compress(data, compresslevel=_COMPRESS_LEVEL_BEST, *, mtime=None):
  function decompress (line 543) | def decompress(data):
  function main (line 551) | def main():

FILE: rd/usr/lib/python3.8/hashlib.py
  function __get_builtin_constructor (line 79) | def __get_builtin_constructor(name):
  function __get_openssl_constructor (line 123) | def __get_openssl_constructor(name):
  function __py_new (line 138) | def __py_new(name, data=b'', **kwargs):
  function __hash_new (line 146) | def __hash_new(name, data=b'', **kwargs):
  function pbkdf2_hmac (line 183) | def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None):

FILE: rd/usr/lib/python3.8/heapq.py
  function heappush (line 130) | def heappush(heap, item):
  function heappop (line 135) | def heappop(heap):
  function heapreplace (line 145) | def heapreplace(heap, item):
  function heappushpop (line 161) | def heappushpop(heap, item):
  function heapify (line 168) | def heapify(x):
  function _heappop_max (line 179) | def _heappop_max(heap):
  function _heapreplace_max (line 189) | def _heapreplace_max(heap, item):
  function _heapify_max (line 196) | def _heapify_max(x):
  function _siftdown (line 205) | def _siftdown(heap, startpos, pos):
  function _siftup (line 258) | def _siftup(heap, pos):
  function _siftdown_max (line 278) | def _siftdown_max(heap, startpos, pos):
  function _siftup_max (line 293) | def _siftup_max(heap, pos):
  function merge (line 314) | def merge(*iterables, key=None, reverse=False):
  function nsmallest (line 461) | def nsmallest(n, iterable, key=None):
  function nlargest (line 521) | def nlargest(n, iterable, key=None):

FILE: rd/usr/lib/python3.8/hmac.py
  class HMAC (line 26) | class HMAC:
    method __init__ (line 33) | def __init__(self, key, msg=None, digestmod=''):
    method name (line 91) | def name(self):
    method update (line 94) | def update(self, msg):
    method copy (line 98) | def copy(self):
    method _current (line 111) | def _current(self):
    method digest (line 120) | def digest(self):
    method hexdigest (line 130) | def hexdigest(self):
  function new (line 136) | def new(key, msg=None, digestmod=''):
  function digest (line 156) | def digest(key, msg, digest):

FILE: rd/usr/lib/python3.8/imghdr.py
  function what (line 11) | def what(file, h=None):
  function test_jpeg (line 37) | def test_jpeg(h, f):
  function test_png (line 44) | def test_png(h, f):
  function test_gif (line 50) | def test_gif(h, f):
  function test_tiff (line 57) | def test_tiff(h, f):
  function test_rgb (line 64) | def test_rgb(h, f):
  function test_pbm (line 71) | def test_pbm(h, f):
  function test_pgm (line 79) | def test_pgm(h, f):
  function test_ppm (line 87) | def test_ppm(h, f):
  function test_rast (line 95) | def test_rast(h, f):
  function test_xbm (line 102) | def test_xbm(h, f):
  function test_bmp (line 109) | def test_bmp(h, f):
  function test_webp (line 115) | def test_webp(h, f):
  function test_exr (line 121) | def test_exr(h, f):
  function test (line 131) | def test():
  function testall (line 146) | def testall(list, recursive, toplevel):

FILE: rd/usr/lib/python3.8/imp.py
  function new_module (line 48) | def new_module(name):
  function get_magic (line 59) | def get_magic():
  function get_tag (line 67) | def get_tag():
  function cache_from_source (line 72) | def cache_from_source(path, debug_override=None):
  function source_from_cache (line 91) | def source_from_cache(path):
  function get_suffixes (line 105) | def get_suffixes():
  class NullImporter (line 114) | class NullImporter:
    method __init__ (line 122) | def __init__(self, path):
    method find_module (line 128) | def find_module(self, fullname):
  class _HackedGetData (line 133) | class _HackedGetData:
    method __init__ (line 138) | def __init__(self, fullname, path, file=None):
    method get_data (line 142) | def get_data(self, path):
  class _LoadSourceCompatibility (line 160) | class _LoadSourceCompatibility(_HackedGetData, machinery.SourceFileLoader):
  function load_source (line 165) | def load_source(name, pathname, file=None):
  class _LoadCompiledCompatibility (line 179) | class _LoadCompiledCompatibility(_HackedGetData, SourcelessFileLoader):
  function load_compiled (line 184) | def load_compiled(name, pathname, file=None):
  function load_package (line 199) | def load_package(name, path):
  function load_module (line 219) | def load_module(name, file, filename, details):
  function find_module (line 254) | def find_module(name, path=None):
  function reload (line 306) | def reload(module):
  function init_builtin (line 317) | def init_builtin(name):
  function load_dynamic (line 330) | def load_dynamic(name, path, file=None):

FILE: rd/usr/lib/python3.8/importlib/__init__.py
  function invalidate_caches (line 66) | def invalidate_caches():
  function find_loader (line 74) | def find_loader(name, path=None):
  function import_module (line 109) | def import_module(name, package=None):
  function reload (line 133) | def reload(module):

FILE: rd/usr/lib/python3.8/importlib/_bootstrap.py
  function _wrap (line 27) | def _wrap(new, old):
  function _new_module (line 35) | def _new_module(name):
  class _DeadlockError (line 48) | class _DeadlockError(RuntimeError):
  class _ModuleLock (line 52) | class _ModuleLock:
    method __init__ (line 58) | def __init__(self, name):
    method has_deadlock (line 66) | def has_deadlock(self):
    method acquire (line 78) | def acquire(self):
    method release (line 103) | def release(self):
    method __repr__ (line 116) | def __repr__(self):
  class _DummyModuleLock (line 120) | class _DummyModuleLock:
    method __init__ (line 124) | def __init__(self, name):
    method acquire (line 128) | def acquire(self):
    method release (line 132) | def release(self):
    method __repr__ (line 137) | def __repr__(self):
  class _ModuleLockManager (line 141) | class _ModuleLockManager:
    method __init__ (line 143) | def __init__(self, name):
    method __enter__ (line 147) | def __enter__(self):
    method __exit__ (line 151) | def __exit__(self, *args, **kwargs):
  function _get_module_lock (line 157) | def _get_module_lock(name):
  function _lock_unlock_module (line 194) | def _lock_unlock_module(name):
  function _call_with_frames_removed (line 211) | def _call_with_frames_removed(f, *args, **kwds):
  function _verbose_message (line 222) | def _verbose_message(message, *args, verbosity=1):
  function _requires_builtin (line 230) | def _requires_builtin(fxn):
  function _requires_frozen (line 241) | def _requires_frozen(fxn):
  function _load_module_shim (line 253) | def _load_module_shim(self, fullname):
  function _module_repr (line 269) | def _module_repr(module):
  class ModuleSpec (line 305) | class ModuleSpec:
    method __init__ (line 342) | def __init__(self, name, loader, *, origin=None, loader_state=None,
    method __repr__ (line 354) | def __repr__(self):
    method __eq__ (line 364) | def __eq__(self, other):
    method cached (line 377) | def cached(self):
    method cached (line 386) | def cached(self, cached):
    method parent (line 390) | def parent(self):
    method has_location (line 398) | def has_location(self):
    method has_location (line 402) | def has_location(self, value):
  function spec_from_loader (line 406) | def spec_from_loader(name, loader, *, origin=None, is_package=None):
  function _spec_from_module (line 432) | def _spec_from_module(module, loader=None, origin=None):
  function _init_module_attrs (line 477) | def _init_module_attrs(spec, module, *, override=False):
  function module_from_spec (line 549) | def module_from_spec(spec):
  function _module_repr_from_spec (line 566) | def _module_repr_from_spec(spec):
  function _exec (line 583) | def _exec(spec, module):
  function _load_backward_compatible (line 613) | def _load_backward_compatible(spec):
  function _load_unlocked (line 650) | def _load_unlocked(spec):
  function _load (line 692) | def _load(spec):
  class BuiltinImporter (line 707) | class BuiltinImporter:
    method module_repr (line 717) | def module_repr(module):
    method find_spec (line 726) | def find_spec(cls, fullname, path=None, target=None):
    method find_module (line 735) | def find_module(cls, fullname, path=None):
    method create_module (line 747) | def create_module(self, spec):
    method exec_module (line 755) | def exec_module(self, module):
    method get_code (line 761) | def get_code(cls, fullname):
    method get_source (line 767) | def get_source(cls, fullname):
    method is_package (line 773) | def is_package(cls, fullname):
  class FrozenImporter (line 780) | class FrozenImporter:
    method module_repr (line 792) | def module_repr(m):
    method find_spec (line 801) | def find_spec(cls, fullname, path=None, target=None):
    method find_module (line 808) | def find_module(cls, fullname, path=None):
    method create_module (line 817) | def create_module(cls, spec):
    method exec_module (line 821) | def exec_module(module):
    method load_module (line 830) | def load_module(cls, fullname):
    method get_code (line 840) | def get_code(cls, fullname):
    method get_source (line 846) | def get_source(cls, fullname):
    method is_package (line 852) | def is_package(cls, fullname):
  class _ImportLockContext (line 859) | class _ImportLockContext:
    method __enter__ (line 863) | def __enter__(self):
    method __exit__ (line 867) | def __exit__(self, exc_type, exc_value, exc_traceback):
  function _resolve_name (line 872) | def _resolve_name(name, package, level):
  function _find_spec_legacy (line 881) | def _find_spec_legacy(finder, name, path):
  function _find_spec (line 890) | def _find_spec(name, path, target=None):
  function _sanity_check (line 937) | def _sanity_check(name, package, level):
  function _find_and_load_unlocked (line 956) | def _find_and_load_unlocked(name, import_):
  function _find_and_load (line 986) | def _find_and_load(name, import_):
  function _gcd_import (line 1002) | def _gcd_import(name, package=None, level=0):
  function _handle_fromlist (line 1017) | def _handle_fromlist(module, fromlist, import_, *, recursive=False):
  function _calc___package__ (line 1054) | def _calc___package__(globals):
  function __import__ (line 1081) | def __import__(name, globals=None, locals=None, fromlist=(), level=0):
  function _builtin_from_name (line 1118) | def _builtin_from_name(name):
  function _setup (line 1125) | def _setup(sys_module, _imp_module):
  function _install (line 1160) | def _install(sys_module, _imp_module):
  function _install_external_importers (line 1168) | def _install_external_importers():

FILE: rd/usr/lib/python3.8/importlib/_bootstrap_external.py
  function _make_relax_case (line 29) | def _make_relax_case():
  function _pack_uint32 (line 46) | def _pack_uint32(x):
  function _unpack_uint32 (line 51) | def _unpack_uint32(data):
  function _unpack_uint16 (line 56) | def _unpack_uint16(data):
  function _path_join (line 62) | def _path_join(*path_parts):
  function _path_split (line 68) | def _path_split(path):
  function _path_stat (line 80) | def _path_stat(path):
  function _path_is_mode_type (line 90) | def _path_is_mode_type(path, mode):
  function _path_isfile (line 99) | def _path_isfile(path):
  function _path_isdir (line 104) | def _path_isdir(path):
  function _path_isabs (line 111) | def _path_isabs(path):
  function _write_atomic (line 120) | def _write_atomic(path, data, mode=0o666):
  function cache_from_source (line 294) | def cache_from_source(path, debug_override=None, *, optimization=None):
  function source_from_cache (line 365) | def source_from_cache(path):
  function _get_sourcefile (line 405) | def _get_sourcefile(bytecode_path):
  function _get_cached (line 424) | def _get_cached(filename):
  function _calc_mode (line 436) | def _calc_mode(path):
  function _check_name (line 448) | def _check_name(method):
  function _find_module_shim (line 476) | def _find_module_shim(self, fullname):
  function _classify_pyc (line 493) | def _classify_pyc(data, name, exc_details):
  function _validate_timestamp_pyc (line 526) | def _validate_timestamp_pyc(data, source_mtime, source_size, name,
  function _validate_hash_pyc (line 554) | def _validate_hash_pyc(data, source_hash, name, exc_details):
  function _compile_bytecode (line 578) | def _compile_bytecode(data, name=None, bytecode_path=None, source_path=N...
  function _code_to_timestamp_pyc (line 591) | def _code_to_timestamp_pyc(code, mtime=0, source_size=0):
  function _code_to_hash_pyc (line 601) | def _code_to_hash_pyc(code, source_hash, checked=True):
  function decode_source (line 612) | def decode_source(source_bytes):
  function spec_from_file_location (line 629) | def spec_from_file_location(name, location=None, *, loader=None,
  class WindowsRegistryFinder (line 697) | class WindowsRegistryFinder:
    method _open_registry (line 710) | def _open_registry(cls, key):
    method _search_registry (line 717) | def _search_registry(cls, fullname):
    method find_spec (line 732) | def find_spec(cls, fullname, path=None, target=None):
    method find_module (line 748) | def find_module(cls, fullname, path=None):
  class _LoaderBasics (line 761) | class _LoaderBasics:
    method is_package (line 766) | def is_package(self, fullname):
    method create_module (line 774) | def create_module(self, spec):
    method exec_module (line 777) | def exec_module(self, module):
    method load_module (line 785) | def load_module(self, fullname):
  class SourceLoader (line 790) | class SourceLoader(_LoaderBasics):
    method path_mtime (line 792) | def path_mtime(self, path):
    method path_stats (line 800) | def path_stats(self, path):
    method _cache_bytecode (line 814) | def _cache_bytecode(self, source_path, cache_path, data):
    method set_data (line 824) | def set_data(self, path, data):
    method get_source (line 831) | def get_source(self, fullname):
    method source_to_code (line 841) | def source_to_code(self, data, path, *, _optimize=-1):
    method get_code (line 849) | def get_code(self, fullname):
  class FileLoader (line 934) | class FileLoader:
    method __init__ (line 939) | def __init__(self, fullname, path):
    method __eq__ (line 945) | def __eq__(self, other):
    method __hash__ (line 949) | def __hash__(self):
    method load_module (line 953) | def load_module(self, fullname):
    method get_filename (line 965) | def get_filename(self, fullname):
    method get_data (line 969) | def get_data(self, path):
    method get_resource_reader (line 981) | def get_resource_reader(self, module):
    method open_resource (line 986) | def open_resource(self, resource):
    method resource_path (line 990) | def resource_path(self, resource):
    method is_resource (line 996) | def is_resource(self, name):
    method contents (line 1002) | def contents(self):
  class SourceFileLoader (line 1006) | class SourceFileLoader(FileLoader, SourceLoader):
    method path_stats (line 1010) | def path_stats(self, path):
    method _cache_bytecode (line 1015) | def _cache_bytecode(self, source_path, bytecode_path, data):
    method set_data (line 1020) | def set_data(self, path, data, *, _mode=0o666):
  class SourcelessFileLoader (line 1051) | class SourcelessFileLoader(FileLoader, _LoaderBasics):
    method get_code (line 1055) | def get_code(self, fullname):
    method get_source (line 1071) | def get_source(self, fullname):
  class ExtensionFileLoader (line 1080) | class ExtensionFileLoader(FileLoader, _LoaderBasics):
    method __init__ (line 1088) | def __init__(self, name, path):
    method __eq__ (line 1092) | def __eq__(self, other):
    method __hash__ (line 1096) | def __hash__(self):
    method create_module (line 1099) | def create_module(self, spec):
    method exec_module (line 1107) | def exec_module(self, module):
    method is_package (line 1113) | def is_package(self, fullname):
    method get_code (line 1119) | def get_code(self, fullname):
    method get_source (line 1123) | def get_source(self, fullname):
    method get_filename (line 1128) | def get_filename(self, fullname):
  class _NamespacePath (line 1133) | class _NamespacePath:
    method __init__ (line 1140) | def __init__(self, name, path, path_finder):
    method _find_parent_path_names (line 1146) | def _find_parent_path_names(self):
    method _get_parent_path (line 1156) | def _get_parent_path(self):
    method _recalculate (line 1160) | def _recalculate(self):
    method __iter__ (line 1173) | def __iter__(self):
    method __getitem__ (line 1176) | def __getitem__(self, index):
    method __setitem__ (line 1179) | def __setitem__(self, index, path):
    method __len__ (line 1182) | def __len__(self):
    method __repr__ (line 1185) | def __repr__(self):
    method __contains__ (line 1188) | def __contains__(self, item):
    method append (line 1191) | def append(self, item):
  class _NamespaceLoader (line 1196) | class _NamespaceLoader:
    method __init__ (line 1197) | def __init__(self, name, path, path_finder):
    method module_repr (line 1201) | def module_repr(cls, module):
    method is_package (line 1209) | def is_package(self, fullname):
    method get_source (line 1212) | def get_source(self, fullname):
    method get_code (line 1215) | def get_code(self, fullname):
    method create_module (line 1218) | def create_module(self, spec):
    method exec_module (line 1221) | def exec_module(self, module):
    method load_module (line 1224) | def load_module(self, fullname):
  class PathFinder (line 1238) | class PathFinder:
    method invalidate_caches (line 1243) | def invalidate_caches(cls):
    method _path_hooks (line 1253) | def _path_hooks(cls, path):
    method _path_importer_cache (line 1266) | def _path_importer_cache(cls, path):
    method _legacy_get_spec (line 1288) | def _legacy_get_spec(cls, fullname, finder):
    method _get_spec (line 1303) | def _get_spec(cls, fullname, path, target=None):
    method find_spec (line 1335) | def find_spec(cls, fullname, path=None, target=None):
    method find_module (line 1359) | def find_module(cls, fullname, path=None):
    method find_distributions (line 1372) | def find_distributions(cls, *args, **kwargs):
  class FileFinder (line 1385) | class FileFinder:
    method __init__ (line 1394) | def __init__(self, path, *loader_details):
    method invalidate_caches (line 1408) | def invalidate_caches(self):
    method find_loader (line 1414) | def find_loader(self, fullname):
    method _get_spec (line 1426) | def _get_spec(self, loader_class, fullname, path, smsl, target):
    method find_spec (line 1431) | def find_spec(self, fullname, target=None):
    method _fill_cache (line 1479) | def _fill_cache(self):
    method path_hook (line 1511) | def path_hook(cls, *loader_details):
    method __repr__ (line 1528) | def __repr__(self):
  function _fix_up_module (line 1534) | def _fix_up_module(ns, name, pathname, cpathname=None):
  function _get_supported_file_loaders (line 1557) | def _get_supported_file_loaders():
  function _setup (line 1568) | def _setup(_bootstrap_module):
  function _install (line 1633) | def _install(_bootstrap_module):

FILE: rd/usr/lib/python3.8/importlib/abc.py
  function _register (line 19) | def _register(abstract_cls, *classes):
  class Finder (line 30) | class Finder(metaclass=abc.ABCMeta):
    method find_module (line 43) | def find_module(self, fullname, path=None):
  class MetaPathFinder (line 50) | class MetaPathFinder(Finder):
    method find_module (line 57) | def find_module(self, fullname, path):
    method invalidate_caches (line 78) | def invalidate_caches(self):
  class PathEntryFinder (line 87) | class PathEntryFinder(Finder):
    method find_loader (line 94) | def find_loader(self, fullname):
    method invalidate_caches (line 128) | def invalidate_caches(self):
  class Loader (line 136) | class Loader(metaclass=abc.ABCMeta):
    method create_module (line 140) | def create_module(self, spec):
    method load_module (line 153) | def load_module(self, fullname):
    method module_repr (line 170) | def module_repr(self, module):
  class ResourceLoader (line 183) | class ResourceLoader(Loader):
    method get_data (line 193) | def get_data(self, path):
  class InspectLoader (line 199) | class InspectLoader(Loader):
    method is_package (line 208) | def is_package(self, fullname):
    method get_code (line 216) | def get_code(self, fullname):
    method get_source (line 230) | def get_source(self, fullname):
    method source_to_code (line 239) | def source_to_code(data, path='<string>'):
  class ExecutionLoader (line 252) | class ExecutionLoader(InspectLoader):
    method get_filename (line 262) | def get_filename(self, fullname):
    method get_code (line 270) | def get_code(self, fullname):
  class FileLoader (line 289) | class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, Executi...
  class SourceLoader (line 298) | class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, Exe...
    method path_mtime (line 315) | def path_mtime(self, path):
    method path_stats (line 321) | def path_stats(self, path):
    method set_data (line 332) | def set_data(self, path, data):
  class ResourceReader (line 345) | class ResourceReader(metaclass=abc.ABCMeta):
    method open_resource (line 355) | def open_resource(self, resource):
    method resource_path (line 366) | def resource_path(self, resource):
    method is_resource (line 378) | def is_resource(self, name):
    method contents (line 383) | def contents(self):

FILE: rd/usr/lib/python3.8/importlib/machinery.py
  function all_suffixes (line 19) | def all_suffixes():

FILE: rd/usr/lib/python3.8/importlib/metadata.py
  class PackageNotFoundError (line 37) | class PackageNotFoundError(ModuleNotFoundError):
  class EntryPoint (line 41) | class EntryPoint(
    method load (line 71) | def load(self):
    method extras (line 82) | def extras(self):
    method _from_config (line 87) | def _from_config(cls, config):
    method _from_text (line 95) | def _from_text(cls, text):
    method __iter__ (line 106) | def __iter__(self):
    method __reduce__ (line 112) | def __reduce__(self):
  class PackagePath (line 119) | class PackagePath(pathlib.PurePosixPath):
    method read_text (line 122) | def read_text(self, encoding='utf-8'):
    method read_binary (line 126) | def read_binary(self):
    method locate (line 130) | def locate(self):
  class FileHash (line 135) | class FileHash:
    method __init__ (line 136) | def __init__(self, spec):
    method __repr__ (line 139) | def __repr__(self):
  class Distribution (line 143) | class Distribution:
    method read_text (line 147) | def read_text(self, filename):
    method locate_file (line 155) | def locate_file(self, path):
    method from_name (line 162) | def from_name(cls, name):
    method discover (line 180) | def discover(cls, **kwargs):
    method at (line 199) | def at(path):
    method _discover_resolvers (line 208) | def _discover_resolvers():
    method metadata (line 217) | def metadata(self):
    method version (line 234) | def version(self):
    method entry_points (line 239) | def entry_points(self):
    method files (line 243) | def files(self):
    method _read_files_distinfo (line 264) | def _read_files_distinfo(self):
    method _read_files_egginfo (line 271) | def _read_files_egginfo(self):
    method requires (line 280) | def requires(self):
    method _read_dist_info_reqs (line 285) | def _read_dist_info_reqs(self):
    method _read_egg_info_reqs (line 288) | def _read_egg_info_reqs(self):
    method _deps_from_requires_text (line 293) | def _deps_from_requires_text(cls, source):
    method _read_sections (line 303) | def _read_sections(lines):
    method _convert_egg_info_reqs_to_simple_reqs (line 313) | def _convert_egg_info_reqs_to_simple_reqs(sections):
  class DistributionFinder (line 339) | class DistributionFinder(MetaPathFinder):
    class Context (line 344) | class Context:
      method __init__ (line 362) | def __init__(self, **kwargs):
      method path (line 366) | def path(self):
    method find_distributions (line 376) | def find_distributions(self, context=Context()):
  class FastPath (line 386) | class FastPath:
    method __init__ (line 392) | def __init__(self, root):
    method joinpath (line 396) | def joinpath(self, child):
    method children (line 399) | def children(self):
    method zip_children (line 406) | def zip_children(self):
    method is_egg (line 416) | def is_egg(self, search):
    method search (line 423) | def search(self, name):
  class Prepared (line 434) | class Prepared:
    method __init__ (line 444) | def __init__(self, name):
  class MetadataPathFinder (line 455) | class MetadataPathFinder(DistributionFinder):
    method find_distributions (line 457) | def find_distributions(cls, context=DistributionFinder.Context()):
    method _search_paths (line 470) | def _search_paths(cls, name, paths):
  class PathDistribution (line 479) | class PathDistribution(Distribution):
    method __init__ (line 480) | def __init__(self, path):
    method read_text (line 488) | def read_text(self, filename):
    method locate_file (line 494) | def locate_file(self, path):
  function distribution (line 498) | def distribution(distribution_name):
  function distributions (line 507) | def distributions(**kwargs):
  function metadata (line 515) | def metadata(distribution_name):
  function version (line 524) | def version(distribution_name):
  function entry_points (line 534) | def entry_points():
  function files (line 550) | def files(distribution_name):
  function requires (line 559) | def requires(distribution_name):

FILE: rd/usr/lib/python3.8/importlib/resources.py
  function _get_package (line 34) | def _get_package(package) -> ModuleType:
  function _normalize_path (line 54) | def _normalize_path(path) -> str:
  function _get_resource_reader (line 66) | def _get_resource_reader(
  function _check_location (line 80) | def _check_location(package):
  function open_binary (line 85) | def open_binary(package: Package, resource: Resource) -> BinaryIO:
  function open_text (line 116) | def open_text(package: Package,
  function read_binary (line 150) | def read_binary(package: Package, resource: Resource) -> bytes:
  function read_text (line 158) | def read_text(package: Package,
  function path (line 174) | def path(package: Package, resource: Resource) -> Iterator[Path]:
  function is_resource (line 218) | def is_resource(package: Package, name: str) -> bool:
  function contents (line 241) | def contents(package: Package) -> Iterable[str]:

FILE: rd/usr/lib/python3.8/importlib/util.py
  function source_hash (line 22) | def source_hash(source_bytes):
  function resolve_name (line 27) | def resolve_name(name, package):
  function _find_spec_from_path (line 42) | def _find_spec_from_path(name, path=None):
  function find_spec (line 73) | def find_spec(name, package=None):
  function _module_to_load (line 119) | def _module_to_load(name):
  function set_package (line 144) | def set_package(fxn):
  function set_loader (line 163) | def set_loader(fxn):
  function module_for_loader (line 180) | def module_for_loader(fxn):
  class _LazyModule (line 219) | class _LazyModule(types.ModuleType):
    method __getattribute__ (line 223) | def __getattribute__(self, attr):
    method __delattr__ (line 258) | def __delattr__(self, attr):
  class LazyLoader (line 266) | class LazyLoader(abc.Loader):
    method __check_eager_loader (line 271) | def __check_eager_loader(loader):
    method factory (line 276) | def factory(cls, loader):
    method __init__ (line 281) | def __init__(self, loader):
    method create_module (line 285) | def create_module(self, spec):
    method exec_module (line 288) | def exec_module(self, module):

FILE: rd/usr/lib/python3.8/inspect.py
  function ismodule (line 63) | def ismodule(object):
  function isclass (line 72) | def isclass(object):
  function ismethod (line 80) | def ismethod(object):
  function ismethoddescriptor (line 90) | def ismethoddescriptor(object):
  function isdatadescriptor (line 110) | def isdatadescriptor(object):
  function ismemberdescriptor (line 126) | def ismemberdescriptor(object):
  function ismemberdescriptor (line 134) | def ismemberdescriptor(object):
  function isgetsetdescriptor (line 143) | def isgetsetdescriptor(object):
  function isgetsetdescriptor (line 151) | def isgetsetdescriptor(object):
  function isfunction (line 158) | def isfunction(object):
  function _has_code_flag (line 171) | def _has_code_flag(f, flag):
  function isgeneratorfunction (line 182) | def isgeneratorfunction(obj):
  function iscoroutinefunction (line 189) | def iscoroutinefunction(obj):
  function isasyncgenfunction (line 196) | def isasyncgenfunction(obj):
  function isasyncgen (line 204) | def isasyncgen(object):
  function isgenerator (line 208) | def isgenerator(object):
  function iscoroutine (line 225) | def iscoroutine(object):
  function isawaitable (line 229) | def isawaitable(object):
  function istraceback (line 236) | def istraceback(object):
  function isframe (line 246) | def isframe(object):
  function iscode (line 260) | def iscode(object):
  function isbuiltin (line 285) | def isbuiltin(object):
  function isroutine (line 294) | def isroutine(object):
  function isabstract (line 301) | def isabstract(object):
  function getmembers (line 325) | def getmembers(object, predicate=None):
  function classify_class_attrs (line 371) | def classify_class_attrs(cls):
  function getmro (line 487) | def getmro(cls):
  function unwrap (line 493) | def unwrap(func, *, stop=None):
  function indentsize (line 529) | def indentsize(line):
  function _findclass (line 534) | def _findclass(func):
  function _finddoc (line 544) | def _finddoc(obj):
  function getdoc (line 606) | def getdoc(object):
  function cleandoc (line 625) | def cleandoc(doc):
  function getfile (line 654) | def getfile(object):
  function getmodulename (line 680) | def getmodulename(path):
  function getsourcefile (line 692) | def getsourcefile(object):
  function getabsfile (line 714) | def getabsfile(object, _filename=None):
  function getmodule (line 726) | def getmodule(object, _filename=None):
  function findsource (line 772) | def findsource(object):
  function getcomments (line 845) | def getcomments(object):
  class EndOfBlock (line 890) | class EndOfBlock(Exception): pass
  class BlockFinder (line 892) | class BlockFinder:
    method __init__ (line 894) | def __init__(self):
    method tokeneater (line 903) | def tokeneater(self, type, token, srowcol, erowcol, line):
  function getblock (line 947) | def getblock(lines):
  function getsourcelines (line 958) | def getsourcelines(object):
  function getsource (line 979) | def getsource(object):
  function walktree (line 989) | def walktree(classes, children, parent):
  function getclasstree (line 999) | def getclasstree(classes, unique=False):
  function getargs (line 1028) | def getargs(co):
  function getargspec (line 1057) | def getargspec(func):
  function getfullargspec (line 1090) | def getfullargspec(func):
  function getargvalues (line 1185) | def getargvalues(frame):
  function formatannotation (line 1195) | def formatannotation(annotation, base_module=None):
  function formatannotationrelativeto (line 1204) | def formatannotationrelativeto(object):
  function formatargspec (line 1210) | def formatargspec(args, varargs=None, varkw=None, defaults=None,
  function formatargvalues (line 1268) | def formatargvalues(args, varargs, varkw, locals,
  function _missing_arguments (line 1291) | def _missing_arguments(f_name, argnames, pos, values):
  function _too_many (line 1307) | def _too_many(f_name, args, kwonly, varargs, defcount, given, values):
  function getcallargs (line 1328) | def getcallargs(func, /, *positional, **named):
  function getclosurevars (line 1390) | def getclosurevars(func):
  function getframeinfo (line 1445) | def getframeinfo(frame, context=1):
  function getlineno (line 1477) | def getlineno(frame):
  function getouterframes (line 1484) | def getouterframes(frame, context=1):
  function getinnerframes (line 1496) | def getinnerframes(tb, context=1):
  function currentframe (line 1508) | def currentframe():
  function stack (line 1512) | def stack(context=1):
  function trace (line 1516) | def trace(context=1):
  function _static_getmro (line 1525) | def _static_getmro(klass):
  function _check_instance (line 1528) | def _check_instance(obj, attr):
  function _check_class (line 1537) | def _check_class(klass, attr):
  function _is_type (line 1546) | def _is_type(obj):
  function _shadowed_dict (line 1553) | def _shadowed_dict(klass):
  function getattr_static (line 1567) | def getattr_static(obj, attr, default=_sentinel):
  function getgeneratorstate (line 1620) | def getgeneratorstate(generator):
  function getgeneratorlocals (line 1638) | def getgeneratorlocals(generator):
  function getcoroutinestate (line 1662) | def getcoroutinestate(coroutine):
  function getcoroutinelocals (line 1680) | def getcoroutinelocals(coroutine):
  function _signature_get_user_defined_method (line 1708) | def _signature_get_user_defined_method(cls, method_name):
  function _signature_get_partial (line 1724) | def _signature_get_partial(wrapped_sig, partial, extra_args=()):
  function _signature_bound_method (line 1800) | def _signature_bound_method(sig):
  function _signature_is_builtin (line 1826) | def _signature_is_builtin(obj):
  function _signature_is_functionlike (line 1838) | def _signature_is_functionlike(obj):
  function _signature_get_bound_param (line 1863) | def _signature_get_bound_param(spec):
  function _signature_strip_non_python_syntax (line 1886) | def _signature_strip_non_python_syntax(signature):
  function _signature_fromstr (line 1958) | def _signature_fromstr(cls, obj, s, skip_bound_arg=True):
  function _signature_from_builtin (line 2096) | def _signature_from_builtin(cls, func, skip_bound_arg=True):
  function _signature_from_function (line 2112) | def _signature_from_function(cls, func, skip_bound_arg=True):
  function _signature_from_callable (line 2206) | def _signature_from_callable(obj, *,
  class _void (line 2408) | class _void:
  class _empty (line 2412) | class _empty:
  class _ParameterKind (line 2416) | class _ParameterKind(enum.IntEnum):
    method __str__ (line 2423) | def __str__(self):
    method description (line 2427) | def description(self):
  class Parameter (line 2445) | class Parameter:
    method __init__ (line 2477) | def __init__(self, name, kind, *, default=_empty, annotation=_empty):
    method __reduce__ (line 2517) | def __reduce__(self):
    method __setstate__ (line 2523) | def __setstate__(self, state):
    method name (line 2528) | def name(self):
    method default (line 2532) | def default(self):
    method annotation (line 2536) | def annotation(self):
    method kind (line 2540) | def kind(self):
    method replace (line 2543) | def replace(self, *, name=_void, kind=_void,
    method __str__ (line 2561) | def __str__(self):
    method __repr__ (line 2583) | def __repr__(self):
    method __hash__ (line 2586) | def __hash__(self):
    method __eq__ (line 2589) | def __eq__(self, other):
  class BoundArguments (line 2600) | class BoundArguments:
    method __init__ (line 2619) | def __init__(self, signature, arguments):
    method signature (line 2624) | def signature(self):
    method args (line 2628) | def args(self):
    method kwargs (line 2651) | def kwargs(self):
    method apply_defaults (line 2680) | def apply_defaults(self):
    method __eq__ (line 2708) | def __eq__(self, other):
    method __setstate__ (line 2716) | def __setstate__(self, state):
    method __getstate__ (line 2720) | def __getstate__(self):
    method __repr__ (line 2723) | def __repr__(self):
  class Signature (line 2730) | class Signature:
    method __init__ (line 2760) | def __init__(self, parameters=None, *, return_annotation=_empty,
    method from_function (line 2816) | def from_function(cls, func):
    method from_builtin (line 2828) | def from_builtin(cls, func):
    method from_callable (line 2840) | def from_callable(cls, obj, *, follow_wrapped=True):
    method parameters (line 2846) | def parameters(self):
    method return_annotation (line 2850) | def return_annotation(self):
    method replace (line 2853) | def replace(self, *, parameters=_void, return_annotation=_void):
    method _hash_basis (line 2868) | def _hash_basis(self):
    method __hash__ (line 2877) | def __hash__(self):
    method __eq__ (line 2882) | def __eq__(self, other):
    method _bind (line 2889) | def _bind(self, args, kwargs, *, partial=False):
    method bind (line 3020) | def bind(self, /, *args, **kwargs):
    method bind_partial (line 3027) | def bind_partial(self, /, *args, **kwargs):
    method __reduce__ (line 3034) | def __reduce__(self):
    method __setstate__ (line 3039) | def __setstate__(self, state):
    method __repr__ (line 3042) | def __repr__(self):
    method __str__ (line 3045) | def __str__(self):
  function signature (line 3091) | def signature(obj, *, follow_wrapped=True):
  function _main (line 3096) | def _main():

FILE: rd/usr/lib/python3.8/io.py
  class IOBase (line 72) | class IOBase(_io._IOBase, metaclass=abc.ABCMeta):
  class RawIOBase (line 75) | class RawIOBase(_io._RawIOBase, IOBase):
  class BufferedIOBase (line 78) | class BufferedIOBase(_io._BufferedIOBase, IOBase):
  class TextIOBase (line 81) | class TextIOBase(_io._TextIOBase, IOBase):

FILE: rd/usr/lib/python3.8/ipaddress.py
  class AddressValueError (line 19) | class AddressValueError(ValueError):
  class NetmaskValueError (line 23) | class NetmaskValueError(ValueError):
  function ip_address (line 27) | def ip_address(address):
  function ip_network (line 57) | def ip_network(address, strict=True):
  function ip_interface (line 87) | def ip_interface(address):
  function v4_int_to_packed (line 122) | def v4_int_to_packed(address):
  function v6_int_to_packed (line 142) | def v6_int_to_packed(address):
  function _split_optional_netmask (line 158) | def _split_optional_netmask(address):
  function _find_address_range (line 166) | def _find_address_range(addresses):
  function _count_righthand_zero_bits (line 186) | def _count_righthand_zero_bits(number, bits):
  function summarize_address_range (line 202) | def summarize_address_range(first, last):
  function _collapse_addresses_internal (line 257) | def _collapse_addresses_internal(addresses):
  function collapse_addresses (line 306) | def collapse_addresses(addresses):
  function get_mixed_type_key (line 360) | def get_mixed_type_key(obj):
  class _IPAddressBase (line 385) | class _IPAddressBase:
    method exploded (line 392) | def exploded(self):
    method compressed (line 397) | def compressed(self):
    method reverse_pointer (line 402) | def reverse_pointer(self):
    method version (line 413) | def version(self):
    method _check_int_address (line 417) | def _check_int_address(self, address):
    method _check_packed_address (line 426) | def _check_packed_address(self, address, expected_len):
    method _ip_int_from_prefix (line 434) | def _ip_int_from_prefix(cls, prefixlen):
    method _prefix_from_ip_int (line 447) | def _prefix_from_ip_int(cls, ip_int):
    method _report_invalid_netmask (line 472) | def _report_invalid_netmask(cls, netmask_str):
    method _prefix_from_prefix_string (line 477) | def _prefix_from_prefix_string(cls, prefixlen_str):
    method _prefix_from_ip_string (line 502) | def _prefix_from_ip_string(cls, ip_str):
    method _split_addr_prefix (line 536) | def _split_addr_prefix(cls, address):
    method __reduce__ (line 559) | def __reduce__(self):
  class _BaseAddress (line 564) | class _BaseAddress(_IPAddressBase):
    method __int__ (line 574) | def __int__(self):
    method __eq__ (line 577) | def __eq__(self, other):
    method __lt__ (line 584) | def __lt__(self, other):
    method __add__ (line 596) | def __add__(self, other):
    method __sub__ (line 601) | def __sub__(self, other):
    method __repr__ (line 606) | def __repr__(self):
    method __str__ (line 609) | def __str__(self):
    method __hash__ (line 612) | def __hash__(self):
    method _get_address_key (line 615) | def _get_address_key(self):
    method __reduce__ (line 618) | def __reduce__(self):
  class _BaseNetwork (line 623) | class _BaseNetwork(_IPAddressBase):
    method __repr__ (line 630) | def __repr__(self):
    method __str__ (line 633) | def __str__(self):
    method hosts (line 636) | def hosts(self):
    method __iter__ (line 648) | def __iter__(self):
    method __getitem__ (line 654) | def __getitem__(self, n):
    method __lt__ (line 667) | def __lt__(self, other):
    method __eq__ (line 679) | def __eq__(self, other):
    method __hash__ (line 687) | def __hash__(self):
    method __contains__ (line 690) | def __contains__(self, other):
    method overlaps (line 702) | def overlaps(self, other):
    method broadcast_address (line 710) | def broadcast_address(self):
    method hostmask (line 715) | def hostmask(self):
    method with_prefixlen (line 719) | def with_prefixlen(self):
    method with_netmask (line 723) | def with_netmask(self):
    method with_hostmask (line 727) | def with_hostmask(self):
    method num_addresses (line 731) | def num_addresses(self):
    method _address_class (line 736) | def _address_class(self):
    method prefixlen (line 744) | def prefixlen(self):
    method address_exclude (line 747) | def address_exclude(self, other):
    method compare_networks (line 822) | def compare_networks(self, other):
    method _get_networks_key (line 870) | def _get_networks_key(self):
    method subnets (line 880) | def subnets(self, prefixlen_diff=1, new_prefix=None):
    method supernet (line 933) | def supernet(self, prefixlen_diff=1, new_prefix=None):
    method is_multicast (line 975) | def is_multicast(self):
    method _is_subnet_of (line 987) | def _is_subnet_of(a, b):
    method subnet_of (line 998) | def subnet_of(self, other):
    method supernet_of (line 1002) | def supernet_of(self, other):
    method is_reserved (line 1007) | def is_reserved(self):
    method is_link_local (line 1019) | def is_link_local(self):
    method is_private (line 1030) | def is_private(self):
    method is_global (line 1042) | def is_global(self):
    method is_unspecified (line 1053) | def is_unspecified(self):
    method is_loopback (line 1065) | def is_loopback(self):
  class _BaseV4 (line 1077) | class _BaseV4:
    method _explode_shorthand_ip_string (line 1096) | def _explode_shorthand_ip_string(self):
    method _make_netmask (line 1100) | def _make_netmask(cls, arg):
    method _ip_int_from_string (line 1126) | def _ip_int_from_string(cls, ip_str):
    method _parse_octet (line 1152) | def _parse_octet(cls, octet_str):
    method _string_from_ip_int (line 1183) | def _string_from_ip_int(cls, ip_int):
    method _reverse_pointer (line 1195) | def _reverse_pointer(self):
    method max_prefixlen (line 1205) | def max_prefixlen(self):
    method version (line 1209) | def version(self):
  class IPv4Address (line 1213) | class IPv4Address(_BaseV4, _BaseAddress):
    method __init__ (line 1219) | def __init__(self, address):
    method packed (line 1255) | def packed(self):
    method is_reserved (line 1260) | def is_reserved(self):
    method is_private (line 1272) | def is_private(self):
    method is_global (line 1284) | def is_global(self):
    method is_multicast (line 1288) | def is_multicast(self):
    method is_unspecified (line 1299) | def is_unspecified(self):
    method is_loopback (line 1310) | def is_loopback(self):
    method is_link_local (line 1320) | def is_link_local(self):
  class IPv4Interface (line 1330) | class IPv4Interface(IPv4Address):
    method __init__ (line 1332) | def __init__(self, address):
    method hostmask (line 1341) | def hostmask(self):
    method __str__ (line 1344) | def __str__(self):
    method __eq__ (line 1348) | def __eq__(self, other):
    method __lt__ (line 1360) | def __lt__(self, other):
    method __hash__ (line 1372) | def __hash__(self):
    method ip (line 1378) | def ip(self):
    method with_prefixlen (line 1382) | def with_prefixlen(self):
    method with_netmask (line 1387) | def with_netmask(self):
    method with_hostmask (line 1392) | def with_hostmask(self):
  class IPv4Network (line 1397) | class IPv4Network(_BaseV4, _BaseNetwork):
    method __init__ (line 1412) | def __init__(self, address, strict=True):
    method is_global (line 1464) | def is_global(self):
  class _IPv4Constants (line 1477) | class _IPv4Constants:
  class _BaseV6 (line 1511) | class _BaseV6:
    method _make_netmask (line 1532) | def _make_netmask(cls, arg):
    method _ip_int_from_string (line 1552) | def _ip_int_from_string(cls, ip_str):
    method _parse_hextet (line 1656) | def _parse_hextet(cls, hextet_str):
    method _compress_hextets (line 1682) | def _compress_hextets(cls, hextets):
    method _string_from_ip_int (line 1730) | def _string_from_ip_int(cls, ip_int=None):
    method _explode_shorthand_ip_string (line 1755) | def _explode_shorthand_ip_string(self):
    method _reverse_pointer (line 1779) | def _reverse_pointer(self):
    method max_prefixlen (line 1789) | def max_prefixlen(self):
    method version (line 1793) | def version(self):
  class IPv6Address (line 1797) | class IPv6Address(_BaseV6, _BaseAddress):
    method __init__ (line 1803) | def __init__(self, address):
    method packed (line 1840) | def packed(self):
    method is_multicast (line 1845) | def is_multicast(self):
    method is_reserved (line 1856) | def is_reserved(self):
    method is_link_local (line 1867) | def is_link_local(self):
    method is_site_local (line 1877) | def is_site_local(self):
    method is_private (line 1892) | def is_private(self):
    method is_global (line 1903) | def is_global(self):
    method is_unspecified (line 1914) | def is_unspecified(self):
    method is_loopback (line 1925) | def is_loopback(self):
    method ipv4_mapped (line 1936) | def ipv4_mapped(self):
    method teredo (line 1949) | def teredo(self):
    method sixtofour (line 1964) | def sixtofour(self):
  class IPv6Interface (line 1977) | class IPv6Interface(IPv6Address):
    method __init__ (line 1979) | def __init__(self, address):
    method hostmask (line 1988) | def hostmask(self):
    method __str__ (line 1991) | def __str__(self):
    method __eq__ (line 1995) | def __eq__(self, other):
    method __lt__ (line 2007) | def __lt__(self, other):
    method __hash__ (line 2019) | def __hash__(self):
    method ip (line 2025) | def ip(self):
    method with_prefixlen (line 2029) | def with_prefixlen(self):
    method with_netmask (line 2034) | def with_netmask(self):
    method with_hostmask (line 2039) | def with_hostmask(self):
    method is_unspecified (line 2044) | def is_unspecified(self):
    method is_loopback (line 2048) | def is_loopback(self):
  class IPv6Network (line 2052) | class IPv6Network(_BaseV6, _BaseNetwork):
    method __init__ (line 2068) | def __init__(self, address, strict=True):
    method hosts (line 2114) | def hosts(self):
    method is_site_local (line 2127) | def is_site_local(self):
  class _IPv6Constants (line 2142) | class _IPv6Constants:

FILE: rd/usr/lib/python3.8/json/__init__.py
  function dump (line 120) | def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=T...
  function dumps (line 183) | def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
  function detect_encoding (line 244) | def detect_encoding(b):
  function load (line 274) | def load(fp, *, cls=None, object_hook=None, parse_float=None,
  function loads (line 299) | def loads(s, *, cls=None, object_hook=None, parse_float=None,

FILE: rd/usr/lib/python3.8/json/decoder.py
  class JSONDecodeError (line 20) | class JSONDecodeError(ValueError):
    method __init__ (line 31) | def __init__(self, msg, doc, pos):
    method __reduce__ (line 42) | def __reduce__(self):
  function _decode_uXXXX (line 59) | def _decode_uXXXX(s, pos):
  function py_scanstring (line 69) | def py_scanstring(s, end, strict=True,
  function JSONObject (line 136) | def JSONObject(s_and_end, strict, scan_once, object_hook, object_pairs_h...
  function JSONArray (line 217) | def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_...
  class JSONDecoder (line 254) | class JSONDecoder(object):
    method __init__ (line 284) | def __init__(self, *, object_hook=None, parse_float=None,
    method decode (line 332) | def decode(self, s, _w=WHITESPACE.match):
    method raw_decode (line 343) | def raw_decode(self, s, idx=0):

FILE: rd/usr/lib/python3.8/json/encoder.py
  function py_encode_basestring (line 36) | def py_encode_basestring(s):
  function py_encode_basestring_ascii (line 48) | def py_encode_basestring_ascii(s):
  class JSONEncoder (line 73) | class JSONEncoder(object):
    method __init__ (line 104) | def __init__(self, *, skipkeys=False, ensure_ascii=True,
    method default (line 160) | def default(self, o):
    method encode (line 182) | def encode(self, o):
    method iterencode (line 204) | def iterencode(self, o, _one_shot=False):
  function _make_iterencode (line 259) | def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,

FILE: rd/usr/lib/python3.8/json/scanner.py
  function py_make_scanner (line 15) | def py_make_scanner(context):

FILE: rd/usr/lib/python3.8/json/tool.py
  function main (line 18) | def main():

FILE: rd/usr/lib/python3.8/linecache.py
  function getline (line 15) | def getline(filename, lineno, module_globals=None):
  function clearcache (line 30) | def clearcache():
  function getlines (line 37) | def getlines(filename, module_globals=None):
  function checkcache (line 53) | def checkcache(filename=None):
  function updatecache (line 82) | def updatecache(filename, module_globals=None):
  function lazycache (line 147) | def lazycache(filename, module_globals):

FILE: rd/usr/lib/python3.8/locale.py
  function _strcoll (line 33) | def _strcoll(a,b):
  function _strxfrm (line 39) | def _strxfrm(s):
  function localeconv (line 63) | def localeconv():
  function setlocale (line 87) | def setlocale(category, value=None):
  function localeconv (line 109) | def localeconv():
  function _grouping_intervals (line 122) | def _grouping_intervals(grouping):
  function _group (line 138) | def _group(s, monetary=False):
  function _strip_padding (line 169) | def _strip_padding(s, amount):
  function _format (line 183) | def _format(percent, value, grouping=False, monetary=False, *additional):
  function format_string (line 207) | def format_string(f, val, grouping=False, monetary=False):
  function format (line 244) | def format(percent, value, grouping=False, monetary=False, *additional):
  function currency (line 259) | def currency(val, symbol=True, grouping=False, international=False):
  function str (line 304) | def str(val):
  function delocalize (line 308) | def delocalize(string):
  function atof (line 324) | def atof(string, func=float):
  function atoi (line 328) | def atoi(string):
  function _test (line 332) | def _test():
  function _replace_encoding (line 350) | def _replace_encoding(code, encoding):
  function _append_modifier (line 373) | def _append_modifier(code, modifier):
  function normalize (line 384) | def normalize(localename):
  function _parse_localename (line 467) | def _parse_localename(localename):
  function _build_localename (line 501) | def _build_localename(localetuple):
  function getdefaultlocale (line 522) | def getdefaultlocale(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE')):
  function getlocale (line 575) | def getlocale(category=LC_CTYPE):
  function setlocale (line 593) | def setlocale(category, locale=None):
  function resetlocale (line 610) | def resetlocale(category=LC_ALL):
  function getpreferredencoding (line 622) | def getpreferredencoding(do_setlocale = True):
  function getpreferredencoding (line 636) | def getpreferredencoding(do_setlocale = True):
  function getpreferredencoding (line 640) | def getpreferredencoding(do_setlocale = True):
  function getpreferredencoding (line 651) | def getpreferredencoding(do_setlocale = True):
  function _print_locale (line 1681) | def _print_locale():

FILE: rd/usr/lib/python3.8/lzma.py
  class LZMAFile (line 38) | class LZMAFile(_compression.BaseStream):
    method __init__ (line 49) | def __init__(self, filename=None, mode="r", *,
    method close (line 134) | def close(self):
    method closed (line 159) | def closed(self):
    method fileno (line 163) | def fileno(self):
    method seekable (line 168) | def seekable(self):
    method readable (line 172) | def readable(self):
    method writable (line 177) | def writable(self):
    method peek (line 182) | def peek(self, size=-1):
    method read (line 193) | def read(self, size=-1):
    method read1 (line 202) | def read1(self, size=-1):
    method readline (line 214) | def readline(self, size=-1):
    method write (line 224) | def write(self, data):
    method seek (line 237) | def seek(self, offset, whence=io.SEEK_SET):
    method tell (line 255) | def tell(self):
  function open (line 263) | def open(filename, mode="rb", *,
  function compress (line 310) | def compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None):
  function decompress (line 322) | def decompress(data, format=FORMAT_AUTO, memlimit=None, filters=None):

FILE: rd/usr/lib/python3.8/mailcap.py
  function lineno_sort_key (line 9) | def lineno_sort_key(entry):
  function getcaps (line 19) | def getcaps():
  function listmailcapfiles (line 45) | def listmailcapfiles():
  function readmailcapfile (line 63) | def readmailcapfile(fp):
  function _readmailcapfile (line 71) | def _readmailcapfile(fp, lineno):
  function parseline (line 112) | def parseline(line):
  function parsefield (line 143) | def parsefield(line, i, n):
  function findmatch (line 159) | def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):
  function lookup (line 179) | def lookup(caps, MIMEtype, key=None):
  function subst (line 192) | def subst(field, MIMEtype, filename, plist=[]):
  function findparam (line 224) | def findparam(name, plist):
  function test (line 235) | def test():
  function show (line 257) | def show(caps):

FILE: rd/usr/lib/python3.8/mimetypes.py
  class MimeTypes (line 58) | class MimeTypes:
    method __init__ (line 66) | def __init__(self, filenames=(), strict=True):
    method add_type (line 80) | def add_type(self, type, ext, strict=True):
    method guess_type (line 97) | def guess_type(self, url, strict=True):
    method guess_all_extensions (line 160) | def guess_all_extensions(self, type, strict=True):
    method guess_extension (line 179) | def guess_extension(self, type, strict=True):
    method read (line 197) | def read(self, filename, strict=True):
    method readfp (line 208) | def readfp(self, fp, strict=True):
    method read_windows_registry (line 231) | def read_windows_registry(self, strict=True):
  function guess_type (line 272) | def guess_type(url, strict=True):
  function guess_all_extensions (line 295) | def guess_all_extensions(type, strict=True):
  function guess_extension (line 312) | def guess_extension(type, strict=True):
  function add_type (line 328) | def add_type(type, ext, strict=True):
  function init (line 345) | def init(files=None):
  function read_mime_types (line 373) | def read_mime_types(file):
  function _default_mime_types (line 384) | def _default_mime_types():
  function _main (line 567) | def _main():

FILE: rd/usr/lib/python3.8/modulefinder.py
  function AddPackagePath (line 40) | def AddPackagePath(packagename, path):
  function ReplacePackage (line 51) | def ReplacePackage(oldname, newname):
  function _find_module (line 55) | def _find_module(name, path=None):
  class Module (line 100) | class Module:
    method __init__ (line 102) | def __init__(self, name, file=None, path=None):
    method __repr__ (line 115) | def __repr__(self):
  class ModuleFinder (line 124) | class ModuleFinder:
    method __init__ (line 126) | def __init__(self, path=None, debug=0, excludes=None, replace_paths=No...
    method msg (line 138) | def msg(self, level, str, *args):
    method msgin (line 147) | def msgin(self, *args):
    method msgout (line 153) | def msgout(self, *args):
    method run_script (line 159) | def run_script(self, pathname):
    method load_file (line 165) | def load_file(self, pathname):
    method import_hook (line 172) | def import_hook(self, name, caller=None, fromlist=None, level=-1):
    method determine_parent (line 183) | def determine_parent(self, caller, level=-1):
    method find_head_package (line 218) | def find_head_package(self, parent, name):
    method load_tail (line 245) | def load_tail(self, q, tail):
    method ensure_fromlist (line 260) | def ensure_fromlist(self, m, fromlist, recursive=0):
    method find_all_submodules (line 274) | def find_all_submodules(self, m):
    method import_module (line 302) | def import_module(self, partname, fqname, parent):
    method load_module (line 334) | def load_module(self, fqname, fp, pathname, file_info):
    method _add_badmodule (line 363) | def _add_badmodule(self, name, caller):
    method _safe_import_hook (line 371) | def _safe_import_hook(self, name, caller, fromlist, level=-1):
    method scan_opcodes (line 397) | def scan_opcodes(self, co):
    method scan_code (line 418) | def scan_code(self, co, m):
    method load_package (line 467) | def load_package(self, fqname, pathname):
    method add_module (line 488) | def add_module(self, fqname):
    method find_module (line 494) | def find_module(self, name, path, parent=None):
    method report (line 512) | def report(self):
    method any_missing (line 546) | def any_missing(self):
    method any_missing_maybe (line 554) | def any_missing_maybe(self):
    method replace_paths_in_code (line 600) | def replace_paths_in_code(self, co):
  function test (line 624) | def test():

FILE: rd/usr/lib/python3.8/netrc.py
  class NetrcParseError (line 10) | class NetrcParseError(Exception):
    method __init__ (line 12) | def __init__(self, msg, filename=None, lineno=None):
    method __str__ (line 18) | def __str__(self):
  class netrc (line 22) | class netrc:
    method __init__ (line 23) | def __init__(self, file=None):
    method _parse (line 32) | def _parse(self, file, fp, default_netrc):
    method authenticators (line 113) | def authenticators(self, host):
    method __repr__ (line 122) | def __repr__(self):

FILE: rd/usr/lib/python3.8/ntpath.py
  function _get_bothseps (line 34) | def _get_bothseps(path):
  function normcase (line 44) | def normcase(s):
  function isabs (line 61) | def isabs(s):
  function join (line 77) | def join(path, *paths):
  function splitdrive (line 124) | def splitdrive(p):
  function split (line 180) | def split(p):
  function splitext (line 203) | def splitext(p):
  function basename (line 214) | def basename(p):
  function dirname (line 221) | def dirname(p):
  function islink (line 228) | def islink(path):
  function lexists (line 240) | def lexists(path):
  function ismount (line 262) | def ismount(path):
  function expanduser (line 289) | def expanduser(path):
  function expandvars (line 337) | def expandvars(path):
  function normpath (line 450) | def normpath(path):
  function _abspath_fallback (line 500) | def _abspath_fallback(path):
  function abspath (line 524) | def abspath(path):
  function _readlink_deep (line 537) | def _readlink_deep(path):
  function _getfinalpathname_nonstrict (line 579) | def _getfinalpathname_nonstrict(path):
  function realpath (line 625) | def realpath(path):
  function relpath (line 678) | def relpath(path, start=None):
  function commonpath (line 734) | def commonpath(paths):

FILE: rd/usr/lib/python3.8/nturl2path.py
  function url2pathname (line 8) | def url2pathname(url):
  function pathname2url (line 45) | def pathname2url(p):

FILE: rd/usr/lib/python3.8/numbers.py
  class Number (line 12) | class Number(metaclass=ABCMeta):
  class Complex (line 32) | class Complex(Number):
    method __complex__ (line 46) | def __complex__(self):
    method __bool__ (line 49) | def __bool__(self):
    method real (line 55) | def real(self):
    method imag (line 64) | def imag(self):
    method __add__ (line 72) | def __add__(self, other):
    method __radd__ (line 77) | def __radd__(self, other):
    method __neg__ (line 82) | def __neg__(self):
    method __pos__ (line 87) | def __pos__(self):
    method __sub__ (line 91) | def __sub__(self, other):
    method __rsub__ (line 95) | def __rsub__(self, other):
    method __mul__ (line 100) | def __mul__(self, other):
    method __rmul__ (line 105) | def __rmul__(self, other):
    method __truediv__ (line 110) | def __truediv__(self, other):
    method __rtruediv__ (line 115) | def __rtruediv__(self, other):
    method __pow__ (line 120) | def __pow__(self, exponent):
    method __rpow__ (line 125) | def __rpow__(self, base):
    method __abs__ (line 130) | def __abs__(self):
    method conjugate (line 135) | def conjugate(self):
    method __eq__ (line 140) | def __eq__(self, other):
  class Real (line 147) | class Real(Complex):
    method __float__ (line 159) | def __float__(self):
    method __trunc__ (line 166) | def __trunc__(self):
    method __floor__ (line 179) | def __floor__(self):
    method __ceil__ (line 184) | def __ceil__(self):
    method __round__ (line 189) | def __round__(self, ndigits=None):
    method __divmod__ (line 197) | def __divmod__(self, other):
    method __rdivmod__ (line 205) | def __rdivmod__(self, other):
    method __floordiv__ (line 214) | def __floordiv__(self, other):
    method __rfloordiv__ (line 219) | def __rfloordiv__(self, other):
    method __mod__ (line 224) | def __mod__(self, other):
    method __rmod__ (line 229) | def __rmod__(self, other):
    method __lt__ (line 234) | def __lt__(self, other):
    method __le__ (line 241) | def __le__(self, other):
    method __complex__ (line 246) | def __complex__(self):
    method real (line 251) | def real(self):
    method imag (line 256) | def imag(self):
    method conjugate (line 260) | def conjugate(self):
  class Rational (line 267) | class Rational(Real):
    method numerator (line 274) | def numerator(self):
    method denominator (line 279) | def denominator(self):
    method __float__ (line 283) | def __float__(self):
  class Integral (line 294) | class Integral(Rational):
    method __int__ (line 300) | def __int__(self):
    method __index__ (line 304) | def __index__(self):
    method __pow__ (line 309) | def __pow__(self, exponent, modulus=None):
    method __lshift__ (line 320) | def __lshift__(self, other):
    method __rlshift__ (line 325) | def __rlshift__(self, other):
    method __rshift__ (line 330) | def __rshift__(self, other):
    method __rrshift__ (line 335) | def __rrshift__(self, other):
    method __and__ (line 340) | def __and__(self, other):
    method __rand__ (line 345) | def __rand__(self, other):
    method __xor__ (line 350) | def __xor__(self, other):
    method __rxor__ (line 355) | def __rxor__(self, other):
    method __or__ (line 360) | def __or__(self, other):
    method __ror__ (line 365) | def __ror__(self, other):
    method __invert__ (line 370) | def __invert__(self):
    method __float__ (line 375) | def __float__(self):
    method numerator (line 380) | def numerator(self):
    method denominator (line 385) | def denominator(self):

FILE: rd/usr/lib/python3.8/opcode.py
  function def_op (line 39) | def def_op(name, op):
  function name_op (line 43) | def name_op(name, op):
  function jrel_op (line 47) | def jrel_op(name, op):
  function jabs_op (line 51) | def jabs_op(name, op):

FILE: rd/usr/lib/python3.8/operator.py
  function lt (line 27) | def lt(a, b):
  function le (line 31) | def le(a, b):
  function eq (line 35) | def eq(a, b):
  function ne (line 39) | def ne(a, b):
  function ge (line 43) | def ge(a, b):
  function gt (line 47) | def gt(a, b):
  function not_ (line 53) | def not_(a):
  function truth (line 57) | def truth(a):
  function is_ (line 61) | def is_(a, b):
  function is_not (line 65) | def is_not(a, b):
  function abs (line 71) | def abs(a):
  function add (line 75) | def add(a, b):
  function and_ (line 79) | def and_(a, b):
  function floordiv (line 83) | def floordiv(a, b):
  function index (line 87) | def index(a):
  function inv (line 91) | def inv(a):
  function lshift (line 96) | def lshift(a, b):
  function mod (line 100) | def mod(a, b):
  function mul (line 104) | def mul(a, b):
  function matmul (line 108) | def matmul(a, b):
  function neg (line 112) | def neg(a):
  function or_ (line 116) | def or_(a, b):
  function pos (line 120) | def pos(a):
  function pow (line 124) | def pow(a, b):
  function rshift (line 128) | def rshift(a, b):
  function sub (line 132) | def sub(a, b):
  function truediv (line 136) | def truediv(a, b):
  function xor (line 140) | def xor(a, b):
  function concat (line 146) | def concat(a, b):
  function contains (line 153) | def contains(a, b):
  function countOf (line 157) | def countOf(a, b):
  function delitem (line 165) | def delitem(a, b):
  function getitem (line 169) | def getitem(a, b):
  function indexOf (line 173) | def indexOf(a, b):
  function setitem (line 181) | def setitem(a, b, c):
  function length_hint (line 185) | def length_hint(obj, default=0):
  class attrgetter (line 226) | class attrgetter:
    method __init__ (line 236) | def __init__(self, attr, *attrs):
    method __call__ (line 254) | def __call__(self, obj):
    method __repr__ (line 257) | def __repr__(self):
    method __reduce__ (line 262) | def __reduce__(self):
  class itemgetter (line 265) | class itemgetter:
    method __init__ (line 273) | def __init__(self, item, *items):
    method __call__ (line 285) | def __call__(self, obj):
    method __repr__ (line 288) | def __repr__(self):
    method __reduce__ (line 293) | def __reduce__(self):
  class methodcaller (line 296) | class methodcaller:
    method __init__ (line 305) | def __init__(self, name, /, *args, **kwargs):
    method __call__ (line 312) | def __call__(self, obj):
    method __repr__ (line 315) | def __repr__(self):
    method __reduce__ (line 323) | def __reduce__(self):
  function iadd (line 333) | def iadd(a, b):
  function iand (line 338) | def iand(a, b):
  function iconcat (line 343) | def iconcat(a, b):
  function ifloordiv (line 351) | def ifloordiv(a, b):
  function ilshift (line 356) | def ilshift(a, b):
  function imod (line 361) | def imod(a, b):
  function imul (line 366) | def imul(a, b):
  function imatmul (line 371) | def imatmul(a, b):
  function ior (line 376) | def ior(a, b):
  function ipow (line 381) | def ipow(a, b):
  function irshift (line 386) | def irshift(a, b):
  function isub (line 391) | def isub(a, b):
  function itruediv (line 396) | def itruediv(a, b):
  function ixor (line 401) | def ixor(a, b):

FILE: rd/usr/lib/python3.8/optparse.py
  function _repr (line 79) | def _repr(self):
  function gettext (line 92) | def gettext(message):
  function ngettext (line 95) | def ngettext(singular, plural, n):
  class OptParseError (line 103) | class OptParseError (Exception):
    method __init__ (line 104) | def __init__(self, msg):
    method __str__ (line 107) | def __str__(self):
  class OptionError (line 111) | class OptionError (OptParseError):
    method __init__ (line 117) | def __init__(self, msg, option):
    method __str__ (line 121) | def __str__(self):
  class OptionConflictError (line 127) | class OptionConflictError (OptionError):
  class OptionValueError (line 132) | class OptionValueError (OptParseError):
  class BadOptionError (line 138) | class BadOptionError (OptParseError):
    method __init__ (line 142) | def __init__(self, opt_str):
    method __str__ (line 145) | def __str__(self):
  class AmbiguousOptionError (line 148) | class AmbiguousOptionError (BadOptionError):
    method __init__ (line 152) | def __init__(self, opt_str, possibilities):
    method __str__ (line 156) | def __str__(self):
  class HelpFormatter (line 161) | class HelpFormatter:
    method __init__ (line 206) | def __init__(self,
    method set_parser (line 231) | def set_parser(self, parser):
    method set_short_opt_delimiter (line 234) | def set_short_opt_delimiter(self, delim):
    method set_long_opt_delimiter (line 240) | def set_long_opt_delimiter(self, delim):
    method indent (line 246) | def indent(self):
    method dedent (line 250) | def dedent(self):
    method format_usage (line 255) | def format_usage(self, usage):
    method format_heading (line 258) | def format_heading(self, heading):
    method _format_text (line 261) | def _format_text(self, text):
    method format_description (line 273) | def format_description(self, description):
    method format_epilog (line 279) | def format_epilog(self, epilog):
    method expand_default (line 286) | def expand_default(self, option):
    method format_option (line 296) | def format_option(self, option):
    method store_option_strings (line 331) | def store_option_strings(self, parser):
    method format_option_strings (line 349) | def format_option_strings(self, option):
  class IndentedHelpFormatter (line 368) | class IndentedHelpFormatter (HelpFormatter):
    method __init__ (line 372) | def __init__(self,
    method format_usage (line 380) | def format_usage(self, usage):
    method format_heading (line 383) | def format_heading(self, heading):
  class TitledHelpFormatter (line 387) | class TitledHelpFormatter (HelpFormatter):
    method __init__ (line 391) | def __init__(self,
    method format_usage (line 399) | def format_usage(self, usage):
    method format_heading (line 402) | def format_heading(self, heading):
  function _parse_num (line 406) | def _parse_num(val, type):
  function _parse_int (line 419) | def _parse_int(val):
  function check_builtin (line 427) | def check_builtin(option, opt, value):
  function check_choice (line 435) | def check_choice(option, opt, value):
  class Option (line 449) | class Option:
    method __init__ (line 564) | def __init__(self, *opts, **attrs):
    method _check_opt_strings (line 583) | def _check_opt_strings(self, opts):
    method _set_opt_strings (line 592) | def _set_opt_strings(self, opts):
    method _set_attrs (line 613) | def _set_attrs(self, attrs):
    method _check_action (line 632) | def _check_action(self):
    method _check_type (line 638) | def _check_type(self):
    method _check_choice (line 662) | def _check_choice(self):
    method _check_dest (line 675) | def _check_dest(self):
    method _check_const (line 690) | def _check_const(self):
    method _check_nargs (line 696) | def _check_nargs(self):
    method _check_callback (line 705) | def _check_callback(self):
    method __str__ (line 744) | def __str__(self):
    method takes_value (line 749) | def takes_value(self):
    method get_opt_string (line 752) | def get_opt_string(self):
    method check_value (line 761) | def check_value(self, opt, value):
    method convert_value (line 768) | def convert_value(self, opt, value):
    method process (line 775) | def process(self, opt, value, values, parser):
    method take_action (line 787) | def take_action(self, action, dest, opt, value, values, parser):
  class Values (line 823) | class Values:
    method __init__ (line 825) | def __init__(self, defaults=None):
    method __str__ (line 830) | def __str__(self):
    method __eq__ (line 835) | def __eq__(self, other):
    method _update_careful (line 843) | def _update_careful(self, dict):
    method _update_loose (line 856) | def _update_loose(self, dict):
    method _update (line 864) | def _update(self, dict, mode):
    method read_module (line 872) | def read_module(self, modname, mode="careful"):
    method read_file (line 877) | def read_file(self, filename, mode="careful"):
    method ensure_value (line 882) | def ensure_value(self, attr, value):
  class OptionContainer (line 888) | class OptionContainer:
    method __init__ (line 920) | def __init__(self, option_class, conflict_handler, description):
    method _create_option_mappings (line 931) | def _create_option_mappings(self):
    method _share_option_mappings (line 940) | def _share_option_mappings(self, parser):
    method set_conflict_handler (line 947) | def set_conflict_handler(self, handler):
    method set_description (line 952) | def set_description(self, description):
    method get_description (line 955) | def get_description(self):
    method destroy (line 959) | def destroy(self):
    method _check_conflict (line 968) | def _check_conflict(self, option):
    method add_option (line 995) | def add_option(self, *args, **kwargs):
    method add_options (line 1025) | def add_options(self, option_list):
    method get_option (line 1031) | def get_option(self, opt_str):
    method has_option (line 1035) | def has_option(self, opt_str):
    method remove_option (line 1039) | def remove_option(self, opt_str):
    method format_option_help (line 1055) | def format_option_help(self, formatter):
    method format_description (line 1064) | def format_description(self, formatter):
    method format_help (line 1067) | def format_help(self, formatter):
  class OptionGroup (line 1076) | class OptionGroup (OptionContainer):
    method __init__ (line 1078) | def __init__(self, parser, title, description=None):
    method _create_option_list (line 1084) | def _create_option_list(self):
    method set_title (line 1088) | def set_title(self, title):
    method destroy (line 1091) | def destroy(self):
    method format_help (line 1098) | def format_help(self, formatter):
  class OptionParser (line 1106) | class OptionParser (OptionContainer):
    method __init__ (line 1178) | def __init__(self,
    method destroy (line 1212) | def destroy(self):
    method _create_option_list (line 1230) | def _create_option_list(self):
    method _add_help_option (line 1235) | def _add_help_option(self):
    method _add_version_option (line 1240) | def _add_version_option(self):
    method _populate_option_list (line 1245) | def _populate_option_list(self, option_list, add_help=True):
    method _init_parsing_state (line 1255) | def _init_parsing_state(self):
    method set_usage (line 1264) | def set_usage(self, usage):
    method enable_interspersed_args (line 1275) | def enable_interspersed_args(self):
    method disable_interspersed_args (line 1283) | def disable_interspersed_args(self):
    method set_process_default_values (line 1291) | def set_process_default_values(self, process):
    method set_default (line 1294) | def set_default(self, dest, value):
    method set_defaults (line 1297) | def set_defaults(self, **kwargs):
    method _get_all_options (line 1300) | def _get_all_options(self):
    method get_default_values (line 1306) | def get_default_values(self):
    method add_option_group (line 1323) | def add_option_group(self, *args, **kwargs):
    method get_option_group (line 1339) | def get_option_group(self, opt_str):
    method _get_args (line 1349) | def _get_args(self, args):
    method parse_args (line 1355) | def parse_args(self, args=None, values=None):
    method check_values (line 1394) | def check_values(self, values, args):
    method _process_args (line 1407) | def _process_args(self, largs, rargs, values):
    method _match_long_opt (line 1458) | def _match_long_opt(self, opt):
    method _process_long_opt (line 1467) | def _process_long_opt(self, rargs, values):
    method _process_short_opts (line 1503) | def _process_short_opts(self, rargs, values):
    method get_prog_name (line 1544) | def get_prog_name(self):
    method expand_prog_name (line 1550) | def expand_prog_name(self, s):
    method get_description (line 1553) | def get_description(self):
    method exit (line 1556) | def exit(self, status=0, msg=None):
    method error (line 1561) | def error(self, msg):
    method get_usage (line 1571) | def get_usage(self):
    method print_usage (line 1578) | def print_usage(self, file=None):
    method get_version (line 1590) | def get_version(self):
    method print_version (line 1596) | def print_version(self, file=None):
    method format_option_help (line 1607) | def format_option_help(self, formatter=None):
    method format_epilog (line 1624) | def format_epilog(self, formatter):
    method format_help (line 1627) | def format_help(self, formatter=None):
    method print_help (line 1639) | def print_help(self, file=None):
  function _match_abbrev (line 1652) | def _match_abbrev(s, wordmap):

FILE: rd/usr/lib/python3.8/os.py
  function _exists (line 39) | def _exists(name):
  function _get_exports_list (line 42) | def _get_exports_list(module):
  function _add (line 102) | def _add(str, fn):
  function makedirs (line 198) | def makedirs(name, mode=0o777, exist_ok=False):
  function removedirs (line 230) | def removedirs(name):
  function renames (line 252) | def renames(old, new):
  function walk (line 280) | def walk(top, topdown=True, onerror=None, followlinks=False):
  function fwalk (line 425) | def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False,...
  function _fwalk (line 473) | def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks):
  function execl (line 531) | def execl(file, *args):
  function execle (line 538) | def execle(file, *args):
  function execlp (line 546) | def execlp(file, *args):
  function execlpe (line 553) | def execlpe(file, *args):
  function execvp (line 562) | def execvp(file, args):
  function execvpe (line 570) | def execvpe(file, args, env):
  function _execvpe (line 581) | def _execvpe(file, args, env=None):
  function get_exec_path (line 613) | def get_exec_path(env=None):
  class _Environ (line 660) | class _Environ(MutableMapping):
    method __init__ (line 661) | def __init__(self, data, encodekey, decodekey, encodevalue, decodevalu...
    method __getitem__ (line 670) | def __getitem__(self, key):
    method __setitem__ (line 678) | def __setitem__(self, key, value):
    method __delitem__ (line 684) | def __delitem__(self, key):
    method __iter__ (line 693) | def __iter__(self):
    method __len__ (line 699) | def __len__(self):
    method __repr__ (line 702) | def __repr__(self):
    method copy (line 707) | def copy(self):
    method setdefault (line 710) | def setdefault(self, key, value):
  function _createenviron (line 731) | def _createenviron():
  function getenv (line 766) | def getenv(key, default=None):
  function _check_bytes (line 776) | def _check_bytes(value):
  function getenvb (line 788) | def getenvb(key, default=None):
  function _fscodec (line 796) | def _fscodec():
  function _spawnvef (line 841) | def _spawnvef(mode, file, args, env, func):
  function spawnv (line 872) | def spawnv(mode, file, args):
  function spawnve (line 881) | def spawnve(mode, file, args, env):
  function spawnvp (line 893) | def spawnvp(mode, file, args):
  function spawnvpe (line 903) | def spawnvpe(mode, file, args, env):
  function spawnl (line 921) | def spawnl(mode, file, *args):
  function spawnle (line 930) | def spawnle(mode, file, *args):
  function spawnlp (line 948) | def spawnlp(mode, file, *args):
  function spawnlpe (line 958) | def spawnlpe(mode, file, *args):
  function popen (line 974) | def popen(cmd, mode="r", buffering=-1):
  class _wrap_close (line 996) | class _wrap_close:
    method __init__ (line 997) | def __init__(self, stream, proc):
    method close (line 1000) | def close(self):
    method __enter__ (line 1009) | def __enter__(self):
    method __exit__ (line 1011) | def __exit__(self, *args):
    method __getattr__ (line 1013) | def __getattr__(self, name):
    method __iter__ (line 1015) | def __iter__(self):
  function fdopen (line 1019) | def fdopen(fd, *args, **kwargs):
  function _fspath (line 1028) | def _fspath(path):
  class PathLike (line 1064) | class PathLike(abc.ABC):
    method __fspath__ (line 1069) | def __fspath__(self):
    method __subclasshook__ (line 1074) | def __subclasshook__(cls, subclass):
  class _AddedDllDirectory (line 1081) | class _AddedDllDirectory:
    method __init__ (line 1082) | def __init__(self, path, cookie, remove_dll_directory):
    method close (line 1086) | def close(self):
    method __enter__ (line 1089) | def __enter__(self):
    method __exit__ (line 1091) | def __exit__(self, *args):
    method __repr__ (line 1093) | def __repr__(self):
  function add_dll_directory (line 1098) | def add_dll_directory(path):

FILE: rd/usr/lib/python3.8/pathlib.py
  function _ignore_error (line 45) | def _ignore_error(exception):
  function _is_wildcard_pattern (line 50) | def _is_wildcard_pattern(pat):
  class _Flavour (line 56) | class _Flavour(object):
    method __init__ (line 60) | def __init__(self):
    method parse_parts (line 63) | def parse_parts(self, parts):
    method join_parsed_parts (line 101) | def join_parsed_parts(self, drv, root, parts, drv2, root2, parts2):
  class _WindowsFlavour (line 119) | class _WindowsFlavour(_Flavour):
    method splitroot (line 145) | def splitroot(self, part, sep=sep):
    method casefold (line 184) | def casefold(self, s):
    method casefold_parts (line 187) | def casefold_parts(self, parts):
    method compile_pattern (line 190) | def compile_pattern(self, pattern):
    method resolve (line 193) | def resolve(self, path, strict=False):
    method _split_extended_path (line 217) | def _split_extended_path(self, s, ext_prefix=ext_namespace_prefix):
    method _ext_to_normal (line 227) | def _ext_to_normal(self, s):
    method is_reserved (line 231) | def is_reserved(self, parts):
    method make_uri (line 243) | def make_uri(self, path):
    method gethomedir (line 255) | def gethomedir(self, username):
  class _PosixFlavour (line 284) | class _PosixFlavour(_Flavour):
    method splitroot (line 292) | def splitroot(self, part, sep=sep):
    method casefold (line 307) | def casefold(self, s):
    method casefold_parts (line 310) | def casefold_parts(self, parts):
    method compile_pattern (line 313) | def compile_pattern(self, pattern):
    method resolve (line 316) | def resolve(self, path, strict=False):
    method is_reserved (line 361) | def is_reserved(self, parts):
    method make_uri (line 364) | def make_uri(self, path):
    method gethomedir (line 370) | def gethomedir(self, username):
  class _Accessor (line 390) | class _Accessor:
  class _NormalAccessor (line 395) | class _NormalAccessor(_Accessor):
    method lchmod (line 412) | def lchmod(self, pathobj, mode):
    method link_to (line 423) | def link_to(self, target):
    method symlink (line 436) | def symlink(a, b, target_is_directory):
    method symlink (line 441) | def symlink(a, b, target_is_directory):
    method readlink (line 447) | def readlink(self, path):
  function _make_selector (line 458) | def _make_selector(pattern_parts, flavour):
  class _Selector (line 475) | class _Selector:
    method __init__ (line 479) | def __init__(self, child_parts, flavour):
    method select_from (line 488) | def select_from(self, parent_path):
  class _TerminatingSelector (line 500) | class _TerminatingSelector:
    method _select_from (line 502) | def _select_from(self, parent_path, is_dir, exists, scandir):
  class _PreciseSelector (line 506) | class _PreciseSelector(_Selector):
    method __init__ (line 508) | def __init__(self, name, child_parts, flavour):
    method _select_from (line 512) | def _select_from(self, parent_path, is_dir, exists, scandir):
  class _WildcardSelector (line 522) | class _WildcardSelector(_Selector):
    method __init__ (line 524) | def __init__(self, pat, child_parts, flavour):
    method _select_from (line 528) | def _select_from(self, parent_path, is_dir, exists, scandir):
  class _RecursiveWildcardSelector (line 553) | class _RecursiveWildcardSelector(_Selector):
    method __init__ (line 555) | def __init__(self, pat, child_parts, flavour):
    method _iterate_directories (line 558) | def _iterate_directories(self, parent_path, is_dir, scandir):
    method _select_from (line 577) | def _select_from(self, parent_path, is_dir, exists, scandir):
  class _PathParents (line 597) | class _PathParents(Sequence):
    method __init__ (line 602) | def __init__(self, path):
    method __len__ (line 609) | def __len__(self):
    method __getitem__ (line 615) | def __getitem__(self, idx):
    method __repr__ (line 621) | def __repr__(self):
  class PurePath (line 625) | class PurePath(object):
    method __new__ (line 639) | def __new__(cls, *args):
    method __reduce__ (line 649) | def __reduce__(self):
    method _parse_args (line 655) | def _parse_args(cls, args):
    method _from_parts (line 675) | def _from_parts(cls, args, init=True):
    method _from_parsed_parts (line 688) | def _from_parsed_parts(cls, drv, root, parts, init=True):
    method _format_parsed_parts (line 698) | def _format_parsed_parts(cls, drv, root, parts):
    method _init (line 704) | def _init(self):
    method _make_child (line 708) | def _make_child(self, args):
    method __str__ (line 714) | def __str__(self):
    method __fspath__ (line 724) | def __fspath__(self):
    method as_posix (line 727) | def as_posix(self):
    method __bytes__ (line 733) | def __bytes__(self):
    method __repr__ (line 738) | def __repr__(self):
    method as_uri (line 741) | def as_uri(self):
    method _cparts (line 748) | def _cparts(self):
    method __eq__ (line 756) | def __eq__(self, other):
    method __hash__ (line 761) | def __hash__(self):
    method __lt__ (line 768) | def __lt__(self, other):
    method __le__ (line 773) | def __le__(self, other):
    method __gt__ (line 778) | def __gt__(self, other):
    method __ge__ (line 783) | def __ge__(self, other):
    method anchor (line 795) | def anchor(self):
    method name (line 801) | def name(self):
    method suffix (line 809) | def suffix(self):
    method suffixes (line 823) | def suffixes(self):
    method stem (line 836) | def stem(self):
    method with_name (line 845) | def with_name(self, name):
    method with_suffix (line 856) | def with_suffix(self, suffix):
    method relative_to (line 877) | def relative_to(self, *other):
    method parts (line 910) | def parts(self):
    method joinpath (line 921) | def joinpath(self, *args):
    method __truediv__ (line 929) | def __truediv__(self, key):
    method __rtruediv__ (line 935) | def __rtruediv__(self, key):
    method parent (line 942) | def parent(self):
    method parents (line 952) | def parents(self):
    method is_absolute (line 956) | def is_absolute(self):
    method is_reserved (line 963) | def is_reserved(self):
    method match (line 968) | def match(self, path_pattern):
  class PurePosixPath (line 998) | class PurePosixPath(PurePath):
  class PureWindowsPath (line 1008) | class PureWindowsPath(PurePath):
  class Path (line 1021) | class Path(PurePath):
    method __new__ (line 1035) | def __new__(cls, *args, **kwargs):
    method _init (line 1045) | def _init(self,
    method _make_child_relpath (line 1055) | def _make_child_relpath(self, part):
    method __enter__ (line 1061) | def __enter__(self):
    method __exit__ (line 1066) | def __exit__(self, t, v, tb):
    method _raise_closed (line 1069) | def _raise_closed(self):
    method _opener (line 1072) | def _opener(self, name, flags, mode=0o666):
    method _raw_open (line 1076) | def _raw_open(self, flags, mode=0o777):
    method cwd (line 1088) | def cwd(cls):
    method home (line 1095) | def home(cls):
    method samefile (line 1101) | def samefile(self, other_path):
    method iterdir (line 1112) | def iterdir(self):
    method glob (line 1126) | def glob(self, pattern):
    method rglob (line 1139) | def rglob(self, pattern):
    method absolute (line 1151) | def absolute(self):
    method resolve (line 1169) | def resolve(self, strict=False):
    method stat (line 1189) | def stat(self):
    method owner (line 1196) | def owner(self):
    method group (line 1203) | def group(self):
    method open (line 1210) | def open(self, mode='r', buffering=-1, encoding=None,
    method read_bytes (line 1221) | def read_bytes(self):
    method read_text (line 1228) | def read_text(self, encoding=None, errors=None):
    method write_bytes (line 1235) | def write_bytes(self, data):
    method write_text (line 1244) | def write_text(self, data, encoding=None, errors=None):
    method touch (line 1254) | def touch(self, mode=0o666, exist_ok=True):
    method mkdir (line 1277) | def mkdir(self, mode=0o777, parents=False, exist_ok=False):
    method chmod (line 1296) | def chmod(self, mode):
    method lchmod (line 1304) | def lchmod(self, mode):
    method unlink (line 1313) | def unlink(self, missing_ok=False):
    method rmdir (line 1326) | def rmdir(self):
    method lstat (line 1334) | def lstat(self):
    method link_to (line 1343) | def link_to(self, target):
    method rename (line 1351) | def rename(self, target):
    method replace (line 1361) | def replace(self, target):
    method symlink_to (line 1372) | def symlink_to(self, target, target_is_directory=False):
    method exists (line 1383) | def exists(self):
    method is_dir (line 1398) | def is_dir(self):
    method is_file (line 1414) | def is_file(self):
    method is_mount (line 1431) | def is_mount(self):
    method is_symlink (line 1452) | def is_symlink(self):
    method is_block_device (line 1467) | def is_block_device(self):
    method is_char_device (line 1483) | def is_char_device(self):
    method is_fifo (line 1499) | def is_fifo(self):
    method is_socket (line 1515) | def is_socket(self):
    method expanduser (line 1531) | def expanduser(self):
  class PosixPath (line 1543) | class PosixPath(Path, PurePosixPath):
  class WindowsPath (line 1550) | class WindowsPath(Path, PureWindowsPath):
    method owner (line 1557) | def owner(self):
    method group (line 1560) | def group(self):
    method is_mount (line 1563) | def is_mount(self):

FILE: rd/usr/lib/python3.8/pipes.py
  class Template (line 82) | class Template:
    method __init__ (line 85) | def __init__(self):
    method __repr__ (line 90) | def __repr__(self):
    method reset (line 94) | def reset(self):
    method clone (line 98) | def clone(self):
    method debug (line 106) | def debug(self, flag):
    method append (line 110) | def append(self, cmd, kind):
    method prepend (line 126) | def prepend(self, cmd, kind):
    method open (line 142) | def open(self, file, rw):
    method open_r (line 152) | def open_r(self, file):
    method open_w (line 162) | def open_w(self, file):
    method copy (line 170) | def copy(self, infile, outfile):
    method makepipeline (line 173) | def makepipeline(self, infile, outfile):
  function makepipeline (line 181) | def makepipeline(infile, steps, outfile):

FILE: rd/usr/lib/python3.8/pkgutil.py
  function _get_spec (line 26) | def _get_spec(finder, name):
  function read_code (line 40) | def read_code(stream):
  function walk_packages (line 53) | def walk_packages(path=None, prefix='', onerror=None):
  function iter_modules (line 110) | def iter_modules(path=None, prefix=''):
  function iter_importer_modules (line 137) | def iter_importer_modules(importer, prefix=''):
  function _iter_file_finder_modules (line 144) | def _iter_file_finder_modules(importer, prefix=''):
  function _import_imp (line 188) | def _import_imp():
  class ImpImporter (line 194) | class ImpImporter:
    method __init__ (line 205) | def __init__(self, path=None):
    method find_module (line 212) | def find_module(self, fullname, path=None):
    method iter_modules (line 227) | def iter_modules(self, prefix=''):
  class ImpLoader (line 268) | class ImpLoader:
    method __init__ (line 273) | def __init__(self, fullname, file, filename, etc):
    method load_module (line 282) | def load_module(self, fullname):
    method get_data (line 293) | def get_data(self, pathname):
    method _reopen (line 297) | def _reopen(self):
    method _fix_name (line 305) | def _fix_name(self, fullname):
    method is_package (line 313) | def is_package(self, fullname):
    method get_code (line 317) | def get_code(self, fullname=None):
    method get_source (line 334) | def get_source(self, fullname=None):
    method _get_delegate (line 352) | def _get_delegate(self):
    method get_filename (line 357) | def get_filename(self, fullname=None):
  function iter_zipimport_modules (line 371) | def iter_zipimport_modules(importer, prefix=''):
  function get_importer (line 405) | def get_importer(path_item):
  function iter_importers (line 429) | def iter_importers(fullname=""):
  function get_loader (line 458) | def get_loader(module_or_name):
  function find_loader (line 482) | def find_loader(fullname):
  function extend_path (line 503) | def extend_path(path, name):
  function get_data (line 597) | def get_data(package, resource):

FILE: rd/usr/lib/python3.8/platform.py
  function _comparable_version (line 139) | def _comparable_version(version):
  function libc_ver (line 159) | def libc_ver(executable=None, lib='', version='', chunksize=16384):
  function _norm_version (line 230) | def _norm_version(version, build=''):
  function _syscmd_ver (line 260) | def _syscmd_ver(system='', release='', version='',
  function win32_is_iot (line 337) | def win32_is_iot():
  function win32_edition (line 340) | def win32_edition():
  function win32_ver (line 358) | def win32_ver(release='', version='', csd='', ptype=''):
  function _mac_ver_xml (line 406) | def _mac_ver_xml():
  function mac_ver (line 428) | def mac_ver(release='', versioninfo=('', '', ''), machine=''):
  function _java_getprop (line 447) | def _java_getprop(name, default):
  function java_ver (line 458) | def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '',...
  function system_alias (line 493) | def system_alias(system, release, version):
  function _platform (line 545) | def _platform(*args):
  function _node (line 577) | def _node(default=''):
  function _follow_symlinks (line 592) | def _follow_symlinks(filepath):
  function _syscmd_uname (line 603) | def _syscmd_uname(option, default=''):
  function _syscmd_file (line 620) | def _syscmd_file(target, default=''):
  function architecture (line 661) | def architecture(executable=sys.executable, bits='', linkage=''):
  function uname (line 746) | def uname():
  function system (line 884) | def system():
  function node (line 893) | def node():
  function release (line 903) | def release():
  function version (line 912) | def version():
  function machine (line 921) | def machine():
  function processor (line 930) | def processor():
  function _sys_version (line 972) | def _sys_version(sys_version=None):
  function python_implementation (line 1076) | def python_implementation():
  function python_version (line 1089) | def python_version():
  function python_version_tuple (line 1099) | def python_version_tuple():
  function python_branch (line 1110) | def python_branch():
  function python_revision (line 1124) | def python_revision():
  function python_build (line 1137) | def python_build():
  function python_compiler (line 1145) | def python_compiler():
  function platform (line 1157) | def platform(aliased=0, terse=0):

FILE: rd/usr/lib/python3.8/plistlib.py
  function _maybe_open (line 80) | def _maybe_open(pathOrFile, mode):
  function readPlist (line 89) | def readPlist(pathOrFile):
  function writePlist (line 102) | def writePlist(value, pathOrFile):
  function readPlistFromBytes (line 115) | def readPlistFromBytes(data):
  function writePlistToBytes (line 126) | def writePlistToBytes(value):
  class Data (line 139) | class Data:
    method __init__ (line 146) | def __init__(self, data):
    method fromBase64 (line 152) | def fromBase64(cls, data):
    method asBase64 (line 157) | def asBase64(self, maxlinelength=76):
    method __eq__ (line 160) | def __eq__(self, other):
    method __repr__ (line 168) | def __repr__(self):
  class UID (line 178) | class UID:
    method __init__ (line 179) | def __init__(self, data):
    method __index__ (line 188) | def __index__(self):
    method __repr__ (line 191) | def __repr__(self):
    method __reduce__ (line 194) | def __reduce__(self):
    method __eq__ (line 197) | def __eq__(self, other):
    method __hash__ (line 202) | def __hash__(self):
  function _encode_base64 (line 223) | def _encode_base64(s, maxlinelength=76):
  function _decode_base64 (line 232) | def _decode_base64(s):
  function _date_from_string (line 245) | def _date_from_string(s):
  function _date_to_string (line 257) | def _date_to_string(d):
  function _escape (line 263) | def _escape(text):
  class _PlistParser (line 275) | class _PlistParser:
    method __init__ (line 276) | def __init__(self, use_builtin_types, dict_type):
    method parse (line 283) | def parse(self, fileobj):
    method handle_begin_element (line 291) | def handle_begin_element(self, element, attrs):
    method handle_end_element (line 297) | def handle_end_element(self, element):
    method handle_data (line 302) | def handle_data(self, data):
    method add_object (line 305) | def add_object(self, value):
    method get_data (line 321) | def get_data(self):
    method begin_dict (line 328) | def begin_dict(self, attrs):
    method end_dict (line 333) | def end_dict(self):
    method end_key (line 339) | def end_key(self):
    method begin_array (line 345) | def begin_array(self, attrs):
    method end_array (line 350) | def end_array(self):
    method end_true (line 353) | def end_true(self):
    method end_false (line 356) | def end_false(self):
    method end_integer (line 359) | def end_integer(self):
    method end_real (line 362) | def end_real(self):
    method end_string (line 365) | def end_string(self):
    method end_data (line 368) | def end_data(self):
    method end_date (line 375) | def end_date(self):
  class _DumbXMLWriter (line 379) | class _DumbXMLWriter:
    method __init__ (line 380) | def __init__(self, file, indent_level=0, indent="\t"):
    method begin_element (line 386) | def begin_element(self, element):
    method end_element (line 391) | def end_element(self, element):
    method simple_element (line 397) | def simple_element(self, element, value=None):
    method writeln (line 405) | def writeln(self, line):
  class _PlistWriter (line 417) | class _PlistWriter(_DumbXMLWriter):
    method __init__ (line 418) | def __init__(
    method write (line 428) | def write(self, value):
    method write_value (line 433) | def write_value(self, value):
    method write_data (line 470) | def write_data(self, data):
    method write_bytes (line 473) | def write_bytes(self, data):
    method write_dict (line 486) | def write_dict(self, d):
    method write_array (line 506) | def write_array(self, array):
  function _is_fmt_xml (line 517) | def _is_fmt_xml(header):
  class InvalidFileException (line 550) | class InvalidFileException (ValueError):
    method __init__ (line 551) | def __init__(self, message="Invalid file"):
  class _BinaryPlistParser (line 558) | class _BinaryPlistParser:
    method __init__ (line 566) | def __init__(self, use_builtin_types, dict_type):
    method parse (line 570) | def parse(self, fp):
    method _get_size (line 595) | def _get_size(self, tokenL):
    method _read_ints (line 605) | def _read_ints(self, n, size):
    method _read_refs (line 615) | def _read_refs(self, n):
    method _read_object (line 618) | def _read_object(self, ref):
  function _count_to_size (line 712) | def _count_to_size(count):
  class _BinaryPlistWriter (line 727) | class _BinaryPlistWriter (object):
    method __init__ (line 728) | def __init__(self, fp, sort_keys, skipkeys):
    method write (line 733) | def write(self, value):
    method _flatten (line 778) | def _flatten(self, value):
    method _getrefnum (line 826) | def _getrefnum(self, value):
    method _write_size (line 834) | def _write_size(self, token, size):
    method _write_object (line 850) | def _write_object(self, value):
  function _is_fmt_binary (line 951) | def _is_fmt_binary(header):
  function load (line 973) | def load(fp, *, fmt=None, use_builtin_types=True, dict_type=dict):
  function loads (line 995) | def loads(value, *, fmt=None, use_builtin_types=True, dict_type=dict):
  function dump (line 1004) | def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False):
  function dumps (line 1015) | def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True):

FILE: rd/usr/lib/python3.8/poplib.py
  class error_proto (line 31) | class error_proto(Exception): pass
  class POP3 (line 51) | class POP3:
    method __init__ (line 98) | def __init__(self, host, port=POP3_PORT,
    method _create_socket (line 109) | def _create_socket(self, timeout):
    method _putline (line 112) | def _putline(self, line):
    method _putcmd (line 120) | def _putcmd(self, line):
    method _getline (line 130) | def _getline(self):
    method _getresp (line 151) | def _getresp(self):
    method _getlongresp (line 161) | def _getlongresp(self):
    method _shortcmd (line 177) | def _shortcmd(self, line):
    method _longcmd (line 184) | def _longcmd(self, line):
    method getwelcome (line 191) | def getwelcome(self):
    method set_debuglevel (line 195) | def set_debuglevel(self, level):
    method user (line 201) | def user(self, user):
    method pass_ (line 209) | def pass_(self, pswd):
    method stat (line 219) | def stat(self):
    method list (line 232) | def list(self, which=None):
    method retr (line 246) | def retr(self, which):
    method dele (line 254) | def dele(self, which):
    method noop (line 262) | def noop(self):
    method rset (line 270) | def rset(self):
    method quit (line 275) | def quit(self):
    method close (line 281) | def close(self):
    method rpop (line 309) | def rpop(self, user):
    method apop (line 316) | def apop(self, user, password):
    method top (line 337) | def top(self, which, howmuch):
    method uidl (line 346) | def uidl(self, which=None):
    method utf8 (line 358) | def utf8(self):
    method capa (line 364) | def capa(self):
    method stls (line 393) | def stls(self, context=None):
  class POP3_SSL (line 417) | class POP3_SSL(POP3):
    method __init__ (line 432) | def __init__(self, host, port=POP3_SSL_PORT, keyfile=None, certfile=None,
    method _create_socket (line 452) | def _create_socket(self, timeout):
    method stls (line 458) | def stls(self, keyfile=None, certfile=None, context=None):

FILE: rd/usr/lib/python3.8/posixpath.py
  function _get_sep (line 41) | def _get_sep(path):
  function normcase (line 52) | def normcase(s):
  function isabs (line 60) | def isabs(s):
  function join (line 71) | def join(a, *p):
  function split (line 100) | def split(p):
  function splitext (line 117) | def splitext(p):
  function splitdrive (line 131) | def splitdrive(p):
  function basename (line 140) | def basename(p):
  function dirname (line 150) | def dirname(p):
  function islink (line 164) | def islink(path):
  function lexists (line 174) | def lexists(path):
  function ismount (line 186) | def ismount(path):
  function expanduser (line 228) | def expanduser(path):
  function expandvars (line 281) | def expandvars(path):
  function normpath (line 334) | def normpath(path):
  function abspath (line 372) | def abspath(path):
  function realpath (line 387) | def realpath(filename):
  function _joinrealpath (line 396) | def _joinrealpath(path, rest, seen):
  function relpath (line 449) | def relpath(path, start=None):
  function commonpath (line 490) | def commonpath(paths):

FILE: rd/usr/lib/python3.8/pprint.py
  function pprint (line 47) | def pprint(object, stream=None, indent=1, width=80, depth=None, *,
  function pformat (line 55) | def pformat(object, indent=1, width=80, depth=None, *,
  function pp (line 61) | def pp(object, *args, sort_dicts=False, **kwargs):
  function saferepr (line 65) | def saferepr(object):
  function isreadable (line 69) | def isreadable(object):
  function isrecursive (line 73) | def isrecursive(object):
  class _safe_key (line 77) | class _safe_key:
    method __init__ (line 89) | def __init__(self, obj):
    method __lt__ (line 92) | def __lt__(self, other):
  function _safe_tuple (line 99) | def _safe_tuple(t):
  class PrettyPrinter (line 103) | class PrettyPrinter:
    method __init__ (line 104) | def __init__(self, indent=1, width=80, depth=None, stream=None, *,
    method pprint (line 147) | def pprint(self, object):
    method pformat (line 151) | def pformat(self, object):
    method isrecursive (line 156) | def isrecursive(self, object):
    method isreadable (line 159) | def isreadable(self, object):
    method _format (line 163) | def _format(self, object, stream, indent, allowance, context, level):
    method _pprint_dict (line 189) | def _pprint_dict(self, object, stream, indent, allowance, context, lev...
    method _pprint_ordered_dict (line 206) | def _pprint_ordered_dict(self, object, stream, indent, allowance, cont...
    method _pprint_list (line 219) | def _pprint_list(self, object, stream, indent, allowance, context, lev...
    method _pprint_tuple (line 227) | def _pprint_tuple(self, object, stream, indent, allowance, context, le...
    method _pprint_set (line 236) | def _pprint_set(self, object, stream, indent, allowance, context, level):
    method _pprint_str (line 256) | def _pprint_str(self, object, stream, indent, allowance, context, level):
    method _pprint_bytes (line 307) | def _pprint_bytes(self, object, stream, indent, allowance, context, le...
    method _pprint_bytearray (line 328) | def _pprint_bytearray(self, object, stream, indent, allowance, context...
    method _pprint_mappingproxy (line 337) | def _pprint_mappingproxy(self, object, stream, indent, allowance, cont...
    method _format_dict_items (line 345) | def _format_dict_items(self, items, stream, indent, allowance, context,
    method _format_items (line 362) | def _format_items(self, items, stream, indent, allowance, context, lev...
    method _repr (line 403) | def _repr(self, object, context, level):
    method format (line 412) | def format(self, object, context, maxlevels, level):
    method _pprint_default_dict (line 419) | def _pprint_default_dict(self, object, stream, indent, allowance, cont...
    method _pprint_counter (line 432) | def _pprint_counter(self, object, stream, indent, allowance, context, ...
    method _pprint_chain_map (line 448) | def _pprint_chain_map(self, object, stream, indent, allowance, context...
    method _pprint_deque (line 465) | def _pprint_deque(self, object, stream, indent, allowance, context, le...
    method _pprint_user_dict (line 485) | def _pprint_user_dict(self, object, stream, indent, allowance, context...
    method _pprint_user_list (line 490) | def _pprint_user_list(self, object, stream, indent, allowance, context...
    method _pprint_user_string (line 495) | def _pprint_user_string(self, object, stream, indent, allowance, conte...
  function _safe_repr (line 502) | def _safe_repr(object, context, maxlevels, level, sort_dicts):
  function _recursion (line 575) | def _recursion(object):
  function _perfcheck (line 580) | def _perfcheck(object=None):
  function _wrap_bytes_repr (line 593) | def _wrap_bytes_repr(object, width, allowance):

FILE: rd/usr/lib/python3.8/profile.py
  class _Utils (line 41) | class _Utils:
    method __init__ (line 47) | def __init__(self, profiler):
    method run (line 50) | def run(self, statement, filename, sort):
    method runctx (line 59) | def runctx(self, statement, globals, locals, filename, sort):
    method _show (line 68) | def _show(self, prof, filename, sort):
  function run (line 80) | def run(statement, filename=None, sort=-1):
  function runctx (line 93) | def runctx(statement, globals, locals, filename=None, sort=-1):
  class Profile (line 102) | class Profile:
    method __init__ (line 143) | def __init__(self, timer=None, bias=None):
    method trace_dispatch (line 182) | def trace_dispatch(self, frame, event, arg):
    method trace_dispatch_i (line 200) | def trace_dispatch_i(self, frame, event, arg):
    method trace_dispatch_mac (line 215) | def trace_dispatch_mac(self, frame, event, arg):
    method trace_dispatch_l (line 229) | def trace_dispatch_l(self, frame, event, arg):
    method trace_dispatch_exception (line 248) | def trace_dispatch_exception(self, frame, t):
    method trace_dispatch_call (line 256) | def trace_dispatch_call(self, frame, t):
    method trace_dispatch_c_call (line 278) | def trace_dispatch_c_call (self, frame, t):
    method trace_dispatch_return (line 289) | def trace_dispatch_return(self, frame, t):
    method set_cmd (line 343) | def set_cmd(self, cmd):
    class fake_code (line 348) | class fake_code:
      method __init__ (line 349) | def __init__(self, filename, line, name):
      method __repr__ (line 355) | def __repr__(self):
    class fake_frame (line 358) | class fake_frame:
      method __init__ (line 359) | def __init__(self, code, prior):
    method simulate_call (line 363) | def simulate_call(self, name):
    method simulate_cmd_complete (line 375) | def simulate_cmd_complete(self):
    method print_stats (line 386) | def print_stats(self, sort=-1):
    method dump_stats (line 391) | def dump_stats(self, file):
    method create_stats (line 396) | def create_stats(self):
    method snapshot_stats (line 400) | def snapshot_stats(self):
    method run (line 413) | def run(self, cmd):
    method runctx (line 418) | def runctx(self, cmd, globals, locals):
    method runcall (line 428) | def runcall(*args, **kw):
    method calibrate (line 493) | def calibrate(self, m, verbose=0):
    method _calibrate_inner (line 504) | def _calibrate_inner(self, m, verbose):
  function main (line 568) | def main():

FILE: rd/usr/lib/python3.8/pstats.py
  class SortKey (line 34) | class SortKey(str, Enum):
    method __new__ (line 45) | def __new__(cls, *values):
  class Stats (line 55) | class Stats:
    method __init__ (line 89) | def __init__(self, *args, stream=None):
    method init (line 99) | def init(self, arg):
    method load_stats (line 118) | def load_stats(self, arg):
    method get_top_level_stats (line 140) | def get_top_level_stats(self):
    method add (line 150) | def add(self, *arg_list):
    method dump_stats (line 176) | def dump_stats(self, filename):
    method get_sort_arg_defs (line 199) | def get_sort_arg_defs(self):
    method sort_stats (line 218) | def sort_stats(self, *field):
    method reverse_order (line 257) | def reverse_order(self):
    method strip_dirs (line 262) | def strip_dirs(self):
    method calc_callees (line 291) | def calc_callees(self):
    method eval_print_amount (line 310) | def eval_print_amount(self, sel, list, msg):
    method get_print_list (line 336) | def get_print_list(self, sel_list):
    method print_stats (line 360) | def print_stats(self, *amount):
    method print_callees (line 383) | def print_callees(self, *amount):
    method print_callers (line 398) | def print_callers(self, *amount):
    method print_call_heading (line 409) | def print_call_heading(self, name_size, column_title):
    method print_call_line (line 421) | def print_call_line(self, name_size, source, call_dict, arrow="->"):
    method print_title (line 446) | def print_title(self):
    method print_line (line 450) | def print_line(self, func):  # hack: should print percentages
  class TupleComp (line 468) | class TupleComp:
    method __init__ (line 476) | def __init__(self, comp_select_list):
    method compare (line 479) | def compare (self, left, right):
  function func_strip_path (line 493) | def func_strip_path(func_name):
  function func_get_function_name (line 497) | def func_get_function_name(func):
  function func_std_string (line 500) | def func_std_string(func_name): # match what old profile produced
  function add_func_stats (line 517) | def add_func_stats(target, source):
  function add_callers (line 524) | def add_callers(target, source):
  function count_calls (line 541) | def count_calls(callers):
  function f8 (line 552) | def f8(x):
  class ProfileBrowser (line 566) | class ProfileBrowser(cmd.Cmd):
    method __init__ (line 567) | def __init__(self, profile=None):
    method generic (line 575) | def generic(self, fn, line):
    method generic_help (line 599) | def generic_help(self):
    method do_add (line 607) | def do_add(self, line):
    method help_add (line 616) | def help_add(self):
    method do_callees (line 619) | def do_callees(self, line):
    method help_callees (line 621) | def help_callees(self):
    method do_callers (line 625) | def do_callers(self, line):
    method help_callers (line 627) | def help_callers(self):
    method do_EOF (line 631) | def do_EOF(self, line):
    method help_EOF (line 634) | def help_EOF(self):
    method do_quit (line 637) | def do_quit(self, line):
    method help_quit (line 639) | def help_quit(self):
    method do_read (line 642) | def do_read(self, line):
    method help_read (line 659) | def help_read(self):
    method do_reverse (line 663) | def do_reverse(self, line):
    method help_reverse (line 669) | def help_reverse(self):
    method do_sort (line 672) | def do_sort(self, line):
    method help_sort (line 684) | def help_sort(self):
    method complete_sort (line 687) | def complete_sort(self, text, *args):
    method do_stats (line 690) | def do_stats(self, line):
    method help_stats (line 692) | def help_stats(self):
    method do_strip (line 696) | def do_strip(self, line):
    method help_strip (line 701) | def help_strip(self):
    method help_help (line 704) | def help_help(self):
    method postcmd (line 707) | def postcmd(self, stop, line):

FILE: rd/usr/lib/python3.8/pty.py
  function openpty (line 22) | def openpty():
  function master_open (line 34) | def master_open():
  function _open_terminal (line 50) | def _open_terminal():
  function slave_open (line 62) | def slave_open(tty_name):
  function fork (line 80) | def fork():
  function _writen (line 120) | def _writen(fd, data):
  function _read (line 126) | def _read(fd):
  function _copy (line 130) | def _copy(master_fd, master_read=_read, stdin_read=_read):
  function spawn (line 151) | def spawn(argv, master_read=_read, stdin_read=_read):

FILE: rd/usr/lib/python3.8/py_compile.py
  class PyCompileError (line 18) | class PyCompileError(Exception):
    method __init__ (line 46) | def __init__(self, exc_type, exc_value, file, msg=''):
    method __str__ (line 62) | def __str__(self):
  class PycInvalidationMode (line 66) | class PycInvalidationMode(enum.Enum):
  function _get_default_invalidation_mode (line 72) | def _get_default_invalidation_mode():
  function compile (line 79) | def compile(file, cfile=None, dfile=None, doraise=False, optimize=-1,
  function main (line 176) | def main(args=None):

FILE: rd/usr/lib/python3.8/pyclbr.py
  class _Object (line 52) | class _Object:
    method __init__ (line 54) | def __init__(self, module, name, file, lineno, parent):
    method _addchild (line 62) | def _addchild(self, name, obj):
  class Function (line 66) | class Function(_Object):
    method __init__ (line 68) | def __init__(self, module, name, file, lineno, parent=None):
  class Class (line 72) | class Class(_Object):
    method __init__ (line 74) | def __init__(self, module, name, super, file, lineno, parent=None):
    method _addmethod (line 79) | def _addmethod(self, name, lineno):
  function _nest_function (line 83) | def _nest_function(ob, func_name, lineno):
  function _nest_class (line 91) | def _nest_class(ob, class_name, lineno, super=None):
  function readmodule (line 97) | def readmodule(module, path=None):
  function readmodule_ex (line 109) | def readmodule_ex(module, path=None):
  function _readmodule (line 118) | def _readmodule(module, path, inpackage=None):
  function _create_tree (line 182) | def _create_tree(fullmodule, path, fname, source, tree, inpackage):
  function _getnamelist (line 325) | def _getnamelist(g):
  function _getname (line 347) | def _getname(g):
  function _main (line 365) | def _main():

FILE: rd/usr/lib/python3.8/queue.py
  class Empty (line 18) | class Empty(Exception):
  class Full (line 22) | class Full(Exception):
  class Queue (line 27) | class Queue:
    method __init__ (line 33) | def __init__(self, maxsize=0):
    method task_done (line 56) | def task_done(self):
    method join (line 78) | def join(self):
    method qsize (line 91) | def qsize(self):
    method empty (line 96) | def empty(self):
    method full (line 110) | def full(self):
    method put (line 121) | def put(self, item, block=True, timeout=None):
    method get (line 153) | def get(self, block=True, timeout=None):
    method put_nowait (line 184) | def put_nowait(self, item):
    method get_nowait (line 192) | def get_nowait(self):
    method _init (line 205) | def _init(self, maxsize):
    method _qsize (line 208) | def _qsize(self):
    method _put (line 212) | def _put(self, item):
    method _get (line 216) | def _get(self):
  class PriorityQueue (line 220) | class PriorityQueue(Queue):
    method _init (line 226) | def _init(self, maxsize):
    method _qsize (line 229) | def _qsize(self):
    method _put (line 232) | def _put(self, item):
    method _get (line 235) | def _get(self):
  class LifoQueue (line 239) | class LifoQueue(Queue):
    method _init (line 242) | def _init(self, maxsize):
    method _qsize (line 245) | def _qsize(self):
    method _put (line 248) | def _put(self, item):
    method _get (line 251) | def _get(self):
  class _PySimpleQueue (line 255) | class _PySimpleQueue:
    method __init__ (line 265) | def __init__(self):
    method put (line 269) | def put(self, item, block=True, timeout=None):
    method get (line 278) | def get(self, block=True, timeout=None):
    method put_nowait (line 295) | def put_nowait(self, item):
    method get_nowait (line 303) | def get_nowait(self):
    method empty (line 311) | def empty(self):
    method qsize (line 315) | def qsize(self):

FILE: rd/usr/lib/python3.8/quopri.py
  function needsquoting (line 21) | def needsquoting(c, quotetabs, header):
  function quote (line 36) | def quote(c):
  function encode (line 44) | def encode(input, output, quotetabs, header=False):
  function encodestring (line 106) | def encodestring(s, quotetabs=False, header=False):
  function decode (line 117) | def decode(input, output, header=False):
  function decodestring (line 160) | def decodestring(s, header=False):
  function ishex (line 172) | def ishex(c):
  function unhex (line 177) | def unhex(s):
  function main (line 195) | def main():

FILE: rd/usr/lib/python3.8/random.py
  class Random (line 78) | class Random(_random.Random):
    method __init__ (line 94) | def __init__(self, x=None):
    method __init_subclass__ (line 103) | def __init_subclass__(cls, /, **kwargs):
    method seed (line 123) | def seed(self, a=None, version=2):
    method getstate (line 155) | def getstate(self):
    method setstate (line 159) | def setstate(self, state):
    method __getstate__ (line 189) | def __getstate__(self): # for pickle
    method __setstate__ (line 192) | def __setstate__(self, state):  # for pickle
    method __reduce__ (line 195) | def __reduce__(self):
    method randrange (line 200) | def randrange(self, start, stop=None, step=1, _int=int):
    method randint (line 244) | def randint(self, a, b):
    method _randbelow_with_getrandbits (line 250) | def _randbelow_with_getrandbits(self, n):
    method _randbelow_without_getrandbits (line 260) | def _randbelow_without_getrandbits(self, n, int=int, maxsize=1<<BPF):
    method choice (line 285) | def choice(self, seq):
    method shuffle (line 293) | def shuffle(self, x, random=None):
    method sample (line 315) | def sample(self, population, k):
    method choices (line 386) | def choices(self, population, weights=None, *, cum_weights=None, k=1):
    method uniform (line 415) | def uniform(self, a, b):
    method triangular (line 421) | def triangular(self, low=0.0, high=1.0, mode=None):
    method normalvariate (line 443) | def normalvariate(self, mu, sigma):
    method lognormvariate (line 468) | def lognormvariate(self, mu, sigma):
    method expovariate (line 480) | def expovariate(self, lambd):
    method vonmisesvariate (line 499) | def vonmisesvariate(self, mu, kappa):
    method gammavariate (line 547) | def gammavariate(self, alpha, beta):
    method gauss (line 616) | def gauss(self, mu, sigma):
    method betavariate (line 669) | def betavariate(self, alpha, beta):
    method paretovariate (line 687) | def paretovariate(self, alpha):
    method weibullvariate (line 696) | def weibullvariate(self, alpha, beta):
  class SystemRandom (line 709) | class SystemRandom(Random):
    method random (line 717) | def random(self):
    method getrandbits (line 721) | def getrandbits(self, k):
    method seed (line 729) | def seed(self, *args, **kwds):
    method _notimplemented (line 733) | def _notimplemented(self, *args, **kwds):
  function _test_generator (line 740) | def _test_generator(n, func, args):
  function _test (line 762) | def _test(N=2000):

FILE: rd/usr/lib/python3.8/re.py
  class RegexFlag (line 145) | class RegexFlag(enum.IntFlag):
    method __repr__ (line 157) | def __repr__(self):
  function match (line 188) | def match(pattern, string, flags=0):
  function fullmatch (line 193) | def fullmatch(pattern, string, flags=0):
  function search (line 198) | def search(pattern, string, flags=0):
  function sub (line 203) | def sub(pattern, repl, string, count=0, flags=0):
  function subn (line 212) | def subn(pattern, repl, string, count=0, flags=0):
  function split (line 223) | def split(pattern, string, maxsplit=0, flags=0):
  function findall (line 233) | def findall(pattern, string, flags=0):
  function finditer (line 243) | def finditer(pattern, string, flags=0):
  function compile (line 250) | def compile(pattern, flags=0):
  function purge (line 254) | def purge():
  function template (line 259) | def template(pattern, flags=0):
  function escape (line 270) | def escape(pattern):
  function _compile (line 289) | def _compile(pattern, flags):
  function _compile_repl (line 316) | def _compile_repl(repl, pattern):
  function _expand (line 320) | def _expand(pattern, match, template):
  function _subx (line 325) | def _subx(pattern, template):
  function _pickle (line 339) | def _pickle(p):
  class Scanner (line 347) | class Scanner:
    method __init__ (line 348) | def __init__(self, lexicon, flags=0):
    method scan (line 365) | def scan(self, string):

FILE: rd/usr/lib/python3.8/reprlib.py
  function recursive_repr (line 9) | def recursive_repr(fillvalue='...'):
  class Repr (line 36) | class Repr:
    method __init__ (line 38) | def __init__(self):
    method repr (line 51) | def repr(self, x):
    method repr1 (line 54) | def repr1(self, x, level):
    method _repr_iterable (line 64) | def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
    method repr_tuple (line 77) | def repr_tuple(self, x, level):
    method repr_list (line 80) | def repr_list(self, x, level):
    method repr_array (line 83) | def repr_array(self, x, level):
    method repr_set (line 89) | def repr_set(self, x, level):
    method repr_frozenset (line 95) | def repr_frozenset(self, x, level):
    method repr_deque (line 102) | def repr_deque(self, x, level):
    method repr_dict (line 105) | def repr_dict(self, x, level):
    method repr_str (line 120) | def repr_str(self, x, level):
    method repr_int (line 129) | def repr_int(self, x, level):
    method repr_instance (line 137) | def repr_instance(self, x, level):
  function _possibly_sorted (line 151) | def _possibly_sorted(x):

FILE: rd/usr/lib/python3.8/rlcompleter.py
  class Completer (line 38) | class Completer:
    method __init__ (line 39) | def __init__(self, namespace = None):
    method complete (line 66) | def complete(self, text, state):
    method _callable_postfix (line 97) | def _callable_postfix(self, val, word):
    method global_matches (line 102) | def global_matches(self, text):
    method attr_matches (line 130) | def attr_matches(self, text):
  function get_class_members (line 188) | def get_class_members(klass):

FILE: rd/usr/lib/python3.8/runpy.py
  class _TempModule (line 25) | class _TempModule(object):
    method __init__ (line 27) | def __init__(self, mod_name):
    method __enter__ (line 32) | def __enter__(self):
    method __exit__ (line 41) | def __exit__(self, *args):
  class _ModifiedArgv0 (line 48) | class _ModifiedArgv0(object):
    method __init__ (line 49) | def __init__(self, value):
    method __enter__ (line 53) | def __enter__(self):
    method __exit__ (line 59) | def __exit__(self, *args):
  function _run_code (line 64) | def _run_code(code, run_globals, init_globals=None,
  function _run_module_code (line 90) | def _run_module_code(code, init_globals=None,
  function _get_module_details (line 104) | def _get_module_details(mod_name, error=ImportError):
  class _Error (line 162) | class _Error(Exception):
  function _run_module_as_main (line 169) | def _run_module_as_main(mod_name, alter_argv=True):
  function run_module (line 197) | def run_module(mod_name, init_globals=None,
  function _get_main_module_details (line 212) | def _get_main_module_details(error=ImportError):
  function _get_code_from_file (line 231) | def _get_code_from_file(run_name, fname):
  function run_path (line 242) | def run_path(path_name, init_globals=None, run_name=None):

FILE: rd/usr/lib/python3.8/sched.py
  class Event (line 34) | class Event(namedtuple('Event', 'time, priority, action, argument, kwarg...
    method __eq__ (line 36) | def __eq__(s, o): return (s.time, s.priority) == (o.time, o.priority)
    method __lt__ (line 37) | def __lt__(s, o): return (s.time, s.priority) <  (o.time, o.priority)
    method __le__ (line 38) | def __le__(s, o): return (s.time, s.priority) <= (o.time, o.priority)
    method __gt__ (line 39) | def __gt__(s, o): return (s.time, s.priority) >  (o.time, o.priority)
    method __ge__ (line 40) | def __ge__(s, o): return (s.time, s.priority) >= (o.time, o.priority)
  class scheduler (line 55) | class scheduler:
    method __init__ (line 57) | def __init__(self, timefunc=_time, delayfunc=time.sleep):
    method enterabs (line 65) | def enterabs(self, time, priority, action, argument=(), kwargs=_sentin...
    method enter (line 79) | def enter(self, delay, priority, action, argument=(), kwargs=_sentinel):
    method cancel (line 88) | def cancel(self, event):
    method empty (line 99) | def empty(self):
    method run (line 104) | def run(self, blocking=True):
    method queue (line 155) | def queue(self):

FILE: rd/usr/lib/python3.8/secrets.py
  function randbelow (line 27) | def randbelow(exclusive_upper_bound):
  function token_bytes (line 35) | def token_bytes(nbytes=None):
  function token_hex (line 49) | def token_hex(nbytes=None):
  function token_urlsafe (line 62) | def token_urlsafe(nbytes=None):

FILE: rd/usr/lib/python3.8/selectors.py
  function _fileobj_to_fd (line 21) | def _fileobj_to_fd(fileobj):
  class _SelectorMapping (line 60) | class _SelectorMapping(Mapping):
    method __init__ (line 63) | def __init__(self, selector):
    method __len__ (line 66) | def __len__(self):
    method __getitem__ (line 69) | def __getitem__(self, fileobj):
    method __iter__ (line 76) | def __iter__(self):
  class BaseSelector (line 80) | class BaseSelector(metaclass=ABCMeta):
    method register (line 96) | def register(self, fileobj, events, data=None):
    method unregister (line 119) | def unregister(self, fileobj):
    method modify (line 137) | def modify(self, fileobj, events, data=None):
    method select (line 155) | def select(self, timeout=None):
    method close (line 173) | def close(self):
    method get_key (line 180) | def get_key(self, fileobj):
    method get_map (line 195) | def get_map(self):
    method __enter__ (line 199) | def __enter__(self):
    method __exit__ (line 202) | def __exit__(self, *args):
  class _BaseSelectorImpl (line 206) | class _BaseSelectorImpl(BaseSelector):
    method __init__ (line 209) | def __init__(self):
    method _fileobj_lookup (line 215) | def _fileobj_lookup(self, fileobj):
    method register (line 234) | def register(self, fileobj, events, data=None):
    method unregister (line 247) | def unregister(self, fileobj):
    method modify (line 254) | def modify(self, fileobj, events, data=None):
    method close (line 268) | def close(self):
    method get_map (line 272) | def get_map(self):
    method _key_from_fd (line 275) | def _key_from_fd(self, fd):
  class SelectSelector (line 290) | class SelectSelector(_BaseSelectorImpl):
    method __init__ (line 293) | def __init__(self):
    method register (line 298) | def register(self, fileobj, events, data=None):
    method unregister (line 306) | def unregister(self, fileobj):
    method _select (line 313) | def _select(self, r, w, _, timeout=None):
    method select (line 319) | def select(self, timeout=None):
  class _PollLikeSelector (line 341) | class _PollLikeSelector(_BaseSelectorImpl):
    method __init__ (line 347) | def __init__(self):
    method register (line 351) | def register(self, fileobj, events, data=None):
    method unregister (line 365) | def unregister(self, fileobj):
    method modify (line 375) | def modify(self, fileobj, events, data=None):
    method select (line 402) | def select(self, timeout=None):
  class PollSelector (line 433) | class PollSelector(_PollLikeSelector):
  class EpollSelector (line 442) | class EpollSelector(_PollLikeSelector):
    method fileno (line 448) | def fileno(self):
    method select (line 451) | def select(self, timeout=None):
    method close (line 483) | def close(self):
  class DevpollSelector (line 490) | class DevpollSelector(_PollLikeSelector):
    method fileno (line 496) | def fileno(self):
    method close (line 499) | def close(self):
  class KqueueSelector (line 506) | class KqueueSelector(_BaseSelectorImpl):
    method __init__ (line 509) | def __init__(self):
    method fileno (line 513) | def fileno(self):
    method register (line 516) | def register(self, fileobj, events, data=None):
    method unregister (line 532) | def unregister(self, fileobj):
    method select (line 553) | def select(self, timeout=None):
    method close (line 575) | def close(self):

FILE: rd/usr/lib/python3.8/shelve.py
  class _ClosedDict (line 66) | class _ClosedDict(collections.abc.MutableMapping):
    method closed (line 69) | def closed(self, *args):
    method __repr__ (line 73) | def __repr__(self):
  class Shelf (line 77) | class Shelf(collections.abc.MutableMapping):
    method __init__ (line 84) | def __init__(self, dict, protocol=None, writeback=False,
    method __iter__ (line 94) | def __iter__(self):
    method __len__ (line 98) | def __len__(self):
    method __contains__ (line 101) | def __contains__(self, key):
    method get (line 104) | def get(self, key, default=None):
    method __getitem__ (line 109) | def __getitem__(self, key):
    method __setitem__ (line 119) | def __setitem__(self, key, value):
    method __delitem__ (line 127) | def __delitem__(self, key):
    method __enter__ (line 134) | def __enter__(self):
    method __exit__ (line 137) | def __exit__(self, type, value, traceback):
    method close (line 140) | def close(self):
    method __del__ (line 157) | def __del__(self):
    method sync (line 164) | def sync(self):
  class BsdDbShelf (line 175) | class BsdDbShelf(Shelf):
    method __init__ (line 188) | def __init__(self, dict, protocol=None, writeback=False,
    method set_location (line 192) | def set_location(self, key):
    method next (line 197) | def next(self):
    method previous (line 202) | def previous(self):
    method first (line 207) | def first(self):
    method last (line 212) | def last(self):
  class DbfilenameShelf (line 218) | class DbfilenameShelf(Shelf):
    method __init__ (line 225) | def __init__(self, filename, flag='c', protocol=None, writeback=False):
  function open (line 230) | def open(filename, flag='c', protocol=None, writeback=False):

FILE: rd/usr/lib/python3.8/shlex.py
  class shlex (line 19) | class shlex:
    method __init__ (line 21) | def __init__(self, instream=None, infile=None, posix=False,
    method punctuation_chars (line 69) | def punctuation_chars(self):
    method push_token (line 72) | def push_token(self, tok):
    method push_source (line 78) | def push_source(self, newstream, newfile=None):
    method pop_source (line 92) | def pop_source(self):
    method get_token (line 101) | def get_token(self):
    method read_token (line 133) | def read_token(self):
    method sourcehook (line 279) | def sourcehook(self, newfile):
    method error_leader (line 288) | def error_leader(self, infile=None, lineno=None):
    method __iter__ (line 296) | def __iter__(self):
    method __next__ (line 299) | def __next__(self):
  function split (line 305) | def split(s, comments=False, posix=True):
  function join (line 314) | def join(split_command):
  function quote (line 321) | def quote(s):
  function _print_tokens (line 333) | def _print_tokens(lexer):

FILE: rd/usr/lib/python3.8/shutil.py
  class Error (line 66) | class Error(OSError):
  class SameFileError (line 69) | class SameFileError(Error):
  class SpecialFileError (line 72) | class SpecialFileError(OSError):
  class ExecError (line 76) | class ExecError(OSError):
  class ReadError (line 79) | class ReadError(OSError):
  class RegistryError (line 82) | class RegistryError(Exception):
  class _GiveupOnFastCopy (line 86) | class _GiveupOnFastCopy(Exception):
  function _fastcopy_fcopyfile (line 91) | def _fastcopy_fcopyfile(fsrc, fdst, flags):
  function _fastcopy_sendfile (line 111) | def _fastcopy_sendfile(fsrc, fdst):
  function _copyfileobj_readinto (line 175) | def _copyfileobj_readinto(fsrc, fdst, length=COPY_BUFSIZE):
  function copyfileobj (line 194) | def copyfileobj(fsrc, fdst, length=0):
  function _samefile (line 207) | def _samefile(src, dst):
  function _stat (line 225) | def _stat(fn):
  function _islink (line 228) | def _islink(fn):
  function copyfile (line 231) | def copyfile(src, dst, *, follow_symlinks=True):
  function copymode (line 286) | def copymode(src, dst, *, follow_symlinks=True):
  function _copyxattr (line 308) | def _copyxattr(src, dst, *, follow_symlinks=True):
  function _copyxattr (line 332) | def _copyxattr(*args, **kwargs):
  function copystat (line 335) | def copystat(src, dst, *, follow_symlinks=True):
  function copy (line 401) | def copy(src, dst, *, follow_symlinks=True):
  function copy2 (line 419) | def copy2(src, dst, *, follow_symlinks=True):
  function ignore_patterns (line 436) | def ignore_patterns(*patterns):
  function _copytree (line 448) | def _copytree(entries, src, dst, symlinks, ignore, copy_function,
  function copytree (line 513) | def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
  function _rmtree_isdir (line 563) | def _rmtree_isdir(entry):
  function _rmtree_islink (line 572) | def _rmtree_islink(path):
  function _rmtree_isdir (line 581) | def _rmtree_isdir(entry):
  function _rmtree_islink (line 587) | def _rmtree_islink(path):
  function _rmtree_unsafe (line 591) | def _rmtree_unsafe(path, onerror):
  function _rmtree_safe_fd (line 622) | def _rmtree_safe_fd(topfd, path, onerror):
  function rmtree (line 679) | def rmtree(path, ignore_errors=False, onerror=None):
  function _basename (line 743) | def _basename(path):
  function move (line 749) | def move(src, dst, copy_function=copy2):
  function _destinsrc (line 806) | def _destinsrc(src, dst):
  function _get_gid (line 815) | def _get_gid(name):
  function _get_uid (line 827) | def _get_uid(name):
  function _make_tarball (line 839) | def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_r...
  function _make_zipfile (line 904) | def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
  function get_archive_formats (line 965) | def get_archive_formats():
  function register_archive_format (line 975) | def register_archive_format(name, function, extra_args=None, description...
  function unregister_archive_format (line 996) | def unregister_archive_format(name):
  function make_archive (line 999) | def make_archive(base_name, format, root_dir=None, base_dir=None, verbos...
  function get_unpack_formats (line 1055) | def get_unpack_formats():
  function _check_unpack_options (line 1066) | def _check_unpack_options(extensions, function, extra_args):
  function register_unpack_format (line 1084) | def register_unpack_format(name, extensions, function, extra_args=None,
  function unregister_unpack_format (line 1106) | def unregister_unpack_format(name):
  function _ensure_directory (line 1110) | def _ensure_directory(path):
  function _unpack_zipfile (line 1116) | def _unpack_zipfile(filename, extract_dir):
  function _unpack_tarfile (line 1150) | def _unpack_tarfile(filename, extract_dir):
  function _find_unpack_format (line 1181) | def _find_unpack_format(filename):
  function unpack_archive (line 1188) | def unpack_archive(filename, extract_dir=None, format=None):
  function disk_usage (line 1238) | def disk_usage(path):
  function disk_usage (line 1255) | def disk_usage(path):
  function chown (line 1266) | def chown(path, user=None, group=None):
  function get_terminal_size (line 1298) | def get_terminal_size(fallback=(80, 24)):
  function _access_check (line 1347) | def _access_check(fn, mode):
  function which (line 1352) | def which(cmd, mode=os.F_OK | os.X_OK, path=None):

FILE: rd/usr/lib/python3.8/signal.py
  function _int_to_enum (line 25) | def _int_to_enum(value, enum_klass):
  function _enum_to_int (line 35) | def _enum_to_int(value):
  function signal (line 46) | def signal(signalnum, handler):
  function getsignal (line 52) | def getsignal(signalnum):
  function pthread_sigmask (line 59) | def pthread_sigmask(how, mask):
  function sigpending (line 67) | def sigpending():
  function sigwait (line 73) | def sigwait(sigset):
  function valid_signals (line 81) | def valid_signals():

FILE: rd/usr/lib/python3.8/site.py
  function makepath (line 91) | def makepath(*paths):
  function abs_paths (line 100) | def abs_paths():
  function removeduppaths (line 116) | def removeduppaths():
  function _init_pathinfo (line 135) | def _init_pathinfo():
  function addpackage (line 148) | def addpackage(sitedir, name, known_paths):
  function addsitedir (line 190) | def addsitedir(sitedir, known_paths=None):
  function check_enableusersite (line 214) | def check_enableusersite():
  function _getuserbase (line 246) | def _getuserbase():
  function _get_path (line 266) | def _get_path(userbase):
  function getuserbase (line 278) | def getuserbase():
  function getusersitepackages (line 291) | def getusersitepackages():
  function addusersitepackages (line 305) | def addusersitepackages(known_paths):
  function getsitepackages (line 319) | def getsitepackages(prefixes=None):
  function addsitepackages (line 346) | def addsitepackages(known_paths, prefixes=None):
  function setquit (line 354) | def setquit():
  function setcopyright (line 370) | def setcopyright():
  function sethelper (line 394) | def sethelper():
  function enablerlcompleter (line 397) | def enablerlcompleter():
  function venv (line 456) | def venv(known_paths):
  function execsitecustomize (line 508) | def execsitecustomize():
  function execusercustomize (line 528) | def execusercustomize():
  function main (line 548) | def main():
  function _script (line 582) | def _script():

FILE: rd/usr/lib/python3.8/smtpd.py
  class Devnull (line 101) | class Devnull:
    method write (line 102) | def write(self, msg): pass
    method flush (line 103) | def flush(self): pass
  function usage (line 112) | def usage(code, msg=''):
  class SMTPChannel (line 119) | class SMTPChannel(asynchat.async_chat):
    method max_command_size_limit (line 127) | def max_command_size_limit(self):
    method __init__ (line 133) | def __init__(self, server, conn, addr, data_size_limit=DATA_SIZE_DEFAULT,
    method _set_post_data_state (line 172) | def _set_post_data_state(self):
    method _set_rset_state (line 181) | def _set_rset_state(self):
    method __server (line 190) | def __server(self):
    method __server (line 195) | def __server(self, value):
    method __line (line 201) | def __line(self):
    method __line (line 206) | def __line(self, value):
    method __state (line 212) | def __state(self):
    method __state (line 217) | def __state(self, value):
    method __greeting (line 223) | def __greeting(self):
    method __greeting (line 228) | def __greeting(self, value):
    method __mailfrom (line 234) | def __mailfrom(self):
    method __mailfrom (line 239) | def __mailfrom(self, value):
    method __rcpttos (line 245) | def __rcpttos(self):
    method __rcpttos (line 250) | def __rcpttos(self, value):
    method __data (line 256) | def __data(self):
    method __data (line 261) | def __data(self, value):
    method __fqdn (line 267) | def __fqdn(self):
    method __fqdn (line 272) | def __fqdn(self, value):
    method __peer (line 278) | def __peer(self):
    method __peer (line 283) | def __peer(self, value):
    method __conn (line 289) | def __conn(self):
    method __conn (line 294) | def __conn(self, value):
    method __addr (line 300) | def __addr(self):
    method __addr (line 305) | def __addr(self, value):
    method push (line 311) | def push(self, msg):
    method collect_incoming_data (line 316) | def collect_incoming_data(self, data):
    method found_terminator (line 332) | def found_terminator(self):
    method smtp_HELO (line 394) | def smtp_HELO(self, arg):
    method smtp_EHLO (line 406) | def smtp_EHLO(self, arg):
    method smtp_NOOP (line 428) | def smtp_NOOP(self, arg):
    method smtp_QUIT (line 434) | def smtp_QUIT(self, arg):
    method _strip_command_keyword (line 439) | def _strip_command_keyword(self, keyword, arg):
    method _getaddr (line 445) | def _getaddr(self, arg):
    method _getparams (line 456) | def _getparams(self, params):
    method smtp_HELP (line 467) | def smtp_HELP(self, arg):
    method smtp_VRFY (line 502) | def smtp_VRFY(self, arg):
    method smtp_MAIL (line 513) | def smtp_MAIL(self, arg):
    method smtp_RCPT (line 567) | def smtp_RCPT(self, arg):
    method smtp_RSET (line 602) | def smtp_RSET(self, arg):
    method smtp_DATA (line 609) | def smtp_DATA(self, arg):
    method smtp_EXPN (line 624) | def smtp_EXPN(self, arg):
  class SMTPServer (line 628) | class SMTPServer(asyncore.dispatcher):
    method __init__ (line 632) | def __init__(self, localaddr, remoteaddr,
    method handle_accepted (line 660) | def handle_accepted(self, conn, addr):
    method process_message (line 671) | def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
  class DebuggingServer (line 705) | class DebuggingServer(SMTPServer):
    method _print_message_content (line 707) | def _print_message_content(self, peer, data):
    method process_message (line 724) | def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
  class PureProxy (line 735) | class PureProxy(SMTPServer):
    method __init__ (line 736) | def __init__(self, *args, **kwargs):
    method process_message (line 741) | def process_message(self, peer, mailfrom, rcpttos, data):
    method _deliver (line 755) | def _deliver(self, mailfrom, rcpttos, data):
  class MailmanProxy (line 780) | class MailmanProxy(PureProxy):
    method __init__ (line 781) | def __init__(self, *args, **kwargs):
    method process_message (line 786) | def process_message(self, peer, mailfrom, rcpttos, data):
  class Options (line 863) | class Options:
  function parseargs (line 870) | def parseargs():

FILE: rd/usr/lib/python3.8/sndhdr.py
  function what (line 52) | def what(filename):
  function whathdr (line 58) | def whathdr(filename):
  function test_aifc (line 75) | def test_aifc(h, f):
  function test_au (line 96) | def test_au(h, f):
  function test_hcom (line 129) | def test_hcom(h, f):
  function test_voc (line 142) | def test_voc(h, f):
  function test_wav (line 156) | def test_wav(h, f):
  function test_8svx (line 172) | def test_8svx(h, f):
  function test_sndt (line 181) | def test_sndt(h, f):
  function test_sndr (line 190) | def test_sndr(h, f):
  function get_long_be (line 203) | def get_long_be(b):
  function get_long_le (line 206) | def get_long_le(b):
  function get_short_be (line 209) | def get_short_be(b):
  function get_short_le (line 212) | def get_short_le(b):
  function test (line 220) | def test():
  function testall (line 235) | def testall(list, recursive, toplevel):

FILE: rd/usr/lib/python3.8/socket.py
  function _intenum_converter (line 97) | def _intenum_converter(value, enum_klass):
  class _GiveupOnSendfile (line 210) | class _GiveupOnSendfile(Exception): pass
  class socket (line 213) | class socket(_socket.socket):
    method __init__ (line 219) | def __init__(self, family=-1, type=-1, proto=-1, fileno=None):
    method __enter__ (line 235) | def __enter__(self):
    method __exit__ (line 238) | def __exit__(self, *args):
    method __repr__ (line 242) | def __repr__(self):
    method __getstate__ (line 271) | def __getstate__(self):
    method dup (line 274) | def dup(self):
    method accept (line 285) | def accept(self):
    method makefile (line 301) | def makefile(self, mode="r", buffering=None, *,
    method _sendfile_use_sendfile (line 345) | def _sendfile_use_sendfile(self, file, offset=0, count=None):
    method _sendfile_use_sendfile (line 410) | def _sendfile_use_sendfile(self, file, offset=0, count=None):
    method _sendfile_use_send (line 414) | def _sendfile_use_send(self, file, offset=0, count=None):
    method _check_sendfile_params (line 450) | def _check_sendfile_params(self, file, offset, count):
    method sendfile (line 463) | def sendfile(self, file, offset=0, count=None):
    method _decref_socketios (line 486) | def _decref_socketios(self):
    method _real_close (line 492) | def _real_close(self, _ss=_socket.socket):
    method close (line 496) | def close(self):
    method detach (line 502) | def detach(self):
    method family (line 513) | def family(self):
    method type (line 519) | def type(self):
    method get_inheritable (line 525) | def get_inheritable(self):
    method set_inheritable (line 527) | def set_inheritable(self, inheritable):
    method get_inheritable (line 530) | def get_inheritable(self):
    method set_inheritable (line 532) | def set_inheritable(self, inheritable):
  function fromfd (line 537) | def fromfd(fd, family, type, proto=0):
  function fromshare (line 547) | def fromshare(info):
  function socketpair (line 558) | def socketpair(family=None, type=SOCK_STREAM, proto=0):
  function socketpair (line 579) | def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
  class SocketIO (line 626) | class SocketIO(io.RawIOBase):
    method __init__ (line 643) | def __init__(self, sock, mode):
    method readinto (line 655) | def readinto(self, b):
    method write (line 678) | def write(self, b):
    method readable (line 694) | def readable(self):
    method writable (line 701) | def writable(self):
    method seekable (line 708) | def seekable(self):
    method fileno (line 715) | def fileno(self):
    method name (line 722) | def name(self):
    method mode (line 729) | def mode(self):
    method close (line 732) | def close(self):
  function getfqdn (line 743) | def getfqdn(name=''):
  function create_connection (line 771) | def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
  function has_dualstack_ipv6 (line 816) | def has_dualstack_ipv6():
  function create_server (line 832) | def create_server(address, *, family=AF_INET, backlog=None, reuse_port=F...
  function getaddrinfo (line 901) | def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):

FILE: rd/usr/lib/python3.8/socketserver.py
  class BaseServer (line 153) | class BaseServer:
    method __init__ (line 200) | def __init__(self, server_address, RequestHandlerClass):
    method server_activate (line 207) | def server_activate(self):
    method serve_forever (line 215) | def serve_forever(self, poll_interval=0.5):
    method shutdown (line 244) | def shutdown(self):
    method service_actions (line 254) | def service_actions(self):
    method handle_request (line 273) | def handle_request(self):
    method _handle_request_noblock (line 303) | def _handle_request_noblock(self):
    method handle_timeout (line 326) | def handle_timeout(self):
    method verify_request (line 333) | def verify_request(self, request, client_address):
    method process_request (line 341) | def process_request(self, request, client_address):
    method server_close (line 350) | def server_close(self):
    method finish_request (line 358) | def finish_request(self, request, client_address):
    method shutdown_request (line 362) | def shutdown_request(self, request):
    method close_request (line 366) | def close_request(self, request):
    method handle_error (line 370) | def handle_error(self, request, client_address):
    method __enter__ (line 383) | def __enter__(self):
    method __exit__ (line 386) | def __exit__(self, *args):
  class TCPServer (line 390) | class TCPServer(BaseServer):
    method __init__ (line 445) | def __init__(self, server_address, RequestHandlerClass, bind_and_activ...
    method server_bind (line 458) | def server_bind(self):
    method server_activate (line 469) | def server_activate(self):
    method server_close (line 477) | def server_close(self):
    method fileno (line 485) | def fileno(self):
    method get_request (line 493) | def get_request(self):
    method shutdown_request (line 501) | def shutdown_request(self, request):
    method close_request (line 511) | def close_request(self, request):
  class UDPServer (line 516) | class UDPServer(TCPServer):
    method get_request (line 526) | def get_request(self):
    method server_activate (line 530) | def server_activate(self):
    method shutdown_request (line 534) | def shutdown_request(self, request):
    method close_request (line 538) | def close_request(self, request):
  class ForkingMixIn (line 543) | class ForkingMixIn:
    method collect_children (line 552) | def collect_children(self, *, blocking=False):
    method handle_timeout (line 587) | def handle_timeout(self):
    method service_actions (line 594) | def service_actions(self):
    method process_request (line 601) | def process_request(self, request, client_address):
    method server_close (line 626) | def server_close(self):
  class ThreadingMixIn (line 631) | class ThreadingMixIn:
    method process_request_thread (line 643) | def process_request_thread(self, request, client_address):
    method process_request (line 656) | def process_request(self, request, client_address):
    method server_close (line 667) | def server_close(self):
  class ForkingUDPServer (line 678) | class ForkingUDPServer(ForkingMixIn, UDPServer): pass
  class ForkingTCPServer (line 679) | class ForkingTCPServer(ForkingMixIn, TCPServer): pass
  class ThreadingUDPServer (line 681) | class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
  class ThreadingTCPServer (line 682) | class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
  class UnixStreamServer (line 686) | class UnixStreamServer(TCPServer):
  class UnixDatagramServer (line 689) | class UnixDatagramServer(UDPServer):
  class ThreadingUnixStreamServer (line 692) | class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
  class ThreadingUnixDatagramServer (line 694) | class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
  class BaseRequestHandler (line 696) | class BaseRequestHandler:
    method __init__ (line 714) | def __init__(self, request, client_address, server):
    method setup (line 724) | def setup(self):
    method handle (line 727) | def handle(self):
    method finish (line 730) | def finish(self):
  class StreamRequestHandler (line 742) | class StreamRequestHandler(BaseRequestHandler):
    method setup (line 763) | def setup(self):
    method finish (line 776) | def finish(self):
  class _SocketWriter (line 787) | class _SocketWriter(BufferedIOBase):
    method __init__ (line 792) | def __init__(self, sock):
    method writable (line 795) | def writable(self):
    method write (line 798) | def write(self, b):
    method fileno (line 803) | def fileno(self):
  class DatagramRequestHandler (line 806) | class DatagramRequestHandler(BaseRequestHandler):
    method setup (line 810) | def setup(self):
    method finish (line 816) | def finish(self):

FILE: rd/usr/lib/python3.8/sqlite3/dbapi2.py
  function DateFromTicks (line 41) | def DateFromTicks(ticks):
  function TimeFromTicks (line 44) | def TimeFromTicks(ticks):
  function TimestampFromTicks (line 47) | def TimestampFromTicks(ticks):
  function register_adapters_and_converters (line 56) | def register_adapters_and_converters():

FILE: rd/usr/lib/python3.8/sqlite3/dump.py
  function _iterdump (line 10) | def _iterdump(connection):

FILE: rd/usr/lib/python3.8/sre_compile.py
  function _combine_flags (line 65) | def _combine_flags(flags, add_flags, del_flags,
  function _compile (line 71) | def _compile(code, pattern, flags):
  function _compile_charset (line 249) | def _compile_charset(charset, flags, code):
  function _optimize_charset (line 276) | def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
  function _mk_bitmap (line 411) | def _mk_bitmap(bits, _CODEBITS=_CODEBITS, _int=int):
  function _bytes_to_codes (line 416) | def _bytes_to_codes(b):
  function _simple (line 423) | def _simple(p):
  function _generate_overlap_table (line 432) | def _generate_overlap_table(prefix):
  function _get_iscased (line 453) | def _get_iscased(flags):
  function _get_literal_prefix (line 461) | def _get_literal_prefix(pattern, flags):
  function _get_charset_prefix (line 492) | def _get_charset_prefix(pattern, flags):
  function _compile_info (line 536) | def _compile_info(code, pattern, flags):
  function isstring (line 595) | def isstring(obj):
  function _code (line 598) | def _code(p, flags):
  function _hex_code (line 613) | def _hex_code(code):
  function dis (line 616) | def dis(code):
  function compile (line 759) | def compile(p, flags=0):

FILE: rd/usr/lib/python3.8/sre_constants.py
  class error (line 23) | class error(Exception):
    method __init__ (line 37) | def __init__(self, msg, pattern=None, pos=None):
  class _NamedIntConstant (line 56) | class _NamedIntConstant(int):
    method __new__ (line 57) | def __new__(cls, value, name):
    method __repr__ (line 62) | def __repr__(self):
  function _makecodes (line 67) | def _makecodes(names):
  function dump (line 218) | def dump(f, d, prefix):

FILE: rd/usr/lib/python3.8/sre_parse.py
  class Verbose (line 71) | class Verbose(Exception):
  class State (line 74) | class State:
    method __init__ (line 76) | def __init__(self):
    method groups (line 82) | def groups(self):
    method opengroup (line 84) | def opengroup(self, name=None):
    method closegroup (line 96) | def closegroup(self, gid, p):
    method checkgroup (line 98) | def checkgroup(self, gid):
    method checklookbehindgroup (line 101) | def checklookbehindgroup(self, gid, source):
  class SubPattern (line 109) | class SubPattern:
    method __init__ (line 111) | def __init__(self, state, data=None):
    method dump (line 118) | def dump(self, level=0):
    method __repr__ (line 158) | def __repr__(self):
    method __len__ (line 160) | def __len__(self):
    method __delitem__ (line 162) | def __delitem__(self, index):
    method __getitem__ (line 164) | def __getitem__(self, index):
    method __setitem__ (line 168) | def __setitem__(self, index, code):
    method insert (line 170) | def insert(self, index, code):
    method append (line 172) | def append(self, code):
    method getwidth (line 174) | def getwidth(self):
  class Tokenizer (line 223) | class Tokenizer:
    method __init__ (line 224) | def __init__(self, string):
    method __next (line 233) | def __next(self):
    method match (line 249) | def match(self, char):
    method get (line 254) | def get(self):
    method getwhile (line 258) | def getwhile(self, n, charset):
    method getuntil (line 267) | def getuntil(self, terminator, name):
    method pos (line 284) | def pos(self):
    method tell (line 286) | def tell(self):
    method seek (line 288) | def seek(self, index):
    method error (line 292) | def error(self, msg, offset=0):
  function _class_escape (line 295) | def _class_escape(source, escape):
  function _escape (line 355) | def _escape(source, escape, state):
  function _uniq (line 432) | def _uniq(items):
  function _parse_sub (line 435) | def _parse_sub(source, state, verbose, nested):
  function _parse (line 493) | def _parse(source, state, verbose, nested, first=False):
  function _parse_flags (line 861) | def _parse_flags(source, state, char):
  function fix_flags (line 921) | def fix_flags(src, flags):
  function parse (line 937) | def parse(str, flags=0, state=None):
  function parse_template (line 969) | def parse_template(source, state):
  function expand_template (line 1054) | def expand_template(template, match):

FILE: rd/usr/lib/python3.8/ssl.py
  class TLSVersion (line 158) | class TLSVersion(_IntEnum):
  class _TLSContentType (line 168) | class _TLSContentType(_IntEnum):
  class _TLSAlertType (line 182) | class _TLSAlertType(_IntEnum):
  class _TLSMessageType (line 223) | class _TLSMessageType(_IntEnum):
  function _dnsname_match (line 275) | def _dnsname_match(dn, hostname):
  function _inet_paton (line 324) | def _inet_paton(ipname):
  function _ipaddress_match (line 359) | def _ipaddress_match(cert_ipaddress, host_ip):
  function match_hostname (line 371) | def match_hostname(cert, hostname):
  function get_default_verify_paths (line 432) | def get_default_verify_paths():
  class _ASN1Object (line 446) | class _ASN1Object(namedtuple("_ASN1Object", "nid shortname longname oid")):
    method __new__ (line 451) | def __new__(cls, oid):
    method fromnid (line 455) | def fromnid(cls, nid):
    method fromname (line 461) | def fromname(cls, name):
  class Purpose (line 467) | class Purpose(_ASN1Object, _Enum):
  class SSLContext (line 474) | class SSLContext(_SSLContext):
    method __new__ (line 482) | def __new__(cls, protocol=PROTOCOL_TLS, *args, **kwargs):
    method _encode_hostname (line 486) | def _encode_hostname(self, hostname):
    method wrap_socket (line 494) | def wrap_socket(self, sock, server_side=False,
    method wrap_bio (line 510) | def wrap_bio(self, incoming, outgoing, server_side=False,
    method set_npn_protocols (line 520) | def set_npn_protocols(self, npn_protocols):
    method set_servername_callback (line 531) | def set_servername_callback(self, server_name_callback):
    method set_alpn_protocols (line 544) | def set_alpn_protocols(self, alpn_protocols):
    method _load_windows_store_certs (line 555) | def _load_windows_store_certs(self, storename, purpose):
    method load_default_certs (line 569) | def load_default_certs(self, purpose=Purpose.SERVER_AUTH):
    method minimum_version (line 579) | def minimum_version(self):
    method minimum_version (line 583) | def minimum_version(self, value):
    method maximum_version (line 589) | def maximum_version(self):
    method maximum_version (line 593) | def maximum_version(self, value):
    method options (line 597) | def options(self):
    method options (line 601) | def options(self, value):
    method hostname_checks_common_name (line 606) | def hostname_checks_common_name(self):
    method hostname_checks_common_name (line 611) | def hostname_checks_common_name(self, value):
    method hostname_checks_common_name (line 618) | def hostname_checks_common_name(self):
    method _msg_callback (line 622) | def _msg_callback(self):
    method _msg_callback (line 661) | def _msg_callback(self, callback):
    method protocol (line 699) | def protocol(self):
    method verify_flags (line 703) | def verify_flags(self):
    method verify_flags (line 707) | def verify_flags(self, value):
    method verify_mode (line 711) | def verify_mode(self):
    method verify_mode (line 719) | def verify_mode(self, value):
  function create_default_context (line 723) | def create_default_context(purpose=Purpose.SERVER_AUTH, *, cafile=None,
  function _create_unverified_context (line 758) | def _create_unverified_context(protocol=PROTOCOL_TLS, *, cert_reqs=CERT_...
  class SSLObject (line 812) | class SSLObject:
    method __init__ (line 827) | def __init__(self, *args, **kwargs):
    method _create (line 834) | def _create(cls, incoming, outgoing, server_side=False,
    method context (line 846) | def context(self):
    method context (line 851) | def context(self, ctx):
    method session (line 855) | def session(self):
    method session (line 860) | def session(self, session):
    method session_reused (line 864) | def session_reused(self):
    method server_side (line 869) | def server_side(self):
    method server_hostname (line 874) | def server_hostname(self):
    method read (line 879) | def read(self, len=1024, buffer=None):
    method write (line 891) | def write(self, data):
    method getpeercert (line 899) | def getpeercert(self, binary_form=False):
    method selected_npn_protocol (line 908) | def selected_npn_protocol(self):
    method selected_alpn_protocol (line 915) | def selected_alpn_protocol(self):
    method cipher (line 922) | def cipher(self):
    method shared_ciphers (line 927) | def shared_ciphers(self):
    method compression (line 933) | def compression(self):
    method pending (line 938) | def pending(self):
    method do_handshake (line 942) | def do_handshake(self):
    method unwrap (line 946) | def unwrap(self):
    method get_channel_binding (line 950) | def get_channel_binding(self, cb_type="tls-unique"):
    method version (line 956) | def version(self):
    method verify_client_post_handshake (line 961) | def verify_client_post_handshake(self):
  function _sslcopydoc (line 965) | def _sslcopydoc(func):
  class SSLSocket (line 971) | class SSLSocket(socket):
    method __init__ (line 976) | def __init__(self, *args, **kwargs):
    method _create (line 984) | def _create(cls, sock, server_side=False, do_handshake_on_connect=True,
    method context (line 1048) | def context(self):
    method context (line 1052) | def context(self, ctx):
    method session (line 1058) | def session(self):
    method session (line 1063) | def session(self, session):
    method session_reused (line 1070) | def session_reused(self):
    method dup (line 1074) | def dup(self):
    method _checkClosed (line 1078) | def _checkClosed(self, msg=None):
    method _check_connected (line 1082) | def _check_connected(self):
    method read (line 1090) | def read(self, len=1024, buffer=None):
    method write (line 1111) | def write(self, data):
    method getpeercert (line 1121) | def getpeercert(self, binary_form=False):
    method selected_npn_protocol (line 1127) | def selected_npn_protocol(self):
    method selected_alpn_protocol (line 1135) | def selected_alpn_protocol(self):
    method cipher (line 1143) | def cipher(self):
    method shared_ciphers (line 1151) | def shared_ciphers(self):
    method compression (line 1159) | def compression(self):
    method send (line 1166) | def send(self, data, flags=0):
    method sendto (line 1177) | def sendto(self, data, flags_or_addr, addr=None):
    method sendmsg (line 1187) | def sendmsg(self, *args, **kwargs):
    method sendall (line 1193) | def sendall(self, data, flags=0):
    method sendfile (line 1209) | def sendfile(self, file, offset=0, count=None):
    method recv (line 1219) | def recv(self, buflen=1024, flags=0):
    method recv_into (line 1230) | def recv_into(self, buffer, nbytes=None, flags=0):
    method recvfrom (line 1245) | def recvfrom(self, buflen=1024, flags=0):
    method recvfrom_into (line 1253) | def recvfrom_into(self, buffer, nbytes=None, flags=0):
    method recvmsg (line 1261) | def recvmsg(self, *args, **kwargs):
    method recvmsg_into (line 1265) | def recvmsg_into(self, *args, **kwargs):
    method pending (line 1270) | def pending(self):
    method shutdown (line 1277) | def shutdown(self, how):
    method unwrap (line 1283) | def unwrap(self):
    method verify_client_post_handshake (line 1292) | def verify_client_post_handshake(self):
    method _real_close (line 1298) | def _real_close(self):
    method do_handshake (line 1303) | def do_handshake(self, block=False):
    method _real_connect (line 1313) | def _real_connect(self, addr, connect_ex):
    method connect (line 1339) | def connect(self, addr):
    method connect_ex (line 1344) | def connect_ex(self, addr):
    method accept (line 1349) | def accept(self):
    method get_channel_binding (line 1362) | def get_channel_binding(self, cb_type="tls-unique"):
    method version (line 1373) | def version(self):
  function wrap_socket (line 1385) | def wrap_socket(sock, keyfile=None, certfile=None,
  function cert_time_to_seconds (line 1413) | def cert_time_to_seconds(cert_time):
  function DER_cert_to_PEM_cert (line 1446) | def DER_cert_to_PEM_cert(der_cert_bytes):
  function PEM_cert_to_DER_cert (line 1456) | def PEM_cert_to_DER_cert(pem_cert_string):
  function get_server_certificate (line 1469) | def get_server_certificate(addr, ssl_version=PROTOCOL_TLS, ca_certs=None):
  function get_protocol_name (line 1488) | def get_protocol_name(protocol_code):

FILE: rd/usr/lib/python3.8/stat.py
  function S_IMODE (line 21) | def S_IMODE(mode):
  function S_IFMT (line 27) | def S_IFMT(mode):
  function S_ISDIR (line 50) | def S_ISDIR(mode):
  function S_ISCHR (line 54) | def S_ISCHR(mode):
  function S_ISBLK (line 58) | def S_ISBLK(mode):
  function S_ISREG (line 62) | def S_ISREG(mode):
  function S_ISFIFO (line 66) | def S_ISFIFO(mode):
  function S_ISLNK (line 70) | def S_ISLNK(mode):
  function S_ISSOCK (line 74) | def S_ISSOCK(mode):
  function S_ISDOOR (line 78) | def S_ISDOOR(mode):
  function S_ISPORT (line 82) | def S_ISPORT(mode):
  function S_ISWHT (line 86) | def S_ISWHT(mode):
  function filemode (line 156) | def filemode(mode):

FILE: rd/usr/lib/python3.8/statistics.py
  class StatisticsError (line 117) | class StatisticsError(ValueError):
  function _sum (line 123) | def _sum(data, start=0):
  function _isfinite (line 181) | def _isfinite(x):
  function _coerce (line 188) | def _coerce(T, S):
  function _exact_ratio (line 219) | def _exact_ratio(x):
  function _convert (line 251) | def _convert(value, T):
  function _find_lteq (line 269) | def _find_lteq(a, x):
  function _find_rteq (line 277) | def _find_rteq(a, l, x):
  function _fail_neg (line 285) | def _fail_neg(values, errmsg='negative value'):
  function mean (line 295) | def mean(data):
  function fmean (line 321) | def fmean(data):
  function geometric_mean (line 348) | def geometric_mean(data):
  function harmonic_mean (line 367) | def harmonic_mean(data):
  function median (line 414) | def median(data):
  function median_low (line 438) | def median_low(data):
  function median_high (line 460) | def median_high(data):
  function median_grouped (line 479) | def median_grouped(data, interval=1):
  function mode (line 534) | def mode(data):
  function multimode (line 565) | def multimode(data):
  function quantiles (line 620) | def quantiles(data, *, n=4, method='exclusive'):
  function _ss (line 677) | def _ss(data, c=None):
  function variance (line 699) | def variance(data, xbar=None):
  function pvariance (line 746) | def pvariance(data, mu=None):
  function stdev (line 790) | def stdev(data, xbar=None):
  function pstdev (line 806) | def pstdev(data, mu=None):
  function _normal_dist_inv_cdf (line 825) | def _normal_dist_inv_cdf(p, mu, sigma):
  class NormalDist (line 899) | class NormalDist:
    method __init__ (line 909) | def __init__(self, mu=0.0, sigma=1.0):
    method from_samples (line 917) | def from_samples(cls, data):
    method samples (line 924) | def samples(self, n, *, seed=None):
    method pdf (line 930) | def pdf(self, x):
    method cdf (line 937) | def cdf(self, x):
    method inv_cdf (line 943) | def inv_cdf(self, p):
    method quantiles (line 959) | def quantiles(self, n=4):
    method overlap (line 970) | def overlap(self, other):
    method mean (line 1005) | def mean(self):
    method median (line 1010) | def median(self):
    method mode (line 1015) | def mode(self):
    method stdev (line 1024) | def stdev(self):
    method variance (line 1029) | def variance(self):
    method __add__ (line 1033) | def __add__(x1, x2):
    method __sub__ (line 1047) | def __sub__(x1, x2):
    method __mul__ (line 1061) | def __mul__(x1, x2):
    method __truediv__ (line 1069) | def __truediv__(x1, x2):
    method __pos__ (line 1077) | def __pos__(x1):
    method __neg__ (line 1081) | def __neg__(x1):
    method __rsub__ (line 1087) | def __rsub__(x1, x2):
    method __eq__ (line 1093) | def __eq__(x1, x2):
    method __hash__ (line 1099) | def __hash__(self):
    method __repr__ (line 1103) | def __repr__(self):
  function assert_close (line 1151) | def assert_close(G1, G2):

FILE: rd/usr/lib/python3.8/string.py
  function capwords (line 37) | def capwords(s, sep=None):
  class _TemplateMetaclass (line 57) | class _TemplateMetaclass(type):
    method __init__ (line 67) | def __init__(cls, name, bases, dct):
  class Template (line 80) | class Template(metaclass=_TemplateMetaclass):
    method __init__ (line 92) | def __init__(self, template):
    method _invalid (line 97) | def _invalid(self, mo):
    method substitute (line 109) | def substitute(self, mapping=_sentinel_dict, /, **kws):
    method safe_substitute (line 128) | def safe_substitute(self, mapping=_sentinel_dict, /, **kws):
  class Formatter (line 161) | class Formatter:
    method format (line 162) | def format(self, format_string, /, *args, **kwargs):
    method vformat (line 165) | def vformat(self, format_string, args, kwargs):
    method _vformat (line 171) | def _vformat(self, format_string, args, kwargs, used_args, recursion_d...
    method get_value (line 225) | def get_value(self, key, args, kwargs):
    method check_unused_args (line 232) | def check_unused_args(self, used_args, args, kwargs):
    method format_field (line 236) | def format_field(self, value, format_spec):
    method convert_field (line 240) | def convert_field(self, value, conversion):
    method parse (line 260) | def parse(self, format_string):
    method get_field (line 269) | def get_field(self, field_name, args, kwargs):

FILE: rd/usr/lib/python3.8/stringprep.py
  function in_table_a1 (line 12) | def in_table_a1(code):
  function in_table_b1 (line 20) | def in_table_b1(code):
  function map_table_b3 (line 189) | def map_table_b3(code):
  function map_table_b2 (line 195) | def map_table_b2(a):
  function in_table_c11 (line 206) | def in_table_c11(code):
  function in_table_c12 (line 210) | def in_table_c12(code):
  function in_table_c11_c12 (line 213) | def in_table_c11_c12(code):
  function in_table_c21 (line 217) | def in_table_c21(code):
  function in_table_c22 (line 221) | def in_table_c22(code):
  function in_table_c21_c22 (line 227) | def in_table_c21_c22(code):
  function in_table_c3 (line 232) | def in_table_c3(code):
  function in_table_c4 (line 236) | def in_table_c4(code):
  function in_table_c5 (line 243) | def in_table_c5(code):
  function in_table_c6 (line 248) | def in_table_c6(code):
  function in_table_c7 (line 253) | def in_table_c7(code):
  function in_table_c8 (line 258) | def in_table_c8(code):
  function in_table_c9 (line 263) | def in_table_c9(code):
  function in_table_d1 (line 267) | def in_table_d1(code):
  function in_table_d2 (line 271) | def in_table_d2(code):

FILE: rd/usr/lib/python3.8/subprocess.py
  class SubprocessError (line 96) | class SubprocessError(Exception): pass
  class CalledProcessError (line 99) | class CalledProcessError(SubprocessError):
    method __init__ (line 106) | def __init__(self, returncode, cmd, output=None, stderr=None):
    method __str__ (line 112) | def __str__(self):
    method stdout (line 125) | def stdout(self):
    method stdout (line 130) | def stdout(self, value):
  class TimeoutExpired (line 136) | class TimeoutExpired(SubprocessError):
    method __init__ (line 143) | def __init__(self, cmd, timeout, output=None, stderr=None):
    method __str__ (line 149) | def __str__(self):
    method stdout (line 154) | def stdout(self):
    method stdout (line 158) | def stdout(self, value):
  class STARTUPINFO (line 165) | class STARTUPINFO:
    method __init__ (line 166) | def __init__(self, *, dwFlags=0, hStdInput=None, hStdOutput=None,
    method copy (line 175) | def copy(self):
  class Handle (line 188) | class Handle(int):
    method Close (line 191) | def Close(self, CloseHandle=_winapi.CloseHandle):
    method Detach (line 196) | def Detach(self):
    method __repr__ (line 202) | def __repr__(self):
  function _cleanup (line 232) | def _cleanup():
  function _cleanup (line 241) | def _cleanup():
  function _optim_args_from_interpreter_flags (line 263) | def _optim_args_from_interpreter_flags():
  function _args_from_interpreter_flags (line 273) | def _args_from_interpreter_flags():
  function call (line 332) | def call(*popenargs, timeout=None, **kwargs):
  function check_call (line 349) | def check_call(*popenargs, **kwargs):
  function check_output (line 368) | def check_output(*popenargs, timeout=None, **kwargs):
  class CompletedProcess (line 415) | class CompletedProcess(object):
    method __init__ (line 426) | def __init__(self, args, returncode, stdout=None, stderr=None):
    method __repr__ (line 432) | def __repr__(self):
    method check_returncode (line 441) | def check_returncode(self):
  function run (line 448) | def run(*popenargs,
  function list2cmdline (line 517) | def list2cmdline(seq):
  function getstatusoutput (line 590) | def getstatusoutput(cmd):
  function getoutput (line 621) | def getoutput(cmd):
  function _use_posix_spawn (line 634) | def _use_posix_spawn():
  class Popen (line 684) | class Popen(object):
    method __init__ (line 732) | def __init__(self, args, bufsize=-1, executable=None,
    method universal_newlines (line 891) | def universal_newlines(self):
    method universal_newlines (line 897) | def universal_newlines(self, universal_newlines):
    method _translate_newlines (line 900) | def _translate_newlines(self, data, encoding, errors):
    method __enter__ (line 904) | def __enter__(self):
    method __exit__ (line 907) | def __exit__(self, exc_type, value, traceback):
    method __del__ (line 935) | def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn):
    method _get_devnull (line 950) | def _get_devnull(self):
    method _stdin_write (line 955) | def _stdin_write(self, input):
    method communicate (line 980) | def communicate(self, input=None, timeout=None):
    method poll (line 1048) | def poll(self):
    method _remaining_time (line 1054) | def _remaining_time(self, endtime):
    method _check_timeout (line 1062) | def _check_timeout(self, endtime, orig_timeout, stdout_seq, stderr_seq,
    method wait (line 1074) | def wait(self, timeout=None):
    method _close_pipe_fds (line 1097) | def _close_pipe_fds(self,
    method _get_handles (line 1130) | def _get_handles(self, stdin, stdout, stderr):
    method _make_inheritable (line 1202) | def _make_inheritable(self, handle):
    method _filter_handle_list (line 1211) | def _filter_handle_list(self, handle_list):
    method _execute_child (line 1224) | def _execute_child(self, args, executable, preexec_fn, close_fds,
    method _internal_poll (line 1332) | def _internal_poll(self, _deadstate=None,
    method _wait (line 1349) | def _wait(self, timeout):
    method _readerthread (line 1365) | def _readerthread(self, fh, buffer):
    method _communicate (line 1370) | def _communicate(self, input, endtime, orig_timeout):
    method send_signal (line 1422) | def send_signal(self, sig):
    method terminate (line 1436) | def terminate(self):
    method _get_handles (line 1457) | def _get_handles(self, stdin, stdout, stderr):
    method _posix_spawn (line 1511) | def _posix_spawn(self, args, executable, env, restore_signals,
    method _execute_child (line 1550) | def _execute_child(self, args, executable, preexec_fn, close_fds,
    method _handle_exitstatus (line 1706) | def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
    method _internal_poll (line 1724) | def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
    method _try_wait (line 1759) | def _try_wait(self, wait_flags):
    method _wait (line 1772) | def _wait(self, timeout):
    method _communicate (line 1813) | def _communicate(self, input, endtime, orig_timeout):
    method _save_input (line 1915) | def _save_input(self, input):
    method send_signal (line 1927) | def send_signal(self, sig):
    method terminate (line 1933) | def terminate(self):
    method kill (line 1938) | def kill(self):

FILE: rd/usr/lib/python3.8/sunau.py
  class Error (line 137) | class Error(Exception):
  function _read_u32 (line 140) | def _read_u32(file):
  function _write_u32 (line 149) | def _write_u32(file, x):
  class Au_read (line 157) | class Au_read:
    method __init__ (line 159) | def __init__(self, f):
    method __del__ (line 168) | def __del__(self):
    method __enter__ (line 172) | def __enter__(self):
    method __exit__ (line 175) | def __exit__(self, *args):
    method initfp (line 178) | def initfp(self, file):
    method getfp (line 224) | def getfp(self):
    method getnchannels (line 227) | def getnchannels(self):
    method getsampwidth (line 230) | def getsampwidth(self):
    method getframerate (line 233) | def getframerate(self):
    method getnframes (line 236) | def getnframes(self):
    method getcomptype (line 243) | def getcomptype(self):
    method getcompname (line 251) | def getcompname(self):
    method getparams (line 259) | def getparams(self):
    method getmarkers (line 264) | def getmarkers(self):
    method getmark (line 267) | def getmark(self, id):
    method readframes (line 270) | def readframes(self, nframes):
    method rewind (line 283) | def rewind(self):
    method tell (line 289) | def tell(self):
    method setpos (line 292) | def setpos(self, pos):
    method close (line 300) | def close(self):
  class Au_write (line 307) | class Au_write:
    method __init__ (line 309) | def __init__(self, f):
    method __del__ (line 318) | def __del__(self):
    method __enter__ (line 323) | def __enter__(self):
    method __exit__ (line 326) | def __exit__(self, *args):
    method initfp (line 329) | def initfp(self, file):
    method setnchannels (line 342) | def setnchannels(self, nchannels):
    method getnchannels (line 349) | def getnchannels(self):
    method setsampwidth (line 354) | def setsampwidth(self, sampwidth):
    method getsampwidth (line 361) | def getsampwidth(self):
    method setframerate (line 366) | def setframerate(self, framerate):
    method getframerate (line 371) | def getframerate(self):
    method setnframes (line 376) | def setnframes(self, nframes):
    method getnframes (line 383) | def getnframes(self):
    method setcomptype (line 386) | def setcomptype(self, type, name):
    method getcomptype (line 392) | def getcomptype(self):
    method getcompname (line 395) | def getcompname(self):
    method setparams (line 403) | def setparams(self, params):
    method getparams (line 411) | def getparams(self):
    method tell (line 416) | def tell(self):
    method writeframesraw (line 419) | def writeframesraw(self, data):
    method writeframes (line 431) | def writeframes(self, data):
    method close (line 437) | def close(self):
    method _ensure_header_written (line 455) | def _ensure_header_written(self):
    method _write_header (line 465) | def _write_header(self):
    method _patchheader (line 507) | def _patchheader(self):
  function open (line 515) | def open(f, mode=None):
  function openfp (line 528) | def openfp(f, mode=None):

FILE: rd/usr/lib/python3.8/symtable.py
  function symtable (line 12) | def symtable(code, filename, compile_type):
  class SymbolTableFactory (line 16) | class SymbolTableFactory:
    method __init__ (line 17) | def __init__(self):
    method new (line 20) | def new(self, table, filename):
    method __call__ (line 27) | def __call__(self, table, filename):
  class SymbolTable (line 37) | class SymbolTable(object):
    method __init__ (line 39) | def __init__(self, raw_table, filename):
    method __repr__ (line 44) | def __repr__(self):
    method get_type (line 57) | def get_type(self):
    method get_id (line 67) | def get_id(self):
    method get_name (line 70) | def get_name(self):
    method get_lineno (line 73) | def get_lineno(self):
    method is_optimized (line 76) | def is_optimized(self):
    method is_nested (line 79) | def is_nested(self):
    method has_children (line 82) | def has_children(self):
    method has_exec (line 85) | def has_exec(self):
    method get_identifiers (line 89) | def get_identifiers(self):
    method lookup (line 92) | def lookup(self, name):
    method get_symbols (line 100) | def get_symbols(self):
    method __check_children (line 103) | def __check_children(self, name):
    method get_children (line 108) | def get_children(self):
  class Function (line 113) | class Function(SymbolTable):
    method __idents_matching (line 122) | def __idents_matching(self, test_func):
    method get_parameters (line 126) | def get_parameters(self):
    method get_locals (line 131) | def get_locals(self):
    method get_globals (line 138) | def get_globals(self):
    method get_nonlocals (line 145) | def get_nonlocals(self):
    method get_frees (line 150) | def get_frees(self):
  class Class (line 157) | class Class(SymbolTable):
    method get_methods (line 161) | def get_methods(self):
  class Symbol (line 170) | class Symbol(object):
    method __init__ (line 172) | def __init__(self, name, flags, namespaces=None):
    method __repr__ (line 178) | def __repr__(self):
    method get_name (line 181) | def get_name(self):
    method is_referenced (line 184) | def is_referenced(self):
    method is_parameter (line 187) | def is_parameter(self):
    method is_global (line 190) | def is_global(self):
    method is_nonlocal (line 193) | def is_nonlocal(self):
    method is_declared_global (line 196) | def is_declared_global(self):
    method is_local (line 199) | def is_local(self):
    method is_annotated (line 202) | def is_annotated(self):
    method is_free (line 205) | def is_free(self):
    method is_imported (line 208) | def is_imported(self):
    method is_assigned (line 211) | def is_assigned(self):
    method is_namespace (line 214) | def is_namespace(self):
    method get_namespaces (line 227) | def get_namespaces(self):
    method get_namespace (line 231) | def get_namespace(self):

FILE: rd/usr/lib/python3.8/sysconfig.py
  function _safe_realpath (line 100) | def _safe_realpath(path):
  function _is_python_source_dir (line 121) | def _is_python_source_dir(d):
  function _fix_pcbuild (line 130) | def _fix_pcbuild(d):
  function is_python_build (line 138) | def is_python_build(check_home=False):
  function _subst_vars (line 151) | def _subst_vars(s, local_vars):
  function _extend_dict (line 160) | def _extend_dict(target_dict, other_dict):
  function _expand_vars (line 168) | def _expand_vars(scheme, vars):
  function _get_default_scheme (line 181) | def _get_default_scheme():
  function _getuserbase (line 190) | def _getuserbase():
  function _parse_makefile (line 209) | def _parse_makefile(filename, vars=None):
  function get_makefile_filename (line 333) | def get_makefile_filename():
  function _get_sysconfigdata_name (line 346) | def _get_sysconfigdata_name():
  function _generate_posix_vars (line 355) | def _generate_posix_vars():
  function _init_posix (line 418) | def _init_posix(vars):
  function _init_non_posix (line 426) | def _init_non_posix(vars):
  function parse_config_h (line 442) | def parse_config_h(fp, vars=None):
  function get_config_h_filename (line 474) | def get_config_h_filename():
  function get_scheme_names (line 486) | def get_scheme_names():
  function get_path_names (line 491) | def get_path_names():
  function get_paths (line 496) | def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
  function get_path (line 508) | def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
  function get_config_vars (line 516) | def get_config_vars(*args):
  function get_config_var (line 593) | def get_config_var(name):
  function get_platform (line 605) | def get_platform():
  function get_python_version (line 685) | def get_python_version():
  function _print_dict (line 689) | def _print_dict(title, data):
  function _main (line 696) | def _main():

FILE: rd/usr/lib/python3.8/tabnanny.py
  function errprint (line 34) | def errprint(*args):
  function main (line 41) | def main():
  class NannyNag (line 61) | class NannyNag(Exception):
    method __init__ (line 66) | def __init__(self, lineno, msg, line):
    method get_lineno (line 68) | def get_lineno(self):
    method get_msg (line 70) | def get_msg(self):
    method get_line (line 72) | def get_line(self):
  function check (line 75) | def check(file):
  class Whitespace (line 136) | class Whitespace:
    method __init__ (line 159) | def __init__(self, ws):
    method longest_run_of_spaces (line 184) | def longest_run_of_spaces(self):
    method indent_level (line 188) | def indent_level(self, tabsize):
    method equal (line 211) | def equal(self, other):
    method not_equal_witness (line 218) | def not_equal_witness(self, other):
    method less (line 242) | def less(self, other):
    method not_less_witness (line 259) | def not_less_witness(self, other):
  function format_witnesses (line 270) | def format_witnesses(w):
  function process_tokens (line 277) | def process_tokens(tokens):

FILE: rd/usr/lib/python3.8/telnetlib.py
  class Telnet (line 141) | class Telnet:
    method __init__ (line 196) | def __init__(self, host=None, port=0,
    method open (line 220) | def open(self, host, port=0, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
    method __del__ (line 237) | def __del__(self):
    method msg (line 241) | def msg(self, msg, *args):
    method set_debuglevel (line 255) | def set_debuglevel(self, debuglevel):
    method close (line 263) | def close(self):
    method get_socket (line 273) | def get_socket(self):
    method fileno (line 277) | def fileno(self):
    method write (line 281) | def write(self, buffer):
    method read_until (line 294) | def read_until(self, match, timeout=None):
    method read_all (line 331) | def read_all(self):
    method read_some (line 341) | def read_some(self):
    method read_very_eager (line 356) | def read_very_eager(self):
    method read_eager (line 370) | def read_eager(self):
    method read_lazy (line 384) | def read_lazy(self):
    method read_very_lazy (line 395) | def read_very_lazy(self):
    method read_sb_data (line 408) | def read_sb_data(self):
    method set_option_negotiation_callback (line 420) | def set_option_negotiation_callback(self, callback):
    method process_rawq (line 424) | def process_rawq(self):
    method rawq_getchar (line 496) | def rawq_getchar(self):
    method fill_rawq (line 514) | def fill_rawq(self):
    method sock_avail (line 531) | def sock_avail(self):
    method interact (line 537) | def interact(self):
    method mt_interact (line 563) | def mt_interact(self):
    method listener (line 573) | def listener(self):
    method expect (line 586) | def expect(self, list, timeout=None):
    method __enter__ (line 642) | def __enter__(self):
    method __exit__ (line 645) | def __exit__(self, type, value, traceback):
  function test (line 649) | def test():

FILE: rd/usr/lib/python3.8/tempfile.py
  function _exists (line 75) | def _exists(fn):
  function _infer_return_type (line 84) | def _infer_return_type(*args):
  function _sanitize_params (line 105) | def _sanitize_params(prefix, suffix, dir):
  class _RandomNameSequence (line 123) | class _RandomNameSequence:
    method rng (line 134) | def rng(self):
    method __iter__ (line 141) | def __iter__(self):
    method __next__ (line 144) | def __next__(self):
  function _candidate_tempdir_list (line 150) | def _candidate_tempdir_list():
  function _get_default_tempdir (line 177) | def _get_default_tempdir():
  function _get_candidate_names (line 224) | def _get_candidate_names():
  function _mkstemp_inner (line 238) | def _mkstemp_inner(dir, pre, suf, flags, output_type):
  function gettempprefix (line 269) | def gettempprefix():
  function gettempprefixb (line 273) | def gettempprefixb():
  function gettempdir (line 279) | def gettempdir():
  function gettempdirb (line 291) | def gettempdirb():
  function mkstemp (line 295) | def mkstemp(suffix=None, prefix=None, dir=None, text=False):
  function mkdtemp (line 335) | def mkdtemp(suffix=None, prefix=None, dir=None):
  function mktemp (line 375) | def mktemp(suffix="", prefix=template, dir=None):
  class _TemporaryFileCloser (line 407) | class _TemporaryFileCloser:
    method __init__ (line 415) | def __init__(self, file, name, delete=True):
    method close (line 430) | def close(self, unlink=_os.unlink):
    method __del__ (line 440) | def __del__(self):
    method close (line 444) | def close(self):
  class _TemporaryFileWrapper (line 450) | class _TemporaryFileWrapper:
    method __init__ (line 458) | def __init__(self, file, name, delete=True):
    method __getattr__ (line 464) | def __getattr__(self, name):
    method __enter__ (line 485) | def __enter__(self):
    method __exit__ (line 491) | def __exit__(self, exc, value, tb):
    method close (line 496) | def close(self):
    method __iter__ (line 503) | def __iter__(self):
  function NamedTemporaryFile (line 513) | def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
  function TemporaryFile (line 563) | def TemporaryFile(mode='w+b', buffering=-1, encoding=None,
  class SpooledTemporaryFile (line 623) | class SpooledTemporaryFile:
    method __init__ (line 630) | def __init__(self, max_size=0, mode='w+b', buffering=-1,
    method _check (line 646) | def _check(self, file):
    method rollover (line 652) | def rollover(self):
    method __enter__ (line 673) | def __enter__(self):
    method __exit__ (line 678) | def __exit__(self, exc, value, tb):
    method __iter__ (line 682) | def __iter__(self):
    method close (line 685) | def close(self):
    method closed (line 689) | def closed(self):
    method encoding (line 693) | def encoding(self):
    method errors (line 697) | def errors(self):
    method fileno (line 700) | def fileno(self):
    method flush (line 704) | def flush(self):
    method isatty (line 707) | def isatty(self):
    method mode (line 711) | def mode(self):
    method name (line 718) | def name(self):
    method newlines (line 725) | def newlines(self):
    method read (line 728) | def read(self, *args):
    method readline (line 731) | def readline(self, *args):
    method readlines (line 734) | def readlines(self, *args):
    method seek (line 737) | def seek(self, *args):
    method softspace (line 741) | def softspace(self):
    method tell (line 744) | def tell(self):
    method truncate (line 747) | def truncate(self, size=None):
    method write (line 755) | def write(self, s):
    method writelines (line 761) | def writelines(self, iterable):
  class TemporaryDirectory (line 768) | class TemporaryDirectory(object):
    method __init__ (line 780) | def __init__(self, suffix=None, prefix=None, dir=None):
    method _rmtree (line 787) | def _rmtree(cls, name):
    method _cleanup (line 817) | def _cleanup(cls, name, warn_message):
    method __repr__ (line 821) | def __repr__(self):
    method __enter__ (line 824) | def __enter__(self):
    method __exit__ (line 827) | def __exit__(self, exc, value, tb):
    method cleanup (line 830) | def cleanup(self):

FILE: rd/usr/lib/python3.8/textwrap.py
  class TextWrapper (line 17) | class TextWrapper:
    method __init__ (line 115) | def __init__(self,
    method _munge_whitespace (line 146) | def _munge_whitespace(self, text):
    method _split (line 160) | def _split(self, text):
    method _fix_sentence_endings (line 182) | def _fix_sentence_endings(self, chunks):
    method _handle_long_word (line 200) | def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
    method _wrap_chunks (line 233) | def _wrap_chunks(self, chunks):
    method _split_chunks (line 336) | def _split_chunks(self, text):
    method wrap (line 342) | def wrap(self, text):
    method fill (line 356) | def fill(self, text):
  function wrap (line 368) | def wrap(text, width=70, **kwargs):
  function fill (line 381) | def fill(text, width=70, **kwargs):
  function shorten (line 393) | def shorten(text, width, **kwargs):
  function dedent (line 414) | def dedent(text):
  function indent (line 465) | def indent(text, prefix, predicate=None):

FILE: rd/usr/lib/python3.8/threading.py
  function setprofile (line 57) | def setprofile(func):
  function settrace (line 67) | def settrace(func):
  function RLock (line 81) | def RLock(*args, **kwargs):
  class _RLock (line 94) | class _RLock:
    method __init__ (line 104) | def __init__(self):
    method __repr__ (line 109) | def __repr__(self):
    method acquire (line 124) | def acquire(self, blocking=True, timeout=-1):
    method release (line 162) | def release(self):
    method __exit__ (line 185) | def __exit__(self, t, v, tb):
    method _acquire_restore (line 190) | def _acquire_restore(self, state):
    method _release_save (line 194) | def _release_save(self):
    method _is_owned (line 204) | def _is_owned(self):
  class Condition (line 210) | class Condition:
    method __init__ (line 222) | def __init__(self, lock=None):
    method __enter__ (line 246) | def __enter__(self):
    method __exit__ (line 249) | def __exit__(self, *args):
    method __repr__ (line 252) | def __repr__(self):
    method _release_save (line 255) | def _release_save(self):
    method _acquire_restore (line 258) | def _acquire_restore(self, x):
    method _is_owned (line 261) | def _is_owned(self):
    method wait (line 270) | def wait(self, timeout=None):
    method wait_for (line 318) | def wait_for(self, predicate, timeout=None):
    method notify (line 341) | def notify(self, n=1):
    method notify_all (line 364) | def notify_all(self):
  class Semaphore (line 376) | class Semaphore:
    method __init__ (line 388) | def __init__(self, value=1):
    method acquire (line 394) | def acquire(self, blocking=True, timeout=None):
    method release (line 441) | def release(self):
    method __exit__ (line 452) | def __exit__(self, t, v, tb):
  class BoundedSemaphore (line 456) | class BoundedSemaphore(Semaphore):
    method __init__ (line 473) | def __init__(self, value=1):
    method release (line 477) | def release(self):
  class Event (line 494) | class Event:
    method __init__ (line 505) | def __init__(self):
    method _reset_internal_locks (line 509) | def _reset_internal_locks(self):
    method is_set (line 513) | def is_set(self):
    method set (line 519) | def set(self):
    method clear (line 530) | def clear(self):
    method wait (line 540) | def wait(self, timeout=None):
  class Barrier (line 573) | class Barrier:
    method __init__ (line 582) | def __init__(self, parties, action=None, timeout=None):
    method wait (line 598) | def wait(self, timeout=None):
    method _enter (line 628) | def _enter(self):
    method _release (line 639) | def _release(self):
    method _wait (line 653) | def _wait(self, timeout):
    method _exit (line 664) | def _exit(self):
    method reset (line 671) | def reset(self):
    method abort (line 691) | def abort(self):
    method _break (line 701) | def _break(self):
    method parties (line 708) | def parties(self):
    method n_waiting (line 713) | def n_waiting(self):
    method broken (line 722) | def broken(self):
  class BrokenBarrierError (line 727) | class BrokenBarrierError(RuntimeError):
  function _newname (line 734) | def _newname(template="Thread-%d"):
  class Thread (line 750) | class Thread:
    method __init__ (line 761) | def __init__(self, group=None, target=None, name=None,
    method _reset_internal_locks (line 808) | def _reset_internal_locks(self, is_alive):
    method __repr__ (line 820) | def __repr__(self):
    method start (line 834) | def start(self):
    method run (line 859) | def run(self):
    method _bootstrap (line 876) | def _bootstrap(self):
    method _set_ident (line 896) | def _set_ident(self):
    method _set_native_id (line 900) | def _set_native_id(self):
    method _set_tstate_lock (line 903) | def _set_tstate_lock(self):
    method _bootstrap_inner (line 915) | def _bootstrap_inner(self):
    method _stop (line 944) | def _stop(self):
    method _delete (line 970) | def _delete(self):
    method join (line 979) | def join(self, timeout=None):
    method _wait_for_tstate_lock (line 1017) | def _wait_for_tstate_lock(self, block=True, timeout=-1):
    method name (line 1032) | def name(self):
    method name (line 1043) | def name(self, name):
    method ident (line 1048) | def ident(self):
    method native_id (line 1061) | def native_id(self):
    method is_alive (line 1071) | def is_alive(self):
    method isAlive (line 1085) | def isAlive(self):
    method daemon (line 1096) | def daemon(self):
    method daemon (line 1111) | def daemon(self, daemonic):
    method isDaemon (line 1118) | def isDaemon(self):
    method setDaemon (line 1121) | def setDaemon(self, daemonic):
    method getName (line 1124) | def getName(self):
    method setName (line 1127) | def setName(self, name):
  function ExceptHookArgs (line 1143) | def ExceptHookArgs(args):
  function excepthook (line 1146) | def excepthook(args, /):
  function _make_invoke_excepthook (line 1177) | def _make_invoke_excepthook():
  class Timer (line 1230) | class Timer(Thread):
    method __init__ (line 1239) | def __init__(self, interval, function, args=None, kwargs=None):
    method cancel (line 1247) | def cancel(self):
    method run (line 1251) | def run(self):
  class _MainThread (line 1260) | class _MainThread(Thread):
    method __init__ (line 1262) | def __init__(self):
  class _DummyThread (line 1281) | class _DummyThread(Thread):
    method __init__ (line 1283) | def __init__(self):
    method _stop (line 1293) | def _stop(self):
    method is_alive (line 1296) | def is_alive(self):
    method join (line 1300) | def join(self, timeout=None):
  function current_thread (line 1306) | def current_thread():
  function active_count (line 1320) | def active_count():
  function _enumerate (line 1332) | def _enumerate():
  function enumerate (line 1336) | def enumerate():
  function _shutdown (line 1355) | def _shutdown():
  function main_thread (line 1395) | def main_thread():
  function _after_fork (line 1412) | def _after_fork():

FILE: rd/usr/lib/python3.8/timeit.py
  function reindent (line 79) | def reindent(src, indent):
  class Timer (line 83) | class Timer:
    method __init__ (line 101) | def __init__(self, stmt="pass", setup="pass", timer=default_timer,
    method print_exc (line 136) | def print_exc(self, file=None):
    method timeit (line 163) | def timeit(self, number=default_number):
    method repeat (line 183) | def repeat(self, repeat=default_repeat, number=default_number):
    method autorange (line 209) | def autorange(self, callback=None):
  function timeit (line 230) | def timeit(stmt="pass", setup="pass", timer=default_timer,
  function repeat (line 235) | def repeat(stmt="pass", setup="pass", timer=default_timer,
  function main (line 240) | def main(args=None, *, _wrap_timer=None):

FILE: rd/usr/lib/python3.8/token.py
  function ISTERMINAL (line 129) | def ISTERMINAL(x):
  function ISNONTERMINAL (line 132) | def ISNONTERMINAL(x):
  function ISEOF (line 135) | def ISEOF(x):

FILE: rd/usr/lib/python3.8/tokenize.py
  class TokenInfo (line 45) | class TokenInfo(collections.namedtuple('TokenInfo', 'type string start e...
    method __repr__ (line 46) | def __repr__(self):
    method exact_type (line 52) | def exact_type(self):
  function group (line 58) | def group(*choices): return '(' + '|'.join(choices) + ')'
  function any (line 59) | def any(*choices): return group(*choices) + '*'
  function maybe (line 60) | def maybe(*choices): return group(*choices) + '?'
  function _all_string_prefixes (line 83) | def _all_string_prefixes():
  function _compile (line 98) | def _compile(expr):
  class TokenError (line 157) | class TokenError(Exception): pass
  class StopTokenizing (line 159) | class StopTokenizing(Exception): pass
  class Untokenizer (line 162) | class Untokenizer:
    method __init__ (line 164) | def __init__(self):
    method add_whitespace (line 170) | def add_whitespace(self, start):
    method untokenize (line 183) | def untokenize(self, iterable):
    method compat (line 220) | def compat(self, token, iterable):
  function untokenize (line 257) | def untokenize(iterable):
  function _get_normal_name (line 284) | def _get_normal_name(orig_enc):
  function detect_encoding (line 295) | def detect_encoding(readline):
  function open (line 388) | def open(filename):
  function tokenize (line 404) | def tokenize(readline):
  function _tokenize (line 429) | def _tokenize(readline, encoding):
  function generate_tokens (line 612) | def generate_tokens(readline):
  function main (line 620) | def main():

FILE: rd/usr/lib/python3.8/trace.py
  class _Ignore (line 68) | class _Ignore:
    method __init__ (line 69) | def __init__(self, modules=None, dirs=None):
    method names (line 75) | def names(self, filename, modulename):
  function _modname (line 118) | def _modname(path):
  function _fullmodname (line 125) | def _fullmodname(path):
  class CoverageResults (line 153) | class CoverageResults:
    method __init__ (line 154) | def __init__(self, counts=None, calledfuncs=None, infile=None,
    method is_ignored_filename (line 180) | def is_ignored_filename(self, filename):
    method update (line 186) | def update(self, other):
    method write_results (line 204) | def write_results(self, show_missing=True, summary=False, coverdir=None):
    method write_results_file (line 296) | def write_results_file(self, path, lines, lnotab, lines_hit, encoding=...
  function _find_lines_from_code (line 328) | def _find_lines_from_code(code, strs):
  function _find_lines (line 338) | def _find_lines(code, strs):
  function _find_strings (line 350) | def _find_strings(filename, encoding=None):
  function _find_executable_linenos (line 373) | def _find_executable_linenos(filename):
  class Trace (line 387) | class Trace:
    method __init__ (line 388) | def __init__(self, count=1, trace=1, countfuncs=0, countcallers=0,
    method run (line 438) | def run(self, cmd):
    method runctx (line 443) | def runctx(self, cmd, globals=None, locals=None):
    method runfunc (line 456) | def runfunc(*args, **kw):
    method file_module_function_of (line 483) | def file_module_function_of(self, frame):
    method globaltrace_trackcallers (line 524) | def globaltrace_trackcallers(self, frame, why, arg):
    method globaltrace_countfuncs (line 535) | def globaltrace_countfuncs(self, frame, why, arg):
    method globaltrace_lt (line 544) | def globaltrace_lt(self, frame, why, arg):
    method localtrace_trace_and_count (line 567) | def localtrace_trace_and_count(self, frame, why, arg):
    method localtrace_trace (line 582) | def localtrace_trace(self, frame, why, arg):
    method localtrace_count (line 595) | def localtrace_count(self, frame, why, arg):
    method results (line 603) | def results(self):
  function main (line 609) | def main():

FILE: rd/usr/lib/python3.8/traceback.py
  function print_list (line 19) | def print_list(extracted_list, file=None):
  function format_list (line 27) | def format_list(extracted_list):
  function print_tb (line 45) | def print_tb(tb, limit=None, file=None):
  function format_tb (line 55) | def format_tb(tb, limit=None):
  function extract_tb (line 59) | def extract_tb(tb, limit=None):
  function print_exception (line 87) | def print_exception(etype, value, tb, limit=None, file=None, chain=True):
  function format_exception (line 108) | def format_exception(etype, value, tb, limit=None, chain=True):
  function format_exception_only (line 124) | def format_exception_only(etype, value):
  function _format_final_exc_line (line 145) | def _format_final_exc_line(etype, value):
  function _some_str (line 153) | def _some_str(value):
  function print_exc (line 161) | def print_exc(limit=None, file=None, chain=True):
  function format_exc (line 165) | def format_exc(limit=None, chain=True):
  function print_last (line 169) | def print_last(limit=None, file=None, chain=True):
  function print_stack (line 181) | def print_stack(f=None, limit=None, file=None):
  function format_stack (line 193) | def format_stack(f=None, limit=None):
  function extract_stack (line 200) | def extract_stack(f=None, limit=None):
  function clear_frames (line 216) | def clear_frames(tb):
  class FrameSummary (line 227) | class FrameSummary:
    method __init__ (line 243) | def __init__(self, filename, lineno, name, *, lookup_line=True,
    method __eq__ (line 262) | def __eq__(self, other):
    method __getitem__ (line 272) | def __getitem__(self, pos):
    method __iter__ (line 275) | def __iter__(self):
    method __repr__ (line 278) | def __repr__(self):
    method __len__ (line 282) | def __len__(self):
    method line (line 286) | def line(self):
  function walk_stack (line 292) | def walk_stack(f):
  function walk_tb (line 305) | def walk_tb(tb):
  class StackSummary (line 318) | class StackSummary(list):
    method extract (line 322) | def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
    method from_list (line 370) | def from_list(klass, a_list):
    method format (line 388) | def format(self):
  class TracebackException (line 440) | class TracebackException:
    method __init__ (line 468) | def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
    method from_exception (line 527) | def from_exception(cls, exc, *args, **kwargs):
    method _load_lines (line 531) | def _load_lines(self):
    method __eq__ (line 540) | def __eq__(self, other):
    method __str__ (line 543) | def __str__(self):
    method format_exception_only (line 546) | def format_exception_only(self):
    method format (line 591) | def format(self, *, chain=True):

FILE: rd/usr/lib/python3.8/tracemalloc.py
  function _format_size (line 13) | def _format_size(size, sign):
  class Statistic (line 30) | class Statistic:
    method __init__ (line 37) | def __init__(self, traceback, size, count):
    method __hash__ (line 42) | def __hash__(self):
    method __eq__ (line 45) | def __eq__(self, other):
    method __str__ (line 50) | def __str__(self):
    method __repr__ (line 60) | def __repr__(self):
    method _sort_key (line 64) | def _sort_key(self):
  class StatisticDiff (line 68) | class StatisticDiff:
    method __init__ (line 75) | def __init__(self, traceback, size, size_diff, count, count_diff):
    method __hash__ (line 82) | def __hash__(self):
    method __eq__ (line 86) | def __eq__(self, other):
    method __str__ (line 93) | def __str__(self):
    method __repr__ (line 105) | def __repr__(self):
    method _sort_key (line 110) | def _sort_key(self):
  function _compare_grouped_stats (line 116) | def _compare_grouped_stats(old_group, new_group):
  class Frame (line 137) | class Frame:
    method __init__ (line 143) | def __init__(self, frame):
    method filename (line 148) | def filename(self):
    method lineno (line 152) | def lineno(self):
    method __eq__ (line 155) | def __eq__(self, other):
    method __lt__ (line 158) | def __lt__(self, other):
    method __hash__ (line 161) | def __hash__(self):
    method __str__ (line 164) | def __str__(self):
    method __repr__ (line 167) | def __repr__(self):
  class Traceback (line 172) | class Traceback(Sequence):
    method __init__ (line 179) | def __init__(self, frames):
    method __len__ (line 187) | def __len__(self):
    method __getitem__ (line 190) | def __getitem__(self, index):
    method __contains__ (line 196) | def __contains__(self, frame):
    method __hash__ (line 199) | def __hash__(self):
    method __eq__ (line 202) | def __eq__(self, other):
    method __lt__ (line 205) | def __lt__(self, other):
    method __str__ (line 208) | def __str__(self):
    method __repr__ (line 211) | def __repr__(self):
    method format (line 214) | def format(self, limit=None, most_recent_first=False):
  function get_object_traceback (line 235) | def get_object_traceback(obj):
  class Trace (line 250) | class Trace:
    method __init__ (line 256) | def __init__(self, trace):
    method domain (line 262) | def domain(self):
    method size (line 266) | def size(self):
    method traceback (line 270) | def traceback(self):
    method __eq__ (line 273) | def __eq__(self, other):
    method __hash__ (line 276) | def __hash__(self):
    method __str__ (line 279) | def __str__(self):
    method __repr__ (line 282) | def __repr__(self):
  class _Traces (line 287) | class _Traces(Sequence):
    method __init__ (line 288) | def __init__(self, traces):
    method __len__ (line 293) | def __len__(self):
    method __getitem__ (line 296) | def __getitem__(self, index):
    method __contains__ (line 302) | def __contains__(self, trace):
    method __eq__ (line 305) | def __eq__(self, other):
    method __repr__ (line 308) | def __repr__(self):
  function _normalize_filename (line 312) | def _normalize_filename(filename):
  class BaseFilter (line 319) | class BaseFilter:
    method __init__ (line 320) | def __init__(self, inclusive):
    method _match (line 323) | def _match(self, trace):
  class Filter (line 327) | class Filter(BaseFilter):
    method __init__ (line 328) | def __init__(self, inclusive, filename_pattern,
    method filename_pattern (line 338) | def filename_pattern(self):
    method _match_frame_impl (line 341) | def _match_frame_impl(self, filename, lineno):
    method _match_frame (line 350) | def _match_frame(self, filename, lineno):
    method _match_traceback (line 353) | def _match_traceback(self, traceback):
    method _match (line 364) | def _match(self, trace):
  class DomainFilter (line 375) | class DomainFilter(BaseFilter):
    method __init__ (line 376) | def __init__(self, inclusive, domain):
    method domain (line 381) | def domain(self):
    method _match (line 384) | def _match(self, trace):
  class Snapshot (line 389) | class Snapshot:
    method __init__ (line 394) | def __init__(self, traces, traceback_limit):
    method dump (line 400) | def dump(self, filename):
    method load (line 408) | def load(filename):
    method _filter_trace (line 415) | def _filter_trace(self, include_filters, exclude_filters, trace):
    method filter_traces (line 426) | def filter_traces(self, filters):
    method _group_by (line 451) | def _group_by(self, key_type, cumulative):
    method statistics (line 502) | def statistics(self, key_type, cumulative=False):
    method compare_to (line 512) | def compare_to(self, old_snapshot, key_type, cumulative=False):
  function take_snapshot (line 525) | def take_snapshot():

FILE: rd/usr/lib/python3.8/tty.py
  function setraw (line 18) | def setraw(fd, when=TCSAFLUSH):
  function setcbreak (line 30) | def setcbreak(fd, when=TCSAFLUSH):

FILE: rd/usr/lib/python3.8/types.py
  function _f (line 11) | def _f(): pass
  function _cell_factory (line 18) | def _cell_factory():
  function _g (line 25) | def _g():
  function _c (line 29) | async def _c(): pass
  function _ag (line 34) | async def _ag():
  class _C (line 39) | class _C:
    method _m (line 40) | def _m(self): pass
  function new_class (line 69) | def new_class(name, bases=(), kwds=None, exec_body=None):
  function resolve_bases (line 79) | def resolve_bases(bases):
  function prepare_class (line 100) | def prepare_class(name, bases=(), kwds=None):
  function _calculate_meta (line 132) | def _calculate_meta(meta, bases):
  class DynamicClassAttribute (line 149) | class DynamicClassAttribute:
    method __init__ (line 161) | def __init__(self, fget=None, fset=None, fdel=None, doc=None):
    method __get__ (line 171) | def __get__(self, instance, ownerclass=None):
    method __set__ (line 180) | def __set__(self, instance, value):
    method __delete__ (line 185) | def __delete__(self, instance):
    method getter (line 190) | def getter(self, fget):
    method setter (line 196) | def setter(self, fset):
    method deleter (line 201) | def deleter(self, fdel):
  class _GeneratorWrapper (line 207) | class _GeneratorWrapper:
    method __init__ (line 209) | def __init__(self, gen):
    method send (line 214) | def send(self, val):
    method throw (line 216) | def throw(self, tp, *rest):
    method close (line 218) | def close(self):
    method gi_code (line 221) | def gi_code(self):
    method gi_frame (line 224) | def gi_frame(self):
    method gi_running (line 227) | def gi_running(self):
    method gi_yieldfrom (line 230) | def gi_yieldfrom(self):
    method __next__ (line 236) | def __next__(self):
    method __iter__ (line 238) | def __iter__(self):
  function coroutine (line 244) | def coroutine(func):

FILE: rd/usr/lib/python3.8/typing.py
  function _type_check (line 120) | def _type_check(arg, msg, is_argument=True):
  function _type_repr (line 153) | def _type_repr(obj):
  function _collect_type_vars (line 172) | def _collect_type_vars(types):
  function _subs_tvars (line 187) | def _subs_tvars(tp, tvars, subs):
  function _check_generic (line 206) | def _check_generic(cls, parameters):
  function _remove_dups_flatten (line 219) | def _remove_dups_flatten(parameters):
  function _tp_cache (line 248) | def _tp_cache(func):
  function _eval_type (line 265) | def _eval_type(t, globalns, localns):
  class _Final (line 281) | class _Final:
    method __init_subclass__ (line 286) | def __init_subclass__(self, /, *args, **kwds):
  class _Immutable (line 290) | class _Immutable:
    method __copy__ (line 293) | def __copy__(self):
    method __deepcopy__ (line 296) | def __deepcopy__(self, memo):
  class _SpecialForm (line 300) | class _SpecialForm(_Final, _Immutable, _root=True):
    method __new__ (line 307) | def __new__(cls, *args, **kwds):
    method __init__ (line 320) | def __init__(self, name, doc):
    method __eq__ (line 324) | def __eq__(self, other):
    method __hash__ (line 329) | def __hash__(self):
    method __repr__ (line 332) | def __repr__(self):
    method __reduce__ (line 335) | def __reduce__(self):
    method __call__ (line 338) | def __call__(self, *args, **kwds):
    method __instancecheck__ (line 341) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 344) | def __subclasscheck__(self, cls):
    method __getitem__ (line 348) | def __getitem__(self, parameters):
  class ForwardRef (line 489) | class ForwardRef(_Final, _root=True):
    method __init__ (line 496) | def __init__(self, arg, is_argument=True):
    method _evaluate (line 509) | def _evaluate(self, globalns, localns):
    method __eq__ (line 524) | def __eq__(self, other):
    method __hash__ (line 532) | def __hash__(self):
    method __repr__ (line 535) | def __repr__(self):
  class TypeVar (line 539) | class TypeVar(_Final, _Immutable, _root=True):
    method __init__ (line 586) | def __init__(self, name, *constraints, bound=None,
    method __repr__ (line 610) | def __repr__(self):
    method __reduce__ (line 619) | def __reduce__(self):
  function _is_dunder (line 646) | def _is_dunder(attr):
  class _GenericAlias (line 650) | class _GenericAlias(_Final, _root=True):
    method __init__ (line 659) | def __init__(self, origin, params, *, inst=True, special=False, name=N...
    method __getitem__ (line 678) | def __getitem__(self, params):
    method copy_with (line 689) | def copy_with(self, params):
    method __repr__ (line 693) | def __repr__(self):
    method __eq__ (line 711) | def __eq__(self, other):
    method __hash__ (line 720) | def __hash__(self):
    method __call__ (line 725) | def __call__(self, *args, **kwargs):
    method __mro_entries__ (line 736) | def __mro_entries__(self, bases):
    method __getattr__ (line 755) | def __getattr__(self, attr):
    method __setattr__ (line 762) | def __setattr__(self, attr, val):
    method __instancecheck__ (line 768) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 771) | def __subclasscheck__(self, cls):
    method __reduce__ (line 780) | def __reduce__(self):
  class _VariadicGenericAlias (line 798) | class _VariadicGenericAlias(_GenericAlias, _root=True):
    method __getitem__ (line 802) | def __getitem__(self, params):
    method __getitem_inner__ (line 819) | def __getitem_inner__(self, params):
  class Generic (line 845) | class Generic:
    method __new__ (line 868) | def __new__(cls, *args, **kwds):
    method __class_getitem__ (line 879) | def __class_getitem__(cls, params):
    method __init_subclass__ (line 900) | def __init_subclass__(cls, *args, **kwargs):
  class _TypingEmpty (line 936) | class _TypingEmpty:
  class _TypingEllipsis (line 943) | class _TypingEllipsis:
  function _get_protocol_attrs (line 958) | def _get_protocol_attrs(cls):
  function _is_callable_members_only (line 975) | def _is_callable_members_only(cls):
  function _no_init (line 980) | def _no_init(self, *args, **kwargs):
  function _allow_reckless_class_cheks (line 985) | def _allow_reckless_class_cheks():
  class _ProtocolMeta (line 1006) | class _ProtocolMeta(ABCMeta):
    method __instancecheck__ (line 1009) | def __instancecheck__(cls, instance):
  class Protocol (line 1026) | class Protocol(Generic, metaclass=_ProtocolMeta):
    method __init_subclass__ (line 1060) | def __init_subclass__(cls, *args, **kwargs):
  function runtime_checkable (line 1124) | def runtime_checkable(cls):
  function cast (line 1149) | def cast(typ, val):
  function _get_defaults (line 1160) | def _get_defaults(func):
  function get_type_hints (line 1185) | def get_type_hints(obj, globalns=None, localns=None):
  function get_origin (line 1271) | def get_origin(tp):
  function get_args (line 1292) | def get_args(tp):
  function no_type_check (line 1311) | def no_type_check(arg):
  function no_type_check_decorator (line 1337) | def no_type_check_decorator(decorator):
  function _overload_dummy (line 1353) | def _overload_dummy(*args, **kwds):
  function overload (line 1362) | def overload(func):
  function final (line 1391) | def final(f):
  function _alias (line 1435) | def _alias(origin, params, inst=True):
  class SupportsInt (line 1522) | class SupportsInt(Protocol):
    method __int__ (line 1527) | def __int__(self) -> int:
  class SupportsFloat (line 1532) | class SupportsFloat(Protocol):
    method __float__ (line 1537) | def __float__(self) -> float:
  class SupportsComplex (line 1542) | class SupportsComplex(Protocol):
    method __complex__ (line 1547) | def __complex__(self) -> complex:
  class SupportsBytes (line 1552) | class SupportsBytes(Protocol):
    method __bytes__ (line 1557) | def __bytes__(self) -> bytes:
  class SupportsIndex (line 1562) | class SupportsIndex(Protocol):
    method __index__ (line 1567) | def __index__(self) -> int:
  class SupportsAbs (line 1572) | class SupportsAbs(Protocol[T_co]):
    method __abs__ (line 1577) | def __abs__(self) -> T_co:
  class SupportsRound (line 1582) | class SupportsRound(Protocol[T_co]):
    method __round__ (line 1587) | def __round__(self, ndigits: int = 0) -> T_co:
  function _make_nmtuple (line 1591) | def _make_nmtuple(name, types):
  class NamedTupleMeta (line 1613) | class NamedTupleMeta(type):
    method __new__ (line 1615) | def __new__(cls, typename, bases, ns):
  class NamedTuple (line 1644) | class NamedTuple(metaclass=NamedTupleMeta):
    method __new__ (line 1670) | def __new__(*args, **kwargs):
  function _dict_new (line 1708) | def _dict_new(cls, /, *args, **kwargs):
  function _typeddict_new (line 1712) | def _typeddict_new(cls, typename, fields=None, /, *, total=True, **kwargs):
  function _check_fails (line 1729) | def _check_fails(cls, other):
  class _TypedDictMeta (line 1734) | class _TypedDictMeta(type):
    method __new__ (line 1735) | def __new__(cls, name, bases, ns, total=True):
  class TypedDict (line 1760) | class TypedDict(dict, metaclass=_TypedDictMeta):
  function NewType (line 1803) | def NewType(name, tp):
  class IO (line 1838) | class IO(Generic[AnyStr]):
    method mode (line 1855) | def mode(self) -> str:
    method name (line 1860) | def name(self) -> str:
    method close (line 1864) | def close(self) -> None:
    method closed (line 1869) | def closed(self) -> bool:
    method fileno (line 1873) | def fileno(self) -> int:
    method flush (line 1877) | def flush(self) -> None:
    method isatty (line 1881) | def isatty(self) -> bool:
    method read (line 1885) | def read(self, n: int = -1) -> AnyStr:
    method readable (line 1889) | def readable(self) -> bool:
    method readline (line 1893) | def readline(self, limit: int = -1) -> AnyStr:
    method readlines (line 1897) | def readlines(self, hint: int = -1) -> List[AnyStr]:
    method seek (line 1901) | def seek(self, offset: int, whence: int = 0) -> int:
    method seekable (line 1905) | def seekable(self) -> bool:
    method tell (line 1909) | def tell(self) -> int:
    method truncate (line 1913) | def truncate(self, size: int = None) -> int:
    method writable (line 1917) | def writable(self) -> bool:
    method write (line 1921) | def write(self, s: AnyStr) -> int:
    method writelines (line 1925) | def writelines(self, lines: List[AnyStr]) -> None:
    method __enter__ (line 1929) | def __enter__(self) -> 'IO[AnyStr]':
    method __exit__ (line 1933) | def __exit__(self, type, value, traceback) -> None:
  class BinaryIO (line 1937) | class BinaryIO(IO[bytes]):
    method write (line 1943) | def write(self, s: Union[bytes, bytearray]) -> int:
    method __enter__ (line 1947) | def __enter__(self) -> 'BinaryIO':
  class TextIO (line 1951) | class TextIO(IO[str]):
    method buffer (line 1958) | def buffer(self) -> BinaryIO:
    method encoding (line 1963) | def encoding(self) -> str:
    method errors (line 1968) | def errors(self) -> Optional[str]:
    method line_buffering (line 1973) | def line_buffering(self) -> bool:
    method newlines (line 1978) | def newlines(self) -> Any:
    method __enter__ (line 1982) | def __enter__(self) -> 'TextIO':
  class io (line 1986) | class io:
  class re (line 2001) | class re:

FILE: rd/usr/lib/python3.8/uu.py
  class Error (line 39) | class Error(Exception):
  function encode (line 42) | def encode(in_file, out_file, name=None, mode=None, *, backtick=False):
  function decode (line 100) | def decode(in_file, out_file=None, mode=None, quiet=False):
  function test (line 167) | def test():

FILE: rd/usr/lib/python3.8/uuid.py
  class SafeUUID (line 70) | class SafeUUID(Enum):
  class UUID (line 76) | class UUID:
    method __init__ (line 130) | def __init__(self, hex=None, bytes=None, bytes_le=None, fields=None,
    method __getstate__ (line 216) | def __getstate__(self):
    method __setstate__ (line 224) | def __setstate__(self, state):
    method __eq__ (line 231) | def __eq__(self, other):
    method __lt__ (line 239) | def __lt__(self, other):
    method __gt__ (line 244) | def __gt__(self, other):
    method __le__ (line 249) | def __le__(self, other):
    method __ge__ (line 254) | def __ge__(self, other):
    method __hash__ (line 259) | def __hash__(self):
    method __int__ (line 262) | def __int__(self):
    method __repr__ (line 265) | def __repr__(self):
    method __setattr__ (line 268) | def __setattr__(self, name, value):
    method __str__ (line 271) | def __str__(self):
    method bytes (line 277) | def bytes(self):
    method bytes_le (line 281) | def bytes_le(self):
    method fields (line 287) | def fields(self):
    method time_low (line 292) | def time_low(self):
    method time_mid (line 296) | def time_mid(self):
    method time_hi_version (line 300) | def time_hi_version(self):
    method clock_seq_hi_variant (line 304) | def clock_seq_hi_variant(self):
    method clock_seq_low (line 308) | def clock_seq_low(self):
    method time (line 312) | def time(self):
    method clock_seq (line 317) | def clock_seq(self):
    method node (line 322) | def node(self):
    method hex (line 326) | def hex(self):
    method urn (line 330) | def urn(self):
    method variant (line 334) | def variant(self):
    method version (line 345) | def version(self):
  function _popen (line 350) | def _popen(command, *args):
  function _is_universal (line 384) | def _is_universal(mac):
  function _find_mac (line 387) | def _find_mac(command, args, hw_identifiers, get_index):
  function _ifconfig_getnode (line 415) | def _ifconfig_getnode():
  function _ip_getnode (line 425) | def _ip_getnode():
  function _arp_getnode (line 433) | def _arp_getnode():
  function _lanscan_getnode (line 459) | def _lanscan_getnode():
  function _netstat_getnode (line 464) | def _netstat_getnode():
  function _ipconfig_getnode (line 493) | def _ipconfig_getnode():
  function _netbios_getnode (line 522) | def _netbios_getnode():
  function _load_system_functions (line 568) | def _load_system_functions():
  function _unix_getnode (line 652) | def _unix_getnode():
  function _windll_getnode (line 659) | def _windll_getnode():
  function _random_getnode (line 667) | def _random_getnode():
  function getnode (line 709) | def getnode(*, getters=None):
  function uuid1 (line 733) | def uuid1(node=None, clock_seq=None):
  function uuid3 (line 772) | def uuid3(namespace, name):
  function uuid4 (line 778) | def uuid4():
  function uuid5 (line 782) | def uuid5(namespace, name):

FILE: rd/usr/lib/python3.8/warnings.py
  function showwarning (line 10) | def showwarning(message, category, filename, lineno, file=None, line=None):
  function formatwarning (line 15) | def formatwarning(message, category, filename, lineno, line=None):
  function _showwarnmsg_impl (line 20) | def _showwarnmsg_impl(msg):
  function _formatwarnmsg_impl (line 35) | def _formatwarnmsg_impl(msg):
  function _showwarnmsg (line 96) | def _showwarnmsg(msg):
  function _formatwarnmsg (line 117) | def _formatwarnmsg(msg):
  function filterwarnings (line 130) | def filterwarnings(action, message="", category=Warning, module="", line...
  function simplefilter (line 165) | def simplefilter(action, category=Warning, lineno=0, append=False):
  function _add_filter (line 181) | def _add_filter(*item, append):
  function resetwarnings (line 195) | def resetwarnings():
  class _OptionError (line 200) | class _OptionError(Exception):
  function _processoptions (line 205) | def _processoptions(args):
  function _setoption (line 213) | def _setoption(arg):
  function _getaction (line 241) | def _getaction(action):
  function _getcategory (line 251) | def _getcategory(category):
  function _is_internal_frame (line 272) | def _is_internal_frame(frame):
  function _next_external_frame (line 278) | def _next_external_frame(frame):
  function warn (line 287) | def warn(message, category=None, stacklevel=1, source=None):
  function warn_explicit (line 327) | def warn_explicit(message, category, filename, lineno,
  class WarningMessage (line 398) | class WarningMessage(object):
    method __init__ (line 403) | def __init__(self, message, category, filename, lineno, file=None,
    method __str__ (line 414) | def __str__(self):
  class catch_warnings (line 420) | class catch_warnings(object):
    method __init__ (line 437) | def __init__(self, *, record=False, module=None):
    method __repr__ (line 449) | def __repr__(self):
    method __enter__ (line 458) | def __enter__(self):
    method __exit__ (line 477) | def __exit__(self, *exc_info):
  function _warn_unawaited_coroutine (line 487) | def _warn_unawaited_coroutine(coro):
  function _filters_mutated (line 530) | def _filters_mutated():

FILE: rd/usr/lib/python3.8/wave.py
  class Error (line 78) | class Error(Exception):
  class Wave_read (line 95) | class Wave_read:
    method initfp (line 126) | def initfp(self, file):
    method __init__ (line 157) | def __init__(self, f):
    method __del__ (line 170) | def __del__(self):
    method __enter__ (line 173) | def __enter__(self):
    method __exit__ (line 176) | def __exit__(self, *args):
    method getfp (line 182) | def getfp(self):
    method rewind (line 185) | def rewind(self):
    method close (line 189) | def close(self):
    method tell (line 196) | def tell(self):
    method getnchannels (line 199) | def getnchannels(self):
    method getnframes (line 202) | def getnframes(self):
    method getsampwidth (line 205) | def getsampwidth(self):
    method getframerate (line 208) | def getframerate(self):
    method getcomptype (line 211) | def getcomptype(self):
    method getcompname (line 214) | def getcompname(self):
    method getparams (line 217) | def getparams(self):
    method getmarkers (line 222) | def getmarkers(self):
    method getmark (line 225) | def getmark(self, id):
    method setpos (line 228) | def setpos(self, pos):
    method readframes (line 234) | def readframes(self, nframes):
    method _read_fmt_chunk (line 255) | def _read_fmt_chunk(self, chunk):
  class Wave_write (line 276) | class Wave_write:
    method __init__ (line 302) | def __init__(self, f):
    method initfp (line 314) | def initfp(self, file):
    method __del__ (line 326) | def __del__(self):
    method __enter__ (line 329) | def __enter__(self):
    method __exit__ (line 332) | def __exit__(self, *args):
    method setnchannels (line 338) | def setnchannels(self, nchannels):
    method getnchannels (line 345) | def getnchannels(self):
    method setsampwidth (line 350) | def setsampwidth(self, sampwidth):
    method getsampwidth (line 357) | def getsampwidth(self):
    method setframerate (line 362) | def setframerate(self, framerate):
    method getframerate (line 369) | def getframerate(self):
    method setnframes (line 374) | def setnframes(self, nframes):
    method getnframes (line 379) | def getnframes(self):
    method setcomptype (line 382) | def setcomptype(self, comptype, compname):
    method getcomptype (line 390) | def getcomptype(self):
    method getcompname (line 393) | def getcompname(self):
    method setparams (line 396) | def setparams(self, params):
    method getparams (line 406) | def getparams(self):
    method setmark (line 412) | def setmark(self, id, pos, name):
    method getmark (line 415) | def getmark(self, id):
    method getmarkers (line 418) | def getmarkers(self):
    method tell (line 421) | def tell(self):
    method writeframesraw (line 424) | def writeframesraw(self, data):
    method writeframes (line 437) | def writeframes(self, data):
    method close (line 442) | def close(self):
    method _ensure_header_written (line 460) | def _ensure_header_written(self, datasize):
    method _write_header (line 470) | def _write_header(self, initlength):
    method _patchheader (line 491) | def _patchheader(self):
  function open (line 503) | def open(f, mode=None):
  function openfp (line 516) | def openfp(f, mode=None):

FILE: rd/usr/lib/python3.8/weakref.py
  class WeakMethod (line 36) | class WeakMethod(ref):
    method __new__ (line 44) | def __new__(cls, meth, callback=None):
    method __call__ (line 66) | def __call__(self):
    method __eq__ (line 73) | def __eq__(self, other):
    method __ne__ (line 80) | def __ne__(self, other):
  class WeakValueDictionary (line 90) | class WeakValueDictionary(_collections_abc.MutableMapping):
    method __init__ (line 102) | def __init__(self, other=(), /, **kw):
    method _commit_removals (line 119) | def _commit_removals(self):
    method __getitem__ (line 128) | def __getitem__(self, key):
    method __delitem__ (line 137) | def __delitem__(self, key):
    method __len__ (line 142) | def __len__(self):
    method __contains__ (line 147) | def __contains__(self, key):
    method __repr__ (line 156) | def __repr__(self):
    method __setitem__ (line 159) | def __setitem__(self, key, value):
    method copy (line 164) | def copy(self):
    method __deepcopy__ (line 177) | def __deepcopy__(self, memo):
    method get (line 189) | def get(self, key, default=None):
    method items (line 204) | def items(self):
    method keys (line 213) | def keys(self):
    method itervaluerefs (line 223) | def itervaluerefs(self):
    method values (line 238) | def values(self):
    method popitem (line 247) | def popitem(self):
    method pop (line 256) | def pop(self, key, *args):
    method setdefault (line 271) | def setdefault(self, key, default=None):
    method update (line 284) | def update(self, other=None, /, **kwargs):
    method valuerefs (line 296) | def valuerefs(self):
  class KeyedRef (line 311) | class KeyedRef(ref):
    method __new__ (line 323) | def __new__(type, ob, callback, key):
    method __init__ (line 328) | def __init__(self, ob, callback, key):
  class WeakKeyDictionary (line 332) | class WeakKeyDictionary(_collections_abc.MutableMapping):
    method __init__ (line 343) | def __init__(self, dict=None):
    method _commit_removals (line 360) | def _commit_removals(self):
    method _scrub_removals (line 373) | def _scrub_removals(self):
    method __delitem__ (line 378) | def __delitem__(self, key):
    method __getitem__ (line 382) | def __getitem__(self, key):
    method __len__ (line 385) | def __len__(self):
    method __repr__ (line 392) | def __repr__(self):
    method __setitem__ (line 395) | def __setitem__(self, key, value):
    method copy (line 398) | def copy(self):
    method __deepcopy__ (line 409) | def __deepcopy__(self, memo):
    method get (line 419) | def get(self, key, default=None):
    method __contains__ (line 422) | def __contains__(self, key):
    method items (line 429) | def items(self):
    method keys (line 436) | def keys(self):
    method values (line 445) | def values(self):
    method keyrefs (line 451) | def keyrefs(self):
    method popitem (line 463) | def popitem(self):
    method pop (line 471) | def pop(self, key, *args):
    method setdefault (line 475) | def setdefault(self, key, default=None):
    method update (line 478) | def update(self, dict=None, /, **kwargs):
  class finalize (line 489) | class finalize:
    class _Info (line 514) | class _Info:
    method __init__ (line 517) | def __init__(*args, **kwargs):
    method __call__ (line 561) | def __call__(self, _=None):
    method detach (line 568) | def detach(self):
    method peek (line 576) | def peek(self):
    method alive (line 585) | def alive(self):
    method atexit (line 590) | def atexit(self):
    method atexit (line 596) | def atexit(self, value):
    method __repr__ (line 601) | def __repr__(self):
    method _select_for_exit (line 611) | def _select_for_exit(cls):
    method _exitfunc (line 618) | def _exitfunc(cls):

FILE: rd/usr/lib/python3.8/webbrowser.py
  class Error (line 14) | class Error(Exception):
  function register (line 22) | def register(name, klass, instance=None, *, preferred=False):
  function get (line 37) | def get(using=None):
  function open (line 71) | def open(url, new=0, autoraise=True):
  function open_new (line 90) | def open_new(url):
  function open_new_tab (line 97) | def open_new_tab(url):
  function _synthesize (line 105) | def _synthesize(browser, *, preferred=False):
  class BaseBrowser (line 139) | class BaseBrowser(object):
    method __init__ (line 144) | def __init__(self, name=""):
    method open (line 148) | def open(self, url, new=0, autoraise=True):
    method open_new (line 151) | def open_new(self, url):
    method open_new_tab (line 154) | def open_new_tab(self, url):
  class GenericBrowser (line 158) | class GenericBrowser(BaseBrowser):
    method __init__ (line 162) | def __init__(self, name):
    method open (line 172) | def open(self, url, new=0, autoraise=True):
  class BackgroundBrowser (line 186) | class BackgroundBrowser(GenericBrowser):
    method open (line 190) | def open(self, url, new=0, autoraise=True):
  class UnixBrowser (line 205) | class UnixBrowser(BaseBrowser):
    method _invoke (line 222) | def _invoke(self, args, remote, autoraise, url=None):
    method open (line 257) | def open(self, url, new=0, autoraise=True):
  class Mozilla (line 284) | class Mozilla(UnixBrowser):
  class Netscape (line 294) | class Netscape(UnixBrowser):
  class Galeon (line 305) | class Galeon(UnixBrowser):
  class Chrome (line 315) | class Chrome(UnixBrowser):
  class Opera (line 327) | class Opera(UnixBrowser):
  class Elinks (line 337) | class Elinks(UnixBrowser):
  class Konqueror (line 351) | class Konqueror(BaseBrowser):
    method open (line 358) | def open(self, url, new=0, autoraise=True):
  class Grail (line 404) | class Grail(BaseBrowser):
    method _find_grail_rc (line 408) | def _find_grail_rc(self):
    method _remote (line 434) | def _remote(self, action):
    method open (line 442) | def open(self, url, new=0, autoraise=True):
  function register_X_browsers (line 458) | def register_X_browsers():
  function register_standard_browsers (line 523) | def register_standard_browsers():
  class WindowsDefault (line 599) | class WindowsDefault(BaseBrowser):
    method open (line 600) | def open(self, url, new=0, autoraise=True):
  class MacOSX (line 617) | class MacOSX(BaseBrowser):
    method __init__ (line 627) | def __init__(self, name):
    method open (line 630) | def open(self, url, new=0, autoraise=True):
  class MacOSXOSAScript (line 664) | class MacOSXOSAScript(BaseBrowser):
    method __init__ (line 665) | def __init__(self, name):
    method open (line 668) | def open(self, url, new=0, autoraise=True):
  function main (line 688) | def main():

FILE: rd/usr/lib/python3.8/xdrlib.py
  class Error (line 14) | class Error(Exception):
    method __init__ (line 24) | def __init__(self, msg):
    method __repr__ (line 26) | def __repr__(self):
    method __str__ (line 28) | def __str__(self):
  class ConversionError (line 32) | class ConversionError(Error):
  function raise_conversion_error (line 35) | def raise_conversion_error(function):
  class Packer (line 47) | class Packer:
    method __init__ (line 50) | def __init__(self):
    method reset (line 53) | def reset(self):
    method get_buffer (line 56) | def get_buffer(self):
    method pack_uint (line 62) | def pack_uint(self, x):
    method pack_int (line 66) | def pack_int(self, x):
    method pack_bool (line 71) | def pack_bool(self, x):
    method pack_uhyper (line 75) | def pack_uhyper(self, x):
    method pack_float (line 88) | def pack_float(self, x):
    method pack_double (line 92) | def pack_double(self, x):
    method pack_fstring (line 95) | def pack_fstring(self, n, s):
    method pack_string (line 105) | def pack_string(self, s):
    method pack_list (line 113) | def pack_list(self, list, pack_item):
    method pack_farray (line 119) | def pack_farray(self, n, list, pack_item):
    method pack_array (line 125) | def pack_array(self, list, pack_item):
  class Unpacker (line 132) | class Unpacker:
    method __init__ (line 135) | def __init__(self, data):
    method reset (line 138) | def reset(self, data):
    method get_position (line 142) | def get_position(self):
    method set_position (line 145) | def set_position(self, position):
    method get_buffer (line 148) | def get_buffer(self):
    method done (line 151) | def done(self):
    method unpack_uint (line 155) | def unpack_uint(self):
    method unpack_int (line 163) | def unpack_int(self):
    method unpack_bool (line 173) | def unpack_bool(self):
    method unpack_uhyper (line 176) | def unpack_uhyper(self):
    method unpack_hyper (line 181) | def unpack_hyper(self):
    method unpack_float (line 187) | def unpack_float(self):
    method unpack_double (line 195) | def unpack_double(self):
    method unpack_fstring (line 203) | def unpack_fstring(self, n):
    method unpack_string (line 215) | def unpack_string(self):
    method unpack_list (line 222) | def unpack_list(self, unpack_item):
    method unpack_farray (line 233) | def unpack_farray(self, n, unpack_item):
    method unpack_array (line 239) | def unpack_array(self, unpack_item):

FILE: rd/usr/lib/python3.8/zipapp.py
  class ZipAppError (line 33) | class ZipAppError(ValueError):
  function _maybe_open (line 38) | def _maybe_open(archive, mode):
  function _write_file_prefix (line 46) | def _write_file_prefix(f, interpreter):
  function _copy_archive (line 53) | def _copy_archive(archive, new_archive, interpreter=None):
  function create_archive (line 76) | def create_archive(source, target=None, interpreter=None, main=None,
  function get_interpreter (line 150) | def get_interpreter(archive):
  function main (line 156) | def main(args=None):

FILE: rd/usr/lib/python3.8/zipimport.py
  class ZipImportError (line 33) | class ZipImportError(ImportError):
  class zipimporter (line 45) | class zipimporter:
    method __init__ (line 63) | def __init__(self, path):
    method find_loader (line 109) | def find_loader(self, fullname, path=None):
    method find_module (line 141) | def find_module(self, fullname, path=None):
    method get_code (line 153) | def get_code(self, fullname):
    method get_data (line 163) | def get_data(self, pathname):
    method get_filename (line 184) | def get_filename(self, fullname):
    method get_source (line 195) | def get_source(self, fullname):
    method is_package (line 221) | def is_package(self, fullname):
    method load_module (line 234) | def load_module(self, fullname):
    method get_resource_reader (line 272) | def get_resource_reader(self, fullname):
    method __repr__ (line 290) | def __repr__(self):
  function _get_module_path (line 308) | def _get_module_path(self, fullname):
  function _is_dir (line 312) | def _is_dir(self, path):
  function _get_module_info (line 321) | def _get_module_info(self, fullname):
  function _read_directory (line 352) | def _read_directory(archive):
  function _get_decompress_func (line 510) | def _get_decompress_func():
  function _get_data (line 531) | def _get_data(archive, toc_entry):
  function _eq_mtime (line 577) | def _eq_mtime(t1, t2):
  function _unmarshal_code (line 587) | def _unmarshal_code(self, pathname, fullpath, fullname, data):
  function _normalize_line_endings (line 638) | def _normalize_line_endings(source):
  function _compile_source (line 645) | def _compile_source(pathname, source):
  function _parse_dostime (line 651) | def _parse_dostime(d, t):
  function _get_mtime_and_size_of_source (line 664) | def _get_mtime_and_size_of_source(self, path):
  function _get_pyc_source (line 683) | def _get_pyc_source(self, path):
  function _get_module_code (line 698) | def _get_module_code(self, fullname):
  class _ZipImportResourceReader (line 724) | class _ZipImportResourceReader:
    method __init__ (line 732) | def __init__(self, zipimporter, fullname):
    method open_resource (line 736) | def open_resource(self, resource):
    method resource_path (line 745) | def resource_path(self, resource):
    method is_resource (line 751) | def is_resource(self, name):
    method contents (line 762) | def contents(self):

FILE: reboot_with_cmd.c
  function main (line 6) | int main(int argc, char **argv) {