SYMBOL INDEX (545 symbols across 21 files)

FILE: basic_type.py
  class BasicType (line 7) | class BasicType(object):
    method qualified_name (line 43) | def qualified_name(self):
    method proper_name (line 50) | def proper_name(self):
    method requires (line 59) | def requires(self):
    method is_builtin (line 72) | def is_builtin(self):
    method is_overload_match (line 75) | def is_overload_match(self, other):
    method from_type (line 91) | def from_type(t):
    method from_java (line 103) | def from_java(definition):

FILE: class_loader.py
  function get_class_name (line 15) | def get_class_name(line):
  function load_class (line 21) | def load_class(name):
  function parse_class_list (line 27) | def parse_class_list(list_path=None):
  function load_all_classes (line 38) | def load_all_classes(prefix='ghidra', list_path=None):

FILE: generate_ghidra_pyi.py
  function main (line 24) | def main():

FILE: generate_stub_package.py
  function generate_package (line 5) | def generate_package(pyi_root, ghidra_version, stub_version="DEV"):

FILE: helper.py
  function get_jsondoc_basepath (line 16) | def get_jsondoc_basepath():
  function extract_jsondoc (line 24) | def extract_jsondoc():
  function are_docs_available (line 34) | def are_docs_available():
  function get_jsondoc (line 38) | def get_jsondoc(class_name):
  function json_path_to_class_name (line 49) | def json_path_to_class_name(root, name, jsondoc_basepath):
  function get_jsondoc_classes (line 57) | def get_jsondoc_classes():
  class ParamDoc (line 66) | class ParamDoc(object):
    method name (line 70) | def name(self):
    method type (line 74) | def type(self):
    method comment (line 78) | def comment(self):
  class MethodDoc (line 82) | class MethodDoc(object):
    method __init__ (line 83) | def __init__(self, jsondoc):
    method comment (line 87) | def comment(self):
    method return_type (line 91) | def return_type(self):
    method javadoc (line 95) | def javadoc(self):
    method params (line 99) | def params(self):
  class OverloadSetDoc (line 104) | class OverloadSetDoc(object):
    method is_matching_overload (line 108) | def is_matching_overload(required_args, provided_args):
    method get_overload (line 119) | def get_overload(self, param_types):
  class ClassDoc (line 130) | class ClassDoc(object):
    method __init__ (line 131) | def __init__(self, class_name):
    method _map_methods (line 140) | def _map_methods(self):
    method extends_doc (line 148) | def extends_doc(self):
    method implements_doc (line 156) | def implements_doc(self):
    method comment (line 164) | def comment(self):
    method extends (line 168) | def extends(self):
    method implements (line 172) | def implements(self):
    method name (line 176) | def name(self):
    method _get_overload_set (line 179) | def _get_overload_set(self, name):
    method get_overload_set (line 192) | def get_overload_set(self, name):

FILE: pythonscript_handler.py
  function format_method_arguments (line 31) | def format_method_arguments(argument_types):
  function format_overload_set (line 37) | def format_overload_set(overload_set):
  function is_ghidra_value (line 51) | def is_ghidra_value(value):
  function is_ghidra_method (line 55) | def is_ghidra_method(value):
  function is_instance_property (line 62) | def is_instance_property(name):
  function get_type_signature (line 71) | def get_type_signature(name, value):
  function get_formatted_overload_set (line 87) | def get_formatted_overload_set(overload_set):
  function generate_ghidra_builtins (line 91) | def generate_ghidra_builtins(my_globals):
  function create_mock (line 129) | def create_mock(pyi_root, my_globals):

FILE: type_extractor.py
  function is_nested_class (line 12) | def is_nested_class(parent, child):
  function get_members (line 27) | def get_members(obj):
  function make_valid_name (line 52) | def make_valid_name(name):
  function get_argument_names (line 58) | def get_argument_names(argument_types, docs):
  function get_return_type (line 68) | def get_return_type(return_type, docs):
  class Overload (line 78) | class Overload(object):
    method from_reflected_args (line 86) | def from_reflected_args(reflected_args, ctor_for=None, docs=None):
    method requires (line 115) | def requires(self):
  class OverloadSet (line 120) | class OverloadSet(object):
    method from_reflected_function (line 126) | def from_reflected_function(reflected_function, docs=None):
    method from_reflected_constructor (line 136) | def from_reflected_constructor(reflected_constructor, cls, docs=None):
    method requires (line 145) | def requires(self):
  class Property (line 154) | class Property(object):
    method has_setter (line 160) | def has_setter(self):
    method has_getter (line 164) | def has_getter(self):
    method from_beanproperty (line 168) | def from_beanproperty(beanproperty, name):
  class Modifier (line 185) | class Modifier(object):
    method is_static (line 189) | def is_static(self):
    method is_final (line 193) | def is_final(self):
  function pretty_repr (line 197) | def pretty_repr(value):
  class Field (line 218) | class Field(object):
    method from_reflectedfield (line 226) | def from_reflectedfield(reflectedfield, name, cls):
  class NamedObject (line 252) | class NamedObject(object):
  function group_by_typename (line 257) | def group_by_typename(items):
  class Class (line 269) | class Class(object):
    method from_class (line 281) | def from_class(cls, docs=None):
    method requires (line 341) | def requires(self):
  class Package (line 355) | class Package(object):
    method from_package (line 361) | def from_package(package):
    method requires (line 383) | def requires(self):

FILE: type_formatter.py
  function indent (line 9) | def indent(text):
  function format_overload_set (line 16) | def format_overload_set(overload_set, bound=False):
  function format_imports (line 73) | def format_imports(imports):
  function format_pyi_class (line 82) | def format_pyi_class(cls, is_nested=False):
  function write_package_classes (line 185) | def write_package_classes(root, package_path, package):
  function update_imports (line 194) | def update_imports(init_path, package):
  function get_package_path (line 215) | def get_package_path(package):
  function create_package_directories (line 220) | def create_package_directories(root, packages):
  function get_all_packages (line 229) | def get_all_packages(preparsed_packages):
  function create_type_hints (line 243) | def create_type_hints(root, *packages):

FILE: vendor/attr/_cmp.py
  function cmp_using (line 14) | def cmp_using(
  function _make_init (line 103) | def _make_init():
  function _make_operator (line 117) | def _make_operator(name, func):
  function _is_comparable_to (line 140) | def _is_comparable_to(self, other):
  function _check_same_type (line 150) | def _check_same_type(self, other):

FILE: vendor/attr/_compat.py
  function isclass (line 34) | def isclass(klass):
  function new_class (line 37) | def new_class(name, bases, kwds, exec_body):
  function iteritems (line 49) | def iteritems(d):
  class ReadOnlyDict (line 53) | class ReadOnlyDict(IterableUserDict):
    method __setitem__ (line 58) | def __setitem__(self, key, val):
    method update (line 64) | def update(self, _):
    method __delitem__ (line 70) | def __delitem__(self, _):
    method clear (line 76) | def clear(self):
    method pop (line 82) | def pop(self, key, default=None):
    method popitem (line 88) | def popitem(self):
    method setdefault (line 94) | def setdefault(self, key, default=None):
    method __repr__ (line 100) | def __repr__(self):
  function metadata_proxy (line 104) | def metadata_proxy(d):
  function just_warn (line 109) | def just_warn(*args, **kw):  # pragma: no cover
  function just_warn (line 118) | def just_warn(*args, **kw):
  function isclass (line 131) | def isclass(klass):
  function iteritems (line 136) | def iteritems(d):
  function metadata_proxy (line 141) | def metadata_proxy(d):
  function make_set_closure_cell (line 145) | def make_set_closure_cell():

FILE: vendor/attr/_config.py
  function set_run_validators (line 11) | def set_run_validators(run):
  function get_run_validators (line 25) | def get_run_validators():

FILE: vendor/attr/_funcs.py
  function asdict (line 12) | def asdict(
  function _asdict_anything (line 119) | def _asdict_anything(
  function astuple (line 192) | def astuple(
  function has (line 292) | def has(cls):
  function assoc (line 304) | def assoc(inst, **changes):
  function evolve (line 344) | def evolve(inst, **changes):
  function resolve_types (line 373) | def resolve_types(cls, globalns=None, localns=None, attribs=None):

FILE: vendor/attr/_make.py
  class _Nothing (line 67) | class _Nothing(object):
    method __new__ (line 78) | def __new__(cls):
    method __repr__ (line 83) | def __repr__(self):
    method __bool__ (line 86) | def __bool__(self):
    method __len__ (line 89) | def __len__(self):
  class _CacheHashWrapper (line 99) | class _CacheHashWrapper(int):
    method __reduce__ (line 115) | def __reduce__(self, _none_constructor=getattr, _args=(0, "", None)):
    method __reduce__ (line 120) | def __reduce__(self, _none_constructor=type(None), _args=()):
  function attrib (line 124) | def attrib(
  function _compile_and_eval (line 320) | def _compile_and_eval(script, globs, locs=None, filename=""):
  function _make_method (line 328) | def _make_method(name, script, filename, globs=None):
  function _make_attr_tuple_class (line 359) | def _make_attr_tuple_class(cls_name, attr_names):
  function _is_class_var (line 401) | def _is_class_var(annot):
  function _has_own_attribute (line 418) | def _has_own_attribute(cls, attrib_name):
  function _get_annotations (line 436) | def _get_annotations(cls):
  function _counter_getter (line 446) | def _counter_getter(e):
  function _collect_base_attrs (line 453) | def _collect_base_attrs(cls, taken_attr_names):
  function _collect_base_attrs_broken (line 484) | def _collect_base_attrs_broken(cls, taken_attr_names):
  function _transform_attrs (line 512) | def _transform_attrs(
  function _frozen_setattrs (line 623) | def _frozen_setattrs(self, name, value):
  function _frozen_setattrs (line 638) | def _frozen_setattrs(self, name, value):
  function _frozen_delattrs (line 645) | def _frozen_delattrs(self, name):
  class _ClassBuilder (line 652) | class _ClassBuilder(object):
    method __init__ (line 677) | def __init__(
    method __repr__ (line 762) | def __repr__(self):
    method build_class (line 765) | def build_class(self):
    method _patch_original_class (line 776) | def _patch_original_class(self):
    method _create_slots_class (line 814) | def _create_slots_class(self):
    method add_repr (line 922) | def add_repr(self, ns):
    method add_str (line 928) | def add_str(self):
    method _make_getstate_setstate (line 941) | def _make_getstate_setstate(self):
    method make_unhashable (line 975) | def make_unhashable(self):
    method add_hash (line 979) | def add_hash(self):
    method add_init (line 991) | def add_init(self):
    method add_match_args (line 1010) | def add_match_args(self):
    method add_attrs_init (line 1017) | def add_attrs_init(self):
    method add_eq (line 1036) | def add_eq(self):
    method add_order (line 1046) | def add_order(self):
    method add_setattr (line 1056) | def add_setattr(self):
    method _add_method_dunders (line 1092) | def _add_method_dunders(self, method):
  function _determine_attrs_eq_order (line 1124) | def _determine_attrs_eq_order(cmp, eq, order, default_eq):
  function _determine_attrib_eq_order (line 1150) | def _determine_attrib_eq_order(cmp, eq, order, default_eq):
  function _determine_whether_to_implement (line 1191) | def _determine_whether_to_implement(
  function attrs (line 1219) | def attrs(
  function _has_frozen_base_class (line 1641) | def _has_frozen_base_class(cls):
  function _has_frozen_base_class (line 1654) | def _has_frozen_base_class(cls):
  function _generate_unique_filename (line 1662) | def _generate_unique_filename(cls, func_name):
  function _make_hash (line 1674) | def _make_hash(cls, attrs, frozen, cache_hash):
  function _add_hash (line 1740) | def _add_hash(cls, attrs):
  function _make_ne (line 1748) | def _make_ne():
  function _make_eq (line 1767) | def _make_eq(cls, attrs):
  function _make_order (line 1819) | def _make_order(cls, attrs):
  function _add_eq (line 1875) | def _add_eq(cls, attrs=None):
  function _make_repr (line 1890) | def _make_repr(attrs, ns, cls):
  function _make_repr (line 1954) | def _make_repr(attrs, ns, _):
  function _add_repr (line 2018) | def _add_repr(cls, ns=None, attrs=None):
  function fields (line 2029) | def fields(cls):
  function fields_dict (line 2057) | def fields_dict(cls):
  function validate (line 2085) | def validate(inst):
  function _is_slot_cls (line 2102) | def _is_slot_cls(cls):
  function _is_slot_attr (line 2106) | def _is_slot_attr(a_name, base_attr_map):
  function _make_init (line 2113) | def _make_init(
  function _setattr (line 2188) | def _setattr(attr_name, value_var, has_on_setattr):
  function _setattr_with_converter (line 2195) | def _setattr_with_converter(attr_name, value_var, has_on_setattr):
  function _assign (line 2207) | def _assign(attr_name, value, has_on_setattr):
  function _assign_with_converter (line 2218) | def _assign_with_converter(attr_name, value_var, has_on_setattr):
  function _unpack_kw_only_py2 (line 2235) | def _unpack_kw_only_py2(attr_name, default=None):
  function _unpack_kw_only_lines_py2 (line 2249) | def _unpack_kw_only_lines_py2(kw_only_args):
  function _attrs_to_init_script (line 2290) | def _attrs_to_init_script(
  class Attribute (line 2587) | class Attribute(object):
    method __init__ (line 2640) | def __init__(
    method __setattr__ (line 2693) | def __setattr__(self, name, value):
    method from_counting_attr (line 2697) | def from_counting_attr(cls, name, ca, type=None):
    method cmp (line 2728) | def cmp(self):
    method evolve (line 2737) | def evolve(self, **changes):
    method __getstate__ (line 2755) | def __getstate__(self):
    method __setstate__ (line 2764) | def __setstate__(self, state):
    method _setattrs (line 2770) | def _setattrs(self, name_values_pairs):
  class _CountingAttr (line 2809) | class _CountingAttr(object):
    method __init__ (line 2882) | def __init__(
    method validator (line 2917) | def validator(self, meth):
    method default (line 2931) | def default(self, meth):
  class Factory (line 2952) | class Factory(object):
    method __init__ (line 2969) | def __init__(self, factory, takes_self=False):
    method __getstate__ (line 2977) | def __getstate__(self):
    method __setstate__ (line 2983) | def __setstate__(self, state):
  function make_class (line 3010) | def make_class(name, attrs, bases=(object,), **attributes_arguments):
  class _AndValidator (line 3087) | class _AndValidator(object):
    method __call__ (line 3094) | def __call__(self, inst, attr, value):
  function and_ (line 3099) | def and_(*validators):
  function pipe (line 3120) | def pipe(*converters):

FILE: vendor/attr/_next_gen.py
  function define (line 24) | def define(
  function field (line 154) | def field(
  function asdict (line 191) | def asdict(inst, *, recurse=True, filter=None, value_serializer=None):
  function astuple (line 207) | def astuple(inst, *, recurse=True, filter=None):

FILE: vendor/attr/_version_info.py
  class VersionInfo (line 13) | class VersionInfo(object):
    method _from_version_string (line 40) | def _from_version_string(cls, s):
    method _ensure_tuple (line 52) | def _ensure_tuple(self, other):
    method __eq__ (line 71) | def __eq__(self, other):
    method __lt__ (line 79) | def __lt__(self, other):

FILE: vendor/attr/converters.py
  function optional (line 26) | def optional(converter):
  function default_if_none (line 65) | def default_if_none(default=NOTHING, factory=None):
  function to_bool (line 117) | def to_bool(val):

FILE: vendor/attr/exceptions.py
  class FrozenError (line 6) | class FrozenError(AttributeError):
  class FrozenInstanceError (line 21) | class FrozenInstanceError(FrozenError):
  class FrozenAttributeError (line 29) | class FrozenAttributeError(FrozenError):
  class AttrsAttributeNotFoundError (line 37) | class AttrsAttributeNotFoundError(ValueError):
  class NotAnAttrsClassError (line 45) | class NotAnAttrsClassError(ValueError):
  class DefaultAlreadySetError (line 53) | class DefaultAlreadySetError(RuntimeError):
  class UnannotatedAttributeError (line 62) | class UnannotatedAttributeError(RuntimeError):
  class PythonTooOldError (line 71) | class PythonTooOldError(RuntimeError):
  class NotCallableError (line 80) | class NotCallableError(TypeError):
    method __init__ (line 88) | def __init__(self, msg, value):
    method __str__ (line 93) | def __str__(self):

FILE: vendor/attr/filters.py
  function _split_what (line 13) | def _split_what(what):
  function include (line 23) | def include(*what):
  function exclude (line 40) | def exclude(*what):

FILE: vendor/attr/setters.py
  function pipe (line 13) | def pipe(*setters):
  function frozen (line 31) | def frozen(_, __, ___):
  function validate (line 40) | def validate(instance, attrib, new_value):
  function convert (line 58) | def convert(instance, attrib, new_value):

FILE: vendor/attr/validators.py
  function set_disabled (line 46) | def set_disabled(disabled):
  function get_disabled (line 64) | def get_disabled():
  function disabled (line 77) | def disabled():
  class _InstanceOfValidator (line 95) | class _InstanceOfValidator(object):
    method __call__ (line 98) | def __call__(self, inst, attr, value):
    method __repr__ (line 116) | def __repr__(self):
  function instance_of (line 122) | def instance_of(type):
  class _MatchesReValidator (line 139) | class _MatchesReValidator(object):
    method __call__ (line 143) | def __call__(self, inst, attr, value):
    method __repr__ (line 158) | def __repr__(self):
  function matches_re (line 164) | def matches_re(regex, flags=0, func=None):
  class _ProvidesValidator (line 220) | class _ProvidesValidator(object):
    method __call__ (line 223) | def __call__(self, inst, attr, value):
    method __repr__ (line 238) | def __repr__(self):
  function provides (line 244) | def provides(interface):
  class _OptionalValidator (line 262) | class _OptionalValidator(object):
    method __call__ (line 265) | def __call__(self, inst, attr, value):
    method __repr__ (line 271) | def __repr__(self):
  function optional (line 277) | def optional(validator):
  class _InValidator (line 296) | class _InValidator(object):
    method __call__ (line 299) | def __call__(self, inst, attr, value):
    method __repr__ (line 312) | def __repr__(self):
  function in_ (line 318) | def in_(options):
  class _IsCallableValidator (line 337) | class _IsCallableValidator(object):
    method __call__ (line 338) | def __call__(self, inst, attr, value):
    method __repr__ (line 354) | def __repr__(self):
  function is_callable (line 358) | def is_callable():
  class _DeepIterable (line 374) | class _DeepIterable(object):
    method __call__ (line 380) | def __call__(self, inst, attr, value):
    method __repr__ (line 390) | def __repr__(self):
  function deep_iterable (line 405) | def deep_iterable(member_validator, iterable_validator=None):
  class _DeepMapping (line 421) | class _DeepMapping(object):
    method __call__ (line 426) | def __call__(self, inst, attr, value):
    method __repr__ (line 437) | def __repr__(self):
  function deep_mapping (line 443) | def deep_mapping(key_validator, value_validator, mapping_validator=None):
  class _NumberValidator (line 460) | class _NumberValidator(object):
    method __call__ (line 465) | def __call__(self, inst, attr, value):
    method __repr__ (line 479) | def __repr__(self):
  function lt (line 485) | def lt(val):
  function le (line 497) | def le(val):
  function ge (line 509) | def ge(val):
  function gt (line 521) | def gt(val):
  class _MaxLengthValidator (line 534) | class _MaxLengthValidator(object):
    method __call__ (line 537) | def __call__(self, inst, attr, value):
    method __repr__ (line 548) | def __repr__(self):
  function max_len (line 552) | def max_len(length):

FILE: vendor/typing.py
  function _qualname (line 94) | def _qualname(x):
  function _trim_name (line 102) | def _trim_name(nm):
  class TypingMeta (line 109) | class TypingMeta(type):
    method __new__ (line 119) | def __new__(cls, name, bases, namespace):
    method assert_no_subclassing (line 123) | def assert_no_subclassing(cls, bases):
    method __init__ (line 129) | def __init__(self, *args, **kwds):
    method _eval_type (line 132) | def _eval_type(self, globalns, localns):
    method _get_type_vars (line 142) | def _get_type_vars(self, tvars):
    method __repr__ (line 145) | def __repr__(self):
  class _TypingBase (line 150) | class _TypingBase(object):
    method __init__ (line 155) | def __init__(self, *args, **kwds):
    method __new__ (line 158) | def __new__(cls, *args, **kwds):
    method _eval_type (line 172) | def _eval_type(self, globalns, localns):
    method _get_type_vars (line 175) | def _get_type_vars(self, tvars):
    method __repr__ (line 178) | def __repr__(self):
    method __call__ (line 183) | def __call__(self, *args, **kwds):
  class _FinalTypingBase (line 187) | class _FinalTypingBase(_TypingBase):
    method __new__ (line 196) | def __new__(cls, *args, **kwds):
    method __reduce__ (line 202) | def __reduce__(self):
  class _ForwardRef (line 206) | class _ForwardRef(_TypingBase):
    method __init__ (line 212) | def __init__(self, arg):
    method _eval_type (line 226) | def _eval_type(self, globalns, localns):
    method __eq__ (line 240) | def __eq__(self, other):
    method __hash__ (line 246) | def __hash__(self):
    method __instancecheck__ (line 249) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 252) | def __subclasscheck__(self, cls):
    method __repr__ (line 255) | def __repr__(self):
  class _TypeAlias (line 259) | class _TypeAlias(_TypingBase):
    method __init__ (line 270) | def __init__(self, name, type_var, impl_type, type_checker):
    method __repr__ (line 290) | def __repr__(self):
    method __getitem__ (line 293) | def __getitem__(self, parameter):
    method __eq__ (line 305) | def __eq__(self, other):
    method __hash__ (line 310) | def __hash__(self):
    method __instancecheck__ (line 313) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 319) | def __subclasscheck__(self, cls):
  function _get_type_vars (line 326) | def _get_type_vars(types, tvars):
  function _type_vars (line 332) | def _type_vars(types):
  function _eval_type (line 338) | def _eval_type(t, globalns, localns):
  function _type_check (line 344) | def _type_check(arg, msg):
  function _type_repr (line 375) | def _type_repr(obj):
  class ClassVarMeta (line 394) | class ClassVarMeta(TypingMeta):
    method __new__ (line 397) | def __new__(cls, name, bases, namespace):
  class _ClassVar (line 403) | class _ClassVar(_FinalTypingBase):
    method __init__ (line 423) | def __init__(self, tp=None, _root=False):
    method __getitem__ (line 426) | def __getitem__(self, item):
    method _eval_type (line 435) | def _eval_type(self, globalns, localns):
    method __repr__ (line 439) | def __repr__(self):
    method __hash__ (line 445) | def __hash__(self):
    method __eq__ (line 448) | def __eq__(self, other):
  class _FinalMeta (line 459) | class _FinalMeta(TypingMeta):
    method __new__ (line 462) | def __new__(cls, name, bases, namespace):
  class _Final (line 468) | class _Final(_FinalTypingBase):
    method __init__ (line 487) | def __init__(self, tp=None, **kwds):
    method __getitem__ (line 490) | def __getitem__(self, item):
    method _eval_type (line 499) | def _eval_type(self, globalns, localns):
    method __repr__ (line 505) | def __repr__(self):
    method __hash__ (line 511) | def __hash__(self):
    method __eq__ (line 514) | def __eq__(self, other):
  function final (line 525) | def final(f):
  class _LiteralMeta (line 548) | class _LiteralMeta(TypingMeta):
    method __new__ (line 551) | def __new__(cls, name, bases, namespace):
  class _Literal (line 557) | class _Literal(_FinalTypingBase):
    method __init__ (line 574) | def __init__(self, values=None, **kwds):
    method __getitem__ (line 577) | def __getitem__(self, item):
    method _eval_type (line 587) | def _eval_type(self, globalns, localns):
    method __repr__ (line 590) | def __repr__(self):
    method __hash__ (line 596) | def __hash__(self):
    method __eq__ (line 599) | def __eq__(self, other):
  class AnyMeta (line 610) | class AnyMeta(TypingMeta):
    method __new__ (line 613) | def __new__(cls, name, bases, namespace):
  class _Any (line 619) | class _Any(_FinalTypingBase):
    method __instancecheck__ (line 633) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 636) | def __subclasscheck__(self, cls):
  class NoReturnMeta (line 643) | class NoReturnMeta(TypingMeta):
    method __new__ (line 646) | def __new__(cls, name, bases, namespace):
  class _NoReturn (line 652) | class _NoReturn(_FinalTypingBase):
    method __instancecheck__ (line 667) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 670) | def __subclasscheck__(self, cls):
  class TypeVarMeta (line 677) | class TypeVarMeta(TypingMeta):
    method __new__ (line 678) | def __new__(cls, name, bases, namespace):
  class TypeVar (line 683) | class TypeVar(_TypingBase):
    method __init__ (line 729) | def __init__(self, name, *constraints, **kwargs):
    method _get_type_vars (line 750) | def _get_type_vars(self, tvars):
    method __repr__ (line 754) | def __repr__(self):
    method __instancecheck__ (line 763) | def __instancecheck__(self, instance):
    method __subclasscheck__ (line 766) | def __subclasscheck__(self, cls):
  function _replace_arg (line 785) | def _replace_arg(arg, tvars, args):
  function _subs_tree (line 812) | def _subs_tree(cls, tvars=None, args=None):
  function _remove_dups_flatten (line 845) | def _remove_dups_flatten(parameters):
  function _check_generic (line 886) | def _check_generic(cls, parameters):
  function _tp_cache (line 900) | def _tp_cache(func):
  class UnionMeta (line 924) | class UnionMeta(TypingMeta):
    method __new__ (line 927) | def __new__(cls, name, bases, namespace):
  class _Union (line 932) | class _Union(_FinalTypingBase):
    method __new__ (line 979) | def __new__(cls, parameters=None, origin=None, *args, **kwds):
    method _eval_type (line 1006) | def _eval_type(self, globalns, localns):
    method _get_type_vars (line 1016) | def _get_type_vars(self, tvars):
    method __repr__ (line 1020) | def __repr__(self):
    method _tree_repr (line 1028) | def _tree_repr(self, tree):
    method __getitem__ (line 1038) | def __getitem__(self, parameters):
    method _subs_tree (line 1052) | def _subs_tree(self, tvars=None, args=None):
    method __eq__ (line 1061) | def __eq__(self, other):
    method __hash__ (line 1069) | def __hash__(self):
    method __instancecheck__ (line 1072) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 1075) | def __subclasscheck__(self, cls):
  class OptionalMeta (line 1082) | class OptionalMeta(TypingMeta):
    method __new__ (line 1085) | def __new__(cls, name, bases, namespace):
  class _Optional (line 1090) | class _Optional(_FinalTypingBase):
    method __getitem__ (line 1100) | def __getitem__(self, arg):
  function _next_in_mro (line 1108) | def _next_in_mro(cls):
  function _make_subclasshook (line 1122) | def _make_subclasshook(cls):
  class GenericMeta (line 1152) | class GenericMeta(TypingMeta, abc.ABCMeta):
    method __new__ (line 1167) | def __new__(cls, name, bases, namespace,
    method __init__ (line 1259) | def __init__(self, *args, **kwargs):
    method _abc_negative_cache (line 1273) | def _abc_negative_cache(self):
    method _abc_negative_cache (line 1279) | def _abc_negative_cache(self, value):
    method _abc_negative_cache_version (line 1287) | def _abc_negative_cache_version(self):
    method _abc_negative_cache_version (line 1293) | def _abc_negative_cache_version(self, value):
    method _get_type_vars (line 1300) | def _get_type_vars(self, tvars):
    method _eval_type (line 1304) | def _eval_type(self, globalns, localns):
    method __repr__ (line 1320) | def __repr__(self):
    method _tree_repr (line 1325) | def _tree_repr(self, tree):
    method _subs_tree (line 1336) | def _subs_tree(self, tvars=None, args=None):
    method __eq__ (line 1342) | def __eq__(self, other):
    method __hash__ (line 1349) | def __hash__(self):
    method __getitem__ (line 1353) | def __getitem__(self, params):
    method __subclasscheck__ (line 1394) | def __subclasscheck__(self, cls):
    method __instancecheck__ (line 1412) | def __instancecheck__(self, instance):
    method __setattr__ (line 1422) | def __setattr__(self, attr, value):
  function _copy_generic (line 1433) | def _copy_generic(self):
  function _generic_new (line 1447) | def _generic_new(base_cls, cls, *args, **kwds):
  class Generic (line 1471) | class Generic(object):
    method __new__ (line 1495) | def __new__(cls, *args, **kwds):
  class _TypingEmpty (line 1502) | class _TypingEmpty(object):
  class _TypingEllipsis (line 1509) | class _TypingEllipsis(object):
  class TupleMeta (line 1513) | class TupleMeta(GenericMeta):
    method __getitem__ (line 1517) | def __getitem__(self, parameters):
    method __instancecheck__ (line 1534) | def __instancecheck__(self, obj):
    method __subclasscheck__ (line 1540) | def __subclasscheck__(self, cls):
  class Tuple (line 1550) | class Tuple(tuple):
    method __new__ (line 1564) | def __new__(cls, *args, **kwds):
  class CallableMeta (line 1571) | class CallableMeta(GenericMeta):
    method __repr__ (line 1574) | def __repr__(self):
    method _tree_repr (line 1579) | def _tree_repr(self, tree):
    method __getitem__ (line 1595) | def __getitem__(self, parameters):
    method __getitem_inner__ (line 1616) | def __getitem_inner__(self, parameters):
  class Callable (line 1631) | class Callable(object):
    method __new__ (line 1646) | def __new__(cls, *args, **kwds):
  function cast (line 1653) | def cast(typ, val):
  function _get_defaults (line 1664) | def _get_defaults(func):
  function get_type_hints (line 1680) | def get_type_hints(obj, globalns=None, localns=None):
  function no_type_check (line 1685) | def no_type_check(arg):
  function no_type_check_decorator (line 1711) | def no_type_check_decorator(decorator):
  function _overload_dummy (line 1727) | def _overload_dummy(*args, **kwds):
  function overload (line 1736) | def overload(func):
  class _ProtocolMeta (line 1770) | class _ProtocolMeta(GenericMeta):
    method __init__ (line 1776) | def __init__(cls, *args, **kwargs):
    method __instancecheck__ (line 1819) | def __instancecheck__(self, instance):
    method __subclasscheck__ (line 1838) | def __subclasscheck__(self, cls):
    method _get_protocol_attrs (line 1855) | def _get_protocol_attrs(self):
  class Protocol (line 1875) | class Protocol(object):
    method __new__ (line 1913) | def __new__(cls, *args, **kwds):
  function runtime_checkable (line 1920) | def runtime_checkable(cls):
  class Iterable (line 1941) | class Iterable(Generic[T_co]):
  class Iterator (line 1946) | class Iterator(Iterable[T_co]):
  class SupportsInt (line 1952) | class SupportsInt(Protocol):
    method __int__ (line 1956) | def __int__(self):
  class SupportsFloat (line 1961) | class SupportsFloat(Protocol):
    method __float__ (line 1965) | def __float__(self):
  class SupportsComplex (line 1970) | class SupportsComplex(Protocol):
    method __complex__ (line 1974) | def __complex__(self):
  class SupportsIndex (line 1979) | class SupportsIndex(Protocol):
    method __index__ (line 1983) | def __index__(self):
  class SupportsAbs (line 1988) | class SupportsAbs(Protocol[T_co]):
    method __abs__ (line 1992) | def __abs__(self):
  class Reversible (line 1997) | class Reversible(Iterable[T_co]):
    method __reversed__ (line 2006) | def __reversed__(self):
  class Reversible (line 2002) | class Reversible(Protocol[T_co]):
    method __reversed__ (line 2006) | def __reversed__(self):
  class Container (line 2013) | class Container(Generic[T_co]):
  class AbstractSet (line 2021) | class AbstractSet(Sized, Iterable[T_co], Container[T_co]):
  class MutableSet (line 2026) | class MutableSet(AbstractSet[T]):
  class Mapping (line 2032) | class Mapping(Sized, Iterable[KT], Container[KT], Generic[KT, VT_co]):
  class MutableMapping (line 2037) | class MutableMapping(Mapping[KT, VT]):
  class Sequence (line 2043) | class Sequence(Sized, Reversible[T_co], Container[T_co]):
  class Sequence (line 2047) | class Sequence(Sized, Iterable[T_co], Container[T_co]):
  class MutableSequence (line 2052) | class MutableSequence(Sequence[T]):
  class ByteString (line 2057) | class ByteString(Sequence[int]):
  class List (line 2065) | class List(list, MutableSequence[T]):
    method __new__ (line 2069) | def __new__(cls, *args, **kwds):
  class Deque (line 2076) | class Deque(collections.deque, MutableSequence[T]):
    method __new__ (line 2080) | def __new__(cls, *args, **kwds):
  class Set (line 2086) | class Set(set, MutableSet[T]):
    method __new__ (line 2090) | def __new__(cls, *args, **kwds):
  class FrozenSet (line 2097) | class FrozenSet(frozenset, AbstractSet[T_co]):
    method __new__ (line 2101) | def __new__(cls, *args, **kwds):
  class MappingView (line 2108) | class MappingView(Sized, Iterable[T_co]):
  class KeysView (line 2113) | class KeysView(MappingView[KT], AbstractSet[KT]):
  class ItemsView (line 2118) | class ItemsView(MappingView[Tuple[KT, VT_co]],
  class ValuesView (line 2125) | class ValuesView(MappingView[VT_co]):
  class ContextManager (line 2130) | class ContextManager(Generic[T_co]):
    method __enter__ (line 2133) | def __enter__(self):
    method __exit__ (line 2137) | def __exit__(self, exc_type, exc_value, traceback):
    method __subclasshook__ (line 2141) | def __subclasshook__(cls, C):
  class Dict (line 2154) | class Dict(dict, MutableMapping[KT, VT]):
    method __new__ (line 2158) | def __new__(cls, *args, **kwds):
  class DefaultDict (line 2165) | class DefaultDict(collections.defaultdict, MutableMapping[KT, VT]):
    method __new__ (line 2169) | def __new__(cls, *args, **kwds):
  class Counter (line 2175) | class Counter(collections.Counter, Dict[T, int]):
    method __new__ (line 2179) | def __new__(cls, *args, **kwds):
  class Generator (line 2194) | class Generator(Iterator[T_co], Generic[T_co, T_contra, V_co]):
    method __new__ (line 2198) | def __new__(cls, *args, **kwds):
  class Type (line 2210) | class Type(Generic[CT_co]):
  function NamedTuple (line 2237) | def NamedTuple(typename, fields):
  function _check_fails (line 2264) | def _check_fails(cls, other):
  function _dict_new (line 2274) | def _dict_new(cls, *args, **kwargs):
  function _typeddict_new (line 2278) | def _typeddict_new(cls, _typename, _fields=None, **kwargs):
  class _TypedDictMeta (line 2296) | class _TypedDictMeta(type):
    method __new__ (line 2297) | def __new__(cls, name, bases, ns, total=True):
  function NewType (line 2345) | def NewType(name, tp):
  class IO (line 2382) | class IO(Generic[AnyStr]):
    method mode (line 2398) | def mode(self):
    method name (line 2402) | def name(self):
    method close (line 2406) | def close(self):
    method closed (line 2410) | def closed(self):
    method fileno (line 2414) | def fileno(self):
    method flush (line 2418) | def flush(self):
    method isatty (line 2422) | def isatty(self):
    method read (line 2426) | def read(self, n=-1):
    method readable (line 2430) | def readable(self):
    method readline (line 2434) | def readline(self, limit=-1):
    method readlines (line 2438) | def readlines(self, hint=-1):
    method seek (line 2442) | def seek(self, offset, whence=0):
    method seekable (line 2446) | def seekable(self):
    method tell (line 2450) | def tell(self):
    method truncate (line 2454) | def truncate(self, size=None):
    method writable (line 2458) | def writable(self):
    method write (line 2462) | def write(self, s):
    method writelines (line 2466) | def writelines(self, lines):
    method __enter__ (line 2470) | def __enter__(self):
    method __exit__ (line 2474) | def __exit__(self, type, value, traceback):
  class BinaryIO (line 2478) | class BinaryIO(IO[bytes]):
    method write (line 2484) | def write(self, s):
    method __enter__ (line 2488) | def __enter__(self):
  class TextIO (line 2492) | class TextIO(IO[unicode]):
    method buffer (line 2498) | def buffer(self):
    method encoding (line 2502) | def encoding(self):
    method errors (line 2506) | def errors(self):
    method line_buffering (line 2510) | def line_buffering(self):
    method newlines (line 2514) | def newlines(self):
    method __enter__ (line 2518) | def __enter__(self):
  class io (line 2522) | class io(object):
  class re (line 2541) | class re(object):