':
msg = 'Generator has incompatible item type {}'.format(
self.format_simple(arg_type))
else:
try:
expected_type = callee.arg_types[m - 1]
except IndexError: # Varargs callees
expected_type = callee.arg_types[-1]
arg_type_str, expected_type_str = self.format_distinctly(arg_type, expected_type)
if arg_kind == ARG_STAR:
arg_type_str = '*' + arg_type_str
elif arg_kind == ARG_STAR2:
arg_type_str = '**' + arg_type_str
msg = 'Argument {} {}has incompatible type {}; expected {}'.format(
n, target, arg_type_str, expected_type_str)
self.fail(msg, context)
def invalid_index_type(self, index_type: Type, expected_type: Type, base_str: str,
context: Context) -> None:
self.fail('Invalid index type {} for {}; expected type {}'.format(
self.format(index_type), base_str, self.format(expected_type)), context)
def too_few_arguments(self, callee: CallableType, context: Context,
argument_names: List[str]) -> None:
if (argument_names is not None and not all(k is None for k in argument_names)
and len(argument_names) >= 1):
diff = [k for k in callee.arg_names if k not in argument_names]
if len(diff) == 1:
msg = 'Missing positional argument'
else:
msg = 'Missing positional arguments'
if callee.name and diff:
msg += ' "{}" in call to {}'.format('", "'.join(diff), callee.name)
else:
msg = 'Too few arguments'
if callee.name:
msg += ' for {}'.format(callee.name)
self.fail(msg, context)
def missing_named_argument(self, callee: CallableType, context: Context, name: str) -> None:
msg = 'Missing named argument "{}"'.format(name)
if callee.name:
msg += ' for function {}'.format(callee.name)
self.fail(msg, context)
def too_many_arguments(self, callee: CallableType, context: Context) -> None:
msg = 'Too many arguments'
if callee.name:
msg += ' for {}'.format(callee.name)
self.fail(msg, context)
def too_many_positional_arguments(self, callee: CallableType,
context: Context) -> None:
msg = 'Too many positional arguments'
if callee.name:
msg += ' for {}'.format(callee.name)
self.fail(msg, context)
def unexpected_keyword_argument(self, callee: CallableType, name: str,
context: Context) -> None:
msg = 'Unexpected keyword argument "{}"'.format(name)
if callee.name:
msg += ' for {}'.format(callee.name)
self.fail(msg, context)
if callee.definition:
fullname = callee.definition.fullname()
if fullname is not None and '.' in fullname:
module_name = fullname.rsplit('.', 1)[0]
path = self.modules[module_name].path
self.note('{} defined here'.format(callee.name), callee.definition,
file=path, origin=context)
def duplicate_argument_value(self, callee: CallableType, index: int,
context: Context) -> None:
self.fail('{} gets multiple values for keyword argument "{}"'.
format(capitalize(callable_name(callee)),
callee.arg_names[index]), context)
def does_not_return_value(self, unusable_type: Type, context: Context) -> None:
"""Report an error about use of an unusable type.
If the type is a Void type and has a source in it, report it in the error message.
This allows giving messages such as 'Foo does not return a value'.
"""
if isinstance(unusable_type, Void) and unusable_type.source is not None:
self.fail('{} does not return a value'.format(
capitalize((cast(Void, unusable_type)).source)), context)
else:
self.fail('Function does not return a value', context)
def deleted_as_rvalue(self, typ: DeletedType, context: Context) -> None:
"""Report an error about using an deleted type as an rvalue."""
if typ.source is None:
s = ""
else:
s = " '{}'".format(typ.source)
self.fail('Trying to read deleted variable{}'.format(s), context)
def deleted_as_lvalue(self, typ: DeletedType, context: Context) -> None:
"""Report an error about using an deleted type as an lvalue.
Currently, this only occurs when trying to assign to an
exception variable outside the local except: blocks.
"""
if typ.source is None:
s = ""
else:
s = " '{}'".format(typ.source)
self.fail('Assignment to variable{} outside except: block'.format(s), context)
def no_variant_matches_arguments(self, overload: Overloaded, arg_types: List[Type],
context: Context) -> None:
if overload.name():
self.fail('No overload variant of {} matches argument types {}'
.format(overload.name(), arg_types), context)
else:
self.fail('No overload variant matches argument types {}'.format(arg_types), context)
def invalid_cast(self, target_type: Type, source_type: Type,
context: Context) -> None:
if not self.check_unusable_type(source_type, context):
self.fail('Cannot cast from {} to {}'.format(
self.format(source_type), self.format(target_type)), context)
def wrong_number_values_to_unpack(self, provided: int, expected: int,
context: Context) -> None:
if provided < expected:
if provided == 1:
self.fail('Need more than 1 value to unpack ({} expected)'.format(expected),
context)
else:
self.fail('Need more than {} values to unpack ({} expected)'.format(
provided, expected), context)
elif provided > expected:
self.fail('Too many values to unpack ({} expected, {} provided)'.format(
expected, provided), context)
def type_not_iterable(self, type: Type, context: Context) -> None:
self.fail('\'{}\' object is not iterable'.format(type), context)
def incompatible_operator_assignment(self, op: str,
context: Context) -> None:
self.fail('Result type of {} incompatible in assignment'.format(op),
context)
def signature_incompatible_with_supertype(
self, name: str, name_in_super: str, supertype: str,
context: Context) -> None:
target = self.override_target(name, name_in_super, supertype)
self.fail('Signature of "{}" incompatible with {}'.format(
name, target), context)
def argument_incompatible_with_supertype(
self, arg_num: int, name: str, name_in_supertype: str,
supertype: str, context: Context) -> None:
target = self.override_target(name, name_in_supertype, supertype)
self.fail('Argument {} of "{}" incompatible with {}'
.format(arg_num, name, target), context)
def return_type_incompatible_with_supertype(
self, name: str, name_in_supertype: str, supertype: str,
context: Context) -> None:
target = self.override_target(name, name_in_supertype, supertype)
self.fail('Return type of "{}" incompatible with {}'
.format(name, target), context)
def override_target(self, name: str, name_in_super: str,
supertype: str) -> str:
target = 'supertype "{}"'.format(supertype)
if name_in_super != name:
target = '"{}" of {}'.format(name_in_super, target)
return target
def incompatible_type_application(self, expected_arg_count: int,
actual_arg_count: int,
context: Context) -> None:
if expected_arg_count == 0:
self.fail('Type application targets a non-generic function or class',
context)
elif actual_arg_count > expected_arg_count:
self.fail('Type application has too many types ({} expected)'
.format(expected_arg_count), context)
else:
self.fail('Type application has too few types ({} expected)'
.format(expected_arg_count), context)
def could_not_infer_type_arguments(self, callee_type: CallableType, n: int,
context: Context) -> None:
if callee_type.name and n > 0:
self.fail('Cannot infer type argument {} of {}'.format(
n, callee_type.name), context)
else:
self.fail('Cannot infer function type argument', context)
def invalid_var_arg(self, typ: Type, context: Context) -> None:
self.fail('List or tuple expected as variable arguments', context)
def invalid_keyword_var_arg(self, typ: Type, context: Context) -> None:
if isinstance(typ, Instance) and (typ.type.fullname() == 'builtins.dict'):
self.fail('Keywords must be strings', context)
else:
self.fail('Argument after ** must be a dictionary',
context)
def undefined_in_superclass(self, member: str, context: Context) -> None:
self.fail('"{}" undefined in superclass'.format(member), context)
def check_unusable_type(self, typ: Type, context: Context) -> bool:
"""If type is a type which is not meant to be used (like Void or
NoneTyp(is_ret_type=True)), report an error such as '.. does not
return a value' and return True. Otherwise, return False.
"""
if (isinstance(typ, Void) or
(isinstance(typ, NoneTyp) and typ.is_ret_type)):
self.does_not_return_value(typ, context)
return True
else:
return False
def too_few_string_formatting_arguments(self, context: Context) -> None:
self.fail('Not enough arguments for format string', context)
def too_many_string_formatting_arguments(self, context: Context) -> None:
self.fail('Not all arguments converted during string formatting', context)
def unsupported_placeholder(self, placeholder: str, context: Context) -> None:
self.fail('Unsupported format character \'%s\'' % placeholder, context)
def string_interpolation_with_star_and_key(self, context: Context) -> None:
self.fail('String interpolation contains both stars and mapping keys', context)
def requires_int_or_char(self, context: Context) -> None:
self.fail('%c requires int or char', context)
def key_not_in_mapping(self, key: str, context: Context) -> None:
self.fail('Key \'%s\' not found in mapping' % key, context)
def string_interpolation_mixing_key_and_non_keys(self, context: Context) -> None:
self.fail('String interpolation mixes specifier with and without mapping keys', context)
def cannot_determine_type(self, name: str, context: Context) -> None:
self.fail("Cannot determine type of '%s'" % name, context)
def cannot_determine_type_in_base(self, name: str, base: str, context: Context) -> None:
self.fail("Cannot determine type of '%s' in base class '%s'" % (name, base), context)
def invalid_method_type(self, sig: CallableType, context: Context) -> None:
self.fail('Invalid method type', context)
def invalid_class_method_type(self, sig: CallableType, context: Context) -> None:
self.fail('Invalid class method type', context)
def incompatible_conditional_function_def(self, defn: FuncDef) -> None:
self.fail('All conditional function variants must have identical '
'signatures', defn)
def cannot_instantiate_abstract_class(self, class_name: str,
abstract_attributes: List[str],
context: Context) -> None:
attrs = format_string_list("'%s'" % a for a in abstract_attributes)
self.fail("Cannot instantiate abstract class '%s' with abstract "
"attribute%s %s" % (class_name, plural_s(abstract_attributes),
attrs),
context)
def base_class_definitions_incompatible(self, name: str, base1: TypeInfo,
base2: TypeInfo,
context: Context) -> None:
self.fail('Definition of "{}" in base class "{}" is incompatible '
'with definition in base class "{}"'.format(
name, base1.name(), base2.name()), context)
def cant_assign_to_method(self, context: Context) -> None:
self.fail(CANNOT_ASSIGN_TO_METHOD, context)
def read_only_property(self, name: str, type: TypeInfo,
context: Context) -> None:
self.fail('Property "{}" defined in "{}" is read-only'.format(
name, type.name()), context)
def incompatible_typevar_value(self, callee: CallableType, index: int,
type: Type, context: Context) -> None:
self.fail('Type argument {} of {} has incompatible value {}'.format(
index, callable_name(callee), self.format(type)), context)
def overloaded_signatures_overlap(self, index1: int, index2: int,
context: Context) -> None:
self.fail('Overloaded function signatures {} and {} overlap with '
'incompatible return types'.format(index1, index2), context)
def operator_method_signatures_overlap(
self, reverse_class: str, reverse_method: str, forward_class: str,
forward_method: str, context: Context) -> None:
self.fail('Signatures of "{}" of "{}" and "{}" of "{}" '
'are unsafely overlapping'.format(
reverse_method, reverse_class,
forward_method, forward_class),
context)
def forward_operator_not_callable(
self, forward_method: str, context: Context) -> None:
self.fail('Forward operator "{}" is not callable'.format(
forward_method), context)
def signatures_incompatible(self, method: str, other_method: str,
context: Context) -> None:
self.fail('Signatures of "{}" and "{}" are incompatible'.format(
method, other_method), context)
def yield_from_invalid_operand_type(self, expr: Type, context: Context) -> Type:
text = self.format(expr) if self.format(expr) != 'object' else expr
self.fail('"yield from" can\'t be applied to {}'.format(text), context)
return AnyType()
def invalid_signature(self, func_type: Type, context: Context) -> None:
self.fail('Invalid signature "{}"'.format(func_type), context)
def reveal_type(self, typ: Type, context: Context) -> None:
self.fail('Revealed type is \'{}\''.format(typ), context)
def unsupported_type_type(self, item: Type, context: Context) -> None:
self.fail('Unsupported type Type[{}]'.format(self.format(item)), context)
def redundant_cast(self, typ: Type, context: Context) -> None:
self.note('Redundant cast to {}'.format(self.format(typ)), context)
def typeddict_instantiated_with_unexpected_items(self,
expected_item_names: List[str],
actual_item_names: List[str],
context: Context) -> None:
self.fail('Expected items {} but found {}.'.format(
expected_item_names, actual_item_names), context)
def typeddict_item_name_must_be_string_literal(self,
typ: TypedDictType,
context: Context,
) -> None:
self.fail('Cannot prove expression is a valid item name; expected one of {}'.format(
format_item_name_list(typ.items.keys())), context)
def typeddict_item_name_not_found(self,
typ: TypedDictType,
item_name: str,
context: Context,
) -> None:
self.fail('\'{}\' is not a valid item name; expected one of {}'.format(
item_name, format_item_name_list(typ.items.keys())), context)
def capitalize(s: str) -> str:
"""Capitalize the first character of a string."""
if s == '':
return ''
else:
return s[0].upper() + s[1:]
def extract_type(name: str) -> str:
"""If the argument is the name of a method (of form C.m), return
the type portion in quotes (e.g. "y"). Otherwise, return the string
unmodified.
"""
name = re.sub('^"[a-zA-Z0-9_]+" of ', '', name)
return name
def strip_quotes(s: str) -> str:
"""Strip a double quote at the beginning and end of the string, if any."""
s = re.sub('^"', '', s)
s = re.sub('"$', '', s)
return s
def plural_s(s: Sequence[Any]) -> str:
if len(s) > 1:
return 's'
else:
return ''
def format_string_list(s: Iterable[str]) -> str:
l = list(s)
assert len(l) > 0
if len(l) == 1:
return l[0]
elif len(l) <= 5:
return '%s and %s' % (', '.join(l[:-1]), l[-1])
else:
return '%s, ... and %s (%i methods suppressed)' % (', '.join(l[:2]), l[-1], len(l) - 3)
def format_item_name_list(s: Iterable[str]) -> str:
l = list(s)
if len(l) <= 5:
return '[' + ', '.join(["'%s'" % name for name in l]) + ']'
else:
return '[' + ', '.join(["'%s'" % name for name in l[:5]]) + ', ...]'
def callable_name(type: CallableType) -> str:
if type.name:
return type.name
else:
return 'function'
def temp_message_builder() -> MessageBuilder:
"""Return a message builder usable for throwaway errors (which may not format properly)."""
return MessageBuilder(Errors(), {})
# For hard-coding suggested missing member alternatives.
COMMON_MISTAKES = {
'add': ('append', 'extend'),
} # type: Dict[str, Sequence[str]]
def best_matches(current: str, options: Iterable[str]) -> List[str]:
ratios = {v: difflib.SequenceMatcher(a=current, b=v).ratio() for v in options}
return sorted((o for o in options if ratios[o] > 0.75),
reverse=True, key=lambda v: (ratios[v], v))
def pretty_or(args: List[str]) -> str:
quoted = ['"' + a + '"' for a in args]
if len(quoted) == 1:
return quoted[0]
if len(quoted) == 2:
return "{} or {}".format(quoted[0], quoted[1])
return ", ".join(quoted[:-1]) + ", or " + quoted[-1]
mypy-0.470/mypy/solve.py 0000644 0000000 0000000 00000005217 13012205774 013726 0 ustar root root """Type inference constraint solving"""
from typing import List, Dict
from collections import defaultdict
from mypy.types import Type, Void, NoneTyp, AnyType, ErrorType, UninhabitedType, TypeVarId
from mypy.constraints import Constraint, SUPERTYPE_OF
from mypy.join import join_types
from mypy.meet import meet_types
from mypy.subtypes import is_subtype
from mypy import experiments
def solve_constraints(vars: List[TypeVarId], constraints: List[Constraint],
strict: bool =True) -> List[Type]:
"""Solve type constraints.
Return the best type(s) for type variables; each type can be None if the value of the variable
could not be solved.
If a variable has no constraints, if strict=True then arbitrarily
pick NoneTyp as the value of the type variable. If strict=False,
pick AnyType.
"""
# Collect a list of constraints for each type variable.
cmap = defaultdict(list) # type: Dict[TypeVarId, List[Constraint]]
for con in constraints:
cmap[con.type_var].append(con)
res = [] # type: List[Type]
# Solve each type variable separately.
for tvar in vars:
bottom = None # type: Type
top = None # type: Type
# Process each constraint separately, and calculate the lower and upper
# bounds based on constraints. Note that we assume that the constraint
# targets do not have constraint references.
for c in cmap.get(tvar, []):
if c.op == SUPERTYPE_OF:
if bottom is None:
bottom = c.target
else:
bottom = join_types(bottom, c.target)
else:
if top is None:
top = c.target
else:
top = meet_types(top, c.target)
if isinstance(top, AnyType) or isinstance(bottom, AnyType):
res.append(AnyType())
continue
elif bottom is None:
if top:
candidate = top
else:
# No constraints for type variable -- type 'None' is the most specific type.
if strict:
if experiments.STRICT_OPTIONAL:
candidate = UninhabitedType()
else:
candidate = NoneTyp()
else:
candidate = AnyType()
elif top is None:
candidate = bottom
elif is_subtype(bottom, top):
candidate = bottom
else:
candidate = None
if isinstance(candidate, ErrorType):
res.append(None)
else:
res.append(candidate)
return res
mypy-0.470/mypy/exprtotype.py 0000644 0000000 0000000 00000005251 13027024636 015021 0 ustar root root """Translate an Expression to a Type value."""
from mypy.nodes import (
Expression, NameExpr, MemberExpr, IndexExpr, TupleExpr,
ListExpr, StrExpr, BytesExpr, UnicodeExpr, EllipsisExpr
)
from mypy.parsetype import parse_str_as_type, TypeParseError
from mypy.types import Type, UnboundType, TypeList, EllipsisType
class TypeTranslationError(Exception):
"""Exception raised when an expression is not valid as a type."""
def expr_to_unanalyzed_type(expr: Expression) -> Type:
"""Translate an expression to the corresponding type.
The result is not semantically analyzed. It can be UnboundType or TypeList.
Raise TypeTranslationError if the expression cannot represent a type.
"""
if isinstance(expr, NameExpr):
name = expr.name
return UnboundType(name, line=expr.line, column=expr.column)
elif isinstance(expr, MemberExpr):
fullname = get_member_expr_fullname(expr)
if fullname:
return UnboundType(fullname, line=expr.line, column=expr.column)
else:
raise TypeTranslationError()
elif isinstance(expr, IndexExpr):
base = expr_to_unanalyzed_type(expr.base)
if isinstance(base, UnboundType):
if base.args:
raise TypeTranslationError()
if isinstance(expr.index, TupleExpr):
args = expr.index.items
else:
args = [expr.index]
base.args = [expr_to_unanalyzed_type(arg) for arg in args]
if not base.args:
base.empty_tuple_index = True
return base
else:
raise TypeTranslationError()
elif isinstance(expr, ListExpr):
return TypeList([expr_to_unanalyzed_type(t) for t in expr.items],
line=expr.line, column=expr.column)
elif isinstance(expr, (StrExpr, BytesExpr, UnicodeExpr)):
# Parse string literal type.
try:
result = parse_str_as_type(expr.value, expr.line)
except TypeParseError:
raise TypeTranslationError()
return result
elif isinstance(expr, EllipsisExpr):
return EllipsisType(expr.line)
else:
raise TypeTranslationError()
def get_member_expr_fullname(expr: MemberExpr) -> str:
"""Return the qualified name representation of a member expression.
Return a string of form foo.bar, foo.bar.baz, or similar, or None if the
argument cannot be represented in this form.
"""
if isinstance(expr.expr, NameExpr):
initial = expr.expr.name
elif isinstance(expr.expr, MemberExpr):
initial = get_member_expr_fullname(expr.expr)
else:
return None
return '{}.{}'.format(initial, expr.name)
mypy-0.470/mypy/stats.py 0000644 0000000 0000000 00000027443 13012205774 013741 0 ustar root root """Utilities for calculating and reporting statistics about types."""
import cgi
import os.path
from typing import Any, Dict, List, cast, Tuple
from mypy.traverser import TraverserVisitor
from mypy.types import (
Type, AnyType, Instance, FunctionLike, TupleType, Void, TypeVarType,
TypeQuery, ANY_TYPE_STRATEGY, CallableType
)
from mypy import nodes
from mypy.nodes import (
Expression, FuncDef, TypeApplication, AssignmentStmt, NameExpr, CallExpr, MypyFile,
MemberExpr, OpExpr, ComparisonExpr, IndexExpr, UnaryExpr, YieldFromExpr, RefExpr
)
TYPE_EMPTY = 0
TYPE_PRECISE = 1
TYPE_IMPRECISE = 2
TYPE_ANY = 3
precision_names = [
'empty',
'precise',
'imprecise',
'any',
]
class StatisticsVisitor(TraverserVisitor):
def __init__(self, inferred: bool, typemap: Dict[Expression, Type] = None,
all_nodes: bool = False) -> None:
self.inferred = inferred
self.typemap = typemap
self.all_nodes = all_nodes
self.num_precise = 0
self.num_imprecise = 0
self.num_any = 0
self.num_simple = 0
self.num_generic = 0
self.num_tuple = 0
self.num_function = 0
self.num_typevar = 0
self.num_complex = 0
self.line = -1
self.line_map = {} # type: Dict[int, int]
self.output = [] # type: List[str]
TraverserVisitor.__init__(self)
def visit_func_def(self, o: FuncDef) -> None:
self.line = o.line
if len(o.expanded) > 1:
if o in o.expanded:
print('ERROR: cycle in function expansion; skipping')
return
for defn in o.expanded:
self.visit_func_def(cast(FuncDef, defn))
else:
if o.type:
sig = cast(CallableType, o.type)
arg_types = sig.arg_types
if (sig.arg_names and sig.arg_names[0] == 'self' and
not self.inferred):
arg_types = arg_types[1:]
for arg in arg_types:
self.type(arg)
self.type(sig.ret_type)
elif self.all_nodes:
self.record_line(self.line, TYPE_ANY)
super().visit_func_def(o)
def visit_type_application(self, o: TypeApplication) -> None:
self.line = o.line
for t in o.types:
self.type(t)
super().visit_type_application(o)
def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
self.line = o.line
if (isinstance(o.rvalue, nodes.CallExpr) and
isinstance(o.rvalue.analyzed, nodes.TypeVarExpr)):
# Type variable definition -- not a real assignment.
return
if o.type:
self.type(o.type)
elif self.inferred:
for lvalue in o.lvalues:
if isinstance(lvalue, nodes.TupleExpr):
items = lvalue.items
elif isinstance(lvalue, nodes.ListExpr):
items = lvalue.items
else:
items = [lvalue]
for item in items:
if isinstance(item, RefExpr) and item.is_def:
t = self.typemap.get(item)
if t:
self.type(t)
else:
self.log(' !! No inferred type on line %d' %
self.line)
self.record_line(self.line, TYPE_ANY)
super().visit_assignment_stmt(o)
def visit_name_expr(self, o: NameExpr) -> None:
self.process_node(o)
super().visit_name_expr(o)
def visit_yield_from_expr(self, o: YieldFromExpr) -> None:
if o.expr:
o.expr.accept(self)
def visit_call_expr(self, o: CallExpr) -> None:
self.process_node(o)
if o.analyzed:
o.analyzed.accept(self)
else:
o.callee.accept(self)
for a in o.args:
a.accept(self)
def visit_member_expr(self, o: MemberExpr) -> None:
self.process_node(o)
super().visit_member_expr(o)
def visit_op_expr(self, o: OpExpr) -> None:
self.process_node(o)
super().visit_op_expr(o)
def visit_comparison_expr(self, o: ComparisonExpr) -> None:
self.process_node(o)
super().visit_comparison_expr(o)
def visit_index_expr(self, o: IndexExpr) -> None:
self.process_node(o)
super().visit_index_expr(o)
def visit_unary_expr(self, o: UnaryExpr) -> None:
self.process_node(o)
super().visit_unary_expr(o)
def process_node(self, node: Expression) -> None:
if self.all_nodes:
typ = self.typemap.get(node)
if typ:
self.line = node.line
self.type(typ)
def type(self, t: Type) -> None:
if isinstance(t, AnyType):
self.log(' !! Any type around line %d' % self.line)
self.num_any += 1
self.record_line(self.line, TYPE_ANY)
elif ((not self.all_nodes and is_imprecise(t)) or
(self.all_nodes and is_imprecise2(t))):
self.log(' !! Imprecise type around line %d' % self.line)
self.num_imprecise += 1
self.record_line(self.line, TYPE_IMPRECISE)
else:
self.num_precise += 1
self.record_line(self.line, TYPE_PRECISE)
if isinstance(t, Instance):
if t.args:
if any(is_complex(arg) for arg in t.args):
self.num_complex += 1
else:
self.num_generic += 1
else:
self.num_simple += 1
elif isinstance(t, Void):
self.num_simple += 1
elif isinstance(t, FunctionLike):
self.num_function += 1
elif isinstance(t, TupleType):
if any(is_complex(item) for item in t.items):
self.num_complex += 1
else:
self.num_tuple += 1
elif isinstance(t, TypeVarType):
self.num_typevar += 1
def log(self, string: str) -> None:
self.output.append(string)
def record_line(self, line: int, precision: int) -> None:
self.line_map[line] = max(precision,
self.line_map.get(line, TYPE_PRECISE))
def dump_type_stats(tree: MypyFile, path: str, inferred: bool = False,
typemap: Dict[Expression, Type] = None) -> None:
if is_special_module(path):
return
print(path)
visitor = StatisticsVisitor(inferred, typemap)
tree.accept(visitor)
for line in visitor.output:
print(line)
print(' ** precision **')
print(' precise ', visitor.num_precise)
print(' imprecise', visitor.num_imprecise)
print(' any ', visitor.num_any)
print(' ** kinds **')
print(' simple ', visitor.num_simple)
print(' generic ', visitor.num_generic)
print(' function ', visitor.num_function)
print(' tuple ', visitor.num_tuple)
print(' TypeVar ', visitor.num_typevar)
print(' complex ', visitor.num_complex)
print(' any ', visitor.num_any)
def is_special_module(path: str) -> bool:
return os.path.basename(path) in ('abc.pyi', 'typing.pyi', 'builtins.pyi')
def is_imprecise(t: Type) -> bool:
return t.accept(HasAnyQuery())
class HasAnyQuery(TypeQuery):
def __init__(self) -> None:
super().__init__(False, ANY_TYPE_STRATEGY)
def visit_any(self, t: AnyType) -> bool:
return True
def visit_instance(self, t: Instance) -> bool:
if t.type.fullname() == 'builtins.tuple':
return True
else:
return super().visit_instance(t)
def is_imprecise2(t: Type) -> bool:
return t.accept(HasAnyQuery2())
class HasAnyQuery2(HasAnyQuery):
def visit_callable_type(self, t: CallableType) -> bool:
# We don't want to flag references to functions with some Any
# argument types (etc.) since they generally don't mean trouble.
return False
def is_generic(t: Type) -> bool:
return isinstance(t, Instance) and bool(t.args)
def is_complex(t: Type) -> bool:
return is_generic(t) or isinstance(t, (FunctionLike, TupleType,
TypeVarType))
html_files = [] # type: List[Tuple[str, str, int, int]]
def generate_html_report(tree: MypyFile, path: str, type_map: Dict[Expression, Type],
output_dir: str) -> None:
if is_special_module(path):
return
# There may be more than one right answer for "what should we do here?"
# but this is a reasonable one.
path = os.path.relpath(path)
if path.startswith('..'):
return
visitor = StatisticsVisitor(inferred=True, typemap=type_map, all_nodes=True)
tree.accept(visitor)
assert not os.path.isabs(path) and not path.startswith('..')
# This line is *wrong* if the preceding assert fails.
target_path = os.path.join(output_dir, 'html', path)
# replace .py or .pyi with .html
target_path = os.path.splitext(target_path)[0] + '.html'
assert target_path.endswith('.html')
ensure_dir_exists(os.path.dirname(target_path))
output = [] # type: List[str]
append = output.append
append('''\
''')
num_imprecise_lines = 0
num_lines = 0
with open(path) as input_file:
for i, line in enumerate(input_file):
lineno = i + 1
status = visitor.line_map.get(lineno, TYPE_PRECISE)
style_map = {TYPE_PRECISE: 'white',
TYPE_IMPRECISE: 'yellow',
TYPE_ANY: 'red'}
style = style_map[status]
append('%4d ' % lineno +
'%s' % (style,
cgi.escape(line)))
if status != TYPE_PRECISE:
num_imprecise_lines += 1
if line.strip():
num_lines += 1
append('')
append('')
with open(target_path, 'w') as output_file:
output_file.writelines(output)
target_path = target_path[len(output_dir) + 1:]
html_files.append((path, target_path, num_lines, num_imprecise_lines))
def generate_html_index(output_dir: str) -> None:
path = os.path.join(output_dir, 'index.html')
output = [] # type: List[str]
append = output.append
append('''\
''')
append('Mypy Type Check Coverage Report
\n')
append('\n')
for source_path, target_path, num_lines, num_imprecise in sorted(html_files):
if num_lines == 0:
continue
source_path = os.path.normpath(source_path)
# TODO: Windows paths.
if (source_path.startswith('stubs/') or
'/stubs/' in source_path):
continue
percent = 100.0 * num_imprecise / num_lines
style = ''
if percent >= 20:
style = 'class="red"'
elif percent >= 5:
style = 'class="yellow"'
append('| %s | %.1f%% imprecise | %d LOC\n' % (
style, target_path, source_path, percent, num_lines))
append(' |
\n')
append('')
with open(path, 'w') as file:
file.writelines(output)
print('Generated HTML report (old): %s' % os.path.abspath(path))
def ensure_dir_exists(dir: str) -> None:
if not os.path.exists(dir):
os.makedirs(dir)
mypy-0.470/mypy/defaults.py 0000644 0000000 0000000 00000000145 13012205774 014400 0 ustar root root PYTHON2_VERSION = (2, 7)
PYTHON3_VERSION = (3, 5)
CACHE_DIR = '.mypy_cache'
CONFIG_FILE = 'mypy.ini'
mypy-0.470/mypy/checkexpr.py 0000644 0000000 0000000 00000322266 13044256774 014573 0 ustar root root """Expression type checker. This file is conceptually part of TypeChecker."""
from collections import OrderedDict
from typing import cast, Dict, Set, List, Iterable, Tuple, Callable, Union, Optional
from mypy.types import (
Type, AnyType, CallableType, Overloaded, NoneTyp, Void, TypeVarDef,
TupleType, TypedDictType, Instance, TypeVarId, TypeVarType, ErasedType, UnionType,
PartialType, DeletedType, UnboundType, UninhabitedType, TypeType,
true_only, false_only, is_named_instance, function_type, callable_type, FunctionLike,
get_typ_args, set_typ_args,
)
from mypy.nodes import (
NameExpr, RefExpr, Var, FuncDef, OverloadedFuncDef, TypeInfo, CallExpr,
MemberExpr, IntExpr, StrExpr, BytesExpr, UnicodeExpr, FloatExpr,
OpExpr, UnaryExpr, IndexExpr, CastExpr, RevealTypeExpr, TypeApplication, ListExpr,
TupleExpr, DictExpr, FuncExpr, SuperExpr, SliceExpr, Context, Expression,
ListComprehension, GeneratorExpr, SetExpr, MypyFile, Decorator,
ConditionalExpr, ComparisonExpr, TempNode, SetComprehension,
DictionaryComprehension, ComplexExpr, EllipsisExpr, StarExpr,
TypeAliasExpr, BackquoteExpr, ARG_POS, ARG_NAMED, ARG_STAR, ARG_STAR2, MODULE_REF,
UNBOUND_TVAR, BOUND_TVAR,
)
from mypy import nodes
import mypy.checker
from mypy import types
from mypy.sametypes import is_same_type
from mypy.erasetype import replace_meta_vars
from mypy.messages import MessageBuilder
from mypy import messages
from mypy.infer import infer_type_arguments, infer_function_type_arguments
from mypy import join
from mypy.maptype import map_instance_to_supertype
from mypy.subtypes import is_subtype, is_equivalent
from mypy import applytype
from mypy import erasetype
from mypy.checkmember import analyze_member_access, type_object_type, bind_self
from mypy.constraints import get_actual_type
from mypy.checkstrformat import StringFormatterChecker
from mypy.expandtype import expand_type, expand_type_by_instance
from mypy.util import split_module_names
from mypy.semanal import fill_typevars
from mypy import experiments
# Type of callback user for checking individual function arguments. See
# check_args() below for details.
ArgChecker = Callable[[Type, Type, int, Type, int, int, CallableType, Context, MessageBuilder],
None]
def extract_refexpr_names(expr: RefExpr) -> Set[str]:
"""Recursively extracts all module references from a reference expression.
Note that currently, the only two subclasses of RefExpr are NameExpr and
MemberExpr."""
output = set() # type: Set[str]
while expr.kind == MODULE_REF or expr.fullname is not None:
if expr.kind == MODULE_REF and expr.fullname is not None:
# If it's None, something's wrong (perhaps due to an
# import cycle or a supressed error). For now we just
# skip it.
output.add(expr.fullname)
if isinstance(expr, NameExpr):
is_suppressed_import = isinstance(expr.node, Var) and expr.node.is_suppressed_import
if isinstance(expr.node, TypeInfo):
# Reference to a class or a nested class
output.update(split_module_names(expr.node.module_name))
elif expr.fullname is not None and '.' in expr.fullname and not is_suppressed_import:
# Everything else (that is not a silenced import within a class)
output.add(expr.fullname.rsplit('.', 1)[0])
break
elif isinstance(expr, MemberExpr):
if isinstance(expr.expr, RefExpr):
expr = expr.expr
else:
break
else:
raise AssertionError("Unknown RefExpr subclass: {}".format(type(expr)))
return output
class Finished(Exception):
"""Raised if we can terminate overload argument check early (no match)."""
class ExpressionChecker:
"""Expression type checker.
This class works closely together with checker.TypeChecker.
"""
# Some services are provided by a TypeChecker instance.
chk = None # type: mypy.checker.TypeChecker
# This is shared with TypeChecker, but stored also here for convenience.
msg = None # type: MessageBuilder
strfrm_checker = None # type: StringFormatterChecker
def __init__(self,
chk: 'mypy.checker.TypeChecker',
msg: MessageBuilder) -> None:
"""Construct an expression type checker."""
self.chk = chk
self.msg = msg
self.strfrm_checker = StringFormatterChecker(self, self.chk, self.msg)
def visit_name_expr(self, e: NameExpr) -> Type:
"""Type check a name expression.
It can be of any kind: local, member or global.
"""
self.chk.module_refs.update(extract_refexpr_names(e))
result = self.analyze_ref_expr(e)
return self.chk.narrow_type_from_binder(e, result)
def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
result = None # type: Type
node = e.node
if isinstance(node, Var):
# Variable reference.
result = self.analyze_var_ref(node, e)
if isinstance(result, PartialType):
if result.type is None:
# 'None' partial type. It has a well-defined type. In an lvalue context
# we want to preserve the knowledge of it being a partial type.
if not lvalue:
result = NoneTyp()
else:
partial_types = self.chk.find_partial_types(node)
if partial_types is not None and not self.chk.current_node_deferred:
context = partial_types[node]
self.msg.fail(messages.NEED_ANNOTATION_FOR_VAR, context)
result = AnyType()
elif isinstance(node, FuncDef):
# Reference to a global function.
result = function_type(node, self.named_type('builtins.function'))
elif isinstance(node, OverloadedFuncDef):
result = node.type
elif isinstance(node, TypeInfo):
# Reference to a type object.
result = type_object_type(node, self.named_type)
elif isinstance(node, MypyFile):
# Reference to a module object.
result = self.named_type('builtins.module')
elif isinstance(node, Decorator):
result = self.analyze_var_ref(node.var, e)
else:
# Unknown reference; use any type implicitly to avoid
# generating extra type errors.
result = AnyType()
return result
def analyze_var_ref(self, var: Var, context: Context) -> Type:
if not var.type:
if not var.is_ready and self.chk.in_checked_function():
self.chk.handle_cannot_determine_type(var.name(), context)
# Implicit 'Any' type.
return AnyType()
else:
# Look up local type of variable with type (inferred or explicit).
val = self.chk.binder.get(var)
if val is None:
return var.type
else:
return val
def visit_call_expr(self, e: CallExpr) -> Type:
"""Type check a call expression."""
if e.analyzed:
# It's really a special form that only looks like a call.
return self.accept(e.analyzed, self.chk.type_context[-1])
if isinstance(e.callee, NameExpr) and isinstance(e.callee.node, TypeInfo) and \
e.callee.node.typeddict_type is not None:
return self.check_typeddict_call(e.callee.node.typeddict_type,
e.arg_kinds, e.arg_names, e.args, e)
self.try_infer_partial_type(e)
callee_type = self.accept(e.callee)
if (self.chk.options.disallow_untyped_calls and
self.chk.in_checked_function() and
isinstance(callee_type, CallableType)
and callee_type.implicit):
return self.msg.untyped_function_call(callee_type, e)
return self.check_call_expr_with_callee_type(callee_type, e)
def check_typeddict_call(self, callee: TypedDictType,
arg_kinds: List[int],
arg_names: List[str],
args: List[Expression],
context: Context) -> Type:
if len(args) >= 1 and all([ak == ARG_NAMED for ak in arg_kinds]):
# ex: Point(x=42, y=1337)
item_names = arg_names
item_args = args
return self.check_typeddict_call_with_kwargs(
callee, OrderedDict(zip(item_names, item_args)), context)
if len(args) == 1 and arg_kinds[0] == ARG_POS:
unique_arg = args[0]
if isinstance(unique_arg, DictExpr):
# ex: Point({'x': 42, 'y': 1337})
return self.check_typeddict_call_with_dict(callee, unique_arg, context)
if isinstance(unique_arg, CallExpr) and isinstance(unique_arg.analyzed, DictExpr):
# ex: Point(dict(x=42, y=1337))
return self.check_typeddict_call_with_dict(callee, unique_arg.analyzed, context)
if len(args) == 0:
# ex: EmptyDict()
return self.check_typeddict_call_with_kwargs(
callee, OrderedDict(), context)
self.chk.fail(messages.INVALID_TYPEDDICT_ARGS, context)
return AnyType()
def check_typeddict_call_with_dict(self, callee: TypedDictType,
kwargs: DictExpr,
context: Context) -> Type:
item_name_exprs = [item[0] for item in kwargs.items]
item_args = [item[1] for item in kwargs.items]
item_names = [] # List[str]
for item_name_expr in item_name_exprs:
if not isinstance(item_name_expr, StrExpr):
self.chk.fail(messages.TYPEDDICT_ITEM_NAME_MUST_BE_STRING_LITERAL, item_name_expr)
return AnyType()
item_names.append(item_name_expr.value)
return self.check_typeddict_call_with_kwargs(
callee, OrderedDict(zip(item_names, item_args)), context)
def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
kwargs: 'OrderedDict[str, Expression]',
context: Context) -> Type:
if callee.items.keys() != kwargs.keys():
callee_item_names = callee.items.keys()
kwargs_item_names = kwargs.keys()
self.msg.typeddict_instantiated_with_unexpected_items(
expected_item_names=list(callee_item_names),
actual_item_names=list(kwargs_item_names),
context=context)
return AnyType()
items = OrderedDict() # type: OrderedDict[str, Type]
for (item_name, item_expected_type) in callee.items.items():
item_value = kwargs[item_name]
item_actual_type = self.chk.check_simple_assignment(
lvalue_type=item_expected_type, rvalue=item_value, context=item_value,
msg=messages.INCOMPATIBLE_TYPES,
lvalue_name='TypedDict item "{}"'.format(item_name),
rvalue_name='expression')
items[item_name] = item_actual_type
mapping_value_type = join.join_type_list(list(items.values()))
fallback = self.chk.named_generic_type('typing.Mapping',
[self.chk.str_type(), mapping_value_type])
return TypedDictType(items, fallback)
# Types and methods that can be used to infer partial types.
item_args = {'builtins.list': ['append'],
'builtins.set': ['add', 'discard'],
}
container_args = {'builtins.list': {'extend': ['builtins.list']},
'builtins.dict': {'update': ['builtins.dict']},
'builtins.set': {'update': ['builtins.set', 'builtins.list']},
}
def try_infer_partial_type(self, e: CallExpr) -> None:
if isinstance(e.callee, MemberExpr) and isinstance(e.callee.expr, RefExpr):
var = cast(Var, e.callee.expr.node)
partial_types = self.chk.find_partial_types(var)
if partial_types is not None and not self.chk.current_node_deferred:
partial_type = var.type
if (partial_type is None or
not isinstance(partial_type, PartialType) or
partial_type.type is None):
# A partial None type -> can't infer anything.
return
typename = partial_type.type.fullname()
methodname = e.callee.name
# Sometimes we can infer a full type for a partial List, Dict or Set type.
# TODO: Don't infer argument expression twice.
if (typename in self.item_args and methodname in self.item_args[typename]
and e.arg_kinds == [ARG_POS]):
item_type = self.accept(e.args[0])
full_item_type = UnionType.make_simplified_union(
[item_type, partial_type.inner_types[0]])
if mypy.checker.is_valid_inferred_type(full_item_type):
var.type = self.chk.named_generic_type(typename, [full_item_type])
del partial_types[var]
elif (typename in self.container_args
and methodname in self.container_args[typename]
and e.arg_kinds == [ARG_POS]):
arg_type = self.accept(e.args[0])
if isinstance(arg_type, Instance):
arg_typename = arg_type.type.fullname()
if arg_typename in self.container_args[typename][methodname]:
full_item_types = [
UnionType.make_simplified_union([item_type, prev_type])
for item_type, prev_type
in zip(arg_type.args, partial_type.inner_types)
]
if all(mypy.checker.is_valid_inferred_type(item_type)
for item_type in full_item_types):
var.type = self.chk.named_generic_type(typename,
list(full_item_types))
del partial_types[var]
def check_call_expr_with_callee_type(self, callee_type: Type,
e: CallExpr) -> Type:
"""Type check call expression.
The given callee type overrides the type of the callee
expression.
"""
return self.check_call(callee_type, e.args, e.arg_kinds, e,
e.arg_names, callable_node=e.callee)[0]
def check_call(self, callee: Type, args: List[Expression],
arg_kinds: List[int], context: Context,
arg_names: List[str] = None,
callable_node: Expression = None,
arg_messages: MessageBuilder = None) -> Tuple[Type, Type]:
"""Type check a call.
Also infer type arguments if the callee is a generic function.
Return (result type, inferred callee type).
Arguments:
callee: type of the called value
args: actual argument expressions
arg_kinds: contains nodes.ARG_* constant for each argument in args
describing whether the argument is positional, *arg, etc.
arg_names: names of arguments (optional)
callable_node: associate the inferred callable type to this node,
if specified
arg_messages: TODO
"""
arg_messages = arg_messages or self.msg
if isinstance(callee, CallableType):
if callee.is_concrete_type_obj() and callee.type_object().is_abstract:
type = callee.type_object()
self.msg.cannot_instantiate_abstract_class(
callee.type_object().name(), type.abstract_attributes,
context)
formal_to_actual = map_actuals_to_formals(
arg_kinds, arg_names,
callee.arg_kinds, callee.arg_names,
lambda i: self.accept(args[i]))
if callee.is_generic():
callee = freshen_generic_callable(callee)
callee = self.infer_function_type_arguments_using_context(
callee, context)
callee = self.infer_function_type_arguments(
callee, args, arg_kinds, formal_to_actual, context)
arg_types = self.infer_arg_types_in_context2(
callee, args, arg_kinds, formal_to_actual)
self.check_argument_count(callee, arg_types, arg_kinds,
arg_names, formal_to_actual, context, self.msg)
self.check_argument_types(arg_types, arg_kinds, callee,
formal_to_actual, context,
messages=arg_messages)
if (callee.is_type_obj() and (len(arg_types) == 1)
and is_equivalent(callee.ret_type, self.named_type('builtins.type'))):
callee = callee.copy_modified(ret_type=TypeType(arg_types[0]))
if callable_node:
# Store the inferred callable type.
self.chk.store_type(callable_node, callee)
return callee.ret_type, callee
elif isinstance(callee, Overloaded):
# Type check arguments in empty context. They will be checked again
# later in a context derived from the signature; these types are
# only used to pick a signature variant.
self.msg.disable_errors()
arg_types = self.infer_arg_types_in_context(None, args)
self.msg.enable_errors()
target = self.overload_call_target(arg_types, arg_kinds, arg_names,
callee, context,
messages=arg_messages)
return self.check_call(target, args, arg_kinds, context, arg_names,
arg_messages=arg_messages)
elif isinstance(callee, AnyType) or not self.chk.in_checked_function():
self.infer_arg_types_in_context(None, args)
return AnyType(), AnyType()
elif isinstance(callee, UnionType):
self.msg.disable_type_names += 1
results = [self.check_call(subtype, args, arg_kinds, context, arg_names,
arg_messages=arg_messages)
for subtype in callee.items]
self.msg.disable_type_names -= 1
return (UnionType.make_simplified_union([res[0] for res in results]),
callee)
elif isinstance(callee, Instance):
call_function = analyze_member_access('__call__', callee, context,
False, False, False, self.named_type,
self.not_ready_callback, self.msg,
original_type=callee, chk=self.chk)
return self.check_call(call_function, args, arg_kinds, context, arg_names,
callable_node, arg_messages)
elif isinstance(callee, TypeVarType):
return self.check_call(callee.upper_bound, args, arg_kinds, context, arg_names,
callable_node, arg_messages)
elif isinstance(callee, TypeType):
# Pass the original Type[] as context since that's where errors should go.
item = self.analyze_type_type_callee(callee.item, callee)
return self.check_call(item, args, arg_kinds, context, arg_names,
callable_node, arg_messages)
else:
return self.msg.not_callable(callee, context), AnyType()
def analyze_type_type_callee(self, item: Type, context: Context) -> Type:
"""Analyze the callee X in X(...) where X is Type[item].
Return a Y that we can pass to check_call(Y, ...).
"""
if isinstance(item, AnyType):
return AnyType()
if isinstance(item, Instance):
return type_object_type(item.type, self.named_type)
if isinstance(item, UnionType):
return UnionType([self.analyze_type_type_callee(item, context)
for item in item.items], item.line)
if isinstance(item, TypeVarType):
# Pretend we're calling the typevar's upper bound,
# i.e. its constructor (a poor approximation for reality,
# but better than AnyType...), but replace the return type
# with typevar.
callee = self.analyze_type_type_callee(item.upper_bound, context)
if isinstance(callee, CallableType):
if callee.is_generic():
callee = None
else:
callee = callee.copy_modified(ret_type=item)
elif isinstance(callee, Overloaded):
if callee.items()[0].is_generic():
callee = None
else:
callee = Overloaded([c.copy_modified(ret_type=item)
for c in callee.items()])
if callee:
return callee
self.msg.unsupported_type_type(item, context)
return AnyType()
def infer_arg_types_in_context(self, callee: Optional[CallableType],
args: List[Expression]) -> List[Type]:
"""Infer argument expression types using a callable type as context.
For example, if callee argument 2 has type List[int], infer the
argument expression with List[int] type context.
"""
# TODO Always called with callee as None, i.e. empty context.
res = [] # type: List[Type]
fixed = len(args)
if callee:
fixed = min(fixed, callee.max_fixed_args())
arg_type = None # type: Type
ctx = None # type: Type
for i, arg in enumerate(args):
if i < fixed:
if callee and i < len(callee.arg_types):
ctx = callee.arg_types[i]
arg_type = self.accept(arg, ctx)
else:
if callee and callee.is_var_arg:
arg_type = self.accept(arg, callee.arg_types[-1])
else:
arg_type = self.accept(arg)
if has_erased_component(arg_type):
res.append(NoneTyp())
else:
res.append(arg_type)
return res
def infer_arg_types_in_context2(
self, callee: CallableType, args: List[Expression], arg_kinds: List[int],
formal_to_actual: List[List[int]]) -> List[Type]:
"""Infer argument expression types using a callable type as context.
For example, if callee argument 2 has type List[int], infer the
argument expression with List[int] type context.
Returns the inferred types of *actual arguments*.
"""
res = [None] * len(args) # type: List[Type]
for i, actuals in enumerate(formal_to_actual):
for ai in actuals:
if arg_kinds[ai] not in (nodes.ARG_STAR, nodes.ARG_STAR2):
res[ai] = self.accept(args[ai], callee.arg_types[i])
# Fill in the rest of the argument types.
for i, t in enumerate(res):
if not t:
res[i] = self.accept(args[i])
return res
def infer_function_type_arguments_using_context(
self, callable: CallableType, error_context: Context) -> CallableType:
"""Unify callable return type to type context to infer type vars.
For example, if the return type is set[t] where 't' is a type variable
of callable, and if the context is set[int], return callable modified
by substituting 't' with 'int'.
"""
ctx = self.chk.type_context[-1]
if not ctx:
return callable
# The return type may have references to type metavariables that
# we are inferring right now. We must consider them as indeterminate
# and they are not potential results; thus we replace them with the
# special ErasedType type. On the other hand, class type variables are
# valid results.
erased_ctx = replace_meta_vars(ctx, ErasedType())
ret_type = callable.ret_type
if isinstance(ret_type, TypeVarType):
if ret_type.values or (not isinstance(ctx, Instance) or
not ctx.args):
# The return type is a type variable. If it has values, we can't easily restrict
# type inference to conform to the valid values. If it's unrestricted, we could
# infer a too general type for the type variable if we use context, and this could
# result in confusing and spurious type errors elsewhere.
#
# Give up and just use function arguments for type inference. As an exception,
# if the context is a generic instance type, actually use it as context, as
# this *seems* to usually be the reasonable thing to do.
#
# See also github issues #462 and #360.
ret_type = NoneTyp()
args = infer_type_arguments(callable.type_var_ids(), ret_type, erased_ctx)
# Only substitute non-Uninhabited and non-erased types.
new_args = [] # type: List[Type]
for arg in args:
if isinstance(arg, UninhabitedType) or has_erased_component(arg):
new_args.append(None)
elif not experiments.STRICT_OPTIONAL and isinstance(arg, NoneTyp):
# Don't substitute None types in non-strict-Optional mode.
new_args.append(None)
else:
new_args.append(arg)
return self.apply_generic_arguments(callable, new_args, error_context)
def infer_function_type_arguments(self, callee_type: CallableType,
args: List[Expression],
arg_kinds: List[int],
formal_to_actual: List[List[int]],
context: Context) -> CallableType:
"""Infer the type arguments for a generic callee type.
Infer based on the types of arguments.
Return a derived callable type that has the arguments applied.
"""
if self.chk.in_checked_function():
# Disable type errors during type inference. There may be errors
# due to partial available context information at this time, but
# these errors can be safely ignored as the arguments will be
# inferred again later.
self.msg.disable_errors()
arg_types = self.infer_arg_types_in_context2(
callee_type, args, arg_kinds, formal_to_actual)
self.msg.enable_errors()
arg_pass_nums = self.get_arg_infer_passes(
callee_type.arg_types, formal_to_actual, len(args))
pass1_args = [] # type: List[Optional[Type]]
for i, arg in enumerate(arg_types):
if arg_pass_nums[i] > 1:
pass1_args.append(None)
else:
pass1_args.append(arg)
inferred_args = infer_function_type_arguments(
callee_type, pass1_args, arg_kinds, formal_to_actual,
strict=self.chk.in_checked_function()) # type: List[Type]
if 2 in arg_pass_nums:
# Second pass of type inference.
(callee_type,
inferred_args) = self.infer_function_type_arguments_pass2(
callee_type, args, arg_kinds, formal_to_actual,
inferred_args, context)
if callee_type.special_sig == 'dict' and len(inferred_args) == 2 and (
ARG_NAMED in arg_kinds or ARG_STAR2 in arg_kinds):
# HACK: Infer str key type for dict(...) with keyword args. The type system
# can't represent this so we special case it, as this is a pretty common
# thing. This doesn't quite work with all possible subclasses of dict
# if they shuffle type variables around, as we assume that there is a 1-1
# correspondence with dict type variables. This is a marginal issue and
# a little tricky to fix so it's left unfixed for now.
if isinstance(inferred_args[0], (NoneTyp, UninhabitedType)):
inferred_args[0] = self.named_type('builtins.str')
elif not is_subtype(self.named_type('builtins.str'), inferred_args[0]):
self.msg.fail(messages.KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE,
context)
else:
# In dynamically typed functions use implicit 'Any' types for
# type variables.
inferred_args = [AnyType()] * len(callee_type.variables)
return self.apply_inferred_arguments(callee_type, inferred_args,
context)
def infer_function_type_arguments_pass2(
self, callee_type: CallableType,
args: List[Expression],
arg_kinds: List[int],
formal_to_actual: List[List[int]],
inferred_args: List[Type],
context: Context) -> Tuple[CallableType, List[Type]]:
"""Perform second pass of generic function type argument inference.
The second pass is needed for arguments with types such as Callable[[T], S],
where both T and S are type variables, when the actual argument is a
lambda with inferred types. The idea is to infer the type variable T
in the first pass (based on the types of other arguments). This lets
us infer the argument and return type of the lambda expression and
thus also the type variable S in this second pass.
Return (the callee with type vars applied, inferred actual arg types).
"""
# None or erased types in inferred types mean that there was not enough
# information to infer the argument. Replace them with None values so
# that they are not applied yet below.
for i, arg in enumerate(inferred_args):
if isinstance(arg, (NoneTyp, UninhabitedType)) or has_erased_component(arg):
inferred_args[i] = None
callee_type = self.apply_generic_arguments(callee_type, inferred_args, context)
arg_types = self.infer_arg_types_in_context2(
callee_type, args, arg_kinds, formal_to_actual)
inferred_args = infer_function_type_arguments(
callee_type, arg_types, arg_kinds, formal_to_actual)
return callee_type, inferred_args
def get_arg_infer_passes(self, arg_types: List[Type],
formal_to_actual: List[List[int]],
num_actuals: int) -> List[int]:
"""Return pass numbers for args for two-pass argument type inference.
For each actual, the pass number is either 1 (first pass) or 2 (second
pass).
Two-pass argument type inference primarily lets us infer types of
lambdas more effectively.
"""
res = [1] * num_actuals
for i, arg in enumerate(arg_types):
if arg.accept(ArgInferSecondPassQuery()):
for j in formal_to_actual[i]:
res[j] = 2
return res
def apply_inferred_arguments(self, callee_type: CallableType,
inferred_args: List[Type],
context: Context) -> CallableType:
"""Apply inferred values of type arguments to a generic function.
Inferred_args contains the values of function type arguments.
"""
# Report error if some of the variables could not be solved. In that
# case assume that all variables have type Any to avoid extra
# bogus error messages.
for i, inferred_type in enumerate(inferred_args):
if not inferred_type or has_erased_component(inferred_type):
# Could not infer a non-trivial type for a type variable.
self.msg.could_not_infer_type_arguments(
callee_type, i + 1, context)
inferred_args = [AnyType()] * len(inferred_args)
# Apply the inferred types to the function type. In this case the
# return type must be CallableType, since we give the right number of type
# arguments.
return self.apply_generic_arguments(callee_type, inferred_args, context)
def check_argument_count(self, callee: CallableType, actual_types: List[Type],
actual_kinds: List[int], actual_names: List[str],
formal_to_actual: List[List[int]],
context: Context,
messages: Optional[MessageBuilder]) -> bool:
"""Check that there is a value for all required arguments to a function.
Also check that there are no duplicate values for arguments. Report found errors
using 'messages' if it's not None.
Return False if there were any errors. Otherwise return True
"""
# TODO(jukka): We could return as soon as we find an error if messages is None.
formal_kinds = callee.arg_kinds
# Collect list of all actual arguments matched to formal arguments.
all_actuals = [] # type: List[int]
for actuals in formal_to_actual:
all_actuals.extend(actuals)
is_unexpected_arg_error = False # Keep track of errors to avoid duplicate errors.
ok = True # False if we've found any error.
for i, kind in enumerate(actual_kinds):
if i not in all_actuals and (
kind != nodes.ARG_STAR or
not is_empty_tuple(actual_types[i])):
# Extra actual: not matched by a formal argument.
ok = False
if kind != nodes.ARG_NAMED:
if messages:
messages.too_many_arguments(callee, context)
else:
if messages:
messages.unexpected_keyword_argument(
callee, actual_names[i], context)
is_unexpected_arg_error = True
elif kind == nodes.ARG_STAR and (
nodes.ARG_STAR not in formal_kinds):
actual_type = actual_types[i]
if isinstance(actual_type, TupleType):
if all_actuals.count(i) < len(actual_type.items):
# Too many tuple items as some did not match.
if messages:
messages.too_many_arguments(callee, context)
ok = False
# *args can be applied even if the function takes a fixed
# number of positional arguments. This may succeed at runtime.
for i, kind in enumerate(formal_kinds):
if kind == nodes.ARG_POS and (not formal_to_actual[i] and
not is_unexpected_arg_error):
# No actual for a mandatory positional formal.
if messages:
messages.too_few_arguments(callee, context, actual_names)
ok = False
elif kind == nodes.ARG_NAMED and (not formal_to_actual[i] and
not is_unexpected_arg_error):
# No actual for a mandatory named formal
if messages:
messages.missing_named_argument(callee, context, callee.arg_names[i])
ok = False
elif kind in [nodes.ARG_POS, nodes.ARG_OPT,
nodes.ARG_NAMED, nodes.ARG_NAMED_OPT] and is_duplicate_mapping(
formal_to_actual[i], actual_kinds):
if (self.chk.in_checked_function() or
isinstance(actual_types[formal_to_actual[i][0]], TupleType)):
if messages:
messages.duplicate_argument_value(callee, i, context)
ok = False
elif (kind in (nodes.ARG_NAMED, nodes.ARG_NAMED_OPT) and formal_to_actual[i] and
actual_kinds[formal_to_actual[i][0]] not in [nodes.ARG_NAMED, nodes.ARG_STAR2]):
# Positional argument when expecting a keyword argument.
if messages:
messages.too_many_positional_arguments(callee, context)
ok = False
return ok
def check_argument_types(self, arg_types: List[Type], arg_kinds: List[int],
callee: CallableType,
formal_to_actual: List[List[int]],
context: Context,
messages: MessageBuilder = None,
check_arg: ArgChecker = None) -> None:
"""Check argument types against a callable type.
Report errors if the argument types are not compatible.
"""
messages = messages or self.msg
check_arg = check_arg or self.check_arg
# Keep track of consumed tuple *arg items.
tuple_counter = [0]
for i, actuals in enumerate(formal_to_actual):
for actual in actuals:
arg_type = arg_types[actual]
if arg_type is None:
continue # Some kind of error was already reported.
# Check that a *arg is valid as varargs.
if (arg_kinds[actual] == nodes.ARG_STAR and
not self.is_valid_var_arg(arg_type)):
messages.invalid_var_arg(arg_type, context)
if (arg_kinds[actual] == nodes.ARG_STAR2 and
not self.is_valid_keyword_var_arg(arg_type)):
messages.invalid_keyword_var_arg(arg_type, context)
# Get the type of an individual actual argument (for *args
# and **args this is the item type, not the collection type).
if (isinstance(arg_type, TupleType)
and tuple_counter[0] >= len(arg_type.items)
and arg_kinds[actual] == nodes.ARG_STAR):
# The tuple is exhausted. Continue with further arguments.
continue
actual_type = get_actual_type(arg_type, arg_kinds[actual],
tuple_counter)
check_arg(actual_type, arg_type, arg_kinds[actual],
callee.arg_types[i],
actual + 1, i + 1, callee, context, messages)
# There may be some remaining tuple varargs items that haven't
# been checked yet. Handle them.
tuplet = arg_types[actual]
if (callee.arg_kinds[i] == nodes.ARG_STAR and
arg_kinds[actual] == nodes.ARG_STAR and
isinstance(tuplet, TupleType)):
while tuple_counter[0] < len(tuplet.items):
actual_type = get_actual_type(arg_type,
arg_kinds[actual],
tuple_counter)
check_arg(actual_type, arg_type, arg_kinds[actual],
callee.arg_types[i],
actual + 1, i + 1, callee, context, messages)
def check_arg(self, caller_type: Type, original_caller_type: Type,
caller_kind: int,
callee_type: Type, n: int, m: int, callee: CallableType,
context: Context, messages: MessageBuilder) -> None:
"""Check the type of a single argument in a call."""
if self.chk.is_unusable_type(caller_type):
messages.does_not_return_value(caller_type, context)
elif isinstance(caller_type, DeletedType):
messages.deleted_as_rvalue(caller_type, context)
elif not is_subtype(caller_type, callee_type):
if self.chk.should_suppress_optional_error([caller_type, callee_type]):
return
messages.incompatible_argument(n, m, callee, original_caller_type,
caller_kind, context)
def overload_call_target(self, arg_types: List[Type], arg_kinds: List[int],
arg_names: List[str],
overload: Overloaded, context: Context,
messages: MessageBuilder = None) -> Type:
"""Infer the correct overload item to call with given argument types.
The return value may be CallableType or AnyType (if an unique item
could not be determined).
"""
messages = messages or self.msg
# TODO: For overlapping signatures we should try to get a more precise
# result than 'Any'.
match = [] # type: List[CallableType]
best_match = 0
for typ in overload.items():
similarity = self.erased_signature_similarity(arg_types, arg_kinds, arg_names,
typ, context=context)
if similarity > 0 and similarity >= best_match:
if (match and not is_same_type(match[-1].ret_type,
typ.ret_type) and
not mypy.checker.is_more_precise_signature(
match[-1], typ)):
# Ambiguous return type. Either the function overload is
# overlapping (which we don't handle very well here) or the
# caller has provided some Any argument types; in either
# case we'll fall back to Any. It's okay to use Any types
# in calls.
#
# Overlapping overload items are generally fine if the
# overlapping is only possible when there is multiple
# inheritance, as this is rare. See docstring of
# mypy.meet.is_overlapping_types for more about this.
#
# Note that there is no ambiguity if the items are
# covariant in both argument types and return types with
# respect to type precision. We'll pick the best/closest
# match.
#
# TODO: Consider returning a union type instead if the
# overlapping is NOT due to Any types?
return AnyType()
else:
match.append(typ)
best_match = max(best_match, similarity)
if not match:
if not self.chk.should_suppress_optional_error(arg_types):
messages.no_variant_matches_arguments(overload, arg_types, context)
return AnyType()
else:
if len(match) == 1:
return match[0]
else:
# More than one signature matches. Pick the first *non-erased*
# matching signature, or default to the first one if none
# match.
for m in match:
if self.match_signature_types(arg_types, arg_kinds, arg_names, m,
context=context):
return m
return match[0]
def erased_signature_similarity(self, arg_types: List[Type], arg_kinds: List[int],
arg_names: List[str], callee: CallableType,
context: Context) -> int:
"""Determine whether arguments could match the signature at runtime.
Return similarity level (0 = no match, 1 = can match, 2 = non-promotion match). See
overload_arg_similarity for a discussion of similarity levels.
"""
formal_to_actual = map_actuals_to_formals(arg_kinds,
arg_names,
callee.arg_kinds,
callee.arg_names,
lambda i: arg_types[i])
if not self.check_argument_count(callee, arg_types, arg_kinds, arg_names,
formal_to_actual, None, None):
# Too few or many arguments -> no match.
return 0
similarity = 2
def check_arg(caller_type: Type, original_caller_type: Type, caller_kind: int,
callee_type: Type, n: int, m: int, callee: CallableType,
context: Context, messages: MessageBuilder) -> None:
nonlocal similarity
similarity = min(similarity,
overload_arg_similarity(caller_type, callee_type))
if similarity == 0:
# No match -- exit early since none of the remaining work can change
# the result.
raise Finished
try:
self.check_argument_types(arg_types, arg_kinds, callee, formal_to_actual,
context=context, check_arg=check_arg)
except Finished:
pass
return similarity
def match_signature_types(self, arg_types: List[Type], arg_kinds: List[int],
arg_names: List[str], callee: CallableType,
context: Context) -> bool:
"""Determine whether arguments types match the signature.
Assume that argument counts are compatible.
Return True if arguments match.
"""
formal_to_actual = map_actuals_to_formals(arg_kinds,
arg_names,
callee.arg_kinds,
callee.arg_names,
lambda i: arg_types[i])
ok = True
def check_arg(caller_type: Type, original_caller_type: Type, caller_kind: int,
callee_type: Type, n: int, m: int, callee: CallableType,
context: Context, messages: MessageBuilder) -> None:
nonlocal ok
if not is_subtype(caller_type, callee_type):
ok = False
self.check_argument_types(arg_types, arg_kinds, callee, formal_to_actual,
context=context, check_arg=check_arg)
return ok
def apply_generic_arguments(self, callable: CallableType, types: List[Type],
context: Context) -> CallableType:
"""Simple wrapper around mypy.applytype.apply_generic_arguments."""
return applytype.apply_generic_arguments(callable, types, self.msg, context)
def visit_member_expr(self, e: MemberExpr) -> Type:
"""Visit member expression (of form e.id)."""
self.chk.module_refs.update(extract_refexpr_names(e))
result = self.analyze_ordinary_member_access(e, False)
return self.chk.narrow_type_from_binder(e, result)
def analyze_ordinary_member_access(self, e: MemberExpr,
is_lvalue: bool) -> Type:
"""Analyse member expression or member lvalue."""
if e.kind is not None:
# This is a reference to a module attribute.
return self.analyze_ref_expr(e)
else:
# This is a reference to a non-module attribute.
original_type = self.accept(e.expr)
member_type = analyze_member_access(
e.name, original_type, e, is_lvalue, False, False,
self.named_type, self.not_ready_callback, self.msg,
original_type=original_type, chk=self.chk)
if is_lvalue:
return member_type
else:
return self.analyze_descriptor_access(original_type, member_type, e)
def analyze_descriptor_access(self, instance_type: Type, descriptor_type: Type,
context: Context) -> Type:
"""Type check descriptor access.
Arguments:
instance_type: The type of the instance on which the descriptor
attribute is being accessed (the type of ``a`` in ``a.f`` when
``f`` is a descriptor).
descriptor_type: The type of the descriptor attribute being accessed
(the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
context: The node defining the context of this inference.
Return:
The return type of the appropriate ``__get__`` overload for the descriptor.
"""
if not isinstance(descriptor_type, Instance):
return descriptor_type
if not descriptor_type.type.has_readable_member('__get__'):
return descriptor_type
dunder_get = descriptor_type.type.get_method('__get__')
if dunder_get is None:
self.msg.fail("{}.__get__ is not callable".format(descriptor_type), context)
return AnyType()
function = function_type(dunder_get, self.named_type('builtins.function'))
bound_method = bind_self(function, descriptor_type)
typ = map_instance_to_supertype(descriptor_type, dunder_get.info)
dunder_get_type = expand_type_by_instance(bound_method, typ)
owner_type = None # type: Type
if isinstance(instance_type, FunctionLike) and instance_type.is_type_obj():
owner_type = instance_type.items()[0].ret_type
instance_type = NoneTyp()
elif isinstance(instance_type, TypeType):
owner_type = instance_type.item
instance_type = NoneTyp()
else:
owner_type = instance_type
_, inferred_dunder_get_type = self.check_call(
dunder_get_type, [TempNode(instance_type), TempNode(TypeType(owner_type))],
[nodes.ARG_POS, nodes.ARG_POS], context)
if isinstance(inferred_dunder_get_type, AnyType):
# check_call failed, and will have reported an error
return inferred_dunder_get_type
if not isinstance(inferred_dunder_get_type, CallableType):
self.msg.fail("{}.__get__ is not callable".format(descriptor_type), context)
return AnyType()
return inferred_dunder_get_type.ret_type
def analyze_external_member_access(self, member: str, base_type: Type,
context: Context) -> Type:
"""Analyse member access that is external, i.e. it cannot
refer to private definitions. Return the result type.
"""
# TODO remove; no private definitions in mypy
return analyze_member_access(member, base_type, context, False, False, False,
self.named_type, self.not_ready_callback, self.msg,
original_type=base_type, chk=self.chk)
def visit_int_expr(self, e: IntExpr) -> Type:
"""Type check an integer literal (trivial)."""
return self.named_type('builtins.int')
def visit_str_expr(self, e: StrExpr) -> Type:
"""Type check a string literal (trivial)."""
return self.named_type('builtins.str')
def visit_bytes_expr(self, e: BytesExpr) -> Type:
"""Type check a bytes literal (trivial)."""
return self.named_type('builtins.bytes')
def visit_unicode_expr(self, e: UnicodeExpr) -> Type:
"""Type check a unicode literal (trivial)."""
return self.named_type('builtins.unicode')
def visit_float_expr(self, e: FloatExpr) -> Type:
"""Type check a float literal (trivial)."""
return self.named_type('builtins.float')
def visit_complex_expr(self, e: ComplexExpr) -> Type:
"""Type check a complex literal."""
return self.named_type('builtins.complex')
def visit_ellipsis(self, e: EllipsisExpr) -> Type:
"""Type check '...'."""
if self.chk.options.python_version[0] >= 3:
return self.named_type('builtins.ellipsis')
else:
# '...' is not valid in normal Python 2 code, but it can
# be used in stubs. The parser makes sure that we only
# get this far if we are in a stub, and we can safely
# return 'object' as ellipsis is special cased elsewhere.
# The builtins.ellipsis type does not exist in Python 2.
return self.named_type('builtins.object')
def visit_op_expr(self, e: OpExpr) -> Type:
"""Type check a binary operator expression."""
if e.op == 'and' or e.op == 'or':
return self.check_boolean_op(e, e)
if e.op == '*' and isinstance(e.left, ListExpr):
# Expressions of form [...] * e get special type inference.
return self.check_list_multiply(e)
if e.op == '%':
pyversion = self.chk.options.python_version
if pyversion[0] == 3:
if isinstance(e.left, BytesExpr) and pyversion[1] >= 5:
return self.strfrm_checker.check_str_interpolation(e.left, e.right)
if isinstance(e.left, StrExpr):
return self.strfrm_checker.check_str_interpolation(e.left, e.right)
elif pyversion[0] <= 2:
if isinstance(e.left, (StrExpr, BytesExpr, UnicodeExpr)):
return self.strfrm_checker.check_str_interpolation(e.left, e.right)
left_type = self.accept(e.left)
if e.op in nodes.op_methods:
method = self.get_operator_method(e.op)
result, method_type = self.check_op(method, left_type, e.right, e,
allow_reverse=True)
e.method_type = method_type
return result
else:
raise RuntimeError('Unknown operator {}'.format(e.op))
def visit_comparison_expr(self, e: ComparisonExpr) -> Type:
"""Type check a comparison expression.
Comparison expressions are type checked consecutive-pair-wise
That is, 'a < b > c == d' is check as 'a < b and b > c and c == d'
"""
result = None # type: mypy.types.Type
# Check each consecutive operand pair and their operator
for left, right, operator in zip(e.operands, e.operands[1:], e.operators):
left_type = self.accept(left)
method_type = None # type: mypy.types.Type
if operator == 'in' or operator == 'not in':
right_type = self.accept(right) # TODO only evaluate if needed
# Keep track of whether we get type check errors (these won't be reported, they
# are just to verify whether something is valid typing wise).
local_errors = self.msg.copy()
local_errors.disable_count = 0
sub_result, method_type = self.check_op_local('__contains__', right_type,
left, e, local_errors)
if isinstance(right_type, PartialType):
# We don't really know if this is an error or not, so just shut up.
pass
elif (local_errors.is_errors() and
# is_valid_var_arg is True for any Iterable
self.is_valid_var_arg(right_type)):
itertype = self.chk.analyze_iterable_item_type(right)
method_type = CallableType(
[left_type],
[nodes.ARG_POS],
[None],
self.chk.bool_type(),
self.named_type('builtins.function'))
sub_result = self.chk.bool_type()
if not is_subtype(left_type, itertype):
self.msg.unsupported_operand_types('in', left_type, right_type, e)
else:
self.msg.add_errors(local_errors)
if operator == 'not in':
sub_result = self.chk.bool_type()
elif operator in nodes.op_methods:
method = self.get_operator_method(operator)
sub_result, method_type = self.check_op(method, left_type, right, e,
allow_reverse=True)
elif operator == 'is' or operator == 'is not':
sub_result = self.chk.bool_type()
method_type = None
else:
raise RuntimeError('Unknown comparison operator {}'.format(operator))
e.method_types.append(method_type)
# Determine type of boolean-and of result and sub_result
if result is None:
result = sub_result
else:
# TODO: check on void needed?
self.check_usable_type(sub_result, e)
result = join.join_types(result, sub_result)
return result
def get_operator_method(self, op: str) -> str:
if op == '/' and self.chk.options.python_version[0] == 2:
# TODO also check for "from __future__ import division"
return '__div__'
else:
return nodes.op_methods[op]
def _check_op_for_errors(self, method: str, base_type: Type, arg: Expression,
context: Context
) -> Tuple[Tuple[Type, Type], MessageBuilder]:
"""Type check a binary operation which maps to a method call.
Return ((result type, inferred operator method type), error message).
"""
local_errors = self.msg.copy()
local_errors.disable_count = 0
result = self.check_op_local(method, base_type,
arg, context,
local_errors)
return result, local_errors
def check_op_local(self, method: str, base_type: Type, arg: Expression,
context: Context, local_errors: MessageBuilder) -> Tuple[Type, Type]:
"""Type check a binary operation which maps to a method call.
Return tuple (result type, inferred operator method type).
"""
method_type = analyze_member_access(method, base_type, context, False, False, True,
self.named_type, self.not_ready_callback, local_errors,
original_type=base_type, chk=self.chk)
return self.check_call(method_type, [arg], [nodes.ARG_POS],
context, arg_messages=local_errors)
def check_op(self, method: str, base_type: Type, arg: Expression,
context: Context,
allow_reverse: bool = False) -> Tuple[Type, Type]:
"""Type check a binary operation which maps to a method call.
Return tuple (result type, inferred operator method type).
"""
# Use a local error storage for errors related to invalid argument
# type (but NOT other errors). This error may need to be suppressed
# for operators which support __rX methods.
local_errors = self.msg.copy()
local_errors.disable_count = 0
if not allow_reverse or self.has_member(base_type, method):
result = self.check_op_local(method, base_type, arg, context,
local_errors)
if allow_reverse:
arg_type = self.chk.type_map[arg]
if isinstance(arg_type, AnyType):
# If the right operand has type Any, we can't make any
# conjectures about the type of the result, since the
# operand could have a __r method that returns anything.
result = AnyType(), result[1]
success = not local_errors.is_errors()
else:
result = AnyType(), AnyType()
success = False
if success or not allow_reverse or isinstance(base_type, AnyType):
# We were able to call the normal variant of the operator method,
# or there was some problem not related to argument type
# validity, or the operator has no __rX method. In any case, we
# don't need to consider the __rX method.
self.msg.add_errors(local_errors)
return result
else:
# Calling the operator method was unsuccessful. Try the __rX
# method of the other operand instead.
rmethod = self.get_reverse_op_method(method)
arg_type = self.accept(arg)
base_arg_node = TempNode(base_type)
# In order to be consistent with showing an error about the lhs not matching if neither
# the lhs nor the rhs have a compatible signature, we keep track of the first error
# message generated when considering __rX methods and __cmp__ methods for Python 2.
first_error = None # type: Optional[Tuple[Tuple[Type, Type], MessageBuilder]]
if self.has_member(arg_type, rmethod):
result, local_errors = self._check_op_for_errors(rmethod, arg_type,
base_arg_node, context)
if not local_errors.is_errors():
return result
first_error = first_error or (result, local_errors)
# If we've failed to find an __rX method and we're checking Python 2, check to see if
# there is a __cmp__ method on the lhs or on the rhs.
if (self.chk.options.python_version[0] == 2 and
method in nodes.ops_falling_back_to_cmp):
cmp_method = nodes.comparison_fallback_method
if self.has_member(base_type, cmp_method):
# First check the if the lhs has a __cmp__ method that works
result, local_errors = self._check_op_for_errors(cmp_method, base_type,
arg, context)
if not local_errors.is_errors():
return result
first_error = first_error or (result, local_errors)
if self.has_member(arg_type, cmp_method):
# Failed to find a __cmp__ method on the lhs, check if
# the rhs as a __cmp__ method that can operate on lhs
result, local_errors = self._check_op_for_errors(cmp_method, arg_type,
base_arg_node, context)
if not local_errors.is_errors():
return result
first_error = first_error or (result, local_errors)
if first_error:
# We found either a __rX method, a __cmp__ method on the base_type, or a __cmp__
# method on the rhs and failed match. Return the error for the first of these to
# fail.
self.msg.add_errors(first_error[1])
return first_error[0]
else:
# No __rX method or __cmp__. Do deferred type checking to
# produce error message that we may have missed previously.
# TODO Fix type checking an expression more than once.
return self.check_op_local(method, base_type, arg, context,
self.msg)
def get_reverse_op_method(self, method: str) -> str:
if method == '__div__' and self.chk.options.python_version[0] == 2:
return '__rdiv__'
else:
return nodes.reverse_op_methods[method]
def check_boolean_op(self, e: OpExpr, context: Context) -> Type:
"""Type check a boolean operation ('and' or 'or')."""
# A boolean operation can evaluate to either of the operands.
# We use the current type context to guide the type inference of of
# the left operand. We also use the left operand type to guide the type
# inference of the right operand so that expressions such as
# '[1] or []' are inferred correctly.
ctx = self.chk.type_context[-1]
left_type = self.accept(e.left, ctx)
assert e.op in ('and', 'or') # Checked by visit_op_expr
if e.op == 'and':
right_map, left_map = self.chk.find_isinstance_check(e.left)
restricted_left_type = false_only(left_type)
result_is_left = not left_type.can_be_true
elif e.op == 'or':
left_map, right_map = self.chk.find_isinstance_check(e.left)
restricted_left_type = true_only(left_type)
result_is_left = not left_type.can_be_false
right_type = self.analyze_cond_branch(right_map, e.right, left_type)
self.check_usable_type(left_type, context)
self.check_usable_type(right_type, context)
if right_map is None:
# The boolean expression is statically known to be the left value
assert left_map is not None # find_isinstance_check guarantees this
return left_type
if left_map is None:
# The boolean expression is statically known to be the right value
assert right_map is not None # find_isinstance_check guarantees this
return right_type
if isinstance(restricted_left_type, UninhabitedType):
# The left operand can never be the result
return right_type
elif result_is_left:
# The left operand is always the result
return left_type
else:
return UnionType.make_simplified_union([restricted_left_type, right_type])
def check_list_multiply(self, e: OpExpr) -> Type:
"""Type check an expression of form '[...] * e'.
Type inference is special-cased for this common construct.
"""
right_type = self.accept(e.right)
if is_subtype(right_type, self.named_type('builtins.int')):
# Special case: [...] * . Use the type context of the
# OpExpr, since the multiplication does not affect the type.
left_type = self.accept(e.left, context=self.chk.type_context[-1])
else:
left_type = self.accept(e.left)
result, method_type = self.check_op('__mul__', left_type, e.right, e)
e.method_type = method_type
return result
def visit_unary_expr(self, e: UnaryExpr) -> Type:
"""Type check an unary operation ('not', '-', '+' or '~')."""
operand_type = self.accept(e.expr)
op = e.op
if op == 'not':
self.check_usable_type(operand_type, e)
result = self.chk.bool_type() # type: Type
elif op == '-':
method_type = self.analyze_external_member_access('__neg__',
operand_type, e)
result, method_type = self.check_call(method_type, [], [], e)
e.method_type = method_type
elif op == '+':
method_type = self.analyze_external_member_access('__pos__',
operand_type, e)
result, method_type = self.check_call(method_type, [], [], e)
e.method_type = method_type
else:
assert op == '~', "unhandled unary operator"
method_type = self.analyze_external_member_access('__invert__',
operand_type, e)
result, method_type = self.check_call(method_type, [], [], e)
e.method_type = method_type
return result
def visit_index_expr(self, e: IndexExpr) -> Type:
"""Type check an index expression (base[index]).
It may also represent type application.
"""
result = self.visit_index_expr_helper(e)
return self.chk.narrow_type_from_binder(e, result)
def visit_index_expr_helper(self, e: IndexExpr) -> Type:
if e.analyzed:
# It's actually a type application.
return self.accept(e.analyzed)
left_type = self.accept(e.base)
if isinstance(left_type, TupleType) and self.chk.in_checked_function():
# Special case for tuples. They support indexing only by integer
# literals.
index = e.index
if isinstance(index, SliceExpr):
return self.visit_tuple_slice_helper(left_type, index)
ok = False
if isinstance(index, IntExpr):
n = index.value
ok = True
elif isinstance(index, UnaryExpr):
if index.op == '-':
operand = index.expr
if isinstance(operand, IntExpr):
n = len(left_type.items) - operand.value
ok = True
if ok:
if n >= 0 and n < len(left_type.items):
return left_type.items[n]
else:
self.chk.fail(messages.TUPLE_INDEX_OUT_OF_RANGE, e)
return AnyType()
else:
self.chk.fail(messages.TUPLE_INDEX_MUST_BE_AN_INT_LITERAL, e)
return AnyType()
elif isinstance(left_type, TypedDictType):
return self.visit_typeddict_index_expr(left_type, e.index)
else:
result, method_type = self.check_op('__getitem__', left_type, e.index, e)
e.method_type = method_type
return result
def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr) -> Type:
begin = None # type: int
end = None # type: int
stride = None # type:int
if slic.begin_index:
begin = self._get_value(slic.begin_index)
if begin is None:
self.chk.fail(
messages.TUPLE_SLICE_MUST_BE_AN_INT_LITERAL,
slic.begin_index)
return AnyType()
if slic.end_index:
end = self._get_value(slic.end_index)
if end is None:
self.chk.fail(
messages.TUPLE_SLICE_MUST_BE_AN_INT_LITERAL,
slic.end_index)
return AnyType()
if slic.stride:
stride = self._get_value(slic.stride)
if stride is None:
self.chk.fail(
messages.TUPLE_SLICE_MUST_BE_AN_INT_LITERAL,
slic.stride)
return AnyType()
return left_type.slice(begin, stride, end)
def _get_value(self, index: Expression) -> Optional[int]:
if isinstance(index, IntExpr):
return index.value
elif isinstance(index, UnaryExpr):
if index.op == '-':
operand = index.expr
if isinstance(operand, IntExpr):
return -1 * operand.value
return None
def visit_typeddict_index_expr(self, td_type: TypedDictType, index: Expression) -> Type:
if not isinstance(index, (StrExpr, UnicodeExpr)):
self.msg.typeddict_item_name_must_be_string_literal(td_type, index)
return AnyType()
item_name = index.value
item_type = td_type.items.get(item_name)
if item_type is None:
self.msg.typeddict_item_name_not_found(td_type, item_name, index)
return AnyType()
return item_type
def visit_cast_expr(self, expr: CastExpr) -> Type:
"""Type check a cast expression."""
source_type = self.accept(expr.expr, context=AnyType())
target_type = expr.type
if self.chk.options.warn_redundant_casts and is_same_type(source_type, target_type):
self.msg.redundant_cast(target_type, expr)
if not self.is_valid_cast(source_type, target_type):
self.msg.invalid_cast(target_type, source_type, expr)
return target_type
def is_valid_cast(self, source_type: Type, target_type: Type) -> bool:
"""Is a cast from source_type to target_type meaningful?"""
return (isinstance(target_type, AnyType) or
(not isinstance(source_type, Void) and
not isinstance(target_type, Void)))
def visit_reveal_type_expr(self, expr: RevealTypeExpr) -> Type:
"""Type check a reveal_type expression."""
revealed_type = self.accept(expr.expr)
if not self.chk.current_node_deferred:
self.msg.reveal_type(revealed_type, expr)
return revealed_type
def visit_type_application(self, tapp: TypeApplication) -> Type:
"""Type check a type application (expr[type, ...])."""
tp = self.accept(tapp.expr)
if isinstance(tp, CallableType):
if not tp.is_type_obj():
self.chk.fail(messages.ONLY_CLASS_APPLICATION, tapp)
if len(tp.variables) != len(tapp.types):
self.msg.incompatible_type_application(len(tp.variables),
len(tapp.types), tapp)
return AnyType()
return self.apply_generic_arguments(tp, tapp.types, tapp)
elif isinstance(tp, Overloaded):
if not tp.is_type_obj():
self.chk.fail(messages.ONLY_CLASS_APPLICATION, tapp)
for item in tp.items():
if len(item.variables) != len(tapp.types):
self.msg.incompatible_type_application(len(item.variables),
len(tapp.types), tapp)
return AnyType()
return Overloaded([self.apply_generic_arguments(item, tapp.types, tapp)
for item in tp.items()])
return AnyType()
def visit_type_alias_expr(self, alias: TypeAliasExpr) -> Type:
"""Get type of a type alias (could be generic) in a runtime expression."""
if isinstance(alias.type, Instance) and alias.type.invalid:
# An invalid alias, error already has been reported
return AnyType()
item = alias.type
if not alias.in_runtime:
# We don't replace TypeVar's with Any for alias used as Alias[T](42).
item = self.replace_tvars_any(item)
if isinstance(item, Instance):
# Normally we get a callable type (or overloaded) with .is_type_obj() true
# representing the class's constructor
tp = type_object_type(item.type, self.named_type)
else:
# This type is invalid in most runtime contexts
# and corresponding an error will be reported.
return alias.fallback
if isinstance(tp, CallableType):
if len(tp.variables) != len(item.args):
self.msg.incompatible_type_application(len(tp.variables),
len(item.args), item)
return AnyType()
return self.apply_generic_arguments(tp, item.args, item)
elif isinstance(tp, Overloaded):
for it in tp.items():
if len(it.variables) != len(item.args):
self.msg.incompatible_type_application(len(it.variables),
len(item.args), item)
return AnyType()
return Overloaded([self.apply_generic_arguments(it, item.args, item)
for it in tp.items()])
return AnyType()
def replace_tvars_any(self, tp: Type) -> Type:
"""Replace all type variables of a type alias tp with Any. Basically, this function
finishes what could not be done in method TypeAnalyser.visit_unbound_type()
from typeanal.py.
"""
typ_args = get_typ_args(tp)
new_args = typ_args[:]
for i, arg in enumerate(typ_args):
if isinstance(arg, UnboundType):
sym = None
try:
sym = self.chk.lookup_qualified(arg.name)
except KeyError:
pass
if sym and (sym.kind == UNBOUND_TVAR or sym.kind == BOUND_TVAR):
new_args[i] = AnyType()
else:
new_args[i] = self.replace_tvars_any(arg)
return set_typ_args(tp, new_args, tp.line, tp.column)
def visit_list_expr(self, e: ListExpr) -> Type:
"""Type check a list expression [...]."""
return self.check_lst_expr(e.items, 'builtins.list', '', e)
def visit_set_expr(self, e: SetExpr) -> Type:
return self.check_lst_expr(e.items, 'builtins.set', '', e)
def check_lst_expr(self, items: List[Expression], fullname: str,
tag: str, context: Context) -> Type:
# Translate into type checking a generic function call.
# Used for list and set expressions, as well as for tuples
# containing star expressions that don't refer to a
# Tuple. (Note: "lst" stands for list-set-tuple. :-)
tvdef = TypeVarDef('T', -1, [], self.chk.object_type())
tv = TypeVarType(tvdef)
constructor = CallableType(
[tv],
[nodes.ARG_STAR],
[None],
self.chk.named_generic_type(fullname, [tv]),
self.named_type('builtins.function'),
name=tag,
variables=[tvdef])
return self.check_call(constructor,
[(i.expr if isinstance(i, StarExpr) else i)
for i in items],
[(nodes.ARG_STAR if isinstance(i, StarExpr) else nodes.ARG_POS)
for i in items],
context)[0]
def visit_tuple_expr(self, e: TupleExpr) -> Type:
"""Type check a tuple expression."""
# Try to determine type context for type inference.
type_context = self.chk.type_context[-1]
type_context_items = None
if isinstance(type_context, UnionType):
tuples_in_context = [t for t in type_context.items
if (isinstance(t, TupleType) and len(t.items) == len(e.items)) or
is_named_instance(t, 'builtins.tuple')]
if len(tuples_in_context) == 1:
type_context = tuples_in_context[0]
else:
# There are either no relevant tuples in the Union, or there is
# more than one. Either way, we can't decide on a context.
pass
if isinstance(type_context, TupleType):
type_context_items = type_context.items
elif is_named_instance(type_context, 'builtins.tuple'):
assert isinstance(type_context, Instance)
if type_context.args:
type_context_items = [type_context.args[0]] * len(e.items)
# NOTE: it's possible for the context to have a different
# number of items than e. In that case we use those context
# items that match a position in e, and we'll worry about type
# mismatches later.
# Infer item types. Give up if there's a star expression
# that's not a Tuple.
items = [] # type: List[Type]
j = 0 # Index into type_context_items; irrelevant if type_context_items is none
for i in range(len(e.items)):
item = e.items[i]
tt = None # type: Type
if isinstance(item, StarExpr):
# Special handling for star expressions.
# TODO: If there's a context, and item.expr is a
# TupleExpr, flatten it, so we can benefit from the
# context? Counterargument: Why would anyone write
# (1, *(2, 3)) instead of (1, 2, 3) except in a test?
tt = self.accept(item.expr)
self.check_usable_type(tt, e)
if isinstance(tt, TupleType):
items.extend(tt.items)
j += len(tt.items)
else:
# A star expression that's not a Tuple.
# Treat the whole thing as a variable-length tuple.
return self.check_lst_expr(e.items, 'builtins.tuple', '', e)
else:
if not type_context_items or j >= len(type_context_items):
tt = self.accept(item)
else:
tt = self.accept(item, type_context_items[j])
j += 1
self.check_usable_type(tt, e)
items.append(tt)
fallback_item = join.join_type_list(items)
return TupleType(items, self.chk.named_generic_type('builtins.tuple', [fallback_item]))
def visit_dict_expr(self, e: DictExpr) -> Type:
"""Type check a dict expression.
Translate it into a call to dict(), with provisions for **expr.
"""
# Collect function arguments, watching out for **expr.
args = [] # type: List[Expression] # Regular "key: value"
stargs = [] # type: List[Expression] # For "**expr"
for key, value in e.items:
if key is None:
stargs.append(value)
else:
args.append(TupleExpr([key, value]))
# Define type variables (used in constructors below).
ktdef = TypeVarDef('KT', -1, [], self.chk.object_type())
vtdef = TypeVarDef('VT', -2, [], self.chk.object_type())
kt = TypeVarType(ktdef)
vt = TypeVarType(vtdef)
# Call dict(*args), unless it's empty and stargs is not.
if args or not stargs:
# The callable type represents a function like this:
#
# def (*v: Tuple[kt, vt]) -> Dict[kt, vt]: ...
constructor = CallableType(
[TupleType([kt, vt], self.named_type('builtins.tuple'))],
[nodes.ARG_STAR],
[None],
self.chk.named_generic_type('builtins.dict', [kt, vt]),
self.named_type('builtins.function'),
name='',
variables=[ktdef, vtdef])
rv = self.check_call(constructor, args, [nodes.ARG_POS] * len(args), e)[0]
else:
# dict(...) will be called below.
rv = None
# Call rv.update(arg) for each arg in **stargs,
# except if rv isn't set yet, then set rv = dict(arg).
if stargs:
for arg in stargs:
if rv is None:
constructor = CallableType(
[self.chk.named_generic_type('typing.Mapping', [kt, vt])],
[nodes.ARG_POS],
[None],
self.chk.named_generic_type('builtins.dict', [kt, vt]),
self.named_type('builtins.function'),
name='',
variables=[ktdef, vtdef])
rv = self.check_call(constructor, [arg], [nodes.ARG_POS], arg)[0]
else:
method = self.analyze_external_member_access('update', rv, arg)
self.check_call(method, [arg], [nodes.ARG_POS], arg)
return rv
def visit_func_expr(self, e: FuncExpr) -> Type:
"""Type check lambda expression."""
inferred_type = self.infer_lambda_type_using_context(e)
if not inferred_type:
# No useful type context.
ret_type = self.accept(e.expr())
if isinstance(ret_type, NoneTyp):
ret_type = Void()
fallback = self.named_type('builtins.function')
return callable_type(e, fallback, ret_type)
else:
# Type context available.
self.chk.check_func_item(e, type_override=inferred_type)
if e.expr() not in self.chk.type_map:
self.accept(e.expr())
ret_type = self.chk.type_map[e.expr()]
if isinstance(ret_type, NoneTyp):
# For "lambda ...: None", just use type from the context.
# Important when the context is Callable[..., None] which
# really means Void. See #1425.
return inferred_type
return replace_callable_return_type(inferred_type, ret_type)
def infer_lambda_type_using_context(self, e: FuncExpr) -> Optional[CallableType]:
"""Try to infer lambda expression type using context.
Return None if could not infer type.
"""
# TODO also accept 'Any' context
ctx = self.chk.type_context[-1]
if isinstance(ctx, UnionType):
callables = [t for t in ctx.items if isinstance(t, CallableType)]
if len(callables) == 1:
ctx = callables[0]
if not ctx or not isinstance(ctx, CallableType):
return None
# The context may have function type variables in it. We replace them
# since these are the type variables we are ultimately trying to infer;
# they must be considered as indeterminate. We use ErasedType since it
# does not affect type inference results (it is for purposes like this
# only).
callable_ctx = replace_meta_vars(ctx, ErasedType())
assert isinstance(callable_ctx, CallableType)
arg_kinds = [arg.kind for arg in e.arguments]
if callable_ctx.is_ellipsis_args:
# Fill in Any arguments to match the arguments of the lambda.
callable_ctx = callable_ctx.copy_modified(
is_ellipsis_args=False,
arg_types=[AnyType()] * len(arg_kinds),
arg_kinds=arg_kinds
)
if ARG_STAR in arg_kinds or ARG_STAR2 in arg_kinds:
# TODO treat this case appropriately
return None
if callable_ctx.arg_kinds != arg_kinds:
# Incompatible context; cannot use it to infer types.
self.chk.fail(messages.CANNOT_INFER_LAMBDA_TYPE, e)
return None
return callable_ctx
def visit_super_expr(self, e: SuperExpr) -> Type:
"""Type check a super expression (non-lvalue)."""
t = self.analyze_super(e, False)
return t
def analyze_super(self, e: SuperExpr, is_lvalue: bool) -> Type:
"""Type check a super expression."""
if e.info and e.info.bases:
# TODO fix multiple inheritance etc
if len(e.info.mro) < 2:
self.chk.fail('Internal error: unexpected mro for {}: {}'.format(
e.info.name(), e.info.mro), e)
return AnyType()
for base in e.info.mro[1:]:
if e.name in base.names or base == e.info.mro[-1]:
if e.info.fallback_to_any and base == e.info.mro[-1]:
# There's an undefined base class, and we're
# at the end of the chain. That's not an error.
return AnyType()
if not self.chk.in_checked_function():
return AnyType()
args = self.chk.scope.top_function().arguments
# An empty args with super() is an error; we need something in declared_self
if not args:
self.chk.fail('super() requires at least one positional argument', e)
return AnyType()
declared_self = args[0].variable.type
return analyze_member_access(name=e.name, typ=fill_typevars(e.info), node=e,
is_lvalue=False, is_super=True, is_operator=False,
builtin_type=self.named_type,
not_ready_callback=self.not_ready_callback,
msg=self.msg, override_info=base,
original_type=declared_self, chk=self.chk)
assert False, 'unreachable'
else:
# Invalid super. This has been reported by the semantic analyzer.
return AnyType()
def visit_slice_expr(self, e: SliceExpr) -> Type:
for index in [e.begin_index, e.end_index, e.stride]:
if index:
t = self.accept(index)
self.chk.check_subtype(t, self.named_type('builtins.int'),
index, messages.INVALID_SLICE_INDEX)
return self.named_type('builtins.slice')
def visit_list_comprehension(self, e: ListComprehension) -> Type:
return self.check_generator_or_comprehension(
e.generator, 'builtins.list', '')
def visit_set_comprehension(self, e: SetComprehension) -> Type:
return self.check_generator_or_comprehension(
e.generator, 'builtins.set', '')
def visit_generator_expr(self, e: GeneratorExpr) -> Type:
return self.check_generator_or_comprehension(e, 'typing.Iterator',
'')
def check_generator_or_comprehension(self, gen: GeneratorExpr,
type_name: str,
id_for_messages: str) -> Type:
"""Type check a generator expression or a list comprehension."""
with self.chk.binder.frame_context(can_skip=True, fall_through=0):
self.check_for_comp(gen)
# Infer the type of the list comprehension by using a synthetic generic
# callable type.
tvdef = TypeVarDef('T', -1, [], self.chk.object_type())
tv = TypeVarType(tvdef)
constructor = CallableType(
[tv],
[nodes.ARG_POS],
[None],
self.chk.named_generic_type(type_name, [tv]),
self.chk.named_type('builtins.function'),
name=id_for_messages,
variables=[tvdef])
return self.check_call(constructor,
[gen.left_expr], [nodes.ARG_POS], gen)[0]
def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> Type:
"""Type check a dictionary comprehension."""
with self.chk.binder.frame_context(can_skip=True, fall_through=0):
self.check_for_comp(e)
# Infer the type of the list comprehension by using a synthetic generic
# callable type.
ktdef = TypeVarDef('KT', -1, [], self.chk.object_type())
vtdef = TypeVarDef('VT', -2, [], self.chk.object_type())
kt = TypeVarType(ktdef)
vt = TypeVarType(vtdef)
constructor = CallableType(
[kt, vt],
[nodes.ARG_POS, nodes.ARG_POS],
[None, None],
self.chk.named_generic_type('builtins.dict', [kt, vt]),
self.chk.named_type('builtins.function'),
name='',
variables=[ktdef, vtdef])
return self.check_call(constructor,
[e.key, e.value], [nodes.ARG_POS, nodes.ARG_POS], e)[0]
def check_for_comp(self, e: Union[GeneratorExpr, DictionaryComprehension]) -> None:
"""Check the for_comp part of comprehensions. That is the part from 'for':
... for x in y if z
Note: This adds the type information derived from the condlists to the current binder.
"""
for index, sequence, conditions in zip(e.indices, e.sequences,
e.condlists):
sequence_type = self.chk.analyze_iterable_item_type(sequence)
self.chk.analyze_index_variables(index, sequence_type, e)
for condition in conditions:
self.accept(condition)
# values are only part of the comprehension when all conditions are true
true_map, _ = mypy.checker.find_isinstance_check(condition, self.chk.type_map)
if true_map:
for var, type in true_map.items():
self.chk.binder.push(var, type)
def visit_conditional_expr(self, e: ConditionalExpr) -> Type:
cond_type = self.accept(e.cond)
self.check_usable_type(cond_type, e)
ctx = self.chk.type_context[-1]
# Gain type information from isinstance if it is there
# but only for the current expression
if_map, else_map = self.chk.find_isinstance_check(e.cond)
if_type = self.analyze_cond_branch(if_map, e.if_expr, context=ctx)
if not mypy.checker.is_valid_inferred_type(if_type):
# Analyze the right branch disregarding the left branch.
else_type = self.analyze_cond_branch(else_map, e.else_expr, context=ctx)
# If it would make a difference, re-analyze the left
# branch using the right branch's type as context.
if ctx is None or not is_equivalent(else_type, ctx):
# TODO: If it's possible that the previous analysis of
# the left branch produced errors that are avoided
# using this context, suppress those errors.
if_type = self.analyze_cond_branch(if_map, e.if_expr, context=else_type)
else:
# Analyze the right branch in the context of the left
# branch's type.
else_type = self.analyze_cond_branch(else_map, e.else_expr, context=if_type)
res = join.join_types(if_type, else_type)
return res
def analyze_cond_branch(self, map: Optional[Dict[Expression, Type]],
node: Expression, context: Optional[Type]) -> Type:
with self.chk.binder.frame_context(can_skip=True, fall_through=0):
if map is None:
# We still need to type check node, in case we want to
# process it for isinstance checks later
self.accept(node, context=context)
return UninhabitedType()
self.chk.push_type_map(map)
return self.accept(node, context=context)
def visit_backquote_expr(self, e: BackquoteExpr) -> Type:
self.accept(e.expr)
return self.named_type('builtins.str')
#
# Helpers
#
def accept(self, node: Expression, context: Type = None) -> Type:
"""Type check a node. Alias for TypeChecker.accept."""
return self.chk.accept(node, context)
def check_usable_type(self, typ: Type, context: Context) -> None:
"""Generate an error if type is Void."""
self.chk.check_usable_type(typ, context)
def named_type(self, name: str) -> Instance:
"""Return an instance type with type given by the name and no type
arguments. Alias for TypeChecker.named_type.
"""
return self.chk.named_type(name)
def is_valid_var_arg(self, typ: Type) -> bool:
"""Is a type valid as a *args argument?"""
return (isinstance(typ, TupleType) or
is_subtype(typ, self.chk.named_generic_type('typing.Iterable',
[AnyType()])) or
isinstance(typ, AnyType))
def is_valid_keyword_var_arg(self, typ: Type) -> bool:
"""Is a type valid as a **kwargs argument?"""
if self.chk.options.python_version[0] >= 3:
return is_subtype(typ, self.chk.named_generic_type(
'builtins.dict', [self.named_type('builtins.str'),
AnyType()]))
else:
return (
is_subtype(typ, self.chk.named_generic_type(
'builtins.dict',
[self.named_type('builtins.str'),
AnyType()]))
or
is_subtype(typ, self.chk.named_generic_type(
'builtins.dict',
[self.named_type('builtins.unicode'),
AnyType()])))
def has_member(self, typ: Type, member: str) -> bool:
"""Does type have member with the given name?"""
# TODO TupleType => also consider tuple attributes
if isinstance(typ, Instance):
return typ.type.has_readable_member(member)
elif isinstance(typ, AnyType):
return True
elif isinstance(typ, UnionType):
result = all(self.has_member(x, member) for x in typ.items)
return result
elif isinstance(typ, TupleType):
return self.has_member(typ.fallback, member)
else:
return False
def not_ready_callback(self, name: str, context: Context) -> None:
"""Called when we can't infer the type of a variable because it's not ready yet.
Either defer type checking of the enclosing function to the next
pass or report an error.
"""
self.chk.handle_cannot_determine_type(name, context)
def map_actuals_to_formals(caller_kinds: List[int],
caller_names: List[str],
callee_kinds: List[int],
callee_names: List[str],
caller_arg_type: Callable[[int],
Type]) -> List[List[int]]:
"""Calculate mapping between actual (caller) args and formals.
The result contains a list of caller argument indexes mapping to each
callee argument index, indexed by callee index.
The caller_arg_type argument should evaluate to the type of the actual
argument type with the given index.
"""
ncallee = len(callee_kinds)
map = [[] for i in range(ncallee)] # type: List[List[int]]
j = 0
for i, kind in enumerate(caller_kinds):
if kind == nodes.ARG_POS:
if j < ncallee:
if callee_kinds[j] in [nodes.ARG_POS, nodes.ARG_OPT,
nodes.ARG_NAMED, nodes.ARG_NAMED_OPT]:
map[j].append(i)
j += 1
elif callee_kinds[j] == nodes.ARG_STAR:
map[j].append(i)
elif kind == nodes.ARG_STAR:
# We need to know the actual type to map varargs.
argt = caller_arg_type(i)
if isinstance(argt, TupleType):
# A tuple actual maps to a fixed number of formals.
for _ in range(len(argt.items)):
if j < ncallee:
if callee_kinds[j] != nodes.ARG_STAR2:
map[j].append(i)
else:
break
if callee_kinds[j] != nodes.ARG_STAR:
j += 1
else:
# Assume that it is an iterable (if it isn't, there will be
# an error later).
while j < ncallee:
if callee_kinds[j] in (nodes.ARG_NAMED, nodes.ARG_NAMED_OPT, nodes.ARG_STAR2):
break
else:
map[j].append(i)
if callee_kinds[j] == nodes.ARG_STAR:
break
j += 1
elif kind in (nodes.ARG_NAMED, nodes.ARG_NAMED_OPT):
name = caller_names[i]
if name in callee_names:
map[callee_names.index(name)].append(i)
elif nodes.ARG_STAR2 in callee_kinds:
map[callee_kinds.index(nodes.ARG_STAR2)].append(i)
else:
assert kind == nodes.ARG_STAR2
for j in range(ncallee):
# TODO tuple varargs complicate this
no_certain_match = (
not map[j] or caller_kinds[map[j][0]] == nodes.ARG_STAR)
if ((callee_names[j] and no_certain_match)
or callee_kinds[j] == nodes.ARG_STAR2):
map[j].append(i)
return map
def is_empty_tuple(t: Type) -> bool:
return isinstance(t, TupleType) and not t.items
def is_duplicate_mapping(mapping: List[int], actual_kinds: List[int]) -> bool:
# Multiple actuals can map to the same formal only if they both come from
# varargs (*args and **kwargs); in this case at runtime it is possible that
# there are no duplicates. We need to allow this, as the convention
# f(..., *args, **kwargs) is common enough.
return len(mapping) > 1 and not (
len(mapping) == 2 and
actual_kinds[mapping[0]] == nodes.ARG_STAR and
actual_kinds[mapping[1]] == nodes.ARG_STAR2)
def replace_callable_return_type(c: CallableType, new_ret_type: Type) -> CallableType:
"""Return a copy of a callable type with a different return type."""
return c.copy_modified(ret_type=new_ret_type)
class ArgInferSecondPassQuery(types.TypeQuery):
"""Query whether an argument type should be inferred in the second pass.
The result is True if the type has a type variable in a callable return
type anywhere. For example, the result for Callable[[], T] is True if t is
a type variable.
"""
def __init__(self) -> None:
super().__init__(False, types.ANY_TYPE_STRATEGY)
def visit_callable_type(self, t: CallableType) -> bool:
return self.query_types(t.arg_types) or t.accept(HasTypeVarQuery())
class HasTypeVarQuery(types.TypeQuery):
"""Visitor for querying whether a type has a type variable component."""
def __init__(self) -> None:
super().__init__(False, types.ANY_TYPE_STRATEGY)
def visit_type_var(self, t: TypeVarType) -> bool:
return True
def has_erased_component(t: Type) -> bool:
return t is not None and t.accept(HasErasedComponentsQuery())
class HasErasedComponentsQuery(types.TypeQuery):
"""Visitor for querying whether a type has an erased component."""
def __init__(self) -> None:
super().__init__(False, types.ANY_TYPE_STRATEGY)
def visit_erased_type(self, t: ErasedType) -> bool:
return True
def overload_arg_similarity(actual: Type, formal: Type) -> int:
"""Return if caller argument (actual) is compatible with overloaded signature arg (formal).
Return a similarity level:
0: no match
1: actual is compatible, but only using type promotions (e.g. int vs float)
2: actual is compatible without type promotions (e.g. int vs object)
The distinction is important in cases where multiple overload items match. We want
give priority to higher similarity matches.
"""
# Replace type variables with their upper bounds. Overloading
# resolution is based on runtime behavior which erases type
# parameters, so no need to handle type variables occurring within
# a type.
if isinstance(actual, TypeVarType):
actual = actual.erase_to_union_or_bound()
if isinstance(formal, TypeVarType):
formal = formal.erase_to_union_or_bound()
if (isinstance(actual, UninhabitedType) or isinstance(actual, AnyType) or
isinstance(formal, AnyType) or
(isinstance(actual, Instance) and actual.type.fallback_to_any)):
# These could match anything at runtime.
return 2
if isinstance(formal, CallableType) and isinstance(actual, (CallableType, Overloaded)):
# TODO: do more sophisticated callable matching
return 2
if isinstance(actual, NoneTyp):
if not experiments.STRICT_OPTIONAL:
# NoneTyp matches anything if we're not doing strict Optional checking
return 2
else:
# NoneType is a subtype of object
if isinstance(formal, Instance) and formal.type.fullname() == "builtins.object":
return 2
if isinstance(actual, UnionType):
return max(overload_arg_similarity(item, formal)
for item in actual.items)
if isinstance(formal, UnionType):
return max(overload_arg_similarity(actual, item)
for item in formal.items)
if isinstance(formal, TypeType):
if isinstance(actual, TypeType):
# Since Type[T] is covariant, check if actual = Type[A] is
# a subtype of formal = Type[F].
return overload_arg_similarity(actual.item, formal.item)
elif isinstance(actual, CallableType) and actual.is_type_obj():
# Check if the actual is a constructor of some sort.
# Note that this is this unsound, since we don't check the __init__ signature.
return overload_arg_similarity(actual.ret_type, formal.item)
else:
return 0
if isinstance(formal, Instance):
if isinstance(actual, CallableType):
actual = actual.fallback
if isinstance(actual, Overloaded):
actual = actual.items()[0].fallback
if isinstance(actual, TupleType):
actual = actual.fallback
if isinstance(actual, Instance):
# First perform a quick check (as an optimization) and fall back to generic
# subtyping algorithm if type promotions are possible (e.g., int vs. float).
if formal.type in actual.type.mro:
return 2
elif actual.type._promote and is_subtype(actual, formal):
return 1
else:
return 0
elif isinstance(actual, TypeType):
if formal.type.fullname() in {"builtins.object", "builtins.type"}:
return 2
else:
return 0
else:
return 0
if isinstance(actual, UnboundType) or isinstance(formal, UnboundType):
# Either actual or formal is the result of an error; shut up.
return 2
# Fall back to a conservative equality check for the remaining kinds of type.
return 2 if is_same_type(erasetype.erase_type(actual), erasetype.erase_type(formal)) else 0
def freshen_generic_callable(callee: CallableType) -> CallableType:
tvdefs = []
tvmap = {} # type: Dict[TypeVarId, Type]
for v in callee.variables:
tvdef = TypeVarDef.new_unification_variable(v)
tvdefs.append(tvdef)
tvmap[v.id] = TypeVarType(tvdef)
return cast(CallableType, expand_type(callee, tvmap)).copy_modified(variables=tvdefs)
mypy-0.470/mypy/parsetype.py 0000644 0000000 0000000 00000016506 13012205774 014615 0 ustar root root """Type parser"""
from typing import List, Tuple, Union, Optional
from mypy.types import (
Type, UnboundType, TupleType, TypeList, CallableType, StarType,
EllipsisType
)
from mypy.lex import Token, Name, StrLit, lex
from mypy import nodes
none = Token('') # Empty token
class TypeParseError(Exception):
def __init__(self, token: Token, index: int, message: Optional[str] = None) -> None:
super().__init__()
self.token = token
self.index = index
self.message = message
def parse_type(tok: List[Token], index: int) -> Tuple[Type, int]:
"""Parse a type.
Return (type, index after type).
"""
p = TypeParser(tok, index)
return p.parse_type(), p.index()
def parse_types(tok: List[Token], index: int) -> Tuple[Type, int]:
"""Parse one or more types separated by commas (optional parentheses).
Return (type, index after type).
"""
p = TypeParser(tok, index)
return p.parse_types(), p.index()
class TypeParser:
def __init__(self, tok: List[Token], ind: int) -> None:
self.tok = tok
self.ind = ind
def index(self) -> int:
return self.ind
def parse_type(self) -> Type:
"""Parse a type."""
t = self.current_token()
if t.string == '(':
return self.parse_parens()
if isinstance(t, Name):
return self.parse_named_type()
elif t.string == '[':
return self.parse_type_list()
elif t.string == '*':
return self.parse_star_type()
elif t.string == '...':
return self.parse_ellipsis_type()
elif isinstance(t, StrLit):
# Type escaped as string literal.
typestr = t.parsed()
line = t.line
self.skip()
try:
result = parse_str_as_type(typestr, line)
except TypeParseError as e:
raise TypeParseError(e.token, self.ind)
return result
else:
raise self.parse_error()
def parse_parens(self) -> Type:
self.expect('(')
types = self.parse_types()
self.expect(')')
return types
def parse_types(self) -> Type:
""" Parse either a single type or a comma separated
list of types as a tuple type. In the latter case, a
trailing comma is needed when the list contains only
a single type (and optional otherwise).
int -> int
int, -> TupleType[int]
int, int, int -> TupleType[int, int, int]
"""
type = self.parse_type()
if self.current_token_str() == ',':
items = [type]
while self.current_token_str() == ',':
self.skip()
if self.current_token_str() == ')':
break
items.append(self.parse_type())
type = TupleType(items, None, type.line, implicit=True)
return type
def parse_type_list(self) -> TypeList:
"""Parse type list [t, ...]."""
lbracket = self.expect('[')
commas = [] # type: List[Token]
items = [] # type: List[Type]
while self.current_token_str() != ']':
t = self.parse_type()
items.append(t)
if self.current_token_str() != ',':
break
commas.append(self.skip())
self.expect(']')
return TypeList(items, line=lbracket.line)
def parse_named_type(self) -> Type:
line = self.current_token().line
name = ''
components = [] # type: List[Token]
components.append(self.expect_type(Name))
name += components[-1].string
while self.current_token_str() == '.':
components.append(self.skip())
t = self.expect_type(Name)
components.append(t)
name += '.' + t.string
commas = [] # type: List[Token]
args = [] # type: List[Type]
if self.current_token_str() == '[':
self.skip()
while True:
typ = self.parse_type()
args.append(typ)
if self.current_token_str() != ',':
break
commas.append(self.skip())
self.expect(']')
typ = UnboundType(name, args, line)
return typ
def parse_star_type(self) -> Type:
star = self.expect('*')
type = self.parse_type()
return StarType(type, star.line)
def parse_ellipsis_type(self) -> Type:
ellipsis = self.expect('...')
return EllipsisType(ellipsis.line)
# Helpers
def skip(self) -> Token:
self.ind += 1
return self.tok[self.ind - 1]
def expect(self, string: str) -> Token:
if self.tok[self.ind].string == string:
self.ind += 1
return self.tok[self.ind - 1]
else:
raise self.parse_error()
def expect_type(self, typ: type) -> Token:
if isinstance(self.current_token(), typ):
self.ind += 1
return self.tok[self.ind - 1]
else:
raise self.parse_error()
def current_token(self) -> Token:
return self.tok[self.ind]
def current_token_str(self) -> str:
return self.current_token().string
def parse_error(self) -> TypeParseError:
return TypeParseError(self.tok[self.ind], self.ind)
def parse_str_as_type(typestr: str, line: int) -> Type:
"""Parse a type represented as a string.
Raise TypeParseError on parse error.
"""
typestr = typestr.strip()
tokens = lex(typestr, line)[0]
result, i = parse_type(tokens, 0)
if i < len(tokens) - 2:
raise TypeParseError(tokens[i], i)
return result
def parse_signature(tokens: List[Token]) -> Tuple[CallableType, int]:
"""Parse signature of form (argtype, ...) -> ...
Return tuple (signature type, token index).
"""
i = 0
if tokens[i].string != '(':
raise TypeParseError(tokens[i], i)
i += 1
arg_types = [] # type: List[Type]
arg_kinds = [] # type: List[int]
encountered_ellipsis = False
while tokens[i].string != ')':
if tokens[i].string == '*':
arg_kinds.append(nodes.ARG_STAR)
i += 1
elif tokens[i].string == '**':
arg_kinds.append(nodes.ARG_STAR2)
i += 1
else:
arg_kinds.append(nodes.ARG_POS)
arg, i = parse_type(tokens, i)
arg_types.append(arg)
next = tokens[i].string
# Check for ellipsis. If it exists, assert it's the only arg_type.
# Disallow '(..., int) -> None' for example.
if isinstance(arg, EllipsisType):
encountered_ellipsis = True
if encountered_ellipsis and len(arg_types) != 1:
raise TypeParseError(tokens[i], i,
"Ellipses cannot accompany other argument types"
" in function type signature.")
if next not in ',)':
raise TypeParseError(tokens[i], i)
if next == ',':
i += 1
i += 1
if tokens[i].string != '->':
raise TypeParseError(tokens[i], i)
i += 1
ret_type, i = parse_type(tokens, i)
return CallableType(arg_types,
arg_kinds,
[None] * len(arg_types),
ret_type, None,
is_ellipsis_args=encountered_ellipsis), i
mypy-0.470/mypy/sharedparse.py 0000644 0000000 0000000 00000003403 13035550742 015075 0 ustar root root from typing import Union, Tuple
"""Shared logic between our three mypy parser files."""
MAGIC_METHODS = {
"__abs__",
"__add__",
"__and__",
"__call__",
"__cmp__",
"__complex__",
"__contains__",
"__del__",
"__delattr__",
"__delitem__",
"__divmod__",
"__div__",
"__divmod__",
"__enter__",
"__exit__",
"__eq__",
"__floordiv__",
"__float__",
"__ge__",
"__getattr__",
"__getattribute__",
"__getitem__",
"__gt__",
"__hex__",
"__iadd__",
"__iand__",
"__idiv__",
"__ifloordiv__",
"__ilshift__",
"__imod__",
"__imul__",
"__init__",
"__init_subclass__",
"__int__",
"__invert__",
"__ior__",
"__ipow__",
"__irshift__",
"__isub__",
"__iter__",
"__ixor__",
"__le__",
"__len__",
"__long__",
"__lshift__",
"__lt__",
"__mod__",
"__mul__",
"__ne__",
"__neg__",
"__new__",
"__nonzero__",
"__oct__",
"__or__",
"__pos__",
"__pow__",
"__radd__",
"__rand__",
"__rdiv__",
"__repr__",
"__reversed__",
"__rfloordiv__",
"__rlshift__",
"__rmod__",
"__rmul__",
"__ror__",
"__rpow__",
"__rrshift__",
"__rshift__",
"__rsub__",
"__rxor__",
"__setattr__",
"__setitem__",
"__str__",
"__sub__",
"__unicode__",
"__xor__",
}
MAGIC_METHODS_ALLOWING_KWARGS = {
"__init__",
"__init_subclass__",
"__new__",
}
MAGIC_METHODS_POS_ARGS_ONLY = MAGIC_METHODS - MAGIC_METHODS_ALLOWING_KWARGS
def special_function_elide_names(name: str) -> bool:
return name in MAGIC_METHODS_POS_ARGS_ONLY
def argument_elide_name(name: Union[str, Tuple, None]) -> bool:
return isinstance(name, str) and name.startswith("__")
mypy-0.470/mypy/semanal.py 0000644 0000000 0000000 00000453222 13044256774 014234 0 ustar root root """The semantic analyzer.
Bind names to definitions and do various other simple consistency
checks. For example, consider this program:
x = 1
y = x
Here semantic analysis would detect that the assignment 'x = 1'
defines a new variable, the type of which is to be inferred (in a
later pass; type inference or type checking is not part of semantic
analysis). Also, it would bind both references to 'x' to the same
module-level variable node. The second assignment would also be
analyzed, and the type of 'y' marked as being inferred.
Semantic analysis is the first analysis pass after parsing, and it is
subdivided into three passes:
* FirstPass looks up externally visible names defined in a module but
ignores imports and local definitions. It helps enable (some)
cyclic references between modules, such as module 'a' that imports
module 'b' and used names defined in b *and* vice versa. The first
pass can be performed before dependent modules have been processed.
* SemanticAnalyzer is the second pass. It does the bulk of the work.
It assumes that dependent modules have been semantically analyzed,
up to the second pass, unless there is a import cycle.
* ThirdPass checks that type argument counts are valid; for example,
it will reject Dict[int]. We don't do this in the second pass,
since we infer the type argument counts of classes during this
pass, and it is possible to refer to classes defined later in a
file, which would not have the type argument count set yet. This
pass also recomputes the method resolution order of each class, in
case one of its bases belongs to a module involved in an import
loop.
Semantic analysis of types is implemented in module mypy.typeanal.
TODO: Check if the third pass slows down type checking significantly.
We could probably get rid of it -- for example, we could collect all
analyzed types in a collection and check them without having to
traverse the entire AST.
"""
from collections import OrderedDict
from typing import (
List, Dict, Set, Tuple, cast, TypeVar, Union, Optional, Callable
)
from mypy.nodes import (
MypyFile, TypeInfo, Node, AssignmentStmt, FuncDef, OverloadedFuncDef,
ClassDef, Var, GDEF, MODULE_REF, FuncItem, Import, Expression, Lvalue,
ImportFrom, ImportAll, Block, LDEF, NameExpr, MemberExpr,
IndexExpr, TupleExpr, ListExpr, ExpressionStmt, ReturnStmt,
RaiseStmt, AssertStmt, OperatorAssignmentStmt, WhileStmt,
ForStmt, BreakStmt, ContinueStmt, IfStmt, TryStmt, WithStmt, DelStmt, PassStmt,
GlobalDecl, SuperExpr, DictExpr, CallExpr, RefExpr, OpExpr, UnaryExpr,
SliceExpr, CastExpr, RevealTypeExpr, TypeApplication, Context, SymbolTable,
SymbolTableNode, BOUND_TVAR, UNBOUND_TVAR, ListComprehension, GeneratorExpr,
FuncExpr, MDEF, FuncBase, Decorator, SetExpr, TypeVarExpr, NewTypeExpr,
StrExpr, BytesExpr, PrintStmt, ConditionalExpr, PromoteExpr,
ComparisonExpr, StarExpr, ARG_POS, ARG_NAMED, ARG_NAMED_OPT, MroError, type_aliases,
YieldFromExpr, NamedTupleExpr, TypedDictExpr, NonlocalDecl, SymbolNode,
SetComprehension, DictionaryComprehension, TYPE_ALIAS, TypeAliasExpr,
YieldExpr, ExecStmt, Argument, BackquoteExpr, ImportBase, AwaitExpr,
IntExpr, FloatExpr, UnicodeExpr, EllipsisExpr, TempNode,
COVARIANT, CONTRAVARIANT, INVARIANT, UNBOUND_IMPORTED, LITERAL_YES,
)
from mypy.visitor import NodeVisitor
from mypy.traverser import TraverserVisitor
from mypy.errors import Errors, report_internal_error
from mypy.types import (
NoneTyp, CallableType, Overloaded, Instance, Type, TypeVarType, AnyType,
FunctionLike, UnboundType, TypeList, TypeVarDef, TypeType,
TupleType, UnionType, StarType, EllipsisType, function_type, TypedDictType,
)
from mypy.nodes import implicit_module_attrs
from mypy.typeanal import TypeAnalyser, TypeAnalyserPass3, analyze_type_alias
from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
from mypy.sametypes import is_same_type
from mypy.erasetype import erase_typevars
from mypy.options import Options
from mypy import join
T = TypeVar('T')
# Inferred truth value of an expression.
ALWAYS_TRUE = 1
MYPY_TRUE = 2 # True in mypy, False at runtime
ALWAYS_FALSE = 3
MYPY_FALSE = 4 # False in mypy, True at runtime
TRUTH_VALUE_UNKNOWN = 5
inverted_truth_mapping = {
ALWAYS_TRUE: ALWAYS_FALSE,
ALWAYS_FALSE: ALWAYS_TRUE,
TRUTH_VALUE_UNKNOWN: TRUTH_VALUE_UNKNOWN,
MYPY_TRUE: MYPY_FALSE,
MYPY_FALSE: MYPY_TRUE,
}
# Map from obsolete name to the current spelling.
obsolete_name_mapping = {
'typing.Function': 'typing.Callable',
'typing.typevar': 'typing.TypeVar',
}
# Hard coded type promotions (shared between all Python versions).
# These add extra ad-hoc edges to the subtyping relation. For example,
# int is considered a subtype of float, even though there is no
# subclass relationship.
TYPE_PROMOTIONS = {
'builtins.int': 'builtins.float',
'builtins.float': 'builtins.complex',
}
# Hard coded type promotions for Python 3.
#
# Note that the bytearray -> bytes promotion is a little unsafe
# as some functions only accept bytes objects. Here convenience
# trumps safety.
TYPE_PROMOTIONS_PYTHON3 = TYPE_PROMOTIONS.copy()
TYPE_PROMOTIONS_PYTHON3.update({
'builtins.bytearray': 'builtins.bytes',
})
# Hard coded type promotions for Python 2.
#
# These promotions are unsafe, but we are doing them anyway
# for convenience and also for Python 3 compatibility
# (bytearray -> str).
TYPE_PROMOTIONS_PYTHON2 = TYPE_PROMOTIONS.copy()
TYPE_PROMOTIONS_PYTHON2.update({
'builtins.str': 'builtins.unicode',
'builtins.bytearray': 'builtins.str',
})
# When analyzing a function, should we analyze the whole function in one go, or
# should we only perform one phase of the analysis? The latter is used for
# nested functions. In the first phase we add the function to the symbol table
# but don't process body. In the second phase we process function body. This
# way we can have mutually recursive nested functions.
FUNCTION_BOTH_PHASES = 0 # Everthing in one go
FUNCTION_FIRST_PHASE_POSTPONE_SECOND = 1 # Add to symbol table but postpone body
FUNCTION_SECOND_PHASE = 2 # Only analyze body
class SemanticAnalyzer(NodeVisitor):
"""Semantically analyze parsed mypy files.
The analyzer binds names and does various consistency checks for a
parse tree. Note that type checking is performed as a separate
pass.
This is the second phase of semantic analysis.
"""
# Library search paths
lib_path = None # type: List[str]
# Module name space
modules = None # type: Dict[str, MypyFile]
# Global name space for current module
globals = None # type: SymbolTable
# Names declared using "global" (separate set for each scope)
global_decls = None # type: List[Set[str]]
# Names declated using "nonlocal" (separate set for each scope)
nonlocal_decls = None # type: List[Set[str]]
# Local names of function scopes; None for non-function scopes.
locals = None # type: List[SymbolTable]
# Nested block depths of scopes
block_depth = None # type: List[int]
# TypeInfo of directly enclosing class (or None)
type = None # type: TypeInfo
# Stack of outer classes (the second tuple item contains tvars).
type_stack = None # type: List[TypeInfo]
# Type variables that are bound by the directly enclosing class
bound_tvars = None # type: List[SymbolTableNode]
# Stack of type variables that were bound by outer classess
tvar_stack = None # type: List[List[SymbolTableNode]]
# Per-module options
options = None # type: Options
# Stack of functions being analyzed
function_stack = None # type: List[FuncItem]
# Stack of next available function type variable ids
next_function_tvar_id_stack = None # type: List[int]
# Status of postponing analysis of nested function bodies. By using this we
# can have mutually recursive nested functions. Values are FUNCTION_x
# constants. Note that separate phasea are not used for methods.
postpone_nested_functions_stack = None # type: List[int]
# Postponed functions collected if
# postpone_nested_functions_stack[-1] == FUNCTION_FIRST_PHASE_POSTPONE_SECOND.
postponed_functions_stack = None # type: List[List[Node]]
loop_depth = 0 # Depth of breakable loops
cur_mod_id = '' # Current module id (or None) (phase 2)
is_stub_file = False # Are we analyzing a stub file?
imports = None # type: Set[str] # Imported modules (during phase 2 analysis)
errors = None # type: Errors # Keeps track of generated errors
def __init__(self,
modules: Dict[str, MypyFile],
missing_modules: Set[str],
lib_path: List[str], errors: Errors) -> None:
"""Construct semantic analyzer.
Use lib_path to search for modules, and report analysis errors
using the Errors instance.
"""
self.locals = [None]
self.imports = set()
self.type = None
self.type_stack = []
self.bound_tvars = None
self.tvar_stack = []
self.function_stack = []
self.next_function_tvar_id_stack = [-1]
self.block_depth = [0]
self.loop_depth = 0
self.lib_path = lib_path
self.errors = errors
self.modules = modules
self.missing_modules = missing_modules
self.postpone_nested_functions_stack = [FUNCTION_BOTH_PHASES]
self.postponed_functions_stack = []
self.all_exports = set() # type: Set[str]
def visit_file(self, file_node: MypyFile, fnam: str, options: Options) -> None:
self.options = options
self.errors.set_file(fnam)
self.cur_mod_node = file_node
self.cur_mod_id = file_node.fullname()
self.is_stub_file = fnam.lower().endswith('.pyi')
self.globals = file_node.names
if 'builtins' in self.modules:
self.globals['__builtins__'] = SymbolTableNode(
MODULE_REF, self.modules['builtins'], self.cur_mod_id)
for name in implicit_module_attrs:
v = self.globals[name].node
if isinstance(v, Var):
v.type = self.anal_type(v.type)
v.is_ready = True
defs = file_node.defs
for d in defs:
self.accept(d)
if self.cur_mod_id == 'builtins':
remove_imported_names_from_symtable(self.globals, 'builtins')
if '__all__' in self.globals:
for name, g in self.globals.items():
if name not in self.all_exports:
g.module_public = False
del self.options
def visit_func_def(self, defn: FuncDef) -> None:
phase_info = self.postpone_nested_functions_stack[-1]
if phase_info != FUNCTION_SECOND_PHASE:
self.function_stack.append(defn)
# First phase of analysis for function.
self.errors.push_function(defn.name())
self.update_function_type_variables(defn)
self.errors.pop_function()
self.function_stack.pop()
defn.is_conditional = self.block_depth[-1] > 0
# TODO(jukka): Figure out how to share the various cases. It doesn't
# make sense to have (almost) duplicate code (here and elsewhere) for
# 3 cases: module-level, class-level and local names. Maybe implement
# a common stack of namespaces. As the 3 kinds of namespaces have
# different semantics, this wouldn't always work, but it might still
# be a win.
if self.is_class_scope():
# Method definition
defn.info = self.type
if not defn.is_decorated and not defn.is_overload:
if defn.name() in self.type.names:
# Redefinition. Conditional redefinition is okay.
n = self.type.names[defn.name()].node
if not self.set_original_def(n, defn):
self.name_already_defined(defn.name(), defn)
self.type.names[defn.name()] = SymbolTableNode(MDEF, defn)
self.prepare_method_signature(defn)
elif self.is_func_scope():
# Nested function
if not defn.is_decorated and not defn.is_overload:
if defn.name() in self.locals[-1]:
# Redefinition. Conditional redefinition is okay.
n = self.locals[-1][defn.name()].node
if not self.set_original_def(n, defn):
self.name_already_defined(defn.name(), defn)
else:
self.add_local(defn, defn)
else:
# Top-level function
if not defn.is_decorated and not defn.is_overload:
symbol = self.globals.get(defn.name())
if isinstance(symbol.node, FuncDef) and symbol.node != defn:
# This is redefinition. Conditional redefinition is okay.
if not self.set_original_def(symbol.node, defn):
# Report error.
self.check_no_global(defn.name(), defn, True)
if phase_info == FUNCTION_FIRST_PHASE_POSTPONE_SECOND:
# Postpone this function (for the second phase).
self.postponed_functions_stack[-1].append(defn)
return
if phase_info != FUNCTION_FIRST_PHASE_POSTPONE_SECOND:
# Second phase of analysis for function.
self.errors.push_function(defn.name())
self.analyze_function(defn)
if defn.is_coroutine and isinstance(defn.type, CallableType):
# A coroutine defined as `async def foo(...) -> T: ...`
# has external return type `Awaitable[T]`.
defn.type = defn.type.copy_modified(
ret_type = self.named_type_or_none('typing.Awaitable',
[defn.type.ret_type]))
self.errors.pop_function()
def prepare_method_signature(self, func: FuncDef) -> None:
"""Check basic signature validity and tweak annotation of self/cls argument."""
# Only non-static methods are special.
functype = func.type
if not func.is_static:
if not func.arguments:
self.fail('Method must have at least one argument', func)
elif isinstance(functype, CallableType):
self_type = functype.arg_types[0]
if isinstance(self_type, AnyType):
if func.is_class or func.name() in ('__new__', '__init_subclass__'):
leading_type = self.class_type(self.type)
else:
leading_type = fill_typevars(self.type)
func.type = replace_implicit_first_type(functype, leading_type)
def set_original_def(self, previous: Node, new: FuncDef) -> bool:
"""If 'new' conditionally redefine 'previous', set 'previous' as original
We reject straight redefinitions of functions, as they are usually
a programming error. For example:
. def f(): ...
. def f(): ... # Error: 'f' redefined
"""
if isinstance(previous, (FuncDef, Var)) and new.is_conditional:
new.original_def = previous
return True
else:
return False
def update_function_type_variables(self, defn: FuncDef) -> None:
"""Make any type variables in the signature of defn explicit.
Update the signature of defn to contain type variable definitions
if defn is generic.
"""
if defn.type:
assert isinstance(defn.type, CallableType)
typevars = self.infer_type_variables(defn.type)
# Do not define a new type variable if already defined in scope.
typevars = [(name, tvar) for name, tvar in typevars
if not self.is_defined_type_var(name, defn)]
if typevars:
next_tvar_id = self.next_function_tvar_id()
defs = [TypeVarDef(tvar[0], next_tvar_id - i,
tvar[1].values, tvar[1].upper_bound,
tvar[1].variance)
for i, tvar in enumerate(typevars)]
defn.type.variables = defs
def infer_type_variables(self,
type: CallableType) -> List[Tuple[str, TypeVarExpr]]:
"""Return list of unique type variables referred to in a callable."""
names = [] # type: List[str]
tvars = [] # type: List[TypeVarExpr]
for arg in type.arg_types + [type.ret_type]:
for name, tvar_expr in self.find_type_variables_in_type(arg):
if name not in names:
names.append(name)
tvars.append(tvar_expr)
return list(zip(names, tvars))
def find_type_variables_in_type(self, type: Type) -> List[Tuple[str, TypeVarExpr]]:
"""Return a list of all unique type variable references in type.
This effectively does partial name binding, results of which are mostly thrown away.
"""
result = [] # type: List[Tuple[str, TypeVarExpr]]
if isinstance(type, UnboundType):
name = type.name
node = self.lookup_qualified(name, type)
if node and node.kind == UNBOUND_TVAR:
assert isinstance(node.node, TypeVarExpr)
result.append((name, node.node))
for arg in type.args:
result.extend(self.find_type_variables_in_type(arg))
elif isinstance(type, TypeList):
for item in type.items:
result.extend(self.find_type_variables_in_type(item))
elif isinstance(type, UnionType):
for item in type.items:
result.extend(self.find_type_variables_in_type(item))
elif isinstance(type, AnyType):
pass
elif isinstance(type, EllipsisType) or isinstance(type, TupleType):
pass
else:
assert False, 'Unsupported type %s' % type
return result
def is_defined_type_var(self, tvar: str, context: Context) -> bool:
return self.lookup_qualified(tvar, context).kind == BOUND_TVAR
def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
t = [] # type: List[CallableType]
for i, item in enumerate(defn.items):
# TODO support decorated overloaded functions properly
item.is_overload = True
item.func.is_overload = True
item.accept(self)
callable = function_type(item.func, self.builtin_type('builtins.function'))
assert isinstance(callable, CallableType)
t.append(callable)
if item.func.is_property and i == 0:
# This defines a property, probably with a setter and/or deleter.
self.analyze_property_with_multi_part_definition(defn)
break
if not [dec for dec in item.decorators
if refers_to_fullname(dec, 'typing.overload')]:
self.fail("'overload' decorator expected", item)
defn.type = Overloaded(t)
defn.type.line = defn.line
if self.is_class_scope():
self.type.names[defn.name()] = SymbolTableNode(MDEF, defn,
typ=defn.type)
defn.info = self.type
elif self.is_func_scope():
self.add_local(defn, defn)
def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -> None:
"""Analyze a property defined using multiple methods (e.g., using @x.setter).
Assume that the first method (@property) has already been analyzed.
"""
defn.is_property = True
items = defn.items
for item in items[1:]:
if len(item.decorators) == 1:
node = item.decorators[0]
if isinstance(node, MemberExpr):
if node.name == 'setter':
# The first item represents the entire property.
defn.items[0].var.is_settable_property = True
# Get abstractness from the original definition.
item.func.is_abstract = items[0].func.is_abstract
else:
self.fail("Decorated property not supported", item)
item.func.accept(self)
def next_function_tvar_id(self) -> int:
return self.next_function_tvar_id_stack[-1]
def analyze_function(self, defn: FuncItem) -> None:
is_method = self.is_class_scope()
tvarnodes = self.add_func_type_variables_to_symbol_table(defn)
next_function_tvar_id = min([self.next_function_tvar_id()] +
[n.tvar_def.id.raw_id - 1 for n in tvarnodes])
self.next_function_tvar_id_stack.append(next_function_tvar_id)
if defn.type:
# Signature must be analyzed in the surrounding scope so that
# class-level imported names and type variables are in scope.
defn.type = self.anal_type(defn.type)
self.check_function_signature(defn)
if isinstance(defn, FuncDef):
defn.type = set_callable_name(defn.type, defn)
for arg in defn.arguments:
if arg.initializer:
arg.initializer.accept(self)
self.function_stack.append(defn)
self.enter()
for arg in defn.arguments:
self.add_local(arg.variable, defn)
for arg in defn.arguments:
if arg.initialization_statement:
lvalue = arg.initialization_statement.lvalues[0]
lvalue.accept(self)
# The first argument of a non-static, non-class method is like 'self'
# (though the name could be different), having the enclosing class's
# instance type.
if is_method and not defn.is_static and not defn.is_class and defn.arguments:
defn.arguments[0].variable.is_self = True
# First analyze body of the function but ignore nested functions.
self.postpone_nested_functions_stack.append(FUNCTION_FIRST_PHASE_POSTPONE_SECOND)
self.postponed_functions_stack.append([])
defn.body.accept(self)
# Analyze nested functions (if any) as a second phase.
self.postpone_nested_functions_stack[-1] = FUNCTION_SECOND_PHASE
for postponed in self.postponed_functions_stack[-1]:
postponed.accept(self)
self.postpone_nested_functions_stack.pop()
self.postponed_functions_stack.pop()
self.next_function_tvar_id_stack.pop()
disable_typevars(tvarnodes)
self.leave()
self.function_stack.pop()
def add_func_type_variables_to_symbol_table(
self, defn: FuncItem) -> List[SymbolTableNode]:
nodes = [] # type: List[SymbolTableNode]
if defn.type:
tt = defn.type
assert isinstance(tt, CallableType)
items = tt.variables
names = self.type_var_names()
for item in items:
name = item.name
if name in names:
self.name_already_defined(name, defn)
node = self.bind_type_var(name, item, defn)
nodes.append(node)
names.add(name)
return nodes
def type_var_names(self) -> Set[str]:
if not self.type:
return set()
else:
return set(self.type.type_vars)
def bind_type_var(self, fullname: str, tvar_def: TypeVarDef,
context: Context) -> SymbolTableNode:
node = self.lookup_qualified(fullname, context)
node.kind = BOUND_TVAR
node.tvar_def = tvar_def
return node
def check_function_signature(self, fdef: FuncItem) -> None:
sig = fdef.type
assert isinstance(sig, CallableType)
if len(sig.arg_types) < len(fdef.arguments):
self.fail('Type signature has too few arguments', fdef)
# Add dummy Any arguments to prevent crashes later.
extra_anys = [AnyType()] * (len(fdef.arguments) - len(sig.arg_types))
sig.arg_types.extend(extra_anys)
elif len(sig.arg_types) > len(fdef.arguments):
self.fail('Type signature has too many arguments', fdef, blocker=True)
def visit_class_def(self, defn: ClassDef) -> None:
self.clean_up_bases_and_infer_type_variables(defn)
if self.analyze_namedtuple_classdef(defn):
return
self.setup_class_def_analysis(defn)
self.bind_class_type_vars(defn)
self.analyze_base_classes(defn)
self.analyze_metaclass(defn)
for decorator in defn.decorators:
self.analyze_class_decorator(defn, decorator)
self.enter_class(defn)
# Analyze class body.
defn.defs.accept(self)
self.calculate_abstract_status(defn.info)
self.setup_type_promotion(defn)
self.leave_class()
self.unbind_class_type_vars()
def enter_class(self, defn: ClassDef) -> None:
# Remember previous active class
self.type_stack.append(self.type)
self.locals.append(None) # Add class scope
self.block_depth.append(-1) # The class body increments this to 0
self.postpone_nested_functions_stack.append(FUNCTION_BOTH_PHASES)
self.type = defn.info
def leave_class(self) -> None:
""" Restore analyzer state. """
self.postpone_nested_functions_stack.pop()
self.block_depth.pop()
self.locals.pop()
self.type = self.type_stack.pop()
def bind_class_type_vars(self, defn: ClassDef) -> None:
""" Unbind type variables of previously active class and bind
the type variables for the active class.
"""
if self.bound_tvars:
disable_typevars(self.bound_tvars)
self.tvar_stack.append(self.bound_tvars)
self.bound_tvars = self.bind_class_type_variables_in_symbol_table(defn.info)
def unbind_class_type_vars(self) -> None:
""" Unbind the active class' type vars and rebind the
type vars of the previously active class.
"""
disable_typevars(self.bound_tvars)
self.bound_tvars = self.tvar_stack.pop()
if self.bound_tvars:
enable_typevars(self.bound_tvars)
def analyze_class_decorator(self, defn: ClassDef, decorator: Expression) -> None:
decorator.accept(self)
def calculate_abstract_status(self, typ: TypeInfo) -> None:
"""Calculate abstract status of a class.
Set is_abstract of the type to True if the type has an unimplemented
abstract attribute. Also compute a list of abstract attributes.
"""
concrete = set() # type: Set[str]
abstract = [] # type: List[str]
for base in typ.mro:
for name, symnode in base.names.items():
node = symnode.node
if isinstance(node, OverloadedFuncDef):
# Unwrap an overloaded function definition. We can just
# check arbitrarily the first overload item. If the
# different items have a different abstract status, there
# should be an error reported elsewhere.
func = node.items[0] # type: Node
else:
func = node
if isinstance(func, Decorator):
fdef = func.func
if fdef.is_abstract and name not in concrete:
typ.is_abstract = True
abstract.append(name)
concrete.add(name)
typ.abstract_attributes = sorted(abstract)
def setup_type_promotion(self, defn: ClassDef) -> None:
"""Setup extra, ad-hoc subtyping relationships between classes (promotion).
This includes things like 'int' being compatible with 'float'.
"""
promote_target = None # type: Type
for decorator in defn.decorators:
if isinstance(decorator, CallExpr):
analyzed = decorator.analyzed
if isinstance(analyzed, PromoteExpr):
# _promote class decorator (undocumented faeture).
promote_target = analyzed.type
if not promote_target:
promotions = (TYPE_PROMOTIONS_PYTHON3 if self.options.python_version[0] >= 3
else TYPE_PROMOTIONS_PYTHON2)
if defn.fullname in promotions:
promote_target = self.named_type_or_none(promotions[defn.fullname])
defn.info._promote = promote_target
def clean_up_bases_and_infer_type_variables(self, defn: ClassDef) -> None:
"""Remove extra base classes such as Generic and infer type vars.
For example, consider this class:
. class Foo(Bar, Generic[T]): ...
Now we will remove Generic[T] from bases of Foo and infer that the
type variable 'T' is a type argument of Foo.
Note that this is performed *before* semantic analysis.
"""
removed = [] # type: List[int]
type_vars = [] # type: List[TypeVarDef]
for i, base_expr in enumerate(defn.base_type_exprs):
try:
base = expr_to_unanalyzed_type(base_expr)
except TypeTranslationError:
# This error will be caught later.
continue
tvars = self.analyze_typevar_declaration(base)
if tvars is not None:
if type_vars:
self.fail('Duplicate Generic in bases', defn)
removed.append(i)
for j, (name, tvar_expr) in enumerate(tvars):
type_vars.append(TypeVarDef(name, j + 1, tvar_expr.values,
tvar_expr.upper_bound, tvar_expr.variance))
if type_vars:
defn.type_vars = type_vars
if defn.info:
defn.info.type_vars = [tv.name for tv in type_vars]
for i in reversed(removed):
del defn.base_type_exprs[i]
def analyze_typevar_declaration(self, t: Type) -> Optional[List[Tuple[str, TypeVarExpr]]]:
if not isinstance(t, UnboundType):
return None
unbound = t
sym = self.lookup_qualified(unbound.name, unbound)
if sym is None or sym.node is None:
return None
if sym.node.fullname() == 'typing.Generic':
tvars = [] # type: List[Tuple[str, TypeVarExpr]]
for arg in unbound.args:
tvar = self.analyze_unbound_tvar(arg)
if tvar:
tvars.append(tvar)
else:
self.fail('Free type variable expected in %s[...]' %
sym.node.name(), t)
return tvars
return None
def analyze_unbound_tvar(self, t: Type) -> Tuple[str, TypeVarExpr]:
if not isinstance(t, UnboundType):
return None
unbound = t
sym = self.lookup_qualified(unbound.name, unbound)
if sym is not None and sym.kind == UNBOUND_TVAR:
assert isinstance(sym.node, TypeVarExpr)
return unbound.name, sym.node
return None
def analyze_namedtuple_classdef(self, defn: ClassDef) -> bool:
# special case for NamedTuple
for base_expr in defn.base_type_exprs:
if isinstance(base_expr, RefExpr):
base_expr.accept(self)
if base_expr.fullname == 'typing.NamedTuple':
node = self.lookup(defn.name, defn)
if node is not None:
node.kind = GDEF # TODO in process_namedtuple_definition also applies here
items, types = self.check_namedtuple_classdef(defn)
node.node = self.build_namedtuple_typeinfo(defn.name, items, types)
return True
return False
def check_namedtuple_classdef(self, defn: ClassDef) -> Tuple[List[str], List[Type]]:
NAMEDTUP_CLASS_ERROR = ('Invalid statement in NamedTuple definition; '
'expected "field_name: field_type"')
if self.options.python_version < (3, 6):
self.fail('NamedTuple class syntax is only supported in Python 3.6', defn)
return [], []
if len(defn.base_type_exprs) > 1:
self.fail('NamedTuple should be a single base', defn)
items = [] # type: List[str]
types = [] # type: List[Type]
for stmt in defn.defs.body:
if not isinstance(stmt, AssignmentStmt):
# Still allow pass or ... (for empty namedtuples).
if (not isinstance(stmt, PassStmt) and
not (isinstance(stmt, ExpressionStmt) and
isinstance(stmt.expr, EllipsisExpr))):
self.fail(NAMEDTUP_CLASS_ERROR, stmt)
elif len(stmt.lvalues) > 1 or not isinstance(stmt.lvalues[0], NameExpr):
# An assignment, but an invalid one.
self.fail(NAMEDTUP_CLASS_ERROR, stmt)
else:
# Append name and type in this case...
name = stmt.lvalues[0].name
items.append(name)
types.append(AnyType() if stmt.type is None else self.anal_type(stmt.type))
# ...despite possible minor failures that allow further analyzis.
if name.startswith('_'):
self.fail('NamedTuple field name cannot start with an underscore: {}'
.format(name), stmt)
if stmt.type is None or hasattr(stmt, 'new_syntax') and not stmt.new_syntax:
self.fail(NAMEDTUP_CLASS_ERROR, stmt)
elif not isinstance(stmt.rvalue, TempNode):
# x: int assigns rvalue to TempNode(AnyType())
self.fail('Right hand side values are not supported in NamedTuple', stmt)
return items, types
def setup_class_def_analysis(self, defn: ClassDef) -> None:
"""Prepare for the analysis of a class definition."""
if not defn.info:
defn.info = TypeInfo(SymbolTable(), defn, self.cur_mod_id)
defn.info._fullname = defn.info.name()
if self.is_func_scope() or self.type:
kind = MDEF
if self.is_func_scope():
kind = LDEF
self.add_symbol(defn.name, SymbolTableNode(kind, defn.info), defn)
def analyze_base_classes(self, defn: ClassDef) -> None:
"""Analyze and set up base classes.
This computes several attributes on the corresponding TypeInfo defn.info
related to the base classes: defn.info.bases, defn.info.mro, and
miscellaneous others (at least tuple_type, fallback_to_any, and is_enum.)
"""
base_types = [] # type: List[Instance]
info = defn.info
for base_expr in defn.base_type_exprs:
try:
base = self.expr_to_analyzed_type(base_expr)
except TypeTranslationError:
self.fail('Invalid base class', base_expr)
info.fallback_to_any = True
continue
if isinstance(base, TupleType):
if info.tuple_type:
self.fail("Class has two incompatible bases derived from tuple", defn)
defn.has_incompatible_baseclass = True
info.tuple_type = base
base_types.append(base.fallback)
elif isinstance(base, Instance):
if base.type.is_newtype:
self.fail("Cannot subclass NewType", defn)
base_types.append(base)
elif isinstance(base, AnyType):
if self.options.disallow_subclassing_any:
if isinstance(base_expr, (NameExpr, MemberExpr)):
msg = "Class cannot subclass '{}' (has type 'Any')".format(base_expr.name)
else:
msg = "Class cannot subclass value of type 'Any'"
self.fail(msg, base_expr)
info.fallback_to_any = True
else:
self.fail('Invalid base class', base_expr)
info.fallback_to_any = True
# Add 'object' as implicit base if there is no other base class.
if (not base_types and defn.fullname != 'builtins.object'):
base_types.append(self.object_type())
info.bases = base_types
# Calculate the MRO. It might be incomplete at this point if
# the bases of defn include classes imported from other
# modules in an import loop. We'll recompute it in ThirdPass.
if not self.verify_base_classes(defn):
# Give it an MRO consisting of just the class itself and object.
defn.info.mro = [defn.info, self.object_type().type]
return
calculate_class_mro(defn, self.fail_blocker)
# If there are cyclic imports, we may be missing 'object' in
# the MRO. Fix MRO if needed.
if info.mro and info.mro[-1].fullname() != 'builtins.object':
info.mro.append(self.object_type().type)
def expr_to_analyzed_type(self, expr: Expression) -> Type:
if isinstance(expr, CallExpr):
expr.accept(self)
info = self.check_namedtuple(expr)
if info is None:
# Some form of namedtuple is the only valid type that looks like a call
# expression. This isn't a valid type.
raise TypeTranslationError()
fallback = Instance(info, [])
return TupleType(info.tuple_type.items, fallback=fallback)
typ = expr_to_unanalyzed_type(expr)
return self.anal_type(typ)
def verify_base_classes(self, defn: ClassDef) -> bool:
info = defn.info
for base in info.bases:
baseinfo = base.type
if self.is_base_class(info, baseinfo):
self.fail('Cycle in inheritance hierarchy', defn, blocker=True)
# Clear bases to forcefully get rid of the cycle.
info.bases = []
if baseinfo.fullname() == 'builtins.bool':
self.fail("'%s' is not a valid base class" %
baseinfo.name(), defn, blocker=True)
return False
dup = find_duplicate(info.direct_base_classes())
if dup:
self.fail('Duplicate base class "%s"' % dup.name(), defn, blocker=True)
return False
return True
def is_base_class(self, t: TypeInfo, s: TypeInfo) -> bool:
"""Determine if t is a base class of s (but do not use mro)."""
# Search the base class graph for t, starting from s.
worklist = [s]
visited = {s}
while worklist:
nxt = worklist.pop()
if nxt == t:
return True
for base in nxt.bases:
if base.type not in visited:
worklist.append(base.type)
visited.add(base.type)
return False
def analyze_metaclass(self, defn: ClassDef) -> None:
if defn.metaclass:
if defn.metaclass == '':
self.fail("Dynamic metaclass not supported for '%s'" % defn.name, defn)
return
sym = self.lookup_qualified(defn.metaclass, defn)
if sym is not None and not isinstance(sym.node, TypeInfo):
self.fail("Invalid metaclass '%s'" % defn.metaclass, defn)
def object_type(self) -> Instance:
return self.named_type('__builtins__.object')
def str_type(self) -> Instance:
return self.named_type('__builtins__.str')
def class_type(self, info: TypeInfo) -> Type:
# Construct a function type whose fallback is cls.
from mypy import checkmember # To avoid import cycle.
leading_type = checkmember.type_object_type(info, self.builtin_type)
if isinstance(leading_type, Overloaded):
# Overloaded __init__ is too complex to handle. Plus it's stubs only.
return AnyType()
else:
return leading_type
def named_type(self, qualified_name: str, args: List[Type] = None) -> Instance:
sym = self.lookup_qualified(qualified_name, None)
assert isinstance(sym.node, TypeInfo)
return Instance(sym.node, args or [])
def named_type_or_none(self, qualified_name: str, args: List[Type] = None) -> Instance:
sym = self.lookup_fully_qualified_or_none(qualified_name)
if not sym:
return None
assert isinstance(sym.node, TypeInfo)
return Instance(sym.node, args or [])
def bind_class_type_variables_in_symbol_table(
self, info: TypeInfo) -> List[SymbolTableNode]:
nodes = [] # type: List[SymbolTableNode]
for var, binder in zip(info.type_vars, info.defn.type_vars):
node = self.bind_type_var(var, binder, info)
nodes.append(node)
return nodes
def visit_import(self, i: Import) -> None:
for id, as_id in i.ids:
if as_id is not None:
self.add_module_symbol(id, as_id, module_public=True, context=i)
else:
# Modules imported in a stub file without using 'as x' won't get exported when
# doing 'from m import *'.
module_public = not self.is_stub_file
base = id.split('.')[0]
self.add_module_symbol(base, base, module_public=module_public,
context=i)
self.add_submodules_to_parent_modules(id, module_public)
def add_submodules_to_parent_modules(self, id: str, module_public: bool) -> None:
"""Recursively adds a reference to a newly loaded submodule to its parent.
When you import a submodule in any way, Python will add a reference to that
submodule to its parent. So, if you do something like `import A.B` or
`from A import B` or `from A.B import Foo`, Python will add a reference to
module A.B to A's namespace.
Note that this "parent patching" process is completely independent from any
changes made to the *importer's* namespace. For example, if you have a file
named `foo.py` where you do `from A.B import Bar`, then foo's namespace will
be modified to contain a reference to only Bar. Independently, A's namespace
will be modified to contain a reference to `A.B`.
"""
while '.' in id:
parent, child = id.rsplit('.', 1)
parent_mod = self.modules.get(parent)
if parent_mod and child not in parent_mod.names:
child_mod = self.modules.get(id)
if child_mod:
sym = SymbolTableNode(MODULE_REF, child_mod, parent,
module_public=module_public)
parent_mod.names[child] = sym
id = parent
def add_module_symbol(self, id: str, as_id: str, module_public: bool,
context: Context) -> None:
if id in self.modules:
m = self.modules[id]
self.add_symbol(as_id, SymbolTableNode(MODULE_REF, m, self.cur_mod_id,
module_public=module_public), context)
else:
self.add_unknown_symbol(as_id, context, is_import=True)
def visit_import_from(self, imp: ImportFrom) -> None:
import_id = self.correct_relative_import(imp)
self.add_submodules_to_parent_modules(import_id, True)
module = self.modules.get(import_id)
for id, as_id in imp.names:
node = module.names.get(id) if module else None
missing = False
# If the module does not contain a symbol with the name 'id',
# try checking if it's a module instead.
if not node or node.kind == UNBOUND_IMPORTED:
possible_module_id = import_id + '.' + id
mod = self.modules.get(possible_module_id)
if mod is not None:
node = SymbolTableNode(MODULE_REF, mod, import_id)
self.add_submodules_to_parent_modules(possible_module_id, True)
elif possible_module_id in self.missing_modules:
missing = True
if node and node.kind != UNBOUND_IMPORTED:
node = self.normalize_type_alias(node, imp)
if not node:
return
imported_id = as_id or id
existing_symbol = self.globals.get(imported_id)
if existing_symbol:
# Import can redefine a variable. They get special treatment.
if self.process_import_over_existing_name(
imported_id, existing_symbol, node, imp):
continue
# 'from m import x as x' exports x in a stub file.
module_public = not self.is_stub_file or as_id is not None
symbol = SymbolTableNode(node.kind, node.node,
self.cur_mod_id,
node.type_override,
module_public=module_public)
self.add_symbol(imported_id, symbol, imp)
elif module and not missing:
# Missing attribute.
message = "Module '{}' has no attribute '{}'".format(import_id, id)
extra = self.undefined_name_extra_info('{}.{}'.format(import_id, id))
if extra:
message += " {}".format(extra)
self.fail(message, imp)
else:
# Missing module.
self.add_unknown_symbol(as_id or id, imp, is_import=True)
def process_import_over_existing_name(self,
imported_id: str, existing_symbol: SymbolTableNode,
module_symbol: SymbolTableNode,
import_node: ImportBase) -> bool:
if (existing_symbol.kind in (LDEF, GDEF, MDEF) and
isinstance(existing_symbol.node, (Var, FuncDef, TypeInfo))):
# This is a valid import over an existing definition in the file. Construct a dummy
# assignment that we'll use to type check the import.
lvalue = NameExpr(imported_id)
lvalue.kind = existing_symbol.kind
lvalue.node = existing_symbol.node
rvalue = NameExpr(imported_id)
rvalue.kind = module_symbol.kind
rvalue.node = module_symbol.node
assignment = AssignmentStmt([lvalue], rvalue)
for node in assignment, lvalue, rvalue:
node.set_line(import_node)
import_node.assignments.append(assignment)
return True
return False
def normalize_type_alias(self, node: SymbolTableNode,
ctx: Context) -> SymbolTableNode:
if node.fullname in type_aliases:
# Node refers to an aliased type such as typing.List; normalize.
node = self.lookup_qualified(type_aliases[node.fullname], ctx)
if node.fullname == 'typing.DefaultDict':
self.add_module_symbol('collections', '__mypy_collections__', False, ctx)
node = self.lookup_qualified('__mypy_collections__.defaultdict', ctx)
return node
def correct_relative_import(self, node: Union[ImportFrom, ImportAll]) -> str:
if node.relative == 0:
return node.id
parts = self.cur_mod_id.split(".")
cur_mod_id = self.cur_mod_id
rel = node.relative
if self.cur_mod_node.is_package_init_file():
rel -= 1
if len(parts) < rel:
self.fail("Relative import climbs too many namespaces", node)
if rel != 0:
cur_mod_id = ".".join(parts[:-rel])
return cur_mod_id + (("." + node.id) if node.id else "")
def visit_import_all(self, i: ImportAll) -> None:
i_id = self.correct_relative_import(i)
if i_id in self.modules:
m = self.modules[i_id]
self.add_submodules_to_parent_modules(i_id, True)
for name, node in m.names.items():
node = self.normalize_type_alias(node, i)
if not name.startswith('_') and node.module_public:
existing_symbol = self.globals.get(name)
if existing_symbol:
# Import can redefine a variable. They get special treatment.
if self.process_import_over_existing_name(
name, existing_symbol, node, i):
continue
self.add_symbol(name, SymbolTableNode(node.kind, node.node,
self.cur_mod_id,
node.type_override), i)
else:
# Don't add any dummy symbols for 'from x import *' if 'x' is unknown.
pass
def add_unknown_symbol(self, name: str, context: Context, is_import: bool = False) -> None:
var = Var(name)
if self.type:
var._fullname = self.type.fullname() + "." + name
else:
var._fullname = self.qualified_name(name)
var.is_ready = True
var.type = AnyType()
var.is_suppressed_import = is_import
self.add_symbol(name, SymbolTableNode(GDEF, var, self.cur_mod_id), context)
#
# Statements
#
def visit_block(self, b: Block) -> None:
if b.is_unreachable:
return
self.block_depth[-1] += 1
for s in b.body:
self.accept(s)
self.block_depth[-1] -= 1
def visit_block_maybe(self, b: Block) -> None:
if b:
self.visit_block(b)
def anal_type(self, t: Type, allow_tuple_literal: bool = False,
aliasing: bool = False) -> Type:
if t:
if allow_tuple_literal:
# Types such as (t1, t2, ...) only allowed in assignment statements. They'll
# generate errors elsewhere, and Tuple[t1, t2, ...] must be used instead.
if isinstance(t, TupleType):
# Unlike TypeAnalyser, also allow implicit tuple types (without Tuple[...]).
star_count = sum(1 for item in t.items if isinstance(item, StarType))
if star_count > 1:
self.fail('At most one star type allowed in a tuple', t)
return TupleType([AnyType() for _ in t.items],
self.builtin_type('builtins.tuple'), t.line)
items = [self.anal_type(item, True)
for item in t.items]
return TupleType(items, self.builtin_type('builtins.tuple'), t.line)
a = TypeAnalyser(self.lookup_qualified,
self.lookup_fully_qualified,
self.fail,
aliasing=aliasing)
return t.accept(a)
else:
return None
def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
for lval in s.lvalues:
self.analyze_lvalue(lval, explicit_type=s.type is not None)
s.rvalue.accept(self)
if s.type:
allow_tuple_literal = isinstance(s.lvalues[-1], (TupleExpr, ListExpr))
s.type = self.anal_type(s.type, allow_tuple_literal)
else:
# For simple assignments, allow binding type aliases.
# Also set the type if the rvalue is a simple literal.
if (s.type is None and len(s.lvalues) == 1 and
isinstance(s.lvalues[0], NameExpr)):
if s.lvalues[0].is_def:
s.type = self.analyze_simple_literal_type(s.rvalue)
res = analyze_type_alias(s.rvalue,
self.lookup_qualified,
self.lookup_fully_qualified,
self.fail)
if res and (not isinstance(res, Instance) or res.args):
# TODO: What if this gets reassigned?
name = s.lvalues[0]
node = self.lookup(name.name, name)
node.kind = TYPE_ALIAS
node.type_override = res
if isinstance(s.rvalue, IndexExpr):
s.rvalue.analyzed = TypeAliasExpr(res,
fallback=self.alias_fallback(res))
if s.type:
# Store type into nodes.
for lvalue in s.lvalues:
self.store_declared_types(lvalue, s.type)
self.check_and_set_up_type_alias(s)
self.process_newtype_declaration(s)
self.process_typevar_declaration(s)
self.process_namedtuple_definition(s)
self.process_typeddict_definition(s)
if (len(s.lvalues) == 1 and isinstance(s.lvalues[0], NameExpr) and
s.lvalues[0].name == '__all__' and s.lvalues[0].kind == GDEF and
isinstance(s.rvalue, (ListExpr, TupleExpr))):
self.add_exports(*s.rvalue.items)
def analyze_simple_literal_type(self, rvalue: Expression) -> Optional[Type]:
"""Return builtins.int if rvalue is an int literal, etc."""
if self.options.semantic_analysis_only or self.function_stack:
# Skip this if we're only doing the semantic analysis pass.
# This is mostly to avoid breaking unit tests.
# Also skip inside a function; this is to avoid confusing
# the code that handles dead code due to isinstance()
# inside type variables with value restrictions (like
# AnyStr).
return None
if isinstance(rvalue, IntExpr):
return self.named_type_or_none('builtins.int')
if isinstance(rvalue, FloatExpr):
return self.named_type_or_none('builtins.float')
if isinstance(rvalue, StrExpr):
return self.named_type_or_none('builtins.str')
if isinstance(rvalue, BytesExpr):
return self.named_type_or_none('builtins.bytes')
if isinstance(rvalue, UnicodeExpr):
return self.named_type_or_none('builtins.unicode')
return None
def alias_fallback(self, tp: Type) -> Instance:
"""Make a dummy Instance with no methods. It is used as a fallback type
to detect errors for non-Instance aliases (i.e. Unions, Tuples, Callables).
"""
kind = (' to Callable' if isinstance(tp, CallableType) else
' to Tuple' if isinstance(tp, TupleType) else
' to Union' if isinstance(tp, UnionType) else '')
cdef = ClassDef('Type alias' + kind, Block([]))
fb_info = TypeInfo(SymbolTable(), cdef, self.cur_mod_id)
fb_info.bases = [self.object_type()]
fb_info.mro = [fb_info, self.object_type().type]
return Instance(fb_info, [])
def check_and_set_up_type_alias(self, s: AssignmentStmt) -> None:
"""Check if assignment creates a type alias and set it up as needed."""
# For now, type aliases only work at the top level of a module.
if (len(s.lvalues) == 1 and not self.is_func_scope() and not self.type
and not s.type):
lvalue = s.lvalues[0]
if isinstance(lvalue, NameExpr):
if not lvalue.is_def:
# Only a definition can create a type alias, not regular assignment.
return
rvalue = s.rvalue
if isinstance(rvalue, RefExpr):
node = rvalue.node
if isinstance(node, TypeInfo):
# TODO: We should record the fact that this is a variable
# that refers to a type, rather than making this
# just an alias for the type.
self.globals[lvalue.name].node = node
def analyze_lvalue(self, lval: Lvalue, nested: bool = False,
add_global: bool = False,
explicit_type: bool = False) -> None:
"""Analyze an lvalue or assignment target.
Only if add_global is True, add name to globals table. If nested
is true, the lvalue is within a tuple or list lvalue expression.
"""
if isinstance(lval, NameExpr):
# Top-level definitions within some statements (at least while) are
# not handled in the first pass, so they have to be added now.
nested_global = (not self.is_func_scope() and
self.block_depth[-1] > 0 and
not self.type)
if (add_global or nested_global) and lval.name not in self.globals:
# Define new global name.
v = Var(lval.name)
v.set_line(lval)
v._fullname = self.qualified_name(lval.name)
v.is_ready = False # Type not inferred yet
lval.node = v
lval.is_def = True
lval.kind = GDEF
lval.fullname = v._fullname
self.globals[lval.name] = SymbolTableNode(GDEF, v,
self.cur_mod_id)
elif isinstance(lval.node, Var) and lval.is_def:
# Since the is_def flag is set, this must have been analyzed
# already in the first pass and added to the symbol table.
assert lval.node.name() in self.globals
elif (self.is_func_scope() and lval.name not in self.locals[-1] and
lval.name not in self.global_decls[-1] and
lval.name not in self.nonlocal_decls[-1]):
# Define new local name.
v = Var(lval.name)
v.set_line(lval)
lval.node = v
lval.is_def = True
lval.kind = LDEF
lval.fullname = lval.name
self.add_local(v, lval)
elif not self.is_func_scope() and (self.type and
lval.name not in self.type.names):
# Define a new attribute within class body.
v = Var(lval.name)
v.info = self.type
v.is_initialized_in_class = True
v.set_line(lval)
lval.node = v
lval.is_def = True
lval.kind = MDEF
lval.fullname = lval.name
self.type.names[lval.name] = SymbolTableNode(MDEF, v)
elif explicit_type:
# Don't re-bind types
self.name_already_defined(lval.name, lval)
else:
# Bind to an existing name.
lval.accept(self)
self.check_lvalue_validity(lval.node, lval)
elif isinstance(lval, MemberExpr):
if not add_global:
self.analyze_member_lvalue(lval)
if explicit_type and not self.is_self_member_ref(lval):
self.fail('Type cannot be declared in assignment to non-self '
'attribute', lval)
elif isinstance(lval, IndexExpr):
if explicit_type:
self.fail('Unexpected type declaration', lval)
if not add_global:
lval.accept(self)
elif (isinstance(lval, TupleExpr) or
isinstance(lval, ListExpr)):
items = lval.items
if len(items) == 0 and isinstance(lval, TupleExpr):
self.fail("Can't assign to ()", lval)
self.analyze_tuple_or_list_lvalue(lval, add_global, explicit_type)
elif isinstance(lval, StarExpr):
if nested:
self.analyze_lvalue(lval.expr, nested, add_global, explicit_type)
else:
self.fail('Starred assignment target must be in a list or tuple', lval)
else:
self.fail('Invalid assignment target', lval)
def analyze_tuple_or_list_lvalue(self, lval: Union[ListExpr, TupleExpr],
add_global: bool = False,
explicit_type: bool = False) -> None:
"""Analyze an lvalue or assignment target that is a list or tuple."""
items = lval.items
star_exprs = [item for item in items if isinstance(item, StarExpr)]
if len(star_exprs) > 1:
self.fail('Two starred expressions in assignment', lval)
else:
if len(star_exprs) == 1:
star_exprs[0].valid = True
for i in items:
self.analyze_lvalue(i, nested=True, add_global=add_global,
explicit_type = explicit_type)
def analyze_member_lvalue(self, lval: MemberExpr) -> None:
lval.accept(self)
if (self.is_self_member_ref(lval) and
self.type.get(lval.name) is None):
# Implicit attribute definition in __init__.
lval.is_def = True
v = Var(lval.name)
v.set_line(lval)
v.info = self.type
v.is_ready = False
lval.def_var = v
lval.node = v
self.type.names[lval.name] = SymbolTableNode(MDEF, v)
self.check_lvalue_validity(lval.node, lval)
def is_self_member_ref(self, memberexpr: MemberExpr) -> bool:
"""Does memberexpr to refer to an attribute of self?"""
if not isinstance(memberexpr.expr, NameExpr):
return False
node = memberexpr.expr.node
return isinstance(node, Var) and node.is_self
def check_lvalue_validity(self, node: Union[Expression, SymbolNode], ctx: Context) -> None:
if isinstance(node, (TypeInfo, TypeVarExpr)):
self.fail('Invalid assignment target', ctx)
def store_declared_types(self, lvalue: Lvalue, typ: Type) -> None:
if isinstance(typ, StarType) and not isinstance(lvalue, StarExpr):
self.fail('Star type only allowed for starred expressions', lvalue)
if isinstance(lvalue, RefExpr):
lvalue.is_def = False
if isinstance(lvalue.node, Var):
var = lvalue.node
var.type = typ
var.is_ready = True
# If node is not a variable, we'll catch it elsewhere.
elif isinstance(lvalue, TupleExpr):
if isinstance(typ, TupleType):
if len(lvalue.items) != len(typ.items):
self.fail('Incompatible number of tuple items', lvalue)
return
for item, itemtype in zip(lvalue.items, typ.items):
self.store_declared_types(item, itemtype)
else:
self.fail('Tuple type expected for multiple variables',
lvalue)
elif isinstance(lvalue, StarExpr):
if isinstance(typ, StarType):
self.store_declared_types(lvalue.expr, typ.type)
else:
self.fail('Star type expected for starred expression', lvalue)
else:
# This has been flagged elsewhere as an error, so just ignore here.
pass
def process_newtype_declaration(self, s: AssignmentStmt) -> None:
"""Check if s declares a NewType; if yes, store it in symbol table."""
# Extract and check all information from newtype declaration
name, call = self.analyze_newtype_declaration(s)
if name is None or call is None:
return
old_type = self.check_newtype_args(name, call, s)
call.analyzed = NewTypeExpr(name, old_type, line=call.line)
if old_type is None:
return
# Create the corresponding class definition if the aliased type is subtypeable
if isinstance(old_type, TupleType):
newtype_class_info = self.build_newtype_typeinfo(name, old_type, old_type.fallback)
newtype_class_info.tuple_type = old_type
elif isinstance(old_type, Instance):
newtype_class_info = self.build_newtype_typeinfo(name, old_type, old_type)
else:
message = "Argument 2 to NewType(...) must be subclassable (got {})"
self.fail(message.format(old_type), s)
return
# If so, add it to the symbol table.
node = self.lookup(name, s)
if node is None:
self.fail("Could not find {} in current namespace".format(name), s)
return
# TODO: why does NewType work in local scopes despite always being of kind GDEF?
node.kind = GDEF
call.analyzed.info = node.node = newtype_class_info
def analyze_newtype_declaration(self,
s: AssignmentStmt) -> Tuple[Optional[str], Optional[CallExpr]]:
"""Return the NewType call expression if `s` is a newtype declaration or None otherwise."""
name, call = None, None
if (len(s.lvalues) == 1
and isinstance(s.lvalues[0], NameExpr)
and isinstance(s.rvalue, CallExpr)
and isinstance(s.rvalue.callee, RefExpr)
and s.rvalue.callee.fullname == 'typing.NewType'):
lvalue = s.lvalues[0]
name = s.lvalues[0].name
if not lvalue.is_def:
if s.type:
self.fail("Cannot declare the type of a NewType declaration", s)
else:
self.fail("Cannot redefine '%s' as a NewType" % name, s)
# This dummy NewTypeExpr marks the call as sufficiently analyzed; it will be
# overwritten later with a fully complete NewTypeExpr if there are no other
# errors with the NewType() call.
call = s.rvalue
return name, call
def check_newtype_args(self, name: str, call: CallExpr, context: Context) -> Optional[Type]:
has_failed = False
args, arg_kinds = call.args, call.arg_kinds
if len(args) != 2 or arg_kinds[0] != ARG_POS or arg_kinds[1] != ARG_POS:
self.fail("NewType(...) expects exactly two positional arguments", context)
return None
# Check first argument
if not isinstance(args[0], (StrExpr, BytesExpr, UnicodeExpr)):
self.fail("Argument 1 to NewType(...) must be a string literal", context)
has_failed = True
elif args[0].value != name:
msg = "String argument 1 '{}' to NewType(...) does not match variable name '{}'"
self.fail(msg.format(args[0].value, name), context)
has_failed = True
# Check second argument
try:
unanalyzed_type = expr_to_unanalyzed_type(args[1])
except TypeTranslationError:
self.fail("Argument 2 to NewType(...) must be a valid type", context)
return None
old_type = self.anal_type(unanalyzed_type)
if isinstance(old_type, Instance) and old_type.type.is_newtype:
self.fail("Argument 2 to NewType(...) cannot be another NewType", context)
has_failed = True
return None if has_failed else old_type
def build_newtype_typeinfo(self, name: str, old_type: Type, base_type: Instance) -> TypeInfo:
info = self.basic_new_typeinfo(name, base_type)
info.is_newtype = True
# Add __init__ method
args = [Argument(Var('cls'), NoneTyp(), None, ARG_POS),
self.make_argument('item', old_type)]
signature = CallableType(
arg_types=[cast(Type, None), old_type],
arg_kinds=[arg.kind for arg in args],
arg_names=['self', 'item'],
ret_type=old_type,
fallback=self.named_type('__builtins__.function'),
name=name)
init_func = FuncDef('__init__', args, Block([]), typ=signature)
init_func.info = info
info.names['__init__'] = SymbolTableNode(MDEF, init_func)
return info
def process_typevar_declaration(self, s: AssignmentStmt) -> None:
"""Check if s declares a TypeVar; it yes, store it in symbol table."""
call = self.get_typevar_declaration(s)
if not call:
return
lvalue = s.lvalues[0]
assert isinstance(lvalue, NameExpr)
name = lvalue.name
if not lvalue.is_def:
if s.type:
self.fail("Cannot declare the type of a type variable", s)
else:
self.fail("Cannot redefine '%s' as a type variable" % name, s)
return
if not self.check_typevar_name(call, name, s):
return
# Constraining types
n_values = call.arg_kinds[1:].count(ARG_POS)
values = self.analyze_types(call.args[1:1 + n_values])
res = self.process_typevar_parameters(call.args[1 + n_values:],
call.arg_names[1 + n_values:],
call.arg_kinds[1 + n_values:],
bool(values),
s)
if res is None:
return
variance, upper_bound = res
# Yes, it's a valid type variable definition! Add it to the symbol table.
node = self.lookup(name, s)
node.kind = UNBOUND_TVAR
TypeVar = TypeVarExpr(name, node.fullname, values, upper_bound, variance)
TypeVar.line = call.line
call.analyzed = TypeVar
node.node = TypeVar
def check_typevar_name(self, call: CallExpr, name: str, context: Context) -> bool:
if len(call.args) < 1:
self.fail("Too few arguments for TypeVar()", context)
return False
if (not isinstance(call.args[0], (StrExpr, BytesExpr, UnicodeExpr))
or not call.arg_kinds[0] == ARG_POS):
self.fail("TypeVar() expects a string literal as first argument", context)
return False
elif call.args[0].value != name:
msg = "String argument 1 '{}' to TypeVar(...) does not match variable name '{}'"
self.fail(msg.format(call.args[0].value, name), context)
return False
return True
def get_typevar_declaration(self, s: AssignmentStmt) -> Optional[CallExpr]:
"""Returns the TypeVar() call expression if `s` is a type var declaration
or None otherwise.
"""
if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
return None
if not isinstance(s.rvalue, CallExpr):
return None
call = s.rvalue
callee = call.callee
if not isinstance(callee, RefExpr):
return None
if callee.fullname != 'typing.TypeVar':
return None
return call
def process_typevar_parameters(self, args: List[Expression],
names: List[Optional[str]],
kinds: List[int],
has_values: bool,
context: Context) -> Optional[Tuple[int, Type]]:
covariant = False
contravariant = False
upper_bound = self.object_type() # type: Type
for param_value, param_name, param_kind in zip(args, names, kinds):
if not param_kind == ARG_NAMED:
self.fail("Unexpected argument to TypeVar()", context)
return None
if param_name == 'covariant':
if isinstance(param_value, NameExpr):
if param_value.name == 'True':
covariant = True
else:
self.fail("TypeVar 'covariant' may only be 'True'", context)
return None
else:
self.fail("TypeVar 'covariant' may only be 'True'", context)
return None
elif param_name == 'contravariant':
if isinstance(param_value, NameExpr):
if param_value.name == 'True':
contravariant = True
else:
self.fail("TypeVar 'contravariant' may only be 'True'", context)
return None
else:
self.fail("TypeVar 'contravariant' may only be 'True'", context)
return None
elif param_name == 'bound':
if has_values:
self.fail("TypeVar cannot have both values and an upper bound", context)
return None
try:
upper_bound = self.expr_to_analyzed_type(param_value)
except TypeTranslationError:
self.fail("TypeVar 'bound' must be a type", param_value)
return None
elif param_name == 'values':
# Probably using obsolete syntax with values=(...). Explain the current syntax.
self.fail("TypeVar 'values' argument not supported", context)
self.fail("Use TypeVar('T', t, ...) instead of TypeVar('T', values=(t, ...))",
context)
return None
else:
self.fail("Unexpected argument to TypeVar(): {}".format(param_name), context)
return None
if covariant and contravariant:
self.fail("TypeVar cannot be both covariant and contravariant", context)
return None
elif covariant:
variance = COVARIANT
elif contravariant:
variance = CONTRAVARIANT
else:
variance = INVARIANT
return (variance, upper_bound)
def process_namedtuple_definition(self, s: AssignmentStmt) -> None:
"""Check if s defines a namedtuple; if yes, store the definition in symbol table."""
if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
return
lvalue = s.lvalues[0]
name = lvalue.name
named_tuple = self.check_namedtuple(s.rvalue, name)
if named_tuple is None:
return
# Yes, it's a valid namedtuple definition. Add it to the symbol table.
node = self.lookup(name, s)
node.kind = GDEF # TODO locally defined namedtuple
node.node = named_tuple
def check_namedtuple(self, node: Expression, var_name: str = None) -> Optional[TypeInfo]:
"""Check if a call defines a namedtuple.
The optional var_name argument is the name of the variable to
which this is assigned, if any.
If it does, return the corresponding TypeInfo. Return None otherwise.
If the definition is invalid but looks like a namedtuple,
report errors but return (some) TypeInfo.
"""
if not isinstance(node, CallExpr):
return None
call = node
callee = call.callee
if not isinstance(callee, RefExpr):
return None
fullname = callee.fullname
if fullname not in ('collections.namedtuple', 'typing.NamedTuple'):
return None
items, types, ok = self.parse_namedtuple_args(call, fullname)
if not ok:
# Error. Construct dummy return value.
return self.build_namedtuple_typeinfo('namedtuple', [], [])
name = cast(StrExpr, call.args[0]).value
if name != var_name or self.is_func_scope():
# Give it a unique name derived from the line number.
name += '@' + str(call.line)
info = self.build_namedtuple_typeinfo(name, items, types)
# Store it as a global just in case it would remain anonymous.
# (Or in the nearest class if there is one.)
stnode = SymbolTableNode(GDEF, info, self.cur_mod_id)
if self.type:
self.type.names[name] = stnode
else:
self.globals[name] = stnode
call.analyzed = NamedTupleExpr(info)
call.analyzed.set_line(call.line, call.column)
return info
def parse_namedtuple_args(self, call: CallExpr,
fullname: str) -> Tuple[List[str], List[Type], bool]:
# TODO: Share code with check_argument_count in checkexpr.py?
args = call.args
if len(args) < 2:
return self.fail_namedtuple_arg("Too few arguments for namedtuple()", call)
if len(args) > 2:
# FIX incorrect. There are two additional parameters
return self.fail_namedtuple_arg("Too many arguments for namedtuple()", call)
if call.arg_kinds != [ARG_POS, ARG_POS]:
return self.fail_namedtuple_arg("Unexpected arguments to namedtuple()", call)
if not isinstance(args[0], (StrExpr, BytesExpr, UnicodeExpr)):
return self.fail_namedtuple_arg(
"namedtuple() expects a string literal as the first argument", call)
types = [] # type: List[Type]
ok = True
if not isinstance(args[1], (ListExpr, TupleExpr)):
if (fullname == 'collections.namedtuple'
and isinstance(args[1], (StrExpr, BytesExpr, UnicodeExpr))):
str_expr = cast(StrExpr, args[1])
items = str_expr.value.replace(',', ' ').split()
else:
return self.fail_namedtuple_arg(
"List or tuple literal expected as the second argument to namedtuple()", call)
else:
listexpr = args[1]
if fullname == 'collections.namedtuple':
# The fields argument contains just names, with implicit Any types.
if any(not isinstance(item, (StrExpr, BytesExpr, UnicodeExpr))
for item in listexpr.items):
return self.fail_namedtuple_arg("String literal expected as namedtuple() item",
call)
items = [cast(StrExpr, item).value for item in listexpr.items]
else:
# The fields argument contains (name, type) tuples.
items, types, ok = self.parse_namedtuple_fields_with_types(listexpr.items, call)
if not types:
types = [AnyType() for _ in items]
underscore = [item for item in items if item.startswith('_')]
if underscore:
self.fail("namedtuple() field names cannot start with an underscore: "
+ ', '.join(underscore), call)
return items, types, ok
def parse_namedtuple_fields_with_types(self, nodes: List[Expression],
context: Context) -> Tuple[List[str], List[Type], bool]:
items = [] # type: List[str]
types = [] # type: List[Type]
for item in nodes:
if isinstance(item, TupleExpr):
if len(item.items) != 2:
return self.fail_namedtuple_arg("Invalid NamedTuple field definition",
item)
name, type_node = item.items
if isinstance(name, (StrExpr, BytesExpr, UnicodeExpr)):
items.append(name.value)
else:
return self.fail_namedtuple_arg("Invalid NamedTuple() field name", item)
try:
type = expr_to_unanalyzed_type(type_node)
except TypeTranslationError:
return self.fail_namedtuple_arg('Invalid field type', type_node)
types.append(self.anal_type(type))
else:
return self.fail_namedtuple_arg("Tuple expected as NamedTuple() field", item)
return items, types, True
def fail_namedtuple_arg(self, message: str,
context: Context) -> Tuple[List[str], List[Type], bool]:
self.fail(message, context)
return [], [], False
def basic_new_typeinfo(self, name: str, basetype_or_fallback: Instance) -> TypeInfo:
class_def = ClassDef(name, Block([]))
class_def.fullname = self.qualified_name(name)
info = TypeInfo(SymbolTable(), class_def, self.cur_mod_id)
info.mro = [info] + basetype_or_fallback.type.mro
info.bases = [basetype_or_fallback]
return info
def build_namedtuple_typeinfo(self, name: str, items: List[str],
types: List[Type]) -> TypeInfo:
strtype = self.str_type()
basetuple_type = self.named_type('__builtins__.tuple', [AnyType()])
dictype = (self.named_type_or_none('builtins.dict', [strtype, AnyType()])
or self.object_type())
# Actual signature should return OrderedDict[str, Union[types]]
ordereddictype = (self.named_type_or_none('builtins.dict', [strtype, AnyType()])
or self.object_type())
fallback = self.named_type('__builtins__.tuple', types)
# Note: actual signature should accept an invariant version of Iterable[UnionType[types]].
# but it can't be expressed. 'new' and 'len' should be callable types.
iterable_type = self.named_type_or_none('typing.Iterable', [AnyType()])
function_type = self.named_type('__builtins__.function')
info = self.basic_new_typeinfo(name, fallback)
info.is_named_tuple = True
info.tuple_type = TupleType(types, fallback)
def add_field(var: Var, is_initialized_in_class: bool = False,
is_property: bool = False) -> None:
var.info = info
var.is_initialized_in_class = is_initialized_in_class
var.is_property = is_property
info.names[var.name()] = SymbolTableNode(MDEF, var)
vars = [Var(item, typ) for item, typ in zip(items, types)]
for var in vars:
add_field(var, is_property=True)
tuple_of_strings = TupleType([strtype for _ in items], basetuple_type)
add_field(Var('_fields', tuple_of_strings), is_initialized_in_class=True)
add_field(Var('_field_types', dictype), is_initialized_in_class=True)
add_field(Var('_source', strtype), is_initialized_in_class=True)
tvd = TypeVarDef('NT', 1, [], info.tuple_type)
selftype = TypeVarType(tvd)
def add_method(funcname: str,
ret: Type,
args: List[Argument],
name: str = None,
is_classmethod: bool = False,
) -> None:
if is_classmethod:
first = [Argument(Var('cls'), TypeType(selftype), None, ARG_POS)]
else:
first = [Argument(Var('self'), selftype, None, ARG_POS)]
args = first + args
types = [arg.type_annotation for arg in args]
items = [arg.variable.name() for arg in args]
arg_kinds = [arg.kind for arg in args]
signature = CallableType(types, arg_kinds, items, ret, function_type,
name=name or info.name() + '.' + funcname)
signature.variables = [tvd]
func = FuncDef(funcname, args, Block([]), typ=signature)
func.info = info
func.is_class = is_classmethod
if is_classmethod:
v = Var(funcname, signature)
v.is_classmethod = True
v.info = info
dec = Decorator(func, [NameExpr('classmethod')], v)
info.names[funcname] = SymbolTableNode(MDEF, dec)
else:
info.names[funcname] = SymbolTableNode(MDEF, func)
add_method('_replace', ret=selftype,
args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED_OPT) for var in vars])
add_method('__init__', ret=NoneTyp(), name=info.name(),
args=[Argument(var, var.type, None, ARG_POS) for var in vars])
add_method('_asdict', args=[], ret=ordereddictype)
add_method('_make', ret=selftype, is_classmethod=True,
args=[Argument(Var('iterable', iterable_type), iterable_type, None, ARG_POS),
Argument(Var('new'), AnyType(), EllipsisExpr(), ARG_NAMED_OPT),
Argument(Var('len'), AnyType(), EllipsisExpr(), ARG_NAMED_OPT)])
return info
def make_argument(self, name: str, type: Type) -> Argument:
return Argument(Var(name), type, None, ARG_POS)
def analyze_types(self, items: List[Expression]) -> List[Type]:
result = [] # type: List[Type]
for node in items:
try:
result.append(self.anal_type(expr_to_unanalyzed_type(node)))
except TypeTranslationError:
self.fail('Type expected', node)
result.append(AnyType())
return result
def process_typeddict_definition(self, s: AssignmentStmt) -> None:
"""Check if s defines a TypedDict; if yes, store the definition in symbol table."""
if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
return
lvalue = s.lvalues[0]
name = lvalue.name
typed_dict = self.check_typeddict(s.rvalue, name)
if typed_dict is None:
return
# Yes, it's a valid TypedDict definition. Add it to the symbol table.
node = self.lookup(name, s)
if node:
node.kind = GDEF # TODO locally defined TypedDict
node.node = typed_dict
def check_typeddict(self, node: Expression, var_name: str = None) -> Optional[TypeInfo]:
"""Check if a call defines a TypedDict.
The optional var_name argument is the name of the variable to
which this is assigned, if any.
If it does, return the corresponding TypeInfo. Return None otherwise.
If the definition is invalid but looks like a TypedDict,
report errors but return (some) TypeInfo.
"""
if not isinstance(node, CallExpr):
return None
call = node
callee = call.callee
if not isinstance(callee, RefExpr):
return None
fullname = callee.fullname
if fullname != 'mypy_extensions.TypedDict':
return None
items, types, ok = self.parse_typeddict_args(call, fullname)
if not ok:
# Error. Construct dummy return value.
return self.build_typeddict_typeinfo('TypedDict', [], [])
name = cast(StrExpr, call.args[0]).value
if name != var_name or self.is_func_scope():
# Give it a unique name derived from the line number.
name += '@' + str(call.line)
info = self.build_typeddict_typeinfo(name, items, types)
# Store it as a global just in case it would remain anonymous.
# (Or in the nearest class if there is one.)
stnode = SymbolTableNode(GDEF, info, self.cur_mod_id)
if self.type:
self.type.names[name] = stnode
else:
self.globals[name] = stnode
call.analyzed = TypedDictExpr(info)
call.analyzed.set_line(call.line, call.column)
return info
def parse_typeddict_args(self, call: CallExpr,
fullname: str) -> Tuple[List[str], List[Type], bool]:
# TODO: Share code with check_argument_count in checkexpr.py?
args = call.args
if len(args) < 2:
return self.fail_typeddict_arg("Too few arguments for TypedDict()", call)
if len(args) > 2:
return self.fail_typeddict_arg("Too many arguments for TypedDict()", call)
# TODO: Support keyword arguments
if call.arg_kinds != [ARG_POS, ARG_POS]:
return self.fail_typeddict_arg("Unexpected arguments to TypedDict()", call)
if not isinstance(args[0], (StrExpr, BytesExpr, UnicodeExpr)):
return self.fail_typeddict_arg(
"TypedDict() expects a string literal as the first argument", call)
if not isinstance(args[1], DictExpr):
return self.fail_typeddict_arg(
"TypedDict() expects a dictionary literal as the second argument", call)
dictexpr = args[1]
items, types, ok = self.parse_typeddict_fields_with_types(dictexpr.items, call)
underscore = [item for item in items if item.startswith('_')]
if underscore:
self.fail("TypedDict() item names cannot start with an underscore: "
+ ', '.join(underscore), call)
return items, types, ok
def parse_typeddict_fields_with_types(self, dict_items: List[Tuple[Expression, Expression]],
context: Context) -> Tuple[List[str], List[Type], bool]:
items = [] # type: List[str]
types = [] # type: List[Type]
for (field_name_expr, field_type_expr) in dict_items:
if isinstance(field_name_expr, (StrExpr, BytesExpr, UnicodeExpr)):
items.append(field_name_expr.value)
else:
return self.fail_typeddict_arg("Invalid TypedDict() field name", field_name_expr)
try:
type = expr_to_unanalyzed_type(field_type_expr)
except TypeTranslationError:
return self.fail_typeddict_arg('Invalid field type', field_type_expr)
types.append(self.anal_type(type))
return items, types, True
def fail_typeddict_arg(self, message: str,
context: Context) -> Tuple[List[str], List[Type], bool]:
self.fail(message, context)
return [], [], False
def build_typeddict_typeinfo(self, name: str, items: List[str],
types: List[Type]) -> TypeInfo:
mapping_value_type = join.join_type_list(types)
fallback = (self.named_type_or_none('typing.Mapping',
[self.str_type(), mapping_value_type])
or self.object_type())
info = self.basic_new_typeinfo(name, fallback)
info.typeddict_type = TypedDictType(OrderedDict(zip(items, types)), fallback)
return info
def visit_decorator(self, dec: Decorator) -> None:
for d in dec.decorators:
d.accept(self)
removed = [] # type: List[int]
no_type_check = False
for i, d in enumerate(dec.decorators):
# A bunch of decorators are special cased here.
if refers_to_fullname(d, 'abc.abstractmethod'):
removed.append(i)
dec.func.is_abstract = True
self.check_decorated_function_is_method('abstractmethod', dec)
elif (refers_to_fullname(d, 'asyncio.coroutines.coroutine') or
refers_to_fullname(d, 'types.coroutine')):
removed.append(i)
dec.func.is_awaitable_coroutine = True
elif refers_to_fullname(d, 'builtins.staticmethod'):
removed.append(i)
dec.func.is_static = True
dec.var.is_staticmethod = True
self.check_decorated_function_is_method('staticmethod', dec)
elif refers_to_fullname(d, 'builtins.classmethod'):
removed.append(i)
dec.func.is_class = True
dec.var.is_classmethod = True
self.check_decorated_function_is_method('classmethod', dec)
elif (refers_to_fullname(d, 'builtins.property') or
refers_to_fullname(d, 'abc.abstractproperty')):
removed.append(i)
dec.func.is_property = True
dec.var.is_property = True
if refers_to_fullname(d, 'abc.abstractproperty'):
dec.func.is_abstract = True
self.check_decorated_function_is_method('property', dec)
if len(dec.func.arguments) > 1:
self.fail('Too many arguments', dec.func)
elif refers_to_fullname(d, 'typing.no_type_check'):
dec.var.type = AnyType()
no_type_check = True
for i in reversed(removed):
del dec.decorators[i]
if not dec.is_overload or dec.var.is_property:
if self.is_func_scope():
self.add_symbol(dec.var.name(), SymbolTableNode(LDEF, dec),
dec)
elif self.type:
dec.var.info = self.type
dec.var.is_initialized_in_class = True
self.add_symbol(dec.var.name(), SymbolTableNode(MDEF, dec),
dec)
if not no_type_check:
dec.func.accept(self)
if dec.decorators and dec.var.is_property:
self.fail('Decorated property not supported', dec)
def check_decorated_function_is_method(self, decorator: str,
context: Context) -> None:
if not self.type or self.is_func_scope():
self.fail("'%s' used with a non-method" % decorator, context)
def visit_expression_stmt(self, s: ExpressionStmt) -> None:
s.expr.accept(self)
def visit_return_stmt(self, s: ReturnStmt) -> None:
if not self.is_func_scope():
self.fail("'return' outside function", s)
if s.expr:
s.expr.accept(self)
def visit_raise_stmt(self, s: RaiseStmt) -> None:
if s.expr:
s.expr.accept(self)
if s.from_expr:
s.from_expr.accept(self)
def visit_assert_stmt(self, s: AssertStmt) -> None:
if s.expr:
s.expr.accept(self)
def visit_operator_assignment_stmt(self,
s: OperatorAssignmentStmt) -> None:
s.lvalue.accept(self)
s.rvalue.accept(self)
if (isinstance(s.lvalue, NameExpr) and s.lvalue.name == '__all__' and
s.lvalue.kind == GDEF and isinstance(s.rvalue, (ListExpr, TupleExpr))):
self.add_exports(*s.rvalue.items)
def visit_while_stmt(self, s: WhileStmt) -> None:
s.expr.accept(self)
self.loop_depth += 1
s.body.accept(self)
self.loop_depth -= 1
self.visit_block_maybe(s.else_body)
def visit_for_stmt(self, s: ForStmt) -> None:
s.expr.accept(self)
# Bind index variables and check if they define new names.
self.analyze_lvalue(s.index)
self.loop_depth += 1
self.visit_block(s.body)
self.loop_depth -= 1
self.visit_block_maybe(s.else_body)
def visit_break_stmt(self, s: BreakStmt) -> None:
if self.loop_depth == 0:
self.fail("'break' outside loop", s, True, blocker=True)
def visit_continue_stmt(self, s: ContinueStmt) -> None:
if self.loop_depth == 0:
self.fail("'continue' outside loop", s, True, blocker=True)
def visit_if_stmt(self, s: IfStmt) -> None:
infer_reachability_of_if_statement(s,
pyversion=self.options.python_version,
platform=self.options.platform)
for i in range(len(s.expr)):
s.expr[i].accept(self)
self.visit_block(s.body[i])
self.visit_block_maybe(s.else_body)
def visit_try_stmt(self, s: TryStmt) -> None:
self.analyze_try_stmt(s, self)
def analyze_try_stmt(self, s: TryStmt, visitor: NodeVisitor,
add_global: bool = False) -> None:
s.body.accept(visitor)
for type, var, handler in zip(s.types, s.vars, s.handlers):
if type:
type.accept(visitor)
if var:
self.analyze_lvalue(var, add_global=add_global)
handler.accept(visitor)
if s.else_body:
s.else_body.accept(visitor)
if s.finally_body:
s.finally_body.accept(visitor)
def visit_with_stmt(self, s: WithStmt) -> None:
for e, n in zip(s.expr, s.target):
e.accept(self)
if n:
self.analyze_lvalue(n)
self.visit_block(s.body)
def visit_del_stmt(self, s: DelStmt) -> None:
s.expr.accept(self)
if not self.is_valid_del_target(s.expr):
self.fail('Invalid delete target', s)
def is_valid_del_target(self, s: Expression) -> bool:
if isinstance(s, (IndexExpr, NameExpr, MemberExpr)):
return True
elif isinstance(s, TupleExpr):
return all(self.is_valid_del_target(item) for item in s.items)
else:
return False
def visit_global_decl(self, g: GlobalDecl) -> None:
for name in g.names:
if name in self.nonlocal_decls[-1]:
self.fail("Name '{}' is nonlocal and global".format(name), g)
self.global_decls[-1].add(name)
def visit_nonlocal_decl(self, d: NonlocalDecl) -> None:
if not self.is_func_scope():
self.fail("nonlocal declaration not allowed at module level", d)
else:
for name in d.names:
for table in reversed(self.locals[:-1]):
if table is not None and name in table:
break
else:
self.fail("No binding for nonlocal '{}' found".format(name), d)
if self.locals[-1] is not None and name in self.locals[-1]:
self.fail("Name '{}' is already defined in local "
"scope before nonlocal declaration".format(name), d)
if name in self.global_decls[-1]:
self.fail("Name '{}' is nonlocal and global".format(name), d)
self.nonlocal_decls[-1].add(name)
def visit_print_stmt(self, s: PrintStmt) -> None:
for arg in s.args:
arg.accept(self)
if s.target:
s.target.accept(self)
def visit_exec_stmt(self, s: ExecStmt) -> None:
s.expr.accept(self)
if s.variables1:
s.variables1.accept(self)
if s.variables2:
s.variables2.accept(self)
#
# Expressions
#
def visit_name_expr(self, expr: NameExpr) -> None:
n = self.lookup(expr.name, expr)
if n:
if n.kind == BOUND_TVAR:
self.fail("'{}' is a type variable and only valid in type "
"context".format(expr.name), expr)
else:
expr.kind = n.kind
expr.node = n.node
expr.fullname = n.fullname
def visit_super_expr(self, expr: SuperExpr) -> None:
if not self.type:
self.fail('"super" used outside class', expr)
return
expr.info = self.type
def visit_tuple_expr(self, expr: TupleExpr) -> None:
for item in expr.items:
if isinstance(item, StarExpr):
item.valid = True
item.accept(self)
def visit_list_expr(self, expr: ListExpr) -> None:
for item in expr.items:
if isinstance(item, StarExpr):
item.valid = True
item.accept(self)
def visit_set_expr(self, expr: SetExpr) -> None:
for item in expr.items:
if isinstance(item, StarExpr):
item.valid = True
item.accept(self)
def visit_dict_expr(self, expr: DictExpr) -> None:
for key, value in expr.items:
if key is not None:
key.accept(self)
value.accept(self)
def visit_star_expr(self, expr: StarExpr) -> None:
if not expr.valid:
# XXX TODO Change this error message
self.fail('Can use starred expression only as assignment target', expr)
else:
expr.expr.accept(self)
def visit_yield_from_expr(self, e: YieldFromExpr) -> None:
if not self.is_func_scope(): # not sure
self.fail("'yield from' outside function", e, True, blocker=True)
else:
if self.function_stack[-1].is_coroutine:
self.fail("'yield from' in async function", e, True, blocker=True)
else:
self.function_stack[-1].is_generator = True
if e.expr:
e.expr.accept(self)
def visit_call_expr(self, expr: CallExpr) -> None:
"""Analyze a call expression.
Some call expressions are recognized as special forms, including
cast(...) and Any(...).
"""
expr.callee.accept(self)
if refers_to_fullname(expr.callee, 'typing.cast'):
# Special form cast(...).
if not self.check_fixed_args(expr, 2, 'cast'):
return
# Translate first argument to an unanalyzed type.
try:
target = expr_to_unanalyzed_type(expr.args[0])
except TypeTranslationError:
self.fail('Cast target is not a type', expr)
return
# Piggyback CastExpr object to the CallExpr object; it takes
# precedence over the CallExpr semantics.
expr.analyzed = CastExpr(expr.args[1], target)
expr.analyzed.line = expr.line
expr.analyzed.accept(self)
elif refers_to_fullname(expr.callee, 'builtins.reveal_type'):
if not self.check_fixed_args(expr, 1, 'reveal_type'):
return
expr.analyzed = RevealTypeExpr(expr.args[0])
expr.analyzed.line = expr.line
expr.analyzed.column = expr.column
expr.analyzed.accept(self)
elif refers_to_fullname(expr.callee, 'typing.Any'):
# Special form Any(...).
if not self.check_fixed_args(expr, 1, 'Any'):
return
expr.analyzed = CastExpr(expr.args[0], AnyType())
expr.analyzed.line = expr.line
expr.analyzed.accept(self)
elif refers_to_fullname(expr.callee, 'typing._promote'):
# Special form _promote(...).
if not self.check_fixed_args(expr, 1, '_promote'):
return
# Translate first argument to an unanalyzed type.
try:
target = expr_to_unanalyzed_type(expr.args[0])
except TypeTranslationError:
self.fail('Argument 1 to _promote is not a type', expr)
return
expr.analyzed = PromoteExpr(target)
expr.analyzed.line = expr.line
expr.analyzed.accept(self)
elif refers_to_fullname(expr.callee, 'builtins.dict'):
expr.analyzed = self.translate_dict_call(expr)
else:
# Normal call expression.
for a in expr.args:
a.accept(self)
if (isinstance(expr.callee, MemberExpr) and
isinstance(expr.callee.expr, NameExpr) and
expr.callee.expr.name == '__all__' and
expr.callee.expr.kind == GDEF and
expr.callee.name in ('append', 'extend')):
if expr.callee.name == 'append' and expr.args:
self.add_exports(expr.args[0])
elif (expr.callee.name == 'extend' and expr.args and
isinstance(expr.args[0], (ListExpr, TupleExpr))):
self.add_exports(*expr.args[0].items)
def translate_dict_call(self, call: CallExpr) -> Optional[DictExpr]:
"""Translate 'dict(x=y, ...)' to {'x': y, ...}.
For other variants of dict(...), return None.
"""
if not call.args:
return None
if not all(kind == ARG_NAMED for kind in call.arg_kinds):
# Must still accept those args.
for a in call.args:
a.accept(self)
return None
expr = DictExpr([(StrExpr(key), value)
for key, value in zip(call.arg_names, call.args)])
expr.set_line(call)
expr.accept(self)
return expr
def check_fixed_args(self, expr: CallExpr, numargs: int,
name: str) -> bool:
"""Verify that expr has specified number of positional args.
Return True if the arguments are valid.
"""
s = 's'
if numargs == 1:
s = ''
if len(expr.args) != numargs:
self.fail("'%s' expects %d argument%s" % (name, numargs, s),
expr)
return False
if expr.arg_kinds != [ARG_POS] * numargs:
self.fail("'%s' must be called with %s positional argument%s" %
(name, numargs, s), expr)
return False
return True
def visit_member_expr(self, expr: MemberExpr) -> None:
base = expr.expr
base.accept(self)
# Bind references to module attributes.
if isinstance(base, RefExpr) and base.kind == MODULE_REF:
# This branch handles the case foo.bar where foo is a module.
# In this case base.node is the module's MypyFile and we look up
# bar in its namespace. This must be done for all types of bar.
file = base.node
assert isinstance(file, MypyFile)
n = file.names.get(expr.name, None) if file is not None else None
if n:
n = self.normalize_type_alias(n, expr)
if not n:
return
expr.kind = n.kind
expr.fullname = n.fullname
expr.node = n.node
else:
# We only catch some errors here; the rest will be
# catched during type checking.
#
# This way we can report a larger number of errors in
# one type checker run. If we reported errors here,
# the build would terminate after semantic analysis
# and we wouldn't be able to report any type errors.
full_name = '%s.%s' % (file.fullname() if file is not None else None, expr.name)
mod_name = " '%s'" % file.fullname() if file is not None else ''
if full_name in obsolete_name_mapping:
self.fail("Module%s has no attribute %r (it's now called %r)" % (
mod_name, expr.name, obsolete_name_mapping[full_name]), expr)
elif isinstance(base, RefExpr) and isinstance(base.node, TypeInfo):
# This branch handles the case C.bar where C is a class
# and bar is a module resulting from `import bar` inside
# class C. Here base.node is a TypeInfo, and again we
# look up the name in its namespace. This is done only
# when bar is a module; other things (e.g. methods)
# are handled by other code in checkmember.
n = base.node.names.get(expr.name)
if n is not None and n.kind == MODULE_REF:
n = self.normalize_type_alias(n, expr)
if not n:
return
expr.kind = n.kind
expr.fullname = n.fullname
expr.node = n.node
def visit_op_expr(self, expr: OpExpr) -> None:
expr.left.accept(self)
expr.right.accept(self)
def visit_comparison_expr(self, expr: ComparisonExpr) -> None:
for operand in expr.operands:
operand.accept(self)
def visit_unary_expr(self, expr: UnaryExpr) -> None:
expr.expr.accept(self)
def visit_index_expr(self, expr: IndexExpr) -> None:
expr.base.accept(self)
if isinstance(expr.base, RefExpr) and expr.base.kind == TYPE_ALIAS:
# Special form -- subscripting a generic type alias.
# Perform the type substitution and create a new alias.
res = analyze_type_alias(expr,
self.lookup_qualified,
self.lookup_fully_qualified,
self.fail)
expr.analyzed = TypeAliasExpr(res, fallback=self.alias_fallback(res),
in_runtime=True)
elif refers_to_class_or_function(expr.base):
# Special form -- type application.
# Translate index to an unanalyzed type.
types = [] # type: List[Type]
if isinstance(expr.index, TupleExpr):
items = expr.index.items
else:
items = [expr.index]
for item in items:
try:
typearg = expr_to_unanalyzed_type(item)
except TypeTranslationError:
self.fail('Type expected within [...]', expr)
return
typearg = self.anal_type(typearg, aliasing=True)
types.append(typearg)
expr.analyzed = TypeApplication(expr.base, types)
expr.analyzed.line = expr.line
else:
expr.index.accept(self)
def visit_slice_expr(self, expr: SliceExpr) -> None:
if expr.begin_index:
expr.begin_index.accept(self)
if expr.end_index:
expr.end_index.accept(self)
if expr.stride:
expr.stride.accept(self)
def visit_cast_expr(self, expr: CastExpr) -> None:
expr.expr.accept(self)
expr.type = self.anal_type(expr.type)
def visit_reveal_type_expr(self, expr: RevealTypeExpr) -> None:
expr.expr.accept(self)
def visit_type_application(self, expr: TypeApplication) -> None:
expr.expr.accept(self)
for i in range(len(expr.types)):
expr.types[i] = self.anal_type(expr.types[i])
def visit_list_comprehension(self, expr: ListComprehension) -> None:
expr.generator.accept(self)
def visit_set_comprehension(self, expr: SetComprehension) -> None:
expr.generator.accept(self)
def visit_dictionary_comprehension(self, expr: DictionaryComprehension) -> None:
self.enter()
self.analyze_comp_for(expr)
expr.key.accept(self)
expr.value.accept(self)
self.leave()
self.analyze_comp_for_2(expr)
def visit_generator_expr(self, expr: GeneratorExpr) -> None:
self.enter()
self.analyze_comp_for(expr)
expr.left_expr.accept(self)
self.leave()
self.analyze_comp_for_2(expr)
def analyze_comp_for(self, expr: Union[GeneratorExpr,
DictionaryComprehension]) -> None:
"""Analyses the 'comp_for' part of comprehensions (part 1).
That is the part after 'for' in (x for x in l if p). This analyzes
variables and conditions which are analyzed in a local scope.
"""
for i, (index, sequence, conditions) in enumerate(zip(expr.indices,
expr.sequences,
expr.condlists)):
if i > 0:
sequence.accept(self)
# Bind index variables.
self.analyze_lvalue(index)
for cond in conditions:
cond.accept(self)
def analyze_comp_for_2(self, expr: Union[GeneratorExpr,
DictionaryComprehension]) -> None:
"""Analyses the 'comp_for' part of comprehensions (part 2).
That is the part after 'for' in (x for x in l if p). This analyzes
the 'l' part which is analyzed in the surrounding scope.
"""
expr.sequences[0].accept(self)
def visit_func_expr(self, expr: FuncExpr) -> None:
self.analyze_function(expr)
def visit_conditional_expr(self, expr: ConditionalExpr) -> None:
expr.if_expr.accept(self)
expr.cond.accept(self)
expr.else_expr.accept(self)
def visit_backquote_expr(self, expr: BackquoteExpr) -> None:
expr.expr.accept(self)
def visit__promote_expr(self, expr: PromoteExpr) -> None:
expr.type = self.anal_type(expr.type)
def visit_yield_expr(self, expr: YieldExpr) -> None:
if not self.is_func_scope():
self.fail("'yield' outside function", expr, True, blocker=True)
else:
if self.function_stack[-1].is_coroutine:
self.fail("'yield' in async function", expr, True, blocker=True)
else:
self.function_stack[-1].is_generator = True
if expr.expr:
expr.expr.accept(self)
def visit_await_expr(self, expr: AwaitExpr) -> None:
if not self.is_func_scope():
self.fail("'await' outside function", expr)
elif not self.function_stack[-1].is_coroutine:
self.fail("'await' outside coroutine ('async def')", expr)
expr.expr.accept(self)
#
# Helpers
#
def lookup(self, name: str, ctx: Context) -> SymbolTableNode:
"""Look up an unqualified name in all active namespaces."""
# 1a. Name declared using 'global x' takes precedence
if name in self.global_decls[-1]:
if name in self.globals:
return self.globals[name]
else:
self.name_not_defined(name, ctx)
return None
# 1b. Name declared using 'nonlocal x' takes precedence
if name in self.nonlocal_decls[-1]:
for table in reversed(self.locals[:-1]):
if table is not None and name in table:
return table[name]
else:
self.name_not_defined(name, ctx)
return None
# 2. Class attributes (if within class definition)
if self.is_class_scope() and name in self.type.names:
return self.type.names[name]
# 3. Local (function) scopes
for table in reversed(self.locals):
if table is not None and name in table:
return table[name]
# 4. Current file global scope
if name in self.globals:
return self.globals[name]
# 5. Builtins
b = self.globals.get('__builtins__', None)
if b:
assert isinstance(b.node, MypyFile)
table = b.node.names
if name in table:
if name[0] == "_" and name[1] != "_":
self.name_not_defined(name, ctx)
return None
node = table[name]
return node
# Give up.
self.name_not_defined(name, ctx)
self.check_for_obsolete_short_name(name, ctx)
return None
def check_for_obsolete_short_name(self, name: str, ctx: Context) -> None:
matches = [obsolete_name
for obsolete_name in obsolete_name_mapping
if obsolete_name.rsplit('.', 1)[-1] == name]
if len(matches) == 1:
self.note("(Did you mean '{}'?)".format(obsolete_name_mapping[matches[0]]), ctx)
def lookup_qualified(self, name: str, ctx: Context) -> SymbolTableNode:
if '.' not in name:
return self.lookup(name, ctx)
else:
parts = name.split('.')
n = self.lookup(parts[0], ctx) # type: SymbolTableNode
if n:
for i in range(1, len(parts)):
if isinstance(n.node, TypeInfo):
if n.node.mro is None:
# We haven't yet analyzed the class `n.node`. Fall back to direct
# lookup in the names declared directly under it, without its base
# classes. This can happen when we have a forward reference to a
# nested class, and the reference is bound before the outer class
# has been fully semantically analyzed.
#
# A better approach would be to introduce a new analysis pass or
# to move things around between passes, but this unblocks a common
# use case even though this is a little limited in case there is
# inheritance involved.
result = n.node.names.get(parts[i])
else:
result = n.node.get(parts[i])
n = result
elif isinstance(n.node, MypyFile):
n = n.node.names.get(parts[i], None)
# TODO: What if node is Var or FuncDef?
if not n:
self.name_not_defined(name, ctx)
break
if n:
n = self.normalize_type_alias(n, ctx)
return n
def builtin_type(self, fully_qualified_name: str) -> Instance:
node = self.lookup_fully_qualified(fully_qualified_name)
assert isinstance(node.node, TypeInfo)
return Instance(node.node, [])
def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
"""Lookup a fully qualified name.
Assume that the name is defined. This happens in the global namespace -- the local
module namespace is ignored.
"""
assert '.' in name
parts = name.split('.')
n = self.modules[parts[0]]
for i in range(1, len(parts) - 1):
next_sym = n.names[parts[i]]
assert isinstance(next_sym.node, MypyFile)
n = next_sym.node
return n.names.get(parts[-1])
def lookup_fully_qualified_or_none(self, name: str) -> Optional[SymbolTableNode]:
"""Lookup a fully qualified name.
Assume that the name is defined. This happens in the global namespace -- the local
module namespace is ignored.
"""
assert '.' in name
parts = name.split('.')
n = self.modules[parts[0]]
for i in range(1, len(parts) - 1):
next_sym = n.names.get(parts[i])
if not next_sym:
return None
assert isinstance(next_sym.node, MypyFile)
n = next_sym.node
return n.names.get(parts[-1])
def qualified_name(self, n: str) -> str:
if self.type is not None:
base = self.type._fullname
else:
base = self.cur_mod_id
return base + '.' + n
def enter(self) -> None:
self.locals.append(SymbolTable())
self.global_decls.append(set())
self.nonlocal_decls.append(set())
# -1 since entering block will increment this to 0.
self.block_depth.append(-1)
def leave(self) -> None:
self.locals.pop()
self.global_decls.pop()
self.nonlocal_decls.pop()
self.block_depth.pop()
def is_func_scope(self) -> bool:
return self.locals[-1] is not None
def is_class_scope(self) -> bool:
return self.type is not None and not self.is_func_scope()
def is_module_scope(self) -> bool:
return not (self.is_class_scope() or self.is_func_scope())
def add_symbol(self, name: str, node: SymbolTableNode,
context: Context) -> None:
if self.is_func_scope():
if name in self.locals[-1]:
# Flag redefinition unless this is a reimport of a module.
if not (node.kind == MODULE_REF and
self.locals[-1][name].node == node.node):
self.name_already_defined(name, context)
self.locals[-1][name] = node
elif self.type:
self.type.names[name] = node
else:
existing = self.globals.get(name)
if existing and (not isinstance(node.node, MypyFile) or
existing.node != node.node) and existing.kind != UNBOUND_IMPORTED:
# Modules can be imported multiple times to support import
# of multiple submodules of a package (e.g. a.x and a.y).
ok = False
# Only report an error if the symbol collision provides a different type.
if existing.type and node.type and is_same_type(existing.type, node.type):
ok = True
if not ok:
self.name_already_defined(name, context)
self.globals[name] = node
def add_local(self, node: Union[Var, FuncDef, OverloadedFuncDef], ctx: Context) -> None:
name = node.name()
if name in self.locals[-1]:
self.name_already_defined(name, ctx)
node._fullname = name
self.locals[-1][name] = SymbolTableNode(LDEF, node)
def add_exports(self, *exps: Expression) -> None:
for exp in exps:
if isinstance(exp, StrExpr):
self.all_exports.add(exp.value)
def check_no_global(self, n: str, ctx: Context,
is_overloaded_func: bool = False) -> None:
if n in self.globals:
prev_is_overloaded = isinstance(self.globals[n], OverloadedFuncDef)
if is_overloaded_func and prev_is_overloaded:
self.fail("Nonconsecutive overload {} found".format(n), ctx)
elif prev_is_overloaded:
self.fail("Definition of '{}' missing 'overload'".format(n), ctx)
else:
self.name_already_defined(n, ctx)
def name_not_defined(self, name: str, ctx: Context) -> None:
message = "Name '{}' is not defined".format(name)
extra = self.undefined_name_extra_info(name)
if extra:
message += ' {}'.format(extra)
self.fail(message, ctx)
def name_already_defined(self, name: str, ctx: Context) -> None:
self.fail("Name '{}' already defined".format(name), ctx)
def fail(self, msg: str, ctx: Context, serious: bool = False, *,
blocker: bool = False) -> None:
if (not serious and
not self.options.check_untyped_defs and
self.function_stack and
self.function_stack[-1].is_dynamic()):
return
# In case it's a bug and we don't really have context
assert ctx is not None, msg
self.errors.report(ctx.get_line(), ctx.get_column(), msg, blocker=blocker)
def fail_blocker(self, msg: str, ctx: Context) -> None:
self.fail(msg, ctx, blocker=True)
def note(self, msg: str, ctx: Context) -> None:
if (not self.options.check_untyped_defs and
self.function_stack and
self.function_stack[-1].is_dynamic()):
return
self.errors.report(ctx.get_line(), ctx.get_column(), msg, severity='note')
def undefined_name_extra_info(self, fullname: str) -> Optional[str]:
if fullname in obsolete_name_mapping:
return "(it's now called '{}')".format(obsolete_name_mapping[fullname])
else:
return None
def accept(self, node: Node) -> None:
try:
node.accept(self)
except Exception as err:
report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
class FirstPass(NodeVisitor):
"""First phase of semantic analysis.
See docstring of 'analyze()' below for a description of what this does.
"""
def __init__(self, sem: SemanticAnalyzer) -> None:
self.sem = sem
def visit_file(self, file: MypyFile, fnam: str, mod_id: str, options: Options) -> None:
"""Perform the first analysis pass.
Populate module global table. Resolve the full names of
definitions not nested within functions and construct type
info structures, but do not resolve inter-definition
references such as base classes.
Also add implicit definitions such as __name__.
In this phase we don't resolve imports. For 'from ... import',
we generate dummy symbol table nodes for the imported names,
and these will get resolved in later phases of semantic
analysis.
"""
sem = self.sem
self.sem.options = options # Needed because we sometimes call into it
self.pyversion = options.python_version
self.platform = options.platform
sem.cur_mod_id = mod_id
sem.errors.set_file(fnam)
sem.globals = SymbolTable()
sem.global_decls = [set()]
sem.nonlocal_decls = [set()]
sem.block_depth = [0]
defs = file.defs
# Add implicit definitions of module '__name__' etc.
for name, t in implicit_module_attrs.items():
v = Var(name, UnboundType(t))
v._fullname = self.sem.qualified_name(name)
self.sem.globals[name] = SymbolTableNode(GDEF, v, self.sem.cur_mod_id)
for d in defs:
d.accept(self)
# Add implicit definition of literals/keywords to builtins, as we
# cannot define a variable with them explicitly.
if mod_id == 'builtins':
literal_types = [
('None', NoneTyp()),
# reveal_type is a mypy-only function that gives an error with the type of its arg
('reveal_type', AnyType()),
] # type: List[Tuple[str, Type]]
# TODO(ddfisher): This guard is only needed because mypy defines
# fake builtins for its tests which often don't define bool. If
# mypy is fast enough that we no longer need those, this
# conditional check should be removed.
if 'bool' in self.sem.globals:
bool_type = self.sem.named_type('bool')
literal_types.extend([
('True', bool_type),
('False', bool_type),
('__debug__', bool_type),
])
for name, typ in literal_types:
v = Var(name, typ)
v._fullname = self.sem.qualified_name(name)
self.sem.globals[name] = SymbolTableNode(GDEF, v, self.sem.cur_mod_id)
del self.sem.options
def visit_block(self, b: Block) -> None:
if b.is_unreachable:
return
self.sem.block_depth[-1] += 1
for node in b.body:
node.accept(self)
self.sem.block_depth[-1] -= 1
def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
if self.sem.is_module_scope():
for lval in s.lvalues:
self.analyze_lvalue(lval, explicit_type=s.type is not None)
def visit_func_def(self, func: FuncDef) -> None:
sem = self.sem
func.is_conditional = sem.block_depth[-1] > 0
func._fullname = sem.qualified_name(func.name())
at_module = sem.is_module_scope()
if at_module and func.name() in sem.globals:
# Already defined in this module.
original_sym = sem.globals[func.name()]
if original_sym.kind == UNBOUND_IMPORTED:
# Ah this is an imported name. We can't resolve them now, so we'll postpone
# this until the main phase of semantic analysis.
return
if not sem.set_original_def(original_sym.node, func):
# Report error.
sem.check_no_global(func.name(), func)
else:
if at_module:
sem.globals[func.name()] = SymbolTableNode(GDEF, func, sem.cur_mod_id)
# Also analyze the function body (in case there are conditional imports).
sem.function_stack.append(func)
sem.errors.push_function(func.name())
sem.enter()
func.body.accept(self)
sem.leave()
sem.errors.pop_function()
sem.function_stack.pop()
def visit_overloaded_func_def(self, func: OverloadedFuncDef) -> None:
kind = self.kind_by_scope()
if kind == GDEF:
self.sem.check_no_global(func.name(), func, True)
func._fullname = self.sem.qualified_name(func.name())
if kind == GDEF:
self.sem.globals[func.name()] = SymbolTableNode(kind, func, self.sem.cur_mod_id)
def visit_class_def(self, cdef: ClassDef) -> None:
kind = self.kind_by_scope()
if kind == LDEF:
return
elif kind == GDEF:
self.sem.check_no_global(cdef.name, cdef)
cdef.fullname = self.sem.qualified_name(cdef.name)
info = TypeInfo(SymbolTable(), cdef, self.sem.cur_mod_id)
info.set_line(cdef.line, cdef.column)
cdef.info = info
if kind == GDEF:
self.sem.globals[cdef.name] = SymbolTableNode(kind, info, self.sem.cur_mod_id)
self.process_nested_classes(cdef)
def process_nested_classes(self, outer_def: ClassDef) -> None:
self.sem.enter_class(outer_def)
for node in outer_def.defs.body:
if isinstance(node, ClassDef):
node.info = TypeInfo(SymbolTable(), node, self.sem.cur_mod_id)
if outer_def.fullname:
node.info._fullname = outer_def.fullname + '.' + node.info.name()
else:
node.info._fullname = node.info.name()
node.fullname = node.info._fullname
symbol = SymbolTableNode(MDEF, node.info)
outer_def.info.names[node.name] = symbol
self.process_nested_classes(node)
elif isinstance(node, (ImportFrom, Import, ImportAll, IfStmt)):
node.accept(self)
self.sem.leave_class()
def visit_import_from(self, node: ImportFrom) -> None:
# We can't bind module names during the first pass, as the target module might be
# unprocessed. However, we add dummy unbound imported names to the symbol table so
# that we at least know that the name refers to a module.
at_module = self.sem.is_module_scope()
node.is_top_level = at_module
if not at_module:
return
for name, as_name in node.names:
imported_name = as_name or name
if imported_name not in self.sem.globals:
self.sem.add_symbol(imported_name, SymbolTableNode(UNBOUND_IMPORTED, None), node)
def visit_import(self, node: Import) -> None:
node.is_top_level = self.sem.is_module_scope()
# This is similar to visit_import_from -- see the comment there.
if not self.sem.is_module_scope():
return
for id, as_id in node.ids:
imported_id = as_id or id
if imported_id not in self.sem.globals:
self.sem.add_symbol(imported_id, SymbolTableNode(UNBOUND_IMPORTED, None), node)
else:
# If the previous symbol is a variable, this should take precedence.
self.sem.globals[imported_id] = SymbolTableNode(UNBOUND_IMPORTED, None)
def visit_import_all(self, node: ImportAll) -> None:
node.is_top_level = self.sem.is_module_scope()
def visit_while_stmt(self, s: WhileStmt) -> None:
if self.sem.is_module_scope():
s.body.accept(self)
if s.else_body:
s.else_body.accept(self)
def visit_for_stmt(self, s: ForStmt) -> None:
if self.sem.is_module_scope():
self.analyze_lvalue(s.index)
s.body.accept(self)
if s.else_body:
s.else_body.accept(self)
def visit_with_stmt(self, s: WithStmt) -> None:
if self.sem.is_module_scope():
for n in s.target:
if n:
self.analyze_lvalue(n)
s.body.accept(self)
def visit_decorator(self, d: Decorator) -> None:
d.var._fullname = self.sem.qualified_name(d.var.name())
self.sem.add_symbol(d.var.name(), SymbolTableNode(self.kind_by_scope(), d.var), d)
def visit_if_stmt(self, s: IfStmt) -> None:
infer_reachability_of_if_statement(s, pyversion=self.pyversion, platform=self.platform)
for node in s.body:
node.accept(self)
if s.else_body:
s.else_body.accept(self)
def visit_try_stmt(self, s: TryStmt) -> None:
if self.sem.is_module_scope():
self.sem.analyze_try_stmt(s, self, add_global=self.sem.is_module_scope())
def analyze_lvalue(self, lvalue: Lvalue, explicit_type: bool = False) -> None:
self.sem.analyze_lvalue(lvalue, add_global=self.sem.is_module_scope(),
explicit_type=explicit_type)
def kind_by_scope(self) -> int:
if self.sem.is_module_scope():
return GDEF
elif self.sem.is_class_scope():
return MDEF
elif self.sem.is_func_scope():
return LDEF
else:
assert False, "Couldn't determine scope"
class ThirdPass(TraverserVisitor):
"""The third and final pass of semantic analysis.
Check type argument counts and values of generic types, and perform some
straightforward type inference.
"""
def __init__(self, modules: Dict[str, MypyFile], errors: Errors) -> None:
self.modules = modules
self.errors = errors
def visit_file(self, file_node: MypyFile, fnam: str, options: Options) -> None:
self.errors.set_file(fnam)
self.options = options
self.accept(file_node)
def accept(self, node: Node) -> None:
try:
node.accept(self)
except Exception as err:
report_internal_error(err, self.errors.file, node.line, self.errors, self.options)
def visit_block(self, b: Block) -> None:
if b.is_unreachable:
return
super().visit_block(b)
def visit_func_def(self, fdef: FuncDef) -> None:
self.errors.push_function(fdef.name())
self.analyze(fdef.type)
super().visit_func_def(fdef)
self.errors.pop_function()
def visit_class_def(self, tdef: ClassDef) -> None:
for type in tdef.info.bases:
self.analyze(type)
# Recompute MRO now that we have analyzed all modules, to pick
# up superclasses of bases imported from other modules in an
# import loop. (Only do so if we succeeded the first time.)
if tdef.info.mro:
tdef.info.mro = [] # Force recomputation
calculate_class_mro(tdef, self.fail_blocker)
super().visit_class_def(tdef)
def visit_decorator(self, dec: Decorator) -> None:
"""Try to infer the type of the decorated function.
This lets us resolve references to decorated functions during
type checking when there are cyclic imports, as otherwise the
type might not be available when we need it.
This basically uses a simple special-purpose type inference
engine just for decorators.
"""
super().visit_decorator(dec)
if dec.var.is_property:
# Decorators are expected to have a callable type (it's a little odd).
if dec.func.type is None:
dec.var.type = CallableType(
[AnyType()],
[ARG_POS],
[None],
AnyType(),
self.builtin_type('function'),
name=dec.var.name())
elif isinstance(dec.func.type, CallableType):
dec.var.type = dec.func.type
return
decorator_preserves_type = True
for expr in dec.decorators:
preserve_type = False
if isinstance(expr, RefExpr) and isinstance(expr.node, FuncDef):
if is_identity_signature(expr.node.type):
preserve_type = True
if not preserve_type:
decorator_preserves_type = False
break
if decorator_preserves_type:
# No non-identity decorators left. We can trivially infer the type
# of the function here.
dec.var.type = function_type(dec.func, self.builtin_type('function'))
if dec.decorators:
if returns_any_if_called(dec.decorators[0]):
# The outermost decorator will return Any so we know the type of the
# decorated function.
dec.var.type = AnyType()
sig = find_fixed_callable_return(dec.decorators[0])
if sig:
# The outermost decorator always returns the same kind of function,
# so we know that this is the type of the decoratored function.
orig_sig = function_type(dec.func, self.builtin_type('function'))
sig.name = orig_sig.items()[0].name
dec.var.type = sig
def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
self.analyze(s.type)
if isinstance(s.rvalue, IndexExpr) and isinstance(s.rvalue.analyzed, TypeAliasExpr):
self.analyze(s.rvalue.analyzed.type)
super().visit_assignment_stmt(s)
def visit_cast_expr(self, e: CastExpr) -> None:
self.analyze(e.type)
super().visit_cast_expr(e)
def visit_reveal_type_expr(self, e: RevealTypeExpr) -> None:
super().visit_reveal_type_expr(e)
def visit_type_application(self, e: TypeApplication) -> None:
for type in e.types:
self.analyze(type)
super().visit_type_application(e)
# Helpers
def analyze(self, type: Type) -> None:
if type:
analyzer = TypeAnalyserPass3(self.fail)
type.accept(analyzer)
def fail(self, msg: str, ctx: Context, *, blocker: bool = False) -> None:
self.errors.report(ctx.get_line(), ctx.get_column(), msg)
def fail_blocker(self, msg: str, ctx: Context) -> None:
self.fail(msg, ctx, blocker=True)
def builtin_type(self, name: str, args: List[Type] = None) -> Instance:
names = self.modules['builtins']
sym = names.names[name]
assert isinstance(sym.node, TypeInfo)
return Instance(sym.node, args or [])
def fill_typevars(typ: TypeInfo) -> Union[Instance, TupleType]:
"""For a non-generic type, return instance type representing the type.
For a generic G type with parameters T1, .., Tn, return G[T1, ..., Tn].
"""
tv = [] # type: List[Type]
for i in range(len(typ.type_vars)):
tv.append(TypeVarType(typ.defn.type_vars[i]))
inst = Instance(typ, tv)
if typ.tuple_type is None:
return inst
return typ.tuple_type.copy_modified(fallback=inst)
def replace_implicit_first_type(sig: FunctionLike, new: Type) -> FunctionLike:
if isinstance(sig, CallableType):
return sig.copy_modified(arg_types=[new] + sig.arg_types[1:])
elif isinstance(sig, Overloaded):
return Overloaded([cast(CallableType, replace_implicit_first_type(i, new))
for i in sig.items()])
else:
assert False
def set_callable_name(sig: Type, fdef: FuncDef) -> Type:
if isinstance(sig, FunctionLike):
if fdef.info:
return sig.with_name(
'"{}" of "{}"'.format(fdef.name(), fdef.info.name()))
else:
return sig.with_name('"{}"'.format(fdef.name()))
else:
return sig
def refers_to_fullname(node: Expression, fullname: str) -> bool:
"""Is node a name or member expression with the given full name?"""
return isinstance(node, RefExpr) and node.fullname == fullname
def refers_to_class_or_function(node: Expression) -> bool:
"""Does semantically analyzed node refer to a class?"""
return (isinstance(node, RefExpr) and
isinstance(node.node, (TypeInfo, FuncDef, OverloadedFuncDef)))
def calculate_class_mro(defn: ClassDef, fail: Callable[[str, Context], None]) -> None:
try:
defn.info.calculate_mro()
except MroError:
fail("Cannot determine consistent method resolution order "
'(MRO) for "%s"' % defn.name, defn)
defn.info.mro = []
# The property of falling back to Any is inherited.
defn.info.fallback_to_any = any(baseinfo.fallback_to_any for baseinfo in defn.info.mro)
def find_duplicate(list: List[T]) -> T:
"""If the list has duplicates, return one of the duplicates.
Otherwise, return None.
"""
for i in range(1, len(list)):
if list[i] in list[:i]:
return list[i]
return None
def disable_typevars(nodes: List[SymbolTableNode]) -> None:
for node in nodes:
assert node.kind in (BOUND_TVAR, UNBOUND_TVAR)
node.kind = UNBOUND_TVAR
def enable_typevars(nodes: List[SymbolTableNode]) -> None:
for node in nodes:
assert node.kind in (BOUND_TVAR, UNBOUND_TVAR)
node.kind = BOUND_TVAR
def remove_imported_names_from_symtable(names: SymbolTable,
module: str) -> None:
"""Remove all imported names from the symbol table of a module."""
removed = [] # type: List[str]
for name, node in names.items():
if node.node is None:
continue
fullname = node.node.fullname()
prefix = fullname[:fullname.rfind('.')]
if prefix != module:
removed.append(name)
for name in removed:
del names[name]
def infer_reachability_of_if_statement(s: IfStmt,
pyversion: Tuple[int, int],
platform: str) -> None:
for i in range(len(s.expr)):
result = infer_if_condition_value(s.expr[i], pyversion, platform)
if result in (ALWAYS_FALSE, MYPY_FALSE):
# The condition is considered always false, so we skip the if/elif body.
mark_block_unreachable(s.body[i])
elif result in (ALWAYS_TRUE, MYPY_TRUE):
# This condition is considered always true, so all of the remaining
# elif/else bodies should not be checked.
if result == MYPY_TRUE:
# This condition is false at runtime; this will affect
# import priorities.
mark_block_mypy_only(s.body[i])
for body in s.body[i + 1:]:
mark_block_unreachable(body)
if s.else_body:
mark_block_unreachable(s.else_body)
break
def infer_if_condition_value(expr: Expression, pyversion: Tuple[int, int], platform: str) -> int:
"""Infer whether if condition is always true/false.
Return ALWAYS_TRUE if always true, ALWAYS_FALSE if always false,
MYPY_TRUE if true under mypy and false at runtime, MYPY_FALSE if
false under mypy and true at runtime, else TRUTH_VALUE_UNKNOWN.
"""
name = ''
negated = False
alias = expr
if isinstance(alias, UnaryExpr):
if alias.op == 'not':
expr = alias.expr
negated = True
result = TRUTH_VALUE_UNKNOWN
if isinstance(expr, NameExpr):
name = expr.name
elif isinstance(expr, MemberExpr):
name = expr.name
else:
result = consider_sys_version_info(expr, pyversion)
if result == TRUTH_VALUE_UNKNOWN:
result = consider_sys_platform(expr, platform)
if result == TRUTH_VALUE_UNKNOWN:
if name == 'PY2':
result = ALWAYS_TRUE if pyversion[0] == 2 else ALWAYS_FALSE
elif name == 'PY3':
result = ALWAYS_TRUE if pyversion[0] == 3 else ALWAYS_FALSE
elif name == 'MYPY' or name == 'TYPE_CHECKING':
result = MYPY_TRUE
if negated:
result = inverted_truth_mapping[result]
return result
def consider_sys_version_info(expr: Expression, pyversion: Tuple[int, ...]) -> int:
"""Consider whether expr is a comparison involving sys.version_info.
Return ALWAYS_TRUE, ALWAYS_FALSE, or TRUTH_VALUE_UNKNOWN.
"""
# Cases supported:
# - sys.version_info[]
# - sys.version_info[:]
# - sys.version_info
# (in this case must be >, >=, <, <=, but cannot be ==, !=)
if not isinstance(expr, ComparisonExpr):
return TRUTH_VALUE_UNKNOWN
# Let's not yet support chained comparisons.
if len(expr.operators) > 1:
return TRUTH_VALUE_UNKNOWN
op = expr.operators[0]
if op not in ('==', '!=', '<=', '>=', '<', '>'):
return TRUTH_VALUE_UNKNOWN
thing = contains_int_or_tuple_of_ints(expr.operands[1])
if thing is None:
return TRUTH_VALUE_UNKNOWN
index = contains_sys_version_info(expr.operands[0])
if isinstance(index, int) and isinstance(thing, int):
# sys.version_info[i] k
if 0 <= index <= 1:
return fixed_comparison(pyversion[index], op, thing)
else:
return TRUTH_VALUE_UNKNOWN
elif isinstance(index, tuple) and isinstance(thing, tuple):
# Why doesn't mypy see that index can't be None here?
lo, hi = cast(tuple, index)
if lo is None:
lo = 0
if hi is None:
hi = 2
if 0 <= lo < hi <= 2:
val = pyversion[lo:hi]
if len(val) == len(thing) or len(val) > len(thing) and op not in ('==', '!='):
return fixed_comparison(val, op, thing)
return TRUTH_VALUE_UNKNOWN
def consider_sys_platform(expr: Expression, platform: str) -> int:
"""Consider whether expr is a comparison involving sys.platform.
Return ALWAYS_TRUE, ALWAYS_FALSE, or TRUTH_VALUE_UNKNOWN.
"""
# Cases supported:
# - sys.platform == 'posix'
# - sys.platform != 'win32'
# - sys.platform.startswith('win')
if isinstance(expr, ComparisonExpr):
# Let's not yet support chained comparisons.
if len(expr.operators) > 1:
return TRUTH_VALUE_UNKNOWN
op = expr.operators[0]
if op not in ('==', '!='):
return TRUTH_VALUE_UNKNOWN
if not is_sys_attr(expr.operands[0], 'platform'):
return TRUTH_VALUE_UNKNOWN
right = expr.operands[1]
if not isinstance(right, (StrExpr, UnicodeExpr)):
return TRUTH_VALUE_UNKNOWN
return fixed_comparison(platform, op, right.value)
elif isinstance(expr, CallExpr):
if not isinstance(expr.callee, MemberExpr):
return TRUTH_VALUE_UNKNOWN
if len(expr.args) != 1 or not isinstance(expr.args[0], (StrExpr, UnicodeExpr)):
return TRUTH_VALUE_UNKNOWN
if not is_sys_attr(expr.callee.expr, 'platform'):
return TRUTH_VALUE_UNKNOWN
if expr.callee.name != 'startswith':
return TRUTH_VALUE_UNKNOWN
if platform.startswith(expr.args[0].value):
return ALWAYS_TRUE
else:
return ALWAYS_FALSE
else:
return TRUTH_VALUE_UNKNOWN
Targ = TypeVar('Targ', int, str, Tuple[int, ...])
def fixed_comparison(left: Targ, op: str, right: Targ) -> int:
rmap = {False: ALWAYS_FALSE, True: ALWAYS_TRUE}
if op == '==':
return rmap[left == right]
if op == '!=':
return rmap[left != right]
if op == '<=':
return rmap[left <= right]
if op == '>=':
return rmap[left >= right]
if op == '<':
return rmap[left < right]
if op == '>':
return rmap[left > right]
return TRUTH_VALUE_UNKNOWN
def contains_int_or_tuple_of_ints(expr: Expression
) -> Union[None, int, Tuple[int], Tuple[int, ...]]:
if isinstance(expr, IntExpr):
return expr.value
if isinstance(expr, TupleExpr):
if expr.literal == LITERAL_YES:
thing = []
for x in expr.items:
if not isinstance(x, IntExpr):
return None
thing.append(x.value)
return tuple(thing)
return None
def contains_sys_version_info(expr: Expression
) -> Union[None, int, Tuple[Optional[int], Optional[int]]]:
if is_sys_attr(expr, 'version_info'):
return (None, None) # Same as sys.version_info[:]
if isinstance(expr, IndexExpr) and is_sys_attr(expr.base, 'version_info'):
index = expr.index
if isinstance(index, IntExpr):
return index.value
if isinstance(index, SliceExpr):
if index.stride is not None:
if not isinstance(index.stride, IntExpr) or index.stride.value != 1:
return None
begin = end = None
if index.begin_index is not None:
if not isinstance(index.begin_index, IntExpr):
return None
begin = index.begin_index.value
if index.end_index is not None:
if not isinstance(index.end_index, IntExpr):
return None
end = index.end_index.value
return (begin, end)
return None
def is_sys_attr(expr: Expression, name: str) -> bool:
# TODO: This currently doesn't work with code like this:
# - import sys as _sys
# - from sys import version_info
if isinstance(expr, MemberExpr) and expr.name == name:
if isinstance(expr.expr, NameExpr) and expr.expr.name == 'sys':
# TODO: Guard against a local named sys, etc.
# (Though later passes will still do most checking.)
return True
return False
def mark_block_unreachable(block: Block) -> None:
block.is_unreachable = True
block.accept(MarkImportsUnreachableVisitor())
class MarkImportsUnreachableVisitor(TraverserVisitor):
"""Visitor that flags all imports nested within a node as unreachable."""
def visit_import(self, node: Import) -> None:
node.is_unreachable = True
def visit_import_from(self, node: ImportFrom) -> None:
node.is_unreachable = True
def visit_import_all(self, node: ImportAll) -> None:
node.is_unreachable = True
def mark_block_mypy_only(block: Block) -> None:
block.accept(MarkImportsMypyOnlyVisitor())
class MarkImportsMypyOnlyVisitor(TraverserVisitor):
"""Visitor that sets is_mypy_only (which affects priority)."""
def visit_import(self, node: Import) -> None:
node.is_mypy_only = True
def visit_import_from(self, node: ImportFrom) -> None:
node.is_mypy_only = True
def visit_import_all(self, node: ImportAll) -> None:
node.is_mypy_only = True
def is_identity_signature(sig: Type) -> bool:
"""Is type a callable of form T -> T (where T is a type variable)?"""
if isinstance(sig, CallableType) and sig.arg_kinds == [ARG_POS]:
if isinstance(sig.arg_types[0], TypeVarType) and isinstance(sig.ret_type, TypeVarType):
return sig.arg_types[0].id == sig.ret_type.id
return False
def returns_any_if_called(expr: Expression) -> bool:
"""Return True if we can predict that expr will return Any if called.
This only uses information available during semantic analysis so this
will sometimes return False because of insufficient information (as
type inference hasn't run yet).
"""
if isinstance(expr, RefExpr):
if isinstance(expr.node, FuncDef):
typ = expr.node.type
if typ is None:
# No signature -> default to Any.
return True
# Explicit Any return?
return isinstance(typ, CallableType) and isinstance(typ.ret_type, AnyType)
elif isinstance(expr.node, Var):
typ = expr.node.type
return typ is None or isinstance(typ, AnyType)
elif isinstance(expr, CallExpr):
return returns_any_if_called(expr.callee)
return False
def find_fixed_callable_return(expr: Expression) -> Optional[CallableType]:
if isinstance(expr, RefExpr):
if isinstance(expr.node, FuncDef):
typ = expr.node.type
if typ:
if isinstance(typ, CallableType) and has_no_typevars(typ.ret_type):
if isinstance(typ.ret_type, CallableType):
return typ.ret_type
elif isinstance(expr, CallExpr):
t = find_fixed_callable_return(expr.callee)
if t:
if isinstance(t.ret_type, CallableType):
return t.ret_type
return None
def has_no_typevars(typ: Type) -> bool:
return is_same_type(typ, erase_typevars(typ))
mypy-0.470/typeshed/ 0000755 0000000 0000000 00000000000 13044320557 013050 5 ustar root root mypy-0.470/typeshed/stdlib/ 0000755 0000000 0000000 00000000000 13044320557 014331 5 ustar root root mypy-0.470/typeshed/stdlib/3.3/ 0000755 0000000 0000000 00000000000 13044320557 014634 5 ustar root root mypy-0.470/typeshed/stdlib/3.3/ipaddress.pyi 0000644 0000000 0000000 00000012143 13035744274 017344 0 ustar root root # Stubs for ipaddress (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
IPV4LENGTH = ... # type: Any
IPV6LENGTH = ... # type: Any
class AddressValueError(ValueError): ...
class NetmaskValueError(ValueError): ...
def ip_address(address): ...
def ip_network(address, strict=...): ...
def ip_interface(address): ...
def v4_int_to_packed(address): ...
def v6_int_to_packed(address): ...
def summarize_address_range(first, last): ...
def collapse_addresses(addresses): ...
def get_mixed_type_key(obj): ...
class _TotalOrderingMixin:
def __eq__(self, other): ...
def __ne__(self, other): ...
def __lt__(self, other): ...
def __le__(self, other): ...
def __gt__(self, other): ...
def __ge__(self, other): ...
class _IPAddressBase(_TotalOrderingMixin):
@property
def exploded(self): ...
@property
def compressed(self): ...
@property
def version(self): ...
class _BaseAddress(_IPAddressBase):
def __init__(self, address) -> None: ...
def __int__(self): ...
def __eq__(self, other): ...
def __lt__(self, other): ...
def __add__(self, other): ...
def __sub__(self, other): ...
def __hash__(self): ...
class _BaseNetwork(_IPAddressBase):
def __init__(self, address) -> None: ...
def hosts(self): ...
def __iter__(self): ...
def __getitem__(self, n): ...
def __lt__(self, other): ...
def __eq__(self, other): ...
def __hash__(self): ...
def __contains__(self, other): ...
def overlaps(self, other): ...
@property
def broadcast_address(self): ...
@property
def hostmask(self): ...
@property
def with_prefixlen(self): ...
@property
def with_netmask(self): ...
@property
def with_hostmask(self): ...
@property
def num_addresses(self): ...
@property
def prefixlen(self): ...
def address_exclude(self, other): ...
def compare_networks(self, other): ...
def subnets(self, prefixlen_diff=..., new_prefix=...): ...
def supernet(self, prefixlen_diff=..., new_prefix=...): ...
@property
def is_multicast(self): ...
@property
def is_reserved(self): ...
@property
def is_link_local(self): ...
@property
def is_private(self): ...
@property
def is_global(self): ...
@property
def is_unspecified(self): ...
@property
def is_loopback(self): ...
class _BaseV4:
def __init__(self, address) -> None: ...
@property
def max_prefixlen(self): ...
@property
def version(self): ...
class IPv4Address(_BaseV4, _BaseAddress):
def __init__(self, address) -> None: ...
@property
def packed(self): ...
@property
def is_reserved(self): ...
@property
def is_private(self): ...
@property
def is_multicast(self): ...
@property
def is_unspecified(self): ...
@property
def is_loopback(self): ...
@property
def is_link_local(self): ...
class IPv4Interface(IPv4Address):
network = ... # type: Any
netmask = ... # type: Any
hostmask = ... # type: Any
def __init__(self, address) -> None: ...
def __eq__(self, other): ...
def __lt__(self, other): ...
def __hash__(self): ...
@property
def ip(self): ...
@property
def with_prefixlen(self): ...
@property
def with_netmask(self): ...
@property
def with_hostmask(self): ...
class IPv4Network(_BaseV4, _BaseNetwork):
network_address = ... # type: Any
netmask = ... # type: Any
hosts = ... # type: Any
def __init__(self, address, strict=...) -> None: ...
@property
def is_global(self): ...
class _BaseV6:
def __init__(self, address) -> None: ...
@property
def max_prefixlen(self): ...
@property
def version(self): ...
class IPv6Address(_BaseV6, _BaseAddress):
def __init__(self, address) -> None: ...
@property
def packed(self): ...
@property
def is_multicast(self): ...
@property
def is_reserved(self): ...
@property
def is_link_local(self): ...
@property
def is_site_local(self): ...
@property
def is_private(self): ...
@property
def is_global(self): ...
@property
def is_unspecified(self): ...
@property
def is_loopback(self): ...
@property
def ipv4_mapped(self): ...
@property
def teredo(self): ...
@property
def sixtofour(self): ...
class IPv6Interface(IPv6Address):
network = ... # type: Any
netmask = ... # type: Any
hostmask = ... # type: Any
def __init__(self, address) -> None: ...
def __eq__(self, other): ...
def __lt__(self, other): ...
def __hash__(self): ...
@property
def ip(self): ...
@property
def with_prefixlen(self): ...
@property
def with_netmask(self): ...
@property
def with_hostmask(self): ...
@property
def is_unspecified(self): ...
@property
def is_loopback(self): ...
class IPv6Network(_BaseV6, _BaseNetwork):
network_address = ... # type: Any
netmask = ... # type: Any
def __init__(self, address, strict=...) -> None: ...
def hosts(self): ...
@property
def is_site_local(self): ...
mypy-0.470/typeshed/stdlib/3.3/xml/ 0000755 0000000 0000000 00000000000 13044320557 015434 5 ustar root root mypy-0.470/typeshed/stdlib/3.3/xml/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 017702 0 ustar root root mypy-0.470/typeshed/stdlib/3.3/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016540 5 ustar root root mypy-0.470/typeshed/stdlib/3.3/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 021006 0 ustar root root mypy-0.470/typeshed/stdlib/3.3/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000013163 13044257024 021476 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
import io
VERSION = ... # type: str
class ParseError(SyntaxError): ...
def iselement(element: 'Element') -> bool: ...
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class Element(Sequence['Element']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
def append(self, subelement: 'Element') -> None: ...
def clear(self) -> None: ...
def copy(self) -> 'Element': ...
def extend(self, elements: Sequence['Element']) -> None: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional['Element']: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def getchildren(self) -> List['Element']: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['Element']: ...
def insert(self, index: int, subelement: 'Element') -> None: ...
def items(self) -> ItemsView[AnyStr, AnyStr]: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator['Element', None, None]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def itertext(self) -> Generator[str, None, None]: ...
def keys(self) -> KeysView[AnyStr]: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> 'Element': ...
def remove(self, subelement: 'Element') -> None: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def __bool__(self) -> bool: ...
def __delitem__(self, index: int) -> None: ...
def __getitem__(self, index) -> 'Element': ...
def __len__(self) -> int: ...
def __setitem__(self, index: int, element: 'Element') -> None: ...
def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> Element: ...
def Comment(text: _str_or_bytes=...) -> Element: ...
def ProcessingInstruction(target: str, text: str=...) -> Element: ...
PI = ... # type: Callable[..., Element]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: Element=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: 'XMLParser'=...) -> Element: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator[Element, None, None]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[Element]: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=..., xml_declaration: Optional[bool]=..., default_namespace: str=..., method: str=...) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: str, uri: str) -> None: ...
def tostring(element: Element, encoding: str=..., method: str=...) -> str: ...
def tostringlist(element: Element, encoding: str=..., method: str=...) -> List[str]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ...
def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
class _IterParseIterator:
root = ... # type: Any
def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
def __next__(self) -> Tuple[str, Element]: ...
def __iter__(self) -> _IterParseIterator: ...
def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., Element]
def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], Element]=...) -> None: ...
def close(self) -> Element: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> Element: ...
def end(self, tag: AnyStr) -> Element: ...
class XMLParser:
parser = ... # type: Any
target = ... # type: TreeBuilder
# TODO-what is entity used for???
entity = ... # type: Any
version = ... # type: str
def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/3.3/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000003167 13044257024 021476 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
from .ElementTree import Element
xpath_tokenizer_re = ... # type: Pattern
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[['_SelectorContext', List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Dict[str, str]=...) -> Generator[_token, None, None]: ...
def get_parent_map(context: '_SelectorContext') -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map = ... # type: Dict[Element, Element]
root = ... # type: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar('_T')
def iterfind(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def findtext(elem: Element, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
mypy-0.470/typeshed/stdlib/3.3/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021634 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/3.3/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001372 13044257024 022161 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from .ElementTree import Element
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: Element, loader: Callable[..., Union[str, Element]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/3.6/ 0000755 0000000 0000000 00000000000 13044320557 014637 5 ustar root root mypy-0.470/typeshed/stdlib/3.6/secrets.pyi 0000644 0000000 0000000 00000000743 13035744274 017044 0 ustar root root # Stubs for secrets (Python 3.6)
from typing import Optional, Sequence, TypeVar
from hmac import compare_digest as compare_digest
from random import SystemRandom as SystemRandom
_T = TypeVar('_T')
def randbelow(exclusive_upper_bound: int) -> int: ...
def randbits(k: int) -> int: ...
def choice(seq: Sequence[_T]) -> _T: ...
def token_bytes(nbytes: Optional[int]) -> bytes: ...
def token_hex(nbytes: Optional[int]) -> str: ...
def token_urlsafe(nbytes: Optional[int]) -> str: ...
mypy-0.470/typeshed/stdlib/3.4/ 0000755 0000000 0000000 00000000000 13044320557 014635 5 ustar root root mypy-0.470/typeshed/stdlib/3.4/asyncio/ 0000755 0000000 0000000 00000000000 13044320557 016302 5 ustar root root mypy-0.470/typeshed/stdlib/3.4/asyncio/__init__.pyi 0000644 0000000 0000000 00000005677 13044257024 020601 0 ustar root root """The asyncio package, tracking PEP 3156."""
import sys
from typing import Type
from asyncio.coroutines import (
coroutine as coroutine,
iscoroutinefunction as iscoroutinefunction,
iscoroutine as iscoroutine,
)
from asyncio.protocols import (
BaseProtocol as BaseProtocol,
Protocol as Protocol,
DatagramProtocol as DatagramProtocol,
SubprocessProtocol as SubprocessProtocol,
)
from asyncio.streams import (
StreamReader as StreamReader,
StreamWriter as StreamWriter,
StreamReaderProtocol as StreamReaderProtocol,
open_connection as open_connection,
start_server as start_server,
IncompleteReadError as IncompleteReadError,
LimitOverrunError as LimitOverrunError,
)
from asyncio.subprocess import (
create_subprocess_exec as create_subprocess_exec,
create_subprocess_shell as create_subprocess_shell,
)
from asyncio.transports import (
BaseTransport as BaseTransport,
ReadTransport as ReadTransport,
WriteTransport as WriteTransport,
Transport as Transport,
DatagramTransport as DatagramTransport,
SubprocessTransport as SubprocessTransport,
)
from asyncio.futures import (
Future as Future,
CancelledError as CancelledError,
TimeoutError as TimeoutError,
InvalidStateError as InvalidStateError,
)
from asyncio.tasks import (
FIRST_COMPLETED as FIRST_COMPLETED,
FIRST_EXCEPTION as FIRST_EXCEPTION,
ALL_COMPLETED as ALL_COMPLETED,
as_completed as as_completed,
ensure_future as ensure_future,
gather as gather,
run_coroutine_threadsafe as run_coroutine_threadsafe,
shield as shield,
sleep as sleep,
wait as wait,
wait_for as wait_for,
Task as Task,
)
from asyncio.events import (
AbstractEventLoopPolicy as AbstractEventLoopPolicy,
AbstractEventLoop as AbstractEventLoop,
AbstractServer as AbstractServer,
Handle as Handle,
get_event_loop_policy as get_event_loop_policy,
set_event_loop_policy as set_event_loop_policy,
get_event_loop as get_event_loop,
set_event_loop as set_event_loop,
new_event_loop as new_event_loop,
get_child_watcher as get_child_watcher,
set_child_watcher as set_child_watcher,
)
from asyncio.queues import (
Queue as Queue,
PriorityQueue as PriorityQueue,
LifoQueue as LifoQueue,
JoinableQueue as JoinableQueue,
QueueFull as QueueFull,
QueueEmpty as QueueEmpty,
)
from asyncio.locks import (
Lock as Lock,
Event as Event,
Condition as Condition,
Semaphore as Semaphore,
BoundedSemaphore as BoundedSemaphore,
)
# TODO: It should be possible to instantiate these classes, but mypy
# currently disallows this.
# See https://github.com/python/mypy/issues/1843
SelectorEventLoop = ... # type: Type[AbstractEventLoop]
if sys.platform == 'win32':
ProactorEventLoop = ... # type: Type[AbstractEventLoop]
DefaultEventLoopPolicy = ... # type: Type[AbstractEventLoopPolicy]
# TODO: AbstractChildWatcher (UNIX only)
__all__ = ... # type: str
mypy-0.470/typeshed/stdlib/3.4/asyncio/locks.pyi 0000644 0000000 0000000 00000003725 13023631176 020146 0 ustar root root from typing import Any, Callable, Generator, Iterable, Iterator, TypeVar, Union
from .coroutines import coroutine
from .events import AbstractEventLoop
from .futures import Future
T = TypeVar('T')
__all__ = ... # type: str
class _ContextManager:
def __init__(self, lock: Union[Lock, Semaphore]) -> None: ...
def __enter__(self) -> object: ...
def __exit__(self, *args: Any) -> None: ...
class _ContextManagerMixin(Future[_ContextManager]):
# Apparently this exists to *prohibit* use as a context manager.
def __enter__(self) -> object: ...
def __exit__(self, *args: Any) -> None: ...
def __aenter__(self): ...
def __aexit__(self, exc_type, exc, tb): ...
class Lock(_ContextManagerMixin):
def __init__(self, *, loop: AbstractEventLoop = None) -> None: ...
def locked(self) -> bool: ...
@coroutine
def acquire(self) -> Future[bool]: ...
def release(self) -> None: ...
class Event:
def __init__(self, *, loop: AbstractEventLoop = None) -> None: ...
def is_set(self) -> bool: ...
def set(self) -> None: ...
def clear(self) -> None: ...
@coroutine
def wait(self) -> bool: ...
class Condition(_ContextManagerMixin):
def __init__(self, lock: Lock = None, *, loop: AbstractEventLoop = None) -> None: ...
def locked(self) -> bool: ...
@coroutine
def acquire(self) -> Future[bool]: ...
def release(self) -> None: ...
@coroutine
def wait(self) -> Future[bool]: ...
@coroutine
def wait_for(self, predicate: Callable[[], T]) -> Future[T]: ...
def notify(self, n: int = 1) -> None: ...
def notify_all(self) -> None: ...
class Semaphore(_ContextManagerMixin):
def __init__(self, value: int = 1, *, loop: AbstractEventLoop = None) -> None: ...
def locked(self) -> bool: ...
@coroutine
def acquire(self) -> Future[bool]: ...
def release(self) -> None: ...
class BoundedSemaphore(Semaphore):
def __init__(self, value=1, *, loop: AbstractEventLoop = None) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/events.pyi 0000644 0000000 0000000 00000017153 13035744274 020346 0 ustar root root import sys
from typing import Any, Awaitable, TypeVar, List, Callable, Tuple, Union, Dict, Generator, overload, Optional
from abc import ABCMeta, abstractmethod
from asyncio.futures import Future
from asyncio.coroutines import coroutine
from asyncio.tasks import Task
__all__ = ... # type: str
_T = TypeVar('_T')
PIPE = ... # type: Any # from subprocess.PIPE
AF_UNSPEC = 0 # from socket
AI_PASSIVE = 0
class Handle:
_cancelled = False
_args = ... # type: List[Any]
def __init__(self, callback: Callable[..., Any], args: List[Any],
loop: AbstractEventLoop) -> None: ...
def __repr__(self) -> str: ...
def cancel(self) -> None: ...
def _run(self) -> None: ...
class AbstractServer:
def close(self) -> None: ...
@coroutine
def wait_closed(self) -> Generator[Any, Any, None]: ...
class AbstractEventLoop(metaclass=ABCMeta):
@abstractmethod
def run_forever(self) -> None: ...
# Can't use a union, see mypy issue # 1873.
@overload
@abstractmethod
def run_until_complete(self, future: Generator[Any, Any, _T]) -> _T: ...
@overload
@abstractmethod
def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
@abstractmethod
def stop(self) -> None: ...
@abstractmethod
def is_running(self) -> bool: ...
@abstractmethod
def close(self) -> None: ...
# Methods scheduling callbacks. All these return Handles.
@abstractmethod
def call_soon(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
@abstractmethod
def call_later(self, delay: Union[int, float], callback: Callable[..., Any], *args: Any) -> Handle: ...
@abstractmethod
def call_at(self, when: float, callback: Callable[..., Any], *args: Any) -> Handle: ...
@abstractmethod
def time(self) -> float: ...
# Future methods
if sys.version_info >= (3, 5):
@abstractmethod
def create_future(self) -> Future[Any]: ...
# Tasks methods
@abstractmethod
def create_task(self, coro: Union[Future[_T], Generator[Any, None, _T]]) -> Task[_T]: ...
@abstractmethod
def set_task_factory(self, factory: Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]) -> None: ...
@abstractmethod
def get_task_factory(self) -> Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]: ...
# Methods for interacting with threads
@abstractmethod
def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any) -> Handle: ...
@abstractmethod
def run_in_executor(self, executor: Any,
callback: Callable[[], Any], *args: Any) -> Future[Any]: ...
@abstractmethod
def set_default_executor(self, executor: Any) -> None: ...
# Network I/O methods returning Futures.
@abstractmethod
def getaddrinfo(self, host: str, port: int, *,
family: int = ..., type: int = ..., proto: int = ..., flags: int = ...) -> Future[List[Tuple[int, int, int, str, tuple]]]: ...
@abstractmethod
def getnameinfo(self, sockaddr: tuple, flags: int = ...) -> Future[Tuple[str, int]]: ...
@abstractmethod
def create_connection(self, protocol_factory: Any, host: str = ..., port: int = ..., *,
ssl: Any = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: Any = ...,
local_addr: str = ..., server_hostname: str = ...) -> tuple: ...
@abstractmethod
def create_server(self, protocol_factory: Any, host: str = ..., port: int = ..., *,
family: int = ..., flags: int = ...,
sock: Any = ..., backlog: int = ..., ssl: Any = ..., reuse_address: Any = ...) -> Any: ...
@abstractmethod
def create_unix_connection(self, protocol_factory: Any, path: str, *,
ssl: Any = ..., sock: Any = ...,
server_hostname: str = ...) -> tuple: ...
@abstractmethod
def create_unix_server(self, protocol_factory: Any, path: str, *,
sock: Any = ..., backlog: int = ..., ssl: Any = ...) -> Any: ...
@abstractmethod
def create_datagram_endpoint(self, protocol_factory: Any,
local_addr: str = ..., remote_addr: str = ..., *,
family: int = ..., proto: int = ..., flags: int = ...) -> tuple: ...
# Pipes and subprocesses.
@abstractmethod
def connect_read_pipe(self, protocol_factory: Any, pipe: Any) -> tuple: ...
@abstractmethod
def connect_write_pipe(self, protocol_factory: Any, pipe: Any) -> tuple: ...
@abstractmethod
def subprocess_shell(self, protocol_factory: Any, cmd: Union[bytes, str], *, stdin: Any = ...,
stdout: Any = ..., stderr: Any = ...,
**kwargs: Any) -> tuple: ...
@abstractmethod
def subprocess_exec(self, protocol_factory: Any, *args: List[Any], stdin: Any = ...,
stdout: Any = ..., stderr: Any = ...,
**kwargs: Any) -> tuple: ...
@abstractmethod
def add_reader(self, fd: int, callback: Callable[[], Any], *args: List[Any]) -> None: ...
@abstractmethod
def remove_reader(self, fd: int) -> None: ...
@abstractmethod
def add_writer(self, fd: int, callback: Callable[[], Any], *args: List[Any]) -> None: ...
@abstractmethod
def remove_writer(self, fd: int) -> None: ...
# Completion based I/O methods returning Futures.
@abstractmethod
def sock_recv(self, sock: Any, nbytes: int) -> Any: ... # TODO
@abstractmethod
def sock_sendall(self, sock: Any, data: bytes) -> None: ... # TODO
@abstractmethod
def sock_connect(self, sock: Any, address: str) -> Any: ... # TODO
@abstractmethod
def sock_accept(self, sock: Any) -> Any: ...
# Signal handling.
@abstractmethod
def add_signal_handler(self, sig: int, callback: Callable[[], Any], *args: List[Any]) -> None: ...
@abstractmethod
def remove_signal_handler(self, sig: int) -> None: ...
# Error handlers.
@abstractmethod
def set_exception_handler(self, handler: Callable[[], Any]) -> None: ...
@abstractmethod
def default_exception_handler(self, context: Any) -> None: ...
@abstractmethod
def call_exception_handler(self, context: Any) -> None: ...
# Debug flag management.
@abstractmethod
def get_debug(self) -> bool: ...
@abstractmethod
def set_debug(self, enabled: bool) -> None: ...
class AbstractEventLoopPolicy(metaclass=ABCMeta):
@abstractmethod
def get_event_loop(self) -> AbstractEventLoop: ...
@abstractmethod
def set_event_loop(self, loop: AbstractEventLoop): ...
@abstractmethod
def new_event_loop(self) -> AbstractEventLoop: ...
# Child processes handling (Unix only).
@abstractmethod
def get_child_watcher(self) -> Any: ... # TODO: unix_events.AbstractChildWatcher
@abstractmethod
def set_child_watcher(self, watcher: Any) -> None: ... # TODO: unix_events.AbstractChildWatcher
class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
def __init__(self) -> None: ...
def get_event_loop(self) -> AbstractEventLoop: ...
def set_event_loop(self, loop: AbstractEventLoop): ...
def new_event_loop(self) -> AbstractEventLoop: ...
def get_event_loop_policy() -> AbstractEventLoopPolicy: ...
def set_event_loop_policy(policy: AbstractEventLoopPolicy) -> None: ...
def get_event_loop() -> AbstractEventLoop: ...
def set_event_loop(loop: AbstractEventLoop) -> None: ...
def new_event_loop() -> AbstractEventLoop: ...
def get_child_watcher() -> Any: ... # TODO: unix_events.AbstractChildWatcher
def set_child_watcher(watcher: Any) -> None: ... # TODO: unix_events.AbstractChildWatcher
mypy-0.470/typeshed/stdlib/3.4/asyncio/futures.pyi 0000644 0000000 0000000 00000003232 13035744274 020530 0 ustar root root from typing import Any, Union, Callable, TypeVar, List, Generic, Iterable, Generator, Awaitable
from .events import AbstractEventLoop
from concurrent.futures._base import (
Error as Error,
)
from concurrent.futures import (
CancelledError as CancelledError,
TimeoutError as TimeoutError,
)
__all__ = ... # type: str
_T = TypeVar('_T')
class InvalidStateError(Error): ...
class _TracebackLogger:
exc = ... # type: BaseException
tb = ... # type: List[str]
def __init__(self, exc: Any, loop: AbstractEventLoop) -> None: ...
def activate(self) -> None: ...
def clear(self) -> None: ...
def __del__(self) -> None: ...
class Future(Iterable[_T], Awaitable[_T], Generic[_T]):
_state = ... # type: str
_exception = ... # type: BaseException
_blocking = False
_log_traceback = False
_tb_logger = _TracebackLogger
def __init__(self, *, loop: AbstractEventLoop = ...) -> None: ...
def __repr__(self) -> str: ...
def __del__(self) -> None: ...
def cancel(self) -> bool: ...
def _schedule_callbacks(self) -> None: ...
def cancelled(self) -> bool: ...
def done(self) -> bool: ...
def result(self) -> _T: ...
def exception(self) -> BaseException: ...
def add_done_callback(self, fn: Callable[[Future[_T]], Any]) -> None: ...
def remove_done_callback(self, fn: Callable[[Future[_T]], Any]) -> int: ...
def set_result(self, result: _T) -> None: ...
def set_exception(self, exception: Union[type, BaseException]) -> None: ...
def _copy_state(self, other: Any) -> None: ...
def __iter__(self) -> Generator[Any, None, _T]: ...
def __await__(self) -> Generator[Any, None, _T]: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/streams.pyi 0000644 0000000 0000000 00000006663 13044257024 020514 0 ustar root root import socket
from typing import Any, Callable, Generator, Iterable, Tuple
from . import coroutines
from . import events
from . import protocols
from . import transports
ClientConnectedCallback = Callable[[Tuple[StreamReader, StreamWriter]], None]
__all__ = ... # type: str
class IncompleteReadError(EOFError):
def __init__(self, partial: str, expected: int) -> None: ...
class LimitOverrunError(Exception):
def __init__(self, message: str, consumed: int) -> None: ...
@coroutines.coroutine
def open_connection(
host: str = ...,
port: int = ...,
*,
loop: events.AbstractEventLoop = ...,
limit: int = ...,
**kwds: Any
) -> Generator[Any, None, Tuple[StreamReader, StreamWriter]]: ...
@coroutines.coroutine
def start_server(
client_connected_cb: ClientConnectedCallback,
host: str = ...,
port: int = ...,
*,
loop: events.AbstractEventLoop = ...,
limit: int = ...,
**kwds: Any
) -> Generator[Any, None, events.AbstractServer]: ...
if hasattr(socket, 'AF_UNIX'):
@coroutines.coroutine
def open_unix_connection(
path: str = ...,
*,
loop: events.AbstractEventLoop = ...,
limit: int = ...,
**kwds: Any
) -> Generator[Any, None, Tuple[StreamReader, StreamWriter]]: ...
@coroutines.coroutine
def start_unix_server(
client_connected_cb: ClientConnectedCallback,
path: str = ...,
*,
loop: int = ...,
limit: int = ...,
**kwds: Any) -> Generator[Any, None, events.AbstractServer]: ...
class FlowControlMixin(protocols.Protocol): ...
class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
def __init__(self,
stream_reader: StreamReader,
client_connected_cb: ClientConnectedCallback = ...,
loop: events.AbstractEventLoop = ...) -> None: ...
def connection_made(self, transport: transports.BaseTransport) -> None: ...
def connection_lost(self, exc: Exception) -> None: ...
def data_received(self, data: bytes) -> None: ...
def eof_received(self) -> bool: ...
class StreamWriter:
def __init__(self,
transport: transports.BaseTransport,
protocol: protocols.BaseProtocol,
reader: StreamReader,
loop: events.AbstractEventLoop) -> None: ...
@property
def transport(self) -> transports.BaseTransport: ...
def write(self, data: bytes) -> None: ...
def writelines(self, data: Iterable[bytes]) -> None: ...
def write_eof(self) -> None: ...
def can_write_eof(self) -> bool: ...
def close(self) -> None: ...
def get_extra_info(self, name: str, default: Any = ...) -> Any: ...
def drain(self) -> None: ...
class StreamReader:
def __init__(self,
limit: int = ...,
loop: events.AbstractEventLoop = ...) -> None: ...
def exception(self) -> Exception: ...
def set_exception(self, exc: Exception) -> None: ...
def set_transport(self, transport: transports.BaseTransport) -> None: ...
def feed_eof(self) -> None: ...
def at_eof(self) -> bool: ...
def feed_data(self, data: bytes): ...
@coroutines.coroutine
def readline(self) -> Generator[Any, None, bytes]: ...
@coroutines.coroutine
def readuntil(self, separator=b'\n') -> Generator[Any, None, bytes]: ...
@coroutines.coroutine
def read(self, n=-1) -> Generator[Any, None, bytes]: ...
@coroutines.coroutine
def readexactly(self, n) -> Generator[Any, None, bytes]: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/tasks.pyi 0000644 0000000 0000000 00000005335 13044257024 020156 0 ustar root root from typing import (Any, TypeVar, Set, Dict, List, TextIO, Union, Tuple, Generic, Callable,
Coroutine, Generator, Iterable, Awaitable, overload, Sequence, Iterator,
Optional)
import concurrent.futures
from .events import AbstractEventLoop
from .futures import Future
__all__ = ... # type: str
_T = TypeVar('_T')
FIRST_EXCEPTION = 'FIRST_EXCEPTION'
FIRST_COMPLETED = 'FIRST_COMPLETED'
ALL_COMPLETED = 'ALL_COMPLETED'
def as_completed(fs: Sequence[Future[_T]], *, loop: AbstractEventLoop = ...,
timeout=None) -> Iterator[Generator[Any, None, _T]]: ...
def ensure_future(coro_or_future: Union[Future[_T], Generator[Any, None, _T]],
*, loop: AbstractEventLoop = ...) -> Future[_T]: ...
# TODO: gather() should use variadic type vars instead of _TAny.
_TAny = Any
def gather(*coros_or_futures: Union[Future[_TAny], Generator[Any, None, _TAny], Awaitable[_TAny]],
loop: AbstractEventLoop = ..., return_exceptions: bool = False) -> Future[List[_TAny]]: ...
def run_coroutine_threadsafe(coro: Union[Generator[Any, None, _T], Coroutine[Any, None, _T], Awaitable[_T]],
loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
def shield(arg: Union[Future[_T], Generator[Any, None, _T]],
*, loop: AbstractEventLoop = ...) -> Future[_T]: ...
def sleep(delay: float, result: _T = ..., loop: AbstractEventLoop = ...) -> Future[_T]: ...
def wait(fs: List[Task[_T]], *, loop: AbstractEventLoop = ...,
timeout: float = ...,
return_when: str = ...) -> Future[Tuple[Set[Future[_T]], Set[Future[_T]]]]: ...
def wait_for(fut: Union[Future[_T], Generator[Any, None, _T], Awaitable[_T]], timeout: Optional[float],
*, loop: AbstractEventLoop = ...) -> Future[_T]: ...
class Task(Future[_T], Generic[_T]):
_all_tasks = ... # type: Set[Task]
_current_tasks = ... # type: Dict[AbstractEventLoop, Task]
@classmethod
def current_task(cls, loop: AbstractEventLoop = ...) -> Task: ...
@classmethod
def all_tasks(cls, loop: AbstractEventLoop = ...) -> Set[Task]: ...
# Can't use a union, see mypy issue #1873.
@overload
def __init__(self, coro: Generator[Any, None, _T],
*, loop: AbstractEventLoop = ...) -> None: ...
@overload
def __init__(self, coro: Awaitable[_T], *, loop: AbstractEventLoop = ...) -> None: ...
def __repr__(self) -> str: ...
def get_stack(self, *, limit: int = ...) -> List[Any]: ... # return List[stackframe]
def print_stack(self, *, limit: int = ..., file: TextIO = ...) -> None: ...
def cancel(self) -> bool: ...
def _step(self, value: Any = ..., exc: Exception = ...) -> None: ...
def _wakeup(self, future: Future[Any]) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/coroutines.pyi 0000644 0000000 0000000 00000000411 13035744274 021221 0 ustar root root from typing import Any, Callable, Generator, TypeVar
__all__ = ... # type: str
_F = TypeVar('_F', bound=Callable[..., Any])
def coroutine(func: _F) -> _F: ...
def iscoroutinefunction(func: Callable[..., Any]) -> bool: ...
def iscoroutine(obj: Any) -> bool: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/protocols.pyi 0000644 0000000 0000000 00000001516 13035744274 021062 0 ustar root root from asyncio import transports
from typing import AnyStr
__all__ = ... # type: str
class BaseProtocol:
def connection_made(self, transport: transports.BaseTransport) -> None: ...
def connection_lost(self, exc: Exception) -> None: ...
def pause_writing(self) -> None: ...
def resume_writing(self) -> None: ...
class Protocol(BaseProtocol):
def data_received(self, data: bytes) -> None: ...
def eof_received(self) -> bool: ...
class DatagramProtocol(BaseProtocol):
def datagram_received(self, data: AnyStr, addr: str) -> None: ...
def error_received(self, exc: Exception) -> None: ...
class SubprocessProtocol(BaseProtocol):
def pipe_data_received(self, fd: int, data: AnyStr) -> None: ...
def pipe_connection_lost(self, fd: int, exc: Exception) -> None: ...
def process_exited(self) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/queues.pyi 0000644 0000000 0000000 00000002271 13044257024 020334 0 ustar root root from asyncio.events import AbstractEventLoop
from .coroutines import coroutine
from .futures import Future
from typing import TypeVar, Generic
__all__ = ... # type: str
class QueueEmpty(Exception): ...
class QueueFull(Exception): ...
T = TypeVar('T')
class Queue(Generic[T]):
def __init__(self, maxsize: int = ..., *, loop: AbstractEventLoop = ...) -> None: ...
def _init(self, maxsize: int) -> None: ...
def _get(self) -> T: ...
def _put(self, item: T) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def _format(self) -> str: ...
def _consume_done_getters(self) -> None: ...
def _consume_done_putters(self) -> None: ...
def qsize(self) -> int: ...
@property
def maxsize(self) -> int: ...
def empty(self) -> bool: ...
def full(self) -> bool: ...
@coroutine
def put(self, item: T) -> Future[None]: ...
def put_nowait(self, item: T) -> None: ...
@coroutine
def get(self) -> Future[T]: ...
def get_nowait(self) -> T: ...
class PriorityQueue(Queue): ...
class LifoQueue(Queue): ...
class JoinableQueue(Queue):
def task_done(self) -> None: ...
@coroutine
def join(self) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/subprocess.pyi 0000644 0000000 0000000 00000003502 13044257024 021213 0 ustar root root from asyncio import events
from asyncio import protocols
from asyncio import streams
from asyncio import transports
from asyncio.coroutines import coroutine
from typing import Any, AnyStr, Tuple, Union
__all__ = ... # type: str
PIPE = ... # type: int
STDOUT = ... # type: int
DEVNULL = ... # type: int
class SubprocessStreamProtocol(streams.FlowControlMixin,
protocols.SubprocessProtocol):
def __init__(self, limit: int, loop: events.AbstractEventLoop) -> None: ...
def connection_made(self, transport: transports.BaseTransport) -> None: ...
def pipe_data_received(self, fd: int, data: AnyStr) -> None: ...
def pipe_connection_lost(self, fd: int, exc: Exception): ...
def process_exited(self) -> None: ...
class Process:
def __init__(self,
transport: transports.BaseTransport,
protocol: protocols.BaseProtocol,
loop: events.AbstractEventLoop) -> None: ...
@property
def returncode(self) -> int: ...
@coroutine
def wait(self) -> int: ...
def send_signal(self, signal: int) -> None: ...
def terminate(self) -> None: ...
def kill(self) -> None: ...
@coroutine
def communicate(self, input: bytes = ...) -> Tuple[bytes, bytes]: ...
@coroutine
def create_subprocess_shell(
*Args: Union[str, bytes], # Union used instead of AnyStr due to mypy issue #1236
stdin: int = ...,
stdout: int = ...,
stderr: int = ...,
loop: events.AbstractEventLoop = ...,
limit: int = ...,
**kwds: Any
): ...
@coroutine
def create_subprocess_exec(
program: Union[str, bytes], # Union used instead of AnyStr due to mypy issue #1236
*args: Any,
stdin: int = ...,
stdout: int = ...,
stderr: int = ...,
loop: events.AbstractEventLoop = ...,
limit: int = ...,
**kwds: Any
) -> Process: ...
mypy-0.470/typeshed/stdlib/3.4/asyncio/transports.pyi 0000644 0000000 0000000 00000002447 13035744274 021261 0 ustar root root from typing import Dict, Any, TypeVar, Mapping, List
__all__ = ... # type: str
class BaseTransport:
def __init__(self, extra: Mapping[Any, Any] = ...) -> None: ...
def get_extra_info(self, name: Any, default: Any = ...) -> Any: ...
def is_closing(self) -> bool: ...
def close(self) -> None: ...
class ReadTransport(BaseTransport):
def pause_reading(self) -> None: ...
def resume_reading(self) -> None: ...
class WriteTransport(BaseTransport):
def set_write_buffer_limits(
self, high: int = ..., low: int = ...
) -> None: ...
def get_write_buffer_size(self) -> int: ...
def write(self, data: Any) -> None: ...
def writelines(self, list_of_data: List[Any]): ...
def write_eof(self) -> None: ...
def can_write_eof(self) -> bool: ...
def abort(self) -> None: ...
class Transport(ReadTransport, WriteTransport): ...
class DatagramTransport(BaseTransport):
def sendto(self, data: Any, addr: str = ...) -> None: ...
def abort(self) -> None: ...
class SubprocessTransport(BaseTransport):
def get_pid(self) -> int: ...
def get_returncode(self) -> int: ...
def get_pipe_transport(self, fd: int) -> BaseTransport: ...
def send_signal(self, signal: int) -> int: ...
def terminate(self) -> None: ...
def kill(self) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/_stat.pyi 0000644 0000000 0000000 00000003620 13035744274 016501 0 ustar root root """Stub file for the '_stat' module."""
SF_APPEND = ... # type: int
SF_ARCHIVED = ... # type: int
SF_IMMUTABLE = ... # type: int
SF_NOUNLINK = ... # type: int
SF_SNAPSHOT = ... # type: int
ST_ATIME = ... # type: int
ST_CTIME = ... # type: int
ST_DEV = ... # type: int
ST_GID = ... # type: int
ST_INO = ... # type: int
ST_MODE = ... # type: int
ST_MTIME = ... # type: int
ST_NLINK = ... # type: int
ST_SIZE = ... # type: int
ST_UID = ... # type: int
S_ENFMT = ... # type: int
S_IEXEC = ... # type: int
S_IFBLK = ... # type: int
S_IFCHR = ... # type: int
S_IFDIR = ... # type: int
S_IFDOOR = ... # type: int
S_IFIFO = ... # type: int
S_IFLNK = ... # type: int
S_IFPORT = ... # type: int
S_IFREG = ... # type: int
S_IFSOCK = ... # type: int
S_IFWHT = ... # type: int
S_IREAD = ... # type: int
S_IRGRP = ... # type: int
S_IROTH = ... # type: int
S_IRUSR = ... # type: int
S_IRWXG = ... # type: int
S_IRWXO = ... # type: int
S_IRWXU = ... # type: int
S_ISGID = ... # type: int
S_ISUID = ... # type: int
S_ISVTX = ... # type: int
S_IWGRP = ... # type: int
S_IWOTH = ... # type: int
S_IWRITE = ... # type: int
S_IWUSR = ... # type: int
S_IXGRP = ... # type: int
S_IXOTH = ... # type: int
S_IXUSR = ... # type: int
UF_APPEND = ... # type: int
UF_COMPRESSED = ... # type: int
UF_HIDDEN = ... # type: int
UF_IMMUTABLE = ... # type: int
UF_NODUMP = ... # type: int
UF_NOUNLINK = ... # type: int
UF_OPAQUE = ... # type: int
def S_IMODE(mode: int) -> int: ...
def S_IFMT(mode: int) -> int: ...
def S_ISBLK(mode: int) -> bool: ...
def S_ISCHR(mode: int) -> bool: ...
def S_ISDIR(mode: int) -> bool: ...
def S_ISDOOR(mode: int) -> bool: ...
def S_ISFIFO(mode: int) -> bool: ...
def S_ISLNK(mode: int) -> bool: ...
def S_ISPORT(mode: int) -> bool: ...
def S_ISREG(mode: int) -> bool: ...
def S_ISSOCK(mode: int) -> bool: ...
def S_ISWHT(mode: int) -> bool: ...
def filemode(mode: int) -> str: ...
mypy-0.470/typeshed/stdlib/3.4/_tracemalloc.pyi 0000644 0000000 0000000 00000001233 13023631176 020003 0 ustar root root """Stub file for the '_tracemalloc' module."""
# This is an autogenerated file. It serves as a starting point
# for a more precise manual annotation of this module.
# Feel free to edit the source below, but remove this header when you do.
from typing import Any, List, Tuple, Dict, Generic
def _get_object_traceback(*args, **kwargs) -> Any: ...
def _get_traces() -> Any:
raise MemoryError()
def clear_traces() -> None: ...
def get_traceback_limit() -> int: ...
def get_traced_memory() -> tuple: ...
def get_tracemalloc_memory() -> Any: ...
def is_tracing() -> bool: ...
def start(*args, **kwargs) -> None:
raise ValueError()
def stop() -> None: ...
mypy-0.470/typeshed/stdlib/3.4/selectors.pyi 0000644 0000000 0000000 00000007142 13023631176 017366 0 ustar root root # Stubs for selector
# See https://docs.python.org/3/library/selectors.html
from typing import Any, List, NamedTuple, Mapping, Tuple, Optional, Union
from abc import ABCMeta, abstractmethod
import socket
# Type aliases added mainly to preserve some context
#
# See https://github.com/python/typeshed/issues/482
# for details regarding how FileObject is typed.
FileObject = Union[int, socket.socket]
FileDescriptor = int
EventMask = int
EVENT_READ = ... # type: EventMask
EVENT_WRITE = ... # type: EventMask
SelectorKey = NamedTuple('SelectorKey', [
('fileobj', FileObject),
('fd', FileDescriptor),
('events', EventMask),
('data', Any)
])
class BaseSelector(metaclass=ABCMeta):
@abstractmethod
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
@abstractmethod
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def modify(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
@abstractmethod
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def close(self) -> None: ...
def get_key(self, fileobj: FileObject) -> SelectorKey: ...
@abstractmethod
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
def __enter__(self) -> BaseSelector: ...
def __exit__(self, *args: Any) -> None: ...
class SelectSelector(BaseSelector):
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
class PollSelector(BaseSelector):
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
class EpollSelector(BaseSelector):
def fileno(self) -> int: ...
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
class DevpollSelector(BaseSelector):
def fileno(self) -> int: ...
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
class KqueueSelector(BaseSelector):
def fileno(self) -> int: ...
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
class DefaultSelector(BaseSelector):
def register(self, fileobj: FileObject, events: EventMask, data: Any = None) -> SelectorKey: ...
def unregister(self, fileobj: FileObject) -> SelectorKey: ...
def select(self, timeout: Optional[int] = None) -> List[Tuple[SelectorKey, EventMask]]: ...
def get_map(self) -> Mapping[FileObject, SelectorKey]: ...
mypy-0.470/typeshed/stdlib/3.4/pathlib.pyi 0000644 0000000 0000000 00000010340 13035744274 017007 0 ustar root root # Stubs for pathlib (Python 3.4)
from typing import Any, Generator, IO, Optional, Sequence, Tuple, Type, TypeVar, Union
import os
import sys
_P = TypeVar('_P', bound='PurePath')
if sys.version_info >= (3, 6):
_PurePathBase = os.PathLike
else:
_PurePathBase = object
class PurePath(_PurePathBase):
parts = ... # type: Tuple[str, ...]
drive = ... # type: str
root = ... # type: str
anchor = ... # type: str
name = ... # type: str
suffix = ... # type: str
suffixes = ... # type: List[str]
stem = ... # type: str
if sys.version_info < (3, 5):
def __init__(self, *pathsegments: str) -> None: ...
else:
def __new__(cls: Type[_P], *args: Union[str, PurePath]) -> _P: ...
def __hash__(self) -> int: ...
def __lt__(self, other: PurePath) -> bool: ...
def __le__(self, other: PurePath) -> bool: ...
def __gt__(self, other: PurePath) -> bool: ...
def __ge__(self, other: PurePath) -> bool: ...
def __truediv__(self: _P, key: Union[str, PurePath]) -> _P: ...
def __bytes__(self) -> bytes: ...
def as_posix(self) -> str: ...
def as_uri(self) -> str: ...
def is_absolute(self) -> bool: ...
def is_reserved(self) -> bool: ...
def match(self, path_pattern: str) -> bool: ...
def relative_to(self: _P, *other: Union[str, PurePath]) -> _P: ...
def with_name(self: _P, name: str) -> _P: ...
def with_suffix(self: _P, suffix: str) -> _P: ...
def joinpath(self: _P, *other: Union[str, PurePath]) -> _P: ...
@property
def parents(self: _P) -> Sequence[_P]: ...
@property
def parent(self: _P) -> _P: ...
class PurePosixPath(PurePath): ...
class PureWindowsPath(PurePath): ...
class Path(PurePath):
@classmethod
def cwd(cls: Type[_P]) -> _P: ...
def stat(self) -> os.stat_result: ...
def chmod(self, mode: int) -> None: ...
def exists(self) -> bool: ...
def glob(self, pattern: str) -> Generator[Path, None, None]: ...
def group(self) -> str: ...
def is_dir(self) -> bool: ...
def is_file(self) -> bool: ...
def is_symlink(self) -> bool: ...
def is_socket(self) -> bool: ...
def is_fifo(self) -> bool: ...
def is_block_device(self) -> bool: ...
def is_char_device(self) -> bool: ...
def iterdir(self) -> Generator[Path, None, None]: ...
def lchmod(self, mode: int) -> None: ...
def lstat(self) -> os.stat_result: ...
if sys.version_info <= (3, 4):
def mkdir(self, mode: int = ...,
parents: bool = ...) -> None: ...
else:
def mkdir(self, mode: int = ..., parents: bool = ...,
exist_ok: bool = ...) -> None: ...
def open(self, mode: str = ..., buffering: int = ...,
encoding: Optional[str] = ..., errors: Optional[str] = ...,
newline: Optional[str] = ...) -> IO[Any]: ...
def owner(self) -> str: ...
def rename(self, target: Union[str, PurePath]) -> None: ...
def replace(self, target: Union[str, PurePath]) -> None: ...
if sys.version_info <= (3, 5):
def resolve(self: _P) -> _P: ...
else:
def resolve(self: _P, strict: bool = ...) -> _P: ...
def rglob(self, pattern: str) -> Generator[Path, None, None]: ...
def rmdir(self) -> None: ...
def symlink_to(self, target: Union[str, Path],
target_is_directory: bool = ...) -> None: ...
def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ...
def unlink(self) -> None: ...
if sys.version_info >= (3, 5):
@classmethod
def home(cls: Type[_P]) -> _P: ...
def __new__(cls: Type[_P], *args: Union[str, PurePath],
**kwargs: Any) -> _P: ...
def absolute(self: _P) -> _P: ...
def expanduser(self: _P) -> _P: ...
def read_bytes(self) -> bytes: ...
def read_text(self, encoding: Optional[str] = ...,
errors: Optional[str] = ...) -> str: ...
def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ...
def write_bytes(self, data: bytes) -> int: ...
def write_text(self, data: str, encoding: Optional[str] = ...,
errors: Optional[str] = ...) -> int: ...
class PosixPath(Path, PurePosixPath): ...
class WindowsPath(Path, PureWindowsPath): ...
mypy-0.470/typeshed/stdlib/3.4/xml/ 0000755 0000000 0000000 00000000000 13044320557 015435 5 ustar root root mypy-0.470/typeshed/stdlib/3.4/xml/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 017703 0 ustar root root mypy-0.470/typeshed/stdlib/3.4/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016541 5 ustar root root mypy-0.470/typeshed/stdlib/3.4/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 021007 0 ustar root root mypy-0.470/typeshed/stdlib/3.4/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000013733 13044257024 021502 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
import io
VERSION = ... # type: str
class ParseError(SyntaxError): ...
def iselement(element: 'Element') -> bool: ...
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class Element(Sequence['Element']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
def append(self, subelement: 'Element') -> None: ...
def clear(self) -> None: ...
def copy(self) -> 'Element': ...
def extend(self, elements: Sequence['Element']) -> None: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional['Element']: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def getchildren(self) -> List['Element']: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['Element']: ...
def insert(self, index: int, subelement: 'Element') -> None: ...
def items(self) -> ItemsView[AnyStr, AnyStr]: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator['Element', None, None]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def itertext(self) -> Generator[str, None, None]: ...
def keys(self) -> KeysView[AnyStr]: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> 'Element': ...
def remove(self, subelement: 'Element') -> None: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def __bool__(self) -> bool: ...
def __delitem__(self, index: int) -> None: ...
def __getitem__(self, index) -> 'Element': ...
def __len__(self) -> int: ...
def __setitem__(self, index: int, element: 'Element') -> None: ...
def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> Element: ...
def Comment(text: _str_or_bytes=...) -> Element: ...
def ProcessingInstruction(target: str, text: str=...) -> Element: ...
PI = ... # type: Callable[..., Element]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: Element=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: 'XMLParser'=...) -> Element: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator[Element, None, None]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[Element]: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=..., xml_declaration: Optional[bool]=..., default_namespace: str=..., method: str=..., *, short_empty_elements: bool=...) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: str, uri: str) -> None: ...
def tostring(element: Element, encoding: str=..., method: str=..., *, short_empty_elements: bool=...) -> str: ...
def tostringlist(element: Element, encoding: str=..., method: str=..., *, short_empty_elements: bool=...) -> List[str]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ...
def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
class XMLPullParser:
def __init__(self, events: Sequence[str]=..., *, _parser: 'XMLParser'=...) -> None: ...
def feed(self, data: bytes) -> None: ...
def close(self) -> None: ...
def read_events(self) -> Iterator[Tuple[str, Element]]: ...
class _IterParseIterator:
root = ... # type: Any
def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
def __next__(self) -> Tuple[str, Element]: ...
def __iter__(self) -> _IterParseIterator: ...
def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., Element]
def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], Element]=...) -> None: ...
def close(self) -> Element: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> Element: ...
def end(self, tag: AnyStr) -> Element: ...
class XMLParser:
parser = ... # type: Any
target = ... # type: TreeBuilder
# TODO-what is entity used for???
entity = ... # type: Any
version = ... # type: str
def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/3.4/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000003167 13044257024 021477 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
from .ElementTree import Element
xpath_tokenizer_re = ... # type: Pattern
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[['_SelectorContext', List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Dict[str, str]=...) -> Generator[_token, None, None]: ...
def get_parent_map(context: '_SelectorContext') -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map = ... # type: Dict[Element, Element]
root = ... # type: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar('_T')
def iterfind(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def findtext(elem: Element, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
mypy-0.470/typeshed/stdlib/3.4/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021635 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/3.4/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001372 13044257024 022162 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from .ElementTree import Element
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: Element, loader: Callable[..., Union[str, Element]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/3.4/enum.pyi 0000644 0000000 0000000 00000003143 13035744274 016333 0 ustar root root # FIXME: Stub incomplete, ommissions include:
# * the metaclass
# * _sunder_ methods with their transformations
import sys
from typing import List, Any, TypeVar, Union
class Enum:
def __new__(cls, value: Any) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def __dir__(self) -> List[str]: ...
def __format__(self, format_spec: str) -> str: ...
def __hash__(self) -> Any: ...
def __reduce_ex__(self, proto: Any) -> Any: ...
name = ... # type: str
value = ... # type: Any
class IntEnum(int, Enum):
value = ... # type: int
_T = TypeVar('_T')
def unique(enumeration: _T) -> _T: ...
if sys.version_info >= (3, 6):
_auto_null = ... # type: Any
class auto:
value = ... # type: Any
class Flag(Enum):
def __contains__(self: _T, other: _T) -> bool: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def __bool__(self) -> bool: ...
def __or__(self: _T, other: _T) -> _T: ...
def __and__(self: _T, other: _T) -> _T: ...
def __xor__(self: _T, other: _T) -> _T: ...
def __invert__(self: _T) -> _T: ...
# All `type: ignore` comments below due to IntFlag making the function signatures more permissive.
class IntFlag(int, Flag): # type: ignore
def __or__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
def __and__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
def __xor__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
__ror__ = __or__
__rand__ = __and__
__rxor__ = __xor__
mypy-0.470/typeshed/stdlib/3.5/ 0000755 0000000 0000000 00000000000 13044320557 014636 5 ustar root root mypy-0.470/typeshed/stdlib/3.5/xml/ 0000755 0000000 0000000 00000000000 13044320557 015436 5 ustar root root mypy-0.470/typeshed/stdlib/3.5/xml/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 017704 0 ustar root root mypy-0.470/typeshed/stdlib/3.5/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016542 5 ustar root root mypy-0.470/typeshed/stdlib/3.5/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 021010 0 ustar root root mypy-0.470/typeshed/stdlib/3.5/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000013733 13044257024 021503 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
import io
VERSION = ... # type: str
class ParseError(SyntaxError): ...
def iselement(element: 'Element') -> bool: ...
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class Element(Sequence['Element']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
def append(self, subelement: 'Element') -> None: ...
def clear(self) -> None: ...
def copy(self) -> 'Element': ...
def extend(self, elements: Sequence['Element']) -> None: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional['Element']: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def getchildren(self) -> List['Element']: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['Element']: ...
def insert(self, index: int, subelement: 'Element') -> None: ...
def items(self) -> ItemsView[AnyStr, AnyStr]: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator['Element', None, None]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def itertext(self) -> Generator[str, None, None]: ...
def keys(self) -> KeysView[AnyStr]: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> 'Element': ...
def remove(self, subelement: 'Element') -> None: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def __bool__(self) -> bool: ...
def __delitem__(self, index: int) -> None: ...
def __getitem__(self, index) -> 'Element': ...
def __len__(self) -> int: ...
def __setitem__(self, index: int, element: 'Element') -> None: ...
def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> Element: ...
def Comment(text: _str_or_bytes=...) -> Element: ...
def ProcessingInstruction(target: str, text: str=...) -> Element: ...
PI = ... # type: Callable[..., Element]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: Element=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: 'XMLParser'=...) -> Element: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator[Element, None, None]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[Element]: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=..., xml_declaration: Optional[bool]=..., default_namespace: str=..., method: str=..., *, short_empty_elements: bool=...) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: str, uri: str) -> None: ...
def tostring(element: Element, encoding: str=..., method: str=..., *, short_empty_elements: bool=...) -> str: ...
def tostringlist(element: Element, encoding: str=..., method: str=..., *, short_empty_elements: bool=...) -> List[str]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ...
def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
class XMLPullParser:
def __init__(self, events: Sequence[str]=..., *, _parser: 'XMLParser'=...) -> None: ...
def feed(self, data: bytes) -> None: ...
def close(self) -> None: ...
def read_events(self) -> Iterator[Tuple[str, Element]]: ...
class _IterParseIterator:
root = ... # type: Any
def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
def __next__(self) -> Tuple[str, Element]: ...
def __iter__(self) -> _IterParseIterator: ...
def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., Element]
def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], Element]=...) -> None: ...
def close(self) -> Element: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> Element: ...
def end(self, tag: AnyStr) -> Element: ...
class XMLParser:
parser = ... # type: Any
target = ... # type: TreeBuilder
# TODO-what is entity used for???
entity = ... # type: Any
version = ... # type: str
def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/3.5/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000003167 13044257024 021500 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
from .ElementTree import Element
xpath_tokenizer_re = ... # type: Pattern
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[['_SelectorContext', List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Dict[str, str]=...) -> Generator[_token, None, None]: ...
def get_parent_map(context: '_SelectorContext') -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map = ... # type: Dict[Element, Element]
root = ... # type: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar('_T')
def iterfind(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def findtext(elem: Element, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
mypy-0.470/typeshed/stdlib/3.5/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021636 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/3.5/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001372 13044257024 022163 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from .ElementTree import Element
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: Element, loader: Callable[..., Union[str, Element]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/3.2/ 0000755 0000000 0000000 00000000000 13044320557 014633 5 ustar root root mypy-0.470/typeshed/stdlib/3.2/xml/ 0000755 0000000 0000000 00000000000 13044320557 015433 5 ustar root root mypy-0.470/typeshed/stdlib/3.2/xml/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 017701 0 ustar root root mypy-0.470/typeshed/stdlib/3.2/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016537 5 ustar root root mypy-0.470/typeshed/stdlib/3.2/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 021005 0 ustar root root mypy-0.470/typeshed/stdlib/3.2/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000014146 13044257024 021477 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
import io
VERSION = ... # type: str
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class _SimpleElementPath:
def find(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> Optional['Element']: ...
def findtext(self, element: 'Element', tag: _str_or_bytes, default: _T=..., namespaces: Any=...) -> Union[str, bytes, _T]: ...
def iterfind(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> Generator['Element', None, None]: ...
def findall(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> List['Element']: ...
class ParseError(SyntaxError): ...
def iselement(element: 'Element') -> bool: ...
class Element(Sequence['Element']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
def append(self, subelement: 'Element') -> None: ...
def clear(self) -> None: ...
def copy(self) -> 'Element': ...
def extend(self, elements: Sequence['Element']) -> None: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional['Element']: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def getchildren(self) -> List['Element']: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['Element']: ...
def insert(self, index: int, subelement: 'Element') -> None: ...
def items(self) -> ItemsView[AnyStr, AnyStr]: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator['Element', None, None]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def itertext(self) -> Generator[str, None, None]: ...
def keys(self) -> KeysView[AnyStr]: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> 'Element': ...
def remove(self, subelement: 'Element') -> None: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def __bool__(self) -> bool: ...
def __delitem__(self, index: int) -> None: ...
def __getitem__(self, index) -> 'Element': ...
def __len__(self) -> int: ...
def __setitem__(self, index: int, element: 'Element') -> None: ...
def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> Element: ...
def Comment(text: _str_or_bytes=...) -> Element: ...
def ProcessingInstruction(target: str, text: str=...) -> Element: ...
PI = ... # type: Callable[..., Element]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: Element=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: 'XMLParser'=...) -> Element: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator[Element, None, None]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[Element]: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=..., xml_declaration: Optional[bool]=..., default_namespace: str=..., method: str=...) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: str, uri: str) -> None: ...
def tostring(element: Element, encoding: str=..., method: str=...) -> str: ...
def tostringlist(element: Element, encoding: str=..., method: str=...) -> List[str]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ...
def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
class _IterParseIterator:
root = ... # type: Any
def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
def __next__(self) -> Tuple[str, Element]: ...
def __iter__(self) -> _IterParseIterator: ...
def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., Element]
def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], Element]=...) -> None: ...
def close(self) -> Element: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> Element: ...
def end(self, tag: AnyStr) -> Element: ...
class XMLParser:
parser = ... # type: Any
target = ... # type: TreeBuilder
# TODO-what is entity used for???
entity = ... # type: Any
version = ... # type: str
def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/3.2/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000003167 13044257024 021475 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
from .ElementTree import Element
xpath_tokenizer_re = ... # type: Pattern
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[['_SelectorContext', List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Dict[str, str]=...) -> Generator[_token, None, None]: ...
def get_parent_map(context: '_SelectorContext') -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map = ... # type: Dict[Element, Element]
root = ... # type: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar('_T')
def iterfind(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def findtext(elem: Element, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
mypy-0.470/typeshed/stdlib/3.2/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021633 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/3.2/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001372 13044257024 022160 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from .ElementTree import Element
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: Element, loader: Callable[..., Union[str, Element]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/2/ 0000755 0000000 0000000 00000000000 13044320557 014472 5 ustar root root mypy-0.470/typeshed/stdlib/2/socket.pyi 0000644 0000000 0000000 00000021431 13035744274 016514 0 ustar root root # Stubs for socket
# Ron Murawski
# based on: http://docs.python.org/3.2/library/socket.html
# see: http://hg.python.org/cpython/file/3d0686d90f55/Lib/socket.py
# see: http://nullege.com/codes/search/socket
# adapted for Python 2.7 by Michal Pokorny
from typing import Any, Tuple, List, Optional, Union, overload
# ----- variables and constants -----
AF_UNIX = 0
AF_INET = 0
AF_INET6 = 0
SOCK_STREAM = 0
SOCK_DGRAM = 0
SOCK_RAW = 0
SOCK_RDM = 0
SOCK_SEQPACKET = 0
SOCK_CLOEXEC = 0
SOCK_NONBLOCK = 0
SOMAXCONN = 0
has_ipv6 = False
_GLOBAL_DEFAULT_TIMEOUT = ... # type: Any
SocketType = ... # type: Any
SocketIO = ... # type: Any
# the following constants are included with Python 3.2.3 (Ubuntu)
# some of the constants may be Linux-only
# all Windows/Mac-specific constants are absent
AF_APPLETALK = 0
AF_ASH = 0
AF_ATMPVC = 0
AF_ATMSVC = 0
AF_AX25 = 0
AF_BLUETOOTH = 0
AF_BRIDGE = 0
AF_DECnet = 0
AF_ECONET = 0
AF_IPX = 0
AF_IRDA = 0
AF_KEY = 0
AF_LLC = 0
AF_NETBEUI = 0
AF_NETLINK = 0
AF_NETROM = 0
AF_PACKET = 0
AF_PPPOX = 0
AF_ROSE = 0
AF_ROUTE = 0
AF_SECURITY = 0
AF_SNA = 0
AF_TIPC = 0
AF_UNSPEC = 0
AF_WANPIPE = 0
AF_X25 = 0
AI_ADDRCONFIG = 0
AI_ALL = 0
AI_CANONNAME = 0
AI_NUMERICHOST = 0
AI_NUMERICSERV = 0
AI_PASSIVE = 0
AI_V4MAPPED = 0
BDADDR_ANY = 0
BDADDR_LOCAL = 0
BTPROTO_HCI = 0
BTPROTO_L2CAP = 0
BTPROTO_RFCOMM = 0
BTPROTO_SCO = 0
CAPI = 0
EAGAIN = 0
EAI_ADDRFAMILY = 0
EAI_AGAIN = 0
EAI_BADFLAGS = 0
EAI_FAIL = 0
EAI_FAMILY = 0
EAI_MEMORY = 0
EAI_NODATA = 0
EAI_NONAME = 0
EAI_OVERFLOW = 0
EAI_SERVICE = 0
EAI_SOCKTYPE = 0
EAI_SYSTEM = 0
EBADF = 0
EINTR = 0
EWOULDBLOCK = 0
HCI_DATA_DIR = 0
HCI_FILTER = 0
HCI_TIME_STAMP = 0
INADDR_ALLHOSTS_GROUP = 0
INADDR_ANY = 0
INADDR_BROADCAST = 0
INADDR_LOOPBACK = 0
INADDR_MAX_LOCAL_GROUP = 0
INADDR_NONE = 0
INADDR_UNSPEC_GROUP = 0
IPPORT_RESERVED = 0
IPPORT_USERRESERVED = 0
IPPROTO_AH = 0
IPPROTO_DSTOPTS = 0
IPPROTO_EGP = 0
IPPROTO_ESP = 0
IPPROTO_FRAGMENT = 0
IPPROTO_GRE = 0
IPPROTO_HOPOPTS = 0
IPPROTO_ICMP = 0
IPPROTO_ICMPV6 = 0
IPPROTO_IDP = 0
IPPROTO_IGMP = 0
IPPROTO_IP = 0
IPPROTO_IPIP = 0
IPPROTO_IPV6 = 0
IPPROTO_NONE = 0
IPPROTO_PIM = 0
IPPROTO_PUP = 0
IPPROTO_RAW = 0
IPPROTO_ROUTING = 0
IPPROTO_RSVP = 0
IPPROTO_TCP = 0
IPPROTO_TP = 0
IPPROTO_UDP = 0
IPV6_CHECKSUM = 0
IPV6_DSTOPTS = 0
IPV6_HOPLIMIT = 0
IPV6_HOPOPTS = 0
IPV6_JOIN_GROUP = 0
IPV6_LEAVE_GROUP = 0
IPV6_MULTICAST_HOPS = 0
IPV6_MULTICAST_IF = 0
IPV6_MULTICAST_LOOP = 0
IPV6_NEXTHOP = 0
IPV6_PKTINFO = 0
IPV6_RECVDSTOPTS = 0
IPV6_RECVHOPLIMIT = 0
IPV6_RECVHOPOPTS = 0
IPV6_RECVPKTINFO = 0
IPV6_RECVRTHDR = 0
IPV6_RECVTCLASS = 0
IPV6_RTHDR = 0
IPV6_RTHDRDSTOPTS = 0
IPV6_RTHDR_TYPE_0 = 0
IPV6_TCLASS = 0
IPV6_UNICAST_HOPS = 0
IPV6_V6ONLY = 0
IP_ADD_MEMBERSHIP = 0
IP_DEFAULT_MULTICAST_LOOP = 0
IP_DEFAULT_MULTICAST_TTL = 0
IP_DROP_MEMBERSHIP = 0
IP_HDRINCL = 0
IP_MAX_MEMBERSHIPS = 0
IP_MULTICAST_IF = 0
IP_MULTICAST_LOOP = 0
IP_MULTICAST_TTL = 0
IP_OPTIONS = 0
IP_RECVOPTS = 0
IP_RECVRETOPTS = 0
IP_RETOPTS = 0
IP_TOS = 0
IP_TTL = 0
MSG_CTRUNC = 0
MSG_DONTROUTE = 0
MSG_DONTWAIT = 0
MSG_EOR = 0
MSG_OOB = 0
MSG_PEEK = 0
MSG_TRUNC = 0
MSG_WAITALL = 0
NETLINK_DNRTMSG = 0
NETLINK_FIREWALL = 0
NETLINK_IP6_FW = 0
NETLINK_NFLOG = 0
NETLINK_ROUTE = 0
NETLINK_USERSOCK = 0
NETLINK_XFRM = 0
NI_DGRAM = 0
NI_MAXHOST = 0
NI_MAXSERV = 0
NI_NAMEREQD = 0
NI_NOFQDN = 0
NI_NUMERICHOST = 0
NI_NUMERICSERV = 0
PACKET_BROADCAST = 0
PACKET_FASTROUTE = 0
PACKET_HOST = 0
PACKET_LOOPBACK = 0
PACKET_MULTICAST = 0
PACKET_OTHERHOST = 0
PACKET_OUTGOING = 0
PF_PACKET = 0
SHUT_RD = 0
SHUT_RDWR = 0
SHUT_WR = 0
SOL_HCI = 0
SOL_IP = 0
SOL_SOCKET = 0
SOL_TCP = 0
SOL_TIPC = 0
SOL_UDP = 0
SO_ACCEPTCONN = 0
SO_BROADCAST = 0
SO_DEBUG = 0
SO_DONTROUTE = 0
SO_ERROR = 0
SO_KEEPALIVE = 0
SO_LINGER = 0
SO_OOBINLINE = 0
SO_RCVBUF = 0
SO_RCVLOWAT = 0
SO_RCVTIMEO = 0
SO_REUSEADDR = 0
SO_SNDBUF = 0
SO_SNDLOWAT = 0
SO_SNDTIMEO = 0
SO_TYPE = 0
TCP_CORK = 0
TCP_DEFER_ACCEPT = 0
TCP_INFO = 0
TCP_KEEPCNT = 0
TCP_KEEPIDLE = 0
TCP_KEEPINTVL = 0
TCP_LINGER2 = 0
TCP_MAXSEG = 0
TCP_NODELAY = 0
TCP_QUICKACK = 0
TCP_SYNCNT = 0
TCP_WINDOW_CLAMP = 0
TIPC_ADDR_ID = 0
TIPC_ADDR_NAME = 0
TIPC_ADDR_NAMESEQ = 0
TIPC_CFG_SRV = 0
TIPC_CLUSTER_SCOPE = 0
TIPC_CONN_TIMEOUT = 0
TIPC_CRITICAL_IMPORTANCE = 0
TIPC_DEST_DROPPABLE = 0
TIPC_HIGH_IMPORTANCE = 0
TIPC_IMPORTANCE = 0
TIPC_LOW_IMPORTANCE = 0
TIPC_MEDIUM_IMPORTANCE = 0
TIPC_NODE_SCOPE = 0
TIPC_PUBLISHED = 0
TIPC_SRC_DROPPABLE = 0
TIPC_SUBSCR_TIMEOUT = 0
TIPC_SUB_CANCEL = 0
TIPC_SUB_PORTS = 0
TIPC_SUB_SERVICE = 0
TIPC_TOP_SRV = 0
TIPC_WAIT_FOREVER = 0
TIPC_WITHDRAWN = 0
TIPC_ZONE_SCOPE = 0
# ----- exceptions -----
class error(IOError):
...
class herror(error):
def __init__(self, herror: int, string: str) -> None: ...
class gaierror(error):
def __init__(self, error: int, string: str) -> None: ...
class timeout(error):
...
# Addresses can be either tuples of varying lengths (AF_INET, AF_INET6,
# AF_NETLINK, AF_TIPC) or strings (AF_UNIX).
# TODO AF_PACKET and AF_BLUETOOTH address objects
# ----- classes -----
class socket:
family = 0
type = 0
proto = 0
def __init__(self, family: int = ..., type: int = ...,
proto: int = ...) -> None: ...
# --- methods ---
# second tuple item is an address
def accept(self) -> Tuple['socket', Any]: ...
def bind(self, address: Union[tuple, str]) -> None: ...
def close(self) -> None: ...
def connect(self, address: Union[tuple, str]) -> None: ...
def connect_ex(self, address: Union[tuple, str]) -> int: ...
def detach(self) -> int: ...
def fileno(self) -> int: ...
# return value is an address
def getpeername(self) -> Any: ...
def getsockname(self) -> Any: ...
@overload
def getsockopt(self, level: int, optname: int) -> int: ...
@overload
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
def gettimeout(self) -> float: ...
def ioctl(self, control: object,
option: Tuple[int, int, int]) -> None: ...
def listen(self, backlog: int) -> None: ...
# TODO the return value may be BinaryIO or TextIO, depending on mode
def makefile(self, mode: str = ..., buffering: int = ...,
encoding: str = ..., errors: str = ...,
newline: str = ...) -> Any:
...
def recv(self, bufsize: int, flags: int = ...) -> str: ...
# return type is an address
def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ...
def recvfrom_into(self, buffer: str, nbytes: int,
flags: int = ...) -> Any: ...
def recv_into(self, buffer: str, nbytes: int,
flags: int = ...) -> Any: ...
def send(self, data: str, flags: int = ...) -> int: ...
def sendall(self, data: str, flags: int = ...) -> None:
... # return type: None on success
def sendto(self, data: str, address: Union[tuple, str], flags: int = ...) -> int: ...
def setblocking(self, flag: bool) -> None: ...
def settimeout(self, value: Union[float, None]) -> None: ...
def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ...
def shutdown(self, how: int) -> None: ...
# ----- functions -----
def create_connection(address: Tuple[str, int],
timeout: float = ...,
source_address: Tuple[str, int] = ...) -> socket: ...
# the 5th tuple item is an address
def getaddrinfo(
host: Optional[str], port: Union[str, int, None], family: int = ...,
socktype: int = ..., proto: int = ..., flags: int = ...) -> List[Tuple[int, int, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]:
...
def getfqdn(name: str = ...) -> str: ...
def gethostbyname(hostname: str) -> str: ...
def gethostbyname_ex(hostname: str) -> Tuple[str, List[str], List[str]]: ...
def gethostname() -> str: ...
def gethostbyaddr(ip_address: str) -> Tuple[str, List[str], List[str]]: ...
def getnameinfo(sockaddr: tuple, flags: int) -> Tuple[str, int]: ...
def getprotobyname(protocolname: str) -> int: ...
def getservbyname(servicename: str, protocolname: str = ...) -> int: ...
def getservbyport(port: int, protocolname: str = ...) -> str: ...
def socketpair(family: int = ...,
type: int = ...,
proto: int = ...) -> Tuple[socket, socket]: ...
def fromfd(fd: int, family: int, type: int, proto: int = ...) -> socket: ...
def ntohl(x: int) -> int: ... # param & ret val are 32-bit ints
def ntohs(x: int) -> int: ... # param & ret val are 16-bit ints
def htonl(x: int) -> int: ... # param & ret val are 32-bit ints
def htons(x: int) -> int: ... # param & ret val are 16-bit ints
def inet_aton(ip_string: str) -> str: ... # ret val 4 bytes in length
def inet_ntoa(packed_ip: str) -> str: ...
def inet_pton(address_family: int, ip_string: str) -> str: ...
def inet_ntop(address_family: int, packed_ip: str) -> str: ...
def getdefaulttimeout() -> Union[float, None]: ...
def setdefaulttimeout(timeout: float) -> None: ...
mypy-0.470/typeshed/stdlib/2/uuid.pyi 0000644 0000000 0000000 00000002411 13035744274 016167 0 ustar root root from typing import NamedTuple, Any, Tuple
_int_type = int
class _UUIDFields(NamedTuple('_UUIDFields',
[('time_low', int), ('time_mid', int), ('time_hi_version', int), ('clock_seq_hi_variant', int), ('clock_seq_low', int), ('node', int)])):
time = ... # type: int
clock_seq = ... # type: int
class UUID:
def __init__(self, hex: str = ..., bytes: str = ..., bytes_le: str = ...,
fields: Tuple[int, int, int, int, int, int] = ..., int: int = ..., version: Any = ...) -> None: ...
bytes = ... # type: str
bytes_le = ... # type: str
fields = ... # type: _UUIDFields
hex = ... # type: str
int = ... # type: _int_type
urn = ... # type: str
variant = ... # type: _int_type
version = ... # type: _int_type
RESERVED_NCS = ... # type: int
RFC_4122 = ... # type: int
RESERVED_MICROSOFT = ... # type: int
RESERVED_FUTURE = ... # type: int
def getnode() -> int: ...
def uuid1(node: int = ..., clock_seq: int = ...) -> UUID: ...
def uuid3(namespace: UUID, name: str) -> UUID: ...
def uuid4() -> UUID: ...
def uuid5(namespace: UUID, name: str) -> UUID: ...
NAMESPACE_DNS = ... # type: UUID
NAMESPACE_URL = ... # type: UUID
NAMESPACE_OID = ... # type: UUID
NAMESPACE_X500 = ... # type: UUID
mypy-0.470/typeshed/stdlib/2/gc.pyi 0000644 0000000 0000000 00000001603 13035744274 015614 0 ustar root root # Stubs for gc
from typing import Any, List, Tuple
def enable() -> None: ...
def disable() -> None: ...
def isenabled() -> bool: ...
def collect(generation: int = ...) -> int: ...
def set_debug(flags: int) -> None: ...
def get_debug() -> int: ...
def get_objects() -> List[Any]: ...
def set_threshold(threshold0: int, threshold1: int = ...,
threshold2: int = ...) -> None: ...
def get_count() -> Tuple[int, int, int]: ...
def get_threshold() -> Tuple[int, int, int]: ...
def get_referrers(*objs: Any) -> List[Any]: ...
def get_referents(*objs: Any) -> List[Any]: ...
def is_tracked(obj: Any) -> bool: ...
garbage = ... # type: List[Any]
DEBUG_STATS = ... # type: int
DEBUG_COLLECTABLE = ... # type: int
DEBUG_UNCOLLECTABLE = ... # type: int
DEBUG_INSTANCES = ... # type: int
DEBUG_OBJECTS = ... # type: int
DEBUG_SAVEALL = ... # type: int
DEBUG_LEAK = ... # type: int
mypy-0.470/typeshed/stdlib/2/pwd.pyi 0000644 0000000 0000000 00000001007 13035744274 016013 0 ustar root root from typing import List
class struct_passwd(tuple):
n_fields = ... # type: int
n_sequence_fields = ... # type: int
n_unnamed_fields = ... # type: int
pw_dir = ... # type: str
pw_name = ... # type: str
pw_passwd = ... # type: str
pw_shell = ... # type: str
pw_gecos = ... # type: str
pw_gid = ... # type: int
pw_uid = ... # type: int
def getpwall() -> List[struct_passwd]: ...
def getpwnam(name: str) -> struct_passwd: ...
def getpwuid(uid: int) -> struct_passwd: ...
mypy-0.470/typeshed/stdlib/2/atexit.pyi 0000644 0000000 0000000 00000000165 13023631176 016514 0 ustar root root from typing import TypeVar, Any
_FT = TypeVar('_FT')
def register(func: _FT, *args: Any, **kargs: Any) -> _FT: ...
mypy-0.470/typeshed/stdlib/2/StringIO.pyi 0000644 0000000 0000000 00000002301 13035744274 016715 0 ustar root root # Stubs for StringIO (Python 2)
from typing import Any, IO, AnyStr, Iterator, Iterable, Generic, List
class StringIO(IO[AnyStr], Generic[AnyStr]):
closed = ... # type: bool
softspace = ... # type: int
len = ... # type: int
name = ... # type: str
def __init__(self, buf: AnyStr = ...) -> None: ...
def __iter__(self) -> Iterator[AnyStr]: ...
def next(self) -> AnyStr: ...
def close(self) -> None: ...
def isatty(self) -> bool: ...
def seek(self, pos: int, mode: int = ...) -> None: ...
def tell(self) -> int: ...
def read(self, n: int = ...) -> AnyStr: ...
def readline(self, length: int = ...) -> AnyStr: ...
def readlines(self, sizehint: int = ...) -> List[AnyStr]: ...
def truncate(self, size: int = ...) -> int: ...
def write(self, s: AnyStr) -> None: ...
def writelines(self, iterable: Iterable[AnyStr]) -> None: ...
def flush(self) -> None: ...
def getvalue(self) -> AnyStr: ...
def __enter__(self) -> Any: ...
def __exit__(self, type: Any, value: Any, traceback: Any) -> Any: ...
def fileno(self) -> int: ...
def readable(self) -> bool: ...
def seekable(self) -> bool: ...
def writable(self) -> bool: ...
mypy-0.470/typeshed/stdlib/2/resource.pyi 0000644 0000000 0000000 00000002407 13035744274 017055 0 ustar root root from typing import Tuple, NamedTuple
class error(Exception): ...
RLIM_INFINITY = ... # type: int
def getrlimit(resource: int) -> Tuple[int, int]: ...
def setrlimit(resource: int, limits: Tuple[int, int]) -> None: ...
RLIMIT_CORE = ... # type: int
RLIMIT_CPU = ... # type: int
RLIMIT_FSIZE = ... # type: int
RLIMIT_DATA = ... # type: int
RLIMIT_STACK = ... # type: int
RLIMIT_RSS = ... # type: int
RLIMIT_NPROC = ... # type: int
RLIMIT_NOFILE = ... # type: int
RLIMIT_OFILE = ... # type: int
RLIMIT_MEMLOCK = ... # type: int
RLIMIT_VMEM = ... # type: int
RLIMIT_AS = ... # type: int
_RUsage = NamedTuple('_RUsage', [('ru_utime', float), ('ru_stime', float), ('ru_maxrss', int),
('ru_ixrss', int), ('ru_idrss', int), ('ru_isrss', int),
('ru_minflt', int), ('ru_majflt', int), ('ru_nswap', int),
('ru_inblock', int), ('ru_oublock', int), ('ru_msgsnd', int),
('ru_msgrcv', int), ('ru_nsignals', int), ('ru_nvcsw', int),
('ru_nivcsw', int)])
def getrusage(who: int) -> _RUsage: ...
def getpagesize() -> int: ...
RUSAGE_SELF = ... # type: int
RUSAGE_CHILDREN = ... # type: int
RUSAGE_BOTH = ... # type: int
mypy-0.470/typeshed/stdlib/2/encodings/ 0000755 0000000 0000000 00000000000 13044320557 016443 5 ustar root root mypy-0.470/typeshed/stdlib/2/encodings/__init__.pyi 0000644 0000000 0000000 00000000136 13023631176 020724 0 ustar root root import codecs
import typing
def search_function(encoding: str) -> codecs.CodecInfo:
...
mypy-0.470/typeshed/stdlib/2/encodings/utf_8.pyi 0000644 0000000 0000000 00000000626 13023631176 020216 0 ustar root root import codecs
class IncrementalEncoder(codecs.IncrementalEncoder):
pass
class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
pass
class StreamWriter(codecs.StreamWriter):
pass
class StreamReader(codecs.StreamReader):
pass
def getregentry() -> codecs.CodecInfo: pass
def encode(input: str, errors: str = ...) -> bytes: pass
def decode(input: bytes, errors: str = ...) -> str: pass
mypy-0.470/typeshed/stdlib/2/_collections.pyi 0000644 0000000 0000000 00000003017 13023631176 017672 0 ustar root root """Stub file for the '_collections' module."""
from typing import Any, Generic, Iterator, TypeVar, Optional, Union
class defaultdict(dict):
default_factory = ... # type: None
def __init__(self, default: Any = ..., init: Any = ...) -> None: ...
def __missing__(self, key) -> Any:
raise KeyError()
def __copy__(self) -> "defaultdict": ...
def copy(self) -> "defaultdict": ...
_T = TypeVar('_T')
_T2 = TypeVar('_T2')
class deque(Generic[_T]):
maxlen = ... # type: Optional[int]
def __init__(self, iterable: Iterator[_T] = ..., maxlen: int = ...) -> None: ...
def append(self, x: _T) -> None: ...
def appendleft(self, x: _T) -> None: ...
def clear(self) -> None: ...
def count(self, x: Any) -> int: ...
def extend(self, iterable: Iterator[_T]) -> None: ...
def extendleft(self, iterable: Iterator[_T]) -> None: ...
def pop(self) -> _T:
raise IndexError()
def popleft(self) -> _T:
raise IndexError()
def remove(self, value: _T) -> None:
raise IndexError()
def reverse(self) -> None: ...
def rotate(self, n: int = ...) -> None: ...
def __contains__(self, o: Any) -> bool: ...
def __copy__(self) -> "deque[_T]": ...
def __getitem__(self, i: int) -> _T:
raise IndexError()
def __iadd__(self, other: "deque[_T2]") -> "deque[Union[_T, _T2]]": ...
def __iter__(self) -> Iterator[_T]: ...
def __len__(self) -> int: ...
def __reversed__(self) -> Iterator[_T]: ...
def __setitem__(self, i: int, x: _T) -> None: ...
mypy-0.470/typeshed/stdlib/2/doctest.pyi 0000644 0000000 0000000 00000000342 13023631176 016660 0 ustar root root # Stubs for doctest
# NOTE: These are incomplete!
from typing import Any, Tuple
# TODO arguments missing
def testmod(m: Any = ..., name: str = ..., globs: Any = ...,
verbose: bool = ...) -> Tuple[int, int]: ...
mypy-0.470/typeshed/stdlib/2/BaseHTTPServer.pyi 0000644 0000000 0000000 00000003766 13023631176 017771 0 ustar root root # Stubs for BaseHTTPServer (Python 2.7)
from typing import Any, BinaryIO, Mapping, Optional, Tuple, Union
import SocketServer
import mimetools
class HTTPServer(SocketServer.TCPServer):
server_name = ... # type: str
server_port = ... # type: int
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type) -> None: ...
class BaseHTTPRequestHandler:
client_address = ... # type: Tuple[str, int]
server = ... # type: SocketServer.BaseServer
close_connection = ... # type: bool
command = ... # type: str
path = ... # type: str
request_version = ... # type: str
headers = ... # type: mimetools.Message
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
server_version = ... # type: str
sys_version = ... # type: str
error_message_format = ... # type: str
error_content_type = ... # type: str
protocol_version = ... # type: str
MessageClass = ... # type: type
responses = ... # type: Mapping[int, Tuple[str, str]]
def __init__(self, request: bytes, client_address: Tuple[str, int],
server: SocketServer.BaseServer) -> None: ...
def handle(self) -> None: ...
def handle_one_request(self) -> None: ...
def send_error(self, code: int, message: Optional[str] = ...) -> None: ...
def send_response(self, code: int,
message: Optional[str] = ...) -> None: ...
def send_header(self, keyword: str, value: str) -> None: ...
def end_headers(self) -> None: ...
def flush_headers(self) -> None: ...
def log_request(self, code: Union[int, str] = ...,
size: Union[int, str] = ...) -> None: ...
def log_error(self, format: str, *args: Any) -> None: ...
def log_message(self, format: str, *args: Any) -> None: ...
def version_string(self) -> str: ...
def date_time_string(self, timestamp: Optional[int] = ...) -> str: ...
def log_date_time_string(self) -> str: ...
def address_string(self) -> str: ...
mypy-0.470/typeshed/stdlib/2/posixpath.pyi 0000644 0000000 0000000 00000002466 13035744274 017252 0 ustar root root # Stubs for posixpath (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, List
from genericpath import * # noqa: F403
curdir = ... # type: Any
pardir = ... # type: Any
extsep = ... # type: Any
sep = ... # type: Any
pathsep = ... # type: Any
defpath = ... # type: Any
altsep = ... # type: Any
devnull = ... # type: Any
def normcase(s): ...
def isabs(s): ...
def join(a, *p): ...
def split(p): ...
def splitext(p): ...
def splitdrive(p): ...
def basename(p): ...
def dirname(p): ...
def islink(path): ...
def lexists(path): ...
def samefile(f1, f2): ...
def sameopenfile(fp1, fp2): ...
def samestat(s1, s2): ...
def ismount(path): ...
def walk(top, func, arg): ...
def expanduser(path): ...
def expandvars(path): ...
def normpath(path): ...
def abspath(path): ...
def realpath(filename): ...
supports_unicode_filenames = ... # type: Any
def relpath(path, start=...): ...
# posixpath imports these from genericpath.py:
def commonprefix(list: List[AnyStr]) -> AnyStr: ...
def exists(path: unicode) -> bool: ...
def getatime(path: unicode) -> float: ...
def getmtime(path: unicode) -> float: ...
def getctime(path: unicode) -> float: ...
def getsize(path: unicode) -> int: ...
def isfile(path: unicode) -> bool: ...
def isdir(path: unicode) -> bool: ...
mypy-0.470/typeshed/stdlib/2/getopt.pyi 0000644 0000000 0000000 00000001107 13035744274 016524 0 ustar root root from typing import List, Tuple
class GetoptError(Exception):
opt = ... # type: str
msg = ... # type: str
def __init__(self, msg: str, opt: str=...) -> None: ...
def __str__(self) -> str: ...
error = GetoptError
def getopt(args: List[str], shortopts: str,
longopts: List[str]=...) -> Tuple[List[Tuple[str, str]],
List[str]]: ...
def gnu_getopt(args: List[str], shortopts: str,
longopts: List[str]=...) -> Tuple[List[Tuple[str, str]],
List[str]]: ...
mypy-0.470/typeshed/stdlib/2/shlex.pyi 0000644 0000000 0000000 00000002047 13035744274 016351 0 ustar root root from typing import Optional, List, Any, IO
def split(s: Optional[str], comments: bool = ..., posix: bool = ...) -> List[str]: ...
class shlex:
def __init__(self, instream: IO[Any] = ..., infile: IO[Any] = ..., posix: bool = ...) -> None: ...
def get_token(self) -> Optional[str]: ...
def push_token(self, _str: str) -> None: ...
def read_token(self) -> str: ...
def sourcehook(self, filename: str) -> None: ...
def push_source(self, stream: IO[Any], filename: str = ...) -> None: ...
def pop_source(self) -> IO[Any]: ...
def error_leader(self, file: str = ..., line: int = ...) -> str: ...
commenters = ... # type: str
wordchars = ... # type: str
whitespace = ... # type: str
escape = ... # type: str
quotes = ... # type: str
escapedquotes = ... # type: str
whitespace_split = ... # type: bool
infile = ... # type: IO[Any]
source = ... # type: Optional[str]
debug = ... # type: int
lineno = ... # type: int
token = ... # type: Any
eof = ... # type: Optional[str]
mypy-0.470/typeshed/stdlib/2/heapq.pyi 0000644 0000000 0000000 00000001134 13023631176 016311 0 ustar root root from typing import TypeVar, List, Iterable, Any, Callable
_T = TypeVar('_T')
def cmp_lt(x, y) -> bool: ...
def heappush(heap: List[_T], item: _T) -> None: ...
def heappop(heap: List[_T]) -> _T:
raise IndexError() # if heap is empty
def heappushpop(heap: List[_T], item: _T) -> _T: ...
def heapify(x: List[_T]) -> None: ...
def heapreplace(heap: List[_T], item: _T) -> _T:
raise IndexError() # if heap is empty
def merge(*iterables: Iterable[_T]) -> Iterable[_T]: ...
def nlargest(n: int, iterable: Iterable[_T]) -> List[_T]: ...
def nsmallest(n: int, iterable: Iterable[_T]) -> List[_T]: ...
mypy-0.470/typeshed/stdlib/2/SocketServer.pyi 0000644 0000000 0000000 00000006754 13023631176 017647 0 ustar root root # Stubs for socketserver
from typing import Any, BinaryIO, Optional, Tuple
from socket import SocketType
import sys
import types
class BaseServer:
address_family = ... # type: int
RequestHandlerClass = ... # type: type
server_address = ... # type: Tuple[str, int]
socket = ... # type: SocketType
allow_reuse_address = ... # type: bool
request_queue_size = ... # type: int
socket_type = ... # type: int
timeout = ... # type: Optional[float]
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type) -> None: ...
def fileno(self) -> int: ...
def handle_request(self) -> None: ...
def serve_forever(self, poll_interval: float = ...) -> None: ...
def shutdown(self) -> None: ...
def server_close(self) -> None: ...
def finish_request(self) -> None: ...
def get_request(self) -> None: ...
def handle_error(self, request: bytes,
client_address: Tuple[str, int]) -> None: ...
def handle_timeout(self) -> None: ...
def process_request(self, request: bytes,
client_address: Tuple[str, int]) -> None: ...
def server_activate(self) -> None: ...
def server_bind(self) -> None: ...
def verify_request(self, request: bytes,
client_address: Tuple[str, int]) -> bool: ...
if sys.version_info >= (3, 6):
def __enter__(self) -> 'BaseServer': ...
def __exit__(self, exc_type: Optional[type],
exc_val: Optional[Exception],
exc_tb: Optional[types.TracebackType]) -> bool: ...
if sys.version_info >= (3, 3):
def service_actions(self) -> None: ...
class TCPServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UDPServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UnixStreamServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UnixDatagramServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class ForkingMixIn: ...
class ThreadingMixIn: ...
class ForkingTCPServer(ForkingMixIn, TCPServer): ...
class ForkingUDPServer(ForkingMixIn, UDPServer): ...
class ThreadingTCPServer(ThreadingMixIn, TCPServer): ...
class ThreadingUDPServer(ThreadingMixIn, UDPServer): ...
class BaseRequestHandler:
# Those are technically of types, respectively:
# * Union[SocketType, Tuple[bytes, SocketType]]
# * Union[Tuple[str, int], str]
# But there are some concerns that having unions here would cause
# too much inconvenience to people using it (see
# https://github.com/python/typeshed/pull/384#issuecomment-234649696)
request = ... # type: Any
client_address = ... # type: Any
server = ... # type: BaseServer
def setup(self) -> None: ...
def handle(self) -> None: ...
def finish(self) -> None: ...
class StreamRequestHandler(BaseRequestHandler):
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
class DatagramRequestHandler(BaseRequestHandler):
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
mypy-0.470/typeshed/stdlib/2/_sha512.pyi 0000644 0000000 0000000 00000001354 13023631176 016361 0 ustar root root from typing import Optional
class sha384(object):
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
digestsize = ... # type: int
def __init__(self, init: Optional[str]) -> None: ...
def copy(self) -> "sha384": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
class sha512(object):
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
digestsize = ... # type: int
def __init__(self, init: Optional[str]) -> None: ...
def copy(self) -> "sha512": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
mypy-0.470/typeshed/stdlib/2/xxsubtype.pyi 0000644 0000000 0000000 00000000765 13035744274 017306 0 ustar root root """Stub file for the 'xxsubtype' module."""
from typing import Any
def bench(obj: Any, name: str, n: int = ...) -> float: ...
class spamdict(dict):
state = ... # type: int
def getstate(self) -> int: ...
def setstate(self, a: int) -> None: ...
class spamlist(list):
state = ... # type: int
def getstate(self) -> int: ...
def setstate(self, a: int) -> None: ...
def classmeth(self, *args, **kwargs) -> tuple: ...
def staticmeth(self, *args, **kwargs) -> tuple: ...
mypy-0.470/typeshed/stdlib/2/UserDict.pyi 0000644 0000000 0000000 00000002642 13044257024 016741 0 ustar root root from typing import (Any, Container, Dict, Generic, Iterable, Iterator, List,
Mapping, Sized, Tuple, TypeVar, overload)
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
class UserDict(Dict[_KT, _VT], Generic[_KT, _VT]):
data = ... # type: Mapping[_KT, _VT]
def __init__(self, initialdata: Mapping[_KT, _VT] = ...) -> None: ...
# TODO: __iter__ is not available for UserDict
class IterableUserDict(UserDict[_KT, _VT], Generic[_KT, _VT]):
...
class DictMixin(Sized, Iterable[_KT], Container[_KT], Generic[_KT, _VT]):
def has_key(self, key: _KT) -> bool: ...
# From typing.Mapping[_KT, _VT]
# (can't inherit because of keys())
def get(self, k: _KT, default: _VT = ...) -> _VT: ...
def values(self) -> List[_VT]: ...
def items(self) -> List[Tuple[_KT, _VT]]: ...
def iterkeys(self) -> Iterator[_KT]: ...
def itervalues(self) -> Iterator[_VT]: ...
def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
def __contains__(self, o: Any) -> bool: ...
# From typing.MutableMapping[_KT, _VT]
def clear(self) -> None: ...
def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
mypy-0.470/typeshed/stdlib/2/urllib.pyi 0000644 0000000 0000000 00000011635 13035744274 016522 0 ustar root root # Stubs for urllib (Python 2)
# NOTE: This dynamically typed stub was originally automatically generated by stubgen.
from typing import Any, Mapping, Union, Tuple, Sequence, IO
def url2pathname(pathname: str) -> str: ...
def pathname2url(pathname: str) -> str: ...
def urlopen(url: str, data=..., proxies: Mapping[str, str] = ..., context=...) -> IO[Any]: ...
def urlretrieve(url, filename=..., reporthook=..., data=..., context=...): ...
def urlcleanup() -> None: ...
class ContentTooShortError(IOError):
content = ... # type: Any
def __init__(self, message, content) -> None: ...
class URLopener:
version = ... # type: Any
proxies = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
context = ... # type: Any
addheaders = ... # type: Any
tempcache = ... # type: Any
ftpcache = ... # type: Any
def __init__(self, proxies: Mapping[str, str] = ..., context=..., **x509) -> None: ...
def __del__(self): ...
def close(self): ...
def cleanup(self): ...
def addheader(self, *args): ...
type = ... # type: Any
def open(self, fullurl: str, data=...): ...
def open_unknown(self, fullurl, data=...): ...
def open_unknown_proxy(self, proxy, fullurl, data=...): ...
def retrieve(self, url, filename=..., reporthook=..., data=...): ...
def open_http(self, url, data=...): ...
def http_error(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_default(self, url, fp, errcode, errmsg, headers): ...
def open_https(self, url, data=...): ...
def open_file(self, url): ...
def open_local_file(self, url): ...
def open_ftp(self, url): ...
def open_data(self, url, data=...): ...
class FancyURLopener(URLopener):
auth_cache = ... # type: Any
tries = ... # type: Any
maxtries = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def http_error_default(self, url, fp, errcode, errmsg, headers): ...
def http_error_302(self, url, fp, errcode, errmsg, headers, data=...): ...
def redirect_internal(self, url, fp, errcode, errmsg, headers, data): ...
def http_error_301(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_303(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_307(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_401(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_407(self, url, fp, errcode, errmsg, headers, data=...): ...
def retry_proxy_http_basic_auth(self, url, realm, data=...): ...
def retry_proxy_https_basic_auth(self, url, realm, data=...): ...
def retry_http_basic_auth(self, url, realm, data=...): ...
def retry_https_basic_auth(self, url, realm, data=...): ...
def get_user_passwd(self, host, realm, clear_cache=...): ...
def prompt_user_passwd(self, host, realm): ...
class ftpwrapper:
user = ... # type: Any
passwd = ... # type: Any
host = ... # type: Any
port = ... # type: Any
dirs = ... # type: Any
timeout = ... # type: Any
refcount = ... # type: Any
keepalive = ... # type: Any
def __init__(self, user, passwd, host, port, dirs, timeout=..., persistent=...) -> None: ...
busy = ... # type: Any
ftp = ... # type: Any
def init(self): ...
def retrfile(self, file, type): ...
def endtransfer(self): ...
def close(self): ...
def file_close(self): ...
def real_close(self): ...
class addbase:
fp = ... # type: Any
read = ... # type: Any
readline = ... # type: Any
readlines = ... # type: Any
fileno = ... # type: Any
__iter__ = ... # type: Any
next = ... # type: Any
def __init__(self, fp) -> None: ...
def close(self): ...
class addclosehook(addbase):
closehook = ... # type: Any
hookargs = ... # type: Any
def __init__(self, fp, closehook, *hookargs) -> None: ...
def close(self): ...
class addinfo(addbase):
headers = ... # type: Any
def __init__(self, fp, headers) -> None: ...
def info(self): ...
class addinfourl(addbase):
headers = ... # type: Any
url = ... # type: Any
code = ... # type: Any
def __init__(self, fp, headers, url, code=...) -> None: ...
def info(self): ...
def getcode(self): ...
def geturl(self): ...
def unwrap(url): ...
def splittype(url): ...
def splithost(url): ...
def splituser(host): ...
def splitpasswd(user): ...
def splitport(host): ...
def splitnport(host, defport=...): ...
def splitquery(url): ...
def splittag(url): ...
def splitattr(url): ...
def splitvalue(attr): ...
def unquote(s: str) -> str: ...
def unquote_plus(s: str) -> str: ...
def quote(s: str, safe=...) -> str: ...
def quote_plus(s: str, safe=...) -> str: ...
def urlencode(query: Union[Sequence[Tuple[Any, Any]], Mapping[Any, Any]], doseq=...) -> str: ...
def getproxies() -> Mapping[str, str]: ...
def proxy_bypass(host): ...
# Names in __all__ with no definition:
# basejoin
mypy-0.470/typeshed/stdlib/2/posix.pyi 0000644 0000000 0000000 00000016436 13035744274 016377 0 ustar root root from typing import List, Mapping, Tuple, Union, Sequence, IO, Optional, TypeVar
error = OSError
confstr_names = ... # type: Dict[str, int]
environ = ... # type: Dict[str, str]
pathconf_names = ... # type: Dict[str, int]
sysconf_names = ... # type: Dict[str, int]
EX_CANTCREAT = ... # type: int
EX_CONFIG = ... # type: int
EX_DATAERR = ... # type: int
EX_IOERR = ... # type: int
EX_NOHOST = ... # type: int
EX_NOINPUT = ... # type: int
EX_NOPERM = ... # type: int
EX_NOUSER = ... # type: int
EX_OK = ... # type: int
EX_OSERR = ... # type: int
EX_OSFILE = ... # type: int
EX_PROTOCOL = ... # type: int
EX_SOFTWARE = ... # type: int
EX_TEMPFAIL = ... # type: int
EX_UNAVAILABLE = ... # type: int
EX_USAGE = ... # type: int
F_OK = ... # type: int
NGROUPS_MAX = ... # type: int
O_APPEND = ... # type: int
O_ASYNC = ... # type: int
O_CREAT = ... # type: int
O_DIRECT = ... # type: int
O_DIRECTORY = ... # type: int
O_DSYNC = ... # type: int
O_EXCL = ... # type: int
O_LARGEFILE = ... # type: int
O_NDELAY = ... # type: int
O_NOATIME = ... # type: int
O_NOCTTY = ... # type: int
O_NOFOLLOW = ... # type: int
O_NONBLOCK = ... # type: int
O_RDONLY = ... # type: int
O_RDWR = ... # type: int
O_RSYNC = ... # type: int
O_SYNC = ... # type: int
O_TRUNC = ... # type: int
O_WRONLY = ... # type: int
R_OK = ... # type: int
TMP_MAX = ... # type: int
WCONTINUED = ... # type: int
WNOHANG = ... # type: int
WUNTRACED = ... # type: int
W_OK = ... # type: int
X_OK = ... # type: int
def WCOREDUMP(status: int) -> bool: ...
def WEXITSTATUS(status: int) -> bool: ...
def WIFCONTINUED(status: int) -> bool: ...
def WIFEXITED(status: int) -> bool: ...
def WIFSIGNALED(status: int) -> bool: ...
def WIFSTOPPED(status: int) -> bool: ...
def WSTOPSIG(status: int) -> bool: ...
def WTERMSIG(status: int) -> bool: ...
class stat_result(object):
n_fields = ... # type: int
n_sequence_fields = ... # type: int
n_unnamed_fields = ... # type: int
st_mode = ... # type: int
st_ino = ... # type: int
st_dev = ... # type: int
st_nlink = ... # type: int
st_uid = ... # type: int
st_gid = ... # type: int
st_size = ... # type: int
st_atime = ... # type: int
st_mtime = ... # type: int
st_ctime = ... # type: int
class statvfs_result(object):
n_fields = ... # type: int
n_sequence_fields = ... # type: int
n_unnamed_fields = ... # type: int
f_bsize = ... # type: int
f_frsize = ... # type: int
f_blocks = ... # type: int
f_bfree = ... # type: int
f_bavail = ... # type: int
f_files = ... # type: int
f_ffree = ... # type: int
f_favail = ... # type: int
f_flag = ... # type: int
f_namemax = ... # type: int
def _exit(status: int) -> None: ...
def abort() -> None: ...
def access(path: unicode, mode: int) -> bool: ...
def chdir(path: unicode) -> None: ...
def chmod(path: unicode, mode: int) -> None: ...
def chown(path: unicode, uid: int, gid: int) -> None: ...
def chroot(path: unicode) -> None: ...
def close(fd: int) -> None: ...
def closerange(fd_low: int, fd_high: int) -> None: ...
def confstr(name: Union[str, int]) -> str: ...
def ctermid() -> str: ...
def dup(fd: int) -> int: ...
def dup2(fd: int, fd2: int) -> None: ...
def execv(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ...
def execve(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ...
def fchdir(fd: int) -> None: ...
def fchmod(fd: int, mode: int) -> None: ...
def fchown(fd: int, uid: int, gid: int) -> None: ...
def fdatasync(fd: int) -> None: ...
def fdopen(fd: int, mode: str = ..., bufsize: int = ...) -> IO[str]: ...
def fork() -> int:
raise OSError()
def forkpty() -> Tuple[int, int]:
raise OSError()
def fpathconf(fd: int, name: str) -> None: ...
def fstat(fd: int) -> stat_result: ...
def fstatvfs(fd: int) -> statvfs_result: ...
def fsync(fd: int) -> None: ...
def ftruncate(fd: int, length: int) -> None: ...
def getcwd() -> str: ...
def getcwdu() -> unicode: ...
def getegid() -> int: ...
def geteuid() -> int: ...
def getgid() -> int: ...
def getgroups() -> List[int]: ...
def getloadavg() -> Tuple[float, float, float]:
raise OSError()
def getlogin() -> str: ...
def getpgid(pid: int) -> int: ...
def getpgrp() -> int: ...
def getpid() -> int: ...
def getppid() -> int: ...
def getresgid() -> Tuple[int, int, int]: ...
def getresuid() -> Tuple[int, int, int]: ...
def getsid(pid: int) -> int: ...
def getuid() -> int: ...
def initgroups(username: str, gid: int) -> None: ...
def isatty(fd: int) -> bool: ...
def kill(pid: int, sig: int) -> None: ...
def killpg(pgid: int, sig: int) -> None: ...
def lchown(path: unicode, uid: int, gid: int) -> None: ...
def link(source: unicode, link_name: str) -> None: ...
_T = TypeVar("_T")
def listdir(path: _T) -> List[_T]: ...
def lseek(fd: int, pos: int, how: int) -> None: ...
def lstat(path: unicode) -> stat_result: ...
def major(device: int) -> int: ...
def makedev(major: int, minor: int) -> int: ...
def minor(device: int) -> int: ...
def mkdir(path: unicode, mode: int = ...) -> None: ...
def mkfifo(path: unicode, mode: int = ...) -> None: ...
def mknod(filename: unicode, mode: int = ..., device: int = ...) -> None: ...
def nice(increment: int) -> int: ...
def open(file: unicode, flags: int, mode: int = ...) -> int: ...
def openpty() -> Tuple[int, int]: ...
def pathconf(path: unicode, name: str) -> str: ...
def pipe() -> Tuple[int, int]: ...
def popen(command: str, mode: str = ..., bufsize: int = ...) -> IO[str]: ...
def putenv(varname: str, value: str) -> None: ...
def read(fd: int, n: int) -> str: ...
def readlink(path: _T) -> _T: ...
def remove(path: unicode) -> None: ...
def rename(src: unicode, dst: unicode) -> None: ...
def rmdir(path: unicode) -> None: ...
def setegid(egid: int) -> None: ...
def seteuid(euid: int) -> None: ...
def setgid(gid: int) -> None: ...
def setgroups(groups: Sequence[int]) -> None: ...
def setpgid(pid: int, pgrp: int) -> None: ...
def setpgrp() -> None: ...
def setregid(rgid: int, egid: int) -> None: ...
def setresgid(rgid: int, egid: int, sgid: int) -> None: ...
def setresuid(ruid: int, euid: int, suid: int) -> None: ...
def setreuid(ruid: int, euid: int) -> None: ...
def setsid() -> None: ...
def setuid(pid: int) -> None: ...
def stat(path: unicode) -> stat_result: ...
def statvfs(path: unicode) -> statvfs_result: ...
def stat_float_times(fd: int) -> None: ...
def strerror(code: int) -> str: ...
def symlink(source: unicode, link_name: unicode) -> None: ...
def sysconf(name: Union[str, int]) -> int: ...
def system(command: unicode) -> int: ...
def tcgetpgrp(fd: int) -> int: ...
def tcsetpgrp(fd: int, pg: int) -> None: ...
def times() -> Tuple[float, float, float, float, float]: ...
def tmpfile() -> IO[str]: ...
def ttyname(fd: int) -> str: ...
def umask(mask: int) -> int: ...
def uname() -> Tuple[str, str, str, str, str]: ...
def unlink(path: unicode) -> None: ...
def unsetenv(varname: str) -> None: ...
def urandom(n: int) -> str: ...
def utime(path: unicode, times: Optional[Tuple[int, int]]) -> None:
raise OSError
def wait() -> int: ...
_r = Tuple[float, float, int, int, int, int, int, int, int, int, int, int, int, int, int, int]
def wait3(options: int) -> Tuple[int, int, _r]: ...
def wait4(pid: int, options: int) -> Tuple[int, int, _r]: ...
def waitpid(pid: int, options: int) -> int:
raise OSError()
def write(fd: int, str: str) -> int: ...
mypy-0.470/typeshed/stdlib/2/fnmatch.pyi 0000644 0000000 0000000 00000000372 13023631176 016636 0 ustar root root from typing import Iterable
def fnmatch(filename: str, pattern: str) -> bool: ...
def fnmatchcase(filename: str, pattern: str) -> bool: ...
def filter(names: Iterable[str], pattern: str) -> Iterable[str]: ...
def translate(pattern: str) -> str: ...
mypy-0.470/typeshed/stdlib/2/token.pyi 0000644 0000000 0000000 00000001513 13023631176 016334 0 ustar root root from typing import Dict
ENDMARKER = 0
NAME = 0
NUMBER = 0
STRING = 0
NEWLINE = 0
INDENT = 0
DEDENT = 0
LPAR = 0
RPAR = 0
LSQB = 0
RSQB = 0
COLON = 0
COMMA = 0
SEMI = 0
PLUS = 0
MINUS = 0
STAR = 0
SLASH = 0
VBAR = 0
AMPER = 0
LESS = 0
GREATER = 0
EQUAL = 0
DOT = 0
PERCENT = 0
BACKQUOTE = 0
LBRACE = 0
RBRACE = 0
EQEQUAL = 0
NOTEQUAL = 0
LESSEQUAL = 0
GREATEREQUAL = 0
TILDE = 0
CIRCUMFLEX = 0
LEFTSHIFT = 0
RIGHTSHIFT = 0
DOUBLESTAR = 0
PLUSEQUAL = 0
MINEQUAL = 0
STAREQUAL = 0
SLASHEQUAL = 0
PERCENTEQUAL = 0
AMPEREQUAL = 0
VBAREQUAL = 0
CIRCUMFLEXEQUAL = 0
LEFTSHIFTEQUAL = 0
RIGHTSHIFTEQUAL = 0
DOUBLESTAREQUAL = 0
DOUBLESLASH = 0
DOUBLESLASHEQUAL = 0
AT = 0
OP = 0
ERRORTOKEN = 0
N_TOKENS = 0
NT_OFFSET = 0
tok_name = ... # type: Dict[int, str]
def ISTERMINAL(x) -> bool: ...
def ISNONTERMINAL(x) -> bool: ...
def ISEOF(x) -> bool: ...
mypy-0.470/typeshed/stdlib/2/_functools.pyi 0000644 0000000 0000000 00000001257 13023631176 017374 0 ustar root root """Stub file for the '_functools' module."""
from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Tuple, overload
_T = TypeVar("_T")
_S = TypeVar("_S")
@overload
def reduce(function: Callable[[_T, _T], _T],
sequence: Iterable[_T]) -> _T: ...
@overload
def reduce(function: Callable[[_T, _S], _T],
sequence: Iterable[_S], initial: _T) -> _T: ...
class partial(object):
func = ... # type: Callable[..., Any]
args = ... # type: Tuple[Any, ...]
keywords = ... # type: Dict[str, Any]
def __init__(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
mypy-0.470/typeshed/stdlib/2/base64.pyi 0000644 0000000 0000000 00000001573 13023631176 016306 0 ustar root root # Stubs for base64
# Based on http://docs.python.org/3.2/library/base64.html
from typing import IO
def b64encode(s: str, altchars: str = ...) -> str: ...
def b64decode(s: str, altchars: str = ...,
validate: bool = ...) -> str: ...
def standard_b64encode(s: str) -> str: ...
def standard_b64decode(s: str) -> str: ...
def urlsafe_b64encode(s: str) -> str: ...
def urlsafe_b64decode(s: str) -> str: ...
def b32encode(s: str) -> str: ...
def b32decode(s: str, casefold: bool = ...,
map01: str = ...) -> str: ...
def b16encode(s: str) -> str: ...
def b16decode(s: str, casefold: bool = ...) -> str: ...
def decode(input: IO[str], output: IO[str]) -> None: ...
def decodebytes(s: str) -> str: ...
def decodestring(s: str) -> str: ...
def encode(input: IO[str], output: IO[str]) -> None: ...
def encodebytes(s: str) -> str: ...
def encodestring(s: str) -> str: ...
mypy-0.470/typeshed/stdlib/2/ast.pyi 0000644 0000000 0000000 00000003452 13044257024 016006 0 ustar root root # Python 2.7 ast
import typing
from typing import Any, Iterator, Union
from _ast import (
Add, alias, And, arguments, Assert, Assign, AST, Attribute, AugAssign,
AugLoad, AugStore, BinOp, BitAnd, BitOr, BitXor, BoolOp, boolop, Break,
Call, ClassDef, cmpop, Compare, comprehension, Continue, Del, Delete, Dict,
DictComp, Div, Ellipsis, Eq, ExceptHandler, Exec, Expr, expr, Expression,
expr_context, ExtSlice, FloorDiv, For, FunctionDef, GeneratorExp, Global,
Gt, GtE, If, IfExp, Import, ImportFrom, In, Index, Interactive, Invert, Is,
IsNot, keyword, Lambda, List, ListComp, Load, LShift, Lt, LtE, Mod, mod,
Module, Mult, Name, Not, NotEq, NotIn, Num, operator, Or, Param, Pass, Pow,
Print, Raise, Repr, Return, RShift, Set, SetComp, Slice, slice, stmt,
Store, Str, Sub, Subscript, Suite, TryExcept, TryFinally, Tuple, UAdd,
UnaryOp, unaryop, USub, While, With, Yield
)
__version__ = ... # type: str
PyCF_ONLY_AST = ... # type: int
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> str: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
class NodeVisitor():
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
mypy-0.470/typeshed/stdlib/2/string.pyi 0000644 0000000 0000000 00000007073 13023631176 016531 0 ustar root root # Stubs for string
# Based on http://docs.python.org/3.2/library/string.html
from typing import Mapping, Sequence, Any, Optional, Union, List, Tuple, Iterable, AnyStr
ascii_letters = ... # type: str
ascii_lowercase = ... # type: str
ascii_uppercase = ... # type: str
digits = ... # type: str
hexdigits = ... # type: str
letters = ... # type: str
lowercase = ... # type: str
octdigits = ... # type: str
punctuation = ... # type: str
printable = ... # type: str
uppercase = ... # type: str
whitespace = ... # type: str
def capwords(s: AnyStr, sep: AnyStr = ...) -> AnyStr: ...
# TODO: originally named 'from'
def maketrans(_from: str, to: str) -> str: ...
def atof(s: unicode) -> float: ...
def atoi(s: unicode, base: int = ...) -> int: ...
def atol(s: unicode, base: int = ...) -> int: ...
def capitalize(word: AnyStr) -> AnyStr: ...
def find(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ...
def rfind(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ...
def index(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ...
def rindex(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ...
def count(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ...
def lower(s: AnyStr) -> AnyStr: ...
def split(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ...
def rsplit(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ...
def splitfields(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ...
def join(words: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ...
def joinfields(word: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ...
def lstrip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ...
def rstrip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ...
def strip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ...
def swapcase(s: AnyStr) -> AnyStr: ...
def translate(s: str, table: str, deletechars: str = ...) -> str: ...
def upper(s: AnyStr) -> AnyStr: ...
def ljust(s: AnyStr, width: int, fillhar: AnyStr = ...) -> AnyStr: ...
def rjust(s: AnyStr, width: int, fillhar: AnyStr = ...) -> AnyStr: ...
def center(s: AnyStr, width: int, fillhar: AnyStr = ...) -> AnyStr: ...
def zfill(s: AnyStr, width: int) -> AnyStr: ...
def replace(s: AnyStr, old: AnyStr, new: AnyStr, maxreplace: int = ...) -> AnyStr: ...
class Template(object):
# TODO: Unicode support?
template = ... # type: str
def __init__(self, template: str) -> None: ...
def substitute(self, mapping: Mapping[str, str] = ..., **kwds: str) -> str: ...
def safe_substitute(self, mapping: Mapping[str, str] = ...,
**kwds: str) -> str: ...
# TODO(MichalPokorny): This is probably badly and/or loosely typed.
class Formatter(object):
def format(self, format_string: str, *args, **kwargs) -> str: ...
def vformat(self, format_string: str, args: Sequence[Any],
kwargs: Mapping[str, Any]) -> str: ...
def parse(self, format_string: str) -> Iterable[Tuple[str, str, str, str]]: ...
def get_field(self, field_name: str, args: Sequence[Any],
kwargs: Mapping[str, Any]) -> Any: ...
def get_value(self, key: Union[int, str], args: Sequence[Any],
kwargs: Mapping[str, Any]) -> Any:
raise IndexError()
raise KeyError()
def check_unused_args(self, used_args: Sequence[Union[int, str]], args: Sequence[Any],
kwargs: Mapping[str, Any]) -> None: ...
def format_field(self, value: Any, format_spec: str) -> Any: ...
def convert_field(self, value: Any, conversion: str) -> Any: ...
mypy-0.470/typeshed/stdlib/2/codecs.pyi 0000644 0000000 0000000 00000016635 13044257024 016466 0 ustar root root # Better codecs stubs hand-written by o11c.
# https://docs.python.org/2/library/codecs.html
from typing import (
BinaryIO,
Callable,
Iterable,
Iterator,
List,
Optional,
Tuple,
Union,
)
from abc import abstractmethod
# TODO: this only satisfies the most common interface, where
# str is the raw form and unicode is the cooked form.
# In the long run, both should become template parameters maybe?
# There *are* str->str and unicode->unicode encodings in the standard library.
# And unlike python 3, they are in fairly widespread use.
_decoded = unicode
_encoded = str
# TODO: It is not possible to specify these signatures correctly, because
# they have an optional positional or keyword argument for errors=.
_encode_type = Callable[[_decoded], _encoded] # signature of Codec().encode
_decode_type = Callable[[_encoded], _decoded] # signature of Codec().decode
_stream_reader_type = Callable[[BinaryIO], 'StreamReader'] # signature of StreamReader __init__
_stream_writer_type = Callable[[BinaryIO], 'StreamWriter'] # signature of StreamWriter __init__
_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__
_incremental_decode_type = Callable[[], 'IncrementalDecoder'] # signature of IncrementalDecoder __init__
def encode(obj: _decoded, encoding: str = ..., errors: str = ...) -> _encoded:
...
def decode(obj: _encoded, encoding: str = ..., errors: str = ...) -> _decoded:
...
def lookup(encoding: str) -> 'CodecInfo':
...
class CodecInfo(Tuple[_encode_type, _decode_type, _stream_reader_type, _stream_writer_type]):
def __init__(self, encode: _encode_type, decode: _decode_type, streamreader: _stream_reader_type = ..., streamwriter: _stream_writer_type = ..., incrementalencoder: _incremental_encoder_type = ..., incrementaldecoder: _incremental_decode_type = ..., name: str = ...) -> None: ...
encode = ... # type: _encode_type
decode = ... # type: _decode_type
streamreader = ... # type: _stream_reader_type
streamwriter = ... # type: _stream_writer_type
incrementalencoder = ... # type: _incremental_encoder_type
incrementaldecoder = ... # type: _incremental_decode_type
name = ... # type: str
def getencoder(encoding: str) -> _encode_type:
...
def getdecoder(encoding: str) -> _encode_type:
...
def getincrementalencoder(encoding: str) -> _incremental_encoder_type:
...
def getincrementaldecoder(encoding: str) -> _incremental_encoder_type:
...
def getreader(encoding: str) -> _stream_reader_type:
...
def getwriter(encoding: str) -> _stream_writer_type:
...
def register(search_function: Callable[[str], CodecInfo]) -> None:
...
def open(filename: str, mode: str = ..., encoding: str = ..., errors: str = ..., buffering: int = ...) -> StreamReaderWriter:
...
def EncodedFile(file: BinaryIO, data_encoding: str, file_encoding: str = ..., errors: Optional[str] = ...) -> 'StreamRecoder':
...
def iterencode(iterator: Iterable[_decoded], encoding: str, errors: str = ...) -> Iterator[_encoded]:
...
def iterdecode(iterator: Iterable[_encoded], encoding: str, errors: str = ...) -> Iterator[_decoded]:
...
BOM = b''
BOM_BE = b''
BOM_LE = b''
BOM_UTF8 = b''
BOM_UTF16 = b''
BOM_UTF16_BE = b''
BOM_UTF16_LE = b''
BOM_UTF32 = b''
BOM_UTF32_BE = b''
BOM_UTF32_LE = b''
# It is expected that different actions be taken depending on which of the
# three subclasses of `UnicodeError` is actually ...ed. However, the Union
# is still needed for at least one of the cases.
def register_error(name: str, error_handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None:
...
def lookup_error(name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]:
...
def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
class Codec:
# These are sort of @abstractmethod but sort of not.
# The StreamReader and StreamWriter subclasses only implement one.
def encode(self, input: _decoded, errors: str = ...) -> Tuple[_encoded, int]:
...
def decode(self, input: _encoded, errors: str = ...) -> Tuple[_decoded, int]:
...
class IncrementalEncoder:
errors = ... # type: str
def __init__(self, errors: str = ...) -> None:
...
@abstractmethod
def encode(self, object: _decoded, final: bool = ...) -> _encoded:
...
def reset(self) -> None:
...
# documentation says int but str is needed for the subclass.
def getstate(self) -> Union[int, _decoded]:
...
def setstate(self, state: Union[int, _decoded]) -> None:
...
class IncrementalDecoder:
errors = ... # type: str
def __init__(self, errors: str = ...) -> None:
...
@abstractmethod
def decode(self, object: _encoded, final: bool = ...) -> _decoded:
...
def reset(self) -> None:
...
def getstate(self) -> Tuple[_encoded, int]:
...
def setstate(self, state: Tuple[_encoded, int]) -> None:
...
# These are not documented but used in encodings/*.py implementations.
class BufferedIncrementalEncoder(IncrementalEncoder):
buffer = ... # type: str
def __init__(self, errors: str = ...) -> None:
...
@abstractmethod
def _buffer_encode(self, input: _decoded, errors: str, final: bool) -> _encoded:
...
def encode(self, input: _decoded, final: bool = ...) -> _encoded:
...
class BufferedIncrementalDecoder(IncrementalDecoder):
buffer = ... # type: str
def __init__(self, errors: str = ...) -> None:
...
@abstractmethod
def _buffer_decode(self, input: _encoded, errors: str, final: bool) -> Tuple[_decoded, int]:
...
def decode(self, object: _encoded, final: bool = ...) -> _decoded:
...
# TODO: it is not possible to specify the requirement that all other
# attributes and methods are passed-through from the stream.
class StreamWriter(Codec):
errors = ... # type: str
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
...
def write(self, obj: _decoded) -> None:
...
def writelines(self, list: List[str]) -> None:
...
def reset(self) -> None:
...
class StreamReader(Codec):
errors = ... # type: str
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
...
def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _decoded:
...
def readline(self, size: int = ..., keepends: bool = ...) -> _decoded:
...
def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_decoded]:
...
def reset(self) -> None:
...
class StreamReaderWriter:
def __init__(self, stream: BinaryIO, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
def __enter__(self) -> BinaryIO:
...
def __exit__(self, typ, exc, tb) -> bool:
...
class StreamRecoder(BinaryIO):
def __init__(self, stream: BinaryIO, encode: _encode_type, decode: _decode_type, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
mypy-0.470/typeshed/stdlib/2/abc.pyi 0000644 0000000 0000000 00000002561 13023631176 015745 0 ustar root root from typing import Any, Dict, Set, Union, Tuple
import _weakrefset
# mypy has special processing for ABCMeta and abstractmethod.
WeakSet = ... # type: _weakrefset.WeakSet
_InstanceType = ... # type: type
types = ... # type: module
def abstractmethod(funcobj: Any) -> Any: ...
class ABCMeta(type):
# TODO: FrozenSet
__abstractmethods__ = ... # type: Set[Any]
_abc_cache = ... # type: _weakrefset.WeakSet
_abc_invalidation_counter = ... # type: int
_abc_negative_cache = ... # type: _weakrefset.WeakSet
_abc_negative_cache_version = ... # type: int
_abc_registry = ... # type: _weakrefset.WeakSet
def __init__(self, name: str, bases: Tuple[type, ...], namespace: Dict[Any, Any]) -> None: ...
def __instancecheck__(cls: "ABCMeta", instance: Any) -> Any: ...
def __subclasscheck__(cls: "ABCMeta", subclass: Any) -> Any: ...
def _dump_registry(cls: "ABCMeta", *args: Any, **kwargs: Any) -> None: ...
# TODO: subclass: Union["ABCMeta", type, Tuple[type, ...]]
def register(cls: "ABCMeta", subclass: Any) -> None: ...
class _C:
pass
# TODO: The real abc.abstractproperty inherits from "property".
class abstractproperty(object):
def __new__(cls, func: Any) -> Any: ...
__isabstractmethod__ = ... # type: bool
doc = ... # type: Any
fdel = ... # type: Any
fget = ... # type: Any
fset = ... # type: Any
mypy-0.470/typeshed/stdlib/2/fcntl.pyi 0000644 0000000 0000000 00000004742 13023631176 016331 0 ustar root root from typing import Any, Union
import io
FASYNC = ... # type: int
FD_CLOEXEC = ... # type: int
DN_ACCESS = ... # type: int
DN_ATTRIB = ... # type: int
DN_CREATE = ... # type: int
DN_DELETE = ... # type: int
DN_MODIFY = ... # type: int
DN_MULTISHOT = ... # type: int
DN_RENAME = ... # type: int
F_DUPFD = ... # type: int
F_EXLCK = ... # type: int
F_GETFD = ... # type: int
F_GETFL = ... # type: int
F_GETLEASE = ... # type: int
F_GETLK = ... # type: int
F_GETLK64 = ... # type: int
F_GETOWN = ... # type: int
F_GETSIG = ... # type: int
F_NOTIFY = ... # type: int
F_RDLCK = ... # type: int
F_SETFD = ... # type: int
F_SETFL = ... # type: int
F_SETLEASE = ... # type: int
F_SETLK = ... # type: int
F_SETLK64 = ... # type: int
F_SETLKW = ... # type: int
F_SETLKW64 = ... # type: int
F_SETOWN = ... # type: int
F_SETSIG = ... # type: int
F_SHLCK = ... # type: int
F_UNLCK = ... # type: int
F_WRLCK = ... # type: int
I_ATMARK = ... # type: int
I_CANPUT = ... # type: int
I_CKBAND = ... # type: int
I_FDINSERT = ... # type: int
I_FIND = ... # type: int
I_FLUSH = ... # type: int
I_FLUSHBAND = ... # type: int
I_GETBAND = ... # type: int
I_GETCLTIME = ... # type: int
I_GETSIG = ... # type: int
I_GRDOPT = ... # type: int
I_GWROPT = ... # type: int
I_LINK = ... # type: int
I_LIST = ... # type: int
I_LOOK = ... # type: int
I_NREAD = ... # type: int
I_PEEK = ... # type: int
I_PLINK = ... # type: int
I_POP = ... # type: int
I_PUNLINK = ... # type: int
I_PUSH = ... # type: int
I_RECVFD = ... # type: int
I_SENDFD = ... # type: int
I_SETCLTIME = ... # type: int
I_SETSIG = ... # type: int
I_SRDOPT = ... # type: int
I_STR = ... # type: int
I_SWROPT = ... # type: int
I_UNLINK = ... # type: int
LOCK_EX = ... # type: int
LOCK_MAND = ... # type: int
LOCK_NB = ... # type: int
LOCK_READ = ... # type: int
LOCK_RW = ... # type: int
LOCK_SH = ... # type: int
LOCK_UN = ... # type: int
LOCK_WRITE = ... # type: int
_ANYFILE = Union[int, io.IOBase]
# TODO All these return either int or bytes depending on the value of
# cmd (not on the type of arg).
def fcntl(fd: _ANYFILE, op: int, arg: Union[int, bytes] = ...) -> Any: ...
# TODO: arg: int or read-only buffer interface or read-write buffer interface
def ioctl(fd: _ANYFILE, op: int, arg: Union[int, bytes] = ...,
mutate_flag: bool = ...) -> Any: ...
def flock(fd: _ANYFILE, op: int) -> None: ...
def lockf(fd: _ANYFILE, op: int, length: int = ..., start: int = ...,
whence: int = ...) -> Any: ...
mypy-0.470/typeshed/stdlib/2/io.pyi 0000644 0000000 0000000 00000007702 13035744274 015640 0 ustar root root # Stubs for io
# Based on https://docs.python.org/2/library/io.html
# Only a subset of functionality is included.
from typing import List, BinaryIO, TextIO, IO, overload, Iterator, Iterable, Any, Union
DEFAULT_BUFFER_SIZE = 0
def open(file: Union[str, unicode, int],
mode: unicode = ..., buffering: int = ..., encoding: unicode = ...,
errors: unicode = ..., newline: unicode = ...,
closefd: bool = ...) -> IO[Any]: ...
class IOBase:
# TODO
...
class BytesIO(BinaryIO):
def __init__(self, initial_bytes: str = ...) -> None: ...
# TODO getbuffer
# TODO see comments in BinaryIO for missing functionality
def close(self) -> None: ...
def closed(self) -> bool: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, n: int = ...) -> str: ...
def readable(self) -> bool: ...
def readline(self, limit: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> int: ...
def writable(self) -> bool: ...
def write(self, s: str) -> None: ...
def writelines(self, lines: Iterable[str]) -> None: ...
def getvalue(self) -> str: ...
def read1(self) -> str: ...
def __iter__(self) -> Iterator[str]: ...
def next(self) -> str: ...
def __enter__(self) -> 'BytesIO': ...
def __exit__(self, type, value, traceback) -> bool: ...
class StringIO(TextIO):
def __init__(self, initial_value: unicode = ...,
newline: unicode = ...) -> None: ...
# TODO see comments in BinaryIO for missing functionality
name = ... # type: str
def close(self) -> None: ...
def closed(self) -> bool: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, n: int = ...) -> unicode: ...
def readable(self) -> bool: ...
def readline(self, limit: int = ...) -> unicode: ...
def readlines(self, hint: int = ...) -> List[unicode]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> int: ...
def writable(self) -> bool: ...
def write(self, s: unicode) -> None: ...
def writelines(self, lines: Iterable[unicode]) -> None: ...
def getvalue(self) -> unicode: ...
def __iter__(self) -> Iterator[unicode]: ...
def next(self) -> unicode: ...
def __enter__(self) -> 'StringIO': ...
def __exit__(self, type, value, traceback) -> bool: ...
class TextIOWrapper(TextIO):
# write_through is undocumented but used by subprocess
def __init__(self, buffer: IO[str], encoding: unicode = ...,
errors: unicode = ..., newline: unicode = ...,
line_buffering: bool = ...,
write_through: bool = ...) -> None: ...
# TODO see comments in BinaryIO for missing functionality
def close(self) -> None: ...
def closed(self) -> bool: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, n: int = ...) -> unicode: ...
def readable(self) -> bool: ...
def readline(self, limit: int = ...) -> unicode: ...
def readlines(self, hint: int = ...) -> List[unicode]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> int: ...
def writable(self) -> bool: ...
def write(self, s: unicode) -> None: ...
def writelines(self, lines: Iterable[unicode]) -> None: ...
def __iter__(self) -> Iterator[unicode]: ...
def next(self) -> unicode: ...
def __enter__(self) -> StringIO: ...
def __exit__(self, type, value, traceback) -> bool: ...
class BufferedIOBase(IOBase): ...
mypy-0.470/typeshed/stdlib/2/sqlite3/ 0000755 0000000 0000000 00000000000 13044320557 016056 5 ustar root root mypy-0.470/typeshed/stdlib/2/sqlite3/__init__.pyi 0000644 0000000 0000000 00000000233 13035744274 020344 0 ustar root root # Stubs for sqlite3 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from sqlite3.dbapi2 import * # noqa: F403
mypy-0.470/typeshed/stdlib/2/sqlite3/dbapi2.pyi 0000644 0000000 0000000 00000023203 13044257024 017740 0 ustar root root # Filip Hron
# based heavily on Andrey Vlasovskikh's python-skeletons https://github.com/JetBrains/python-skeletons/blob/master/sqlite3.py
from typing import Any, Union, List, Iterator
from numbers import Integral
from datetime import time, datetime
from collections import Iterable
paramstyle = ... # type: str
threadsafety = ... # type: int
apilevel = ... # type: str
Date = ... # type: datetime
Time = ... # type: time
Timestamp = ... # type: datetime
def DateFromTicks(ticks): ...
def TimeFromTicks(ticks): ...
def TimestampFromTicks(ticks): ...
version_info = ... # type: Any
sqlite_version_info = ... # type: Any
Binary = ... # type: Any
def register_adapters_and_converters(): ...
# The remaining definitions are imported from _sqlite3.
PARSE_COLNAMES = ... # type: int
PARSE_DECLTYPES = ... # type: int
SQLITE_ALTER_TABLE = ... # type: int
SQLITE_ANALYZE = ... # type: int
SQLITE_ATTACH = ... # type: int
SQLITE_CREATE_INDEX = ... # type: int
SQLITE_CREATE_TABLE = ... # type: int
SQLITE_CREATE_TEMP_INDEX = ... # type: int
SQLITE_CREATE_TEMP_TABLE = ... # type: int
SQLITE_CREATE_TEMP_TRIGGER = ... # type: int
SQLITE_CREATE_TEMP_VIEW = ... # type: int
SQLITE_CREATE_TRIGGER = ... # type: int
SQLITE_CREATE_VIEW = ... # type: int
SQLITE_DELETE = ... # type: int
SQLITE_DENY = ... # type: int
SQLITE_DETACH = ... # type: int
SQLITE_DROP_INDEX = ... # type: int
SQLITE_DROP_TABLE = ... # type: int
SQLITE_DROP_TEMP_INDEX = ... # type: int
SQLITE_DROP_TEMP_TABLE = ... # type: int
SQLITE_DROP_TEMP_TRIGGER = ... # type: int
SQLITE_DROP_TEMP_VIEW = ... # type: int
SQLITE_DROP_TRIGGER = ... # type: int
SQLITE_DROP_VIEW = ... # type: int
SQLITE_IGNORE = ... # type: int
SQLITE_INSERT = ... # type: int
SQLITE_OK = ... # type: int
SQLITE_PRAGMA = ... # type: int
SQLITE_READ = ... # type: int
SQLITE_REINDEX = ... # type: int
SQLITE_SELECT = ... # type: int
SQLITE_TRANSACTION = ... # type: int
SQLITE_UPDATE = ... # type: int
adapters = ... # type: Any
converters = ... # type: Any
sqlite_version = ... # type: str
version = ... # type: str
# TODO: adapt needs to get probed
def adapt(obj, protocol, alternate): ...
def complete_statement(sql: str) -> bool: ...
def connect(database: Union[bytes, unicode],
timeout: float = ...,
detect_types: int = ...,
isolation_level: Union[str, None] = ...,
check_same_thread: bool = ...,
factory: Union[Connection, None] = ...,
cached_statements: int = ...) -> Connection: ...
def enable_callback_tracebacks(flag: bool) -> None: ...
def enable_shared_cache(do_enable: int) -> None: ...
def register_adapter(type: type, callable: Any) -> None: ...
# TODO: sqlite3.register_converter.__doc__ specifies callable as unknown
def register_converter(typename: str, callable: bytes) -> None: ...
class Cache:
def __init__(self, *args, **kwargs) -> None: ...
def display(self, *args, **kwargs) -> None: ...
def get(self, *args, **kwargs) -> None: ...
class Connection:
DataError = ... # type: Any
DatabaseError = ... # type: Any
Error = ... # type: Any
IntegrityError = ... # type: Any
InterfaceError = ... # type: Any
InternalError = ... # type: Any
NotSupportedError = ... # type: Any
OperationalError = ... # type: Any
ProgrammingError = ... # type: Any
Warning = ... # type: Any
in_transaction = ... # type: Any
isolation_level = ... # type: Any
row_factory = ... # type: Any
text_factory = ... # type: Any
total_changes = ... # type: Any
def __init__(self, *args, **kwargs): ...
def close(self) -> None: ...
def commit(self) -> None: ...
def create_aggregate(self, name: str, num_params: int, aggregate_class: type) -> None: ...
def create_collation(self, name: str, callable: Any) -> None: ...
def create_function(self, name: str, num_params: int, func: Any) -> None: ...
def cursor(self, cursorClass=...) -> Cursor: ...
def execute(self, sql: str, parameters: Iterable = ...) -> Cursor: ...
# TODO: please check in executemany() if seq_of_parameters type is possible like this
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable]) -> Cursor: ...
def executescript(self, sql_script: Union[bytes, unicode]) -> Cursor: ...
def interrupt(self, *args, **kwargs) -> None: ...
def iterdump(self, *args, **kwargs) -> None: ...
def rollback(self, *args, **kwargs) -> None: ...
# TODO: set_authorizer(authorzer_callback)
# see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_authorizer
# returns [SQLITE_OK, SQLITE_DENY, SQLITE_IGNORE] so perhaps int
def set_authorizer(self, *args, **kwargs) -> None: ...
# set_progress_handler(handler, n) -> see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_progress_handler
def set_progress_handler(self, *args, **kwargs) -> None: ...
def set_trace_callback(self, *args, **kwargs): ...
def __call__(self, *args, **kwargs): ...
def __enter__(self, *args, **kwargs): ...
def __exit__(self, *args, **kwargs): ...
class Cursor(Iterator[Any]):
arraysize = ... # type: Any
connection = ... # type: Any
description = ... # type: Any
lastrowid = ... # type: Any
row_factory = ... # type: Any
rowcount = ... # type: Any
# TODO: Cursor class accepts exactly 1 argument
# required type is sqlite3.Connection (which is imported as _Connection)
# however, the name of the __init__ variable is unknown
def __init__(self, *args, **kwargs): ...
def close(self, *args, **kwargs): ...
def execute(self, sql: str, parameters: Iterable = ...) -> Cursor: ...
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable]): ...
def executescript(self, sql_script: Union[bytes, unicode]) -> Cursor: ...
def fetchall(self) -> List[Any]: ...
def fetchmany(self, size: Integral = ...) -> List[Any]: ...
def fetchone(self) -> Any: ...
def setinputsizes(self, *args, **kwargs): ...
def setoutputsize(self, *args, **kwargs): ...
def __iter__(self) -> Cursor: ...
def __next__(self) -> Any: ...
class DataError(DatabaseError): ...
class DatabaseError(Error): ...
class Error(Exception): ...
class IntegrityError(DatabaseError): ...
class InterfaceError(Error): ...
class InternalError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
class OperationalError(DatabaseError): ...
class OptimizedUnicode:
maketrans = ... # type: Any
def __init__(self, *args, **kwargs): ...
def capitalize(self, *args, **kwargs): ...
def casefold(self, *args, **kwargs): ...
def center(self, *args, **kwargs): ...
def count(self, *args, **kwargs): ...
def encode(self, *args, **kwargs): ...
def endswith(self, *args, **kwargs): ...
def expandtabs(self, *args, **kwargs): ...
def find(self, *args, **kwargs): ...
def format(self, *args, **kwargs): ...
def format_map(self, *args, **kwargs): ...
def index(self, *args, **kwargs): ...
def isalnum(self, *args, **kwargs): ...
def isalpha(self, *args, **kwargs): ...
def isdecimal(self, *args, **kwargs): ...
def isdigit(self, *args, **kwargs): ...
def isidentifier(self, *args, **kwargs): ...
def islower(self, *args, **kwargs): ...
def isnumeric(self, *args, **kwargs): ...
def isprintable(self, *args, **kwargs): ...
def isspace(self, *args, **kwargs): ...
def istitle(self, *args, **kwargs): ...
def isupper(self, *args, **kwargs): ...
def join(self, *args, **kwargs): ...
def ljust(self, *args, **kwargs): ...
def lower(self, *args, **kwargs): ...
def lstrip(self, *args, **kwargs): ...
def partition(self, *args, **kwargs): ...
def replace(self, *args, **kwargs): ...
def rfind(self, *args, **kwargs): ...
def rindex(self, *args, **kwargs): ...
def rjust(self, *args, **kwargs): ...
def rpartition(self, *args, **kwargs): ...
def rsplit(self, *args, **kwargs): ...
def rstrip(self, *args, **kwargs): ...
def split(self, *args, **kwargs): ...
def splitlines(self, *args, **kwargs): ...
def startswith(self, *args, **kwargs): ...
def strip(self, *args, **kwargs): ...
def swapcase(self, *args, **kwargs): ...
def title(self, *args, **kwargs): ...
def translate(self, *args, **kwargs): ...
def upper(self, *args, **kwargs): ...
def zfill(self, *args, **kwargs): ...
def __add__(self, other): ...
def __contains__(self, *args, **kwargs): ...
def __eq__(self, other): ...
def __format__(self, *args, **kwargs): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __getnewargs__(self, *args, **kwargs): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args, **kwargs): ...
def __lt__(self, other): ...
def __mod__(self, other): ...
def __mul__(self, other): ...
def __ne__(self, other): ...
def __rmod__(self, other): ...
def __rmul__(self, other): ...
def __sizeof__(self): ...
class PrepareProtocol:
def __init__(self, *args, **kwargs): ...
class ProgrammingError(DatabaseError): ...
class Row:
def __init__(self, *args, **kwargs): ...
def keys(self, *args, **kwargs): ...
def __eq__(self, other): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args, **kwargs): ...
def __lt__(self, other): ...
def __ne__(self, other): ...
class Statement:
def __init__(self, *args, **kwargs): ...
class Warning(Exception): ...
mypy-0.470/typeshed/stdlib/2/urlparse.pyi 0000644 0000000 0000000 00000004064 13035744274 017064 0 ustar root root # Stubs for urlparse (Python 2)
from typing import Dict, List, NamedTuple, Tuple, Sequence, Union, overload
uses_relative = ... # type: List[str]
uses_netloc = ... # type: List[str]
uses_params = ... # type: List[str]
non_hierarchical = ... # type: List[str]
uses_query = ... # type: List[str]
uses_fragment = ... # type: List[str]
scheme_chars = ... # type: str
MAX_CACHE_SIZE = 0
def clear_cache() -> None: ...
class ResultMixin(object):
@property
def username(self) -> str: ...
@property
def password(self) -> str: ...
@property
def hostname(self) -> str: ...
@property
def port(self) -> int: ...
class SplitResult(
NamedTuple(
'SplitResult',
[
('scheme', str), ('netloc', str), ('path', str), ('query', str), ('fragment', str)
]
),
ResultMixin
):
def geturl(self) -> str: ...
class ParseResult(
NamedTuple(
'ParseResult',
[
('scheme', str), ('netloc', str), ('path', str), ('params', str), ('query', str),
('fragment', str)
]
),
ResultMixin
):
def geturl(self) -> str: ...
def urlparse(url: Union[str, unicode], scheme: str = ...,
allow_fragments: bool = ...) -> ParseResult: ...
def urlsplit(url: Union[str, unicode], scheme: str = ...,
allow_fragments: bool = ...) -> SplitResult: ...
@overload
def urlunparse(data: Tuple[str, str, str, str, str, str]) -> str: ...
@overload
def urlunparse(data: Sequence[str]) -> str: ...
@overload
def urlunsplit(data: Tuple[str, str, str, str, str]) -> str: ...
@overload
def urlunsplit(data: Sequence[str]) -> str: ...
def urljoin(base: Union[str, unicode], url: Union[str, unicode],
allow_fragments: bool = ...) -> str: ...
def urldefrag(url: Union[str, unicode]) -> str: ...
def unquote(s: str) -> str: ...
def parse_qs(qs: str, keep_blank_values: bool = ...,
strict_parsing: bool = ...) -> Dict[str, List[str]]: ...
def parse_qsl(qs: str, keep_blank_values: int = ...,
strict_parsing: bool = ...) -> List[Tuple[str, str]]: ...
mypy-0.470/typeshed/stdlib/2/ConfigParser.pyi 0000644 0000000 0000000 00000007751 13035744274 017617 0 ustar root root from typing import Any, IO, Sequence, Tuple, Union
__all__ = ... # type: list[str]
DEFAULTSECT = ... # type: str
MAX_INTERPOLATION_DEPTH = ... # type: int
class Error(Exception):
message = ... # type: Any
def __init__(self, msg: str = ...) -> None: ...
def _get_message(self) -> None: ...
def _set_message(self, value: str) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
class NoSectionError(Error):
section = ... # type: str
def __init__(self, section: str) -> None: ...
class DuplicateSectionError(Error):
section = ... # type: str
def __init__(self, section: str) -> None: ...
class NoOptionError(Error):
section = ... # type: str
option = ... # type: str
def __init__(self, option: str, section: str) -> None: ...
class InterpolationError(Error):
section = ... # type: str
option = ... # type: str
msg = ... # type: str
def __init__(self, option: str, section: str, msg: str) -> None: ...
class InterpolationMissingOptionError(InterpolationError):
reference = ... # type: str
def __init__(self, option: str, section: str, rawval: str, reference: str) -> None: ...
class InterpolationSyntaxError(InterpolationError): ...
class InterpolationDepthError(InterpolationError):
def __init__(self, option: str, section: str, rawval: str) -> None: ...
class ParsingError(Error):
filename = ... # type: str
errors = ... # type: list[Tuple[Any, Any]]
def __init__(self, filename: str) -> None: ...
def append(self, lineno: Any, line: Any) -> None: ...
class MissingSectionHeaderError(ParsingError):
lineno = ... # type: Any
line = ... # type: Any
def __init__(self, filename: str, lineno: Any, line: Any) -> None: ...
class RawConfigParser:
_dict = ... # type: Any
_sections = ... # type: dict
_defaults = ... # type: dict
_optcre = ... # type: Any
SECTCRE = ... # type: Any
OPTCRE = ... # type: Any
OPTCRE_NV = ... # type: Any
def __init__(self, defaults: dict[Any, Any] = ..., dict_type: Any = ..., allow_no_value: bool = ...) -> None: ...
def defaults(self) -> dict[Any, Any]: ...
def sections(self) -> list[str]: ...
def add_section(self, section: str) -> None: ...
def has_section(self, section: str) -> bool: ...
def options(self, section: str) -> list[str]: ...
def read(self, filenames: Union[str, Sequence[str]]) -> list[str]: ...
def readfp(self, fp: IO[str], filename: str = ...) -> None: ...
def get(self, section: str, option: str) -> str: ...
def items(self, section: str) -> list[Tuple[Any, Any]]: ...
def _get(self, section: str, conv: type, option: str) -> Any: ...
def getint(self, section: str, option: str) -> int: ...
def getfloat(self, section: str, option: str) -> float: ...
_boolean_states = ... # type: dict[str, bool]
def getboolean(self, section: str, option: str) -> bool: ...
def optionxform(self, optionstr: str) -> str: ...
def has_option(self, section: str, option: str) -> bool: ...
def set(self, section: str, option: str, value: Any = ...) -> None: ...
def write(self, fp: file) -> None: ...
def remove_option(self, section: str, option: Any) -> bool: ...
def remove_section(self, section: str) -> bool: ...
def _read(self, fp: file, fpname: str) -> None: ...
class ConfigParser(RawConfigParser):
_KEYCRE = ... # type: Any
def get(self, section: str, option: str, raw: bool = ..., vars: dict = ...) -> Any: ...
def items(self, section: str, raw: bool = ..., vars: dict = ...) -> list[Tuple[str, Any]]: ...
def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
def _interpolation_replace(self, match: Any) -> str: ...
class SafeConfigParser(ConfigParser):
_interpvar_re = ... # type: Any
def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
def _interpolate_some(self, option: str, accum: list, rest: str, section: str, map: dict, depth: int) -> None: ...
mypy-0.470/typeshed/stdlib/2/gzip.pyi 0000644 0000000 0000000 00000002421 13035744274 016173 0 ustar root root # Stubs for gzip (Python 2)
#
# NOTE: Based on a dynamically typed stub automatically generated by stubgen.
from typing import Any, IO
import io
class GzipFile(io.BufferedIOBase):
myfileobj = ... # type: Any
max_read_chunk = ... # type: Any
mode = ... # type: Any
extrabuf = ... # type: Any
extrasize = ... # type: Any
extrastart = ... # type: Any
name = ... # type: Any
min_readsize = ... # type: Any
compress = ... # type: Any
fileobj = ... # type: Any
offset = ... # type: Any
mtime = ... # type: Any
def __init__(self, filename: str = ..., mode: str = ..., compresslevel: int = ...,
fileobj: IO[str] = ..., mtime: float = ...) -> None: ...
@property
def filename(self): ...
size = ... # type: Any
crc = ... # type: Any
def write(self, data): ...
def read(self, size=...): ...
@property
def closed(self): ...
def close(self): ...
def flush(self, zlib_mode=...): ...
def fileno(self): ...
def rewind(self): ...
def readable(self): ...
def writable(self): ...
def seekable(self): ...
def seek(self, offset, whence=...): ...
def readline(self, size=...): ...
def open(filename: str, mode: str = ..., compresslevel: int = ...) -> GzipFile: ...
mypy-0.470/typeshed/stdlib/2/sys.pyi 0000644 0000000 0000000 00000011176 13035744274 016047 0 ustar root root """Stubs for the 'sys' module."""
from typing import (
IO, Union, List, Sequence, Any, Dict, Tuple, BinaryIO, Optional, Callable,
overload, Type,
)
from types import FrameType, ModuleType, TracebackType, ClassType
from mypy_extensions import NoReturn
class _flags:
bytes_warning = ... # type: int
debug = ... # type: int
division_new = ... # type: int
division_warning = ... # type: int
dont_write_bytecode = ... # type: int
hash_randomization = ... # type: int
ignore_environment = ... # type: int
inspect = ... # type: int
interactive = ... # type: int
no_site = ... # type: int
no_user_site = ... # type: int
optimize = ... # type: int
py3k_warning = ... # type: int
tabcheck = ... # type: int
unicode = ... # type: int
verbose = ... # type: int
class _float_info:
max = ... # type: float
max_exp = ... # type: int
max_10_exp = ... # type: int
min = ... # type: float
min_exp = ... # type: int
min_10_exp = ... # type: int
dig = ... # type: int
mant_dig = ... # type: int
epsilon = ... # type: float
radix = ... # type: int
rounds = ... # type: int
class _version_info(Tuple[int, int, int, str, int]):
major = 0
minor = 0
micro = 0
releaselevel = ... # type: str
serial = 0
_mercurial = ... # type: Tuple[str, str, str]
api_version = ... # type: int
argv = ... # type: List[str]
builtin_module_names = ... # type: Tuple[str, ...]
byteorder = ... # type: str
copyright = ... # type: str
dont_write_bytecode = ... # type: bool
exec_prefix = ... # type: str
executable = ... # type: str
flags = ... # type: _flags
float_repr_style = ... # type: str
hexversion = ... # type: int
long_info = ... # type: object
maxint = ... # type: int
maxsize = ... # type: int
maxunicode = ... # type: int
modules = ... # type: Dict[str, ModuleType]
path = ... # type: List[str]
platform = ... # type: str
prefix = ... # type: str
py3kwarning = ... # type: bool
__stderr__ = ... # type: IO[str]
__stdin__ = ... # type: IO[str]
__stdout__ = ... # type: IO[str]
stderr = ... # type: IO[str]
stdin = ... # type: IO[str]
stdout = ... # type: IO[str]
subversion = ... # type: Tuple[str, str, str]
version = ... # type: str
warnoptions = ... # type: object
float_info = ... # type: _float_info
version_info = ... # type: _version_info
ps1 = ... # type: str
ps2 = ... # type: str
last_type = ... # type: type
last_value = ... # type: BaseException
last_traceback = ... # type: TracebackType
# TODO precise types
meta_path = ... # type: List[Any]
path_hooks = ... # type: List[Any]
path_importer_cache = ... # type: Dict[str, Any]
displayhook = ... # type: Optional[Callable[[int], None]]
excepthook = ... # type: Optional[Callable[[type, BaseException, TracebackType], None]]
exc_type = ... # type: Optional[type]
exc_value = ... # type: Union[BaseException, ClassType]
exc_traceback = ... # type: TracebackType
class _WindowsVersionType:
major = ... # type: Any
minor = ... # type: Any
build = ... # type: Any
platform = ... # type: Any
service_pack = ... # type: Any
service_pack_major = ... # type: Any
service_pack_minor = ... # type: Any
suite_mask = ... # type: Any
product_type = ... # type: Any
def getwindowsversion() -> _WindowsVersionType: ...
def _clear_type_cache() -> None: ...
def _current_frames() -> Dict[int, FrameType]: ...
def _getframe(depth: int = ...) -> FrameType: ...
def call_tracing(fn: Any, args: Any) -> Any: ...
def __displayhook__(value: int) -> None: ...
def __excepthook__(type_: type, value: BaseException, traceback: TracebackType) -> None: ...
def exc_clear() -> None:
raise DeprecationWarning()
# TODO should be a union of tuple, see mypy#1178
def exc_info() -> Tuple[Optional[Type[BaseException]],
Optional[BaseException],
Optional[TracebackType]]: ...
# sys.exit() accepts an optional argument of anything printable
def exit(arg: Any = ...) -> NoReturn:
raise SystemExit()
def getcheckinterval() -> int: ... # deprecated
def getdefaultencoding() -> str: ...
def getdlopenflags() -> int: ...
def getfilesystemencoding() -> Union[str, None]: ...
def getrefcount(arg: Any) -> int: ...
def getrecursionlimit() -> int: ...
def getsizeof(obj: object, default: int = ...) -> int: ...
def getprofile() -> None: ...
def gettrace() -> None: ...
def setcheckinterval(interval: int) -> None: ... # deprecated
def setdlopenflags(n: int) -> None: ...
def setprofile(profilefunc: Any) -> None: ... # TODO type
def setrecursionlimit(limit: int) -> None: ...
def settrace(tracefunc: Any) -> None: ... # TODO type
mypy-0.470/typeshed/stdlib/2/_weakrefset.pyi 0000644 0000000 0000000 00000000707 13023631176 017517 0 ustar root root from typing import Iterator, Any, Iterable, MutableSet, TypeVar, Generic
_T = TypeVar('_T')
class WeakSet(MutableSet[_T], Generic[_T]):
def __init__(self, data: Iterable[_T] = ...) -> None: ...
def add(self, x: _T) -> None: ...
def discard(self, x: _T) -> None: ...
def __contains__(self, x: Any) -> bool: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
# TODO: difference, difference_update, ...
mypy-0.470/typeshed/stdlib/2/pickle.pyi 0000644 0000000 0000000 00000001310 13023631176 016456 0 ustar root root # Stubs for pickle (Python 2)
from typing import Any, BinaryIO
HIGHEST_PROTOCOL = ... # type: int
def dump(obj: Any, file: BinaryIO, protocol: int = None) -> None: ...
def dumps(obj: Any, protocol: int = ...) -> bytes: ...
def load(file: BinaryIO) -> Any: ...
def loads(string: bytes) -> Any: ...
class PickleError(Exception):
pass
class PicklingError(PickleError):
pass
class UnpicklingError(PickleError):
pass
class Pickler:
def __init__(self, file: BinaryIO, protocol: int = None) -> None: ...
def dump(self, obj: Any) -> None: ...
def clear_memo(self) -> None: ...
class Unpickler:
def __init__(self, file: BinaryIO) -> None: ...
def load(self) -> Any: ...
mypy-0.470/typeshed/stdlib/2/syslog.pyi 0000644 0000000 0000000 00000002220 13044257024 016527 0 ustar root root LOG_ALERT = ... # type: int
LOG_AUTH = ... # type: int
LOG_CONS = ... # type: int
LOG_CRIT = ... # type: int
LOG_CRON = ... # type: int
LOG_DAEMON = ... # type: int
LOG_DEBUG = ... # type: int
LOG_EMERG = ... # type: int
LOG_ERR = ... # type: int
LOG_INFO = ... # type: int
LOG_KERN = ... # type: int
LOG_LOCAL0 = ... # type: int
LOG_LOCAL1 = ... # type: int
LOG_LOCAL2 = ... # type: int
LOG_LOCAL3 = ... # type: int
LOG_LOCAL4 = ... # type: int
LOG_LOCAL5 = ... # type: int
LOG_LOCAL6 = ... # type: int
LOG_LOCAL7 = ... # type: int
LOG_LPR = ... # type: int
LOG_MAIL = ... # type: int
LOG_NDELAY = ... # type: int
LOG_NEWS = ... # type: int
LOG_NOTICE = ... # type: int
LOG_NOWAIT = ... # type: int
LOG_PERROR = ... # type: int
LOG_PID = ... # type: int
LOG_SYSLOG = ... # type: int
LOG_USER = ... # type: int
LOG_UUCP = ... # type: int
LOG_WARNING = ... # type: int
def LOG_MASK(a: int) -> int: ...
def LOG_UPTO(a: int) -> int: ...
def closelog() -> None: ...
def openlog(ident: str = ..., logoption: int = ..., facility: int = ...) -> None: ...
def setlogmask(x: int) -> int: ...
def syslog(priority: int, message: str) -> None: ...
mypy-0.470/typeshed/stdlib/2/_sre.pyi 0000644 0000000 0000000 00000004046 13035744274 016157 0 ustar root root """Stub file for the '_sre' module."""
from typing import Any, Union, Iterable, Optional, Mapping, Sequence, Dict, List, Tuple, overload
CODESIZE = ... # type: int
MAGIC = ... # type: int
MAXREPEAT = ... # type: long
copyright = ... # type: str
class SRE_Match(object):
def start(self, group: int = ...) -> int:
raise IndexError()
def end(self, group: int = ...) -> int:
raise IndexError()
def expand(self, s: str) -> Any: ...
@overload
def group(self) -> str: ...
@overload
def group(self, group: int = ...) -> Optional[str]: ...
def groupdict(self) -> Dict[int, Optional[str]]: ...
def groups(self) -> Tuple[Optional[str]]: ...
def span(self) -> Tuple[int, int]:
raise IndexError()
class SRE_Scanner(object):
pattern = ... # type: str
def match(self) -> SRE_Match: ...
def search(self) -> SRE_Match: ...
class SRE_Pattern(object):
pattern = ... # type: str
flags = ... # type: int
groups = ... # type: int
groupindex = ... # type: Mapping[int, int]
indexgroup = ... # type: Sequence[int]
def findall(self, source: str, pos: int = ..., endpos: int = ...) -> List[Union[tuple, str]]: ...
def finditer(self, source: str, pos: int = ..., endpos: int = ...) -> Iterable[Union[tuple, str]]: ...
def match(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
def scanner(self, s: str, start: int = ..., end: int = ...) -> SRE_Scanner: ...
def search(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
def split(self, source: str, maxsplit: int = ...) -> List[Optional[str]]: ...
def sub(self, repl: str, string: str, count: int = ...) -> tuple: ...
def subn(self, repl: str, string: str, count: int = ...) -> tuple: ...
def compile(pattern: str, flags: int, code: List[int],
groups: int = ...,
groupindex: Mapping[int, int] = ...,
indexgroup: Sequence[int] = ...) -> SRE_Pattern:
raise OverflowError()
def getcodesize() -> int: ...
def getlower(a: int, b: int) -> int: ...
mypy-0.470/typeshed/stdlib/2/_weakref.pyi 0000644 0000000 0000000 00000001165 13035744274 017011 0 ustar root root from typing import Any, Callable, Generic, Optional, TypeVar
_T = TypeVar('_T')
class CallableProxyType(object): # "weakcallableproxy"
pass
class ProxyType(object): # "weakproxy"
pass
class ReferenceType(Generic[_T]):
# TODO rest of members
def __init__(self, o: _T, callback: Callable[[ReferenceType[_T]],
Any] = ...) -> None: ...
def __call__(self) -> Optional[_T]: ...
ref = ReferenceType
def getweakrefcount(object: Any) -> int: ...
def getweakrefs(object: Any) -> int: ...
def proxy(object: Any, callback: Callable[[Any], Any] = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2/shutil.pyi 0000644 0000000 0000000 00000003202 13035744274 016530 0 ustar root root # Stubs for shutil (Python 2)
#
# NOTE: Based on a dynamically typed stub automatically generated by stubgen.
from typing import List, Iterable, Callable, IO, AnyStr, Any, Optional, Tuple, Sequence
class Error(EnvironmentError): ...
class SpecialFileError(EnvironmentError): ...
class ExecError(EnvironmentError): ...
def copyfileobj(fsrc: IO[AnyStr], fdst: IO[AnyStr], length: int = ...) -> None: ...
def copyfile(src: unicode, dst: unicode) -> None: ...
def copymode(src: unicode, dst: unicode) -> None: ...
def copystat(src: unicode, dst: unicode) -> None: ...
def copy(src: unicode, dst: unicode) -> None: ...
def copy2(src: unicode, dst: unicode) -> None: ...
def ignore_patterns(*patterns: AnyStr) -> Callable[[AnyStr, List[AnyStr]], Iterable[AnyStr]]: ...
def copytree(src: AnyStr, dst: AnyStr, symlinks: bool = ...,
ignore: Optional[Callable[[AnyStr, List[AnyStr]], Iterable[AnyStr]]] = ...) -> None: ...
def rmtree(path: AnyStr, ignore_errors: bool = ...,
onerror: Callable[[Any, AnyStr, Any], None] = ...) -> None: ...
def move(src: unicode, dst: unicode) -> None: ...
def get_archive_formats() -> List[Tuple[str, str]]: ...
def register_archive_format(name: str, function: Callable[..., Any],
extra_args: Sequence[Tuple[str, Any]] = ...,
description: str = ...) -> None: ...
def unregister_archive_format(name: str) -> None: ...
def make_archive(base_name: AnyStr, format: str, root_dir: unicode = ...,
base_dir: unicode = ..., verbose: int = ..., dry_run: int = ...,
owner: str = ..., group: str = ..., logger: Any = ...) -> AnyStr: ...
mypy-0.470/typeshed/stdlib/2/csv.pyi 0000644 0000000 0000000 00000005312 13023631176 016010 0 ustar root root # Stubs for csv (Python 2.7)
#
# NOTE: Based on a dynamically typed stub automatically generated by stubgen.
from typing import Any, Dict, Iterable, List, Sequence, Union
# Public interface of _csv.reader's return type
class _Reader(Iterable[List[str]]):
dialect = ... # type: Dialect
line_num = ... # type: int
def next(self) -> List[str]: ...
_Row = Sequence[Union[str, int]]
# Public interface of _csv.writer's return type
class _Writer:
dialect = ... # type: Dialect
def writerow(self, row: _Row) -> None: ...
def writerows(self, rows: Iterable[_Row]) -> None: ...
QUOTE_ALL = ... # type: int
QUOTE_MINIMAL = ... # type: int
QUOTE_NONE = ... # type: int
QUOTE_NONNUMERIC = ... # type: int
class Error(Exception): ...
_Dialect = Union[str, Dialect]
def writer(csvfile: Any, dialect: _Dialect = ..., **fmtparams) -> _Writer: ...
def reader(csvfile: Iterable[str], dialect: _Dialect = ..., **fmtparams) -> _Reader: ...
def register_dialect(name, dialect=..., **fmtparams): ...
def unregister_dialect(name): ...
def get_dialect(name: str) -> Dialect: ...
def list_dialects(): ...
def field_size_limit(new_limit: int = ...) -> int: ...
class Dialect:
delimiter = ... # type: str
quotechar = ... # type: str
escapechar = ... # type: str
doublequote = ... # type: bool
skipinitialspace = ... # type: bool
lineterminator = ... # type: str
quoting = ... # type: int
def __init__(self) -> None: ...
class excel(Dialect):
pass
class excel_tab(excel):
pass
class unix_dialect(Dialect):
pass
class DictReader(Iterable):
restkey = ... # type: Any
restval = ... # type: Any
reader = ... # type: Any
dialect = ... # type: _Dialect
line_num = ... # type: int
fieldnames = ... # type: Sequence[Any]
def __init__(self, f: Iterable[str], fieldnames: Sequence[Any] = ..., restkey=...,
restval=..., dialect: _Dialect = ..., *args, **kwds) -> None: ...
def __iter__(self): ...
def __next__(self): ...
_DictRow = Dict[Any, Union[str, int]]
class DictWriter:
fieldnames = ... # type: Any
restval = ... # type: Any
extrasaction = ... # type: Any
writer = ... # type: Any
def __init__(self, f: Any, fieldnames: Sequence[Any], restval=..., extrasaction: str = ...,
dialect: _Dialect = ..., *args, **kwds) -> None: ...
def writeheader(self) -> None: ...
def writerow(self, rowdict: _DictRow) -> None: ...
def writerows(self, rowdicts: Iterable[_DictRow]) -> None: ...
class Sniffer:
preferred = ... # type: Any
def __init__(self) -> None: ...
def sniff(self, sample: str, delimiters: str = ...) -> Dialect: ...
def has_header(self, sample: str) -> bool: ...
mypy-0.470/typeshed/stdlib/2/pdb.pyi 0000644 0000000 0000000 00000001146 13023631176 015763 0 ustar root root # Stub for pdb (incomplete, only some global functions)
from typing import Any, Dict
def run(statement: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> None:
...
def runeval(expression: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> Any:
...
def runctx(statement: str,
globals: Dict[str, Any],
locals: Dict[str, Any]) -> None:
...
def runcall(*args: Any, **kwds: Any) -> Any:
...
def set_trace() -> None:
...
def post_mortem(t: Any = None) -> None:
...
def pm() -> None:
...
mypy-0.470/typeshed/stdlib/2/builtins.pyi 0000644 0000000 0000000 00000115742 13044257024 017056 0 ustar root root # Stubs for builtins (Python 2.7)
# True and False are deliberately omitted because they are keywords in
# Python 3, and stub files conform to Python 3 syntax.
from typing import (
TypeVar, Iterator, Iterable, overload,
Sequence, Mapping, Tuple, List, Any, Dict, Callable, Generic, Set,
AbstractSet, FrozenSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
SupportsRound, IO, BinaryIO, Union, AnyStr, MutableSequence, MutableMapping,
MutableSet, ItemsView, KeysView, ValuesView, Optional, Container,
)
from abc import abstractmethod, ABCMeta
from mypy_extensions import NoReturn
_T = TypeVar('_T')
_T_co = TypeVar('_T_co', covariant=True)
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
_S = TypeVar('_S')
_T1 = TypeVar('_T1')
_T2 = TypeVar('_T2')
_T3 = TypeVar('_T3')
_T4 = TypeVar('_T4')
_TT = TypeVar('_TT', bound='type')
class staticmethod: pass # Special, only valid as a decorator.
class classmethod: pass # Special, only valid as a decorator.
class object:
__doc__ = ... # type: Optional[str]
__class__ = ... # type: type
__slots__ = ... # type: Optional[Union[str, unicode, Iterable[Union[str, unicode]]]]
def __init__(self) -> None: ...
def __new__(cls) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __eq__(self, o: object) -> bool: ...
def __ne__(self, o: object) -> bool: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __hash__(self) -> int: ...
def __format__(self, format_spec: str) -> str: ...
def __getattribute__(self, name: str) -> Any: ...
def __delattr__(self, name: str) -> None: ...
class type:
__bases__ = ... # type: Tuple[type, ...]
__name__ = ... # type: str
__module__ = ... # type: str
__dict__ = ... # type: Dict[unicode, Any]
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
# TODO: __new__ may have to be special and not a static method.
@overload
def __new__(cls, o: object) -> type: ...
@overload
def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
def __call__(self, *args: Any, **kwds: Any) -> Any: ...
# Only new-style classes
__mro__ = ... # type: Tuple[type, ...]
# Note: the documentation doesnt specify what the return type is, the standard
# implementation seems to be returning a list.
def mro(self) -> List[type]: ...
def __subclasses__(self: _TT) -> List[_TT]: ...
class int(SupportsInt, SupportsFloat, SupportsAbs[int]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: SupportsInt) -> None: ...
@overload
def __init__(self, x: Union[str, unicode, bytearray], base: int = 10) -> None: ...
def bit_length(self) -> int: ...
def __add__(self, x: int) -> int: ...
def __sub__(self, x: int) -> int: ...
def __mul__(self, x: int) -> int: ...
def __floordiv__(self, x: int) -> int: ...
def __div__(self, x: int) -> int: ...
def __truediv__(self, x: int) -> float: ...
def __mod__(self, x: int) -> int: ...
def __radd__(self, x: int) -> int: ...
def __rsub__(self, x: int) -> int: ...
def __rmul__(self, x: int) -> int: ...
def __rfloordiv__(self, x: int) -> int: ...
def __rdiv__(self, x: int) -> int: ...
def __rtruediv__(self, x: int) -> float: ...
def __rmod__(self, x: int) -> int: ...
def __pow__(self, x: int) -> Any: ... # Return type can be int or float, depending on x.
def __rpow__(self, x: int) -> Any: ...
def __and__(self, n: int) -> int: ...
def __or__(self, n: int) -> int: ...
def __xor__(self, n: int) -> int: ...
def __lshift__(self, n: int) -> int: ...
def __rshift__(self, n: int) -> int: ...
def __rand__(self, n: int) -> int: ...
def __ror__(self, n: int) -> int: ...
def __rxor__(self, n: int) -> int: ...
def __rlshift__(self, n: int) -> int: ...
def __rrshift__(self, n: int) -> int: ...
def __neg__(self) -> int: ...
def __pos__(self) -> int: ...
def __invert__(self) -> int: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: int) -> bool: ...
def __le__(self, x: int) -> bool: ...
def __gt__(self, x: int) -> bool: ...
def __ge__(self, x: int) -> bool: ...
def __str__(self) -> str: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def __abs__(self) -> int: ...
def __hash__(self) -> int: ...
class float(SupportsFloat, SupportsInt, SupportsAbs[float]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: SupportsFloat) -> None: ...
@overload
def __init__(self, x: unicode) -> None: ...
@overload
def __init__(self, x: bytearray) -> None: ...
def as_integer_ratio(self) -> Tuple[int, int]: ...
def hex(self) -> str: ...
def is_integer(self) -> bool: ...
@classmethod
def fromhex(cls, s: str) -> float: ...
def __add__(self, x: float) -> float: ...
def __sub__(self, x: float) -> float: ...
def __mul__(self, x: float) -> float: ...
def __floordiv__(self, x: float) -> float: ...
def __div__(self, x: float) -> float: ...
def __truediv__(self, x: float) -> float: ...
def __mod__(self, x: float) -> float: ...
def __pow__(self, x: float) -> float: ...
def __radd__(self, x: float) -> float: ...
def __rsub__(self, x: float) -> float: ...
def __rmul__(self, x: float) -> float: ...
def __rfloordiv__(self, x: float) -> float: ...
def __rdiv__(self, x: float) -> float: ...
def __rtruediv__(self, x: float) -> float: ...
def __rmod__(self, x: float) -> float: ...
def __rpow__(self, x: float) -> float: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: float) -> bool: ...
def __le__(self, x: float) -> bool: ...
def __gt__(self, x: float) -> bool: ...
def __ge__(self, x: float) -> bool: ...
def __neg__(self) -> float: ...
def __pos__(self) -> float: ...
def __str__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class complex(SupportsAbs[float]):
@overload
def __init__(self, re: float = 0.0, im: float = 0.0) -> None: ...
@overload
def __init__(self, s: str) -> None: ...
@property
def real(self) -> float: ...
@property
def imag(self) -> float: ...
def conjugate(self) -> complex: ...
def __add__(self, x: complex) -> complex: ...
def __sub__(self, x: complex) -> complex: ...
def __mul__(self, x: complex) -> complex: ...
def __pow__(self, x: complex) -> complex: ...
def __div__(self, x: complex) -> complex: ...
def __truediv__(self, x: complex) -> complex: ...
def __radd__(self, x: complex) -> complex: ...
def __rsub__(self, x: complex) -> complex: ...
def __rmul__(self, x: complex) -> complex: ...
def __rpow__(self, x: complex) -> complex: ...
def __rdiv__(self, x: complex) -> complex: ...
def __rtruediv__(self, x: complex) -> complex: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __neg__(self) -> complex: ...
def __pos__(self) -> complex: ...
def __str__(self) -> str: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class basestring(metaclass=ABCMeta): ...
class unicode(basestring, Sequence[unicode]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
def capitalize(self) -> unicode: ...
def center(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def count(self, x: unicode) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
end: int = ...) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> unicode: ...
def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def format(self, *args: Any, **kwargs: Any) -> unicode: ...
def format_map(self, map: Mapping[unicode, Any]) -> unicode: ...
def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def isidentifier(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isprintable(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[unicode]) -> unicode: ...
def ljust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def lower(self) -> unicode: ...
def lstrip(self, chars: unicode = ...) -> unicode: ...
def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...
def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
def rstrip(self, chars: unicode = ...) -> unicode: ...
def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
end: int = ...) -> bool: ...
def strip(self, chars: unicode = ...) -> unicode: ...
def swapcase(self) -> unicode: ...
def title(self) -> unicode: ...
def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
def upper(self) -> unicode: ...
def zfill(self, width: int) -> unicode: ...
@overload
def __getitem__(self, i: int) -> unicode: ...
@overload
def __getitem__(self, s: slice) -> unicode: ...
def __getslice__(self, start: int, stop: int) -> unicode: ...
def __add__(self, s: unicode) -> unicode: ...
def __mul__(self, n: int) -> unicode: ...
def __mod__(self, x: Any) -> unicode: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: unicode) -> bool: ...
def __le__(self, x: unicode) -> bool: ...
def __gt__(self, x: unicode) -> bool: ...
def __ge__(self, x: unicode) -> bool: ...
def __len__(self) -> int: ...
def __contains__(self, s: object) -> bool: ...
def __iter__(self) -> Iterator[unicode]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
class str(basestring, Sequence[str]):
def __init__(self, object: object) -> None: ...
def capitalize(self) -> str: ...
def center(self, width: int, fillchar: str = ...) -> str: ...
def count(self, x: unicode) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> str: ...
def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def format(self, *args: Any, **kwargs: Any) -> str: ...
def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...
def ljust(self, width: int, fillchar: str = ...) -> str: ...
def lower(self) -> str: ...
@overload
def lstrip(self, chars: str = ...) -> str: ...
@overload
def lstrip(self, chars: unicode) -> unicode: ...
@overload
def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
@overload
def partition(self, sep: str) -> Tuple[str, str, str]: ...
@overload
def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ...
def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: str = ...) -> str: ...
@overload
def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
@overload
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
@overload
def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
@overload
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
@overload
def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
@overload
def rstrip(self, chars: str = ...) -> str: ...
@overload
def rstrip(self, chars: unicode) -> unicode: ...
@overload
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
@overload
def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
def splitlines(self, keepends: bool = ...) -> List[str]: ...
def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
@overload
def strip(self, chars: str = ...) -> str: ...
@overload
def strip(self, chars: unicode) -> unicode: ...
def swapcase(self) -> str: ...
def title(self) -> str: ...
def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
def upper(self) -> str: ...
def zfill(self, width: int) -> str: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[str]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> str: ...
@overload
def __getitem__(self, s: slice) -> str: ...
def __getslice__(self, start: int, stop: int) -> str: ...
def __add__(self, s: AnyStr) -> AnyStr: ...
def __mul__(self, n: int) -> str: ...
def __rmul__(self, n: int) -> str: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: unicode) -> bool: ...
def __le__(self, x: unicode) -> bool: ...
def __gt__(self, x: unicode) -> bool: ...
def __ge__(self, x: unicode) -> bool: ...
def __mod__(self, x: Any) -> str: ...
class bytearray(MutableSequence[int]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: Union[Iterable[int], str]) -> None: ...
@overload
def __init__(self, x: unicode, encoding: unicode,
errors: unicode = ...) -> None: ...
@overload
def __init__(self, length: int) -> None: ...
def capitalize(self) -> bytearray: ...
def center(self, width: int, fillchar: str = ...) -> bytearray: ...
def count(self, x: str) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[str, Tuple[str, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> bytearray: ...
def find(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def index(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def insert(self, index: int, object: int) -> None: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[str]) -> bytearray: ...
def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...
def lower(self) -> bytearray: ...
def lstrip(self, chars: str = ...) -> bytearray: ...
def partition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
def replace(self, old: str, new: str, count: int = ...) -> bytearray: ...
def rfind(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def rindex(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def rjust(self, width: int, fillchar: str = ...) -> bytearray: ...
def rpartition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def rstrip(self, chars: str = ...) -> bytearray: ...
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool: ...
def strip(self, chars: str = ...) -> bytearray: ...
def swapcase(self) -> bytearray: ...
def title(self) -> bytearray: ...
def translate(self, table: str) -> bytearray: ...
def upper(self) -> bytearray: ...
def zfill(self, width: int) -> bytearray: ...
@staticmethod
def fromhex(x: str) -> bytearray: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytearray: ...
def __getslice__(self, start: int, stop: int) -> bytearray: ...
@overload
def __setitem__(self, i: int, x: int) -> None: ...
@overload
def __setitem__(self, s: slice, x: Union[Iterable[int], str]) -> None: ...
def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __delslice__(self, start: int, stop: int) -> None: ...
def __add__(self, s: str) -> bytearray: ...
def __mul__(self, n: int) -> bytearray: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: str) -> bool: ...
def __le__(self, x: str) -> bool: ...
def __gt__(self, x: str) -> bool: ...
def __ge__(self, x: str) -> bool: ...
class bool(int, SupportsInt, SupportsFloat):
def __init__(self, o: object = ...) -> None: ...
class slice:
start = 0
step = 0
stop = 0
def __init__(self, start: int, stop: int = 0, step: int = 0) -> None: ...
class tuple(Sequence[_T_co], Generic[_T_co]):
def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, x: object) -> bool: ...
@overload
def __getitem__(self, x: int) -> _T_co: ...
@overload
def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
def count(self, x: Any) -> int: ...
def index(self, x: Any) -> int: ...
class function:
# TODO name of the class (corresponds to Python 'function' class)
__name__ = ... # type: str
__module__ = ... # type: str
class list(MutableSequence[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def append(self, object: _T) -> None: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def pop(self, index: int = -1) -> _T: ...
def index(self, object: _T, start: int = 0, stop: int = ...) -> int: ...
def count(self, object: _T) -> int: ...
def insert(self, index: int, object: _T) -> None: ...
def remove(self, object: _T) -> None: ...
def reverse(self) -> None: ...
def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> List[_T]: ...
def __getslice__(self, start: int, stop: int) -> List[_T]: ...
@overload
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __delslice__(self, start: int, stop: int) -> None: ...
def __add__(self, x: List[_T]) -> List[_T]: ...
def __iadd__(self, x: Iterable[_T]) -> List[_T]: ...
def __mul__(self, n: int) -> List[_T]: ...
def __rmul__(self, n: int) -> List[_T]: ...
def __contains__(self, o: object) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
def __gt__(self, x: List[_T]) -> bool: ...
def __ge__(self, x: List[_T]) -> bool: ...
def __lt__(self, x: List[_T]) -> bool: ...
def __le__(self, x: List[_T]) -> bool: ...
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
# NOTE: Keyword arguments are special. If they are used, _KT must include
# str, but we have no way of enforcing it here.
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def has_key(self, k: _KT) -> bool: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
def get(self, k: _KT, default: _VT = None) -> _VT: ...
def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def keys(self) -> List[_KT]: ...
def values(self) -> List[_VT]: ...
def items(self) -> List[Tuple[_KT, _VT]]: ...
def iterkeys(self) -> Iterator[_KT]: ...
def itervalues(self) -> Iterator[_VT]: ...
def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
def viewkeys(self) -> KeysView[_KT]: ...
def viewvalues(self) -> ValuesView[_VT]: ...
def viewitems(self) -> ItemsView[_KT, _VT]: ...
@staticmethod
@overload
def fromkeys(seq: Sequence[_T]) -> Dict[_T, Any]: ... # TODO: Actually a class method (mypy/issues#328)
@staticmethod
@overload
def fromkeys(seq: Sequence[_T], value: _S) -> Dict[_T, _S]: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
class set(MutableSet[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
def add(self, element: _T) -> None: ...
def clear(self) -> None: ...
def copy(self) -> set[_T]: ...
def difference(self, *s: Iterable[Any]) -> set[_T]: ...
def difference_update(self, *s: Iterable[Any]) -> None: ...
def discard(self, element: _T) -> None: ...
def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
def intersection_update(self, *s: Iterable[Any]) -> None: ...
def isdisjoint(self, s: Iterable[Any]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def symmetric_difference(self, s: Iterable[_T]) -> set[_T]: ...
def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
def union(self, *s: Iterable[_T]) -> set[_T]: ...
def update(self, *s: Iterable[_T]) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __iand__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ior__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __isub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ixor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
# TODO more set operations
class frozenset(FrozenSet[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def copy(self) -> frozenset[_T]: ...
def difference(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def intersection(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def isdisjoint(self, s: Iterable[_T]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def symmetric_difference(self, s: Iterable[_T]) -> frozenset[_T]: ...
def union(self, *s: Iterable[_T]) -> frozenset[_T]: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
def __init__(self, iterable: Iterable[_T], start: int = 0) -> None: ...
def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
def next(self) -> Tuple[int, _T]: ...
# TODO __getattribute__
class xrange(Sized, Iterable[int], Reversible[int]):
@overload
def __init__(self, stop: int) -> None: ...
@overload
def __init__(self, start: int, stop: int, step: int = 1) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __getitem__(self, i: int) -> int: ...
def __reversed__(self) -> Iterator[int]: ...
class module:
__name__ = ... # type: str
__file__ = ... # type: str
__dict__ = ... # type: Dict[unicode, Any]
class property:
def __init__(self, fget: Callable[[Any], Any] = None,
fset: Callable[[Any, Any], None] = None,
fdel: Callable[[Any], None] = None, doc: str = None) -> None: ...
def getter(self, fget: Callable[[Any], Any]) -> property: ...
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
def __get__(self, obj: Any, type: type=None) -> Any: ...
def __set__(self, obj: Any, value: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
long = int
bytes = str
NotImplemented = ... # type: Any
def abs(n: SupportsAbs[_T]) -> _T: ...
def all(i: Iterable) -> bool: ...
def any(i: Iterable) -> bool: ...
def bin(number: int) -> str: ...
def callable(o: object) -> bool: ...
def chr(code: int) -> str: ...
def compile(source: Any, filename: unicode, mode: str, flags: int = 0,
dont_inherit: int = 0) -> Any: ...
def delattr(o: Any, name: unicode) -> None: ...
def dir(o: object = ...) -> List[str]: ...
@overload
def divmod(a: int, b: int) -> Tuple[int, int]: ...
@overload
def divmod(a: float, b: float) -> Tuple[float, float]: ...
def exit(code: int = ...) -> NoReturn: ...
@overload
def filter(function: Callable[[_T], Any],
iterable: Iterable[_T]) -> List[_T]: ...
@overload
def filter(function: None,
iterable: Iterable[Optional[_T]]) -> List[_T]: ...
def format(o: object, format_spec: str = '') -> str: ... # TODO unicode
def getattr(o: Any, name: unicode, default: Any = None) -> Any: ...
def hasattr(o: Any, name: unicode) -> bool: ...
def hash(o: object) -> int: ...
def hex(i: int) -> str: ... # TODO __index__
def id(o: object) -> int: ...
def input(prompt: unicode = ...) -> Any: ...
def intern(string: str) -> str: ...
@overload
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def iter(function: Callable[[], _T], sentinel: _T) -> Iterator[_T]: ...
def isinstance(o: object, t: Union[type, Tuple[type, ...]]) -> bool: ...
def issubclass(cls: type, classinfo: Union[type, Tuple[type, ...]]) -> bool: ...
def len(o: Sized) -> int: ...
@overload
def map(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> List[_S]: ...
@overload
def map(func: Callable[[_T1, _T2], _S],
iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> List[_S]: ... # TODO more than two iterables
@overload
def max(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def max(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def min(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def min(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def next(i: Iterator[_T]) -> _T: ...
@overload
def next(i: Iterator[_T], default: _T) -> _T: ...
def oct(i: int) -> str: ... # TODO __index__
@overload
def open(file: str, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
@overload
def open(file: unicode, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
@overload
def open(file: int, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
def ord(c: unicode) -> int: ...
# This is only available after from __future__ import print_function.
def print(*values: Any, sep: unicode = u' ', end: unicode = u'\n',
file: IO[Any] = ...) -> None: ...
@overload
def pow(x: int, y: int) -> Any: ... # The return type can be int or float, depending on y.
@overload
def pow(x: int, y: int, z: int) -> Any: ...
@overload
def pow(x: float, y: float) -> float: ...
@overload
def pow(x: float, y: float, z: float) -> float: ...
def quit(code: int = ...) -> None: ...
def range(x: int, y: int = 0, step: int = 1) -> List[int]: ...
def raw_input(prompt: unicode = ...) -> str: ...
@overload
def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], initializer: _T) -> _T: ...
@overload
def reduce(function: Callable[[_T, _T], _T], iterable: Iterable[_T]) -> _T: ...
def reload(module: Any) -> Any: ...
@overload
def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
@overload
def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
def repr(o: object) -> str: ...
@overload
def round(number: float) -> float: ...
@overload
def round(number: float, ndigits: int) -> float: ... # Always return a float if given ndigits.
@overload
def round(number: SupportsRound[_T]) -> _T: ...
@overload
def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
def setattr(object: Any, name: unicode, value: Any) -> None: ...
def sorted(iterable: Iterable[_T], *,
cmp: Callable[[_T, _T], int] = ...,
key: Callable[[_T], Any] = ...,
reverse: bool = ...) -> List[_T]: ...
def sum(iterable: Iterable[_T], start: _T = ...) -> _T: ...
def unichr(i: int) -> unicode: ...
def vars(object: Any = ...) -> Dict[str, Any]: ...
@overload
def zip(iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
@overload
def zip(iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2,
_T3, _T4]]: ... # TODO more than four iterables
def __import__(name: unicode,
globals: Dict[str, Any] = ...,
locals: Dict[str, Any] = ...,
fromlist: List[str] = ..., level: int = ...) -> Any: ...
def globals() -> Dict[str, Any]: ...
def locals() -> Dict[str, Any]: ...
# Actually the type of Ellipsis is , but since it's
# not exposed anywhere under that name, we make it private here.
class ellipsis: ...
Ellipsis = ... # type: ellipsis
# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
AnyBuffer = TypeVar('AnyBuffer', str, unicode, bytearray, buffer)
class buffer(Sized):
def __init__(self, object: AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
def __add__(self, other: AnyBuffer) -> str: ...
def __cmp__(self, other: AnyBuffer) -> bool: ...
def __getitem__(self, key: Union[int, slice]) -> str: ...
def __getslice__(self, i: int, j: int) -> str: ...
def __len__(self) -> int: ...
def __mul__(self, x: int) -> str: ...
class memoryview(Sized, Container[bytes]):
format = ... # type: str
itemsize = ... # type: int
shape = ... # type: Optional[Tuple[int, ...]]
strides = ... # type: Optional[Tuple[int, ...]]
suboffsets = ... # type: Optional[Tuple[int, ...]]
readonly = ... # type: bool
ndim = ... # type: int
def __init__(self, obj: Union[str, bytearray, buffer, memoryview]) -> None: ...
@overload
def __getitem__(self, i: int) -> bytes: ...
@overload
def __getitem__(self, s: slice) -> memoryview: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
def __len__(self) -> int: ...
@overload
def __setitem__(self, i: int, o: bytes) -> None: ...
@overload
def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
@overload
def __setitem__(self, s: slice, o: memoryview) -> None: ...
def tobytes(self) -> bytes: ...
def tolist(self) -> List[int]: ...
class BaseException:
args = ... # type: Tuple[Any, ...]
message = ... # type: str
def __init__(self, *args: Any) -> None: ...
class GeneratorExit(BaseException): ...
class KeyboardInterrupt(BaseException): ...
class SystemExit(BaseException):
code = 0
class Exception(BaseException): ...
class StopIteration(Exception): ...
class StandardError(Exception): ...
class ArithmeticError(StandardError): ...
class BufferError(StandardError): ...
class EnvironmentError(StandardError):
errno = 0
strerror = ... # type: str
# TODO can this be unicode?
filename = ... # type: str
class LookupError(StandardError): ...
class RuntimeError(StandardError): ...
class ValueError(StandardError): ...
class AssertionError(StandardError): ...
class AttributeError(StandardError): ...
class EOFError(StandardError): ...
class FloatingPointError(ArithmeticError): ...
class IOError(EnvironmentError): ...
class ImportError(StandardError): ...
class IndexError(LookupError): ...
class KeyError(LookupError): ...
class MemoryError(StandardError): ...
class NameError(StandardError): ...
class NotImplementedError(RuntimeError): ...
class OSError(EnvironmentError): ...
class WindowsError(OSError):
winerror = ... # type: int
class OverflowError(ArithmeticError): ...
class ReferenceError(StandardError): ...
class SyntaxError(StandardError):
msg = ... # type: str
lineno = ... # type: int
offset = ... # type: int
text = ... # type: str
class IndentationError(SyntaxError): ...
class TabError(IndentationError): ...
class SystemError(StandardError): ...
class TypeError(StandardError): ...
class UnboundLocalError(NameError): ...
class UnicodeError(ValueError): ...
class UnicodeDecodeError(UnicodeError): ...
class UnicodeEncodeError(UnicodeError): ...
class UnicodeTranslateError(UnicodeError): ...
class ZeroDivisionError(ArithmeticError): ...
class Warning(Exception): ...
class UserWarning(Warning): ...
class DeprecationWarning(Warning): ...
class SyntaxWarning(Warning): ...
class RuntimeWarning(Warning): ...
class FutureWarning(Warning): ...
class PendingDeprecationWarning(Warning): ...
class ImportWarning(Warning): ...
class UnicodeWarning(Warning): ...
class BytesWarning(Warning): ...
class ResourceWarning(Warning): ...
def eval(s: str, globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...) -> Any: ...
def exec(object: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> Any: ... # TODO code object as source
def cmp(x: Any, y: Any) -> int: ...
def execfile(filename: str, globals: Dict[str, Any] = None, locals: Dict[str, Any] = None) -> None: ...
class file(BinaryIO):
@overload
def __init__(self, file: str, mode: str = 'r', buffering: int = ...) -> None: ...
@overload
def __init__(self, file: unicode, mode: str = 'r', buffering: int = ...) -> None: ...
@overload
def __init__(self, file: int, mode: str = 'r', buffering: int = ...) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def read(self, n: int = ...) -> str: ...
def __enter__(self) -> BinaryIO: ...
def __exit__(self, t: type = None, exc: BaseException = None, tb: Any = None) -> bool: ...
def flush(self) -> None: ...
def fileno(self) -> int: ...
def isatty(self) -> bool: ...
def close(self) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def seekable(self) -> bool: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def tell(self) -> int: ...
def readline(self, limit: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def write(self, data: str) -> None: ...
def writelines(self, data: Iterable[str]) -> None: ...
def truncate(self, pos: int = ...) -> int: ...
# Very old builtins
def apply(func: Callable[..., _T], args: Sequence[Any] = None, kwds: Mapping[str, Any] = None) -> _T: ...
_N = TypeVar('_N', bool, int, float, complex)
def coerce(x: _N, y: _N) -> Tuple[_N, _N]: ...
mypy-0.470/typeshed/stdlib/2/types.pyi 0000644 0000000 0000000 00000012043 13044257024 016357 0 ustar root root # Stubs for types
# Note, all classes "defined" here require special handling.
from typing import (
Any, Callable, Dict, Iterable, Iterator, List, Optional,
Tuple, TypeVar, Union, overload,
)
_T = TypeVar('_T')
class NoneType: ...
TypeType = type
ObjectType = object
IntType = int
LongType = long
FloatType = float
BooleanType = bool
ComplexType = complex
StringType = str
UnicodeType = unicode
StringTypes = (StringType, UnicodeType)
BufferType = buffer
TupleType = tuple
ListType = list
DictType = DictionaryType = dict
class _Cell:
cell_contents = ... # type: Any
class FunctionType:
func_closure = ... # type: Optional[Tuple[_Cell, ...]]
func_code = ... # type: CodeType
func_defaults = ... # type: Optional[Tuple[Any, ...]]
func_dict = ... # type: Dict[str, Any]
func_doc = ... # type: Optional[str]
func_globals = ... # type: Dict[str, Any]
func_name = ... # type: str
__closure__ = func_closure
__code__ = func_code
__defaults__ = func_defaults
__dict__ = func_dict
__globals__ = func_globals
__name__ = func_name
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Optional[object], type: Optional[type]) -> 'UnboundMethodType': ...
LambdaType = FunctionType
class CodeType:
co_argcount = ... # type: int
co_cellvars = ... # type: Tuple[str, ...]
co_code = ... # type: str
co_consts = ... # type: Tuple[Any, ...]
co_filename = ... # type: Optional[str]
co_firstlineno = ... # type: int
co_flags = ... # type: int
co_freevars = ... # type: Tuple[str, ...]
co_lnotab = ... # type: str
co_name = ... # type: str
co_names = ... # type: Tuple[str, ...]
co_nlocals = ... # type: int
co_stacksize = ... # type: int
co_varnames = ... # type: Tuple[str, ...]
class GeneratorType:
gi_code = ... # type: CodeType
gi_frame = ... # type: FrameType
gi_running = ... # type: int
def __iter__(self) -> 'GeneratorType': ...
def close(self) -> None: ...
def next(self) -> Any: ...
def send(self, arg: Any) -> Any: ...
@overload
def throw(self, val: BaseException) -> Any: ...
@overload
def throw(self, typ: type, val: BaseException = ..., tb: 'TracebackType' = ...) -> Any: ...
class ClassType: ...
class UnboundMethodType:
im_class = ... # type: type
im_func = ... # type: FunctionType
im_self = ... # type: Optional[object]
__func__ = im_func
__self__ = im_self
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
class InstanceType: ...
MethodType = UnboundMethodType
class BuiltinFunctionType:
__self__ = ... # type: Optional[object]
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
BuiltinMethodType = BuiltinFunctionType
class ModuleType:
__doc__ = ... # type: Optional[str]
__file__ = ... # type: Optional[str]
__name__ = ... # type: str
__package__ = ... # type: Optional[str]
__path__ = ... # type: Optional[Iterable[str]]
def __init__(self, name: str, doc: str) -> None: ...
FileType = file
XRangeType = xrange
class TracebackType:
tb_frame = ... # type: FrameType
tb_lasti = ... # type: int
tb_lineno = ... # type: int
tb_next = ... # type: TracebackType
class FrameType:
f_back = ... # type: FrameType
f_builtins = ... # type: Dict[str, Any]
f_code = ... # type: CodeType
f_exc_type = ... # type: None
f_exc_value = ... # type: None
f_exc_traceback = ... # type: None
f_globals = ... # type: Dict[str, Any]
f_lasti = ... # type: int
f_lineno = ... # type: int
f_locals = ... # type: Dict[str, Any]
f_restricted = ... # type: bool
f_trace = ... # type: Callable[[], None]
def clear(self) -> None: pass
SliceType = slice
class EllipsisType: ...
class DictProxyType:
# TODO is it possible to have non-string keys?
# no __init__
def copy(self) -> dict: ...
def get(self, key: str, default: _T = ...) -> Union[Any, _T]: ...
def has_key(self, key: str) -> bool: ...
def items(self) -> List[Tuple[str, Any]]: ...
def iteritems(self) -> Iterator[Tuple[str, Any]]: ...
def iterkeys(self) -> Iterator[str]: ...
def itervalues(self) -> Iterator[Any]: ...
def keys(self) -> List[str]: ...
def values(self) -> List[Any]: ...
def __contains__(self, key: str) -> bool: ...
def __getitem__(self, key: str) -> Any: ...
def __iter__(self) -> Iterator[str]: ...
def __len__(self) -> int: ...
class NotImplementedType: ...
class GetSetDescriptorType:
__name__ = ... # type: str
__objclass__ = ... # type: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
# Same type on Jython, different on CPython and PyPy, unknown on IronPython.
class MemberDescriptorType:
__name__ = ... # type: str
__objclass__ = ... # type: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
mypy-0.470/typeshed/stdlib/2/md5.pyi 0000644 0000000 0000000 00000000423 13023631176 015700 0 ustar root root # Stubs for Python 2.7 md5 stdlib module
class md5(object):
def update(self, arg: str) -> None: ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def copy(self) -> md5: ...
def new(string: str = ...) -> md5: ...
blocksize = 0
digest_size = 0
mypy-0.470/typeshed/stdlib/2/inspect.pyi 0000644 0000000 0000000 00000006327 13035744274 016700 0 ustar root root # TODO incomplete
from types import TracebackType, FrameType, ModuleType
from typing import Any, Callable, List, Optional, Tuple, Union, NamedTuple
# Types and members
ModuleInfo = NamedTuple('ModuleInfo', [('name', str),
('suffix', str),
('mode', str),
('module_type', int),
])
def getmembers(
object: object,
predicate: Callable[[Any], bool] = ...
) -> List[Tuple[str, Any]]: ...
def getmoduleinfo(path: str) -> Optional[ModuleInfo]: ...
def getmodulename(path: str) -> Optional[str]: ...
def ismodule(object: object) -> bool: ...
def isclass(object: object) -> bool: ...
def ismethod(object: object) -> bool: ...
def isfunction(object: object) -> bool: ...
def isisgeneratorfunction(object: object) -> bool: ...
def isgenerator(object: object) -> bool: ...
def istraceback(object: object) -> bool: ...
def isframe(object: object) -> bool: ...
def iscode(object: object) -> bool: ...
def isbuiltin(object: object) -> bool: ...
def isroutine(object: object) -> bool: ...
def isabstract(object: object) -> bool: ...
def ismethoddescriptor(object: object) -> bool: ...
def isdatadescriptor(object: object) -> bool: ...
def isgetsetdescriptor(object: object) -> bool: ...
def ismemberdescriptor(object: object) -> bool: ...
# Retrieving source code
def getdoc(object: object) -> str: ...
def getcomments(object: object) -> str: ...
def getfile(object: object) -> str: ...
def getmodule(object: object) -> ModuleType: ...
def getsourcefile(object: object) -> str: ...
# TODO restrict to "module, class, method, function, traceback, frame,
# or code object"
def getsourcelines(object: object) -> Tuple[List[str], int]: ...
# TODO restrict to "a module, class, method, function, traceback, frame,
# or code object"
def getsource(object: object) -> str: ...
def cleandoc(doc: str) -> str: ...
# Classes and functions
# TODO make the return type more specific
def getclasstree(classes: List[type], unique: bool = ...) -> Any: ...
ArgSpec = NamedTuple('ArgSpec', [('args', List[str]),
('varargs', str),
('keywords', str),
('defaults', tuple),
])
def getargspec(func: object) -> ArgSpec: ...
# TODO make the return type more specific
def getargvalues(frame: FrameType) -> Any: ...
# TODO formatargspec
# TODO formatargvalues
def getmro(cls: type) -> Tuple[type, ...]: ...
# TODO getcallargs
# The interpreter stack
Traceback = NamedTuple(
'Traceback',
[
('filename', str),
('lineno', int),
('function', str),
('code_context', List[str]),
('index', int),
]
)
_FrameRecord = Tuple[FrameType, str, int, str, List[str], int]
def getouterframes(frame: FrameType, context: int = ...) -> List[FrameType]: ...
def getframeinfo(frame: Union[FrameType, TracebackType], context: int = ...) -> Traceback: ...
def getinnerframes(traceback: TracebackType, context: int = ...) -> List[FrameType]: ...
def currentframe() -> FrameType: ...
def stack(context: int = ...) -> List[_FrameRecord]: ...
def trace(context: int = ...) -> List[_FrameRecord]: ...
mypy-0.470/typeshed/stdlib/2/_warnings.pyi 0000644 0000000 0000000 00000000663 13035744274 017217 0 ustar root root from typing import Any, List
default_action = ... # type: str
filters = ... # type: List[tuple]
once_registry = ... # type: dict
def warn(message: Warning, category: type = ..., stacklevel: int = ...) -> None: ...
def warn_explicit(message: Warning, category: type,
filename: str, lineno: int,
module: Any = ..., registry: dict = ...,
module_globals: dict = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2/HTMLParser.pyi 0000644 0000000 0000000 00000002125 13035744274 017144 0 ustar root root from typing import List, Tuple, AnyStr
from markupbase import ParserBase
class HTMLParser(ParserBase):
def __init__(self) -> None: ...
def feed(self, feed: AnyStr) -> None: ...
def close(self) -> None: ...
def reset(self) -> None: ...
def get_starttag_text(self) -> AnyStr: ...
def set_cdata_mode(self, AnyStr) -> None: ...
def clear_cdata_mode(self) -> None: ...
def handle_startendtag(self, tag: AnyStr, attrs: List[Tuple[AnyStr, AnyStr]]): ...
def handle_starttag(self, tag: AnyStr, attrs: List[Tuple[AnyStr, AnyStr]]): ...
def handle_endtag(self, tag: AnyStr): ...
def handle_charref(self, name: AnyStr): ...
def handle_entityref(self, name: AnyStr): ...
def handle_data(self, data: AnyStr): ...
def handle_comment(self, data: AnyStr): ...
def handle_decl(self, decl: AnyStr): ...
def handle_pi(self, data: AnyStr): ...
def unknown_decl(self, data: AnyStr): ...
def unescape(self, s: AnyStr) -> AnyStr: ...
class HTMLParseError(Exception):
msg = ... # type: str
lineno = ... # type: int
offset = ... # type: int
mypy-0.470/typeshed/stdlib/2/spwd.pyi 0000644 0000000 0000000 00000000633 13023631176 016173 0 ustar root root from typing import List
class struct_spwd(object):
sp_nam = ... # type: str
sp_pwd = ... # type: str
sp_lstchg = ... # type: int
sp_min = ... # type: int
sp_max = ... # type: int
sp_warn = ... # type: int
sp_inact = ... # type: int
sp_expire = ... # type: int
sp_flag = ... # type: int
def getspall() -> List[struct_spwd]: pass
def getspnam() -> struct_spwd: pass
mypy-0.470/typeshed/stdlib/2/thread.pyi 0000644 0000000 0000000 00000001744 13023631176 016471 0 ustar root root """Stubs for the "thread" module."""
from typing import Callable, Any
def _count() -> int: ...
class error(Exception): ...
class LockType:
def acquire(self, waitflag: int = ...) -> bool: ...
def acquire_lock(self, waitflag: int = ...) -> bool: ...
def release(self) -> None: ...
def release_lock(self) -> None: ...
def locked(self) -> bool: ...
def locked_lock(self) -> bool: ...
def __enter__(self) -> LockType: ...
def __exit__(self, value: Any, traceback: Any) -> None: ...
class _local(object):
pass
class _localdummy(object):
pass
def start_new(function: Callable[..., Any], args: Any, kwargs: Any = ...) -> int: ...
def start_new_thread(function: Callable[..., Any], args: Any, kwargs: Any = ...) -> int: ...
def interrupt_main() -> None: ...
def exit() -> None:
raise SystemExit()
def exit_thread() -> Any:
raise SystemExit()
def allocate_lock() -> LockType: ...
def get_ident() -> int: ...
def stack_size(size: int = ...) -> int: ...
mypy-0.470/typeshed/stdlib/2/imp.pyi 0000644 0000000 0000000 00000002665 13023631176 016012 0 ustar root root """Stubs for the 'imp' module."""
from typing import List, Optional, Tuple, Iterable, IO, Any
import types
C_BUILTIN = ... # type: int
C_EXTENSION = ... # type: int
IMP_HOOK = ... # type: int
PKG_DIRECTORY = ... # type: int
PY_CODERESOURCE = ... # type: int
PY_COMPILED = ... # type: int
PY_FROZEN = ... # type: int
PY_RESOURCE = ... # type: int
PY_SOURCE = ... # type: int
SEARCH_ERROR = ... # type: int
def acquire_lock() -> None: ...
def find_module(name: str, path: Iterable[str] = ...) -> Optional[Tuple[str, str, Tuple[str, str, int]]]: ...
def get_magic() -> str: ...
def get_suffixes() -> List[Tuple[str, str, int]]: ...
def init_builtin(name: str) -> types.ModuleType: ...
def init_frozen(name: str) -> types.ModuleType: ...
def is_builtin(name: str) -> int: ...
def is_frozen(name: str) -> bool: ...
def load_compiled(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
def load_dynamic(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
def load_module(name: str, file: str, pathname: str, description: Tuple[str, str, int]) -> types.ModuleType: ...
def load_source(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
def lock_held() -> bool: ...
def new_module(name: str) -> types.ModuleType: ...
def release_lock() -> None: ...
class NullImporter:
def __init__(self, path_string: str) -> None: ...
def find_module(self, fullname: str, path: str = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2/pprint.pyi 0000644 0000000 0000000 00000001527 13023631176 016535 0 ustar root root # Stubs for pprint (Python 2)
#
# NOTE: Based on a dynamically typed automatically generated by stubgen.
from typing import IO, Any
def pprint(object: Any, stream: IO[str] = ..., indent: int = ..., width: int = ...,
depth: int = ...) -> None: ...
def pformat(object: Any, indent: int =..., width: int =..., depth: int =...) -> str: ...
def saferepr(object): ...
def isreadable(object): ...
def isrecursive(object): ...
class PrettyPrinter:
def __init__(self,
indent: int = ...,
width: int = ...,
depth: int = ...,
stream: IO[Any] = ...) -> None: ...
def pprint(self, object: Any) -> str: ...
def pformat(self, object): ...
def isrecursive(self, object): ...
def isreadable(self, object): ...
def format(self, object, context, maxlevels, level): ...
mypy-0.470/typeshed/stdlib/2/weakref.pyi 0000644 0000000 0000000 00000003257 13035744274 016656 0 ustar root root # Stubs for weakref (Python 2)
#
# Based on stub automatically generated by stubgen.
from typing import Any, MutableMapping, Generic, Iterator, List, TypeVar
from _weakref import (getweakrefcount, getweakrefs, ref, proxy,
CallableProxyType, ProxyType, ReferenceType)
from _weakrefset import WeakSet
ProxyTypes = ... # type: Any
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
# Don't inherit from typing.Dict since
# isinstance(weakref.WeakValueDictionary(), dict) is False
class WeakValueDictionary(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
def itervaluerefs(self) -> Iterator[ReferenceType[_VT]]: ...
def valuerefs(self) -> List[ReferenceType[_VT]]: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_KT]: ...
def has_key(self, key: _KT) -> bool: ...
def copy(self) -> WeakValueDictionary[_KT, _VT]: ...
class WeakKeyDictionary(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
def iterkeyrefs(self) -> Iterator[ReferenceType[_KT]]: ...
def keyrefs(self) -> List[ReferenceType[_KT]]: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_KT]: ...
def has_key(self, key: _KT) -> bool: ...
def copy(self) -> WeakKeyDictionary[_KT, _VT]: ...
# TODO: make generic
class KeyedRef(ReferenceType):
key = ... # type: Any
def __new__(type, ob, callback, key): ...
def __init__(self, ob, callback, key): ...
mypy-0.470/typeshed/stdlib/2/_symtable.pyi 0000644 0000000 0000000 00000002116 13035744274 017202 0 ustar root root from typing import List, Dict
CELL = ... # type: int
DEF_BOUND = ... # type: int
DEF_FREE = ... # type: int
DEF_FREE_CLASS = ... # type: int
DEF_GLOBAL = ... # type: int
DEF_IMPORT = ... # type: int
DEF_LOCAL = ... # type: int
DEF_PARAM = ... # type: int
FREE = ... # type: int
GLOBAL_EXPLICIT = ... # type: int
GLOBAL_IMPLICIT = ... # type: int
LOCAL = ... # type: int
OPT_BARE_EXEC = ... # type: int
OPT_EXEC = ... # type: int
OPT_IMPORT_STAR = ... # type: int
SCOPE_MASK = ... # type: int
SCOPE_OFF = ... # type: int
TYPE_CLASS = ... # type: int
TYPE_FUNCTION = ... # type: int
TYPE_MODULE = ... # type: int
USE = ... # type: int
class _symtable_entry(object):
...
class symtable(object):
children = ... # type: List[_symtable_entry]
id = ... # type: int
lineno = ... # type: int
name = ... # type: str
nested = ... # type: int
optimized = ... # type: int
symbols = ... # type: Dict[str, int]
type = ... # type: int
varnames = ... # type: List[str]
def __init__(self, src: str, filename: str, startstr: str) -> None: ...
mypy-0.470/typeshed/stdlib/2/strop.pyi 0000644 0000000 0000000 00000003526 13035744274 016400 0 ustar root root """Stub file for the 'strop' module."""
from typing import List, Sequence
lowercase = ... # type: str
uppercase = ... # type: str
whitespace = ... # type: str
def atof(a: str) -> float:
raise DeprecationWarning()
def atoi(a: str, base: int = ...) -> int:
raise DeprecationWarning()
def atol(a: str, base: int = ...) -> long:
raise DeprecationWarning()
def capitalize(s: str) -> str:
raise DeprecationWarning()
def count(s: str, sub: str, start: int = ..., end: int = ...) -> int:
raise DeprecationWarning()
def expandtabs(string: str, tabsize: int = ...) -> str:
raise DeprecationWarning()
raise OverflowError()
def find(s: str, sub: str, start: int = ..., end: int = ...) -> int:
raise DeprecationWarning()
def join(list: Sequence[str], sep: str = ...) -> str:
raise DeprecationWarning()
raise OverflowError()
def joinfields(list: Sequence[str], sep: str = ...) -> str:
raise DeprecationWarning()
raise OverflowError()
def lower(s: str) -> str:
raise DeprecationWarning()
def lstrip(s: str) -> str:
raise DeprecationWarning()
def maketrans(frm: str, to: str) -> str: ...
def replace(s: str, old: str, new: str, maxsplit: int = ...) -> str:
raise DeprecationWarning()
def rfind(s: str, sub: str, start: int = ..., end: int = ...) -> int:
raise DeprecationWarning()
def rstrip(s: str) -> str:
raise DeprecationWarning()
def split(s: str, sep: str, maxsplit: int = ...) -> List[str]:
raise DeprecationWarning()
def splitfields(s: str, sep: str, maxsplit: int = ...) -> List[str]:
raise DeprecationWarning()
def strip(s: str) -> str:
raise DeprecationWarning()
def swapcase(s: str) -> str:
raise DeprecationWarning()
def translate(s: str, table: str, deletechars: str = ...) -> str:
raise DeprecationWarning()
def upper(s: str) -> str:
raise DeprecationWarning()
mypy-0.470/typeshed/stdlib/2/copy.pyi 0000644 0000000 0000000 00000000302 13023631176 016161 0 ustar root root # Stubs for copy
# NOTE: These are incomplete!
from typing import TypeVar, Dict, Any
_T = TypeVar('_T')
def deepcopy(x: _T, memo: Dict[Any, Any] = ...) -> _T: ...
def copy(x: _T) -> _T: ...
mypy-0.470/typeshed/stdlib/2/genericpath.pyi 0000644 0000000 0000000 00000000515 13023631176 017506 0 ustar root root # Stubs for genericpath (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class _unicode: ...
def exists(path): ...
def isfile(path): ...
def isdir(s): ...
def getsize(filename): ...
def getmtime(filename): ...
def getatime(filename): ...
def getctime(filename): ...
def commonprefix(m): ...
mypy-0.470/typeshed/stdlib/2/email/ 0000755 0000000 0000000 00000000000 13044320557 015561 5 ustar root root mypy-0.470/typeshed/stdlib/2/email/MIMEText.pyi 0000644 0000000 0000000 00000000424 13023631176 017677 0 ustar root root # Stubs for email.MIMEText (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from email.mime.nonmultipart import MIMENonMultipart
class MIMEText(MIMENonMultipart):
def __init__(self, _text, _subtype=..., _charset=...) -> None: ...
mypy-0.470/typeshed/stdlib/2/email/__init__.pyi 0000644 0000000 0000000 00000000416 13023631176 020043 0 ustar root root from typing import IO, Any, AnyStr
def message_from_string(s: AnyStr, *args, **kwargs): ...
def message_from_bytes(s: str, *args, **kwargs): ...
def message_from_file(fp: IO[AnyStr], *args, **kwargs): ...
def message_from_binary_file(fp: IO[str], *args, **kwargs): ...
mypy-0.470/typeshed/stdlib/2/email/_parseaddr.pyi 0000644 0000000 0000000 00000002422 13035744274 020416 0 ustar root root # Stubs for email._parseaddr (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def parsedate_tz(data): ...
def parsedate(data): ...
def mktime_tz(data): ...
def quote(str): ...
class AddrlistClass:
specials = ... # type: Any
pos = ... # type: Any
LWS = ... # type: Any
CR = ... # type: Any
FWS = ... # type: Any
atomends = ... # type: Any
phraseends = ... # type: Any
field = ... # type: Any
commentlist = ... # type: Any
def __init__(self, field): ...
def gotonext(self): ...
def getaddrlist(self): ...
def getaddress(self): ...
def getrouteaddr(self): ...
def getaddrspec(self): ...
def getdomain(self): ...
def getdelimited(self, beginchar, endchars, allowcomments=True): ...
def getquote(self): ...
def getcomment(self): ...
def getdomainliteral(self): ...
def getatom(self, atomends=None): ...
def getphraselist(self): ...
class AddressList(AddrlistClass):
addresslist = ... # type: Any
def __init__(self, field): ...
def __len__(self): ...
def __add__(self, other): ...
def __iadd__(self, other): ...
def __sub__(self, other): ...
def __isub__(self, other): ...
def __getitem__(self, index): ...
mypy-0.470/typeshed/stdlib/2/email/utils.pyi 0000644 0000000 0000000 00000001450 13023631176 017443 0 ustar root root # Stubs for email.utils (Python 2)
#
# Derived from stub automatically generated by stubgen.
from email._parseaddr import AddressList as _AddressList
from email._parseaddr import mktime_tz as mktime_tz
from email._parseaddr import parsedate as _parsedate
from email._parseaddr import parsedate_tz as _parsedate_tz
from quopri import decodestring as _qdecode
def formataddr(pair): ...
def getaddresses(fieldvalues): ...
def formatdate(timeval=None, localtime=False, usegmt=False): ...
def make_msgid(idstring=None): ...
def parsedate(data): ...
def parsedate_tz(data): ...
def parseaddr(addr): ...
def unquote(str): ...
def decode_rfc2231(s): ...
def encode_rfc2231(s, charset=None, language=None): ...
def decode_params(params): ...
def collapse_rfc2231_value(value, errors=..., fallback_charset=...): ...
mypy-0.470/typeshed/stdlib/2/email/mime/ 0000755 0000000 0000000 00000000000 13044320557 016510 5 ustar root root mypy-0.470/typeshed/stdlib/2/email/mime/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020757 0 ustar root root mypy-0.470/typeshed/stdlib/2/email/mime/text.pyi 0000644 0000000 0000000 00000000425 13023631176 020217 0 ustar root root # Stubs for email.mime.text (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from email.mime.nonmultipart import MIMENonMultipart
class MIMEText(MIMENonMultipart):
def __init__(self, _text, _subtype=..., _charset=...) -> None: ...
mypy-0.470/typeshed/stdlib/2/email/mime/multipart.pyi 0000644 0000000 0000000 00000000432 13023631176 021252 0 ustar root root # Stubs for email.mime.multipart (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from email.mime.base import MIMEBase
class MIMEMultipart(MIMEBase):
def __init__(self, _subtype=..., boundary=..., _subparts=..., **_params) -> None: ...
mypy-0.470/typeshed/stdlib/2/email/mime/base.pyi 0000644 0000000 0000000 00000000406 13035744274 020153 0 ustar root root # Stubs for email.mime.base (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# import message
# TODO
# class MIMEBase(message.Message):
class MIMEBase:
def __init__(self, _maintype, _subtype, **_params) -> None: ...
mypy-0.470/typeshed/stdlib/2/email/mime/nonmultipart.pyi 0000644 0000000 0000000 00000000351 13023631176 021765 0 ustar root root # Stubs for email.mime.nonmultipart (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from email.mime.base import MIMEBase
class MIMENonMultipart(MIMEBase):
def attach(self, payload): ...
mypy-0.470/typeshed/stdlib/2/_socket.pyi 0000644 0000000 0000000 00000022723 13023631176 016651 0 ustar root root from typing import Tuple, Union, IO, Any, Optional, overload
AF_APPLETALK = ... # type: int
AF_ASH = ... # type: int
AF_ATMPVC = ... # type: int
AF_ATMSVC = ... # type: int
AF_AX25 = ... # type: int
AF_BLUETOOTH = ... # type: int
AF_BRIDGE = ... # type: int
AF_DECnet = ... # type: int
AF_ECONET = ... # type: int
AF_INET = ... # type: int
AF_INET6 = ... # type: int
AF_IPX = ... # type: int
AF_IRDA = ... # type: int
AF_KEY = ... # type: int
AF_LLC = ... # type: int
AF_NETBEUI = ... # type: int
AF_NETLINK = ... # type: int
AF_NETROM = ... # type: int
AF_PACKET = ... # type: int
AF_PPPOX = ... # type: int
AF_ROSE = ... # type: int
AF_ROUTE = ... # type: int
AF_SECURITY = ... # type: int
AF_SNA = ... # type: int
AF_TIPC = ... # type: int
AF_UNIX = ... # type: int
AF_UNSPEC = ... # type: int
AF_WANPIPE = ... # type: int
AF_X25 = ... # type: int
AI_ADDRCONFIG = ... # type: int
AI_ALL = ... # type: int
AI_CANONNAME = ... # type: int
AI_NUMERICHOST = ... # type: int
AI_NUMERICSERV = ... # type: int
AI_PASSIVE = ... # type: int
AI_V4MAPPED = ... # type: int
BDADDR_ANY = ... # type: str
BDADDR_LOCAL = ... # type: str
BTPROTO_HCI = ... # type: int
BTPROTO_L2CAP = ... # type: int
BTPROTO_RFCOMM = ... # type: int
BTPROTO_SCO = ... # type: int
EAI_ADDRFAMILY = ... # type: int
EAI_AGAIN = ... # type: int
EAI_BADFLAGS = ... # type: int
EAI_FAIL = ... # type: int
EAI_FAMILY = ... # type: int
EAI_MEMORY = ... # type: int
EAI_NODATA = ... # type: int
EAI_NONAME = ... # type: int
EAI_OVERFLOW = ... # type: int
EAI_SERVICE = ... # type: int
EAI_SOCKTYPE = ... # type: int
EAI_SYSTEM = ... # type: int
EBADF = ... # type: int
EINTR = ... # type: int
HCI_DATA_DIR = ... # type: int
HCI_FILTER = ... # type: int
HCI_TIME_STAMP = ... # type: int
INADDR_ALLHOSTS_GROUP = ... # type: int
INADDR_ANY = ... # type: int
INADDR_BROADCAST = ... # type: int
INADDR_LOOPBACK = ... # type: int
INADDR_MAX_LOCAL_GROUP = ... # type: int
INADDR_NONE = ... # type: int
INADDR_UNSPEC_GROUP = ... # type: int
IPPORT_RESERVED = ... # type: int
IPPORT_USERRESERVED = ... # type: int
IPPROTO_AH = ... # type: int
IPPROTO_DSTOPTS = ... # type: int
IPPROTO_EGP = ... # type: int
IPPROTO_ESP = ... # type: int
IPPROTO_FRAGMENT = ... # type: int
IPPROTO_GRE = ... # type: int
IPPROTO_HOPOPTS = ... # type: int
IPPROTO_ICMP = ... # type: int
IPPROTO_ICMPV6 = ... # type: int
IPPROTO_IDP = ... # type: int
IPPROTO_IGMP = ... # type: int
IPPROTO_IP = ... # type: int
IPPROTO_IPIP = ... # type: int
IPPROTO_IPV6 = ... # type: int
IPPROTO_NONE = ... # type: int
IPPROTO_PIM = ... # type: int
IPPROTO_PUP = ... # type: int
IPPROTO_RAW = ... # type: int
IPPROTO_ROUTING = ... # type: int
IPPROTO_RSVP = ... # type: int
IPPROTO_TCP = ... # type: int
IPPROTO_TP = ... # type: int
IPPROTO_UDP = ... # type: int
IPV6_CHECKSUM = ... # type: int
IPV6_DSTOPTS = ... # type: int
IPV6_HOPLIMIT = ... # type: int
IPV6_HOPOPTS = ... # type: int
IPV6_JOIN_GROUP = ... # type: int
IPV6_LEAVE_GROUP = ... # type: int
IPV6_MULTICAST_HOPS = ... # type: int
IPV6_MULTICAST_IF = ... # type: int
IPV6_MULTICAST_LOOP = ... # type: int
IPV6_NEXTHOP = ... # type: int
IPV6_PKTINFO = ... # type: int
IPV6_RECVDSTOPTS = ... # type: int
IPV6_RECVHOPLIMIT = ... # type: int
IPV6_RECVHOPOPTS = ... # type: int
IPV6_RECVPKTINFO = ... # type: int
IPV6_RECVRTHDR = ... # type: int
IPV6_RECVTCLASS = ... # type: int
IPV6_RTHDR = ... # type: int
IPV6_RTHDRDSTOPTS = ... # type: int
IPV6_RTHDR_TYPE_0 = ... # type: int
IPV6_TCLASS = ... # type: int
IPV6_UNICAST_HOPS = ... # type: int
IPV6_V6ONLY = ... # type: int
IP_ADD_MEMBERSHIP = ... # type: int
IP_DEFAULT_MULTICAST_LOOP = ... # type: int
IP_DEFAULT_MULTICAST_TTL = ... # type: int
IP_DROP_MEMBERSHIP = ... # type: int
IP_HDRINCL = ... # type: int
IP_MAX_MEMBERSHIPS = ... # type: int
IP_MULTICAST_IF = ... # type: int
IP_MULTICAST_LOOP = ... # type: int
IP_MULTICAST_TTL = ... # type: int
IP_OPTIONS = ... # type: int
IP_RECVOPTS = ... # type: int
IP_RECVRETOPTS = ... # type: int
IP_RETOPTS = ... # type: int
IP_TOS = ... # type: int
IP_TTL = ... # type: int
MSG_CTRUNC = ... # type: int
MSG_DONTROUTE = ... # type: int
MSG_DONTWAIT = ... # type: int
MSG_EOR = ... # type: int
MSG_OOB = ... # type: int
MSG_PEEK = ... # type: int
MSG_TRUNC = ... # type: int
MSG_WAITALL = ... # type: int
MethodType = ... # type: type
NETLINK_DNRTMSG = ... # type: int
NETLINK_FIREWALL = ... # type: int
NETLINK_IP6_FW = ... # type: int
NETLINK_NFLOG = ... # type: int
NETLINK_ROUTE = ... # type: int
NETLINK_USERSOCK = ... # type: int
NETLINK_XFRM = ... # type: int
NI_DGRAM = ... # type: int
NI_MAXHOST = ... # type: int
NI_MAXSERV = ... # type: int
NI_NAMEREQD = ... # type: int
NI_NOFQDN = ... # type: int
NI_NUMERICHOST = ... # type: int
NI_NUMERICSERV = ... # type: int
PACKET_BROADCAST = ... # type: int
PACKET_FASTROUTE = ... # type: int
PACKET_HOST = ... # type: int
PACKET_LOOPBACK = ... # type: int
PACKET_MULTICAST = ... # type: int
PACKET_OTHERHOST = ... # type: int
PACKET_OUTGOING = ... # type: int
PF_PACKET = ... # type: int
SHUT_RD = ... # type: int
SHUT_RDWR = ... # type: int
SHUT_WR = ... # type: int
SOCK_DGRAM = ... # type: int
SOCK_RAW = ... # type: int
SOCK_RDM = ... # type: int
SOCK_SEQPACKET = ... # type: int
SOCK_STREAM = ... # type: int
SOL_HCI = ... # type: int
SOL_IP = ... # type: int
SOL_SOCKET = ... # type: int
SOL_TCP = ... # type: int
SOL_TIPC = ... # type: int
SOL_UDP = ... # type: int
SOMAXCONN = ... # type: int
SO_ACCEPTCONN = ... # type: int
SO_BROADCAST = ... # type: int
SO_DEBUG = ... # type: int
SO_DONTROUTE = ... # type: int
SO_ERROR = ... # type: int
SO_KEEPALIVE = ... # type: int
SO_LINGER = ... # type: int
SO_OOBINLINE = ... # type: int
SO_RCVBUF = ... # type: int
SO_RCVLOWAT = ... # type: int
SO_RCVTIMEO = ... # type: int
SO_REUSEADDR = ... # type: int
SO_REUSEPORT = ... # type: int
SO_SNDBUF = ... # type: int
SO_SNDLOWAT = ... # type: int
SO_SNDTIMEO = ... # type: int
SO_TYPE = ... # type: int
SSL_ERROR_EOF = ... # type: int
SSL_ERROR_INVALID_ERROR_CODE = ... # type: int
SSL_ERROR_SSL = ... # type: int
SSL_ERROR_SYSCALL = ... # type: int
SSL_ERROR_WANT_CONNECT = ... # type: int
SSL_ERROR_WANT_READ = ... # type: int
SSL_ERROR_WANT_WRITE = ... # type: int
SSL_ERROR_WANT_X509_LOOKUP = ... # type: int
SSL_ERROR_ZERO_RETURN = ... # type: int
TCP_CORK = ... # type: int
TCP_DEFER_ACCEPT = ... # type: int
TCP_INFO = ... # type: int
TCP_KEEPCNT = ... # type: int
TCP_KEEPIDLE = ... # type: int
TCP_KEEPINTVL = ... # type: int
TCP_LINGER2 = ... # type: int
TCP_MAXSEG = ... # type: int
TCP_NODELAY = ... # type: int
TCP_QUICKACK = ... # type: int
TCP_SYNCNT = ... # type: int
TCP_WINDOW_CLAMP = ... # type: int
TIPC_ADDR_ID = ... # type: int
TIPC_ADDR_NAME = ... # type: int
TIPC_ADDR_NAMESEQ = ... # type: int
TIPC_CFG_SRV = ... # type: int
TIPC_CLUSTER_SCOPE = ... # type: int
TIPC_CONN_TIMEOUT = ... # type: int
TIPC_CRITICAL_IMPORTANCE = ... # type: int
TIPC_DEST_DROPPABLE = ... # type: int
TIPC_HIGH_IMPORTANCE = ... # type: int
TIPC_IMPORTANCE = ... # type: int
TIPC_LOW_IMPORTANCE = ... # type: int
TIPC_MEDIUM_IMPORTANCE = ... # type: int
TIPC_NODE_SCOPE = ... # type: int
TIPC_PUBLISHED = ... # type: int
TIPC_SRC_DROPPABLE = ... # type: int
TIPC_SUBSCR_TIMEOUT = ... # type: int
TIPC_SUB_CANCEL = ... # type: int
TIPC_SUB_PORTS = ... # type: int
TIPC_SUB_SERVICE = ... # type: int
TIPC_TOP_SRV = ... # type: int
TIPC_WAIT_FOREVER = ... # type: int
TIPC_WITHDRAWN = ... # type: int
TIPC_ZONE_SCOPE = ... # type: int
# PyCapsule
CAPI = ... # type: Any
has_ipv6 = ... # type: bool
class error(IOError): ...
class gaierror(error): ...
class timeout(error): ...
class SocketType(object):
family = ... # type: int
type = ... # type: int
proto = ... # type: int
timeout = ... # type: float
def __init__(self, family: int = ..., type: int = ..., proto: int = ...) -> None: ...
def accept(self) -> Tuple['SocketType', tuple]: ...
def bind(self, address: tuple) -> None: ...
def close(self) -> None: ...
def connect(self, address: tuple) -> None:
raise gaierror
raise timeout
def connect_ex(self, address: tuple) -> int: ...
def dup(self) -> "SocketType": ...
def fileno(self) -> int: ...
def getpeername(self) -> tuple: ...
def getsockname(self) -> tuple: ...
def getsockopt(self, level: int, option: int, buffersize: int = ...) -> str: ...
def gettimeout(self) -> float: ...
def listen(self, backlog: int) -> None:
raise error
def makefile(self, mode: str = ..., buffersize: int = ...) -> IO[Any]: ...
def recv(self, buffersize: int, flags: int = ...) -> str: ...
def recv_into(self, buffer: bytearray, nbytes: int = ..., flags: int = ...) -> int: ...
def recvfrom(self, buffersize: int, flags: int = ...) -> tuple:
raise error
def recvfrom_into(self, buffer: bytearray, nbytes: int = ...,
flags: int = ...) -> int: ...
def send(self, data: str, flags: int =...) -> int: ...
def sendall(self, data: str, flags: int = ...) -> None: ...
@overload
def sendto(self, data: str, address: tuple) -> int: ...
@overload
def sendto(self, data: str, flags: int, address: tuple) -> int: ...
def setblocking(self, flag: bool) -> None: ...
def setsockopt(self, level: int, option: int, value: Union[int, str]) -> None: ...
def settimeout(self, value: Optional[float]) -> None: ...
def shutdown(self, flag: int) -> None: ...
mypy-0.470/typeshed/stdlib/2/grp.pyi 0000644 0000000 0000000 00000000530 13023631176 016002 0 ustar root root from typing import Optional, List
class struct_group(object):
gr_name = ... # type: Optional[str]
gr_passwd = ... # type: Optional[str]
gr_gid = ... # type: int
gr_mem = ... # type: List[str]
def getgrall() -> List[struct_group]: ...
def getgrgid(id: int) -> struct_group: ...
def getgrnam(name: str) -> struct_group: ...
mypy-0.470/typeshed/stdlib/2/unittest.pyi 0000644 0000000 0000000 00000017361 13044257024 017102 0 ustar root root # Stubs for unittest
# Based on http://docs.python.org/2.7/library/unittest.html
# Only a subset of functionality is included.
from typing import (
Any, Callable, Dict, Iterable, Tuple, List, TextIO, Sequence,
overload, Set, TypeVar, Pattern
)
from abc import abstractmethod, ABCMeta
_T = TypeVar('_T')
_FT = TypeVar('_FT')
class Testable(metaclass=ABCMeta):
@abstractmethod
def run(self, result: 'TestResult') -> None: ...
@abstractmethod
def debug(self) -> None: ...
@abstractmethod
def countTestCases(self) -> int: ...
# TODO ABC for test runners?
class TestResult:
errors = ... # type: List[Tuple[Testable, str]]
failures = ... # type: List[Tuple[Testable, str]]
testsRun = 0
shouldStop = ... # type: bool
def wasSuccessful(self) -> bool: ...
def stop(self) -> None: ...
def startTest(self, test: Testable) -> None: ...
def stopTest(self, test: Testable) -> None: ...
def addError(self, test: Testable,
err: Tuple[type, Any, Any]) -> None: ... # TODO
def addFailure(self, test: Testable,
err: Tuple[type, Any, Any]) -> None: ... # TODO
def addSuccess(self, test: Testable) -> None: ...
class _AssertRaisesBaseContext:
expected = ... # type: Any
failureException = ... # type: type
obj_name = ... # type: str
expected_regex = ... # type: Pattern[str]
class _AssertRaisesContext(_AssertRaisesBaseContext):
exception = ... # type: Any # TODO precise type
def __enter__(self) -> _AssertRaisesContext: ...
def __exit__(self, exc_type, exc_value, tb) -> bool: ...
class TestCase(Testable):
def __init__(self, methodName: str = ...) -> None: ...
# TODO failureException
def setUp(self) -> None: ...
def tearDown(self) -> None: ...
def run(self, result: TestResult = ...) -> None: ...
def debug(self) -> None: ...
def assert_(self, expr: Any, msg: object = ...) -> None: ...
def failUnless(self, expr: Any, msg: object = ...) -> None: ...
def assertTrue(self, expr: Any, msg: object = ...) -> None: ...
def assertEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertEquals(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def failUnlessEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertNotEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertNotEquals(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def failIfEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertAlmostEqual(self, first: float, second: float, places: int = ...,
msg: object = ...,
delta: float = ...) -> None: ...
def assertAlmostEquals(self, first: float, second: float, places: int = ...,
msg: object = ...,
delta: float = ...) -> None: ...
def failUnlessAlmostEqual(self, first: float, second: float, places: int = ...,
msg: object = ...) -> None: ...
def assertNotAlmostEqual(self, first: float, second: float, places: int = ...,
msg: object = ...,
delta: float = ...) -> None: ...
def assertNotAlmostEquals(self, first: float, second: float, places: int = ...,
msg: object = ...,
delta: float = ...) -> None: ...
def failIfAlmostEqual(self, first: float, second: float, places: int = ...,
msg: object = ...,
delta: float = ...) -> None: ...
def assertGreater(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertGreaterEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertMultiLineEqual(self, first: str, second: str,
msg: object = ...) -> None: ...
def assertSequenceEqual(self, first: Sequence[Any], second: Sequence[Any],
msg: object = ..., seq_type: type = ...) -> None: ...
def assertListEqual(self, first: List[Any], second: List[Any],
msg: object = ...) -> None: ...
def assertTupleEqual(self, first: Tuple[Any, ...], second: Tuple[Any, ...],
msg: object = ...) -> None: ...
def assertSetEqual(self, first: Set[Any], second: Set[Any],
msg: object = ...) -> None: ...
def assertDictEqual(self, first: Dict[Any, Any], second: Dict[Any, Any],
msg: object = ...) -> None: ...
def assertLess(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertLessEqual(self, first: Any, second: Any,
msg: object = ...) -> None: ...
def assertRaises(self, expected_exception: type, *args: Any, **kwargs: Any) -> Any: ...
def failUnlessRaises(self, expected_exception: type, *args: Any, **kwargs: Any) -> Any: ...
def failIf(self, expr: Any, msg: object = ...) -> None: ...
def assertFalse(self, expr: Any, msg: object = ...) -> None: ...
def assertIs(self, first: object, second: object,
msg: object = ...) -> None: ...
def assertIsNot(self, first: object, second: object,
msg: object = ...) -> None: ...
def assertIsNone(self, expr: Any, msg: object = ...) -> None: ...
def assertIsNotNone(self, expr: Any, msg: object = ...) -> None: ...
def assertIn(self, first: _T, second: Iterable[_T],
msg: object = ...) -> None: ...
def assertNotIn(self, first: _T, second: Iterable[_T],
msg: object = ...) -> None: ...
def assertIsInstance(self, obj: Any, cls: type,
msg: object = ...) -> None: ...
def assertNotIsInstance(self, obj: Any, cls: type,
msg: object = ...) -> None: ...
def fail(self, msg: object = ...) -> None: ...
def countTestCases(self) -> int: ...
def defaultTestResult(self) -> TestResult: ...
def id(self) -> str: ...
def shortDescription(self) -> str: ... # May return None
def addCleanup(function: Any, *args: Any, **kwargs: Any) -> None: ...
def skipTest(self, reason: Any) -> None: ...
class CallableTestCase(Testable):
def __init__(self, testFunc: Callable[[], None],
setUp: Callable[[], None] = ...,
tearDown: Callable[[], None] = ...,
description: str = ...) -> None: ...
def run(self, result: TestResult) -> None: ...
def debug(self) -> None: ...
def countTestCases(self) -> int: ...
class TestSuite(Testable):
def __init__(self, tests: Iterable[Testable] = ...) -> None: ...
def addTest(self, test: Testable) -> None: ...
def addTests(self, tests: Iterable[Testable]) -> None: ...
def run(self, result: TestResult) -> None: ...
def debug(self) -> None: ...
def countTestCases(self) -> int: ...
# TODO TestLoader
# TODO defaultTestLoader
class TextTestRunner:
def __init__(self, stream: TextIO = ..., descriptions: bool = ...,
verbosity: int = ..., failfast: bool = ...) -> None: ...
class SkipTest(Exception):
...
# TODO precise types
def skipUnless(condition: Any, reason: str) -> Any: ...
def skipIf(condition: Any, reason: str) -> Any: ...
def expectedFailure(func: _FT) -> _FT: ...
def skip(reason: str) -> Any: ...
def main(module: str = ..., defaultTest: str = ...,
argv: List[str] = ..., testRunner: Any = ...,
testLoader: Any = ...) -> None: ... # TODO types
# private but occasionally used
util = ... # type: module
mypy-0.470/typeshed/stdlib/2/_ast.pyi 0000644 0000000 0000000 00000016626 13035744274 016164 0 ustar root root import typing
from typing import Optional, Union
__version__ = ... # type: str
PyCF_ONLY_AST = ... # type: int
identifier = str
class AST:
_attributes = ... # type: typing.Tuple[str, ...]
_fields = ... # type: typing.Tuple[str, ...]
def __init__(self, *args, **kwargs) -> None: ...
class mod(AST):
...
class Module(mod):
body = ... # type: typing.List[stmt]
class Interactive(mod):
body = ... # type: typing.List[stmt]
class Expression(mod):
body = ... # type: expr
class Suite(mod):
body = ... # type: typing.List[stmt]
class stmt(AST):
lineno = ... # type: int
col_offset = ... # type: int
class FunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
class ClassDef(stmt):
name = ... # type: identifier
bases = ... # type: typing.List[expr]
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
class Return(stmt):
value = ... # type: Optional[expr]
class Delete(stmt):
targets = ... # type: typing.List[expr]
class Assign(stmt):
targets = ... # type: typing.List[expr]
value = ... # type: expr
class AugAssign(stmt):
target = ... # type: expr
op = ... # type: operator
value = ... # type: expr
class Print(stmt):
dest = ... # type: Optional[expr]
values = ... # type: typing.List[expr]
nl = ... # type: bool
class For(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class While(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class If(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class With(stmt):
context_expr = ... # type: expr
optional_vars = ... # type: Optional[expr]
body = ... # type: typing.List[stmt]
class Raise(stmt):
type = ... # type: Optional[expr]
inst = ... # type: Optional[expr]
tback = ... # type: Optional[expr]
class TryExcept(stmt):
body = ... # type: typing.List[stmt]
handlers = ... # type: typing.List[ExceptHandler]
orelse = ... # type: typing.List[stmt]
class TryFinally(stmt):
body = ... # type: typing.List[stmt]
finalbody = ... # type: typing.List[stmt]
class Assert(stmt):
test = ... # type: expr
msg = ... # type: Optional[expr]
class Import(stmt):
names = ... # type: typing.List[alias]
class ImportFrom(stmt):
module = ... # type: Optional[identifier]
names = ... # type: typing.List[alias]
level = ... # type: Optional[int]
class Exec(stmt):
body = ... # type: expr
globals = ... # type: Optional[expr]
locals = ... # type: Optional[expr]
class Global(stmt):
names = ... # type: typing.List[identifier]
class Expr(stmt):
value = ... # type: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class slice(AST):
...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower = ... # type: Optional[expr]
upper = ... # type: Optional[expr]
step = ... # type: Optional[expr]
class ExtSlice(slice):
dims = ... # type: typing.List[slice]
class Index(slice):
value = ... # type: expr
class Ellipsis(slice): ...
class expr(AST):
lineno = ... # type: int
col_offset = ... # type: int
class BoolOp(expr):
op = ... # type: boolop
values = ... # type: typing.List[expr]
class BinOp(expr):
left = ... # type: expr
op = ... # type: operator
right = ... # type: expr
class UnaryOp(expr):
op = ... # type: unaryop
operand = ... # type: expr
class Lambda(expr):
args = ... # type: arguments
body = ... # type: expr
class IfExp(expr):
test = ... # type: expr
body = ... # type: expr
orelse = ... # type: expr
class Dict(expr):
keys = ... # type: typing.List[expr]
values = ... # type: typing.List[expr]
class Set(expr):
elts = ... # type: typing.List[expr]
class ListComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class SetComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class DictComp(expr):
key = ... # type: expr
value = ... # type: expr
generators = ... # type: typing.List[comprehension]
class GeneratorExp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class Yield(expr):
value = ... # type: Optional[expr]
class Compare(expr):
left = ... # type: expr
ops = ... # type: typing.List[cmpop]
comparators = ... # type: typing.List[expr]
class Call(expr):
func = ... # type: expr
args = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
starargs = ... # type: Optional[expr]
kwargs = ... # type: Optional[expr]
class Repr(expr):
value = ... # type: expr
class Num(expr):
n = ... # type: Union[int, float]
class Str(expr):
s = ... # type: str
class Attribute(expr):
value = ... # type: expr
attr = ... # type: identifier
ctx = ... # type: expr_context
class Subscript(expr):
value = ... # type: expr
slice = ... # type: _slice
ctx = ... # type: expr_context
class Name(expr):
id = ... # type: identifier
ctx = ... # type: expr_context
class List(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class Tuple(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class expr_context(AST):
...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(expr_context): ...
class Store(expr_context): ...
class boolop(AST):
...
class And(boolop): ...
class Or(boolop): ...
class operator(AST):
...
class Add(operator): ...
class BitAnd(operator): ...
class BitOr(operator): ...
class BitXor(operator): ...
class Div(operator): ...
class FloorDiv(operator): ...
class LShift(operator): ...
class Mod(operator): ...
class Mult(operator): ...
class Pow(operator): ...
class RShift(operator): ...
class Sub(operator): ...
class unaryop(AST):
...
class Invert(unaryop): ...
class Not(unaryop): ...
class UAdd(unaryop): ...
class USub(unaryop): ...
class cmpop(AST):
...
class Eq(cmpop): ...
class Gt(cmpop): ...
class GtE(cmpop): ...
class In(cmpop): ...
class Is(cmpop): ...
class IsNot(cmpop): ...
class Lt(cmpop): ...
class LtE(cmpop): ...
class NotEq(cmpop): ...
class NotIn(cmpop): ...
class comprehension(AST):
target = ... # type: expr
iter = ... # type: expr
ifs = ... # type: typing.List[expr]
class ExceptHandler(AST):
type = ... # type: Optional[expr]
name = ... # type: Optional[expr]
body = ... # type: typing.List[stmt]
lineno = ... # type: int
col_offset = ... # type: int
class arguments(AST):
args = ... # type: typing.List[expr]
vararg = ... # type: Optional[identifier]
kwarg = ... # type: Optional[identifier]
defaults = ... # type: typing.List[expr]
class keyword(AST):
arg = ... # type: identifier
value = ... # type: expr
class alias(AST):
name = ... # type: identifier
asname = ... # type: Optional[identifier]
mypy-0.470/typeshed/stdlib/2/mimetools.pyi 0000644 0000000 0000000 00000001610 13035744274 017231 0 ustar root root # Stubs for mimetools (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import rfc822
class Message(rfc822.Message):
encodingheader = ... # type: Any
typeheader = ... # type: Any
def __init__(self, fp, seekable=1): ...
plisttext = ... # type: Any
type = ... # type: Any
maintype = ... # type: Any
subtype = ... # type: Any
def parsetype(self): ...
plist = ... # type: Any
def parseplist(self): ...
def getplist(self): ...
def getparam(self, name): ...
def getparamnames(self): ...
def getencoding(self): ...
def gettype(self): ...
def getmaintype(self): ...
def getsubtype(self): ...
def choose_boundary(): ...
def decode(input, output, encoding): ...
def encode(input, output, encoding): ...
def copyliteral(input, output): ...
def copybinary(input, output): ...
mypy-0.470/typeshed/stdlib/2/json.pyi 0000644 0000000 0000000 00000006354 13035744274 016204 0 ustar root root from typing import Any, IO, Optional, Tuple, Callable, Dict, List, Union, Text
class JSONDecodeError(ValueError):
def dumps(self, obj: Any) -> str: ...
def dump(self, obj: Any, fp: IO[str], *args: Any, **kwds: Any) -> None: ...
def loads(self, s: str) -> Any: ...
def load(self, fp: IO[str]) -> Any: ...
def dumps(obj: Any,
skipkeys: bool = ...,
ensure_ascii: bool = ...,
check_circular: bool = ...,
allow_nan: bool = ...,
cls: Any = ...,
indent: Optional[int] = ...,
separators: Optional[Tuple[str, str]] = ...,
encoding: str = ...,
default: Optional[Callable[[Any], Any]] = ...,
sort_keys: bool = ...,
**kwds: Any) -> str: ...
def dump(obj: Any,
fp: IO[str],
skipkeys: bool = ...,
ensure_ascii: bool = ...,
check_circular: bool = ...,
allow_nan: bool = ...,
cls: Any = ...,
indent: Optional[int] = ...,
separators: Optional[Tuple[str, str]] = ...,
encoding: str = ...,
default: Optional[Callable[[Any], Any]] = ...,
sort_keys: bool = ...,
**kwds: Any) -> None: ...
def loads(s: Union[Text, bytes],
encoding: Any = ...,
cls: Any = ...,
object_hook: Optional[Callable[[Dict], Any]] = ...,
parse_float: Optional[Callable[[str], Any]] = ...,
parse_int: Optional[Callable[[str], Any]] = ...,
parse_constant: Optional[Callable[[str], Any]] = ...,
object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ...,
**kwds: Any) -> Any: ...
def load(fp: IO[str],
encoding: Optional[str] = ...,
cls: Any = ...,
object_hook: Optional[Callable[[Dict], Any]] = ...,
parse_float: Optional[Callable[[str], Any]] = ...,
parse_int: Optional[Callable[[str], Any]] = ...,
parse_constant: Optional[Callable[[str], Any]] = ...,
object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ...,
**kwds: Any) -> Any: ...
class JSONDecoder(object):
def __init__(self,
encoding: Union[Text, bytes] = ...,
object_hook: Callable[..., Any] = ...,
parse_float: Callable[[str], float] = ...,
parse_int: Callable[[str], int] = ...,
parse_constant: Callable[[str], Any] = ...,
strict: bool = ...,
object_pairs_hook: Callable[..., Any] = ...) -> None: ...
def decode(self, s: Union[Text, bytes], _w: Any = ...) -> Any: ...
def raw_decode(self,
s: Union[Text, bytes],
idx: int = ...) -> Tuple[Any, Any]: ...
class JSONEncoder(object):
item_separator = ... # type: str
key_separator = ... # type: str
skipkeys = ... # type: bool
ensure_ascii = ... # type: bool
check_circular = ... # type: bool
allow_nan = ... # type: bool
sort_keys = ... # type: bool
indent = ... # type: int
def __init__(self,
skipkeys: bool = ...,
ensure_ascii: bool = ...,
check_circular: bool = ...,
allow_nan: bool = ...,
sort_keys: bool = ...,
indent: int = ...,
separators: Tuple[Union[Text, bytes], Union[Text, bytes]] = ...,
encoding: Union[Text, bytes] = ...,
default: Callable[..., Any] = ...) -> None: ...
def default(self, o: Any) -> Any: ...
def encode(self, o: Any) -> str: ...
def iterencode(self, o: Any, _one_shot: bool = ...) -> str: ...
mypy-0.470/typeshed/stdlib/2/linecache.pyi 0000644 0000000 0000000 00000000341 13023631176 017125 0 ustar root root # Stubs for linecache (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def getline(filename, lineno, module_globals=None): ...
def clearcache(): ...
def checkcache(filename=None): ...
mypy-0.470/typeshed/stdlib/2/future_builtins.pyi 0000644 0000000 0000000 00000000342 13023631176 020436 0 ustar root root from typing import Any
from itertools import ifilter as filter
from itertools import imap as map
from itertools import izip as zip
def ascii(obj: Any) -> str: ...
def hex(x: int) -> str: ...
def oct(x: int) -> str: ...
mypy-0.470/typeshed/stdlib/2/os/ 0000755 0000000 0000000 00000000000 13044320557 015113 5 ustar root root mypy-0.470/typeshed/stdlib/2/os/path.pyi 0000644 0000000 0000000 00000004234 13035744274 016603 0 ustar root root # Stubs for os.path
# Ron Murawski
# based on http://docs.python.org/3.2/library/os.path.html
# adapted for 2.7 by Michal Pokorny
from typing import overload, List, Any, Tuple, BinaryIO, TextIO, TypeVar, Callable, AnyStr
# ----- os.path variables -----
supports_unicode_filenames = False
# aliases (also in os)
curdir = ... # type: str
pardir = ... # type: str
sep = ... # type: str
altsep = ... # type: str
extsep = ... # type: str
pathsep = ... # type: str
defpath = ... # type: str
devnull = ... # type: str
# ----- os.path function stubs -----
def abspath(path: AnyStr) -> AnyStr: ...
def basename(path: AnyStr) -> AnyStr: ...
def commonprefix(list: List[AnyStr]) -> AnyStr: ...
def dirname(path: AnyStr) -> AnyStr: ...
def exists(path: unicode) -> bool: ...
def lexists(path: unicode) -> bool: ...
def expanduser(path: AnyStr) -> AnyStr: ...
def expandvars(path: AnyStr) -> AnyStr: ...
# These return float if os.stat_float_times() == True,
# but int is a subclass of float.
def getatime(path: unicode) -> float: ...
def getmtime(path: unicode) -> float: ...
def getctime(path: unicode) -> float: ...
def getsize(path: unicode) -> int: ...
def isabs(path: unicode) -> bool: ...
def isfile(path: unicode) -> bool: ...
def isdir(path: unicode) -> bool: ...
def islink(path: unicode) -> bool: ...
def ismount(path: unicode) -> bool: ...
def join(path: AnyStr, *paths: AnyStr) -> AnyStr: ...
def normcase(path: AnyStr) -> AnyStr: ...
def normpath(path: AnyStr) -> AnyStr: ...
def realpath(path: AnyStr) -> AnyStr: ...
def relpath(path: AnyStr, start: AnyStr = ...) -> AnyStr: ...
def samefile(path1: unicode, path2: unicode) -> bool: ...
def sameopenfile(fp1: int, fp2: int) -> bool: ...
# TODO
# def samestat(stat1: stat_result,
# stat2: stat_result) -> bool: ... # Unix only
def split(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitdrive(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitext(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitunc(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # Windows only, deprecated
_T = TypeVar('_T')
def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ...
mypy-0.470/typeshed/stdlib/2/os/__init__.pyi 0000644 0000000 0000000 00000023724 13035744274 017413 0 ustar root root # created from https://docs.python.org/2/library/os.html
from typing import (
List, Tuple, Union, Sequence, Mapping, IO, Any, Optional, AnyStr, Iterator,
Dict, MutableMapping, NamedTuple, overload
)
from . import path
from mypy_extensions import NoReturn
error = OSError
name = ... # type: str
class _Environ(MutableMapping[str, str]):
def copy(self) -> Dict[str, str]: ...
environ = ... # type: _Environ
def chdir(path: unicode) -> None: ...
def fchdir(fd: int) -> None: ...
def getcwd() -> str: ...
def ctermid() -> str: ...
def getegid() -> int: ...
def geteuid() -> int: ...
def getgid() -> int: ...
def getgroups() -> List[int]: ...
def initgroups(username: str, gid: int) -> None: ...
def getlogin() -> str: ...
def getpgid(pid: int) -> int: ...
def getpgrp() -> int: ...
def getpid() -> int: ...
def getppid() -> int: ...
def getresuid() -> Tuple[int, int, int]: ...
def getresgid() -> Tuple[int, int, int]: ...
def getuid() -> int: ...
def getenv(varname: unicode, value: unicode = ...) -> str: ...
def putenv(varname: unicode, value: unicode) -> None: ...
def setegid(egid: int) -> None: ...
def seteuid(euid: int) -> None: ...
def setgid(gid: int) -> None: ...
def setgroups(groups: Sequence[int]) -> None: ...
# TODO(MichalPokorny)
def setpgrp(*args) -> None: ...
def setpgid(pid: int, pgrp: int) -> None: ...
def setregid(rgid: int, egid: int) -> None: ...
def setresgid(rgid: int, egid: int, sgid: int) -> None: ...
def setresuid(ruid: int, euid: int, suid: int) -> None: ...
def setreuid(ruid: int, euid: int) -> None: ...
def getsid(pid: int) -> int: ...
def setsid() -> None: ...
def setuid(pid: int) -> None: ...
def strerror(code: int) -> str: ...
def umask(mask: int) -> int: ...
def uname() -> Tuple[str, str, str, str, str]: ...
def unsetenv(varname: str) -> None: ...
# TODO(MichalPokorny)
def fdopen(fd: int, *args, **kwargs) -> IO[Any]: ...
def popen(command: str, *args, **kwargs) -> Optional[IO[Any]]: ...
def tmpfile() -> IO[Any]: ...
def tmpnam() -> str: ...
def tempnam(dir: str = ..., prefix: str = ...) -> str: ...
def popen2(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ...
def popen3(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any], IO[Any]]: ...
def popen4(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ...
def close(fd: int) -> None: ...
def closerange(fd_low: int, fd_high: int) -> None: ...
def dup(fd: int) -> int: ...
def dup2(fd: int, fd2: int) -> None: ...
def fchmod(fd: int, mode: int) -> None: ...
def fchown(fd: int, uid: int, gid: int) -> None: ...
def fdatasync(fd: int) -> None: ...
def fpathconf(fd: int, name: str) -> None: ...
# TODO(prvak)
def fstat(fd: int) -> Any: ...
def fsync(fd: int) -> None: ...
def ftruncate(fd: int, length: int) -> None: ...
def isatty(fd: int) -> bool: ...
def lseek(fd: int, pos: int, how: int) -> None: ...
SEEK_SET = 0
SEEK_CUR = 0
SEEK_END = 0
# TODO(prvak): maybe file should be unicode? (same with all other paths...)
def open(file: unicode, flags: int, mode: int = ...) -> int: ...
def openpty() -> Tuple[int, int]: ...
def pipe() -> Tuple[int, int]: ...
def read(fd: int, n: int) -> str: ...
def tcgetpgrp(fd: int) -> int: ...
def tcsetpgrp(fd: int, pg: int) -> None: ...
def ttyname(fd: int) -> str: ...
def write(fd: int, str: str) -> int: ...
# TODO: O_*
def access(path: unicode, mode: int) -> bool: ...
F_OK = 0
R_OK = 0
W_OK = 0
X_OK = 0
def getcwdu() -> unicode: ...
def chflags(path: unicode, flags: int) -> None: ...
def chroot(path: unicode) -> None: ...
def chmod(path: unicode, mode: int) -> None: ...
def chown(path: unicode, uid: int, gid: int) -> None: ...
def lchflags(path: unicode, flags: int) -> None: ...
def lchmod(path: unicode, uid: int, gid: int) -> None: ...
def lchown(path: unicode, uid: int, gid: int) -> None: ...
def link(source: unicode, link_name: unicode) -> None: ...
def listdir(path: AnyStr) -> List[AnyStr]: ...
# TODO(MichalPokorny)
def lstat(path: unicode) -> Any: ...
def mkfifo(path: unicode, mode: int = ...) -> None: ...
def mknod(filename: unicode, mode: int = ..., device: int = ...) -> None: ...
def major(device: int) -> int: ...
def minor(device: int) -> int: ...
def makedev(major: int, minor: int) -> int: ...
def mkdir(path: unicode, mode: int = ...) -> None: ...
def makedirs(path: unicode, mode: int = ...) -> None: ...
def pathconf(path: unicode, name: str) -> str: ...
pathconf_names = ... # type: Mapping[str, int]
def readlink(path: AnyStr) -> AnyStr: ...
def remove(path: unicode) -> None: ...
def removedirs(path: unicode) -> None: ...
def rename(src: unicode, dst: unicode) -> None: ...
def renames(old: unicode, new: unicode) -> None: ...
def rmdir(path: unicode) -> None: ...
# TODO(MichalPokorny)
def stat(path: unicode) -> Any: ...
_StatVFS = NamedTuple('_StatVFS', [('f_bsize', int), ('f_frsize', int), ('f_blocks', int),
('f_bfree', int), ('f_bavail', int), ('f_files', int),
('f_ffree', int), ('f_favail', int), ('f_flag', int),
('f_namemax', int)])
def fstatvfs(fd: int) -> _StatVFS: ...
def statvfs(path: unicode) -> _StatVFS: ...
def walk(top: AnyStr, topdown: bool = ..., onerror: Any = ...,
followlinks: bool = ...) -> Iterator[Tuple[AnyStr, List[AnyStr],
List[AnyStr]]]: ...
def symlink(source: unicode, link_name: unicode) -> None: ...
def unlink(path: unicode) -> None: ...
def utime(path: unicode, times: Optional[Tuple[int, int]]) -> None: ...
def abort() -> None: ...
EX_OK = 0 # Unix only
EX_USAGE = 0 # Unix only
EX_DATAERR = 0 # Unix only
EX_NOINPUT = 0 # Unix only
EX_NOUSER = 0 # Unix only
EX_NOHOST = 0 # Unix only
EX_UNAVAILABLE = 0 # Unix only
EX_SOFTWARE = 0 # Unix only
EX_OSERR = 0 # Unix only
EX_OSFILE = 0 # Unix only
EX_CANTCREAT = 0 # Unix only
EX_IOERR = 0 # Unix only
EX_TEMPFAIL = 0 # Unix only
EX_PROTOCOL = 0 # Unix only
EX_NOPERM = 0 # Unix only
EX_CONFIG = 0 # Unix only
def execl(file: AnyStr, *args) -> None: ...
def execle(file: AnyStr, *args) -> None: ...
def execlp(file: AnyStr, *args) -> None: ...
def execlpe(file: AnyStr, *args) -> None: ...
def execvp(file: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]]) -> None: ...
def execvpe(file: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]], env: Mapping[AnyStr, AnyStr]) -> None: ...
def execv(path: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]]) -> None: ...
def execve(path: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]], env: Mapping[AnyStr, AnyStr]) -> None: ...
def _exit(n: int) -> NoReturn: ...
def fork() -> int: ...
def forkpty() -> Tuple[int, int]: ...
def kill(pid: int, sig: int) -> None: ...
def killpg(pgid: int, sig: int) -> None: ...
def nice(increment: int) -> int: ...
# TODO: plock, popen*, P_*
def spawnl(mode: int, path: AnyStr, arg0: AnyStr, *args: AnyStr) -> int: ...
def spawnle(mode: int, path: AnyStr, arg0: AnyStr,
*args: Any) -> int: ... # Imprecise sig
def spawnlp(mode: int, file: AnyStr, arg0: AnyStr,
*args: AnyStr) -> int: ... # Unix only TODO
def spawnlpe(mode: int, file: AnyStr, arg0: AnyStr, *args: Any) -> int:
... # Imprecise signature; Unix only TODO
def spawnv(mode: int, path: AnyStr, args: List[AnyStr]) -> int: ...
def spawnve(mode: int, path: AnyStr, args: List[AnyStr],
env: Mapping[str, str]) -> int: ...
def spawnvp(mode: int, file: AnyStr, args: List[AnyStr]) -> int: ... # Unix only
def spawnvpe(mode: int, file: AnyStr, args: List[AnyStr],
env: Mapping[str, str]) -> int:
... # Unix only
def startfile(path: unicode, operation: str = ...) -> None: ... # Windows only
def system(command: unicode) -> int: ...
def times() -> Tuple[float, float, float, float, float]: ...
def wait() -> Tuple[int, int]: ... # Unix only
def wait3(options: int) -> Tuple[int, int, Any]: ... # Unix only
def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ... # Unix only
def waitpid(pid: int, options: int) -> Tuple[int, int]: ...
def confstr(name: Union[str, int]) -> Optional[str]: ...
confstr_names = ... # type: Mapping[str, int]
def getloadavg() -> Tuple[float, float, float]: ...
def sysconf(name: Union[str, int]) -> int: ...
sysconf_names = ... # type: Mapping[str, int]
curdir = ... # type: str
pardir = ... # type: str
sep = ... # type: str
altsep = ... # type: str
extsep = ... # type: str
pathsep = ... # type: str
defpath = ... # type: str
linesep = ... # type: str
devnull = ... # type: str
def urandom(n: int) -> str: ...
# More constants, copied from stdlib/3/os/__init__.pyi
O_RDONLY = 0
O_WRONLY = 0
O_RDWR = 0
O_APPEND = 0
O_CREAT = 0
O_EXCL = 0
O_TRUNC = 0
O_DSYNC = 0 # Unix only
O_RSYNC = 0 # Unix only
O_SYNC = 0 # Unix only
O_NDELAY = 0 # Unix only
O_NONBLOCK = 0 # Unix only
O_NOCTTY = 0 # Unix only
O_SHLOCK = 0 # Unix only
O_EXLOCK = 0 # Unix only
O_BINARY = 0 # Windows only
O_NOINHERIT = 0 # Windows only
O_SHORT_LIVED = 0 # Windows only
O_TEMPORARY = 0 # Windows only
O_RANDOM = 0 # Windows only
O_SEQUENTIAL = 0 # Windows only
O_TEXT = 0 # Windows only
O_ASYNC = 0 # Gnu extension if in C library
O_DIRECT = 0 # Gnu extension if in C library
O_DIRECTORY = 0 # Gnu extension if in C library
O_NOFOLLOW = 0 # Gnu extension if in C library
O_NOATIME = 0 # Gnu extension if in C library
O_LARGEFILE = 0 # Gnu extension if in C library
P_NOWAIT = 0
P_NOWAITO = 0
P_WAIT = 0
# P_DETACH = 0 # Windows only
# P_OVERLAY = 0 # Windows only
# wait()/waitpid() options
WNOHANG = 0 # Unix only
WCONTINUED = 0 # some Unix systems
WUNTRACED = 0 # Unix only
P_ALL = 0
WEXITED = 0
WNOWAIT = 0
TMP_MAX = 0
# Below are Unix-only
def WCOREDUMP(status: int) -> bool: ...
def WEXITSTATUS(status: int) -> int: ...
def WIFCONTINUED(status: int) -> bool: ...
def WIFEXITED(status: int) -> bool: ...
def WIFSIGNALED(status: int) -> bool: ...
def WIFSTOPPED(status: int) -> bool: ...
def WSTOPSIG(status: int) -> int: ...
def WTERMSIG(status: int) -> int: ...
@overload
def stat_float_times(newvalue: bool = ...) -> None: ...
@overload
def stat_float_times() -> bool: ...
mypy-0.470/typeshed/stdlib/2/ssl.pyi 0000644 0000000 0000000 00000020322 13035744274 016023 0 ustar root root # Stubs for ssl
from typing import (
Any, Dict, Callable, List, NamedTuple, Optional, Set, Tuple, Union,
)
import socket
import sys
_PCTRTT = Tuple[Tuple[str, str], ...]
_PCTRTTT = Tuple[_PCTRTT, ...]
_PeerCertRetDictType = Dict[str, Union[str, _PCTRTTT, _PCTRTT]]
_PeerCertRetType = Union[_PeerCertRetDictType, bytes, None]
_EnumRetType = List[Tuple[bytes, str, Union[Set[str], bool]]]
_PasswordType = Union[Callable[[], Union[str, bytes]], str, bytes]
_SrvnmeCbType = Callable[['SSLSocket', Optional[str], 'SSLSocket'], Optional[int]]
class SSLError(OSError):
library = ... # type: str
reason = ... # type: str
class SSLZeroReturnError(SSLError): ...
class SSLWantReadError(SSLError): ...
class SSLWantWriteError(SSLError): ...
class SSLSyscallError(SSLError): ...
class SSLEOFError(SSLError): ...
class CertificateError(Exception): ...
def wrap_socket(sock: socket.socket, keyfile: Optional[str] = ...,
certfile: Optional[str] = ..., server_side: bool = ...,
cert_reqs: int = ..., ssl_version: int = ...,
ca_certs: Optional[str] = ...,
do_handshake_on_connect: bool = ...,
suppress_ragged_eofs: bool = ...,
ciphers: Optional[str] = ...) -> 'SSLSocket': ...
def create_default_context(purpose: Any = ..., *,
cafile: Optional[str] = ...,
capath: Optional[str] = ...,
cadata: Optional[str] = ...) -> 'SSLContext': ...
def RAND_status() -> bool: ...
def RAND_egd(path: str) -> None: ...
def RAND_add(bytes: bytes, entropy: float) -> None: ...
def match_hostname(cert: _PeerCertRetType, hostname: str) -> None: ...
def cert_time_to_seconds(cert_time: str) -> int: ...
def get_server_certificate(addr: Tuple[str, int], ssl_version: int = ...,
ca_certs: Optional[str] = ...) -> str: ...
def DER_cert_to_PEM_cert(der_cert_bytes: bytes) -> str: ...
def PEM_cert_to_DER_cert(pem_cert_string: str) -> bytes: ...
DefaultVerifyPaths = NamedTuple('DefaultVerifyPaths',
[('cafile', str), ('capath', str),
('openssl_cafile_env', str),
('openssl_cafile', str),
('openssl_capath_env', str),
('openssl_capath', str)])
def get_default_verify_paths() -> DefaultVerifyPaths: ...
if sys.platform == 'win32':
def enum_certificates(store_name: str) -> _EnumRetType: ...
def enum_crls(store_name: str) -> _EnumRetType: ...
CERT_NONE = ... # type: int
CERT_OPTIONAL = ... # type: int
CERT_REQUIRED = ... # type: int
VERIFY_DEFAULT = ... # type: int
VERIFY_CRL_CHECK_LEAF = ... # type: int
VERIFY_CRL_CHECK_CHAIN = ... # type: int
VERIFY_X509_STRICT = ... # type: int
VERIFY_X509_TRUSTED_FIRST = ... # type: int
PROTOCOL_SSLv23 = ... # type: int
PROTOCOL_SSLv2 = ... # type: int
PROTOCOL_SSLv3 = ... # type: int
PROTOCOL_TLSv1 = ... # type: int
PROTOCOL_TLSv1_1 = ... # type: int
PROTOCOL_TLSv1_2 = ... # type: int
OP_ALL = ... # type: int
OP_NO_SSLv2 = ... # type: int
OP_NO_SSLv3 = ... # type: int
OP_NO_TLSv1 = ... # type: int
OP_NO_TLSv1_1 = ... # type: int
OP_NO_TLSv1_2 = ... # type: int
OP_CIPHER_SERVER_PREFERENCE = ... # type: int
OP_SINGLE_DH_USE = ... # type: int
OP_SINGLE_ECDH_USE = ... # type: int
OP_NO_COMPRESSION = ... # type: int
HAS_ALPN = ... # type: int
HAS_ECDH = ... # type: bool
HAS_SNI = ... # type: bool
HAS_NPN = ... # type: bool
CHANNEL_BINDING_TYPES = ... # type: List[str]
OPENSSL_VERSION = ... # type: str
OPENSSL_VERSION_INFO = ... # type: Tuple[int, int, int, int, int]
OPENSSL_VERSION_NUMBER = ... # type: int
ALERT_DESCRIPTION_HANDSHAKE_FAILURE = ... # type: int
ALERT_DESCRIPTION_INTERNAL_ERROR = ... # type: int
ALERT_DESCRIPTION_ACCESS_DENIED = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE = ... # type: int
ALERT_DESCRIPTION_BAD_RECORD_MAC = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_EXPIRED = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_REVOKED = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE = ... # type: int
ALERT_DESCRIPTION_CLOSE_NOTIFY = ... # type: int
ALERT_DESCRIPTION_DECODE_ERROR = ... # type: int
ALERT_DESCRIPTION_DECOMPRESSION_FAILURE = ... # type: int
ALERT_DESCRIPTION_DECRYPT_ERROR = ... # type: int
ALERT_DESCRIPTION_ILLEGAL_PARAMETER = ... # type: int
ALERT_DESCRIPTION_INSUFFICIENT_SECURITY = ... # type: int
ALERT_DESCRIPTION_NO_RENEGOTIATION = ... # type: int
ALERT_DESCRIPTION_PROTOCOL_VERSION = ... # type: int
ALERT_DESCRIPTION_RECORD_OVERFLOW = ... # type: int
ALERT_DESCRIPTION_UNEXPECTED_MESSAGE = ... # type: int
ALERT_DESCRIPTION_UNKNOWN_CA = ... # type: int
ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY = ... # type: int
ALERT_DESCRIPTION_UNRECOGNIZED_NAME = ... # type: int
ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE = ... # type: int
ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION = ... # type: int
ALERT_DESCRIPTION_USER_CANCELLED = ... # type: int
_PurposeType = NamedTuple('_PurposeType',
[('nid', int), ('shortname', str),
('longname', str), ('oid', str)])
class Purpose:
SERVER_AUTH = ... # type: _PurposeType
CLIENT_AUTH = ... # type: _PurposeType
class SSLSocket(socket.socket):
def do_handshake(self) -> None: ...
def getpeercert(self, binary_form: bool = ...) -> _PeerCertRetType: ...
def cipher(self) -> Tuple[str, int, int]: ...
def compression(self) -> Optional[str]: ...
def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ...
def selected_alpn_protocol(self) -> Optional[str]: ...
def selected_npn_protocol(self) -> Optional[str]: ...
def unwrap(self) -> socket.socket: ...
def version(self) -> Optional[str]: ...
class SSLContext:
check_hostname = ... # type: bool
options = ... # type: int
@property
def protocol(self) -> int: ...
verify_flags = ... # type: int
verify_mode = ... # type: int
def __init__(self, protocol: int) -> None: ...
def cert_store_stats(self) -> Dict[str, int]: ...
def load_cert_chain(self, certfile: str, keyfile: Optional[str] = ...,
password: _PasswordType = ...) -> None: ...
def load_default_certs(self, purpose: _PurposeType = ...) -> None: ...
def load_verify_locations(self, cafile: Optional[str] = ...,
capath: Optional[str] = ...,
cadata: Union[str, bytes, None] = ...) -> None: ...
def get_ca_certs(self,
binary_form: bool = ...) -> Union[List[_PeerCertRetDictType], List[bytes]]: ...
def set_default_verify_paths(self) -> None: ...
def set_ciphers(self, ciphers: str) -> None: ...
def set_alpn_protocols(self, protocols: List[str]) -> None: ...
def set_npn_protocols(self, protocols: List[str]) -> None: ...
def set_servername_callback(self,
server_name_callback: Optional[_SrvnmeCbType]) -> None: ...
def load_dh_params(self, dhfile: str) -> None: ...
def set_ecdh_curve(self, curve_name: str) -> None: ...
def wrap_socket(self, sock: socket.socket, server_side: bool = ...,
do_handshake_on_connect: bool = ...,
suppress_ragged_eofs: bool = ...,
server_hostname: Optional[str] = ...) -> 'SSLContext': ...
def session_stats(self) -> Dict[str, int]: ...
# TODO below documented in cpython but not in docs.python.org
# taken from python 3.4
SSL_ERROR_EOF = ... # type: int
SSL_ERROR_INVALID_ERROR_CODE = ... # type: int
SSL_ERROR_SSL = ... # type: int
SSL_ERROR_SYSCALL = ... # type: int
SSL_ERROR_WANT_CONNECT = ... # type: int
SSL_ERROR_WANT_READ = ... # type: int
SSL_ERROR_WANT_WRITE = ... # type: int
SSL_ERROR_WANT_X509_LOOKUP = ... # type: int
SSL_ERROR_ZERO_RETURN = ... # type: int
def get_protocol_name(protocol_code: int) -> str: ...
AF_INET = ... # type: int
PEM_FOOTER = ... # type: str
PEM_HEADER = ... # type: str
SOCK_STREAM = ... # type: int
SOL_SOCKET = ... # type: int
SO_TYPE = ... # type: int
mypy-0.470/typeshed/stdlib/2/_io.pyi 0000644 0000000 0000000 00000006644 13023631176 015774 0 ustar root root from typing import Any, Optional, Iterable, Tuple, List, Union
DEFAULT_BUFFER_SIZE = ... # type: int
class BlockingIOError(IOError):
characters_written = ... # type: int
class UnsupportedOperation(ValueError, IOError): ...
class _IOBase(object):
closed = ... # type: bool
def __enter__(self) -> "_IOBase": ...
def __exit__(self, type, value, traceback) -> bool: ...
def __iter__(self) -> "_IOBase": ...
def _checkClosed(self) -> None: ...
def _checkReadable(self) -> None: ...
def _checkSeekable(self) -> None: ...
def _checkWritable(self) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def next(self) -> str: ...
def readable(self) -> bool: ...
def readline(self, limit: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> int: ...
def writable(self) -> bool: ...
def writelines(self, lines: Iterable[str]) -> None: ...
class _BufferedIOBase(_IOBase):
def read1(self, n: int) -> str: ...
def read(self, n: int = ...) -> str: ...
def readinto(self, buffer: bytearray) -> int: ...
def write(self, s: str) -> int: ...
def detach(self) -> "_BufferedIOBase": ...
class BufferedRWPair(_BufferedIOBase):
def peek(self, n: int = ...) -> str: ...
class BufferedRandom(_BufferedIOBase):
name = ... # type: str
raw = ... # type: _IOBase
mode = ... # type: str
def peek(self, n: int = ...) -> str: ...
class BufferedReader(_BufferedIOBase):
name = ... # type: str
raw = ... # type: _IOBase
mode = ... # type: str
def peek(self, n: int = ...) -> str: ...
class BufferedWriter(_BufferedIOBase):
name = ... # type: str
raw = ... # type: _IOBase
mode = ... # type: str
class BytesIO(_BufferedIOBase):
def __setstate__(self, tuple) -> None: ...
def __getstate__(self) -> tuple: ...
def getvalue(self) -> str: ...
class _RawIOBase(_IOBase):
def readall(self) -> str: ...
def read(self, n: int = ...) -> str: ...
class FileIO(_RawIOBase):
mode = ... # type: str
closefd = ... # type: bool
def readinto(self, buffer: bytearray)-> int: ...
def write(self, pbuf: str) -> int: ...
class IncrementalNewlineDecoder(object):
newlines = ... # type: Union[str, unicode]
def decode(self, input, final) -> Any: ...
def getstate(self) -> Tuple[Any, int]: ...
def setstate(self, state: Tuple[Any, int]) -> None: ...
def reset(self) -> None: ...
class _TextIOBase(_IOBase):
errors = ... # type: Optional[str]
newlines = ... # type: Union[str, unicode]
encoding = ... # type: Optional[str]
def read(self, n: int = ...) -> str: ...
def write(self) -> None:
raise UnsupportedOperation
def detach(self) -> None:
raise UnsupportedOperation
class StringIO(_TextIOBase):
line_buffering = ... # type: bool
def getvalue(self) -> str: ...
def __setstate__(self, state: tuple) -> None: ...
def __getstate__(self) -> tuple: ...
class TextIOWrapper(_TextIOBase):
name = ... # type: str
line_buffering = ... # type: bool
buffer = ... # type: str
_CHUNK_SIZE = ... # type: int
def open(file: Union[int, str], mode: str = ...) -> _IOBase: ...
mypy-0.470/typeshed/stdlib/2/importlib.pyi 0000644 0000000 0000000 00000000130 13023631176 017207 0 ustar root root import types
def import_module(name: str, package: str = ...) -> types.ModuleType: ...
mypy-0.470/typeshed/stdlib/2/_struct.pyi 0000644 0000000 0000000 00000001463 13035744274 016712 0 ustar root root """Stub file for the '_struct' module."""
from typing import Any, AnyStr, Tuple
class error(Exception): ...
class Struct(object):
size = ... # type: int
format = ... # type: str
def __init__(self, fmt: str) -> None: ...
def pack_into(self, buffer: bytearray, offset: int, obj: Any) -> None: ...
def pack(self, *args) -> str: ...
def unpack(self, s: str) -> Tuple[Any]: ...
def unpack_from(self, buffer: bytearray, offset: int = ...) -> Tuple[Any]: ...
def _clearcache() -> None: ...
def calcsize(fmt: str) -> int: ...
def pack(fmt: AnyStr, obj: Any) -> str: ...
def pack_into(fmt: AnyStr, buffer: bytearray, offset: int, obj: Any) -> None: ...
def unpack(fmt: AnyStr, data: str) -> Tuple[Any]: ...
def unpack_from(fmt: AnyStr, buffer: bytearray, offset: int = ...) -> Tuple[Any]: ...
mypy-0.470/typeshed/stdlib/2/select.pyi 0000644 0000000 0000000 00000006242 13035744274 016506 0 ustar root root """Stubs for the 'select' module."""
from typing import Any, Optional, Tuple, Iterable, List
EPOLLERR = ... # type: int
EPOLLET = ... # type: int
EPOLLHUP = ... # type: int
EPOLLIN = ... # type: int
EPOLLMSG = ... # type: int
EPOLLONESHOT = ... # type: int
EPOLLOUT = ... # type: int
EPOLLPRI = ... # type: int
EPOLLRDBAND = ... # type: int
EPOLLRDNORM = ... # type: int
EPOLLWRBAND = ... # type: int
EPOLLWRNORM = ... # type: int
EPOLL_RDHUP = ... # type: int
KQ_EV_ADD = ... # type: int
KQ_EV_CLEAR = ... # type: int
KQ_EV_DELETE = ... # type: int
KQ_EV_DISABLE = ... # type: int
KQ_EV_ENABLE = ... # type: int
KQ_EV_EOF = ... # type: int
KQ_EV_ERROR = ... # type: int
KQ_EV_FLAG1 = ... # type: int
KQ_EV_ONESHOT = ... # type: int
KQ_EV_SYSFLAGS = ... # type: int
KQ_FILTER_AIO = ... # type: int
KQ_FILTER_NETDEV = ... # type: int
KQ_FILTER_PROC = ... # type: int
KQ_FILTER_READ = ... # type: int
KQ_FILTER_SIGNAL = ... # type: int
KQ_FILTER_TIMER = ... # type: int
KQ_FILTER_VNODE = ... # type: int
KQ_FILTER_WRITE = ... # type: int
KQ_NOTE_ATTRIB = ... # type: int
KQ_NOTE_CHILD = ... # type: int
KQ_NOTE_DELETE = ... # type: int
KQ_NOTE_EXEC = ... # type: int
KQ_NOTE_EXIT = ... # type: int
KQ_NOTE_EXTEND = ... # type: int
KQ_NOTE_FORK = ... # type: int
KQ_NOTE_LINK = ... # type: int
KQ_NOTE_LINKDOWN = ... # type: int
KQ_NOTE_LINKINV = ... # type: int
KQ_NOTE_LINKUP = ... # type: int
KQ_NOTE_LOWAT = ... # type: int
KQ_NOTE_PCTRLMASK = ... # type: int
KQ_NOTE_PDATAMASK = ... # type: int
KQ_NOTE_RENAME = ... # type: int
KQ_NOTE_REVOKE = ... # type: int
KQ_NOTE_TRACK = ... # type: int
KQ_NOTE_TRACKERR = ... # type: int
KQ_NOTE_WRITE = ... # type: int
PIPE_BUF = ... # type: int
POLLERR = ... # type: int
POLLHUP = ... # type: int
POLLIN = ... # type: int
POLLMSG = ... # type: int
POLLNVAL = ... # type: int
POLLOUT = ... # type: int
POLLPRI = ... # type: int
POLLRDBAND = ... # type: int
POLLRDNORM = ... # type: int
POLLWRBAND = ... # type: int
POLLWRNORM = ... # type: int
def poll() -> epoll: ...
def select(rlist, wlist, xlist, timeout: float = None) -> Tuple[List, List, List]: ...
class error(Exception): ...
class kevent(object):
data = ... # type: Any
fflags = ... # type: int
filter = ... # type: int
flags = ... # type: int
ident = ... # type: Any
udata = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
class kqueue(object):
closed = ... # type: bool
def __init__(self) -> None: ...
def close(self) -> None: ...
def control(self, changelist: Optional[Iterable[kevent]], max_events: int, timeout: int = ...) -> List[kevent]: ...
def fileno(self) -> int: ...
@classmethod
def fromfd(cls, fd: int) -> kqueue: ...
class epoll(object):
def __init__(self, sizehint: int = ...) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def register(self, fd: int, eventmask: int = ...) -> None: ...
def modify(self, fd: int, eventmask: int) -> None: ...
def unregister(self, fd: int) -> None: ...
def poll(self, timeout: float = ..., maxevents: int = ...) -> Any: ...
@classmethod
def fromfd(cls, fd: int) -> epoll: ...
mypy-0.470/typeshed/stdlib/2/Cookie.pyi 0000644 0000000 0000000 00000002477 13035744274 016446 0 ustar root root # Stubs for Cookie (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class CookieError(Exception): ...
class Morsel(dict):
key = ... # type: Any
def __init__(self): ...
def __setitem__(self, K, V): ...
def isReservedKey(self, K): ...
value = ... # type: Any
coded_value = ... # type: Any
def set(self, key, val, coded_val, LegalChars=..., idmap=..., translate=...): ...
def output(self, attrs=None, header=...): ...
def js_output(self, attrs=None): ...
def OutputString(self, attrs=None): ...
class BaseCookie(dict):
def value_decode(self, val): ...
def value_encode(self, val): ...
def __init__(self, input=None): ...
def __setitem__(self, key, value): ...
def output(self, attrs=None, header=..., sep=...): ...
def js_output(self, attrs=None): ...
def load(self, rawdata): ...
class SimpleCookie(BaseCookie):
def value_decode(self, val): ...
def value_encode(self, val): ...
class SerialCookie(BaseCookie):
def __init__(self, input=None): ...
def value_decode(self, val): ...
def value_encode(self, val): ...
class SmartCookie(BaseCookie):
def __init__(self, input=None): ...
def value_decode(self, val): ...
def value_encode(self, val): ...
Cookie = ... # type: Any
mypy-0.470/typeshed/stdlib/2/platform.pyi 0000644 0000000 0000000 00000002640 13035744274 017051 0 ustar root root # Stubs for platform (Python 2)
#
# Based on stub generated by stubgen.
from typing import Any
__copyright__ = ... # type: Any
DEV_NULL = ... # type: Any
def libc_ver(executable=..., lib=..., version=..., chunksize=2048): ...
def linux_distribution(distname=..., version=..., id=..., supported_dists=..., full_distribution_name=1): ...
def dist(distname=..., version=..., id=..., supported_dists=...): ...
class _popen:
tmpfile = ... # type: Any
pipe = ... # type: Any
bufsize = ... # type: Any
mode = ... # type: Any
def __init__(self, cmd, mode=..., bufsize=None): ...
def read(self): ...
def readlines(self): ...
def close(self, remove=..., error=...): ...
__del__ = ... # type: Any
def popen(cmd, mode=..., bufsize=None): ...
def win32_ver(release=..., version=..., csd=..., ptype=...): ...
def mac_ver(release=..., versioninfo=..., machine=...): ...
def java_ver(release=..., vendor=..., vminfo=..., osinfo=...): ...
def system_alias(system, release, version): ...
def architecture(executable=..., bits=..., linkage=...): ...
def uname(): ...
def system(): ...
def node(): ...
def release(): ...
def version(): ...
def machine(): ...
def processor(): ...
def python_implementation(): ...
def python_version(): ...
def python_version_tuple(): ...
def python_branch(): ...
def python_revision(): ...
def python_build(): ...
def python_compiler(): ...
def platform(aliased=0, terse=0): ...
mypy-0.470/typeshed/stdlib/2/httplib.pyi 0000644 0000000 0000000 00000013645 13035744274 016702 0 ustar root root # Stubs for httplib (Python 2)
#
# Generated by stubgen and manually massaged a bit.
# Needs lots more work!
from typing import Any, Dict
import mimetools
class HTTPMessage(mimetools.Message):
def addheader(self, key: str, value: str) -> None: ...
def addcontinue(self, key: str, more: str) -> None: ...
dict = ... # type: Dict[str, str]
unixfrom = ... # type: str
headers = ... # type: Any
status = ... # type: str
seekable = ... # type: bool
def readheaders(self) -> None: ...
class HTTPResponse:
fp = ... # type: Any
debuglevel = ... # type: Any
strict = ... # type: Any
msg = ... # type: Any
version = ... # type: Any
status = ... # type: Any
reason = ... # type: Any
chunked = ... # type: Any
chunk_left = ... # type: Any
length = ... # type: Any
will_close = ... # type: Any
def __init__(self, sock, debuglevel=0, strict=0, method=None, buffering: bool=...) -> None: ...
def begin(self): ...
def close(self): ...
def isclosed(self): ...
def read(self, amt=None): ...
def fileno(self): ...
def getheader(self, name, default=None): ...
def getheaders(self): ...
class HTTPConnection:
response_class = ... # type: Any
default_port = ... # type: Any
auto_open = ... # type: Any
debuglevel = ... # type: Any
strict = ... # type: Any
timeout = ... # type: Any
source_address = ... # type: Any
sock = ... # type: Any
def __init__(self, host, port=None, strict=None, timeout=..., source_address=None) -> None: ...
def set_tunnel(self, host, port=None, headers=None): ...
def set_debuglevel(self, level): ...
def connect(self): ...
def close(self): ...
def send(self, data): ...
def putrequest(self, method, url, skip_host=0, skip_accept_encoding=0): ...
def putheader(self, header, *values): ...
def endheaders(self, message_body=None): ...
def request(self, method, url, body=None, headers=...): ...
def getresponse(self, buffering: bool=...): ...
class HTTP:
debuglevel = ... # type: Any
def __init__(self, host: str=..., port=None, strict=None) -> None: ...
def connect(self, host=None, port=None): ...
def getfile(self): ...
file = ... # type: Any
headers = ... # type: Any
def getreply(self, buffering: bool=...): ...
def close(self): ...
class HTTPSConnection(HTTPConnection):
default_port = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
def __init__(self, host, port=None, key_file=None, cert_file=None, strict=None, timeout=..., source_address=None, context=None) -> None: ...
sock = ... # type: Any
def connect(self): ...
class HTTPS(HTTP):
key_file = ... # type: Any
cert_file = ... # type: Any
def __init__(self, host: str=..., port=None, key_file=None, cert_file=None, strict=None, context=None) -> None: ...
class HTTPException(Exception): ...
class NotConnected(HTTPException): ...
class InvalidURL(HTTPException): ...
class UnknownProtocol(HTTPException):
args = ... # type: Any
version = ... # type: Any
def __init__(self, version) -> None: ...
class UnknownTransferEncoding(HTTPException): ...
class UnimplementedFileMode(HTTPException): ...
class IncompleteRead(HTTPException):
args = ... # type: Any
partial = ... # type: Any
expected = ... # type: Any
def __init__(self, partial, expected=None) -> None: ...
class ImproperConnectionState(HTTPException): ...
class CannotSendRequest(ImproperConnectionState): ...
class CannotSendHeader(ImproperConnectionState): ...
class ResponseNotReady(ImproperConnectionState): ...
class BadStatusLine(HTTPException):
args = ... # type: Any
line = ... # type: Any
def __init__(self, line) -> None: ...
class LineTooLong(HTTPException):
def __init__(self, line_type) -> None: ...
error = ... # type: Any
class LineAndFileWrapper:
def __init__(self, line, file) -> None: ...
def __getattr__(self, attr): ...
def read(self, amt=None): ...
def readline(self): ...
def readlines(self, size=None): ...
# Constants
responses = ... # type: Dict[int, str]
HTTP_PORT = ... # type: int
HTTPS_PORT = ... # type: int
# status codes
# informational
CONTINUE = ... # type: int
SWITCHING_PROTOCOLS = ... # type: int
PROCESSING = ... # type: int
# successful
OK = ... # type: int
CREATED = ... # type: int
ACCEPTED = ... # type: int
NON_AUTHORITATIVE_INFORMATION = ... # type: int
NO_CONTENT = ... # type: int
RESET_CONTENT = ... # type: int
PARTIAL_CONTENT = ... # type: int
MULTI_STATUS = ... # type: int
IM_USED = ... # type: int
# redirection
MULTIPLE_CHOICES = ... # type: int
MOVED_PERMANENTLY = ... # type: int
FOUND = ... # type: int
SEE_OTHER = ... # type: int
NOT_MODIFIED = ... # type: int
USE_PROXY = ... # type: int
TEMPORARY_REDIRECT = ... # type: int
# client error
BAD_REQUEST = ... # type: int
UNAUTHORIZED = ... # type: int
PAYMENT_REQUIRED = ... # type: int
FORBIDDEN = ... # type: int
NOT_FOUND = ... # type: int
METHOD_NOT_ALLOWED = ... # type: int
NOT_ACCEPTABLE = ... # type: int
PROXY_AUTHENTICATION_REQUIRED = ... # type: int
REQUEST_TIMEOUT = ... # type: int
CONFLICT = ... # type: int
GONE = ... # type: int
LENGTH_REQUIRED = ... # type: int
PRECONDITION_FAILED = ... # type: int
REQUEST_ENTITY_TOO_LARGE = ... # type: int
REQUEST_URI_TOO_LONG = ... # type: int
UNSUPPORTED_MEDIA_TYPE = ... # type: int
REQUESTED_RANGE_NOT_SATISFIABLE = ... # type: int
EXPECTATION_FAILED = ... # type: int
UNPROCESSABLE_ENTITY = ... # type: int
LOCKED = ... # type: int
FAILED_DEPENDENCY = ... # type: int
UPGRADE_REQUIRED = ... # type: int
# server error
INTERNAL_SERVER_ERROR = ... # type: int
NOT_IMPLEMENTED = ... # type: int
BAD_GATEWAY = ... # type: int
SERVICE_UNAVAILABLE = ... # type: int
GATEWAY_TIMEOUT = ... # type: int
HTTP_VERSION_NOT_SUPPORTED = ... # type: int
INSUFFICIENT_STORAGE = ... # type: int
NOT_EXTENDED = ... # type: int
mypy-0.470/typeshed/stdlib/2/cookielib.pyi 0000644 0000000 0000000 00000011067 13023631176 017161 0 ustar root root # Stubs for cookielib (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class Cookie:
version = ... # type: Any
name = ... # type: Any
value = ... # type: Any
port = ... # type: Any
port_specified = ... # type: Any
domain = ... # type: Any
domain_specified = ... # type: Any
domain_initial_dot = ... # type: Any
path = ... # type: Any
path_specified = ... # type: Any
secure = ... # type: Any
expires = ... # type: Any
discard = ... # type: Any
comment = ... # type: Any
comment_url = ... # type: Any
rfc2109 = ... # type: Any
def __init__(self, version, name, value, port, port_specified, domain, domain_specified, domain_initial_dot, path, path_specified, secure, expires, discard, comment, comment_url, rest, rfc2109=False): ...
def has_nonstandard_attr(self, name): ...
def get_nonstandard_attr(self, name, default=None): ...
def set_nonstandard_attr(self, name, value): ...
def is_expired(self, now=None): ...
class CookiePolicy:
def set_ok(self, cookie, request): ...
def return_ok(self, cookie, request): ...
def domain_return_ok(self, domain, request): ...
def path_return_ok(self, path, request): ...
class DefaultCookiePolicy(CookiePolicy):
DomainStrictNoDots = ... # type: Any
DomainStrictNonDomain = ... # type: Any
DomainRFC2965Match = ... # type: Any
DomainLiberal = ... # type: Any
DomainStrict = ... # type: Any
netscape = ... # type: Any
rfc2965 = ... # type: Any
rfc2109_as_netscape = ... # type: Any
hide_cookie2 = ... # type: Any
strict_domain = ... # type: Any
strict_rfc2965_unverifiable = ... # type: Any
strict_ns_unverifiable = ... # type: Any
strict_ns_domain = ... # type: Any
strict_ns_set_initial_dollar = ... # type: Any
strict_ns_set_path = ... # type: Any
def __init__(self, blocked_domains=None, allowed_domains=None, netscape=True, rfc2965=False, rfc2109_as_netscape=None, hide_cookie2=False, strict_domain=False, strict_rfc2965_unverifiable=True, strict_ns_unverifiable=False, strict_ns_domain=..., strict_ns_set_initial_dollar=False, strict_ns_set_path=False): ...
def blocked_domains(self): ...
def set_blocked_domains(self, blocked_domains): ...
def is_blocked(self, domain): ...
def allowed_domains(self): ...
def set_allowed_domains(self, allowed_domains): ...
def is_not_allowed(self, domain): ...
def set_ok(self, cookie, request): ...
def set_ok_version(self, cookie, request): ...
def set_ok_verifiability(self, cookie, request): ...
def set_ok_name(self, cookie, request): ...
def set_ok_path(self, cookie, request): ...
def set_ok_domain(self, cookie, request): ...
def set_ok_port(self, cookie, request): ...
def return_ok(self, cookie, request): ...
def return_ok_version(self, cookie, request): ...
def return_ok_verifiability(self, cookie, request): ...
def return_ok_secure(self, cookie, request): ...
def return_ok_expires(self, cookie, request): ...
def return_ok_port(self, cookie, request): ...
def return_ok_domain(self, cookie, request): ...
def domain_return_ok(self, domain, request): ...
def path_return_ok(self, path, request): ...
class Absent: ...
class CookieJar:
non_word_re = ... # type: Any
quote_re = ... # type: Any
strict_domain_re = ... # type: Any
domain_re = ... # type: Any
dots_re = ... # type: Any
magic_re = ... # type: Any
def __init__(self, policy=None): ...
def set_policy(self, policy): ...
def add_cookie_header(self, request): ...
def make_cookies(self, response, request): ...
def set_cookie_if_ok(self, cookie, request): ...
def set_cookie(self, cookie): ...
def extract_cookies(self, response, request): ...
def clear(self, domain=None, path=None, name=None): ...
def clear_session_cookies(self): ...
def clear_expired_cookies(self): ...
def __iter__(self): ...
def __len__(self): ...
class LoadError(IOError): ...
class FileCookieJar(CookieJar):
filename = ... # type: Any
delayload = ... # type: Any
def __init__(self, filename=None, delayload=False, policy=None): ...
def save(self, filename=None, ignore_discard=False, ignore_expires=False): ...
def load(self, filename=None, ignore_discard=False, ignore_expires=False): ...
def revert(self, filename=None, ignore_discard=False, ignore_expires=False): ...
MozillaCookieJar = FileCookieJar
LWPCookieJar = FileCookieJar
def lwp_cookie_str(cookie: Cookie) -> str: ...
mypy-0.470/typeshed/stdlib/2/random.pyi 0000644 0000000 0000000 00000006207 13035744274 016510 0 ustar root root # Stubs for random
# Ron Murawski
# Updated by Jukka Lehtosalo
# based on https://docs.python.org/2/library/random.html
# ----- random classes -----
import _random
from typing import (
Any, TypeVar, Sequence, List, Callable, AbstractSet, Union,
overload
)
_T = TypeVar('_T')
class Random(_random.Random):
def __init__(self, x: object = ...) -> None: ...
def seed(self, x: object = ...) -> None: ...
def getstate(self) -> _random._State: ...
def setstate(self, state: _random._State) -> None: ...
def jumpahead(self, n: int) -> None: ...
def getrandbits(self, k: int) -> int: ...
@overload
def randrange(self, stop: int) -> int: ...
@overload
def randrange(self, start: int, stop: int, step: int = ...) -> int: ...
def randint(self, a: int, b: int) -> int: ...
def choice(self, seq: Sequence[_T]) -> _T: ...
def shuffle(self, x: List[Any], random: Callable[[], None] = ...) -> None: ...
def sample(self, population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random(self) -> float: ...
def uniform(self, a: float, b: float) -> float: ...
def triangular(self, low: float = ..., high: float = ...,
mode: float = ...) -> float: ...
def betavariate(self, alpha: float, beta: float) -> float: ...
def expovariate(self, lambd: float) -> float: ...
def gammavariate(self, alpha: float, beta: float) -> float: ...
def gauss(self, mu: float, sigma: float) -> float: ...
def lognormvariate(self, mu: float, sigma: float) -> float: ...
def normalvariate(self, mu: float, sigma: float) -> float: ...
def vonmisesvariate(self, mu: float, kappa: float) -> float: ...
def paretovariate(self, alpha: float) -> float: ...
def weibullvariate(self, alpha: float, beta: float) -> float: ...
# SystemRandom is not implemented for all OS's; good on Windows & Linux
class SystemRandom(Random):
...
# ----- random function stubs -----
def seed(x: object = ...) -> None: ...
def getstate() -> object: ...
def setstate(state: object) -> None: ...
def jumpahead(n: int) -> None: ...
def getrandbits(k: int) -> int: ...
@overload
def randrange(stop: int) -> int: ...
@overload
def randrange(start: int, stop: int, step: int = ...) -> int: ...
def randint(a: int, b: int) -> int: ...
def choice(seq: Sequence[_T]) -> _T: ...
def shuffle(x: List[Any], random: Callable[[], float] = ...) -> None: ...
def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random() -> float: ...
def uniform(a: float, b: float) -> float: ...
def triangular(low: float = ..., high: float = ...,
mode: float = ...) -> float: ...
def betavariate(alpha: float, beta: float) -> float: ...
def expovariate(lambd: float) -> float: ...
def gammavariate(alpha: float, beta: float) -> float: ...
def gauss(mu: float, sigma: float) -> float: ...
def lognormvariate(mu: float, sigma: float) -> float: ...
def normalvariate(mu: float, sigma: float) -> float: ...
def vonmisesvariate(mu: float, kappa: float) -> float: ...
def paretovariate(alpha: float) -> float: ...
def weibullvariate(alpha: float, beta: float) -> float: ...
mypy-0.470/typeshed/stdlib/2/_sha256.pyi 0000644 0000000 0000000 00000001354 13023631176 016366 0 ustar root root from typing import Optional
class sha224(object):
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
digestsize = ... # type: int
def __init__(self, init: Optional[str]) -> None: ...
def copy(self) -> "sha224": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
class sha256(object):
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
digestsize = ... # type: int
def __init__(self, init: Optional[str]) -> None: ...
def copy(self) -> "sha256": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
mypy-0.470/typeshed/stdlib/2/compileall.pyi 0000644 0000000 0000000 00000000526 13023631176 017340 0 ustar root root # Stubs for compileall (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def compile_dir(dir, maxlevels=..., ddir=..., force=..., rx=..., quiet=...): ...
def compile_file(fullname, ddir=..., force=..., rx=..., quiet=...): ...
def compile_path(skip_curdir=..., maxlevels=..., force=..., quiet=...): ...
mypy-0.470/typeshed/stdlib/2/_md5.pyi 0000644 0000000 0000000 00000000564 13023631176 016045 0 ustar root root blocksize = ... # type: int
digest_size = ... # type: int
class MD5Type(object):
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
def copy(self) -> "MD5Type": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
def new(arg: str = ...) -> MD5Type: ...
mypy-0.470/typeshed/stdlib/2/decimal.pyi 0000644 0000000 0000000 00000023473 13044257024 016622 0 ustar root root # Stubs for decimal (Python 2)
from typing import (
Any, Dict, NamedTuple, Optional, Sequence, Tuple, Union,
SupportsAbs, SupportsFloat, SupportsInt,
)
_Decimal = Union[Decimal, int]
_ComparableNum = Union[Decimal, int, float]
DecimalTuple = NamedTuple('DecimalTuple',
[('sign', int),
('digits', Sequence[int]), # TODO: Use Tuple[int, ...]
('exponent', int)])
ROUND_DOWN = ... # type: str
ROUND_HALF_UP = ... # type: str
ROUND_HALF_EVEN = ... # type: str
ROUND_CEILING = ... # type: str
ROUND_FLOOR = ... # type: str
ROUND_UP = ... # type: str
ROUND_HALF_DOWN = ... # type: str
ROUND_05UP = ... # type: str
class DecimalException(ArithmeticError):
def handle(self, context, *args): ...
class Clamped(DecimalException): ...
class InvalidOperation(DecimalException): ...
class ConversionSyntax(InvalidOperation): ...
class DivisionByZero(DecimalException, ZeroDivisionError): ...
class DivisionImpossible(InvalidOperation): ...
class DivisionUndefined(InvalidOperation, ZeroDivisionError): ...
class Inexact(DecimalException): ...
class InvalidContext(InvalidOperation): ...
class Rounded(DecimalException): ...
class Subnormal(DecimalException): ...
class Overflow(Inexact, Rounded): ...
class Underflow(Inexact, Rounded, Subnormal): ...
def setcontext(context: Context): ...
def getcontext() -> Context: ...
def localcontext(ctx: Optional[Context] = None) -> _ContextManager: ...
class Decimal(SupportsAbs[Decimal], SupportsFloat, SupportsInt):
def __init__(cls, value: Union[_Decimal, float, str,
Tuple[int, Sequence[int], int]] = ...,
context: Context = ...) -> None: ...
@classmethod
def from_float(cls, f: float) -> Decimal: ...
def __nonzero__(self) -> bool: ...
def __eq__(self, other: object) -> bool: ...
def __ne__(self, other: object) -> bool: ...
def __lt__(self, other: _ComparableNum) -> bool: ...
def __le__(self, other: _ComparableNum) -> bool: ...
def __gt__(self, other: _ComparableNum) -> bool: ...
def __ge__(self, other: _ComparableNum) -> bool: ...
def compare(self, other: _Decimal) -> Decimal: ...
def __hash__(self) -> int: ...
def as_tuple(self) -> DecimalTuple: ...
def to_eng_string(self, context: Context = ...) -> str: ...
def __neg__(self) -> Decimal: ...
def __pos__(self) -> Decimal: ...
def __abs__(self, round: bool = True) -> Decimal: ...
def __add__(self, other: _Decimal) -> Decimal: ...
def __radd__(self, other: int) -> Decimal: ...
def __sub__(self, other: _Decimal) -> Decimal: ...
def __rsub__(self, other: int) -> Decimal: ...
def __mul__(self, other: _Decimal) -> Decimal: ...
def __rmul__(self, other: int) -> Decimal: ...
def __truediv__(self, other: _Decimal) -> Decimal: ...
def __rtruediv__(self, other: int) -> Decimal: ...
def __div__(self, other: _Decimal) -> Decimal: ...
def __rdiv__(self, other: int) -> Decimal: ...
def __divmod__(self, other: _Decimal) -> Tuple[Decimal, Decimal]: ...
def __rdivmod__(self, other: int) -> Tuple[Decimal, Decimal]: ...
def __mod__(self, other: _Decimal) -> Decimal: ...
def __rmod__(self, other: int) -> Decimal: ...
def remainder_near(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def __floordiv__(self, other: _Decimal) -> Decimal: ...
def __rfloordiv__(self, other: int) -> Decimal: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def __trunc__(self) -> int: ...
@property
def imag(self) -> Decimal: ...
@property
def real(self) -> Decimal: ...
def conjugate(self) -> Decimal: ...
def __complex__(self) -> complex: ...
def __long__(self) -> long: ...
def fma(self, other: _Decimal, third: _Decimal, context: Context = ...) -> Decimal: ...
def __pow__(self, other: _Decimal) -> Decimal: ...
def __rpow__(self, other: int) -> Decimal: ...
def normalize(self, context: Context = ...) -> Decimal: ...
def quantize(self, exp: _Decimal, rounding: str = ...,
context: Context = ...) -> Decimal: ...
def same_quantum(self, other: Decimal) -> bool: ...
def to_integral(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def to_integral_exact(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def to_integral_value(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def sqrt(self, context: Context = ...) -> Decimal: ...
def max(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def min(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def adjusted(self) -> int: ...
def canonical(self, context: Context = ...) -> Decimal: ...
def compare_signal(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def compare_total(self, other: _Decimal) -> Decimal: ...
def compare_total_mag(self, other: _Decimal) -> Decimal: ...
def copy_abs(self) -> Decimal: ...
def copy_negate(self) -> Decimal: ...
def copy_sign(self, other: _Decimal) -> Decimal: ...
def exp(self, context: Context = ...) -> Decimal: ...
def is_canonical(self) -> bool: ...
def is_finite(self) -> bool: ...
def is_infinite(self) -> bool: ...
def is_nan(self) -> bool: ...
def is_normal(self, context: Context = ...) -> bool: ...
def is_qnan(self) -> bool: ...
def is_signed(self) -> bool: ...
def is_snan(self) -> bool: ...
def is_subnormal(self, context: Context = ...) -> bool: ...
def is_zero(self) -> bool: ...
def ln(self, context: Context = ...) -> Decimal: ...
def log10(self, context: Context = ...) -> Decimal: ...
def logb(self, context: Context = ...) -> Decimal: ...
def logical_and(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def logical_invert(self, context: Context = ...) -> Decimal: ...
def logical_or(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def logical_xor(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def max_mag(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def min_mag(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def next_minus(self, context: Context = ...) -> Decimal: ...
def next_plus(self, context: Context = ...) -> Decimal: ...
def next_toward(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def number_class(self, context: Context = ...) -> str: ...
def radix(self) -> Decimal: ...
def rotate(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def scaleb(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def shift(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def __reduce__(self): ...
def __copy__(self): ...
def __deepcopy__(self, memo): ...
def __format__(self, specifier, context=None, _localeconv=None) -> str: ...
class _ContextManager:
new_context = ... # type: Context
saved_context = ... # type: Context
def __init__(self, new_context: Context) -> None: ...
def __enter__(self): ...
def __exit__(self, t, v, tb): ...
class Context:
prec = ... # type: int
rounding = ... # type: str
Emin = ... # type: int
Emax = ... # type: int
capitals = ... # type: int
traps = ... # type: Dict[type, bool]
flags = ... # type: Any
def __init__(self, prec=None, rounding=None, traps=None, flags=None, Emin=None, Emax=None, capitals=None, _clamp=0, _ignored_flags=None): ...
def clear_flags(self): ...
def copy(self): ...
__copy__ = ... # type: Any
__hash__ = ... # type: Any
def Etiny(self): ...
def Etop(self): ...
def create_decimal(self, num=...): ...
def create_decimal_from_float(self, f): ...
def abs(self, a): ...
def add(self, a, b): ...
def canonical(self, a): ...
def compare(self, a, b): ...
def compare_signal(self, a, b): ...
def compare_total(self, a, b): ...
def compare_total_mag(self, a, b): ...
def copy_abs(self, a): ...
def copy_decimal(self, a): ...
def copy_negate(self, a): ...
def copy_sign(self, a, b): ...
def divide(self, a, b): ...
def divide_int(self, a, b): ...
def divmod(self, a, b): ...
def exp(self, a): ...
def fma(self, a, b, c): ...
def is_canonical(self, a): ...
def is_finite(self, a): ...
def is_infinite(self, a): ...
def is_nan(self, a): ...
def is_normal(self, a): ...
def is_qnan(self, a): ...
def is_signed(self, a): ...
def is_snan(self, a): ...
def is_subnormal(self, a): ...
def is_zero(self, a): ...
def ln(self, a): ...
def log10(self, a): ...
def logb(self, a): ...
def logical_and(self, a, b): ...
def logical_invert(self, a): ...
def logical_or(self, a, b): ...
def logical_xor(self, a, b): ...
def max(self, a, b): ...
def max_mag(self, a, b): ...
def min(self, a, b): ...
def min_mag(self, a, b): ...
def minus(self, a): ...
def multiply(self, a, b): ...
def next_minus(self, a): ...
def next_plus(self, a): ...
def next_toward(self, a, b): ...
def normalize(self, a): ...
def number_class(self, a): ...
def plus(self, a): ...
def power(self, a, b, modulo=None): ...
def quantize(self, a, b): ...
def radix(self): ...
def remainder(self, a, b): ...
def remainder_near(self, a, b): ...
def rotate(self, a, b): ...
def same_quantum(self, a, b): ...
def scaleb(self, a, b): ...
def shift(self, a, b): ...
def sqrt(self, a): ...
def subtract(self, a, b): ...
def to_eng_string(self, a): ...
def to_sci_string(self, a): ...
def to_integral_exact(self, a): ...
def to_integral_value(self, a): ...
def to_integral(self, a): ...
DefaultContext = ... # type: Context
BasicContext = ... # type: Context
ExtendedContext = ... # type: Context
mypy-0.470/typeshed/stdlib/2/urllib2.pyi 0000644 0000000 0000000 00000013052 13035744274 016577 0 ustar root root
from typing import AnyStr, Dict, List, Union
from urllib import addinfourl
class URLError(IOError):
reason = ... # type: Union[str, BaseException]
class HTTPError(URLError, addinfourl):
code = ... # type: int
headers = ... # type: Dict[str, str]
class Request(object):
host = ... # type: str
port = ... # type: str
data = ... # type: str
headers = ... # type: Dict[str, str]
unverifiable = ... # type: bool
type = ...
origin_req_host = ...
unredirected_hdrs = ...
def __init__(self, url: str, data: str = None, headers: Dict[str, str] = ...,
origin_req_host: str = None, unverifiable: bool = ...) -> None: ...
def __getattr__(self, attr): ...
def get_method(self) -> str: ...
def add_data(self, data) -> None: ...
def has_data(self) -> bool: ...
def get_data(self) -> str: ...
def get_full_url(self) -> str: ...
def get_type(self): ...
def get_host(self) -> str: ...
def get_selector(self): ...
def set_proxy(self, host, type) -> None: ...
def has_proxy(self) -> bool: ...
def get_origin_req_host(self) -> str: ...
def is_unverifiable(self) -> bool: ...
def add_header(self, key: str, val: str) -> None: ...
def add_unredirected_header(self, key: str, val: str) -> None: ...
def has_header(self, header_name: str) -> bool: ...
def get_header(self, header_name: str, default: str = None) -> str: ...
def header_items(self): ...
class OpenerDirector(object): ...
def urlopen(url, data=None, timeout=..., cafile=None, capath=None, cadefault=False,
context=None): ...
def install_opener(opener): ...
def build_opener(*handlers): ...
class BaseHandler:
handler_order = ... # int
def add_parent(self, parent) -> None: ...
def close(self) -> None: ...
def __lt__(self, other) -> bool: ...
class HTTPErrorProcessor(BaseHandler):
def http_response(self, request, response): ...
class HTTPDefaultErrorHandler(BaseHandler):
def http_error_default(self, req, fp, code, msg, hdrs): ...
class HTTPRedirectHandler(BaseHandler):
max_repeats = ... # int
max_redirections = ... # int
def redirect_request(self, req, fp, code, msg, headers, newurl): ...
def http_error_301(self, req, fp, code, msg, headers): ...
def http_error_302(self, req, fp, code, msg, headers): ...
def http_error_303(self, req, fp, code, msg, headers): ...
def http_error_307(self, req, fp, code, msg, headers): ...
inf_msg = ... # type: str
class ProxyHandler(BaseHandler):
def __init__(self, proxies=None): ...
def proxy_open(self, req, proxy, type): ...
class HTTPPasswordMgr:
def __init__(self) -> None: ...
def add_password(self, realm, uri, user, passwd): ...
def find_user_password(self, realm, authuri): ...
def reduce_uri(self, uri, default_port: bool): ...
def is_suburi(self, base, test): ...
class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr): ...
class AbstractBasicAuthHandler:
def __init__(self, password_mgr=None): ...
def reset_retry_count(self): ...
def http_error_auth_reqed(self, authreq, host, req, headers): ...
def retry_http_basic_auth(self, host, req, realm): ...
class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
auth_header = ... # type: str
def http_error_401(self, req, fp, code, msg, headers): ...
class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
auth_header = ... # type: str
def http_error_407(self, req, fp, code, msg, headers): ...
class AbstractDigestAuthHandler:
def __init__(self, passwd=None): ...
def reset_retry_count(self): ...
def http_error_auth_reqed(self, auth_header, host, req, headers): ...
def retry_http_digest_auth(self, req, auth): ...
def get_cnonce(self, nonce): ...
def get_authorization(self, req, chal): ...
def get_algorithm_impls(self, algorithm): ...
def get_entity_digest(self, data, chal): ...
class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
auth_header = ... # str
handler_order = ... # int
def http_error_401(self, req, fp, code, msg, headers): ...
class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
auth_header = ... # str
handler_order = ... # int
def http_error_407(self, req, fp, code, msg, headers): ...
class AbstractHTTPHandler(BaseHandler):
def __init__(self, debuglevel: int) -> None: ...
def do_request_(self, request): ...
def do_open(self, http_class, req): ...
class HTTPHandler(AbstractHTTPHandler):
def http_open(self, req): ...
def http_request(self, request): ...
class HTTPSHandler(AbstractHTTPHandler):
def __init__(self, debuglevel=0, context=None): ...
def https_open(self, req): ...
def https_request(self, request): ...
class HTTPCookieProcessor(BaseHandler):
def __init__(self, cookiejar=None): ...
def http_request(self, request): ...
def http_response(self, request, response): ...
class UnknownHandler(BaseHandler):
def unknown_open(self, req): ...
class FileHandler(BaseHandler):
def file_open(self, req): ...
def get_names(self): ...
def open_local_file(self, req): ...
class FTPHandler(BaseHandler):
def ftp_open(self, req): ...
def connect_ftp(self, user, passwd, host, port, dirs, timeout): ...
class CacheFTPHandler(FTPHandler):
def __init__(self): ...
def setTimeout(self, t): ...
def setMaxConns(self, m): ...
def check_cache(self): ...
def clear_cache(self): ...
def parse_http_list(s: AnyStr) -> List[AnyStr]: ...
def parse_keqv_list(l: List[AnyStr]) -> Dict[AnyStr, AnyStr]: ...
mypy-0.470/typeshed/stdlib/2/textwrap.pyi 0000644 0000000 0000000 00000002311 13035744274 017076 0 ustar root root # Stubs for textwrap (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _unicode: ...
class TextWrapper:
whitespace_trans = ... # type: Any
unicode_whitespace_trans = ... # type: Any
uspace = ... # type: Any
wordsep_re = ... # type: Any
wordsep_simple_re = ... # type: Any
sentence_end_re = ... # type: Any
width = ... # type: Any
initial_indent = ... # type: Any
subsequent_indent = ... # type: Any
expand_tabs = ... # type: Any
replace_whitespace = ... # type: Any
fix_sentence_endings = ... # type: Any
break_long_words = ... # type: Any
drop_whitespace = ... # type: Any
break_on_hyphens = ... # type: Any
wordsep_re_uni = ... # type: Any
wordsep_simple_re_uni = ... # type: Any
def __init__(self, width=..., initial_indent=..., subsequent_indent=..., expand_tabs=..., replace_whitespace=..., fix_sentence_endings=..., break_long_words=..., drop_whitespace=..., break_on_hyphens=...) -> None: ...
def wrap(self, text): ...
def fill(self, text): ...
def wrap(text, width=..., **kwargs): ...
def fill(text, width=..., **kwargs): ...
def dedent(text): ...
mypy-0.470/typeshed/stdlib/2/runpy.pyi 0000644 0000000 0000000 00000001143 13035744274 016377 0 ustar root root # Stubs for runpy (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _TempModule:
mod_name = ... # type: Any
module = ... # type: Any
def __init__(self, mod_name): ...
def __enter__(self): ...
def __exit__(self, *args): ...
class _ModifiedArgv0:
value = ... # type: Any
def __init__(self, value): ...
def __enter__(self): ...
def __exit__(self, *args): ...
def run_module(mod_name, init_globals=None, run_name=None, alter_sys=False): ...
def run_path(path_name, init_globals=None, run_name=None): ...
mypy-0.470/typeshed/stdlib/2/_codecs.pyi 0000644 0000000 0000000 00000007370 13035744274 016631 0 ustar root root """Stub file for the '_codecs' module."""
from typing import Any, AnyStr, Callable, Tuple, Optional
import codecs
# For convenience:
_Handler = Callable[[Exception], Tuple[unicode, int]]
# Not exposed. In Python 2, this is defined in unicode.c:
class _EncodingMap(object):
def size(self) -> int: ...
def register(search_function: Callable[[str], Any]) -> None: ...
def register_error(errors: str, handler: _Handler) -> None: ...
def lookup(a: str) -> codecs.CodecInfo: ...
def lookup_error(a: str) -> _Handler: ...
def decode(obj: Any, encoding: str = ..., errors: str = ...) -> Any: ...
def encode(obj: Any, encoding: str = ..., errors: str = ...) -> Any: ...
def charmap_build(a: unicode) -> _EncodingMap: ...
def ascii_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def ascii_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def charbuffer_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def charmap_decode(data: AnyStr, errors: str = ..., mapping: Optional[_EncodingMap] = ...) -> Tuple[unicode, int]: ...
def charmap_encode(data: AnyStr, errors: str, mapping: Optional[_EncodingMap] = ...) -> Tuple[str, int]: ...
def escape_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def escape_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def latin_1_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def latin_1_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def raw_unicode_escape_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def raw_unicode_escape_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def readbuffer_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def unicode_escape_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def unicode_escape_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def unicode_internal_decode(data: AnyStr, errors: str = ...) -> Tuple[unicode, int]: ...
def unicode_internal_encode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def utf_16_be_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_16_be_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_16_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_ex_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_16_le_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_16_le_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_be_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_32_be_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_32_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_ex_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_32_le_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_32_le_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_7_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_7_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_8_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[unicode, int]: ...
def utf_8_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
mypy-0.470/typeshed/stdlib/2/rfc822.pyi 0000644 0000000 0000000 00000004572 13035744274 016241 0 ustar root root # Stubs for rfc822 (Python 2)
#
# Based on stub generated by stubgen.
from typing import Any
class Message:
fp = ... # type: Any
seekable = ... # type: Any
startofheaders = ... # type: Any
startofbody = ... # type: Any
def __init__(self, fp, seekable=1): ...
def rewindbody(self): ...
dict = ... # type: Any
unixfrom = ... # type: Any
headers = ... # type: Any
status = ... # type: Any
def readheaders(self): ...
def isheader(self, line): ...
def islast(self, line): ...
def iscomment(self, line): ...
def getallmatchingheaders(self, name): ...
def getfirstmatchingheader(self, name): ...
def getrawheader(self, name): ...
def getheader(self, name, default=None): ...
get = ... # type: Any
def getheaders(self, name): ...
def getaddr(self, name): ...
def getaddrlist(self, name): ...
def getdate(self, name): ...
def getdate_tz(self, name): ...
def __len__(self): ...
def __getitem__(self, name): ...
def __setitem__(self, name, value): ...
def __delitem__(self, name): ...
def setdefault(self, name, default=...): ...
def has_key(self, name): ...
def __contains__(self, name): ...
def __iter__(self): ...
def keys(self): ...
def values(self): ...
def items(self): ...
class AddrlistClass:
specials = ... # type: Any
pos = ... # type: Any
LWS = ... # type: Any
CR = ... # type: Any
atomends = ... # type: Any
phraseends = ... # type: Any
field = ... # type: Any
commentlist = ... # type: Any
def __init__(self, field): ...
def gotonext(self): ...
def getaddrlist(self): ...
def getaddress(self): ...
def getrouteaddr(self): ...
def getaddrspec(self): ...
def getdomain(self): ...
def getdelimited(self, beginchar, endchars, allowcomments=1): ...
def getquote(self): ...
def getcomment(self): ...
def getdomainliteral(self): ...
def getatom(self, atomends=None): ...
def getphraselist(self): ...
class AddressList(AddrlistClass):
addresslist = ... # type: Any
def __init__(self, field): ...
def __len__(self): ...
def __add__(self, other): ...
def __iadd__(self, other): ...
def __sub__(self, other): ...
def __isub__(self, other): ...
def __getitem__(self, index): ...
def parsedate_tz(data): ...
def parsedate(data): ...
def mktime_tz(data): ...
mypy-0.470/typeshed/stdlib/2/__future__.pyi 0000644 0000000 0000000 00000000650 13023631176 017323 0 ustar root root from sys import _version_info
class _Feature:
def getOptionalRelease(self) -> _version_info: ...
def getMandatoryRelease(self) -> _version_info: ...
absolute_import = ... # type: _Feature
division = ... # type: _Feature
generators = ... # type: _Feature
nested_scopes = ... # type: _Feature
print_function = ... # type: _Feature
unicode_literals = ... # type: _Feature
with_statement = ... # type: _Feature
mypy-0.470/typeshed/stdlib/2/typing.pyi 0000644 0000000 0000000 00000027541 13044257024 016536 0 ustar root root # Stubs for typing (Python 2.7)
from abc import abstractmethod, ABCMeta
# Definitions of special type checking related constructs. Their definition
# are not used, so their value does not matter.
overload = object()
Any = object()
TypeVar = object()
Generic = object()
Tuple = object()
Callable = object()
Type = object()
_promote = object()
class GenericMeta(type): ...
# Type aliases
class TypeAlias:
# Class for defining generic aliases for library types.
def __init__(self, target_type: type) -> None: ...
def __getitem__(self, typeargs: Any) -> Any: ...
Union = TypeAlias(object)
Optional = TypeAlias(object)
List = TypeAlias(object)
Dict = TypeAlias(object)
DefaultDict = TypeAlias(object)
Set = TypeAlias(object)
# Predefined type variables.
AnyStr = TypeVar('AnyStr', str, unicode)
# Abstract base classes.
# These type variables are used by the container types.
_T = TypeVar('_T')
_S = TypeVar('_S')
_KT = TypeVar('_KT') # Key type.
_VT = TypeVar('_VT') # Value type.
_T_co = TypeVar('_T_co', covariant=True) # Any type covariant containers.
_V_co = TypeVar('_V_co', covariant=True) # Any type covariant containers.
_KT_co = TypeVar('_KT_co', covariant=True) # Key type covariant containers.
_VT_co = TypeVar('_VT_co', covariant=True) # Value type covariant containers.
_T_contra = TypeVar('_T_contra', contravariant=True) # Ditto contravariant.
class SupportsInt(metaclass=ABCMeta):
@abstractmethod
def __int__(self) -> int: ...
class SupportsFloat(metaclass=ABCMeta):
@abstractmethod
def __float__(self) -> float: ...
class SupportsAbs(Generic[_T]):
@abstractmethod
def __abs__(self) -> _T: ...
class SupportsRound(Generic[_T]):
@abstractmethod
def __round__(self, ndigits: int = ...) -> _T: ...
class Reversible(Generic[_T_co]):
@abstractmethod
def __reversed__(self) -> Iterator[_T_co]: ...
class Sized(metaclass=ABCMeta):
@abstractmethod
def __len__(self) -> int: ...
class Iterable(Generic[_T_co]):
@abstractmethod
def __iter__(self) -> Iterator[_T_co]: ...
class Iterator(Iterable[_T_co], Generic[_T_co]):
@abstractmethod
def next(self) -> _T_co: ...
class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]):
@abstractmethod
def next(self) -> _T_co: ...
@abstractmethod
def send(self, value: _T_contra) -> _T_co: ...
@abstractmethod
def throw(self, typ: BaseException, val: Any = None, tb: Any = None) -> None: ...
@abstractmethod
def close(self) -> None: ...
class Container(Generic[_T_co]):
@abstractmethod
def __contains__(self, x: object) -> bool: ...
class Sequence(Iterable[_T_co], Container[_T_co], Sized, Reversible[_T_co], Generic[_T_co]):
@overload
@abstractmethod
def __getitem__(self, i: int) -> _T_co: ...
@overload
@abstractmethod
def __getitem__(self, s: slice) -> Sequence[_T_co]: ...
# Mixin methods
def index(self, x: Any) -> int: ...
def count(self, x: Any) -> int: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __reversed__(self) -> Iterator[_T_co]: ...
class MutableSequence(Sequence[_T], Generic[_T]):
@abstractmethod
def insert(self, index: int, object: _T) -> None: ...
@overload
@abstractmethod
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
@abstractmethod
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
@abstractmethod
def __delitem__(self, i: Union[int, slice]) -> None: ...
# Mixin methods
def append(self, object: _T) -> None: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def reverse(self) -> None: ...
def pop(self, index: int = ...) -> _T: ...
def remove(self, object: _T) -> None: ...
def __iadd__(self, x: Iterable[_T]) -> MutableSequence[_T]: ...
class AbstractSet(Sized, Iterable[_T_co], Container[_T_co], Generic[_T_co]):
@abstractmethod
def __contains__(self, x: object) -> bool: ...
# Mixin methods
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __and__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
def __or__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ...
def __sub__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ...
# TODO: argument can be any container?
def isdisjoint(self, s: AbstractSet[Any]) -> bool: ...
class FrozenSet(AbstractSet[_T_co], Generic[_T_co]): ...
class MutableSet(AbstractSet[_T], Generic[_T]):
@abstractmethod
def add(self, x: _T) -> None: ...
@abstractmethod
def discard(self, x: _T) -> None: ...
# Mixin methods
def clear(self) -> None: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def __ior__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ...
def __iand__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ...
def __ixor__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ...
def __isub__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ...
class MappingView(Sized):
def __len__(self) -> int: ...
class ItemsView(AbstractSet[Tuple[_KT_co, _VT_co]], MappingView, Generic[_KT_co, _VT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ...
class KeysView(AbstractSet[_KT_co], MappingView, Generic[_KT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT_co]: ...
class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_VT_co]: ...
class Mapping(Sized, Iterable[_KT], Container[_KT], Generic[_KT, _VT_co]):
# TODO: We wish the key type could also be covariant, but that doesn't work,
# see discussion in https: //github.com/python/typing/pull/273.
@abstractmethod
def __getitem__(self, k: _KT) -> _VT_co:
...
# Mixin methods
def get(self, k: _KT, default: _VT_co = ...) -> _VT_co: # type: ignore
...
def keys(self) -> list[_KT]: ...
def values(self) -> list[_VT_co]: ...
def items(self) -> list[Tuple[_KT, _VT_co]]: ...
def iterkeys(self) -> Iterator[_KT]: ...
def itervalues(self) -> Iterator[_VT_co]: ...
def iteritems(self) -> Iterator[Tuple[_KT, _VT_co]]: ...
def __contains__(self, o: object) -> bool: ...
class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
@abstractmethod
def __setitem__(self, k: _KT, v: _VT) -> None: ...
@abstractmethod
def __delitem__(self, v: _KT) -> None: ...
def clear(self) -> None: ...
def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
Text = unicode
TYPE_CHECKING = True
class IO(Iterator[AnyStr], Generic[AnyStr]):
# TODO detach
# TODO use abstract properties
@property
def mode(self) -> str: ...
@property
def name(self) -> str: ...
@abstractmethod
def close(self) -> None: ...
@property
def closed(self) -> bool: ...
@abstractmethod
def fileno(self) -> int: ...
@abstractmethod
def flush(self) -> None: ...
@abstractmethod
def isatty(self) -> bool: ...
# TODO what if n is None?
@abstractmethod
def read(self, n: int = ...) -> AnyStr: ...
@abstractmethod
def readable(self) -> bool: ...
@abstractmethod
def readline(self, limit: int = ...) -> AnyStr: ...
@abstractmethod
def readlines(self, hint: int = ...) -> list[AnyStr]: ...
@abstractmethod
def seek(self, offset: int, whence: int = ...) -> None: ...
@abstractmethod
def seekable(self) -> bool: ...
@abstractmethod
def tell(self) -> int: ...
@abstractmethod
def truncate(self, size: int = ...) -> Optional[int]: ...
@abstractmethod
def writable(self) -> bool: ...
# TODO buffer objects
@abstractmethod
def write(self, s: AnyStr) -> None: ...
@abstractmethod
def writelines(self, lines: Iterable[AnyStr]) -> None: ...
@abstractmethod
def next(self) -> AnyStr: ...
@abstractmethod
def __iter__(self) -> Iterator[AnyStr]: ...
@abstractmethod
def __enter__(self) -> 'IO[AnyStr]': ...
@abstractmethod
def __exit__(self, t: Optional[Type[BaseException]], value: Optional[BaseException],
# TODO: traceback should be TracebackType but that's defined in types
traceback: Optional[Any]) -> bool: ...
class BinaryIO(IO[str]):
# TODO readinto
# TODO read1?
# TODO peek?
@abstractmethod
def __enter__(self) -> BinaryIO: ...
class TextIO(IO[unicode]):
# TODO use abstractproperty
@property
def buffer(self) -> BinaryIO: ...
@property
def encoding(self) -> str: ...
@property
def errors(self) -> Optional[str]: ...
@property
def line_buffering(self) -> bool: ...
@property
def newlines(self) -> Any: ... # None, str or tuple
@abstractmethod
def __enter__(self) -> TextIO: ...
class Match(Generic[AnyStr]):
pos = 0
endpos = 0
lastindex = 0
lastgroup = ... # type: AnyStr
string = ... # type: AnyStr
# The regular expression object whose match() or search() method produced
# this match instance.
re = ... # type: 'Pattern[AnyStr]'
def expand(self, template: AnyStr) -> AnyStr: ...
@overload
def group(self, group1: int = ...) -> AnyStr: ...
@overload
def group(self, group1: str) -> AnyStr: ...
@overload
def group(self, group1: int, group2: int,
*groups: int) -> Sequence[AnyStr]: ...
@overload
def group(self, group1: str, group2: str,
*groups: str) -> Sequence[AnyStr]: ...
def groups(self, default: AnyStr = ...) -> Sequence[AnyStr]: ...
def groupdict(self, default: AnyStr = ...) -> dict[str, AnyStr]: ...
def start(self, group: Union[int, str] = ...) -> int: ...
def end(self, group: Union[int, str] = ...) -> int: ...
def span(self, group: Union[int, str] = ...) -> Tuple[int, int]: ...
class Pattern(Generic[AnyStr]):
flags = 0
groupindex = 0
groups = 0
pattern = ... # type: AnyStr
def search(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Match[AnyStr]: ...
def match(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Match[AnyStr]: ...
def split(self, string: AnyStr, maxsplit: int = ...) -> list[AnyStr]: ...
def findall(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> list[Any]: ...
def finditer(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def sub(self, repl: AnyStr, string: AnyStr,
count: int = ...) -> AnyStr: ...
@overload
def sub(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr,
count: int = ...) -> AnyStr: ...
@overload
def subn(self, repl: AnyStr, string: AnyStr,
count: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr,
count: int = ...) -> Tuple[AnyStr, int]: ...
# Functions
def get_type_hints(obj: Callable) -> dict[str, Any]: ...
def cast(tp: Type[_T], obj: Any) -> _T: ...
# Type constructors
# NamedTuple is special-cased in the type checker; the initializer is ignored.
def NamedTuple(typename: str, fields: Iterable[Tuple[str, Any]], *,
verbose: bool = ..., rename: bool = ...) -> Type[tuple]: ...
def NewType(name: str, tp: Type[_T]) -> Type[_T]: ...
mypy-0.470/typeshed/stdlib/2/_sha.pyi 0000644 0000000 0000000 00000000700 13023631176 016123 0 ustar root root blocksize = ... # type: int
block_size = ... # type: int
digest_size = ... # type: int
class sha(object): # not actually exposed
name = ... # type: str
block_size = ... # type: int
digest_size = ... # type: int
digestsize = ... # type: int
def copy(self) -> "sha": ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def update(self, arg: str) -> None: ...
def new(arg: str = ...) -> sha: ...
mypy-0.470/typeshed/stdlib/2/cStringIO.pyi 0000644 0000000 0000000 00000003464 13023631176 017064 0 ustar root root # Stubs for cStringIO (Python 2.7)
# See https://docs.python.org/2/library/stringio.html
from typing import overload, IO, List, Iterable, Iterator, Optional, Union
from types import TracebackType
# TODO the typing.IO[] generics should be split into input and output.
class InputType(IO[str], Iterator[str]):
def getvalue(self) -> str: ...
def close(self) -> None: ...
@property
def closed(self) -> bool: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, size: int = ...) -> str: ...
def readline(self, size: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> Optional[int]: ...
def __iter__(self) -> 'InputType': ...
def next(self) -> str: ...
def reset(self) -> None: ...
class OutputType(IO[str], Iterator[str]):
@property
def softspace(self) -> int: ...
def getvalue(self) -> str: ...
def close(self) -> None: ...
@property
def closed(self) -> bool: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, size: int = ...) -> str: ...
def readline(self, size: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def tell(self) -> int: ...
def truncate(self, size: int = ...) -> Optional[int]: ...
def __iter__(self) -> 'OutputType': ...
def next(self) -> str: ...
def reset(self) -> None: ...
def write(self, b: Union[str, unicode]) -> None: ...
def writelines(self, lines: Iterable[Union[str, unicode]]) -> None: ...
@overload
def StringIO() -> OutputType: ...
@overload
def StringIO(s: str) -> InputType: ...
mypy-0.470/typeshed/stdlib/2/cPickle.pyi 0000644 0000000 0000000 00000001513 13023631176 016566 0 ustar root root from typing import Any, IO, List
HIGHEST_PROTOCOL = ... # type: int
compatible_formats = ... # type: List[str]
format_version = ... # type: str
class Pickler:
def __init__(self, file: IO[str], protocol: int = ...) -> None: ...
def dump(self, obj: Any) -> None: ...
def clear_memo(self) -> None: ...
class Unpickler:
def __init__(self, file: IO[str]) -> None: ...
def load(self) -> Any: ...
def noload(self) -> Any: ...
def dump(obj: Any, file: IO[str], protocol: int = ...) -> None: ...
def dumps(obj: Any, protocol: int = ...) -> str: ...
def load(file: IO[str]) -> Any: ...
def loads(str: str) -> Any: ...
class PickleError(Exception): ...
class UnpicklingError(PickleError): ...
class BadPickleGet(UnpicklingError): ...
class PicklingError(PickleError): ...
class UnpickleableError(PicklingError): ...
mypy-0.470/typeshed/stdlib/2/wsgiref/ 0000755 0000000 0000000 00000000000 13044320557 016140 5 ustar root root mypy-0.470/typeshed/stdlib/2/wsgiref/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020407 0 ustar root root mypy-0.470/typeshed/stdlib/2/wsgiref/validate.pyi 0000644 0000000 0000000 00000002340 13035744274 020461 0 ustar root root # Stubs for wsgiref.validate (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class WSGIWarning(Warning): ...
def validator(application): ...
class InputWrapper:
input = ... # type: Any
def __init__(self, wsgi_input): ...
def read(self, *args): ...
def readline(self): ...
def readlines(self, *args): ...
def __iter__(self): ...
def close(self): ...
class ErrorWrapper:
errors = ... # type: Any
def __init__(self, wsgi_errors): ...
def write(self, s): ...
def flush(self): ...
def writelines(self, seq): ...
def close(self): ...
class WriteWrapper:
writer = ... # type: Any
def __init__(self, wsgi_writer): ...
def __call__(self, s): ...
class PartialIteratorWrapper:
iterator = ... # type: Any
def __init__(self, wsgi_iterator): ...
def __iter__(self): ...
class IteratorWrapper:
original_iterator = ... # type: Any
iterator = ... # type: Any
closed = ... # type: Any
check_start_response = ... # type: Any
def __init__(self, wsgi_iterator, check_start_response): ...
def __iter__(self): ...
def next(self): ...
def close(self): ...
def __del__(self): ...
mypy-0.470/typeshed/stdlib/2/fileinput.pyi 0000644 0000000 0000000 00000002637 13035744274 017232 0 ustar root root from typing import Iterable, Callable, IO, Optional, Union, Iterator
class FileInput(Iterable[str]):
def __init__(
self,
files: Optional[Union[str, Iterable[str]]] = None,
inplace: bool = ...,
backup: str = ...,
bufsize: int = ...,
mode: str = ...,
openhook: Callable[[str, str], IO[str]] = ...
) -> None: ...
def __del__(self) -> None: ...
def close(self) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def __getitem__(self, i: Union[int, slice]) -> str: ...
def next(self) -> str: ...
def nextfile(self) -> None: ...
def readline(self) -> str: ...
def filename(self) -> Optional[str]: ...
def lineno(self) -> int: ...
def filelineno(self) -> int: ...
def fileno(self) -> int: ...
def isfirstline(self) -> bool: ...
def isstdin(self) -> bool: ...
def input(
files: Optional[Union[str, Iterable[str]]] = None,
inplace: bool = ...,
backup: str = ...,
bufsize: int = ...,
mode: str = ...,
openhook: Callable[[str, str], IO[str]] = ...) -> FileInput: ...
def filename() -> Optional[str]: ...
def lineno() -> int: ...
def filelineno() -> int: ...
def isfirstline() -> bool: ...
def isstdin() -> bool: ...
def nextfile() -> None: ...
def close() -> None: ...
def hook_compressed(filename: str, mode: str) -> IO[str]: ...
def hook_encoded(encoding: str) -> Callable[[str, str], IO[str]]: ...
mypy-0.470/typeshed/stdlib/2/smtplib.pyi 0000644 0000000 0000000 00000005726 13035744274 016707 0 ustar root root # Stubs for smtplib (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class SMTPException(Exception): ...
class SMTPServerDisconnected(SMTPException): ...
class SMTPResponseException(SMTPException):
smtp_code = ... # type: Any
smtp_error = ... # type: Any
args = ... # type: Any
def __init__(self, code, msg) -> None: ...
class SMTPSenderRefused(SMTPResponseException):
smtp_code = ... # type: Any
smtp_error = ... # type: Any
sender = ... # type: Any
args = ... # type: Any
def __init__(self, code, msg, sender) -> None: ...
class SMTPRecipientsRefused(SMTPException):
recipients = ... # type: Any
args = ... # type: Any
def __init__(self, recipients) -> None: ...
class SMTPDataError(SMTPResponseException): ...
class SMTPConnectError(SMTPResponseException): ...
class SMTPHeloError(SMTPResponseException): ...
class SMTPAuthenticationError(SMTPResponseException): ...
def quoteaddr(addr): ...
def quotedata(data): ...
class SSLFakeFile:
sslobj = ... # type: Any
def __init__(self, sslobj) -> None: ...
def readline(self, size=...): ...
def close(self): ...
class SMTP:
debuglevel = ... # type: Any
file = ... # type: Any
helo_resp = ... # type: Any
ehlo_msg = ... # type: Any
ehlo_resp = ... # type: Any
does_esmtp = ... # type: Any
default_port = ... # type: Any
timeout = ... # type: Any
esmtp_features = ... # type: Any
local_hostname = ... # type: Any
def __init__(self, host: str = ..., port: int = ..., local_hostname=..., timeout=...) -> None: ...
def set_debuglevel(self, debuglevel): ...
sock = ... # type: Any
def connect(self, host=..., port=...): ...
def send(self, str): ...
def putcmd(self, cmd, args=...): ...
def getreply(self): ...
def docmd(self, cmd, args=...): ...
def helo(self, name=...): ...
def ehlo(self, name=...): ...
def has_extn(self, opt): ...
def help(self, args=...): ...
def rset(self): ...
def noop(self): ...
def mail(self, sender, options=...): ...
def rcpt(self, recip, options=...): ...
def data(self, msg): ...
def verify(self, address): ...
vrfy = ... # type: Any
def expn(self, address): ...
def ehlo_or_helo_if_needed(self): ...
def login(self, user, password): ...
def starttls(self, keyfile=..., certfile=...): ...
def sendmail(self, from_addr, to_addrs, msg, mail_options=..., rcpt_options=...): ...
def close(self): ...
def quit(self): ...
class SMTP_SSL(SMTP):
default_port = ... # type: Any
keyfile = ... # type: Any
certfile = ... # type: Any
def __init__(self, host=..., port=..., local_hostname=..., keyfile=..., certfile=..., timeout=...) -> None: ...
class LMTP(SMTP):
ehlo_msg = ... # type: Any
def __init__(self, host=..., port=..., local_hostname=...) -> None: ...
sock = ... # type: Any
def connect(self, host=..., port=...): ...
mypy-0.470/typeshed/stdlib/2/shelve.pyi 0000644 0000000 0000000 00000003064 13023631176 016505 0 ustar root root from typing import Any, Dict, Iterator, List, Optional, Tuple
import collections
class Shelf(collections.MutableMapping):
def __init__(self, dict: Dict[Any, Any], protocol: Optional[int] = None, writeback: bool = ..., keyencoding: str = 'utf-8') -> None: ...
def __iter__(self) -> Iterator[str]: ...
def keys(self) -> List[Any]: ...
def __len__(self) -> int: ...
def has_key(self, key: Any) -> bool: ...
def __contains__(self, key: Any) -> bool: ...
def get(self, key: Any, default: Any = None) -> Any: ...
def __getitem__(self, key: Any) -> Any: ...
def __setitem__(self, key: Any, value: Any) -> None: ...
def __delitem__(self, key: Any) -> None: ...
def __enter__(self) -> Shelf: ...
def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ...
def close(self) -> None: ...
def __del__(self) -> None: ...
def sync(self) -> None: ...
class BsdDbShelf(Shelf):
def __init__(self, dict: Dict[Any, Any], protocol: Optional[int] = None, writeback: bool = ..., keyencoding: str = 'utf-8') -> None: ...
def set_location(self, key: Any) -> Tuple[str, Any]: ...
def next(self) -> Tuple[str, Any]: ...
def previous(self) -> Tuple[str, Any]: ...
def first(self) -> Tuple[str, Any]: ...
def last(self) -> Tuple[str, Any]: ...
class DbfilenameShelf(Shelf):
def __init__(self, filename: str, flag: str = 'c', protocol: Optional[int] = None, writeback: bool = ...) -> None: ...
def open(filename: str, flag: str = 'c', protocol: Optional[int] = None, writeback: bool = ...) -> DbfilenameShelf: ...
mypy-0.470/typeshed/stdlib/2/multiprocessing/ 0000755 0000000 0000000 00000000000 13044320557 017721 5 ustar root root mypy-0.470/typeshed/stdlib/2/multiprocessing/__init__.pyi 0000644 0000000 0000000 00000002231 13035744274 022207 0 ustar root root # Stubs for multiprocessing (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from multiprocessing.process import Process as Process, current_process as current_process, active_children as active_children
from multiprocessing.util import SUBDEBUG as SUBDEBUG, SUBWARNING as SUBWARNING
class ProcessError(Exception): ...
class BufferTooShort(ProcessError): ...
class TimeoutError(ProcessError): ...
class AuthenticationError(ProcessError): ...
def Manager(): ...
def Pipe(duplex=True): ...
def cpu_count() -> int: ...
def freeze_support(): ...
def get_logger(): ...
def log_to_stderr(level=None): ...
def allow_connection_pickling(): ...
def Lock(): ...
def RLock(): ...
def Condition(lock=None): ...
def Semaphore(value=1): ...
def BoundedSemaphore(value=1): ...
def Event(): ...
def Queue(maxsize=0): ...
def JoinableQueue(maxsize=0): ...
def Pool(processes=None, initializer=None, initargs=..., maxtasksperchild=None): ...
def RawValue(typecode_or_type, *args): ...
def RawArray(typecode_or_type, size_or_initializer): ...
def Value(typecode_or_type, *args, **kwds): ...
def Array(typecode_or_type, size_or_initializer, **kwds): ...
mypy-0.470/typeshed/stdlib/2/multiprocessing/util.pyi 0000644 0000000 0000000 00000001503 13035744274 021426 0 ustar root root # Stubs for multiprocessing.util (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import threading
SUBDEBUG = ... # type: Any
SUBWARNING = ... # type: Any
def sub_debug(msg, *args): ...
def debug(msg, *args): ...
def info(msg, *args): ...
def sub_warning(msg, *args): ...
def get_logger(): ...
def log_to_stderr(level=None): ...
def get_temp_dir(): ...
def register_after_fork(obj, func): ...
class Finalize:
def __init__(self, obj, callback, args=..., kwargs=None, exitpriority=None): ...
def __call__(self, wr=None): ...
def cancel(self): ...
def still_active(self): ...
def is_exiting(): ...
class ForkAwareThreadLock:
def __init__(self): ...
class ForkAwareLocal(threading.local):
def __init__(self): ...
def __reduce__(self): ...
mypy-0.470/typeshed/stdlib/2/multiprocessing/process.pyi 0000644 0000000 0000000 00000001676 13035744274 022142 0 ustar root root # Stubs for multiprocessing.process (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def current_process(): ...
def active_children(): ...
class Process:
def __init__(self, group=None, target=None, name=None, args=..., kwargs=...): ...
def run(self): ...
def start(self): ...
def terminate(self): ...
def join(self, timeout=None): ...
def is_alive(self): ...
@property
def name(self): ...
@name.setter
def name(self, name): ...
@property
def daemon(self): ...
@daemon.setter
def daemon(self, daemonic): ...
@property
def authkey(self): ...
@authkey.setter
def authkey(self, authkey): ...
@property
def exitcode(self): ...
@property
def ident(self): ...
pid = ... # type: Any
class AuthenticationString(bytes):
def __reduce__(self): ...
class _MainProcess(Process):
def __init__(self): ...
mypy-0.470/typeshed/stdlib/2/UserList.pyi 0000644 0000000 0000000 00000000105 13023631176 016762 0 ustar root root import collections
class UserList(collections.MutableSequence): ...
mypy-0.470/typeshed/stdlib/2/_json.pyi 0000644 0000000 0000000 00000000762 13023631176 016331 0 ustar root root """Stub file for the '_json' module."""
# This is an autogenerated file. It serves as a starting point
# for a more precise manual annotation of this module.
# Feel free to edit the source below, but remove this header when you do.
from typing import Any, List, Tuple, Dict, Generic
def encode_basestring_ascii(*args, **kwargs) -> str:
raise TypeError()
def scanstring(a, b, *args, **kwargs) -> tuple:
raise TypeError()
class Encoder(object):
pass
class Scanner(object):
pass
mypy-0.470/typeshed/stdlib/2/robotparser.pyi 0000644 0000000 0000000 00000000346 13023631176 017561 0 ustar root root class RobotFileParser:
def set_url(self, url: str): ...
def read(self): ...
def parse(self, lines: str): ...
def can_fetch(self, user_agent: str, url: str): ...
def mtime(self): ...
def modified(self): ...
mypy-0.470/typeshed/stdlib/2/_random.pyi 0000644 0000000 0000000 00000000651 13023631176 016635 0 ustar root root from typing import Tuple
# Actually Tuple[(int,) * 625]
_State = Tuple[int, ...]
class Random(object):
def __init__(self, seed: object = ...) -> None: ...
def seed(self, x: object = ...) -> None: ...
def getstate(self) -> _State: ...
def setstate(self, state: _State) -> None: ...
def random(self) -> float: ...
def getrandbits(self, k: int) -> int: ...
def jumpahead(self, i: int) -> None: ...
mypy-0.470/typeshed/stdlib/2/_hotshot.pyi 0000644 0000000 0000000 00000001736 13023631176 017052 0 ustar root root """Stub file for the '_hotshot' module."""
# This is an autogenerated file. It serves as a starting point
# for a more precise manual annotation of this module.
# Feel free to edit the source below, but remove this header when you do.
from typing import Any, List, Tuple, Dict, Generic
def coverage(a: str) -> Any: ...
def logreader(a: str) -> LogReaderType:
raise IOError()
raise RuntimeError()
def profiler(a: str, *args, **kwargs) -> Any:
raise IOError()
def resolution() -> tuple: ...
class LogReaderType(object):
def close(self) -> None: ...
def fileno(self) -> int:
raise ValueError()
class ProfilerType(object):
def addinfo(self, a: str, b: str) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int:
raise ValueError()
def runcall(self, *args, **kwargs) -> Any: ...
def runcode(self, a, b, *args, **kwargs) -> Any:
raise TypeError()
def start(self) -> None: ...
def stop(self) -> None: ...
mypy-0.470/typeshed/stdlib/2/pipes.pyi 0000644 0000000 0000000 00000000705 13023631176 016336 0 ustar root root from typing import Any, IO
class Template:
def __init__(self) -> None: ...
def reset(self) -> None: ...
def clone(self) -> Template: ...
def debug(self, flag: bool) -> None: ...
def append(self, cmd: str, kind: str) -> None: ...
def prepend(self, cmd: str, kind: str) -> None: ...
def open(self, file: str, mode: str) -> IO[Any]: ...
def copy(self, infile: str, outfile: str) -> None: ...
def quote(s: str) -> str: ...
mypy-0.470/typeshed/stdlib/2/itertools.pyi 0000644 0000000 0000000 00000006515 13035744274 017256 0 ustar root root # Stubs for itertools
# Based on https://docs.python.org/2/library/itertools.html
from typing import (Iterator, TypeVar, Iterable, overload, Any, Callable, Tuple,
Union, Sequence, Generic, Optional)
_T = TypeVar('_T')
_S = TypeVar('_S')
def count(start: int = ...,
step: int = ...) -> Iterator[int]: ... # more general types?
def cycle(iterable: Iterable[_T]) -> Iterator[_T]: ...
def repeat(object: _T, times: int = ...) -> Iterator[_T]: ...
def accumulate(iterable: Iterable[_T]) -> Iterator[_T]: ...
class chain(Iterator[_T], Generic[_T]):
def __init__(self, *iterables: Iterable[_T]) -> None: ...
def next(self) -> _T: ...
def __iter__(self) -> Iterator[_T]: ...
@staticmethod
def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ...
def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ...
def dropwhile(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
def ifilter(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
def ifilterfalse(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def groupby(iterable: Iterable[_T]) -> Iterator[Tuple[_T, Iterator[_T]]]: ...
@overload
def groupby(iterable: Iterable[_T],
key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ...
@overload
def islice(iterable: Iterable[_T], stop: int) -> Iterator[_T]: ...
@overload
def islice(iterable: Iterable[_T], start: int, stop: Optional[int],
step: int = ...) -> Iterator[_T]: ...
_T1 = TypeVar('_T1')
_T2 = TypeVar('_T2')
_T3 = TypeVar('_T3')
_T4 = TypeVar('_T4')
@overload
def imap(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> Iterable[_S]: ...
@overload
def imap(func: Callable[[_T1, _T2], _S],
iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> Iterable[_S]: ... # TODO more than two iterables
def starmap(func: Any, iterable: Iterable[Any]) -> Iterator[Any]: ...
def takewhile(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
def tee(iterable: Iterable[Any], n: int = ...) -> Iterator[Any]: ...
@overload
def izip(iter1: Iterable[_T1]) -> Iterable[Tuple[_T1]]: ...
@overload
def izip(iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> Iterable[Tuple[_T1, _T2]]: ...
@overload
def izip(iter1: Iterable[_T1], iter2: Iterable[_T2],
iter3: Iterable[_T3]) -> Iterable[Tuple[_T1, _T2, _T3]]: ...
@overload
def izip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
iter4: Iterable[_T4]) -> Iterable[Tuple[_T1, _T2,
_T3, _T4]]: ... # TODO more than four iterables
def izip_longest(*p: Iterable[Any],
fillvalue: Any = ...) -> Iterator[Any]: ...
# TODO: Return type should be Iterator[Tuple[..]], but unknown tuple shape.
# Iterator[Sequence[_T]] loses this type information.
def product(*p: Iterable[_T], repeat: int = ...) -> Iterator[Sequence[_T]]: ...
def permutations(iterable: Iterable[_T],
r: int = ...) -> Iterator[Sequence[_T]]: ...
def combinations(iterable: Iterable[_T],
r: int) -> Iterable[Sequence[_T]]: ...
def combinations_with_replacement(iterable: Iterable[_T],
r: int) -> Iterable[Sequence[_T]]: ...
mypy-0.470/typeshed/stdlib/2/collections.pyi 0000644 0000000 0000000 00000010024 13044257024 017526 0 ustar root root # Stubs for collections
# Based on http://docs.python.org/2.7/library/collections.html
# TODO more abstract base classes (interfaces in mypy)
# NOTE: These are incomplete!
from typing import (
Any, Container, Dict, Generic, TypeVar, Iterable, Tuple, Callable, Mapping, overload,
Iterator, Type, Sized, Optional, List, Set, Sequence, Union, Reversible,
MutableMapping, MutableSet, MutableSequence,
)
import typing
_T = TypeVar('_T')
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
# namedtuple is special-cased in the type checker; the initializer is ignored.
def namedtuple(typename: str, field_names: Union[str, Iterable[Any]], *,
verbose: bool = ..., rename: bool = ...) -> Type[tuple]: ...
class deque(Sized, Iterable[_T], Reversible[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...,
maxlen: int = ...) -> None: ...
@property
def maxlen(self) -> Optional[int]: ...
def append(self, x: _T) -> None: ...
def appendleft(self, x: _T) -> None: ...
def clear(self) -> None: ...
def count(self, x: _T) -> int: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def extendleft(self, iterable: Iterable[_T]) -> None: ...
def pop(self) -> _T: ...
def popleft(self) -> _T: ...
def remove(self, value: _T) -> None: ...
def reverse(self) -> None: ...
def rotate(self, n: int) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
def __getitem__(self, i: int) -> _T: ...
def __setitem__(self, i: int, x: _T) -> None: ...
def __contains__(self, o: _T) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
class Counter(Dict[_T, int], Generic[_T]):
# TODO: __init__ keyword arguments
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, Mapping: Mapping[_T, int]) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def elements(self) -> Iterator[_T]: ...
def most_common(self, n: int = ...) -> List[_T]: ...
@overload
def subtract(self, mapping: Mapping[_T, int]) -> None: ...
@overload
def subtract(self, iterable: Iterable[_T]) -> None: ...
# The Iterable[Tuple[...]] argument type is not actually desirable
# (the tuples will be added as keys, breaking type safety) but
# it's included so that the signature is compatible with
# Dict.update. Not sure if we should use '# type: ignore' instead
# and omit the type from the union.
@overload
def update(self, m: Mapping[_T, int], **kwargs: _VT) -> None: ...
@overload
def update(self, m: Union[Iterable[_T], Iterable[Tuple[_T, int]]], **kwargs: _VT) -> None: ...
class OrderedDict(Dict[_KT, _VT], Generic[_KT, _VT]):
def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ...
def move_to_end(self, key: _KT, last: bool = ...) -> None: ...
class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
default_factory = ... # type: Callable[[], _VT]
# TODO: __init__ keyword args
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT],
map: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT],
iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
def __missing__(self, key: _KT) -> _VT: ...
class ChainMap(Dict[_KT, _VT], Generic[_KT, _VT]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, *maps: Mapping[_KT, _VT]) -> None: ...
@property
def maps(self) -> List[Mapping[_KT, _VT]]: ...
def new_child(self, m: Mapping[_KT, _VT] = ...) -> ChainMap[_KT, _VT]: ...
@property
def parents(self) -> ChainMap[_KT, _VT]: ...
mypy-0.470/typeshed/stdlib/2/xml/ 0000755 0000000 0000000 00000000000 13044320557 015272 5 ustar root root mypy-0.470/typeshed/stdlib/2/xml/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 017540 0 ustar root root mypy-0.470/typeshed/stdlib/2/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016376 5 ustar root root mypy-0.470/typeshed/stdlib/2/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 020644 0 ustar root root mypy-0.470/typeshed/stdlib/2/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000014076 13044257024 021340 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, Generator
import io
VERSION = ... # type: str
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class _SimpleElementPath:
def find(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> Optional['Element']: ...
def findtext(self, element: 'Element', tag: _str_or_bytes, default: _T=..., namespaces: Any=...) -> Union[str, bytes, _T]: ...
def iterfind(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> Generator['Element', None, None]: ...
def findall(self, element: 'Element', tag: _str_or_bytes, namespaces: Any=...) -> List['Element']: ...
class ParseError(SyntaxError): ...
def iselement(element: 'Element') -> bool: ...
class Element(Sequence['Element']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., 'Element']], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> None: ...
def append(self, element: 'Element') -> None: ...
def clear(self) -> None: ...
def copy(self) -> 'Element': ...
def extend(self, elements: Sequence['Element']) -> None: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional['Element']: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def getchildren(self) -> List['Element']: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['Element']: ...
def insert(self, index: int, element: 'Element') -> None: ...
def items(self) -> List[Tuple[AnyStr, AnyStr]]: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator['Element', None, None]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List['Element']: ...
def itertext(self) -> Generator[str, None, None]: ...
def keys(self) -> List[AnyStr]: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> 'Element': ...
def remove(self, element: 'Element') -> None: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def __bool__(self) -> bool: ...
def __delitem__(self, index: int) -> None: ...
def __getitem__(self, index) -> 'Element': ...
def __len__(self) -> int: ...
def __setitem__(self, index: int, element: 'Element') -> None: ...
def SubElement(parent: Element, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> Element: ...
def Comment(text: _str_or_bytes=...) -> Element: ...
def ProcessingInstruction(target: str, text: str=...) -> Element: ...
PI = ... # type: Callable[..., Element]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: Element=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: 'XMLParser'=...) -> Element: ...
def iter(self, tag: Union[str, AnyStr]=...) -> Generator[Element, None, None]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[Element]: ...
def find(self, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findtext(self, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
def findall(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def iterfind(self, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=..., xml_declaration: Optional[bool]=..., default_namespace: str=..., method: str=...) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: str, uri: str) -> None: ...
def tostring(element: Element, encoding: str=..., method: str=...) -> str: ...
def tostringlist(element: Element, encoding: str=..., method: str=...) -> List[str]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: 'XMLParser'=...) -> ElementTree: ...
def iterparse(source: _file_or_filename, events: Sequence[str]=..., parser: 'XMLParser'=...) -> Iterator[Tuple[str, Element]]: ...
class _IterParseIterator:
root = ... # type: Any
def __init__(self, source: _file_or_filename, events: Sequence[str], parser: 'XMLParser', close_source: bool=...) -> None: ...
def next(self) -> Tuple[str, Element]: ...
def __iter__(self) -> _IterParseIterator: ...
def XML(text: AnyStr, parser: 'XMLParser'=...) -> Element: ...
def XMLID(text: AnyStr, parser: 'XMLParser'=...) -> Tuple[Element, Dict[str, Element]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., Element]
def fromstringlist(sequence: Sequence[AnyStr], parser: 'XMLParser'=...) -> Element: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], Element]=...) -> None: ...
def close(self) -> Element: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> Element: ...
def end(self, tag: AnyStr) -> Element: ...
class XMLParser:
parser = ... # type: Any
target = ... # type: TreeBuilder
# TODO-what is entity used for???
entity = ... # type: Any
version = ... # type: str
def __init__(self, html: int=..., target: TreeBuilder=..., encoding: str=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/2/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000003200 13044257024 021320 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Pattern, Dict, Generator, Tuple, List, Union, TypeVar, Callable, Optional
from xml.etree.ElementTree import Element
xpath_tokenizer_re = ... # type: Pattern
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[['_SelectorContext', List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Dict[str, str]=...) -> Generator[_token, None, None]: ...
def get_parent_map(context: '_SelectorContext') -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops = ... # type: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map = ... # type: Dict[Element, Element]
root = ... # type: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar('_T')
def iterfind(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Dict[str, str]=...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Dict[str, str]=...) -> List[Element]: ...
def findtext(elem: Element, path: str, default: _T=..., namespaces: Dict[str, str]=...) -> Union[_T, str]: ...
mypy-0.470/typeshed/stdlib/2/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021472 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/2/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001403 13044257024 022012 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from xml.etree.ElementTree import Element
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: Element, loader: Callable[..., Union[str, Element]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/2/unicodedata.pyi 0000644 0000000 0000000 00000003553 13035744274 017511 0 ustar root root """Stubs for the 'unicodedata' module."""
from typing import Any, TypeVar, Union
ucd_3_2_0 = ... # type: UCD
unidata_version = ... # type: str
# PyCapsule
ucnhash_CAPI = ... # type: Any
_default = TypeVar("_default")
def bidirectional(unichr: unicode) -> str: ...
def category(unichr: unicode) -> str: ...
def combining(unichr: unicode) -> int: ...
def decimal(chr: unicode, default: _default = ...) -> Union[int, _default]: ...
def decomposition(unichr: unicode) -> str: ...
def digit(chr: unicode, default: _default = ...) -> Union[int, _default]: ...
def east_asian_width(unichr: unicode) -> str: ...
def lookup(name: str) -> unicode: ...
def mirrored(unichr: unicode) -> int: ...
def name(chr: unicode, default: _default = ...) -> Union[str, _default]: ...
def normalize(form: str, unistr: unicode) -> unicode: ...
def numeric(chr, default: _default = ...) -> Union[float, _default]: ...
class UCD(object):
unidata_version = ... # type: str
# The methods below are constructed from the same array in C
# (unicodedata_functions) and hence identical to the methods above.
def bidirectional(self, unichr: unicode) -> str: ...
def category(self, unichr: unicode) -> str: ...
def combining(self, unichr: unicode) -> int: ...
def decimal(self, chr: unicode, default: _default = ...) -> Union[int, _default]: ...
def decomposition(self, unichr: unicode) -> str: ...
def digit(self, chr: unicode, default: _default = ...) -> Union[int, _default]: ...
def east_asian_width(self, unichr: unicode) -> str: ...
def lookup(self, name: str) -> unicode: ...
def mirrored(self, unichr: unicode) -> int: ...
def name(self, chr: unicode, default: _default = ...) -> Union[str, _default]: ...
def normalize(self, form: str, unistr: unicode) -> unicode: ...
def numeric(self, chr: unicode, default: _default = ...) -> Union[float, _default]: ...
mypy-0.470/typeshed/stdlib/2/time.pyi 0000644 0000000 0000000 00000002724 13035744274 016166 0 ustar root root """Stub file for the 'time' module."""
# See https://docs.python.org/2/library/time.html
from typing import NamedTuple, Tuple, Union, Any, Optional
# ----- variables and constants -----
accept2dyear = False
altzone = 0
daylight = 0
timezone = 0
tzname = ... # type: Tuple[str, str]
class struct_time(NamedTuple('_struct_time',
[('tm_year', int), ('tm_mon', int), ('tm_mday', int),
('tm_hour', int), ('tm_min', int), ('tm_sec', int),
('tm_wday', int), ('tm_yday', int), ('tm_isdst', int)])):
def __init__(self, o: Tuple[int, int, int,
int, int, int,
int, int, int], _arg: Any = ...) -> None: ...
_TIME_TUPLE = Tuple[int, int, int, int, int, int, int, int, int]
def asctime(t: struct_time = ...) -> str:
raise ValueError()
def clock() -> float: ...
def ctime(secs: Optional[float] = ...) -> str:
raise ValueError()
def gmtime(secs: Optional[float] = ...) -> struct_time: ...
def localtime(secs: Optional[float] = ...) -> struct_time: ...
def mktime(t: struct_time) -> float:
raise OverflowError()
raise ValueError()
def sleep(secs: float) -> None: ...
def strftime(format: str, t: struct_time = ...) -> str:
raise MemoryError()
raise ValueError()
def strptime(string: str, format: str = ...) -> struct_time:
raise ValueError()
def time() -> float:
raise IOError()
def tzset() -> None: ...
mypy-0.470/typeshed/stdlib/2/commands.pyi 0000644 0000000 0000000 00000000231 13035744274 017020 0 ustar root root from typing import Tuple
def getstatus(file: str) -> str: ...
def getoutput(cmd: str) -> str: ...
def getstatusoutput(cmd: str) -> Tuple[int, str]: ...
mypy-0.470/typeshed/stdlib/2/__builtin__.pyi 0000644 0000000 0000000 00000115742 13044257024 017467 0 ustar root root # Stubs for builtins (Python 2.7)
# True and False are deliberately omitted because they are keywords in
# Python 3, and stub files conform to Python 3 syntax.
from typing import (
TypeVar, Iterator, Iterable, overload,
Sequence, Mapping, Tuple, List, Any, Dict, Callable, Generic, Set,
AbstractSet, FrozenSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
SupportsRound, IO, BinaryIO, Union, AnyStr, MutableSequence, MutableMapping,
MutableSet, ItemsView, KeysView, ValuesView, Optional, Container,
)
from abc import abstractmethod, ABCMeta
from mypy_extensions import NoReturn
_T = TypeVar('_T')
_T_co = TypeVar('_T_co', covariant=True)
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
_S = TypeVar('_S')
_T1 = TypeVar('_T1')
_T2 = TypeVar('_T2')
_T3 = TypeVar('_T3')
_T4 = TypeVar('_T4')
_TT = TypeVar('_TT', bound='type')
class staticmethod: pass # Special, only valid as a decorator.
class classmethod: pass # Special, only valid as a decorator.
class object:
__doc__ = ... # type: Optional[str]
__class__ = ... # type: type
__slots__ = ... # type: Optional[Union[str, unicode, Iterable[Union[str, unicode]]]]
def __init__(self) -> None: ...
def __new__(cls) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __eq__(self, o: object) -> bool: ...
def __ne__(self, o: object) -> bool: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __hash__(self) -> int: ...
def __format__(self, format_spec: str) -> str: ...
def __getattribute__(self, name: str) -> Any: ...
def __delattr__(self, name: str) -> None: ...
class type:
__bases__ = ... # type: Tuple[type, ...]
__name__ = ... # type: str
__module__ = ... # type: str
__dict__ = ... # type: Dict[unicode, Any]
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
# TODO: __new__ may have to be special and not a static method.
@overload
def __new__(cls, o: object) -> type: ...
@overload
def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
def __call__(self, *args: Any, **kwds: Any) -> Any: ...
# Only new-style classes
__mro__ = ... # type: Tuple[type, ...]
# Note: the documentation doesnt specify what the return type is, the standard
# implementation seems to be returning a list.
def mro(self) -> List[type]: ...
def __subclasses__(self: _TT) -> List[_TT]: ...
class int(SupportsInt, SupportsFloat, SupportsAbs[int]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: SupportsInt) -> None: ...
@overload
def __init__(self, x: Union[str, unicode, bytearray], base: int = 10) -> None: ...
def bit_length(self) -> int: ...
def __add__(self, x: int) -> int: ...
def __sub__(self, x: int) -> int: ...
def __mul__(self, x: int) -> int: ...
def __floordiv__(self, x: int) -> int: ...
def __div__(self, x: int) -> int: ...
def __truediv__(self, x: int) -> float: ...
def __mod__(self, x: int) -> int: ...
def __radd__(self, x: int) -> int: ...
def __rsub__(self, x: int) -> int: ...
def __rmul__(self, x: int) -> int: ...
def __rfloordiv__(self, x: int) -> int: ...
def __rdiv__(self, x: int) -> int: ...
def __rtruediv__(self, x: int) -> float: ...
def __rmod__(self, x: int) -> int: ...
def __pow__(self, x: int) -> Any: ... # Return type can be int or float, depending on x.
def __rpow__(self, x: int) -> Any: ...
def __and__(self, n: int) -> int: ...
def __or__(self, n: int) -> int: ...
def __xor__(self, n: int) -> int: ...
def __lshift__(self, n: int) -> int: ...
def __rshift__(self, n: int) -> int: ...
def __rand__(self, n: int) -> int: ...
def __ror__(self, n: int) -> int: ...
def __rxor__(self, n: int) -> int: ...
def __rlshift__(self, n: int) -> int: ...
def __rrshift__(self, n: int) -> int: ...
def __neg__(self) -> int: ...
def __pos__(self) -> int: ...
def __invert__(self) -> int: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: int) -> bool: ...
def __le__(self, x: int) -> bool: ...
def __gt__(self, x: int) -> bool: ...
def __ge__(self, x: int) -> bool: ...
def __str__(self) -> str: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def __abs__(self) -> int: ...
def __hash__(self) -> int: ...
class float(SupportsFloat, SupportsInt, SupportsAbs[float]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: SupportsFloat) -> None: ...
@overload
def __init__(self, x: unicode) -> None: ...
@overload
def __init__(self, x: bytearray) -> None: ...
def as_integer_ratio(self) -> Tuple[int, int]: ...
def hex(self) -> str: ...
def is_integer(self) -> bool: ...
@classmethod
def fromhex(cls, s: str) -> float: ...
def __add__(self, x: float) -> float: ...
def __sub__(self, x: float) -> float: ...
def __mul__(self, x: float) -> float: ...
def __floordiv__(self, x: float) -> float: ...
def __div__(self, x: float) -> float: ...
def __truediv__(self, x: float) -> float: ...
def __mod__(self, x: float) -> float: ...
def __pow__(self, x: float) -> float: ...
def __radd__(self, x: float) -> float: ...
def __rsub__(self, x: float) -> float: ...
def __rmul__(self, x: float) -> float: ...
def __rfloordiv__(self, x: float) -> float: ...
def __rdiv__(self, x: float) -> float: ...
def __rtruediv__(self, x: float) -> float: ...
def __rmod__(self, x: float) -> float: ...
def __rpow__(self, x: float) -> float: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: float) -> bool: ...
def __le__(self, x: float) -> bool: ...
def __gt__(self, x: float) -> bool: ...
def __ge__(self, x: float) -> bool: ...
def __neg__(self) -> float: ...
def __pos__(self) -> float: ...
def __str__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class complex(SupportsAbs[float]):
@overload
def __init__(self, re: float = 0.0, im: float = 0.0) -> None: ...
@overload
def __init__(self, s: str) -> None: ...
@property
def real(self) -> float: ...
@property
def imag(self) -> float: ...
def conjugate(self) -> complex: ...
def __add__(self, x: complex) -> complex: ...
def __sub__(self, x: complex) -> complex: ...
def __mul__(self, x: complex) -> complex: ...
def __pow__(self, x: complex) -> complex: ...
def __div__(self, x: complex) -> complex: ...
def __truediv__(self, x: complex) -> complex: ...
def __radd__(self, x: complex) -> complex: ...
def __rsub__(self, x: complex) -> complex: ...
def __rmul__(self, x: complex) -> complex: ...
def __rpow__(self, x: complex) -> complex: ...
def __rdiv__(self, x: complex) -> complex: ...
def __rtruediv__(self, x: complex) -> complex: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __neg__(self) -> complex: ...
def __pos__(self) -> complex: ...
def __str__(self) -> str: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class basestring(metaclass=ABCMeta): ...
class unicode(basestring, Sequence[unicode]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
def capitalize(self) -> unicode: ...
def center(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def count(self, x: unicode) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
end: int = ...) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> unicode: ...
def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def format(self, *args: Any, **kwargs: Any) -> unicode: ...
def format_map(self, map: Mapping[unicode, Any]) -> unicode: ...
def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def isidentifier(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isprintable(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[unicode]) -> unicode: ...
def ljust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def lower(self) -> unicode: ...
def lstrip(self, chars: unicode = ...) -> unicode: ...
def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...
def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: unicode = u' ') -> unicode: ...
def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
def rstrip(self, chars: unicode = ...) -> unicode: ...
def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = 0,
end: int = ...) -> bool: ...
def strip(self, chars: unicode = ...) -> unicode: ...
def swapcase(self) -> unicode: ...
def title(self) -> unicode: ...
def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
def upper(self) -> unicode: ...
def zfill(self, width: int) -> unicode: ...
@overload
def __getitem__(self, i: int) -> unicode: ...
@overload
def __getitem__(self, s: slice) -> unicode: ...
def __getslice__(self, start: int, stop: int) -> unicode: ...
def __add__(self, s: unicode) -> unicode: ...
def __mul__(self, n: int) -> unicode: ...
def __mod__(self, x: Any) -> unicode: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: unicode) -> bool: ...
def __le__(self, x: unicode) -> bool: ...
def __gt__(self, x: unicode) -> bool: ...
def __ge__(self, x: unicode) -> bool: ...
def __len__(self) -> int: ...
def __contains__(self, s: object) -> bool: ...
def __iter__(self) -> Iterator[unicode]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
class str(basestring, Sequence[str]):
def __init__(self, object: object) -> None: ...
def capitalize(self) -> str: ...
def center(self, width: int, fillchar: str = ...) -> str: ...
def count(self, x: unicode) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> str: ...
def find(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def format(self, *args: Any, **kwargs: Any) -> str: ...
def index(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...
def ljust(self, width: int, fillchar: str = ...) -> str: ...
def lower(self) -> str: ...
@overload
def lstrip(self, chars: str = ...) -> str: ...
@overload
def lstrip(self, chars: unicode) -> unicode: ...
@overload
def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
@overload
def partition(self, sep: str) -> Tuple[str, str, str]: ...
@overload
def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ...
def rfind(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: unicode, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: str = ...) -> str: ...
@overload
def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
@overload
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
@overload
def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
@overload
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
@overload
def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
@overload
def rstrip(self, chars: str = ...) -> str: ...
@overload
def rstrip(self, chars: unicode) -> unicode: ...
@overload
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
@overload
def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
def splitlines(self, keepends: bool = ...) -> List[str]: ...
def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]]) -> bool: ...
@overload
def strip(self, chars: str = ...) -> str: ...
@overload
def strip(self, chars: unicode) -> unicode: ...
def swapcase(self) -> str: ...
def title(self) -> str: ...
def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
def upper(self) -> str: ...
def zfill(self, width: int) -> str: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[str]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> str: ...
@overload
def __getitem__(self, s: slice) -> str: ...
def __getslice__(self, start: int, stop: int) -> str: ...
def __add__(self, s: AnyStr) -> AnyStr: ...
def __mul__(self, n: int) -> str: ...
def __rmul__(self, n: int) -> str: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: unicode) -> bool: ...
def __le__(self, x: unicode) -> bool: ...
def __gt__(self, x: unicode) -> bool: ...
def __ge__(self, x: unicode) -> bool: ...
def __mod__(self, x: Any) -> str: ...
class bytearray(MutableSequence[int]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, x: Union[Iterable[int], str]) -> None: ...
@overload
def __init__(self, x: unicode, encoding: unicode,
errors: unicode = ...) -> None: ...
@overload
def __init__(self, length: int) -> None: ...
def capitalize(self) -> bytearray: ...
def center(self, width: int, fillchar: str = ...) -> bytearray: ...
def count(self, x: str) -> int: ...
def decode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
def endswith(self, suffix: Union[str, Tuple[str, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> bytearray: ...
def find(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def index(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def insert(self, index: int, object: int) -> None: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[str]) -> bytearray: ...
def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...
def lower(self) -> bytearray: ...
def lstrip(self, chars: str = ...) -> bytearray: ...
def partition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
def replace(self, old: str, new: str, count: int = ...) -> bytearray: ...
def rfind(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def rindex(self, sub: str, start: int = 0, end: int = ...) -> int: ...
def rjust(self, width: int, fillchar: str = ...) -> bytearray: ...
def rpartition(self, sep: str) -> Tuple[bytearray, bytearray, bytearray]: ...
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def rstrip(self, chars: str = ...) -> bytearray: ...
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool: ...
def strip(self, chars: str = ...) -> bytearray: ...
def swapcase(self) -> bytearray: ...
def title(self) -> bytearray: ...
def translate(self, table: str) -> bytearray: ...
def upper(self) -> bytearray: ...
def zfill(self, width: int) -> bytearray: ...
@staticmethod
def fromhex(x: str) -> bytearray: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytearray: ...
def __getslice__(self, start: int, stop: int) -> bytearray: ...
@overload
def __setitem__(self, i: int, x: int) -> None: ...
@overload
def __setitem__(self, s: slice, x: Union[Iterable[int], str]) -> None: ...
def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __delslice__(self, start: int, stop: int) -> None: ...
def __add__(self, s: str) -> bytearray: ...
def __mul__(self, n: int) -> bytearray: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: str) -> bool: ...
def __le__(self, x: str) -> bool: ...
def __gt__(self, x: str) -> bool: ...
def __ge__(self, x: str) -> bool: ...
class bool(int, SupportsInt, SupportsFloat):
def __init__(self, o: object = ...) -> None: ...
class slice:
start = 0
step = 0
stop = 0
def __init__(self, start: int, stop: int = 0, step: int = 0) -> None: ...
class tuple(Sequence[_T_co], Generic[_T_co]):
def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, x: object) -> bool: ...
@overload
def __getitem__(self, x: int) -> _T_co: ...
@overload
def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
def count(self, x: Any) -> int: ...
def index(self, x: Any) -> int: ...
class function:
# TODO name of the class (corresponds to Python 'function' class)
__name__ = ... # type: str
__module__ = ... # type: str
class list(MutableSequence[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def append(self, object: _T) -> None: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def pop(self, index: int = -1) -> _T: ...
def index(self, object: _T, start: int = 0, stop: int = ...) -> int: ...
def count(self, object: _T) -> int: ...
def insert(self, index: int, object: _T) -> None: ...
def remove(self, object: _T) -> None: ...
def reverse(self) -> None: ...
def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> List[_T]: ...
def __getslice__(self, start: int, stop: int) -> List[_T]: ...
@overload
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __delslice__(self, start: int, stop: int) -> None: ...
def __add__(self, x: List[_T]) -> List[_T]: ...
def __iadd__(self, x: Iterable[_T]) -> List[_T]: ...
def __mul__(self, n: int) -> List[_T]: ...
def __rmul__(self, n: int) -> List[_T]: ...
def __contains__(self, o: object) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
def __gt__(self, x: List[_T]) -> bool: ...
def __ge__(self, x: List[_T]) -> bool: ...
def __lt__(self, x: List[_T]) -> bool: ...
def __le__(self, x: List[_T]) -> bool: ...
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
# NOTE: Keyword arguments are special. If they are used, _KT must include
# str, but we have no way of enforcing it here.
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def has_key(self, k: _KT) -> bool: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
def get(self, k: _KT, default: _VT = None) -> _VT: ...
def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def keys(self) -> List[_KT]: ...
def values(self) -> List[_VT]: ...
def items(self) -> List[Tuple[_KT, _VT]]: ...
def iterkeys(self) -> Iterator[_KT]: ...
def itervalues(self) -> Iterator[_VT]: ...
def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
def viewkeys(self) -> KeysView[_KT]: ...
def viewvalues(self) -> ValuesView[_VT]: ...
def viewitems(self) -> ItemsView[_KT, _VT]: ...
@staticmethod
@overload
def fromkeys(seq: Sequence[_T]) -> Dict[_T, Any]: ... # TODO: Actually a class method (mypy/issues#328)
@staticmethod
@overload
def fromkeys(seq: Sequence[_T], value: _S) -> Dict[_T, _S]: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
class set(MutableSet[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
def add(self, element: _T) -> None: ...
def clear(self) -> None: ...
def copy(self) -> set[_T]: ...
def difference(self, *s: Iterable[Any]) -> set[_T]: ...
def difference_update(self, *s: Iterable[Any]) -> None: ...
def discard(self, element: _T) -> None: ...
def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
def intersection_update(self, *s: Iterable[Any]) -> None: ...
def isdisjoint(self, s: Iterable[Any]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def symmetric_difference(self, s: Iterable[_T]) -> set[_T]: ...
def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
def union(self, *s: Iterable[_T]) -> set[_T]: ...
def update(self, *s: Iterable[_T]) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __iand__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ior__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __isub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ixor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
# TODO more set operations
class frozenset(FrozenSet[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def copy(self) -> frozenset[_T]: ...
def difference(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def intersection(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def isdisjoint(self, s: Iterable[_T]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def symmetric_difference(self, s: Iterable[_T]) -> frozenset[_T]: ...
def union(self, *s: Iterable[_T]) -> frozenset[_T]: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
def __init__(self, iterable: Iterable[_T], start: int = 0) -> None: ...
def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
def next(self) -> Tuple[int, _T]: ...
# TODO __getattribute__
class xrange(Sized, Iterable[int], Reversible[int]):
@overload
def __init__(self, stop: int) -> None: ...
@overload
def __init__(self, start: int, stop: int, step: int = 1) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __getitem__(self, i: int) -> int: ...
def __reversed__(self) -> Iterator[int]: ...
class module:
__name__ = ... # type: str
__file__ = ... # type: str
__dict__ = ... # type: Dict[unicode, Any]
class property:
def __init__(self, fget: Callable[[Any], Any] = None,
fset: Callable[[Any, Any], None] = None,
fdel: Callable[[Any], None] = None, doc: str = None) -> None: ...
def getter(self, fget: Callable[[Any], Any]) -> property: ...
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
def __get__(self, obj: Any, type: type=None) -> Any: ...
def __set__(self, obj: Any, value: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
long = int
bytes = str
NotImplemented = ... # type: Any
def abs(n: SupportsAbs[_T]) -> _T: ...
def all(i: Iterable) -> bool: ...
def any(i: Iterable) -> bool: ...
def bin(number: int) -> str: ...
def callable(o: object) -> bool: ...
def chr(code: int) -> str: ...
def compile(source: Any, filename: unicode, mode: str, flags: int = 0,
dont_inherit: int = 0) -> Any: ...
def delattr(o: Any, name: unicode) -> None: ...
def dir(o: object = ...) -> List[str]: ...
@overload
def divmod(a: int, b: int) -> Tuple[int, int]: ...
@overload
def divmod(a: float, b: float) -> Tuple[float, float]: ...
def exit(code: int = ...) -> NoReturn: ...
@overload
def filter(function: Callable[[_T], Any],
iterable: Iterable[_T]) -> List[_T]: ...
@overload
def filter(function: None,
iterable: Iterable[Optional[_T]]) -> List[_T]: ...
def format(o: object, format_spec: str = '') -> str: ... # TODO unicode
def getattr(o: Any, name: unicode, default: Any = None) -> Any: ...
def hasattr(o: Any, name: unicode) -> bool: ...
def hash(o: object) -> int: ...
def hex(i: int) -> str: ... # TODO __index__
def id(o: object) -> int: ...
def input(prompt: unicode = ...) -> Any: ...
def intern(string: str) -> str: ...
@overload
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def iter(function: Callable[[], _T], sentinel: _T) -> Iterator[_T]: ...
def isinstance(o: object, t: Union[type, Tuple[type, ...]]) -> bool: ...
def issubclass(cls: type, classinfo: Union[type, Tuple[type, ...]]) -> bool: ...
def len(o: Sized) -> int: ...
@overload
def map(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> List[_S]: ...
@overload
def map(func: Callable[[_T1, _T2], _S],
iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> List[_S]: ... # TODO more than two iterables
@overload
def max(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def max(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def min(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def min(iterable: Iterable[_T], key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def next(i: Iterator[_T]) -> _T: ...
@overload
def next(i: Iterator[_T], default: _T) -> _T: ...
def oct(i: int) -> str: ... # TODO __index__
@overload
def open(file: str, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
@overload
def open(file: unicode, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
@overload
def open(file: int, mode: str = 'r', buffering: int = ...) -> BinaryIO: ...
def ord(c: unicode) -> int: ...
# This is only available after from __future__ import print_function.
def print(*values: Any, sep: unicode = u' ', end: unicode = u'\n',
file: IO[Any] = ...) -> None: ...
@overload
def pow(x: int, y: int) -> Any: ... # The return type can be int or float, depending on y.
@overload
def pow(x: int, y: int, z: int) -> Any: ...
@overload
def pow(x: float, y: float) -> float: ...
@overload
def pow(x: float, y: float, z: float) -> float: ...
def quit(code: int = ...) -> None: ...
def range(x: int, y: int = 0, step: int = 1) -> List[int]: ...
def raw_input(prompt: unicode = ...) -> str: ...
@overload
def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], initializer: _T) -> _T: ...
@overload
def reduce(function: Callable[[_T, _T], _T], iterable: Iterable[_T]) -> _T: ...
def reload(module: Any) -> Any: ...
@overload
def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
@overload
def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
def repr(o: object) -> str: ...
@overload
def round(number: float) -> float: ...
@overload
def round(number: float, ndigits: int) -> float: ... # Always return a float if given ndigits.
@overload
def round(number: SupportsRound[_T]) -> _T: ...
@overload
def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
def setattr(object: Any, name: unicode, value: Any) -> None: ...
def sorted(iterable: Iterable[_T], *,
cmp: Callable[[_T, _T], int] = ...,
key: Callable[[_T], Any] = ...,
reverse: bool = ...) -> List[_T]: ...
def sum(iterable: Iterable[_T], start: _T = ...) -> _T: ...
def unichr(i: int) -> unicode: ...
def vars(object: Any = ...) -> Dict[str, Any]: ...
@overload
def zip(iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
@overload
def zip(iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2,
_T3, _T4]]: ... # TODO more than four iterables
def __import__(name: unicode,
globals: Dict[str, Any] = ...,
locals: Dict[str, Any] = ...,
fromlist: List[str] = ..., level: int = ...) -> Any: ...
def globals() -> Dict[str, Any]: ...
def locals() -> Dict[str, Any]: ...
# Actually the type of Ellipsis is , but since it's
# not exposed anywhere under that name, we make it private here.
class ellipsis: ...
Ellipsis = ... # type: ellipsis
# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
AnyBuffer = TypeVar('AnyBuffer', str, unicode, bytearray, buffer)
class buffer(Sized):
def __init__(self, object: AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
def __add__(self, other: AnyBuffer) -> str: ...
def __cmp__(self, other: AnyBuffer) -> bool: ...
def __getitem__(self, key: Union[int, slice]) -> str: ...
def __getslice__(self, i: int, j: int) -> str: ...
def __len__(self) -> int: ...
def __mul__(self, x: int) -> str: ...
class memoryview(Sized, Container[bytes]):
format = ... # type: str
itemsize = ... # type: int
shape = ... # type: Optional[Tuple[int, ...]]
strides = ... # type: Optional[Tuple[int, ...]]
suboffsets = ... # type: Optional[Tuple[int, ...]]
readonly = ... # type: bool
ndim = ... # type: int
def __init__(self, obj: Union[str, bytearray, buffer, memoryview]) -> None: ...
@overload
def __getitem__(self, i: int) -> bytes: ...
@overload
def __getitem__(self, s: slice) -> memoryview: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
def __len__(self) -> int: ...
@overload
def __setitem__(self, i: int, o: bytes) -> None: ...
@overload
def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
@overload
def __setitem__(self, s: slice, o: memoryview) -> None: ...
def tobytes(self) -> bytes: ...
def tolist(self) -> List[int]: ...
class BaseException:
args = ... # type: Tuple[Any, ...]
message = ... # type: str
def __init__(self, *args: Any) -> None: ...
class GeneratorExit(BaseException): ...
class KeyboardInterrupt(BaseException): ...
class SystemExit(BaseException):
code = 0
class Exception(BaseException): ...
class StopIteration(Exception): ...
class StandardError(Exception): ...
class ArithmeticError(StandardError): ...
class BufferError(StandardError): ...
class EnvironmentError(StandardError):
errno = 0
strerror = ... # type: str
# TODO can this be unicode?
filename = ... # type: str
class LookupError(StandardError): ...
class RuntimeError(StandardError): ...
class ValueError(StandardError): ...
class AssertionError(StandardError): ...
class AttributeError(StandardError): ...
class EOFError(StandardError): ...
class FloatingPointError(ArithmeticError): ...
class IOError(EnvironmentError): ...
class ImportError(StandardError): ...
class IndexError(LookupError): ...
class KeyError(LookupError): ...
class MemoryError(StandardError): ...
class NameError(StandardError): ...
class NotImplementedError(RuntimeError): ...
class OSError(EnvironmentError): ...
class WindowsError(OSError):
winerror = ... # type: int
class OverflowError(ArithmeticError): ...
class ReferenceError(StandardError): ...
class SyntaxError(StandardError):
msg = ... # type: str
lineno = ... # type: int
offset = ... # type: int
text = ... # type: str
class IndentationError(SyntaxError): ...
class TabError(IndentationError): ...
class SystemError(StandardError): ...
class TypeError(StandardError): ...
class UnboundLocalError(NameError): ...
class UnicodeError(ValueError): ...
class UnicodeDecodeError(UnicodeError): ...
class UnicodeEncodeError(UnicodeError): ...
class UnicodeTranslateError(UnicodeError): ...
class ZeroDivisionError(ArithmeticError): ...
class Warning(Exception): ...
class UserWarning(Warning): ...
class DeprecationWarning(Warning): ...
class SyntaxWarning(Warning): ...
class RuntimeWarning(Warning): ...
class FutureWarning(Warning): ...
class PendingDeprecationWarning(Warning): ...
class ImportWarning(Warning): ...
class UnicodeWarning(Warning): ...
class BytesWarning(Warning): ...
class ResourceWarning(Warning): ...
def eval(s: str, globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...) -> Any: ...
def exec(object: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> Any: ... # TODO code object as source
def cmp(x: Any, y: Any) -> int: ...
def execfile(filename: str, globals: Dict[str, Any] = None, locals: Dict[str, Any] = None) -> None: ...
class file(BinaryIO):
@overload
def __init__(self, file: str, mode: str = 'r', buffering: int = ...) -> None: ...
@overload
def __init__(self, file: unicode, mode: str = 'r', buffering: int = ...) -> None: ...
@overload
def __init__(self, file: int, mode: str = 'r', buffering: int = ...) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def read(self, n: int = ...) -> str: ...
def __enter__(self) -> BinaryIO: ...
def __exit__(self, t: type = None, exc: BaseException = None, tb: Any = None) -> bool: ...
def flush(self) -> None: ...
def fileno(self) -> int: ...
def isatty(self) -> bool: ...
def close(self) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def seekable(self) -> bool: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def tell(self) -> int: ...
def readline(self, limit: int = ...) -> str: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def write(self, data: str) -> None: ...
def writelines(self, data: Iterable[str]) -> None: ...
def truncate(self, pos: int = ...) -> int: ...
# Very old builtins
def apply(func: Callable[..., _T], args: Sequence[Any] = None, kwds: Mapping[str, Any] = None) -> _T: ...
_N = TypeVar('_N', bool, int, float, complex)
def coerce(x: _N, y: _N) -> Tuple[_N, _N]: ...
mypy-0.470/typeshed/stdlib/2/stat.pyi 0000644 0000000 0000000 00000001661 13023631176 016173 0 ustar root root def S_ISDIR(mode: int) -> bool: ...
def S_ISCHR(mode: int) -> bool: ...
def S_ISBLK(mode: int) -> bool: ...
def S_ISREG(mode: int) -> bool: ...
def S_ISFIFO(mode: int) -> bool: ...
def S_ISLNK(mode: int) -> bool: ...
def S_ISSOCK(mode: int) -> bool: ...
def S_IMODE(mode: int) -> int: ...
def S_IFMT(mode: int) -> int: ...
ST_MODE = 0
ST_INO = 0
ST_DEV = 0
ST_NLINK = 0
ST_UID = 0
ST_GID = 0
ST_SIZE = 0
ST_ATIME = 0
ST_MTIME = 0
ST_CTIME = 0
S_IFSOCK = 0
S_IFLNK = 0
S_IFREG = 0
S_IFBLK = 0
S_IFDIR = 0
S_IFCHR = 0
S_IFIFO = 0
S_ISUID = 0
S_ISGID = 0
S_ISVTX = 0
S_IRWXU = 0
S_IRUSR = 0
S_IWUSR = 0
S_IXUSR = 0
S_IRWXG = 0
S_IRGRP = 0
S_IWGRP = 0
S_IXGRP = 0
S_IRWXO = 0
S_IROTH = 0
S_IWOTH = 0
S_IXOTH = 0
S_ENFMT = 0
S_IREAD = 0
S_IWRITE = 0
S_IEXEC = 0
UF_NODUMP = 0
UF_IMMUTABLE = 0
UF_APPEND = 0
UF_OPAQUE = 0
UF_NOUNLINK = 0
UF_COMPRESSED = 0
UF_HIDDEN = 0
SF_ARCHIVED = 0
SF_IMMUTABLE = 0
SF_APPEND = 0
SF_NOUNLINK = 0
SF_SNAPSHOT = 0
mypy-0.470/typeshed/stdlib/2/tokenize.pyi 0000644 0000000 0000000 00000010431 13023631176 017043 0 ustar root root # Automatically generated by pytype, manually fixed up. May still contain errors.
from typing import Any, Callable, Dict, Generator, Iterator, List, Tuple, Union, Iterable
__all__ = ... # type: List[str]
__author__ = ... # type: str
__credits__ = ... # type: str
AMPER = ... # type: int
AMPEREQUAL = ... # type: int
AT = ... # type: int
BACKQUOTE = ... # type: int
Binnumber = ... # type: str
Bracket = ... # type: str
CIRCUMFLEX = ... # type: int
CIRCUMFLEXEQUAL = ... # type: int
COLON = ... # type: int
COMMA = ... # type: int
COMMENT = ... # type: int
Comment = ... # type: str
ContStr = ... # type: str
DEDENT = ... # type: int
DOT = ... # type: int
DOUBLESLASH = ... # type: int
DOUBLESLASHEQUAL = ... # type: int
DOUBLESTAR = ... # type: int
DOUBLESTAREQUAL = ... # type: int
Decnumber = ... # type: str
Double = ... # type: str
Double3 = ... # type: str
ENDMARKER = ... # type: int
EQEQUAL = ... # type: int
EQUAL = ... # type: int
ERRORTOKEN = ... # type: int
Expfloat = ... # type: str
Exponent = ... # type: str
Floatnumber = ... # type: str
Funny = ... # type: str
GREATER = ... # type: int
GREATEREQUAL = ... # type: int
Hexnumber = ... # type: str
INDENT = ... # type: int
def ISEOF(x: int) -> bool: ...
def ISNONTERMINAL(x: int) -> bool: ...
def ISTERMINAL(x: int) -> bool: ...
Ignore = ... # type: str
Imagnumber = ... # type: str
Intnumber = ... # type: str
LBRACE = ... # type: int
LEFTSHIFT = ... # type: int
LEFTSHIFTEQUAL = ... # type: int
LESS = ... # type: int
LESSEQUAL = ... # type: int
LPAR = ... # type: int
LSQB = ... # type: int
MINEQUAL = ... # type: int
MINUS = ... # type: int
NAME = ... # type: int
NEWLINE = ... # type: int
NL = ... # type: int
NOTEQUAL = ... # type: int
NT_OFFSET = ... # type: int
NUMBER = ... # type: int
N_TOKENS = ... # type: int
Name = ... # type: str
Number = ... # type: str
OP = ... # type: int
Octnumber = ... # type: str
Operator = ... # type: str
PERCENT = ... # type: int
PERCENTEQUAL = ... # type: int
PLUS = ... # type: int
PLUSEQUAL = ... # type: int
PlainToken = ... # type: str
Pointfloat = ... # type: str
PseudoExtras = ... # type: str
PseudoToken = ... # type: str
RBRACE = ... # type: int
RIGHTSHIFT = ... # type: int
RIGHTSHIFTEQUAL = ... # type: int
RPAR = ... # type: int
RSQB = ... # type: int
SEMI = ... # type: int
SLASH = ... # type: int
SLASHEQUAL = ... # type: int
STAR = ... # type: int
STAREQUAL = ... # type: int
STRING = ... # type: int
Single = ... # type: str
Single3 = ... # type: str
Special = ... # type: str
String = ... # type: str
TILDE = ... # type: int
Token = ... # type: str
Triple = ... # type: str
VBAR = ... # type: int
VBAREQUAL = ... # type: int
Whitespace = ... # type: str
chain = ... # type: type
double3prog = ... # type: type
endprogs = ... # type: Dict[str, Any]
pseudoprog = ... # type: type
re = ... # type: module
single3prog = ... # type: type
single_quoted = ... # type: Dict[str, str]
string = ... # type: module
sys = ... # type: module
t = ... # type: str
tabsize = ... # type: int
tok_name = ... # type: Dict[int, str]
token = ... # type: module
tokenprog = ... # type: type
triple_quoted = ... # type: Dict[str, str]
x = ... # type: str
_Pos = Tuple[int, int]
_TokenType = Tuple[int, str, _Pos, _Pos, str]
def any(*args, **kwargs) -> str: ...
def generate_tokens(readline: Callable[[], str]) -> Generator[_TokenType, None, None]: ...
def group(*args: str) -> str: ...
def maybe(*args: str) -> str: ...
def printtoken(type: int, token: str, srow_scol: _Pos, erow_ecol: _Pos, line: str) -> None: ...
def tokenize(readline: Callable[[], str], tokeneater: Callable[[Tuple[int, str, _Pos, _Pos, str]], None]) -> None: ...
def tokenize_loop(readline: Callable[[], str], tokeneater: Callable[[Tuple[int, str, _Pos, _Pos, str]], None]) -> None: ...
def untokenize(iterable: Iterable[_TokenType]) -> str: ...
class StopTokenizing(Exception):
pass
class TokenError(Exception):
pass
class Untokenizer:
prev_col = ... # type: int
prev_row = ... # type: int
tokens = ... # type: List[str]
def __init__(self) -> None: ...
def add_whitespace(self, _Pos) -> None: ...
def compat(self, token: Tuple[int, Any], iterable: Iterator[_TokenType]) -> None: ...
def untokenize(self, iterable: Iterable[_TokenType]) -> str: ...
mypy-0.470/typeshed/stdlib/2/glob.pyi 0000644 0000000 0000000 00000000220 13023631176 016131 0 ustar root root from typing import List, Iterator, AnyStr
def glob(pathname: AnyStr) -> List[AnyStr]: ...
def iglob(pathname: AnyStr) -> Iterator[AnyStr]: ...
mypy-0.470/typeshed/stdlib/2/UserString.pyi 0000644 0000000 0000000 00000000202 13035744274 017322 0 ustar root root import collections
class UserString(collections.Sequence): ...
class MutableString(UserString, collections.MutableSequence): ...
mypy-0.470/typeshed/stdlib/2/distutils/ 0000755 0000000 0000000 00000000000 13044320557 016516 5 ustar root root mypy-0.470/typeshed/stdlib/2/distutils/emxccompiler.pyi 0000644 0000000 0000000 00000000164 13023631176 021730 0 ustar root root # Stubs for emxccompiler
from distutils.unixccompiler import UnixCCompiler
class EMXCCompiler(UnixCCompiler): ...
mypy-0.470/typeshed/stdlib/2/distutils/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020765 0 ustar root root mypy-0.470/typeshed/stdlib/2/Queue.pyi 0000644 0000000 0000000 00000001636 13035744274 016315 0 ustar root root # Stubs for Queue (Python 2)
from typing import Any, TypeVar, Generic, Optional
_T = TypeVar('_T')
class Empty(Exception): ...
class Full(Exception): ...
class Queue(Generic[_T]):
maxsize = ... # type: Any
mutex = ... # type: Any
not_empty = ... # type: Any
not_full = ... # type: Any
all_tasks_done = ... # type: Any
unfinished_tasks = ... # type: Any
def __init__(self, maxsize: int = ...) -> None: ...
def task_done(self) -> None: ...
def join(self) -> None: ...
def qsize(self) -> int: ...
def empty(self) -> bool: ...
def full(self) -> bool: ...
def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
def put_nowait(self, item: _T) -> None: ...
def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
def get_nowait(self) -> _T: ...
class PriorityQueue(Queue): ...
class LifoQueue(Queue): ...
mypy-0.470/typeshed/stdlib/2/htmlentitydefs.pyi 0000644 0000000 0000000 00000000442 13035744274 020266 0 ustar root root # Stubs for htmlentitydefs (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Mapping
name2codepoint = ... # type: Mapping[str, int]
codepoint2name = ... # type: Mapping[int, str]
entitydefs = ... # type: Mapping[str, str]
mypy-0.470/typeshed/stdlib/2/functools.pyi 0000644 0000000 0000000 00000002501 13035744274 017235 0 ustar root root # Stubs for functools (Python 2.7)
# NOTE: These are incomplete!
from abc import ABCMeta, abstractmethod
from typing import Any, Callable, Generic, Dict, Iterable, Optional, Sequence, Tuple, TypeVar, overload
from collections import namedtuple
_AnyCallable = Callable[..., Any]
_T = TypeVar("_T")
_S = TypeVar("_S")
@overload
def reduce(function: Callable[[_T, _T], _T],
sequence: Iterable[_T]) -> _T: ...
@overload
def reduce(function: Callable[[_T, _S], _T],
sequence: Iterable[_S], initial: _T) -> _T: ...
WRAPPER_ASSIGNMENTS = ... # type: Sequence[str]
WRAPPER_UPDATES = ... # type: Sequence[str]
def update_wrapper(wrapper: _AnyCallable, wrapped: _AnyCallable, assigned: Sequence[str] = ...,
updated: Sequence[str] = ...) -> None: ...
def wraps(wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> Callable[[_AnyCallable], _AnyCallable]: ...
def total_ordering(cls: type) -> type: ...
def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], Any]: ...
class partial(Generic[_T]):
func = ... # Callable[..., _T]
args = ... # type: Tuple[Any, ...]
keywords = ... # type: Dict[str, Any]
def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
mypy-0.470/typeshed/stdlib/2/calendar.pyi 0000644 0000000 0000000 00000010647 13035744274 017004 0 ustar root root from typing import Any, Iterable, List, Optional, Tuple, Sequence
import datetime
LocaleType = Tuple[Optional[str], Optional[str]]
class IllegalMonthError(ValueError):
def __init__(self, month: int) -> None: ...
def __str__(self) -> str: ...
class IllegalWeekdayError(ValueError):
def __init__(self, weekday: int) -> None: ...
def __str__(self) -> str: ...
def isleap(year: int) -> bool: ...
def leapdays(y1: int, y2: int) -> int: ...
def weekday(year: int, month: int, day: int) -> int: ...
def monthrange(year: int, month: int) -> Tuple[int, int]: ...
class Calendar(object):
def __init__(self, firstweekday: int = 0) -> None: ...
def getfirstweekday(self) -> int: ...
def setfirstweekday(self, firstweekday: int) -> None: ...
def iterweekdays(self) -> Iterable[int]: ...
def itermonthdates(self, year: int, month: int) -> Iterable[datetime.date]: ...
def itermonthdays2(self, year: int, month: int) -> Iterable[Tuple[int, int]]: ...
def itermonthdays(self, year: int, month: int) -> Iterable[int]: ...
def monthdatescalendar(self, year: int, month: int) -> List[List[datetime.date]]: ...
def monthdays2calendar(self, year: int, month: int) -> List[List[Tuple[int, int]]]: ...
def monthdayscalendar(self, year: int, month: int) -> List[List[int]]: ...
def yeardatescalendar(self, year: int, width: int = 3) -> List[List[int]]: ...
def yeardays2calendar(self, year: int, width: int = 3) -> List[List[Tuple[int, int]]]: ...
def yeardayscalendar(self, year: int, width: int = 3) -> List[List[int]]: ...
class TextCalendar(Calendar):
def prweek(self, theweek: int, width: int) -> None: ...
def formatday(self, day: int, weekday: int, width: int) -> str: ...
def formatweek(self, theweek: int, width: int) -> str: ...
def formatweekday(self, day: int, width: int) -> str: ...
def formatweekheader(self, width: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ...
def prmonth(self, theyear: int, themonth: int, w: Any=0, l: Any = 0) -> None: ...
def formatmonth(self, theyear: int, themonth: int, w: int = 0, l: int = 0) -> str: ...
def formatyear(self, theyear: int, w: int = 2, l: int = 1, c: int = 6, m: int = 3) -> str: ...
def pryear(self, theyear: int, w: Any = 0, l: Any = 0, c: Any = 6, m: Any = 3) -> None: ...
class HTMLCalendar(Calendar):
def formatday(self, day: int, weekday: int) -> str: ...
def formatweek(self, theweek: int) -> str: ...
def formatweekday(self, day: int) -> str: ...
def formatweekheader(self) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
def formatmonth(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
def formatyear(self, theyear: int, width: int = 3) -> str: ...
def formatyearpage(self, theyear: int, width: int = 3, css: Optional[str] = ..., encoding: Optional[str] = ...) -> str: ...
class TimeEncoding:
def __init__(self, locale: LocaleType) -> None: ...
def __enter__(self) -> LocaleType: ...
def __exit__(self, *args) -> None: ...
class LocaleTextCalendar(TextCalendar):
def __init__(self, firstweekday: int = 0, locale: Optional[LocaleType] = ...) -> None: ...
def formatweekday(self, day: int, width: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ...
class LocaleHTMLCalendar(HTMLCalendar):
def __init__(self, firstweekday: int = 0, locale: Optional[LocaleType] = ...) -> None: ...
def formatweekday(self, day: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
c = ... # type: TextCalendar
def setfirstweekday(firstweekday: int) -> None: ...
def format(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ...
def formatstring(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ...
def timegm(tuple: Tuple[int, ...]) -> int: ...
# Data attributes
day_name = ... # type: Sequence[str]
day_abbr = ... # type: Sequence[str]
month_name = ... # type: Sequence[str]
month_abbr = ... # type: Sequence[str]
# Below constants are not in docs or __all__, but enough people have used them
# they are now effectively public.
MONDAY = ... # type: int
TUESDAY = ... # type: int
WEDNESDAY = ... # type: int
THURSDAY = ... # type: int
FRIDAY = ... # type: int
SATURDAY = ... # type: int
SUNDAY = ... # type: int
mypy-0.470/typeshed/stdlib/2/array.pyi 0000644 0000000 0000000 00000004207 13023631176 016335 0 ustar root root """Stub file for the 'array' module."""
from typing import (Any, Generic, IO, Iterable, Sequence, TypeVar,
Union, overload, Iterator, Tuple, BinaryIO, List)
T = TypeVar('T')
class array(Generic[T]):
def __init__(self, typecode: str, init: Iterable[T] = ...) -> None: ...
def __add__(self, y: "array[T]") -> "array[T]": ...
def __contains__(self, y: Any) -> bool: ...
def __copy__(self) -> "array[T]": ...
def __deepcopy__(self) -> "array": ...
def __delitem__(self, y: Union[slice, int]) -> None: ...
def __delslice__(self, i: int, j: int) -> None: ...
@overload
def __getitem__(self, i: int) -> Any: ...
@overload
def __getitem__(self, s: slice) -> "array": ...
def __iadd__(self, y: "array[T]") -> "array[T]": ...
def __imul__(self, y: int) -> "array[T]": ...
def __iter__(self) -> Iterator[T]: ...
def __len__(self) -> int: ...
def __mul__(self, n: int) -> "array[T]": ...
def __rmul__(self, n: int) -> "array[T]": ...
@overload
def __setitem__(self, i: int, y: T) -> None: ...
@overload
def __setitem__(self, i: slice, y: "array[T]") -> None: ...
def append(self, x: T) -> None: ...
def buffer_info(self) -> Tuple[int, int]: ...
def byteswap(self) -> None:
raise RuntimeError()
def count(self) -> int: ...
def extend(self, x: Sequence[T]) -> None: ...
def fromlist(self, list: List[T]) -> None:
raise EOFError()
raise IOError()
def fromfile(self, f: BinaryIO, n: int) -> None: ...
def fromstring(self, s: str) -> None: ...
def fromunicode(self, u: unicode) -> None: ...
def index(self, x: T) -> int: ...
def insert(self, i: int, x: T) -> None: ...
def pop(self, i: int = ...) -> T: ...
def read(self, f: IO[str], n: int) -> None:
raise DeprecationWarning()
def remove(self, x: T) -> None: ...
def reverse(self) -> None: ...
def tofile(self, f: BinaryIO) -> None:
raise IOError()
def tolist(self) -> List[T]: ...
def tostring(self) -> str: ...
def tounicode(self) -> unicode: ...
def write(self, f: IO[str]) -> None:
raise DeprecationWarning()
mypy-0.470/typeshed/stdlib/2/gettext.pyi 0000644 0000000 0000000 00000004140 13023631176 016677 0 ustar root root # TODO(MichalPokorny): better types
from typing import Any, IO, List, Optional, Union
def bindtextdomain(domain: str, localedir: str = ...) -> str: ...
def bind_textdomain_codeset(domain: str, codeset: str = ...) -> str: ...
def textdomain(domain: str = ...) -> str: ...
def gettext(message: str) -> str: ...
def lgettext(message: str) -> str: ...
def dgettext(domain: str, message: str) -> str: ...
def ldgettext(domain: str, message: str) -> str: ...
def ngettext(singular: str, plural: str, n: int) -> str: ...
def lngettext(singular: str, plural: str, n: int) -> str: ...
def dngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
def ldngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
class NullTranslations(object):
def __init__(self, fp: IO[str] = ...) -> None: ...
def _parse(self, fp: IO[str]) -> None: ...
def add_fallback(self, fallback: NullTranslations) -> None: ...
def gettext(self, message: str) -> str: ...
def lgettext(self, message: str) -> str: ...
def ugettext(self, message: Union[str, unicode]) -> unicode: ...
def ngettext(self, singular: str, plural: str, n: int) -> str: ...
def lngettext(self, singular: str, plural: str, n: int) -> str: ...
def ungettext(self, singular: Union[str, unicode], plural: Union[str, unicode], n: int) -> unicode: ...
def info(self) -> Any: ...
def charset(self) -> Any: ...
def output_charset(self) -> Any: ...
def set_output_charset(self, charset: Any) -> None: ...
def install(self, unicode: bool = ..., names: Any = ...) -> None: ...
class GNUTranslations(NullTranslations):
LE_MAGIC = ... # type: int
BE_MAGIC = ... # type: int
def find(domain: str, localedir: str = ..., languages: List[str] = ...,
all: Any = ...) -> Optional[Union[str, List[str]]]: ...
def translation(domain: str, localedir: str = ..., languages: List[str] = ...,
class_: Any = ..., fallback: Any = ..., codeset: Any = ...) -> NullTranslations: ...
def install(domain: str, localedir: str = ..., unicode: Any = ..., codeset: Any = ...,
names: Any = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2/exceptions.pyi 0000644 0000000 0000000 00000005431 13023631176 017400 0 ustar root root from typing import Any, Tuple, Optional
class StandardError(Exception): ...
class ArithmeticError(StandardError): ...
class AssertionError(StandardError): ...
class AttributeError(StandardError): ...
class BaseException(object):
args = ... # type: Tuple[Any, ...]
message = ... # type: str
def __getslice__(self, start, end) -> Any: ...
def __getitem__(self, start, end) -> Any: ...
def __unicode__(self) -> unicode: ...
class BufferError(StandardError): ...
class BytesWarning(Warning): ...
class DeprecationWarning(Warning): ...
class EOFError(StandardError): ...
class EnvironmentError(StandardError):
errno = ... # type: int
strerror = ... # type: str
filename = ... # type: str
class Exception(BaseException): ...
class FloatingPointError(ArithmeticError): ...
class FutureWarning(Warning): ...
class GeneratorExit(BaseException): ...
class IOError(EnvironmentError): ...
class ImportError(StandardError): ...
class ImportWarning(Warning): ...
class IndentationError(SyntaxError): ...
class IndexError(LookupError): ...
class KeyError(LookupError): ...
class KeyboardInterrupt(BaseException): ...
class LookupError(StandardError): ...
class MemoryError(StandardError): ...
class NameError(StandardError): ...
class NotImplementedError(RuntimeError): ...
class OSError(EnvironmentError): ...
class OverflowError(ArithmeticError): ...
class PendingDeprecationWarning(Warning): ...
class ReferenceError(StandardError): ...
class RuntimeError(StandardError): ...
class RuntimeWarning(Warning): ...
class StopIteration(Exception): ...
class SyntaxError(StandardError):
text = ... # type: str
print_file_and_line = ... # type: Optional[str]
filename = ... # type: str
lineno = ... # type: int
offset = ... # type: int
msg = ... # type: str
class SyntaxWarning(Warning): ...
class SystemError(StandardError): ...
class SystemExit(BaseException):
code = ... # type: int
class TabError(IndentationError): ...
class TypeError(StandardError): ...
class UnboundLocalError(NameError): ...
class UnicodeError(ValueError): ...
class UnicodeDecodeError(UnicodeError):
start = ... # type: int
reason = ... # type: str
object = ... # type: str
end = ... # type: int
encoding = ... # type: str
class UnicodeEncodeError(UnicodeError):
start = ... # type: int
reason = ... # type: str
object = ... # type: unicode
end = ... # type: int
encoding = ... # type: str
class UnicodeTranslateError(UnicodeError):
start = ... # type: int
reason = ... # type: str
object = ... # type: Any
end = ... # type: int
encoding = ... # type: str
class UnicodeWarning(Warning): ...
class UserWarning(Warning): ...
class ValueError(StandardError): ...
class Warning(Exception): ...
class ZeroDivisionError(ArithmeticError): ...
mypy-0.470/typeshed/stdlib/2/optparse.pyi 0000644 0000000 0000000 00000024556 13035744274 017074 0 ustar root root # Generated by pytype, with only minor tweaks. Might be incomplete.
from typing import Any, Optional, List, Callable, Tuple, Dict, Iterable, Union
# See https://groups.google.com/forum/#!topic/python-ideas/gA1gdj3RZ5g
Text = Union[str, unicode]
NO_DEFAULT = ... # type: Tuple[str, ...]
SUPPRESS_HELP = ... # type: str
SUPPRESS_USAGE = ... # type: str
def check_builtin(option: Option, opt, value: Text) -> Any: ...
def check_choice(option: Option, opt, value) -> Any: ...
def isbasestring(x) -> bool: ...
class OptParseError(Exception):
msg = ... # type: Any
def __init__(self, msg) -> None: ...
class BadOptionError(OptParseError):
opt_str = ... # type: Any
def __init__(self, opt_str) -> None: ...
class AmbiguousOptionError(BadOptionError):
possibilities = ... # type: Any
def __init__(self, opt_str, possibilities) -> None: ...
class OptionError(OptParseError):
msg = ... # type: Any
option_id = ... # type: str
def __init__(self, msg, option: Option) -> None: ...
class OptionConflictError(OptionError): ...
class HelpFormatter:
NO_DEFAULT_VALUE = ... # type: str
_long_opt_fmt = ... # type: Union[str, unicode]
_short_opt_fmt = ... # type: Union[str, unicode]
current_indent = ... # type: int
default_tag = ... # type: str
help_position = ... # type: Any
help_width = ... # type: Any
indent_increment = ... # type: Any
level = ... # type: int
max_help_position = ... # type: int
option_strings = ... # type: Dict[Option, str]
parser = ... # type: Any
short_first = ... # type: Any
width = ... # type: Any
def __init__(self, indent_increment, max_help_position, width, short_first) -> None: ...
def _format_text(self, text: Text) -> Text: ...
def dedent(self) -> None: ...
def expand_default(self, option: Option) -> Text: ...
def format_description(self, description) -> Any: ...
def format_epilog(self, epilog) -> Any: ...
def format_heading(self, heading) -> Any: ...
def format_option(self, option: Any) -> str: ...
def format_option_strings(self, option: Any) -> Any: ...
def format_usage(self, usage) -> Any: ...
def indent(self) -> None: ...
def set_long_opt_delimiter(self, delim) -> None: ...
def set_parser(self, parser) -> None: ...
def set_short_opt_delimiter(self, delim) -> None: ...
def store_option_strings(self, parser) -> None: ...
class IndentedHelpFormatter(HelpFormatter):
_long_opt_fmt = ... # type: str
_short_opt_fmt = ... # type: str
current_indent = ... # type: int
default_tag = ... # type: str
help_position = ... # type: int
help_width = ... # type: Optional[int]
indent_increment = ... # type: Any
level = ... # type: int
max_help_position = ... # type: int
option_strings = ... # type: Dict[Any, Any]
parser = ... # type: Optional[OptionParser]
short_first = ... # type: Any
width = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def format_heading(self, heading) -> str: ...
def format_usage(self, usage) -> str: ...
class Option:
ACTIONS = ... # type: Tuple[str, ...]
ALWAYS_TYPED_ACTIONS = ... # type: Tuple[str, ...]
ATTRS = ... # type: List[str]
CHECK_METHODS = ... # type: Union[None, List[Callable]]
CONST_ACTIONS = ... # type: Tuple[str, ...]
STORE_ACTIONS = ... # type: Tuple[str, ...]
TYPED_ACTIONS = ... # type: Tuple[str, ...]
TYPES = ... # type: Tuple[str, ...]
TYPE_CHECKER = ... # type: Dict[str, Callable]
_long_opts = ... # type: List[Text]
_short_opts = ... # type: List[Text]
action = ... # type: str
dest = ... # type: Any
nargs = ... # type: int
type = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def _check_action(self) -> None: ...
def _check_callback(self) -> None: ...
def _check_choice(self) -> None: ...
def _check_const(self) -> None: ...
def _check_dest(self) -> None: ...
def _check_nargs(self) -> None: ...
def _check_opt_strings(self, opts) -> Any: ...
def _check_type(self) -> None: ...
def _set_attrs(self, attrs: Dict[str, Any]) -> None: ...
def _set_opt_strings(self, opts) -> None: ...
def check_value(self, opt, value) -> Any: ...
def convert_value(self, opt, value) -> Any: ...
def get_opt_string(self) -> Text: ...
def process(self, opt, value, values: Any, parser: OptionParser) -> int: ...
def take_action(self, action, dest, opt, value, values, parser: OptionParser) -> int: ...
def takes_value(self) -> bool: ...
make_option = Option
class OptionContainer:
_long_opt = ... # type: Dict[Text, Any]
_short_opt = ... # type: Dict[Text, Any]
conflict_handler = ... # type: Any
defaults = ... # type: Dict[Text, Any]
description = ... # type: Any
option_class = ... # type: Any
def __init__(self, option_class, conflict_handler, description) -> None: ...
def _check_conflict(self, option: Any) -> None: ...
def _create_option_mappings(self) -> None: ...
def _share_option_mappings(self, parser) -> None: ...
def add_option(self, *args, **kwargs) -> Any: ...
def add_options(self, option_list) -> None: ...
def destroy(self) -> None: ...
def format_description(self, formatter: Optional[HelpFormatter]) -> Any: ...
def format_help(self, formatter: HelpFormatter) -> str: ...
def format_option_help(self, formatter: Optional[HelpFormatter]) -> str: ...
def get_description(self) -> Any: ...
def get_option(self, opt_str) -> Optional[Option]: ...
def has_option(self, opt_str) -> bool: ...
def remove_option(self, opt_str) -> None: ...
def set_conflict_handler(self, handler) -> None: ...
def set_description(self, description) -> None: ...
class OptionGroup(OptionContainer):
_long_opt = ... # type: Dict[Any, Any]
_short_opt = ... # type: Dict[Any, Any]
conflict_handler = ... # type: Any
defaults = ... # type: Dict[Text, Any]
description = ... # type: Any
option_class = ... # type: Any
option_list = ... # type: List
parser = ... # type: Any
title = ... # type: Any
def __init__(self, parser, title, *args, **kwargs) -> None: ...
def _create_option_list(self) -> None: ...
def format_help(self, formatter: HelpFormatter) -> Any: ...
def set_title(self, title) -> None: ...
class OptionParser(OptionContainer):
_long_opt = ... # type: Dict[Text, Any]
_short_opt = ... # type: Dict[Any, Any]
allow_interspersed_args = ... # type: bool
conflict_handler = ... # type: Any
defaults = ... # type: Dict[Any, Any]
description = ... # type: Text
epilog = ... # type: Any
formatter = ... # type: HelpFormatter
largs = ... # type: Union[None, List[Text]]
option_class = ... # type: Callable
option_groups = ... # type: List[OptionParser]
option_list = ... # type: List[Any]
process_default_values = ... # type: Any
prog = ... # type: Any
rargs = ... # type: Optional[List[Any]]
standard_option_list = ... # type: List
usage = ... # type: Optional[Text]
values = ... # type: Any
version = ... # type: Text
def __init__(self, *args, **kwargs) -> None: ...
def _add_help_option(self) -> None: ...
def _add_version_option(self) -> None: ...
def _create_option_list(self) -> None: ...
def _get_all_options(self) -> List[Any]: ...
def _get_args(self, args: Iterable) -> List[Any]: ...
def _get_encoding(self, file) -> Any: ...
def _init_parsing_state(self) -> None: ...
def _match_long_opt(self, opt) -> Any: ...
def _populate_option_list(self, option_list, *args, **kwargs) -> None: ...
def _process_args(self, largs: List[Text], rargs: List, values: Values) -> None: ...
def _process_long_opt(self, rargs: List, values) -> None: ...
def _process_short_opts(self, rargs: List, values) -> None: ...
def add_option_group(self, *args, **kwargs) -> OptionParser: ...
def check_values(self, values, args) -> Tuple[Any, ...]: ...
def disable_interspersed_args(self) -> None: ...
def enable_interspersed_args(self) -> None: ...
def error(self, msg) -> None: ...
def exit(self, *args, **kwargs) -> None: ...
def expand_prog_name(self, s: Optional[Text]) -> Any: ...
def format_epilog(self, formatter: Union[HelpFormatter, OptionParser, None]) -> Any: ...
def format_help(self, *args, **kwargs) -> str: ...
def format_option_help(self, *args, **kwargs) -> str: ...
def get_default_values(self) -> Values: ...
def get_option_group(self, opt_str) -> Any: ...
def get_prog_name(self) -> Any: ...
def get_usage(self) -> Text: ...
def get_version(self) -> Any: ...
def parse_args(self, *args, **kwargs) -> Tuple[Any, ...]: ...
def print_help(self, *args, **kwargs) -> None: ...
def print_usage(self, *args, **kwargs) -> None: ...
def print_version(self, *args, **kwargs) -> None: ...
def set_default(self, dest, value) -> None: ...
def set_defaults(self, *args, **kwargs) -> None: ...
def set_process_default_values(self, process) -> None: ...
def set_usage(self, usage: Text) -> None: ...
class OptionValueError(OptParseError):
msg = ... # type: Any
class TitledHelpFormatter(HelpFormatter):
_long_opt_fmt = ... # type: str
_short_opt_fmt = ... # type: str
current_indent = ... # type: int
default_tag = ... # type: str
help_position = ... # type: int
help_width = ... # type: None
indent_increment = ... # type: Any
level = ... # type: int
max_help_position = ... # type: int
option_strings = ... # type: Dict
parser = ... # type: None
short_first = ... # type: Any
width = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def format_heading(self, heading) -> str: ...
def format_usage(self, usage) -> str: ...
class Values:
def __cmp__(self, other) -> int: ...
def __init__(self, *args, **kwargs) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def _update(self, dict: Dict[str, Any], mode) -> None: ...
def _update_careful(self, dict: Dict[str, Any]) -> None: ...
def _update_loose(self, dict) -> None: ...
def ensure_value(self, attr, value) -> Any: ...
def read_file(self, filename, *args, **kwargs) -> None: ...
def read_module(self, modname, *args, **kwargs) -> None: ...
mypy-0.470/typeshed/stdlib/2/zlib.pyi 0000644 0000000 0000000 00000002456 13035744274 016172 0 ustar root root # Stubs for zlib (Python 2.7)
DEFLATED = ... # type: int
DEF_MEM_LEVEL = ... # type: int
MAX_WBITS = ... # type: int
ZLIB_VERSION = ... # type: str
Z_BEST_COMPRESSION = ... # type: int
Z_BEST_SPEED = ... # type: int
Z_DEFAULT_COMPRESSION = ... # type: int
Z_DEFAULT_STRATEGY = ... # type: int
Z_FILTERED = ... # type: int
Z_FINISH = ... # type: int
Z_FULL_FLUSH = ... # type: int
Z_HUFFMAN_ONLY = ... # type: int
Z_NO_FLUSH = ... # type: int
Z_SYNC_FLUSH = ... # type: int
class error(Exception): ...
class Compress:
def compress(self, data: str) -> str: ...
def flush(self) -> str: ...
def copy(self) -> "Compress": ...
class Decompress:
unused_data = ... # type: str
unconsumed_tail = ... # type: str
def decompress(self, data: str, max_length: int = ...) -> str: ...
def flush(self) -> str: ...
def copy(self) -> "Decompress": ...
def adler32(data: str, value: int = ...) -> int: ...
def compress(data: str, level: int = ...) -> str: ...
def compressobj(level: int = ..., method: int = ..., wbits: int = ...,
memlevel: int = ..., strategy: int = ...) -> Compress: ...
def crc32(data: str, value: int = ...) -> int: ...
def decompress(data: str, wbits: int = ..., bufsize: int = ...) -> str: ...
def decompressobj(wbits: int = ...) -> Decompress: ...
mypy-0.470/typeshed/stdlib/2/getpass.pyi 0000644 0000000 0000000 00000000300 13023631176 016653 0 ustar root root # Stubs for getpass (Python 2)
from typing import Any, IO
class GetPassWarning(UserWarning): ...
def getpass(prompt: str = ..., stream: IO[Any] = ...) -> str: ...
def getuser() -> str: ...
mypy-0.470/typeshed/stdlib/2/struct.pyi 0000644 0000000 0000000 00000001556 13035744274 016556 0 ustar root root # Stubs for struct for Python 2.7
# Based on https://docs.python.org/2/library/struct.html
from typing import Any, Tuple
class error(Exception): ...
def pack(fmt: str, *v: Any) -> str: ...
# TODO buffer type
def pack_into(fmt: str, buffer: Any, offset: int, *v: Any) -> None: ...
# TODO buffer type
def unpack(fmt: str, buffer: Any) -> Tuple[Any, ...]: ...
def unpack_from(fmt: str, buffer: Any, offset: int = ...) -> Tuple[Any, ...]: ...
def calcsize(fmt: str) -> int: ...
class Struct:
format = ... # type: str
size = ... # type: int
def __init__(self, format: str) -> None: ...
def pack(self, *v: Any) -> str: ...
# TODO buffer type
def pack_into(self, buffer: Any, offset: int, *v: Any) -> None: ...
def unpack(self, buffer: Any) -> Tuple[Any, ...]: ...
def unpack_from(self, buffer: Any, offset: int = ...) -> Tuple[Any, ...]: ...
mypy-0.470/typeshed/stdlib/2/difflib.pyi 0000644 0000000 0000000 00000005643 13023631176 016623 0 ustar root root # Stubs for difflib
# Based on https://docs.python.org/2.7/library/difflib.html
# TODO: Support unicode?
from typing import (
TypeVar, Callable, Iterable, Iterator, List, NamedTuple, Sequence, Tuple,
Generic, Optional
)
_T = TypeVar('_T')
class SequenceMatcher(Generic[_T]):
def __init__(self, isjunk: Optional[Callable[[_T], bool]] = ...,
a: Sequence[_T] = ..., b: Sequence[_T] = ...,
autojunk: bool = ...) -> None: ...
def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ...
def set_seq1(self, a: Sequence[_T]) -> None: ...
def set_seq2(self, b: Sequence[_T]) -> None: ...
def find_longest_match(self, alo: int, ahi: int, blo: int,
bhi: int) -> Tuple[int, int, int]: ...
def get_matching_blocks(self) -> List[Tuple[int, int, int]]: ...
def get_opcodes(self) -> List[Tuple[str, int, int, int, int]]: ...
def get_grouped_opcodes(self, n: int = ...
) -> Iterable[Tuple[str, int, int, int, int]]: ...
def ratio(self) -> float: ...
def quick_ratio(self) -> float: ...
def real_quick_ratio(self) -> float: ...
def get_close_matches(word: Sequence[_T], possibilities: List[Sequence[_T]],
n: int = ..., cutoff: float = ...) -> List[Sequence[_T]]: ...
class Differ:
def __init__(self, linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...) -> None: ...
def compare(self, a: Sequence[str], b: Sequence[str]) -> Iterator[str]: ...
def IS_LINE_JUNK(str) -> bool: ...
def IS_CHARACTER_JUNK(str) -> bool: ...
def unified_diff(a: Sequence[str], b: Sequence[str], fromfile: str = ...,
tofile: str = ..., fromfiledate: str = ..., tofiledate: str = ...,
n: int = ..., lineterm: str = ...) -> Iterator[str]: ...
def context_diff(a: Sequence[str], b: Sequence[str], fromfile: str=...,
tofile: str = ..., fromfiledate: str = ..., tofiledate: str = ...,
n: int = ..., lineterm: str = ...) -> Iterator[str]: ...
def ndiff(a: Sequence[str], b: Sequence[str],
linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...
) -> Iterator[str]: ...
class HtmlDiff(object):
def __init__(self, tabsize: int = ..., wrapcolumn: int = ...,
linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...
) -> None: ...
def make_file(self, fromlines: Sequence[str], tolines: Sequence[str],
fromdesc: str = ..., todesc: str = ..., context: bool = ...,
numlines: int = ...) -> str: ...
def make_table(self, fromlines: Sequence[str], tolines: Sequence[str],
fromdesc: str = ..., todesc: str = ..., context: bool = ...,
numlines: int = ...) -> str: ...
def restore(delta: Iterable[str], which: int) -> Iterator[int]: ...
mypy-0.470/typeshed/stdlib/2/hashlib.pyi 0000644 0000000 0000000 00000001512 13023631176 016625 0 ustar root root # Stubs for hashlib (Python 2)
from typing import Tuple
class _hash(object):
# This is not actually in the module namespace.
digest_size = 0
block_size = 0
def update(self, arg: str) -> None: ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def copy(self) -> _hash: ...
def new(name: str, data: str = ...) -> _hash: ...
def md5(s: str = ...) -> _hash: ...
def sha1(s: str = ...) -> _hash: ...
def sha224(s: str = ...) -> _hash: ...
def sha256(s: str = ...) -> _hash: ...
def sha384(s: str = ...) -> _hash: ...
def sha512(s: str = ...) -> _hash: ...
algorithms = ... # type: Tuple[str, ...]
algorithms_guaranteed = ... # type: Tuple[str, ...]
algorithms_available = ... # type: Tuple[str, ...]
def pbkdf2_hmac(name: str, password: str, salt: str, rounds: int, dklen: int = ...) -> str: ...
mypy-0.470/typeshed/stdlib/2/subprocess.pyi 0000644 0000000 0000000 00000007436 13035744274 017425 0 ustar root root # Stubs for subprocess
# Based on http://docs.python.org/2/library/subprocess.html and Python 3 stub
from typing import Sequence, Any, AnyStr, Mapping, Callable, Tuple, IO, Union, Optional
_FILE = Union[int, IO[Any]]
# Same args as Popen.__init__
def call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...) -> int: ...
def check_call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...) -> int: ...
# Same args as Popen.__init__ except for stdout
def check_output(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...) -> str: ...
PIPE = ... # type: int
STDOUT = ... # type: int
class CalledProcessError(Exception):
returncode = 0
cmd = ... # type: str
output = ... # type: str # May be None
def __init__(self, returncode: int, cmd: str, output: Optional[str] = ...) -> None: ...
class Popen:
stdin = ... # type: Optional[IO[Any]]
stdout = ... # type: Optional[IO[Any]]
stderr = ... # type: Optional[IO[Any]]
pid = 0
returncode = 0
def __init__(self,
args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: Optional[str] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[str] = ...,
env: Optional[Mapping[str, str]] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...) -> None: ...
def poll(self) -> int: ...
def wait(self) -> int: ...
def communicate(self, input: Optional[AnyStr] = ...) -> Tuple[Optional[bytes], Optional[bytes]]: ...
def send_signal(self, signal: int) -> None: ...
def terminate(self) -> None: ...
def kill(self) -> None: ...
def __enter__(self) -> 'Popen': ...
def __exit__(self, type, value, traceback) -> bool: ...
def getstatusoutput(cmd: str) -> Tuple[int, str]: ...
def getoutput(cmd: str) -> str: ...
# Windows-only: STARTUPINFO etc.
STD_INPUT_HANDLE = ... # type: Any
STD_OUTPUT_HANDLE = ... # type: Any
STD_ERROR_HANDLE = ... # type: Any
SW_HIDE = ... # type: Any
STARTF_USESTDHANDLES = ... # type: Any
STARTF_USESHOWWINDOW = ... # type: Any
CREATE_NEW_CONSOLE = ... # type: Any
CREATE_NEW_PROCESS_GROUP = ... # type: Any
mypy-0.470/typeshed/stdlib/2/binascii.pyi 0000644 0000000 0000000 00000001435 13023631176 017000 0 ustar root root """Stubs for the binascii module."""
def a2b_base64(string: str) -> str: ...
def a2b_hex(hexstr: str) -> str: ...
def a2b_hqx(string: str) -> str: ...
def a2b_qp(string: str, header: bool = ...) -> str: ...
def a2b_uu(string: str) -> str: ...
def b2a_base64(data: str) -> str: ...
def b2a_hex(data: str) -> str: ...
def b2a_hqx(data: str) -> str: ...
def b2a_qp(data: str, quotetabs: bool = ..., istext: bool = ..., header: bool = ...) -> str: ...
def b2a_uu(data: str) -> str: ...
def crc32(data: str, crc: int = None) -> int: ...
def crc_hqx(data: str, oldcrc: int) -> int: ...
def hexlify(data: str) -> str: ...
def rlecode_hqx(data: str) -> str: ...
def rledecode_hqx(data: str) -> str: ...
def unhexlify(hexstr: str) -> str: ...
class Error(Exception): ...
class Incomplete(Exception): ...
mypy-0.470/typeshed/stdlib/2/datetime.pyi 0000644 0000000 0000000 00000016627 13044257024 017023 0 ustar root root # Stubs for datetime
# NOTE: These are incomplete!
from time import struct_time
from typing import Optional, SupportsAbs, Tuple, Union, overload
MINYEAR = 0
MAXYEAR = 0
class tzinfo(object):
def tzname(self, dt: Optional[datetime]) -> str: ...
def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
def fromutc(self, dt: datetime) -> datetime: ...
_tzinfo = tzinfo
class date(object):
min = ... # type: date
max = ... # type: date
resolution = ... # type: timedelta
def __init__(self, year: int, month: int = ..., day: int = ...) -> None: ...
@classmethod
def fromtimestamp(cls, t: float) -> date: ...
@classmethod
def today(cls) -> date: ...
@classmethod
def fromordinal(cls, n: int) -> date: ...
@property
def year(self) -> int: ...
@property
def month(self) -> int: ...
@property
def day(self) -> int: ...
def ctime(self) -> str: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: Union[str, unicode]) -> str: ...
def isoformat(self) -> str: ...
def timetuple(self) -> struct_time: ...
def toordinal(self) -> int: ...
def replace(self, year: int = ..., month: int = ..., day: int = ...) -> date: ...
def __le__(self, other: date) -> bool: ...
def __lt__(self, other: date) -> bool: ...
def __ge__(self, other: date) -> bool: ...
def __gt__(self, other: date) -> bool: ...
def __add__(self, other: timedelta) -> date: ...
@overload
def __sub__(self, other: timedelta) -> date: ...
@overload
def __sub__(self, other: date) -> timedelta: ...
def __hash__(self) -> int: ...
def weekday(self) -> int: ...
def isoweekday(self) -> int: ...
def isocalendar(self) -> Tuple[int, int, int]: ...
class time:
min = ... # type: time
max = ... # type: time
resolution = ... # type: timedelta
def __init__(self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ...,
tzinfo: tzinfo = ...) -> None: ...
@property
def hour(self) -> int: ...
@property
def minute(self) -> int: ...
@property
def second(self) -> int: ...
@property
def microsecond(self) -> int: ...
@property
def tzinfo(self) -> _tzinfo: ...
def __le__(self, other: time) -> bool: ...
def __lt__(self, other: time) -> bool: ...
def __ge__(self, other: time) -> bool: ...
def __gt__(self, other: time) -> bool: ...
def __hash__(self) -> int: ...
def isoformat(self) -> str: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: str) -> str: ...
def utcoffset(self) -> Optional[timedelta]: ...
def tzname(self) -> Optional[str]: ...
def dst(self) -> Optional[int]: ...
def replace(self, hour: int = ..., minute: int = ..., second: int = ...,
microsecond: int = ..., tzinfo: Union[_tzinfo, bool] = ...) -> time: ...
_date = date
_time = time
class timedelta(SupportsAbs[timedelta]):
min = ... # type: timedelta
max = ... # type: timedelta
resolution = ... # type: timedelta
def __init__(self, days: float = ..., seconds: float = ..., microseconds: float = ...,
milliseconds: float = ..., minutes: float = ..., hours: float = ...,
weeks: float = ...) -> None: ...
@property
def days(self) -> int: ...
@property
def seconds(self) -> int: ...
@property
def microseconds(self) -> int: ...
def total_seconds(self) -> float: ...
def __add__(self, other: timedelta) -> timedelta: ...
def __radd__(self, other: timedelta) -> timedelta: ...
def __sub__(self, other: timedelta) -> timedelta: ...
def __rsub(self, other: timedelta) -> timedelta: ...
def __neg__(self) -> timedelta: ...
def __pos__(self) -> timedelta: ...
def __abs__(self) -> timedelta: ...
def __mul__(self, other: float) -> timedelta: ...
def __rmul__(self, other: float) -> timedelta: ...
@overload
def __floordiv__(self, other: timedelta) -> int: ...
@overload
def __floordiv__(self, other: int) -> timedelta: ...
@overload
def __truediv__(self, other: timedelta) -> float: ...
@overload
def __truediv__(self, other: float) -> timedelta: ...
def __mod__(self, other: timedelta) -> timedelta: ...
def __divmod__(self, other: timedelta) -> Tuple[int, timedelta]: ...
def __le__(self, other: timedelta) -> bool: ...
def __lt__(self, other: timedelta) -> bool: ...
def __ge__(self, other: timedelta) -> bool: ...
def __gt__(self, other: timedelta) -> bool: ...
def __hash__(self) -> int: ...
class datetime(object):
# TODO: is actually subclass of date, but __le__, __lt__, __ge__, __gt__ don't work with date.
min = ... # type: datetime
max = ... # type: datetime
resolution = ... # type: timedelta
def __init__(self, year: int, month: int = ..., day: int = ..., hour: int = ...,
minute: int = ..., second: int = ..., microseconds: int = ...,
tzinfo: tzinfo = ...) -> None: ...
@property
def year(self) -> int: ...
@property
def month(self) -> int: ...
@property
def day(self) -> int: ...
@property
def hour(self) -> int: ...
@property
def minute(self) -> int: ...
@property
def second(self) -> int: ...
@property
def microsecond(self) -> int: ...
@property
def tzinfo(self) -> _tzinfo: ...
@classmethod
def fromtimestamp(cls, t: float, tz: _tzinfo = ...) -> datetime: ...
@classmethod
def utcfromtimestamp(cls, t: float) -> datetime: ...
@classmethod
def today(cls) -> datetime: ...
@classmethod
def fromordinal(cls, n: int) -> datetime: ...
@classmethod
def now(cls, tz: _tzinfo = ...) -> datetime: ...
@classmethod
def utcnow(cls) -> datetime: ...
@classmethod
def combine(cls, date: date, time: time) -> datetime: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: str) -> str: ...
def toordinal(self) -> int: ...
def timetuple(self) -> struct_time: ...
def timestamp(self) -> float: ...
def utctimetuple(self) -> struct_time: ...
def date(self) -> _date: ...
def time(self) -> _time: ...
def timetz(self) -> _time: ...
def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int = ...,
minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo:
Union[_tzinfo, bool] = ...) -> datetime: ...
def astimezone(self, tz: _tzinfo = ...) -> datetime: ...
def ctime(self) -> str: ...
def isoformat(self, sep: str = ...) -> str: ...
@classmethod
def strptime(cls, date_string: str, format: str) -> datetime: ...
def utcoffset(self) -> Optional[timedelta]: ...
def tzname(self) -> Optional[str]: ...
def dst(self) -> Optional[int]: ...
def __le__(self, other: datetime) -> bool: ...
def __lt__(self, other: datetime) -> bool: ...
def __ge__(self, other: datetime) -> bool: ...
def __gt__(self, other: datetime) -> bool: ...
def __add__(self, other: timedelta) -> datetime: ...
@overload
def __sub__(self, other: datetime) -> timedelta: ...
@overload
def __sub__(self, other: timedelta) -> datetime: ...
def __hash__(self) -> int: ...
def weekday(self) -> int: ...
def isoweekday(self) -> int: ...
def isocalendar(self) -> Tuple[int, int, int]: ...
mypy-0.470/typeshed/stdlib/2/quopri.pyi 0000644 0000000 0000000 00000000435 13023631176 016535 0 ustar root root # Stubs for quopri (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def encode(input, output, quotetabs, header=0): ...
def encodestring(s, quotetabs=0, header=0): ...
def decode(input, output, header=0): ...
def decodestring(s, header=0): ...
mypy-0.470/typeshed/stdlib/2/tempfile.pyi 0000644 0000000 0000000 00000006557 13035744274 017045 0 ustar root root # Stubs for tempfile
# Ron Murawski
# based on http: //docs.python.org/3.3/library/tempfile.html
# Adapted for Python 2.7 by Michal Pokorny
# TODO: Don't use basestring. Use Union[str, bytes] or AnyStr for arguments.
# Avoid using Union[str, bytes] for return values, as it implies that
# an isinstance() check will often be required, which is inconvenient.
from typing import Tuple, IO, Union, AnyStr, Any, overload, Iterator, List, Type, Optional
import thread
import random
TMP_MAX = ... # type: int
tempdir = ... # type: str
template = ... # type: str
_name_sequence = ... # type: Optional[_RandomNameSequence]
class _RandomNameSequence:
_rng = ... # type: random.Random
_rng_pid = ... # type: int
characters = ... # type: str
mutex = ... # type: thread.LockType
rng = ... # type: random.Random
def __iter__(self) -> "_RandomNameSequence": ...
def next(self) -> str: ...
# from os.path:
def normcase(self, path: AnyStr) -> AnyStr: ...
class _TemporaryFileWrapper(IO[str]):
close_called = ... # type: bool
delete = ... # type: bool
file = ... # type: IO
name = ... # type: Any
def __init__(self, file: IO, name, delete: bool = ...) -> None: ...
def __del__(self) -> None: ...
def __enter__(self) -> "_TemporaryFileWrapper": ...
def __exit__(self, exc, value, tb) -> bool: ...
def __getattr__(self, name: unicode) -> Any: ...
def close(self) -> None: ...
def unlink(self, path: unicode) -> None: ...
# TODO text files
def TemporaryFile(
mode: Union[bytes, unicode] = ...,
bufsize: int = ...,
suffix: Union[bytes, unicode] = ...,
prefix: Union[bytes, unicode] = ...,
dir: Union[bytes, unicode] = ...
) -> _TemporaryFileWrapper:
...
def NamedTemporaryFile(
mode: Union[bytes, unicode] = ...,
bufsize: int = ...,
suffix: Union[bytes, unicode] = ...,
prefix: Union[bytes, unicode] = ...,
dir: Union[bytes, unicode] = ...,
delete: bool = ...
) -> _TemporaryFileWrapper:
...
def SpooledTemporaryFile(
max_size: int = ...,
mode: Union[bytes, unicode] = ...,
buffering: int = ...,
suffix: Union[bytes, unicode] = ...,
prefix: Union[bytes, unicode] = ...,
dir: Union[bytes, unicode] = ...
) -> _TemporaryFileWrapper:
...
class TemporaryDirectory:
name = ... # type: Any # Can be str or unicode
def __init__(self,
suffix: Union[bytes, unicode] = ...,
prefix: Union[bytes, unicode] = ...,
dir: Union[bytes, unicode] = ...) -> None: ...
def cleanup(self) -> None: ...
def __enter__(self) -> Any: ... # Can be str or unicode
def __exit__(self, type, value, traceback) -> bool: ...
@overload
def mkstemp() -> Tuple[int, str]: ...
@overload
def mkstemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: AnyStr = ...,
text: bool = ...) -> Tuple[int, AnyStr]: ...
@overload
def mkdtemp() -> str: ...
@overload
def mkdtemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: AnyStr = ...) -> AnyStr: ...
@overload
def mktemp() -> str: ...
@overload
def mktemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: AnyStr = ...) -> AnyStr: ...
def gettempdir() -> str: ...
def gettempprefix() -> str: ...
def _candidate_tempdir_list() -> List[str]: ...
def _get_candidate_names() -> Optional[_RandomNameSequence]: ...
def _get_default_tempdir() -> str: ...
mypy-0.470/typeshed/stdlib/2/re.pyi 0000644 0000000 0000000 00000007073 13035744274 015640 0 ustar root root # Stubs for re
# Ron Murawski
# 'bytes' support added by Jukka Lehtosalo
# based on: http: //docs.python.org/2.7/library/re.html
from typing import (
List, Iterator, overload, Callable, Tuple, Sequence, Dict,
Generic, AnyStr, Match, Pattern, Any, Union
)
# ----- re variables and constants -----
DEBUG = 0
I = 0
IGNORECASE = 0
L = 0
LOCALE = 0
M = 0
MULTILINE = 0
S = 0
DOTALL = 0
X = 0
VERBOSE = 0
U = 0
UNICODE = 0
T = 0
TEMPLATE = 0
class error(Exception): ...
@overload
def compile(pattern: AnyStr, flags: int = ...) -> Pattern[AnyStr]: ...
@overload
def compile(pattern: Pattern[AnyStr], flags: int = ...) -> Pattern[AnyStr]: ...
@overload
def search(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def search(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def match(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def match(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def split(pattern: Union[str, unicode], string: AnyStr,
maxsplit: int = ..., flags: int = ...) -> List[AnyStr]: ...
@overload
def split(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr,
maxsplit: int = ..., flags: int = ...) -> List[AnyStr]: ...
@overload
def findall(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> List[Any]: ...
@overload
def findall(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> List[Any]: ...
# Return an iterator yielding match objects over all non-overlapping matches
# for the RE pattern in string. The string is scanned left-to-right, and
# matches are returned in the order found. Empty matches are included in the
# result unless they touch the beginning of another match.
@overload
def finditer(pattern: Union[str, unicode], string: AnyStr,
flags: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def finditer(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr,
flags: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def sub(pattern: Union[str, unicode], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: Union[str, unicode], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ..., flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: Union[Pattern[str], Pattern[unicode]], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: Union[Pattern[str], Pattern[unicode]], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ..., flags: int = ...) -> AnyStr: ...
@overload
def subn(pattern: Union[str, unicode], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: Union[str, unicode], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: Union[Pattern[str], Pattern[unicode]], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: Union[Pattern[str], Pattern[unicode]], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
def escape(string: AnyStr) -> AnyStr: ...
def purge() -> None: ...
mypy-0.470/typeshed/stdlib/2/signal.pyi 0000644 0000000 0000000 00000003452 13023631176 016475 0 ustar root root from typing import Callable, Any, Tuple, Union
from types import FrameType
SIG_DFL = ... # type: int
SIG_IGN = ... # type: int
ITIMER_REAL = ... # type: int
ITIMER_VIRTUAL = ... # type: int
ITIMER_PROF = ... # type: int
SIGABRT = ... # type: int
SIGALRM = ... # type: int
SIGBUS = ... # type: int
SIGCHLD = ... # type: int
SIGCLD = ... # type: int
SIGCONT = ... # type: int
SIGFPE = ... # type: int
SIGHUP = ... # type: int
SIGILL = ... # type: int
SIGINT = ... # type: int
SIGIO = ... # type: int
SIGIOT = ... # type: int
SIGKILL = ... # type: int
SIGPIPE = ... # type: int
SIGPOLL = ... # type: int
SIGPROF = ... # type: int
SIGPWR = ... # type: int
SIGQUIT = ... # type: int
SIGRTMAX = ... # type: int
SIGRTMIN = ... # type: int
SIGSEGV = ... # type: int
SIGSTOP = ... # type: int
SIGSYS = ... # type: int
SIGTERM = ... # type: int
SIGTRAP = ... # type: int
SIGTSTP = ... # type: int
SIGTTIN = ... # type: int
SIGTTOU = ... # type: int
SIGURG = ... # type: int
SIGUSR1 = ... # type: int
SIGUSR2 = ... # type: int
SIGVTALRM = ... # type: int
SIGWINCH = ... # type: int
SIGXCPU = ... # type: int
SIGXFSZ = ... # type: int
NSIG = ... # type: int
class ItimerError(IOError): ...
_HANDLER = Union[Callable[[int, FrameType], None], int, None]
def alarm(time: int) -> int: ...
def getsignal(signalnum: int) -> _HANDLER: ...
def pause() -> None: ...
def setitimer(which: int, seconds: float, interval: float = ...) -> Tuple[float, float]: ...
def getitimer(which: int) -> Tuple[float, float]: ...
def set_wakeup_fd(fd: int) -> int: ...
def siginterrupt(signalnum: int, flag: bool) -> None:
raise RuntimeError()
def signal(signalnum: int, handler: _HANDLER) -> _HANDLER:
raise RuntimeError()
def default_int_handler(signum: int, frame: FrameType) -> None:
raise KeyboardInterrupt()
mypy-0.470/typeshed/stdlib/2/sha.pyi 0000644 0000000 0000000 00000000423 13035744274 015775 0 ustar root root # Stubs for Python 2.7 sha stdlib module
class sha(object):
def update(self, arg: str) -> None: ...
def digest(self) -> str: ...
def hexdigest(self) -> str: ...
def copy(self) -> sha: ...
def new(string: str = ...) -> sha: ...
blocksize = 0
digest_size = 0
mypy-0.470/typeshed/stdlib/2/markupbase.pyi 0000644 0000000 0000000 00000000410 13023631176 017341 0 ustar root root from typing import Tuple
class ParserBase(object):
def __init__(self) -> None: ...
def error(self, message: str) -> None: ...
def reset(self) -> None: ...
def getpos(self) -> Tuple[int, int]: ...
def unkown_decl(self, data: str) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/ 0000755 0000000 0000000 00000000000 13044320557 015240 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/traceback.pyi 0000644 0000000 0000000 00000011322 13035744274 017707 0 ustar root root # Stubs for traceback
from typing import Generator, IO, Iterator, List, Mapping, Optional, Tuple, Type
from types import FrameType, TracebackType
import sys
_PT = Tuple[str, int, str, Optional[str]]
def print_tb(tb: TracebackType, limit: Optional[int] = ...,
file: Optional[IO[str]] = ...) -> None: ...
if sys.version_info >= (3,):
def print_exception(etype: Type[BaseException], value: BaseException,
tb: Optional[TracebackType], limit: Optional[int] = ...,
file: Optional[IO[str]] = ...,
chain: bool = ...) -> None: ...
def print_exc(limit: Optional[int] = ..., file: Optional[IO[str]] = ...,
chain: bool = ...) -> None: ...
def print_last(limit: Optional[int] = ..., file: Optional[IO[str]] = ...,
chain: bool = ...) -> None: ...
else:
def print_exception(etype: Type[BaseException], value: BaseException,
tb: Optional[TracebackType], limit: Optional[int] = ...,
file: Optional[IO[str]] = ...) -> None: ...
def print_exc(limit: Optional[int] = ...,
file: Optional[IO[str]] = ...) -> None: ...
def print_last(limit: Optional[int] = ...,
file: Optional[IO[str]] = ...) -> None: ...
def print_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...,
file: Optional[IO[str]] = ...) -> None: ...
def extract_tb(tb: TracebackType, limit: Optional[int] = ...) -> List[_PT]: ...
def extract_stack(f: Optional[FrameType] = ...,
limit: Optional[int] = ...) -> List[_PT]: ...
def format_list(extracted_list: List[_PT]) -> List[str]: ...
def format_exception_only(etype: Type[BaseException],
value: BaseException) -> List[str]: ...
if sys.version_info >= (3,):
def format_exception(etype: Type[BaseException], value: BaseException,
tb: TracebackType, limit: Optional[int] = ...,
chain: bool = ...) -> List[str]: ...
def format_exc(limit: Optional[int] = ..., chain: bool = ...) -> str: ...
else:
def format_exception(etype: Type[BaseException], value: BaseException,
tb: TracebackType,
limit: Optional[int] = ...) -> List[str]: ...
def format_exc(limit: Optional[int] = ...) -> str: ...
def format_tb(tb: TracebackType, limit: Optional[int] = ...) -> List[str]: ...
def format_stack(f: Optional[FrameType] = ...,
limit: Optional[int] = ...) -> List[str]: ...
if sys.version_info >= (3, 4):
def clear_frames(tb: TracebackType) -> None: ...
if sys.version_info >= (3, 5):
def walk_stack(f: Optional[FrameType]) -> Iterator[Tuple[FrameType, int]]: ...
def walk_tb(tb: TracebackType) -> Iterator[Tuple[FrameType, int]]: ...
if sys.version_info < (3,):
def tb_lineno(tb: TracebackType) -> int: ...
if sys.version_info >= (3, 5):
class TracebackException:
__cause__ = ... # type:TracebackException
__context__ = ... # type:TracebackException
__suppress_context__ = ... # type: bool
stack = ... # type: StackSummary
exc_type = ... # type: Type[BaseException]
filename = ... # type: str
lineno = ... # type: int
text = ... # type: str
offset = ... # type: int
msg = ... # type: str
def __init__(self, exc_type: Type[BaseException],
exc_value: BaseException, exc_traceback: TracebackType,
*, limit: Optional[int] = ..., lookup_lines: bool = ...,
capture_locals: bool = ...) -> None: ...
@classmethod
def from_exception(cls, exc: BaseException,
*, limit: Optional[int] = ...,
lookup_lines: bool = ...,
capture_locals: bool = ...) -> TracebackException: ...
def format(self, *, chain: bool = ...) -> Generator[str, None, None]: ...
def format_exception_only(self) -> Generator[str, None, None]: ...
if sys.version_info >= (3, 5):
class StackSummary:
@classmethod
def extract(cls,
frame_gen: Generator[Tuple[FrameType, int], None, None],
*, limit: Optional[int] = ..., lookup_lines: bool = ...,
capture_locals: bool = ...) -> StackSummary: ...
@classmethod
def from_list(cls, a_list: List[_PT]) -> StackSummary: ...
if sys.version_info >= (3, 5):
class FrameSummary:
def __init__(self, filename: str, lineno: int, name: str,
lookup_line: bool = ...,
locals: Optional[Mapping[str, str]] = ...,
line: Optional[int] = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/math.pyi 0000644 0000000 0000000 00000004202 13035744274 016720 0 ustar root root # Stubs for math
# See: http://docs.python.org/2/library/math.html
from typing import Tuple, Iterable, Optional
import sys
e = ... # type: float
pi = ... # type: float
if sys.version_info >= (3, 5):
inf = ... # type: float
nan = ... # type: float
if sys.version_info >= (3, 6):
tau = ... # type: float
def acos(x: float) -> float: ...
def acosh(x: float) -> float: ...
def asin(x: float) -> float: ...
def asinh(x: float) -> float: ...
def atan(x: float) -> float: ...
def atan2(y: float, x: float) -> float: ...
def atanh(x: float) -> float: ...
def ceil(x: float) -> int: ...
def copysign(x: float, y: float) -> float: ...
def cos(x: float) -> float: ...
def cosh(x: float) -> float: ...
def degrees(x: float) -> float: ...
def erf(x: float) -> float: ...
def erfc(x: float) -> float: ...
def exp(x: float) -> float: ...
def expm1(x: float) -> float: ...
def fabs(x: float) -> float: ...
def factorial(x: int) -> int: ...
if sys.version_info >= (3,):
def floor(x: float) -> int: ...
else:
def floor(x: float) -> float: ...
def fmod(x: float, y: float) -> float: ...
def frexp(x: float) -> Tuple[float, int]: ...
def fsum(iterable: Iterable) -> float: ...
def gamma(x: float) -> float: ...
if sys.version_info >= (3, 5):
def gcd(a: int, b: int) -> int: ...
def hypot(x: float, y: float) -> float: ...
if sys.version_info >= (3, 5):
def isclose(a: float, b: float, rel_tol: float = ..., abs_tol: float = ...) -> bool: ...
def isinf(x: float) -> bool: ...
if sys.version_info >= (3,):
def isfinite(x: float) -> bool: ...
def isnan(x: float) -> bool: ...
def ldexp(x: float, i: int) -> float: ...
def lgamma(x: float) -> float: ...
def log(x: float, base: float = ...) -> float: ...
def log10(x: float) -> float: ...
def log1p(x: float) -> float: ...
if sys.version_info >= (3, 3):
def log2(x: float) -> float: ...
def modf(x: float) -> Tuple[float, float]: ...
def pow(x: float, y: float) -> float: ...
def radians(x: float) -> float: ...
def sin(x: float) -> float: ...
def sinh(x: float) -> float: ...
def sqrt(x: float) -> float: ...
def tan(x: float) -> float: ...
def tanh(x: float) -> float: ...
def trunc(x: float) -> int: ...
mypy-0.470/typeshed/stdlib/2and3/profile.pyi 0000644 0000000 0000000 00000002116 13035744274 017431 0 ustar root root from typing import Any, Callable, Dict, Optional, TypeVar
def run(statement: str, filename: Optional[str] = ..., sort: int = ...) -> None: ...
def runctx(statement: str, globals: Dict[str, Any], locals: Dict[str, Any], filename: Optional[str] = ..., sort: int = ...) -> None: ...
_SelfT = TypeVar('_SelfT', bound='Profile')
_T = TypeVar('_T')
class Profile:
def __init__(self, timer: Optional[Callable[[], float]] = ..., bias: Optional[int] = ...) -> None: ...
def set_cmd(self, cmd: str) -> None: ...
def simulate_call(self, name: str) -> None: ...
def simulate_cmd_complete(self) -> None: ...
def print_stats(self, sort: int = ...) -> None: ...
def dump_stats(self, file: str) -> None: ...
def create_stats(self) -> None: ...
def snapshot_stats(self) -> None: ...
def run(self: _SelfT, cmd: str) -> _SelfT: ...
def runctx(self: _SelfT, cmd: str, globals: Dict[str, Any], locals: Dict[str, Any]) -> _SelfT: ...
def runcall(self, func: Callable[..., _T], *args: Any, **kw: Any) -> _T: ...
def calibrate(self, m: int, verbose: int = ...) -> float: ...
mypy-0.470/typeshed/stdlib/2and3/logging/ 0000755 0000000 0000000 00000000000 13044320557 016666 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/logging/__init__.pyi 0000644 0000000 0000000 00000042052 13044257024 021151 0 ustar root root # Stubs for logging (Python 3.4)
from typing import (
Any, Callable, Dict, Iterable, Mapping, MutableMapping, Optional, IO,
Tuple, Text, Union, overload,
)
from string import Template
from time import struct_time
from types import TracebackType
import sys
import threading
_SysExcInfoType = Union[Tuple[type, BaseException, TracebackType],
Tuple[None, None, None]]
if sys.version_info >= (3, 5):
_ExcInfoType = Union[bool, _SysExcInfoType, Exception]
else:
_ExcInfoType = Union[bool, _SysExcInfoType]
_ArgsType = Union[Tuple[Any, ...], Dict[str, Any]]
_FilterType = Union['Filter', Callable[['LogRecord'], int]]
class Logger:
name = ... # type: str
level = ... # type: int
parent = ... # type: Union[Logger, PlaceHolder]
propagate = ... # type: bool
handlers = ... # type: List[Handler]
disabled = ... # type: int
def setLevel(self, lvl: Union[int, str]) -> None: ...
def isEnabledFor(self, lvl: int) -> bool: ...
def getEffectiveLevel(self) -> int: ...
def getChild(self, suffix: str) -> 'Logger': ...
if sys.version_info > (3,):
def debug(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def info(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def warning(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def warn(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def error(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def critical(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def log(self, lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def exception(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
else:
def debug(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def info(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def warning(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def warn(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def error(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def critical(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def log(self,
lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def exception(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def addFilter(self, filt: _FilterType) -> None: ...
def removeFilter(self, filt: _FilterType) -> None: ...
def filter(self, record: 'LogRecord') -> bool: ...
def addHandler(self, hdlr: 'Handler') -> None: ...
def removeHandler(self, hdlr: 'Handler') -> None: ...
if sys.version_info >= (3,):
def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ...
else:
def findCaller(self) -> Tuple[str, int, str]: ...
def handle(self, record: 'LogRecord') -> None: ...
if sys.version_info >= (3,):
def makeRecord(self, name: str, lvl: int, fn: str, lno: int, msg: Text,
args: Mapping[str, Any],
exc_info: Optional[_SysExcInfoType],
func: Optional[str] = ...,
extra: Optional[Mapping[str, Any]] = ...,
sinfo: Optional[str] = ...) -> None: ...
else:
def makeRecord(self,
name: str, lvl: int, fn: str, lno: int, msg: Text,
args: Mapping[str, Any],
exc_info: Optional[_SysExcInfoType],
func: Optional[str] = ...,
extra: Optional[Mapping[str, Any]] = ...) -> None: ...
if sys.version_info >= (3,):
def hasHandlers(self) -> bool: ...
CRITICAL = ... # type: int
ERROR = ... # type: int
WARNING = ... # type: int
WARN = ... # type: int
INFO = ... # type: int
DEBUG = ... # type: int
NOTSET = ... # type: int
class Filterer(object):
filters = ... # type: List[Filter]
def __init__(self) -> None: ...
def addFilter(self, filter: Filter) -> None: ...
def removeFilter(self, filter: Filter) -> None: ...
def filter(self, record) -> bool: ...
class Handler(Filterer):
level = ... # type: int
formatter = ... # type: Optional[Formatter]
lock = ... # type: Optional[threading.Lock]
def __init__(self, level: int = ...) -> None: ...
def createLock(self) -> None: ...
def acquire(self) -> None: ...
def release(self) -> None: ...
def setLevel(self, lvl: Union[int, str]) -> None: ...
def setFormatter(self, form: 'Formatter') -> None: ...
def addFilter(self, filt: _FilterType) -> None: ...
def removeFilter(self, filt: _FilterType) -> None: ...
def filter(self, record: 'LogRecord') -> bool: ...
def flush(self) -> None: ...
def close(self) -> None: ...
def handle(self, record: 'LogRecord') -> None: ...
def handleError(self, record: 'LogRecord') -> None: ...
def format(self, record: 'LogRecord') -> None: ...
def emit(self, record: 'LogRecord') -> None: ...
class Formatter:
converter = ... # type: Callable[[Optional[float]], struct_time]
_fmt = ... # type: Optional[str]
datefmt = ... # type: Optional[str]
if sys.version_info >= (3,):
_style = ... # type: PercentStyle
default_time_format = ... # type: str
default_msec_format = ... # type: str
if sys.version_info >= (3,):
def __init__(self, fmt: Optional[str] = ...,
datefmt: Optional[str] =...,
style: str = ...) -> None: ...
else:
def __init__(self,
fmt: Optional[str] = ...,
datefmt: Optional[str] =...) -> None: ...
def format(self, record: 'LogRecord') -> str: ...
def formatTime(self, record: 'LogRecord', datefmt: str = ...) -> str: ...
def formatException(self, exc_info: _SysExcInfoType) -> str: ...
if sys.version_info >= (3,):
def formatStack(self, stack_info: str) -> str: ...
class Filter:
def __init__(self, name: str = ...) -> None: ...
def filter(self, record: 'LogRecord') -> int: ...
class LogRecord:
args = ... # type: _ArgsType
asctime = ... # type: str
created = ... # type: int
exc_info = ... # type: Optional[_SysExcInfoType]
filename = ... # type: str
funcName = ... # type: str
levelname = ... # type: str
levelno = ... # type: int
lineno = ... # type: int
module = ... # type: str
msecs = ... # type: int
message = ... # type: str
msg = ... # type: str
name = ... # type: str
pathname = ... # type: str
process = ... # type: int
processName = ... # type: str
relativeCreated = ... # type: int
if sys.version_info >= (3,):
stack_info = ... # type: Optional[str]
thread = ... # type: int
threadName = ... # type: str
if sys.version_info >= (3,):
def __init__(self, name: str, level: int, pathname: str, lineno: int,
msg: Text, args: _ArgsType,
exc_info: Optional[_SysExcInfoType],
func: Optional[str] = ...,
sinfo: Optional[str] = ...) -> None: ...
else:
def __init__(self,
name: str, level: int, pathname: str, lineno: int,
msg: Text, args: _ArgsType,
exc_info: Optional[_SysExcInfoType],
func: Optional[str] = ...) -> None: ...
def getMessage(self) -> str: ...
class LoggerAdapter:
def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ...
def process(self, msg: Text, kwargs: MutableMapping[str, Any]) -> Tuple[str, MutableMapping[str, Any]]: ...
if sys.version_info > (3,):
def debug(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def info(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def warning(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def error(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def exception(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def critical(self, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def log(self, lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
else:
def debug(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def info(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def warning(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def error(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def exception(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def critical(self,
msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def log(self,
lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def isEnabledFor(self, lvl: int) -> bool: ...
if sys.version_info >= (3,):
def getEffectiveLevel(self) -> int: ...
def setLevel(self, lvl: Union[int, str]) -> None: ...
def hasHandlers(self) -> bool: ...
if sys.version_info >= (3,):
def getLogger(name: Optional[str] = ...) -> Logger: ...
else:
@overload
def getLogger() -> Logger: ...
@overload
def getLogger(name: str) -> Logger: ...
def getLoggerClass() -> type: ...
if sys.version_info >= (3,):
def getLogRecordFactory() -> Callable[..., LogRecord]: ...
if sys.version_info > (3,):
def debug(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def info(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def warning(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def warn(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def error(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def critical(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def exception(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
def log(lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
stack_info: bool = ..., extra: Dict[str, Any] = ...,
**kwargs: Any) -> None: ...
else:
def debug(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def info(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def warning(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def warn(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def error(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def critical(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def exception(msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def log(lvl: int, msg: Text, *args: Any, exc_info: _ExcInfoType = ...,
extra: Dict[str, Any] = ..., **kwargs: Any) -> None: ...
def disable(lvl: int) -> None: ...
def addLevelName(lvl: int, levelName: str) -> None: ...
def getLevelName(lvl: int) -> str: ...
def makeLogRecord(attrdict: Mapping[str, Any]) -> LogRecord: ...
if sys.version_info >= (3,):
def basicConfig(*, filename: str = ..., filemode: str = ...,
format: str = ..., datefmt: str = ..., style: str = ...,
level: int = ..., stream: IO[str] = ...,
handlers: Iterable[Handler] = ...) -> None: ...
else:
@overload
def basicConfig() -> None: ...
@overload
def basicConfig(*, filename: str = ..., filemode: str = ...,
format: str = ..., datefmt: str = ...,
level: int = ..., stream: IO[str] = ...) -> None: ...
def shutdown() -> None: ...
def setLoggerClass(klass: type) -> None: ...
if sys.version_info >= (3,):
def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ...
if sys.version_info >= (3,):
lastResort = ... # type: Optional['StreamHandler']
class StreamHandler(Handler):
def __init__(self, stream: Optional[IO[str]] = ...) -> None: ...
class FileHandler(Handler):
def __init__(self, filename: str, mode: str = ...,
encoding: Optional[str] = ..., delay: bool = ...) -> None: ...
class NullHandler(Handler): ...
class PlaceHolder:
def __init__(self, alogger: Logger) -> None: ...
def append(self, alogger: Logger) -> None: ...
# Below aren't in module docs but still visible
class RootLogger(Logger): ...
root = ... # type: RootLogger
if sys.version_info >= (3,):
class PercentStyle(object):
default_format = ... # type: str
asctime_format = ... # type: str
asctime_search = ... # type: str
_fmt = ... # type: str
def __init__(self, fmt) -> None: ...
def usesTime(self) -> bool: ...
def format(self, record: Any) -> str: ...
class StrFormatStyle(PercentStyle):
...
class StringTemplateStyle(PercentStyle):
_tpl = ... # type: Template
BASIC_FORMAT = ... # type: str
_STYLES = ... # type: Dict[str, Tuple[PercentStyle, str]]
mypy-0.470/typeshed/stdlib/2and3/logging/handlers.pyi 0000644 0000000 0000000 00000017356 13035744274 021233 0 ustar root root # Stubs for logging.handlers (Python 2.4)
import datetime
from logging import Handler, FileHandler, LogRecord
from socket import SocketType
import ssl
import sys
from typing import Any, Callable, Dict, List, Optional, Tuple, Union, overload
if sys.version_info >= (3,):
from queue import Queue
else:
from Queue import Queue
# TODO update socket stubs to add SocketKind
SocketKind = int
class WatchedFileHandler(Handler):
@overload
def __init__(self, filename: str) -> None: ...
@overload
def __init__(self, filename: str, mode: str) -> None: ...
@overload
def __init__(self, filename: str, mode: str,
encoding: Optional[str]) -> None: ...
@overload
def __init__(self, filename: str, mode: str, encoding: Optional[str],
delay: bool) -> None: ...
if sys.version_info >= (3,):
class BaseRotatingHandler(FileHandler):
namer = ... # type: Optional[Callable[[str], None]]
rotator = ... # type: Optional[Callable[[str, str], None]]
def __init__(self, filename: str, mode: str,
encoding: Optional[str] = ...,
delay: bool = ...) -> None: ...
def rotation_filename(self, default_name: str) -> None: ...
def rotate(self, source: str, dest: str) -> None: ...
if sys.version_info >= (3,):
class RotatingFileHandler(BaseRotatingHandler):
def __init__(self, filename: str, mode: str = ..., maxBytes: int = ...,
backupCount: int = ..., encoding: Optional[str] = ...,
delay: bool = ...) -> None: ...
def doRollover(self) -> None: ...
else:
class RotatingFileHandler(Handler):
def __init__(self, filename: str, mode: str = ..., maxBytes: int = ...,
backupCount: int = ..., encoding: Optional[str] = ...,
delay: bool = ...) -> None: ...
def doRollover(self) -> None: ...
if sys.version_info >= (3,):
class TimedRotatingFileHandler(BaseRotatingHandler):
if sys.version_info >= (3, 4):
def __init__(self, filename: str, when: str = ...,
interval: int = ...,
backupCount: int = ..., encoding: Optional[str] = ...,
delay: bool = ..., utc: bool = ...,
atTime: Optional[datetime.datetime] = ...) -> None: ...
else:
def __init__(self,
filename: str, when: str = ..., interval: int = ...,
backupCount: int = ..., encoding: Optional[str] = ...,
delay: bool = ..., utc: bool = ...) -> None: ...
def doRollover(self) -> None: ...
else:
class TimedRotatingFileHandler:
def __init__(self,
filename: str, when: str = ..., interval: int = ...,
backupCount: int = ..., encoding: Optional[str] = ...,
delay: bool = ..., utc: bool = ...) -> None: ...
def doRollover(self) -> None: ...
class SocketHandler(Handler):
retryStart = ... # type: float
retryFactor = ... # type: float
retryMax = ... # type: float
if sys.version_info >= (3, 4):
def __init__(self, host: str, port: Optional[int]) -> None: ...
else:
def __init__(self, host: str, port: int) -> None: ...
def makeSocket(self) -> SocketType: ...
def makePickle(self, record: LogRecord) -> bytes: ...
def send(self, packet: bytes) -> None: ...
def createSocket(self) -> None: ...
class DatagramHandler(SocketHandler): ...
class SysLogHandler(Handler):
LOG_ALERT = ... # type: int
LOG_CRIT = ... # type: int
LOG_DEBUG = ... # type: int
LOG_EMERG = ... # type: int
LOG_ERR = ... # type: int
LOG_INFO = ... # type: int
LOG_NOTICE = ... # type: int
LOG_WARNING = ... # type: int
LOG_AUTH = ... # type: int
LOG_AUTHPRIV = ... # type: int
LOG_CRON = ... # type: int
LOG_DAEMON = ... # type: int
LOG_FTP = ... # type: int
LOG_KERN = ... # type: int
LOG_LPR = ... # type: int
LOG_MAIL = ... # type: int
LOG_NEWS = ... # type: int
LOG_SYSLOG = ... # type: int
LOG_USER = ... # type: int
LOG_UUCP = ... # type: int
LOG_LOCAL0 = ... # type: int
LOG_LOCAL1 = ... # type: int
LOG_LOCAL2 = ... # type: int
LOG_LOCAL3 = ... # type: int
LOG_LOCAL4 = ... # type: int
LOG_LOCAL5 = ... # type: int
LOG_LOCAL6 = ... # type: int
LOG_LOCAL7 = ... # type: int
def __init__(self, address: Union[Tuple[str, int], str] = ...,
facility: int = ..., socktype: SocketKind = ...) -> None: ...
def encodePriority(self, facility: Union[int, str],
priority: Union[int, str]) -> int: ...
def mapPriority(self, levelName: int) -> str: ...
class NTEventLogHandler(Handler):
def __init__(self, appname: str, dllname: str = ...,
logtype: str = ...) -> None: ...
def getEventCategory(self, record: LogRecord) -> int: ...
# TODO correct return value?
def getEventType(self, record: LogRecord) -> int: ...
def getMessageID(self, record: LogRecord) -> int: ...
class SMTPHandler(Handler):
# TODO `secure` can also be an empty tuple
if sys.version_info >= (3,):
def __init__(self, mailhost: Union[str, Tuple[str, int]], fromaddr: str,
toaddrs: List[str], subject: str,
credentials: Optional[Tuple[str, str]] = ...,
secure: Union[Tuple[str], Tuple[str, str], None] =...,
timeout: float = ...) -> None: ...
else:
def __init__(self,
mailhost: Union[str, Tuple[str, int]], fromaddr: str,
toaddrs: List[str], subject: str,
credentials: Optional[Tuple[str, str]] = ...,
secure: Union[Tuple[str], Tuple[str, str], None] =...) -> None: ...
def getSubject(self, record: LogRecord) -> str: ...
class BufferingHandler(Handler):
def __init__(self, capacity: int) -> None: ...
def shouldFlush(self, record: LogRecord) -> bool: ...
class MemoryHandler(BufferingHandler):
def __init__(self, capacity: int, flushLevel: int = ...,
target: Optional[Handler] =...) -> None: ...
def setTarget(self, target: Handler) -> None: ...
class HTTPHandler(Handler):
if sys.version_info >= (3, 5):
def __init__(self, host: str, url: str, method: str = ...,
secure: bool = ...,
credentials: Optional[Tuple[str, str]] = ...,
context: Optional[ssl.SSLContext] = ...) -> None: ...
elif sys.version_info >= (3,):
def __init__(self,
host: str, url: str, method: str = ..., secure: bool = ...,
credentials: Optional[Tuple[str, str]] = ...) -> None: ...
else:
def __init__(self,
host: str, url: str, method: str = ...) -> None: ...
def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ...
if sys.version_info > (3,):
class QueueHandler(Handler):
def __init__(self, queue: Queue) -> None: ...
def prepare(self, record: LogRecord) -> Any: ...
def enqueue(self, record: LogRecord) -> None: ...
class QueueListener:
if sys.version_info >= (3, 5):
def __init__(self, queue: Queue, *handlers: Handler,
respect_handler_level: bool = ...) -> None: ...
else:
def __init__(self,
queue: Queue, *handlers: Handler) -> None: ...
def dequeue(self, block: bool) -> LogRecord: ...
def prepare(self, record: LogRecord) -> Any: ...
def start(self) -> None: ...
def stop(self) -> None: ...
def enqueue_sentinel(self) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/logging/config.pyi 0000644 0000000 0000000 00000001724 13035744274 020670 0 ustar root root # Stubs for logging.config (Python 3.4)
from typing import Any, Callable, Dict, Optional, IO, Union
import sys
if sys.version_info >= (3,):
# from configparser import RawConfigParser
# TODO add RawConfigParser to configparser stubs
RawConfigParser = Any
else:
from ConfigParser import RawConfigParser
def dictConfig(config: Dict[str, Any]) -> None: ...
if sys.version_info >= (3, 4):
def fileConfig(fname: Union[str, IO[str], RawConfigParser],
defaults: Optional[Dict[str, str]] = ...,
disable_existing_loggers: bool = ...) -> None: ...
def listen(port: int = ...,
verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> None: ...
else:
def fileConfig(fname: Union[str, IO[str]],
defaults: Optional[Dict[str, str]] = ...,
disable_existing_loggers: bool = ...) -> None: ...
def listen(port: int = ...) -> None: ...
def stopListening() -> None: ...
mypy-0.470/typeshed/stdlib/2and3/tarfile.pyi 0000644 0000000 0000000 00000015442 13035744274 017425 0 ustar root root # Stubs for tarfile
from typing import (
Callable, IO, Iterable, Iterator, List, Mapping, Optional, Type,
Union,
)
import sys
from types import TracebackType
ENCODING = ... # type: str
USTAR_FORMAT = ... # type: int
GNU_FORMAT = ... # type: int
PAX_FORMAT = ... # type: int
DEFAULT_FORMAT = ... # type: int
REGTYPE = ... # type: bytes
AREGTYPE = ... # type: bytes
LNKTYPE = ... # type: bytes
SYMTYPE = ... # type: bytes
DIRTYPE = ... # type: bytes
FIFOTYPE = ... # type: bytes
CONTTYPE = ... # type: bytes
CHRTYPE = ... # type: bytes
BLKTYPE = ... # type: bytes
GNUTYPE_SPARSE = ... # type: bytes
if sys.version_info < (3,):
TAR_PLAIN = ... # type: int
TAR_GZIPPED = ... # type: int
def open(name: Optional[str] = ..., mode: str = ...,
fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,
*, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
dereference: Optional[bool] = ...,
ignore_zeros: Optional[bool] = ...,
encoding: Optional[str] = ..., errors: str = ...,
pax_headers: Optional[Mapping[str, str]] = ...,
debug: Optional[int] = ...,
errorlevel: Optional[int] = ...) -> TarFile: ...
class TarFile(Iterable[TarInfo]):
name = ... # type: Optional[str]
mode = ... # type: str
fileobj = ... # type: Optional[IO[bytes]]
format = ... # type: Optional[int]
tarinfo = ... # type: Optional[TarInfo]
dereference = ... # type: Optional[bool]
ignore_zeros = ... # type: Optional[bool]
encoding = ... # type: Optional[str]
errors = ... # type: str
pax_headers = ... # type: Optional[Mapping[str, str]]
debug = ... # type: Optional[int]
errorlevel = ... # type: Optional[int]
if sys.version_info < (3,):
posix = ... # type: bool
def __init__(self, name: Optional[str] = ..., mode: str = ...,
fileobj: Optional[IO[bytes]] = ...,
format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
dereference: Optional[bool] = ...,
ignore_zeros: Optional[bool] = ...,
encoding: Optional[str] = ..., errors: str = ...,
pax_headers: Optional[Mapping[str, str]] = ...,
debug: Optional[int] = ...,
errorlevel: Optional[int] = ...) -> None: ...
def __enter__(self) -> TarFile: ...
def __exit__(self,
exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
def __iter__(self) -> Iterator[TarInfo]: ...
@classmethod
def open(cls, name: Optional[str] = ..., mode: str = ...,
fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,
*, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
dereference: Optional[bool] = ...,
ignore_zeros: Optional[bool] = ...,
encoding: Optional[str] = ..., errors: str = ...,
pax_headers: Optional[Mapping[str, str]] = ...,
debug: Optional[int] = ...,
errorlevel: Optional[int] = ...) -> TarFile: ...
def getmember(self, name: str) -> TarInfo: ...
def getmembers(self) -> List[TarInfo]: ...
def getnames(self) -> List[str]: ...
if sys.version_info >= (3, 5):
def list(self, verbose: bool = ...,
*, members: Optional[List[TarInfo]] = ...) -> None: ...
else:
def list(self, verbose: bool = ...) -> None: ...
def next(self) -> Optional[TarInfo]: ...
if sys.version_info >= (3, 5):
def extractall(self, path: str = ...,
members: Optional[List[TarInfo]] = ...,
*, numeric_owner: bool = ...) -> None: ...
else:
def extractall(self, path: str = ...,
members: Optional[List[TarInfo]] = ...) -> None: ...
if sys.version_info >= (3, 5):
def extract(self, member: Union[str, TarInfo], path: str = ...,
set_attrs: bool = ...,
*, numeric_owner: bool = ...) -> None: ...
elif sys.version_info >= (3,):
def extract(self, member: Union[str, TarInfo], path: str = ...,
set_attrs: bool = ...) -> None: ...
else:
def extract(self, member: Union[str, TarInfo],
path: str = ...) -> None: ...
def extractfile(self,
member: Union[str, TarInfo]) -> Optional[IO[bytes]]: ...
if sys.version_info >= (3,):
def add(self, name: str, arcname: Optional[str] = ...,
recursive: bool = ...,
exclude: Optional[Callable[[str], bool]] = ..., *,
filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...
else:
def add(self, name: str, arcname: Optional[str] = ...,
recursive: bool = ...,
exclude: Optional[Callable[[str], bool]] = ...,
filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...
def addfile(self, tarinfo: TarInfo,
fileobj: Optional[IO[bytes]] = ...) -> None: ...
def gettarinfo(self, name: Optional[str] = ...,
arcname: Optional[str] = ...,
fileobj: Optional[IO[bytes]] = ...) -> TarInfo: ...
def close(self) -> None: ...
def is_tarfile(name: str) -> bool: ...
if sys.version_info < (3,):
class TarFileCompat:
def __init__(self, filename: str, mode: str = ...,
compression: int = ...) -> None: ...
class TarError(Exception): ...
class ReadError(TarError): ...
class CompressionError(TarError): ...
class StreamError(TarError): ...
class ExtractError(TarError): ...
class HeaderError(TarError): ...
class TarInfo:
name = ... # type: str
size = ... # type: int
mtime = ... # type: int
mode = ... # type: int
type = ... # type: bytes
linkname = ... # type: str
uid = ... # type: int
gid = ... # type: int
uname = ... # type: str
gname = ... # type: str
pax_headers = ... # type: Mapping[str, str]
def __init__(self, name: str = ...) -> None: ...
if sys.version_info >= (3,):
@classmethod
def frombuf(cls, buf: bytes, encoding: str, errors: str) -> TarInfo: ...
else:
@classmethod
def frombuf(cls, buf: bytes) -> TarInfo: ...
@classmethod
def fromtarfile(cls, tarfile: TarFile) -> TarInfo: ...
def tobuf(self, format: Optional[int] = ...,
encoding: Optional[str] = ..., errors: str = ...) -> bytes: ...
def isfile(self) -> bool: ...
def isreg(self) -> bool: ...
def isdir(self) -> bool: ...
def issym(self) -> bool: ...
def islnk(self) -> bool: ...
def ischr(self) -> bool: ...
def isblk(self) -> bool: ...
def isfifo(self) -> bool: ...
def isdev(self) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/plistlib.pyi 0000644 0000000 0000000 00000004352 13023631176 017610 0 ustar root root # Stubs for plistlib
from typing import (
Any, IO, Mapping, MutableMapping, Optional, Union,
Type, TypeVar,
)
from typing import Dict as DictT
from enum import Enum
import sys
mm = MutableMapping[str, Any]
_D = TypeVar('_D', mm)
if sys.version_info >= (3,):
_Path = str
else:
_Path = Union[str, unicode]
if sys.version_info >= (3,):
class PlistFormat(Enum):
FMT_XML = ... # type: PlistFormat
FMT_BINARY = ... # type: PlistFormat
if sys.version_info >= (3, 4):
def load(fp: IO[bytes], *, fmt: Optional[PlistFormat] = ...,
use_builtin_types: bool, dict_type: Type[_D] =...) -> _D: ...
def loads(data: bytes, *, fmt: Optional[PlistFormat] = ...,
use_builtin_types: bool = ..., dict_type: Type[_D] = ...) -> _D: ...
def dump(value: Mapping[str, Any], fp: IO[bytes], *,
fmt: PlistFormat =..., sort_keys: bool = ...,
skipkeys: bool = ...) -> None: ...
def dumps(value: Mapping[str, Any], *, fmt: PlistFormat = ...,
skipkeys: bool = ..., sort_keys: bool = ...) -> bytes: ...
def readPlist(pathOrFile: Union[_Path, IO[bytes]]) -> DictT[str, Any]: ...
def writePlist(value: Mapping[str, Any], pathOrFile: Union[_Path, IO[bytes]]) -> None: ...
def readPlistFromBytes(data: bytes) -> DictT[str, Any]: ...
def writePlistToBytes(value: Mapping[str, Any]) -> bytes: ...
if sys.version_info < (3,):
def readPlistFromResource(path: _Path, restype: str = ...,
resid: int = ...) -> DictT[str, Any]: ...
def writePlistToResource(rootObject: Mapping[str, Any], path: _Path,
restype: str = ...,
resid: int = ...) -> None: ...
def readPlistFromString(data: str) -> DictT[str, Any]: ...
def writePlistToString(rootObject: Mapping[str, Any]) -> str: ...
if sys.version_info >= (3,):
class Dict(dict):
def __getattr__(self, attr: str) -> Any: ...
def __setattr__(self, attr: str, value: Any) -> None: ...
def __delattr__(self, attr: str) -> None: ...
class Data:
data = ... # type: bytes
def __init__(self, data: bytes) -> None: ...
if sys.version_info >= (3,):
FMT_XML = PlistFormat.FMT_XML
FMT_BINARY = PlistFormat.FMT_BINARY
mypy-0.470/typeshed/stdlib/2and3/fractions.pyi 0000644 0000000 0000000 00000006005 13023631176 017753 0 ustar root root # Stubs for fractions
# See https://docs.python.org/3/library/fractions.html
#
# Note: these stubs are incomplete. The more complex type
# signatures are currently omitted. Also see numbers.pyi.
from typing import Optional, TypeVar, Union, overload
from numbers import Real, Integral, Rational
from decimal import Decimal
import sys
_ComparableNum = Union[int, float, Decimal, Real]
@overload
def gcd(a: int, b: int) -> int: ...
@overload
def gcd(a: Integral, b: int) -> Integral: ...
@overload
def gcd(a: int, b: Integral) -> Integral: ...
@overload
def gcd(a: Integral, b: Integral) -> Integral: ...
class Fraction(Rational):
@overload
def __init__(self,
numerator: Union[int, Rational] = 0,
denominator: Optional[Union[int, Rational]] = 0,
*,
_normalize: bool = True) -> None: ...
@overload
def __init__(self, value: float, *, _normalize=True) -> None: ...
@overload
def __init__(self, value: Decimal, *, _normalize=True) -> None: ...
@overload
def __init__(self, value: str, *, _normalize=True) -> None: ...
@classmethod
def from_float(cls, f: float) -> 'Fraction': ...
@classmethod
def from_decimal(cls, dec: Decimal) -> 'Fraction': ...
def limit_denominator(self, max_denominator: int = 1000000) -> 'Fraction': ...
@property
def numerator(self) -> int: ...
@property
def denominator(self) -> int: ...
def __add__(self, other): ...
def __radd__(self, other): ...
def __sub__(self, other): ...
def __rsub__(self, other): ...
def __mul__(self, other): ...
def __rmul__(self, other): ...
def __truediv__(self, other): ...
def __rtruediv__(self, other): ...
if sys.version_info < (3, 0):
def __div__(self, other): ...
def __rdiv__(self, other): ...
def __floordiv__(self, other) -> int: ...
def __rfloordiv__(self, other) -> int: ...
def __mod__(self, other): ...
def __rmod__(self, other): ...
def __pow__(self, other): ...
def __rpow__(self, other): ...
def __pos__(self) -> 'Fraction': ...
def __neg__(self) -> 'Fraction': ...
def __abs__(self) -> 'Fraction': ...
def __trunc__(self) -> int: ...
if sys.version_info >= (3, 0):
def __floor__(self) -> int: ...
def __ceil__(self) -> int: ...
def __round__(self, ndigits=None): ...
def __hash__(self) -> int: ...
def __eq__(self, other: object) -> bool: ...
def __lt__(self, other: _ComparableNum) -> bool: ...
def __gt__(self, other: _ComparableNum) -> bool: ...
def __le__(self, other: _ComparableNum) -> bool: ...
def __ge__(self, other: _ComparableNum) -> bool: ...
if sys.version_info >= (3, 0):
def __bool__(self) -> bool: ...
else:
def __nonzero__(self) -> bool: ...
# Not actually defined within fractions.py, but provides more useful
# overrides
@property
def real(self) -> 'Fraction': ...
@property
def imag(self) -> 'Fraction': ...
def conjugate(self) -> 'Fraction': ...
mypy-0.470/typeshed/stdlib/2and3/zipfile.pyi 0000644 0000000 0000000 00000006712 13035744274 017441 0 ustar root root # Stubs for zipfile
from typing import Callable, IO, List, Optional, Tuple, Type, Union
from types import TracebackType
import sys
_SZI = Union[str, ZipInfo]
_DT = Tuple[int, int, int, int, int, int]
if sys.version_info >= (3,):
class BadZipFile(Exception): ...
BadZipfile = BadZipFile
else:
class BadZipfile(Exception): ...
class LargeZipFile(Exception): ...
class ZipFile:
debug = ... # type: int
comment = ... # type: bytes
def __init__(self, file: Union[str, IO[bytes]], mode: str = ..., compression: int = ...,
allowZip64: bool = ...) -> None: ...
def __enter__(self) -> ZipFile: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
def close(self) -> None: ...
def getinfo(self, name: str) -> ZipInfo: ...
def infolist(self) -> List[ZipInfo]: ...
def namelist(self) -> List[str]: ...
def open(self, name: _SZI, mode: str = ...,
pwd: Optional[bytes] = ...) -> IO[bytes]: ...
def extract(self, member: _SZI, path: Optional[_SZI] = ...,
pwd: bytes = ...) -> str: ...
def extractall(self, path: Optional[str] = ...,
members: Optional[List[str]] = ...,
pwd: Optional[bytes] = ...) -> None: ...
def printdir(self) -> None: ...
def setpassword(self, pwd: bytes) -> None: ...
def read(self, name: _SZI, pwd: Optional[bytes] = ...) -> bytes: ...
def testzip(self) -> Optional[str]: ...
def write(self, filename: str, arcname: Optional[str] = ...,
compress_type: Optional[int] = ...) -> None: ...
if sys.version_info >= (3,):
def writestr(self, zinfo_or_arcname: _SZI, data: Union[bytes, str],
compress_type: Optional[int] = ...) -> None: ...
else:
def writestr(self,
zinfo_or_arcname: _SZI, bytes: bytes,
compress_type: Optional[int] = ...) -> None: ...
class PyZipFile(ZipFile):
if sys.version_info >= (3,):
def __init__(self, file: Union[str, IO[bytes]], mode: str = ...,
compression: int = ..., allowZip64: bool = ...,
opimize: int = ...) -> None: ...
def writepy(self, pathname: str, basename: str = ...,
filterfunc: Optional[Callable[[str], bool]] = ...) -> None: ...
else:
def writepy(self,
pathname: str, basename: str = ...) -> None: ...
class ZipInfo:
filename = ... # type: str
date_time = ... # type: _DT
compress_type = ... # type: int
comment = ... # type: bytes
extra = ... # type: bytes
create_system = ... # type: int
create_version = ... # type: int
extract_version = ... # type: int
reserved = ... # type: int
flag_bits = ... # type: int
volume = ... # type: int
internal_attr = ... # type: int
external_attr = ... # type: int
header_offset = ... # type: int
CRC = ... # type: int
compress_size = ... # type: int
file_size = ... # type: int
if sys.version_info < (3,):
def __init__(self, filename: Optional[str] = ...,
date_time: Optional[_DT] = ...) -> None: ...
def is_zipfile(filename: Union[str, IO[bytes]]) -> bool: ...
ZIP_STORED = ... # type: int
ZIP_DEFLATED = ... # type: int
if sys.version_info >= (3, 3):
ZIP_BZIP2 = ... # type: int
ZIP_LZMA = ... # type: int
mypy-0.470/typeshed/stdlib/2and3/readline.pyi 0000644 0000000 0000000 00000002765 13023631176 017557 0 ustar root root # Stubs for readline
from typing import Callable, Optional, Sequence
import sys
_CompleterT = Optional[Callable[[str, int], Optional[str]]]
_CompDispT = Optional[Callable[[str, Sequence[str], int], None]]
def parse_and_bind(string: str) -> None: ...
def read_init_file(filename: str = ...) -> None: ...
def get_line_buffer() -> str: ...
def insert_text(string: str) -> None: ...
def redisplay() -> None: ...
def read_history_file(filename: str = ...) -> None: ...
def write_history_file(filename: str = ...) -> None: ...
if sys.version_info >= (3, 5):
def append_history_file(nelements: int, filename: str = ...) -> None: ...
def get_history_length() -> int: ...
def set_history_length(length: int) -> None: ...
def clear_history() -> None: ...
def get_current_history_length() -> int: ...
def get_history_item(index: int) -> str: ...
def remove_history_item(pos: int) -> None: ...
def replace_history_item(pos: int, line: str) -> None: ...
def add_history(string: str) -> None: ...
def set_startup_hook(function: Optional[Callable[[], None]] = ...) -> None: ...
def set_pre_input_hook(function: Optional[Callable[[], None]] = ...) -> None: ...
def set_completer(function: _CompleterT = ...) -> None: ...
def get_completer() -> _CompleterT: ...
def get_completion_type() -> int: ...
def get_begidx() -> int: ...
def get_endidx() -> int: ...
def set_completer_delims(string: str) -> None: ...
def get_completer_delims() -> str: ...
def set_completion_display_matches_hook(function: _CompDispT = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/argparse.pyi 0000644 0000000 0000000 00000015277 13044257024 017601 0 ustar root root # Stubs for argparse (Python 3.4)
from typing import (
Any, Callable, Iterable, List, IO, Optional, Sequence, Tuple, Type, Union,
TypeVar, overload
)
import sys
_T = TypeVar('_T')
ONE_OR_MORE = ... # type: str
OPTIONAL = ... # type: str
PARSER = ... # type: str
REMAINDER = ... # type: str
SUPPRESS = ... # type: str
ZERO_OR_MORE = ... # type: str
class ArgumentError(Exception): ...
class ArgumentParser:
if sys.version_info >= (3, 5):
def __init__(self,
prog: Optional[str] = ...,
usage: Optional[str] = ...,
description: Optional[str] = ...,
epilog: Optional[str] = ...,
parents: Sequence[ArgumentParser] = ...,
formatter_class: Type[HelpFormatter] = ...,
prefix_chars: str = ...,
fromfile_prefix_chars: Optional[str] = ...,
argument_default: Optional[str] = ...,
conflict_handler: str = ...,
add_help: bool = ...,
allow_abbrev: bool = ...) -> None: ...
else:
def __init__(self,
prog: Optional[str] = ...,
usage: Optional[str] = ...,
description: Optional[str] = ...,
epilog: Optional[str] = ...,
parents: Sequence[ArgumentParser] = ...,
formatter_class: Type[HelpFormatter] = ...,
prefix_chars: str = ...,
fromfile_prefix_chars: Optional[str] = ...,
argument_default: Optional[str] = ...,
conflict_handler: str = ...,
add_help: bool = ...) -> None: ...
def add_argument(self,
*name_or_flags: Union[str, Sequence[str]],
action: Union[str, Type[Action]] = ...,
nargs: Union[int, str] = ...,
const: Any = ...,
default: Any = ...,
type: Union[Callable[[str], _T], FileType] = ...,
choices: Iterable[_T] = ...,
required: bool = ...,
help: str = ...,
metavar: Union[str, Tuple[str, ...]] = ...,
dest: str = ...,
version: str = ...) -> None: ... # weirdly documented
def parse_args(self, args: Optional[Sequence[str]] = ...,
namespace: Optional[Namespace] = ...) -> Namespace: ...
def add_subparsers(self, title: str = ...,
description: Optional[str] = ...,
prog: str = ...,
parser_class: Type[ArgumentParser] = ...,
action: Type[Action] = ...,
option_string: str = ...,
dest: Optional[str] = ...,
help: Optional[str] = ...,
metavar: Optional[str] = ...) -> _SubParsersAction: ...
def add_argument_group(self, title: Optional[str] = ...,
description: Optional[str] = ...) -> _ArgumentGroup: ...
def add_mutually_exclusive_group(self, required: bool = ...) -> _MutuallyExclusiveGroup: ...
def set_defaults(self, **kwargs: Any) -> None: ...
def get_default(self, dest: str) -> Any: ...
def print_usage(self, file: Optional[IO[str]] = ...) -> None: ...
def print_help(self, file: Optional[IO[str]] = ...) -> None: ...
def format_usage(self) -> str: ...
def format_help(self) -> str: ...
def parse_known_args(self, args: Optional[Sequence[str]] = ...,
namespace: Optional[Namespace] = ...) -> Tuple[Namespace, List[str]]: ...
def convert_arg_line_to_args(self, arg_line: str) -> List[str]: ...
def exit(self, status: int = ..., message: Optional[str] = ...) -> None: ...
def error(self, message: str) -> None: ...
class HelpFormatter:
# not documented
def __init__(self, prog: str, indent_increment: int = ...,
max_help_position: int = ...,
width: Optional[int] = ...) -> None: ...
class RawDescriptionHelpFormatter(HelpFormatter): ...
class RawTextHelpFormatter(HelpFormatter): ...
class ArgumentDefaultsHelpFormatter(HelpFormatter): ...
if sys.version_info >= (3,):
class MetavarTypeHelpFormatter(HelpFormatter): ...
class Action:
def __init__(self,
option_strings: Sequence[str],
dest: str = ...,
nargs: Optional[Union[int, str]] = ...,
const: Any = ...,
default: Any = ...,
type: Union[Callable[[str], _T], FileType, None] = ...,
choices: Optional[Iterable[_T]] = ...,
required: bool = ...,
help: Optional[str] = ...,
metavar: Union[str, Tuple[str, ...]] = ...) -> None: ...
def __call__(self, parser: ArgumentParser, namespace: Namespace,
values: Union[str, Sequence[Any], None],
option_string: str = ...) -> None: ...
class Namespace:
def __getattr__(self, name: str) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
class FileType:
if sys.version_info >= (3, 4):
def __init__(self, mode: str = ..., bufsize: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...) -> None: ...
elif sys.version_info >= (3,):
def __init__(self,
mode: str = ..., bufsize: int = ...) -> None: ...
else:
def __init__(self,
mode: str = ..., bufsize: Optional[int] = ...) -> None: ...
def __call__(self, string: str) -> IO[Any]: ...
class _ArgumentGroup:
def add_argument(self,
*name_or_flags: Union[str, Sequence[str]],
action: Union[str, Type[Action]] = ...,
nargs: Union[int, str] = ...,
const: Any = ...,
default: Any = ...,
type: Union[Callable[[str], _T], FileType] = ...,
choices: Iterable[_T] = ...,
required: bool = ...,
help: str = ...,
metavar: Union[str, Tuple[str, ...]] = ...,
dest: str = ...,
version: str = ...) -> None: ...
def add_mutually_exclusive_group(self, required: bool = ...) -> _MutuallyExclusiveGroup: ...
class _MutuallyExclusiveGroup(_ArgumentGroup): ...
class _SubParsersAction:
# TODO: Type keyword args properly.
def add_parser(self, name: str, **kwargs: Any) -> ArgumentParser: ...
# not documented
class ArgumentTypeError(Exception): ...
mypy-0.470/typeshed/stdlib/2and3/_bisect.pyi 0000644 0000000 0000000 00000001102 13023631176 017364 0 ustar root root """Stub file for the '_bisect' module."""
from typing import Any, Sequence, TypeVar
T = TypeVar('T')
def bisect(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> int: ...
def bisect_left(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> int: ...
def bisect_right(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> int: ...
def insort(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> None: ...
def insort_left(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> None: ...
def insort_right(a: Sequence[T], x: T, lo: int = ..., hi: int = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/contextlib.pyi 0000644 0000000 0000000 00000003674 13023631176 020147 0 ustar root root # Stubs for contextlib
from typing import (
Any, Callable, Generator, IO, Iterable, Iterator, Optional, Type,
Generic, TypeVar,
)
from types import TracebackType
import sys
_T = TypeVar('_T')
_ExitFunc = Callable[[Optional[Type[BaseException]],
Optional[Exception],
Optional[TracebackType]], bool]
_CM_EF = TypeVar('_CM_EF', ContextManager, _ExitFunc)
# TODO already in PEP, have to get added to mypy
class ContextManager(Generic[_T]):
def __enter__(self) -> _T: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., ContextManager[_T]]: ...
if sys.version_info < (3,):
def nested(*mgr: ContextManager[Any]) -> ContextManager[Iterable[Any]]: ...
class closing(Generic[_T], ContextManager[_T]):
def __init__(self, thing: _T) -> None: ...
if sys.version_info >= (3, 4):
class suppress(ContextManager[None]):
def __init__(self, *exceptions: Type[BaseException]) -> None: ...
class redirect_stdout(ContextManager[None]):
def __init__(self, new_target: IO[str]) -> None: ...
if sys.version_info >= (3, 5):
class redirect_stderr(ContextManager[None]):
def __init__(self, new_target: IO[str]) -> None: ...
if sys.version_info >= (3,):
class ContextDecorator:
def __call__(self, func: Callable[..., None]) -> Callable[..., ContextManager[None]]: ...
class ExitStack(ContextManager[ExitStack]):
def __init__(self) -> None: ...
def enter_context(self, cm: ContextManager[_T]) -> _T: ...
def push(self, exit: _CM_EF) -> _CM_EF: ...
def callback(self, callback: Callable[..., None],
*args: Any, **kwds: Any) -> Callable[..., None]: ...
def pop_all(self) -> ExitStack: ...
def close(self) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/termios.pyi 0000644 0000000 0000000 00000014720 13035744274 017457 0 ustar root root # Stubs for termios
from typing import IO, List, Union
_FD = Union[int, IO[str]]
_Attr = List[Union[int, List[bytes]]]
# TODO constants not really documented
B0 = ... # type: int
B1000000 = ... # type: int
B110 = ... # type: int
B115200 = ... # type: int
B1152000 = ... # type: int
B1200 = ... # type: int
B134 = ... # type: int
B150 = ... # type: int
B1500000 = ... # type: int
B1800 = ... # type: int
B19200 = ... # type: int
B200 = ... # type: int
B2000000 = ... # type: int
B230400 = ... # type: int
B2400 = ... # type: int
B2500000 = ... # type: int
B300 = ... # type: int
B3000000 = ... # type: int
B3500000 = ... # type: int
B38400 = ... # type: int
B4000000 = ... # type: int
B460800 = ... # type: int
B4800 = ... # type: int
B50 = ... # type: int
B500000 = ... # type: int
B57600 = ... # type: int
B576000 = ... # type: int
B600 = ... # type: int
B75 = ... # type: int
B921600 = ... # type: int
B9600 = ... # type: int
BRKINT = ... # type: int
BS0 = ... # type: int
BS1 = ... # type: int
BSDLY = ... # type: int
CBAUD = ... # type: int
CBAUDEX = ... # type: int
CDSUSP = ... # type: int
CEOF = ... # type: int
CEOL = ... # type: int
CEOT = ... # type: int
CERASE = ... # type: int
CFLUSH = ... # type: int
CIBAUD = ... # type: int
CINTR = ... # type: int
CKILL = ... # type: int
CLNEXT = ... # type: int
CLOCAL = ... # type: int
CQUIT = ... # type: int
CR0 = ... # type: int
CR1 = ... # type: int
CR2 = ... # type: int
CR3 = ... # type: int
CRDLY = ... # type: int
CREAD = ... # type: int
CRPRNT = ... # type: int
CRTSCTS = ... # type: int
CS5 = ... # type: int
CS6 = ... # type: int
CS7 = ... # type: int
CS8 = ... # type: int
CSIZE = ... # type: int
CSTART = ... # type: int
CSTOP = ... # type: int
CSTOPB = ... # type: int
CSUSP = ... # type: int
CWERASE = ... # type: int
ECHO = ... # type: int
ECHOCTL = ... # type: int
ECHOE = ... # type: int
ECHOK = ... # type: int
ECHOKE = ... # type: int
ECHONL = ... # type: int
ECHOPRT = ... # type: int
EXTA = ... # type: int
EXTB = ... # type: int
FF0 = ... # type: int
FF1 = ... # type: int
FFDLY = ... # type: int
FIOASYNC = ... # type: int
FIOCLEX = ... # type: int
FIONBIO = ... # type: int
FIONCLEX = ... # type: int
FIONREAD = ... # type: int
FLUSHO = ... # type: int
HUPCL = ... # type: int
ICANON = ... # type: int
ICRNL = ... # type: int
IEXTEN = ... # type: int
IGNBRK = ... # type: int
IGNCR = ... # type: int
IGNPAR = ... # type: int
IMAXBEL = ... # type: int
INLCR = ... # type: int
INPCK = ... # type: int
IOCSIZE_MASK = ... # type: int
IOCSIZE_SHIFT = ... # type: int
ISIG = ... # type: int
ISTRIP = ... # type: int
IUCLC = ... # type: int
IXANY = ... # type: int
IXOFF = ... # type: int
IXON = ... # type: int
NCC = ... # type: int
NCCS = ... # type: int
NL0 = ... # type: int
NL1 = ... # type: int
NLDLY = ... # type: int
NOFLSH = ... # type: int
N_MOUSE = ... # type: int
N_PPP = ... # type: int
N_SLIP = ... # type: int
N_STRIP = ... # type: int
N_TTY = ... # type: int
OCRNL = ... # type: int
OFDEL = ... # type: int
OFILL = ... # type: int
OLCUC = ... # type: int
ONLCR = ... # type: int
ONLRET = ... # type: int
ONOCR = ... # type: int
OPOST = ... # type: int
PARENB = ... # type: int
PARMRK = ... # type: int
PARODD = ... # type: int
PENDIN = ... # type: int
TAB0 = ... # type: int
TAB1 = ... # type: int
TAB2 = ... # type: int
TAB3 = ... # type: int
TABDLY = ... # type: int
TCFLSH = ... # type: int
TCGETA = ... # type: int
TCGETS = ... # type: int
TCIFLUSH = ... # type: int
TCIOFF = ... # type: int
TCIOFLUSH = ... # type: int
TCION = ... # type: int
TCOFLUSH = ... # type: int
TCOOFF = ... # type: int
TCOON = ... # type: int
TCSADRAIN = ... # type: int
TCSAFLUSH = ... # type: int
TCSANOW = ... # type: int
TCSBRK = ... # type: int
TCSBRKP = ... # type: int
TCSETA = ... # type: int
TCSETAF = ... # type: int
TCSETAW = ... # type: int
TCSETS = ... # type: int
TCSETSF = ... # type: int
TCSETSW = ... # type: int
TCXONC = ... # type: int
TIOCCONS = ... # type: int
TIOCEXCL = ... # type: int
TIOCGETD = ... # type: int
TIOCGICOUNT = ... # type: int
TIOCGLCKTRMIOS = ... # type: int
TIOCGPGRP = ... # type: int
TIOCGSERIAL = ... # type: int
TIOCGSOFTCAR = ... # type: int
TIOCGWINSZ = ... # type: int
TIOCINQ = ... # type: int
TIOCLINUX = ... # type: int
TIOCMBIC = ... # type: int
TIOCMBIS = ... # type: int
TIOCMGET = ... # type: int
TIOCMIWAIT = ... # type: int
TIOCMSET = ... # type: int
TIOCM_CAR = ... # type: int
TIOCM_CD = ... # type: int
TIOCM_CTS = ... # type: int
TIOCM_DSR = ... # type: int
TIOCM_DTR = ... # type: int
TIOCM_LE = ... # type: int
TIOCM_RI = ... # type: int
TIOCM_RNG = ... # type: int
TIOCM_RTS = ... # type: int
TIOCM_SR = ... # type: int
TIOCM_ST = ... # type: int
TIOCNOTTY = ... # type: int
TIOCNXCL = ... # type: int
TIOCOUTQ = ... # type: int
TIOCPKT = ... # type: int
TIOCPKT_DATA = ... # type: int
TIOCPKT_DOSTOP = ... # type: int
TIOCPKT_FLUSHREAD = ... # type: int
TIOCPKT_FLUSHWRITE = ... # type: int
TIOCPKT_NOSTOP = ... # type: int
TIOCPKT_START = ... # type: int
TIOCPKT_STOP = ... # type: int
TIOCSCTTY = ... # type: int
TIOCSERCONFIG = ... # type: int
TIOCSERGETLSR = ... # type: int
TIOCSERGETMULTI = ... # type: int
TIOCSERGSTRUCT = ... # type: int
TIOCSERGWILD = ... # type: int
TIOCSERSETMULTI = ... # type: int
TIOCSERSWILD = ... # type: int
TIOCSER_TEMT = ... # type: int
TIOCSETD = ... # type: int
TIOCSLCKTRMIOS = ... # type: int
TIOCSPGRP = ... # type: int
TIOCSSERIAL = ... # type: int
TIOCSSOFTCAR = ... # type: int
TIOCSTI = ... # type: int
TIOCSWINSZ = ... # type: int
TOSTOP = ... # type: int
VDISCARD = ... # type: int
VEOF = ... # type: int
VEOL = ... # type: int
VEOL2 = ... # type: int
VERASE = ... # type: int
VINTR = ... # type: int
VKILL = ... # type: int
VLNEXT = ... # type: int
VMIN = ... # type: int
VQUIT = ... # type: int
VREPRINT = ... # type: int
VSTART = ... # type: int
VSTOP = ... # type: int
VSUSP = ... # type: int
VSWTC = ... # type: int
VSWTCH = ... # type: int
VT0 = ... # type: int
VT1 = ... # type: int
VTDLY = ... # type: int
VTIME = ... # type: int
VWERASE = ... # type: int
XCASE = ... # type: int
XTABS = ... # type: int
def tcgetattr(fd: _FD) -> _Attr: ...
def tcsetattr(fd: _FD, when: int, attributes: _Attr) -> None: ...
def tcsendbreak(fd: _FD, duration: int) -> None: ...
def tcdrain(fd: _FD) -> None: ...
def tcflush(fd: _FD, queue: int) -> None: ...
def tcflow(fd: _FD, action: int) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/numbers.pyi 0000644 0000000 0000000 00000007521 13023631176 017442 0 ustar root root # Stubs for numbers (Python 3.5)
# See https://docs.python.org/2.7/library/numbers.html
# and https://docs.python.org/3/library/numbers.html
#
# Note: these stubs are incomplete. The more complex type
# signatures are currently omitted.
from typing import Any, Optional, TypeVar
from abc import ABCMeta, abstractmethod
import sys
class Number(metaclass=ABCMeta):
@abstractmethod
def __hash__(self) -> int: ...
class Complex(Number):
@abstractmethod
def __complex__(self) -> complex: ...
if sys.version_info >= (3, 0):
def __bool__(self) -> bool: ...
else:
def __nonzero__(self) -> bool: ...
@property
@abstractmethod
def real(self): ...
@property
@abstractmethod
def imag(self): ...
@abstractmethod
def __add__(self, other): ...
@abstractmethod
def __radd__(self, other): ...
@abstractmethod
def __neg__(self): ...
@abstractmethod
def __pos__(self): ...
def __sub__(self, other): ...
def __rsub__(self, other): ...
@abstractmethod
def __mul__(self, other): ...
@abstractmethod
def __rmul__(self, other): ...
if sys.version_info < (3, 0):
@abstractmethod
def __div__(self, other): ...
@abstractmethod
def __rdiv__(self, other): ...
@abstractmethod
def __truediv__(self, other): ...
@abstractmethod
def __rtruediv__(self, other): ...
@abstractmethod
def __pow__(self, exponent): ...
@abstractmethod
def __rpow__(self, base): ...
def __abs__(self): ...
def conjugate(self): ...
def __eq__(self, other: object) -> bool: ...
if sys.version_info < (3, 0):
def __ne__(self, other: object) -> bool: ...
class Real(Complex):
@abstractmethod
def __float__(self) -> float: ...
@abstractmethod
def __trunc__(self) -> int: ...
if sys.version_info >= (3, 0):
@abstractmethod
def __floor__(self) -> int: ...
@abstractmethod
def __ceil__(self) -> int: ...
@abstractmethod
def __round__(self, ndigits: Optional[int] = None): ...
def __divmod__(self, other): ...
def __rdivmod__(self, other): ...
@abstractmethod
def __floordiv__(self, other): ...
@abstractmethod
def __rfloordiv__(self, other): ...
@abstractmethod
def __mod__(self, other): ...
@abstractmethod
def __rmod__(self, other): ...
@abstractmethod
def __lt__(self, other) -> bool: ...
@abstractmethod
def __le__(self, other) -> bool: ...
def __complex__(self) -> complex: ...
@property
def real(self): ...
@property
def imag(self): ...
def conjugate(self): ...
class Rational(Real):
@property
@abstractmethod
def numerator(self) -> int: ...
@property
@abstractmethod
def denominator(self) -> int: ...
def __float__(self) -> float: ...
class Integral(Rational):
if sys.version_info >= (3, 0):
@abstractmethod
def __int__(self) -> int: ...
else:
@abstractmethod
def __long__(self) -> long: ...
def __index__(self) -> int: ...
@abstractmethod
def __pow__(self, exponent, modulus=None): ...
@abstractmethod
def __lshift__(self, other): ...
@abstractmethod
def __rlshift__(self, other): ...
@abstractmethod
def __rshift__(self, other): ...
@abstractmethod
def __rrshift__(self, other): ...
@abstractmethod
def __and__(self, other): ...
@abstractmethod
def __rand__(self, other): ...
@abstractmethod
def __xor__(self, other): ...
@abstractmethod
def __rxor__(self, other): ...
@abstractmethod
def __or__(self, other): ...
@abstractmethod
def __ror__(self, other): ...
@abstractmethod
def __invert__(self): ...
def __float__(self) -> float: ...
@property
def numerator(self) -> int: ...
@property
def denominator(self) -> int: ...
mypy-0.470/typeshed/stdlib/2and3/cmath.pyi 0000644 0000000 0000000 00000001652 13035744274 017071 0 ustar root root """Stub file for the 'cmath' module."""
import sys
from typing import Union, Tuple
e = ... # type: float
pi = ... # type: float
_C = Union[float, complex]
def acos(x: _C) -> complex: ...
def acosh(x: _C) -> complex: ...
def asin(x: _C) -> complex: ...
def asinh(x: _C) -> complex: ...
def atan(x: _C) -> complex: ...
def atanh(x: _C) -> complex: ...
def cos(x: _C) -> complex: ...
def cosh(x: _C) -> complex: ...
def exp(x: _C) -> complex: ...
def isinf(z: _C) -> bool: ...
def isnan(z: _C) -> bool: ...
def log(x: _C, base: _C = ...) -> complex: ...
def log10(x: _C) -> complex: ...
def phase(z: _C) -> float: ...
def polar(z: _C) -> Tuple[float, float]: ...
def rect(r: float, phi: float) -> complex: ...
def sin(x: _C) -> complex: ...
def sinh(x: _C) -> complex: ...
def sqrt(x: _C) -> complex: ...
def tan(x: _C) -> complex: ...
def tanh(x: _C) -> complex: ...
if sys.version_info >= (3,):
def isfinite(z: _C) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/bz2.pyi 0000644 0000000 0000000 00000001751 13035744274 016472 0 ustar root root # Stubs for bz2
from typing import Any, BinaryIO, TextIO, IO, Union
def compress(data: bytes, compresslevel: int = ...) -> bytes: ...
def decompress(data: bytes) -> bytes: ...
def open(filename: Union[str, bytes, IO[Any]],
mode: str = 'rb',
encoding: str = None,
errors: str = None,
newline: str = None) -> IO[Any]: ...
class BZ2File(BinaryIO):
def __init__(self,
filename: Union[str, bytes, IO[Any]],
mode: str = "r",
buffering: Any = None,
compresslevel: int = 9) -> None: ...
class BZ2Compressor(object):
def __init__(self, compresslevel: int = 9) -> None: ...
def compress(self, data: bytes) -> bytes: ...
def flush(self) -> bytes: ...
class BZ2Decompressor(object):
def decompress(self, data: bytes) -> bytes: ...
@property
def eof(self) -> bool: ...
@property
def needs_input(self) -> bool: ...
@property
def unused_data(self) -> bytes: ...
mypy-0.470/typeshed/stdlib/2and3/marshal.pyi 0000644 0000000 0000000 00000000372 13023631176 017413 0 ustar root root from typing import Any, IO
version = ... # type: int
def dump(value: Any, file: IO[Any], version: int = ...) -> None: ...
def load(file: IO[Any]) -> Any: ...
def dumps(value: Any, version: int = ...) -> str: ...
def loads(string: str) -> Any: ...
mypy-0.470/typeshed/stdlib/2and3/zipimport.pyi 0000644 0000000 0000000 00000001315 13035744274 020026 0 ustar root root """Stub file for the 'zipimport' module."""
from typing import Optional
from types import CodeType, ModuleType
class ZipImportError(ImportError): ...
class zipimporter(object):
archive = ... # type: str
prefix = ... # type: str
def __init__(self, archivepath: str) -> None: ...
def find_module(self, fullname: str, path: str = ...) -> Optional[zipimporter]: ...
def get_code(self, fullname: str) -> CodeType: ...
def get_data(self, pathname: str) -> str: ...
def get_filename(self, fullname: str) -> str: ...
def get_source(self, fullname: str) -> Optional[str]: ...
def is_package(self, fullname: str) -> bool: ...
def load_module(self, fullname: str) -> ModuleType: ...
mypy-0.470/typeshed/stdlib/2and3/threading.pyi 0000644 0000000 0000000 00000014555 13023631176 017741 0 ustar root root # Stubs for threading
from typing import (
Any, Callable, Iterable, List, Mapping, Optional, Tuple, Type, Union,
TypeVar,
)
from types import FrameType, TracebackType
import sys
# TODO recursive type
_TF = Callable[[FrameType, str, Any], Optional[Callable[..., Any]]]
_PF = Callable[[FrameType, str, Any], None]
_T = TypeVar('_T')
def active_count() -> int: ...
if sys.version_info < (3,):
def activeCount() -> int: ...
def current_thread() -> Thread: ...
if sys.version_info < (3,):
def currentThread() -> Thread: ...
if sys.version_info >= (3,):
def get_ident() -> int: ...
def enumerate() -> List[Thread]: ...
if sys.version_info >= (3, 4):
def main_thread() -> Thread: ...
def settrace(func: _TF) -> None: ...
def setprofile(func: _PF) -> None: ...
def stack_size(size: int = ...) -> int: ...
if sys.version_info >= (3,):
TIMEOUT_MAX = ... # type: int
if sys.version_info < (3,):
class ThreadError(Exception): ...
# TODO: Change to a class with __getattr__ and __setattr__
# once mypy supports universal __setattr__.
# See https://github.com/python/mypy/issues/521
local = ... # type: Any
class Thread:
name = ... # type: str
ident = ... # type: Optional[int]
daemon = ... # type: bool
if sys.version_info >= (3,):
def __init__(self, group: None = ...,
target: Optional[Callable[..., None]] = ...,
name: Optional[str] = ...,
args: Tuple[Any, ...] = ...,
kwargs: Mapping[str, Any] = ...,
*, daemon: Optional[bool] = ...) -> None: ...
else:
def __init__(self, group: None = ...,
target: Optional[Callable[..., None]] = ...,
name: Optional[str] = ...,
args: Tuple[Any, ...] = ...,
kwargs: Mapping[str, Any] = ...) -> None: ...
def start(self) -> None: ...
def run(self) -> None: ...
def join(self, timeout: Optional[float] = ...) -> None: ...
def getName(self) -> str: ...
def setName(self, name: str) -> None: ...
def is_alive(self) -> bool: ...
if sys.version_info < (3,):
def isAlive(self) -> bool: ...
def isDaemon(self) -> bool: ...
def setDaemon(self, daemonic: bool) -> None: ...
class _DummyThread(Thread):
pass
class Lock:
def __init__(self) -> None: ...
def __enter__(self) -> bool: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
if sys.version_info >= (3,):
def acquire(self, blocking: bool = ..., timeout: int = ...) -> bool: ...
else:
def acquire(self, blocking: bool = ...) -> bool: ...
def release(self) -> None: ...
def locked(self) -> bool: ...
class _RLock:
def __init__(self) -> None: ...
def __enter__(self) -> bool: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
if sys.version_info >= (3,):
def acquire(self, blocking: bool = ..., timeout: int = ...) -> bool: ...
else:
def acquire(self, blocking: bool = ...) -> bool: ...
def release(self) -> None: ...
RLock = _RLock
class Condition:
def __init__(self, lock: Union[Lock, _RLock, None] = ...) -> None: ...
def __enter__(self) -> bool: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
if sys.version_info >= (3,):
def acquire(self, blocking: bool = ..., timeout: int = ...) -> bool: ...
else:
def acquire(self, blocking: bool = ...) -> bool: ...
def release(self) -> None: ...
def wait(self, timeout: Optional[float] = ...) -> bool: ...
if sys.version_info >= (3,):
def wait_for(self, predicate: Callable[[], _T],
timeout: Optional[float]) -> _T: ...
def notify(self, n: int = ...) -> None: ...
def notify_all(self) -> None: ...
def notifyAll(self) -> None: ...
class Semaphore:
def __init__(self, value: int = ...) -> None: ...
def __enter__(self) -> bool: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
if sys.version_info >= (3,):
def acquire(self, blocking: bool = ..., timeout: int = ...) -> bool: ...
else:
def acquire(self, blocking: bool = ...) -> bool: ...
def release(self) -> None: ...
class BoundedSemaphore:
def __init__(self, value: int = ...) -> None: ...
def __enter__(self) -> bool: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
if sys.version_info >= (3,):
def acquire(self, blocking: bool = ..., timeout: int = ...) -> bool: ...
else:
def acquire(self, blocking: bool = ...) -> bool: ...
def release(self) -> None: ...
class Event:
def __init__(self) -> None: ...
def is_set(self) -> bool: ...
if sys.version_info < (3,):
def isSet(self) -> bool: ...
def set(self) -> None: ...
def clear(self) -> None: ...
def wait(self, timeout: Optional[float] = ...) -> bool: ...
class Timer(Thread):
if sys.version_info >= (3,):
def __init__(self, interval: float, function: Callable[..., None],
args: Optional[List[Any]] = ...,
kwargs: Optional[Mapping[str, Any]] = ...) -> None: ...
else:
def __init__(self, interval: float, function: Callable[..., None],
args: List[Any] = ...,
kwargs: Mapping[str, Any] = ...) -> None: ...
def cancel(self) -> None: ...
if sys.version_info >= (3,):
class Barrier:
parties = ... # type: int
n_waiting = ... # type: int
broken = ... # type: bool
def __init__(self, parties: int, action: Optional[Callable[[], None]] = ...,
timeout: Optional[float] = ...) -> None: ...
def wait(self, timeout: Optional[float] = ...) -> int: ...
def reset(self) -> None: ...
def abort(self) -> None: ...
class BrokenBarrierError(RuntimeError): ...
mypy-0.470/typeshed/stdlib/2and3/bisect.pyi 0000644 0000000 0000000 00000002103 13035744274 017236 0 ustar root root # Stubs for bisect
from typing import Any, Sequence, TypeVar
_T = TypeVar('_T')
# TODO uncomment when mypy# 2035 is fixed
# def bisect_left(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
# def bisect_right(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
# def bisect(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
#
# def insort_left(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
# def insort_right(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
# def insort(a: Sequence[_T], x: _T, lo: int = ..., hi: int = ...) -> int: ...
def bisect_left(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
def bisect_right(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
def bisect(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
def insort_left(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
def insort_right(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
def insort(a: Sequence, x: Any, lo: int = ..., hi: int = ...) -> int: ...
mypy-0.470/typeshed/stdlib/2and3/locale.pyi 0000644 0000000 0000000 00000005762 13023631176 017233 0 ustar root root # Stubs for locale
from typing import Any, Iterable, List, Mapping, Optional, Sequence, Tuple, Union
import sys
# workaround for mypy#2010
if sys.version_info < (3,):
from __builtin__ import str as _str
else:
from builtins import str as _str
CODESET = ... # type: int
D_T_FMT = ... # type: int
D_FMT = ... # type: int
T_FMT = ... # type: int
T_FMT_AMPM = ... # type: int
DAY_1 = ... # type: int
DAY_2 = ... # type: int
DAY_3 = ... # type: int
DAY_4 = ... # type: int
DAY_5 = ... # type: int
DAY_6 = ... # type: int
DAY_7 = ... # type: int
ABDAY_1 = ... # type: int
ABDAY_2 = ... # type: int
ABDAY_3 = ... # type: int
ABDAY_4 = ... # type: int
ABDAY_5 = ... # type: int
ABDAY_6 = ... # type: int
ABDAY_7 = ... # type: int
MON_1 = ... # type: int
MON_2 = ... # type: int
MON_3 = ... # type: int
MON_4 = ... # type: int
MON_5 = ... # type: int
MON_6 = ... # type: int
MON_7 = ... # type: int
MON_8 = ... # type: int
MON_9 = ... # type: int
MON_10 = ... # type: int
MON_11 = ... # type: int
MON_12 = ... # type: int
ABMON_1 = ... # type: int
ABMON_2 = ... # type: int
ABMON_3 = ... # type: int
ABMON_4 = ... # type: int
ABMON_5 = ... # type: int
ABMON_6 = ... # type: int
ABMON_7 = ... # type: int
ABMON_8 = ... # type: int
ABMON_9 = ... # type: int
ABMON_10 = ... # type: int
ABMON_11 = ... # type: int
ABMON_12 = ... # type: int
RADIXCHAR = ... # type: int
THOUSEP = ... # type: int
YESEXPR = ... # type: int
NOEXPR = ... # type: int
CRNCYSTR = ... # type: int
ERA = ... # type: int
ERA_D_T_FMT = ... # type: int
ERA_D_FMT = ... # type: int
ERA_T_FMT = ... # type: int
ALT_DIGITS = ... # type: int
LC_CTYPE = ... # type: int
LC_COLLATE = ... # type: int
LC_TIME = ... # type: int
LC_MONETARY = ... # type: int
LC_MESSAGES = ... # type: int
LC_NUMERIC = ... # type: int
LC_ALL = ... # type: int
CHAR_MAX = ... # type: int
class Error(Exception): ...
def setlocale(category: int,
locale: Union[_str, Iterable[_str], None] = ...) -> _str: ...
def localeconv() -> Mapping[_str, Union[int, _str, List[int]]]: ...
def nl_langinfo(option: int) -> _str: ...
def getdefaultlocale(envvars: Tuple[_str] = ...) -> Tuple[Optional[_str], Optional[_str]]: ...
def getlocale(category: int = ...) -> Sequence[_str]: ...
def getpreferredencoding(do_setlocale: bool = ...) -> _str: ...
def normalize(localename: _str) -> _str: ...
def resetlocale(category: int = ...) -> None: ...
def strcoll(string1: _str, string2: _str) -> int: ...
def strxfrm(string: _str) -> _str: ...
def format(format: _str, val: int, grouping: bool = ...,
monetary: bool = ...) -> _str: ...
def format_string(format: _str, val: Sequence[Any],
grouping: bool = ...) -> _str: ...
def currency(val: int, symbol: bool = ..., grouping: bool = ...,
international: bool = ...) -> _str: ...
if sys.version_info >= (3, 5):
def delocalize(string: _str) -> None: ...
def atof(string: _str) -> float: ...
def atoi(string: _str) -> int: ...
def str(float: float) -> _str: ...
mypy-0.470/typeshed/stdlib/2and3/errno.pyi 0000644 0000000 0000000 00000006545 13035744274 017130 0 ustar root root # Stubs for errno
from typing import Mapping
import sys
errorcode = ... # type: Mapping[int, str]
EPERM = ... # type: int
ENOENT = ... # type: int
ESRCH = ... # type: int
EINTR = ... # type: int
EIO = ... # type: int
ENXIO = ... # type: int
E2BIG = ... # type: int
ENOEXEC = ... # type: int
EBADF = ... # type: int
ECHILD = ... # type: int
EAGAIN = ... # type: int
ENOMEM = ... # type: int
EACCES = ... # type: int
EFAULT = ... # type: int
ENOTBLK = ... # type: int
EBUSY = ... # type: int
EEXIST = ... # type: int
EXDEV = ... # type: int
ENODEV = ... # type: int
ENOTDIR = ... # type: int
EISDIR = ... # type: int
EINVAL = ... # type: int
ENFILE = ... # type: int
EMFILE = ... # type: int
ENOTTY = ... # type: int
ETXTBSY = ... # type: int
EFBIG = ... # type: int
ENOSPC = ... # type: int
ESPIPE = ... # type: int
EROFS = ... # type: int
EMLINK = ... # type: int
EPIPE = ... # type: int
EDOM = ... # type: int
ERANGE = ... # type: int
EDEADLCK = ... # type: int
ENAMETOOLONG = ... # type: int
ENOLCK = ... # type: int
ENOSYS = ... # type: int
ENOTEMPTY = ... # type: int
ELOOP = ... # type: int
EWOULDBLOCK = ... # type: int
ENOMSG = ... # type: int
EIDRM = ... # type: int
ECHRNG = ... # type: int
EL2NSYNC = ... # type: int
EL3HLT = ... # type: int
EL3RST = ... # type: int
ELNRNG = ... # type: int
EUNATCH = ... # type: int
ENOCSI = ... # type: int
EL2HLT = ... # type: int
EBADE = ... # type: int
EBADR = ... # type: int
EXFULL = ... # type: int
ENOANO = ... # type: int
EBADRQC = ... # type: int
EBADSLT = ... # type: int
EDEADLOCK = ... # type: int
EBFONT = ... # type: int
ENOSTR = ... # type: int
ENODATA = ... # type: int
ETIME = ... # type: int
ENOSR = ... # type: int
ENONET = ... # type: int
ENOPKG = ... # type: int
EREMOTE = ... # type: int
ENOLINK = ... # type: int
EADV = ... # type: int
ESRMNT = ... # type: int
ECOMM = ... # type: int
EPROTO = ... # type: int
EMULTIHOP = ... # type: int
EDOTDOT = ... # type: int
EBADMSG = ... # type: int
EOVERFLOW = ... # type: int
ENOTUNIQ = ... # type: int
EBADFD = ... # type: int
EREMCHG = ... # type: int
ELIBACC = ... # type: int
ELIBBAD = ... # type: int
ELIBSCN = ... # type: int
ELIBMAX = ... # type: int
ELIBEXEC = ... # type: int
EILSEQ = ... # type: int
ERESTART = ... # type: int
ESTRPIPE = ... # type: int
EUSERS = ... # type: int
ENOTSOCK = ... # type: int
EDESTADDRREQ = ... # type: int
EMSGSIZE = ... # type: int
EPROTOTYPE = ... # type: int
ENOPROTOOPT = ... # type: int
EPROTONOSUPPORT = ... # type: int
ESOCKTNOSUPPORT = ... # type: int
EOPNOTSUPP = ... # type: int
EPFNOSUPPORT = ... # type: int
EAFNOSUPPORT = ... # type: int
EADDRINUSE = ... # type: int
EADDRNOTAVAIL = ... # type: int
ENETDOWN = ... # type: int
ENETUNREACH = ... # type: int
ENETRESET = ... # type: int
ECONNABORTED = ... # type: int
ECONNRESET = ... # type: int
ENOBUFS = ... # type: int
EISCONN = ... # type: int
ENOTCONN = ... # type: int
ESHUTDOWN = ... # type: int
ETOOMANYREFS = ... # type: int
ETIMEDOUT = ... # type: int
ECONNREFUSED = ... # type: int
EHOSTDOWN = ... # type: int
EHOSTUNREACH = ... # type: int
EALREADY = ... # type: int
EINPROGRESS = ... # type: int
ESTALE = ... # type: int
EUCLEAN = ... # type: int
ENOTNAM = ... # type: int
ENAVAIL = ... # type: int
EISNAM = ... # type: int
EREMOTEIO = ... # type: int
EDQUOT = ... # type: int
mypy-0.470/typeshed/stdlib/2and3/rlcompleter.pyi 0000644 0000000 0000000 00000000364 13023631176 020315 0 ustar root root # Stubs for rlcompleter
from typing import Optional, Union
import sys
if sys.version_info >= (3,):
_Text = str
else:
_Text = Union[str, unicode]
class Completer:
def complete(self, text: _Text, state: int) -> Optional[str]: ...
mypy-0.470/typeshed/stdlib/2and3/warnings.pyi 0000644 0000000 0000000 00000003474 13035744274 017631 0 ustar root root # Stubs for warnings
from typing import Any, Dict, List, NamedTuple, Optional, TextIO, Tuple, Type, Union
from types import ModuleType, TracebackType
def warn(message: Union[str, Warning], category: Optional[Type[Warning]] = ...,
stacklevel: int = ...) -> None: ...
def warn_explicit(message: Union[str, Warning], category: Type[Warning],
filename: str, lineno: int, module: Optional[str] = ...,
registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ...,
module_globals: Optional[Dict[str, Any]] = ...) -> None: ...
def showwarning(message: str, category: Type[Warning], filename: str,
lineno: int, file: Optional[TextIO] = ...,
line: Optional[str] = ...) -> None: ...
def formatwarning(message: str, category: Type[Warning], filename: str,
lineno: int, line: Optional[str] = ...) -> None: ...
def filterwarnings(action: str, message: str = ...,
category: Type[Warning] = ..., module: str = ...,
lineno: int = ..., append: bool = ...) -> None: ...
def simplefilter(action: str, category: Type[Warning] = ..., lineno: int = ...,
append: bool = ...) -> None: ...
def resetwarnings() -> None: ...
_Record = NamedTuple('_Record',
[('message', str),
('category', Type[Warning]),
('filename', str),
('lineno', int),
('file', Optional[TextIO]),
('line', Optional[str])]
)
class catch_warnings:
def __init__(self, *, record: bool = ...,
module: Optional[ModuleType] = ...) -> None: ...
def __enter__(self) -> Optional[List[_Record]]: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/operator.pyi 0000644 0000000 0000000 00000014561 13035744274 017633 0 ustar root root # Stubs for operator
from typing import (
Any, Callable, Container, Mapping, MutableMapping, MutableSequence, Sequence, SupportsAbs, Tuple,
TypeVar, overload,
)
import sys
_T = TypeVar('_T')
_K = TypeVar('_K')
_V = TypeVar('_V')
def lt(a: Any, b: Any) -> Any: ...
def le(a: Any, b: Any) -> Any: ...
def eq(a: Any, b: Any) -> Any: ...
def ne(a: Any, b: Any) -> Any: ...
def ge(a: Any, b: Any) -> Any: ...
def gt(a: Any, b: Any) -> Any: ...
def __lt__(a: Any, b: Any) -> Any: ...
def __le__(a: Any, b: Any) -> Any: ...
def __eq__(a: Any, b: Any) -> Any: ...
def __ne__(a: Any, b: Any) -> Any: ...
def __ge__(a: Any, b: Any) -> Any: ...
def __gt__(a: Any, b: Any) -> Any: ...
def not_(obj: Any) -> bool: ...
def __not__(obj: Any) -> bool: ...
def truth(x: Any) -> bool: ...
def is_(a: Any, b: Any) -> bool: ...
def is_not(a: Any, b: Any) -> bool: ...
def abs(x: SupportsAbs) -> Any: ...
def __abs__(a: SupportsAbs) -> Any: ...
def add(a: Any, b: Any) -> Any: ...
def __add__(a: Any, b: Any) -> Any: ...
def and_(a: Any, b: Any) -> Any: ...
def __and__(a: Any, b: Any) -> Any: ...
if sys.version_info < (3, ):
def div(a: Any, b: Any) -> Any: ...
def __div__(a: Any, b: Any) -> Any: ...
def floordiv(a: Any, b: Any) -> Any: ...
def __floordiv__(a: Any, b: Any) -> Any: ...
def index(a: Any) -> int: ...
def __index__(a: Any) -> int: ...
def inv(obj: Any) -> Any: ...
def invert(obj: Any) -> Any: ...
def __inv__(obj: Any) -> Any: ...
def __invert__(obj: Any) -> Any: ...
def lshift(a: Any, b: Any) -> Any: ...
def __lshift__(a: Any, b: Any) -> Any: ...
def mod(a: Any, b: Any) -> Any: ...
def __mod__(a: Any, b: Any) -> Any: ...
def mul(a: Any, b: Any) -> Any: ...
def __mul__(a: Any, b: Any) -> Any: ...
if sys.version_info >= (3, 5):
def matmul(a: Any, b: Any) -> Any: ...
def __matmul__(a: Any, b: Any) -> Any: ...
def neg(obj: Any) -> Any: ...
def __neg__(obj: Any) -> Any: ...
def or_(a: Any, b: Any) -> Any: ...
def __or__(a: Any, b: Any) -> Any: ...
def pos(obj: Any) -> Any: ...
def __pos__(obj: Any) -> Any: ...
def pow(a: Any, b: Any) -> Any: ...
def __pow__(a: Any, b: Any) -> Any: ...
def rshift(a: Any, b: Any) -> Any: ...
def __rshift__(a: Any, b: Any) -> Any: ...
def sub(a: Any, b: Any) -> Any: ...
def __sub__(a: Any, b: Any) -> Any: ...
def truediv(a: Any, b: Any) -> Any: ...
def __truediv__(a: Any, b: Any) -> Any: ...
def xor(a: Any, b: Any) -> Any: ...
def __xor__(a: Any, b: Any) -> Any: ...
def concat(a: Sequence[_T], b: Sequence[_T]) -> Sequence[_T]: ...
def __concat__(a: Sequence[_T], b: Sequence[_T]) -> Sequence[_T]: ...
def contains(a: Container[Any], b: Any) -> bool: ...
def __contains__(a: Container[Any], b: Any) -> bool: ...
def countOf(a: Container[Any], b: Any) -> int: ...
@overload
def delitem(a: MutableSequence[_T], b: int) -> None: ...
@overload
def delitem(a: MutableMapping[_K, _V], b: _K) -> None: ...
@overload
def __delitem__(a: MutableSequence[_T], b: int) -> None: ...
@overload
def __delitem__(a: MutableMapping[_K, _V], b: _K) -> None: ...
if sys.version_info < (3, ):
def delslice(a: MutableSequence[Any], b: int, c: int) -> None: ...
def __delslice__(a: MutableSequence[Any], b: int, c: int) -> None: ...
@overload
def getitem(a: Sequence[_T], b: int) -> _T: ...
@overload
def getitem(a: Mapping[_K, _V], b: _K) -> _V: ...
@overload
def __getitem__(a: Sequence[_T], b: int) -> _T: ...
@overload
def __getitem__(a: Mapping[_K, _V], b: _K) -> _V: ...
if sys.version_info < (3, ):
def getslice(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ...
def __getslice__(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ...
def indexOf(a: Sequence[_T], b: _T) -> int: ...
if sys.version_info < (3, ):
def repeat(a: Any, b: int) -> Any: ...
def __repeat__(a: Any, b: int) -> Any: ...
if sys.version_info < (3, ):
def sequenceIncludes(a: Container[Any], b: Any) -> bool: ...
@overload
def setitem(a: MutableSequence[_T], b: int, c: _T) -> None: ...
@overload
def setitem(a: MutableMapping[_K, _V], b: _K, c: _V) -> None: ...
@overload
def __setitem__(a: MutableSequence[_T], b: int, c: _T) -> None: ...
@overload
def __setitem__(a: MutableMapping[_K, _V], b: _K, c: _V) -> None: ...
if sys.version_info < (3, ):
def setslice(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ...
def __setslice__(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ...
if sys.version_info >= (3, 4):
def length_hint(obj: Any, default: int = ...) -> int: ...
@overload
def attrgetter(attr: str) -> Callable[[Any], Any]: ...
@overload
def attrgetter(*attrs: str) -> Callable[[Any], Tuple[Any, ...]]: ...
@overload
def itemgetter(item: Any) -> Callable[[Any], Any]: ...
@overload
def itemgetter(*items: Any) -> Callable[[Any], Tuple[Any, ...]]: ...
def methodcaller(name: str, *args: Any, **kwargs: Any) -> Callable[..., Any]: ...
def iadd(a: Any, b: Any) -> Any: ...
def __iadd__(a: Any, b: Any) -> Any: ...
def iand(a: Any, b: Any) -> Any: ...
def __iand__(a: Any, b: Any) -> Any: ...
def iconcat(a: Any, b: Any) -> Any: ...
def __iconcat__(a: Any, b: Any) -> Any: ...
if sys.version_info < (3, ):
def idiv(a: Any, b: Any) -> Any: ...
def __idiv__(a: Any, b: Any) -> Any: ...
def ifloordiv(a: Any, b: Any) -> Any: ...
def __ifloordiv__(a: Any, b: Any) -> Any: ...
def ilshift(a: Any, b: Any) -> Any: ...
def __ilshift__(a: Any, b: Any) -> Any: ...
def imod(a: Any, b: Any) -> Any: ...
def __imod__(a: Any, b: Any) -> Any: ...
def imul(a: Any, b: Any) -> Any: ...
def __imul__(a: Any, b: Any) -> Any: ...
if sys.version_info >= (3, 5):
def imatmul(a: Any, b: Any) -> Any: ...
def __imatmul__(a: Any, b: Any) -> Any: ...
def ior(a: Any, b: Any) -> Any: ...
def __ior__(a: Any, b: Any) -> Any: ...
def ipow(a: Any, b: Any) -> Any: ...
def __ipow__(a: Any, b: Any) -> Any: ...
if sys.version_info < (3, ):
def irepeat(a: Any, b: int) -> Any: ...
def __irepeat__(a: Any, b: int) -> Any: ...
def irshift(a: Any, b: Any) -> Any: ...
def __irshift__(a: Any, b: Any) -> Any: ...
def isub(a: Any, b: Any) -> Any: ...
def __isub__(a: Any, b: Any) -> Any: ...
def itruediv(a: Any, b: Any) -> Any: ...
def __itruediv__(a: Any, b: Any) -> Any: ...
def ixor(a: Any, b: Any) -> Any: ...
def __ixor__(a: Any, b: Any) -> Any: ...
if sys.version_info < (3, ):
def isCallable(x: Any) -> bool: ...
def isMappingType(x: Any) -> bool: ...
def isNumberType(x: Any) -> bool: ...
def isSequenceType(x: Any) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/_heapq.pyi 0000644 0000000 0000000 00000001003 13023631176 017211 0 ustar root root """Stub file for the '_heapq' module."""
from typing import TypeVar, List
_T = TypeVar("_T")
def heapify(heap: List[_T]) -> None: ...
def heappop(heap: List[_T]) -> _T:
raise IndexError() # if list is empty
def heappush(heap: List[_T], item: _T) -> None: ...
def heappushpop(heap: List[_T], item: _T) -> _T: ...
def heapreplace(heap: List[_T], item: _T) -> _T:
raise IndexError() # if list is empty
def nlargest(a: int, b: List[_T]) -> List[_T]: ...
def nsmallest(a: int, b: List[_T]) -> List[_T]: ...
mypy-0.470/typeshed/stdlib/2and3/keyword.pyi 0000644 0000000 0000000 00000000225 13023631176 017445 0 ustar root root # Stubs for keyword
from typing import Sequence, Text, Union
def iskeyword(s: Union[Text, bytes]) -> bool: ...
kwlist = ... # type: Sequence[str]
mypy-0.470/typeshed/stdlib/2and3/webbrowser.pyi 0000644 0000000 0000000 00000007074 13035744274 020162 0 ustar root root # Stubs for webbrowser (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
import sys
from typing import Any, Optional, Callable, List
class Error(Exception): ...
def register(name: str, klass: Optional[Callable[[], BaseBrowser]], instance: BaseBrowser=..., update_tryorder: int=...) -> None: ...
def get(using: str=...) -> BaseBrowser: ...
def open(url: str, new: int=..., autoraise: bool=...) -> bool: ...
def open_new(url: str) -> bool: ...
def open_new_tab(url: str) -> bool: ...
class BaseBrowser:
args = ... # type: List[str]
name = ... # type: str
basename = ... # type: str
def __init__(self, name: str=...) -> None: ...
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
def open_new(self, url: str) -> bool: ...
def open_new_tab(self, url: str) -> bool: ...
class GenericBrowser(BaseBrowser):
args = ... # type: List[str]
name = ... # type: str
basename = ... # type: str
def __init__(self, name: str) -> None: ...
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class BackgroundBrowser(GenericBrowser):
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class UnixBrowser(BaseBrowser):
raise_opts = ... # type: List[str]
background = ... # type: bool
redirect_stdout = ... # type: bool
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
remote_action_newtab = ... # type: str
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class Mozilla(UnixBrowser):
raise_opts = ... # type: List[str]
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
remote_action_newtab = ... # type: str
background = ... # type: bool
class Galeon(UnixBrowser):
raise_opts = ... # type: List[str]
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
background = ... # type: bool
if sys.version_info[:2] == (2, 7) or sys.version_info >= (3, 3):
class Chrome(UnixBrowser):
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
remote_action_newtab = ... # type: str
background = ... # type: bool
class Opera(UnixBrowser):
raise_opts = ... # type: List[str]
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
remote_action_newtab = ... # type: str
background = ... # type: bool
class Elinks(UnixBrowser):
remote_args = ... # type: List[str]
remote_action = ... # type: str
remote_action_newwin = ... # type: str
remote_action_newtab = ... # type: str
background = ... # type: bool
redirect_stdout = ... # type: bool
class Konqueror(BaseBrowser):
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class Grail(BaseBrowser):
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class WindowsDefault(BaseBrowser):
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class MacOSX(BaseBrowser):
name = ... # type: str
def __init__(self, name: str) -> None: ...
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
class MacOSXOSAScript(BaseBrowser):
def __init__(self, name: str) -> None: ...
def open(self, url: str, new: int=..., autoraise: bool=...) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/asyncore.pyi 0000644 0000000 0000000 00000011621 13035744274 017615 0 ustar root root from typing import Tuple, Union, Optional, Any, Dict, overload
import os
import select
import socket
import sys
import time
import warnings
from errno import (EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, EINVAL,
ENOTCONN, ESHUTDOWN, EINTR, EISCONN, EBADF, ECONNABORTED,
EPIPE, EAGAIN, errorcode)
# cyclic dependence with asynchat
_maptype = Dict[str, Any]
class ExitNow(Exception): pass
def read(obj: Any) -> None: ...
def write(obj: Any) -> None: ...
def readwrite(obj: Any, flags: int) -> None: ...
def poll(timeout: float = ..., map: _maptype = ...) -> None: ...
def poll2(timeout: float = ..., map: _maptype = ...) -> None: ...
poll3 = poll2
def loop(timeout: float = ..., use_poll: bool = ..., map: _maptype = ..., count: int = None) -> None: ...
# Not really subclass of socket.socket; it's only delegation.
# It is not covariant to it.
class dispatcher:
debug = ... # type: bool
connected = ... # type: bool
accepting = ... # type: bool
connecting = ... # type: bool
closing = ... # type: bool
ignore_log_types = ... # type: frozenset[str]
def __init__(self, sock: socket.socket = None, map: _maptype = ...) -> None: ...
def add_channel(self, map: _maptype = ...) -> None: ...
def del_channel(self, map: _maptype = ...) -> None: ...
def create_socket(self, family: int, type: int) -> None: ...
def set_socket(self, sock: socket.socket, map: _maptype = ...) -> None: ...
def set_reuse_addr(self) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def accept(self) -> Optional[Tuple[socket.socket, Any]]: ...
def recv(self, buffer_size: int) -> str: ...
def log(self, message: Any) -> None: ...
def log_info(self, message: Any, type: str = ...) -> None: ...
def handle_read_event(self) -> None: ...
def handle_connect_event(self) -> None: ...
def handle_write_event(self) -> None: ...
def handle_expt_event(self) -> None: ...
def handle_error(self) -> None: ...
def handle_expt(self) -> None: ...
def handle_read(self) -> None: ...
def handle_write(self) -> None: ...
def handle_connect(self) -> None: ...
def handle_accept(self) -> None: ...
def handle_close(self) -> None: ...
def detach(self) -> int: ...
def fileno(self) -> int: ...
# return value is an address
def getpeername(self) -> Any: ...
def getsockname(self) -> Any: ...
@overload
def getsockopt(self, level: int, optname: int) -> int: ...
@overload
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
def gettimeout(self) -> float: ...
def ioctl(self, control: object,
option: Tuple[int, int, int]) -> None: ...
def listen(self, backlog: int) -> None: ...
# TODO the return value may be BinaryIO or TextIO, depending on mode
def makefile(self, mode: str = ..., buffering: int = ...,
encoding: str = ..., errors: str = ...,
newline: str = ...) -> Any:
...
# return type is an address
def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ...
def recvfrom_into(self, buffer: str, nbytes: int, flags: int = ...) -> Any: ...
def recv_into(self, buffer: str, nbytes: int, flags: int = ...) -> Any: ...
def send(self, data: str, flags: int = ...) -> Optional[int]: ...
def sendall(self, data: str, flags: int = ...) -> None: ...
def sendto(self, data: str, address: Union[tuple, str], flags: int = ...) -> int: ...
def setblocking(self, flag: bool) -> None: ...
def settimeout(self, value: Union[float, None]) -> None: ...
def setsockopt(self, level: int, optname: int, value: Union[int, str]) -> None: ...
def shutdown(self, how: int) -> None: ...
class dispatcher_with_send(dispatcher):
def __init__(self, sock: socket.socket = ..., map: _maptype = ...) -> None: ...
def initiate_send(self) -> None: ...
def handle_write(self) -> None: ...
# incompatible signature:
# def send(self, data: str) -> Optional[int]: ...
def compact_traceback() -> Tuple[Tuple[str, str, str], type, type, str]: ...
def close_all(map: _maptype = ..., ignore_all: bool = ...) -> None: ...
# if os.name == 'posix':
# import fcntl
class file_wrapper:
fd = ... # type: int
def __init__(self, fd: int) -> None: ...
def recv(self, bufsize: int, flags: int = ...) -> str: ...
def send(self, data: str, flags: int = ...) -> int: ...
@overload
def getsockopt(self, level: int, optname: int) -> int: ...
@overload
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
def read(self, bufsize: int, flags: int = ...) -> str: ...
def write(self, data: str, flags: int = ...) -> int: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
class file_dispatcher(dispatcher):
def __init__(self, fd: int, map: _maptype = ...) -> None: ...
def set_file(self, fd: int) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/colorsys.pyi 0000644 0000000 0000000 00000001202 13023631176 017632 0 ustar root root # Stubs for colorsys
from typing import Tuple
def rgb_to_yiq(r: float, g: float, b: float) -> Tuple[float, float, float]: ...
def yiq_to_rgb(y: float, i: float, q: float) -> Tuple[float, float, float]: ...
def rgb_to_hls(r: float, g: float, b: float) -> Tuple[float, float, float]: ...
def hls_to_rgb(h: float, l: float, s: float) -> Tuple[float, float, float]: ...
def rgb_to_hsv(r: float, g: float, b: float) -> Tuple[float, float, float]: ...
def hsv_to_rgb(h: float, s: float, v: float) -> Tuple[float, float, float]: ...
# TODO undocumented
ONE_SIXTH = ... # type: float
ONE_THIRD = ... # type: float
TWO_THIRD = ... # type: float
mypy-0.470/typeshed/stdlib/2and3/xml/ 0000755 0000000 0000000 00000000000 13044320557 016040 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/xml/__init__.pyi 0000644 0000000 0000000 00000001237 13023631176 020324 0 ustar root root # Stubs for xml.sax (Python 3)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class SAXException(Exception):
def __init__(self, msg, exception=None): ...
def getMessage(self): ...
def getException(self): ...
def __getitem__(self, ix): ...
class SAXParseException(SAXException):
def __init__(self, msg, exception, locator): ...
def getColumnNumber(self): ...
def getLineNumber(self): ...
def getPublicId(self): ...
def getSystemId(self): ...
class SAXNotRecognizedException(SAXException): ...
class SAXNotSupportedException(SAXException): ...
class SAXReaderNotAvailable(SAXNotSupportedException): ...
mypy-0.470/typeshed/stdlib/2and3/xml/sax/ 0000755 0000000 0000000 00000000000 13044320557 016633 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/xml/sax/__init__.pyi 0000644 0000000 0000000 00000002216 13035744274 021124 0 ustar root root from typing import List
import xml.sax
from xml.sax.xmlreader import InputSource
from xml.sax.handler import ContentHandler, ErrorHandler
class SAXException(Exception):
def __init__(self, msg, exception=None): ...
def getMessage(self): ...
def getException(self): ...
def __getitem__(self, ix): ...
class SAXParseException(SAXException):
def __init__(self, msg, exception, locator): ...
def getColumnNumber(self): ...
def getLineNumber(self): ...
def getPublicId(self): ...
def getSystemId(self): ...
class SAXNotRecognizedException(SAXException): ...
class SAXNotSupportedException(SAXException): ...
class SAXReaderNotAvailable(SAXNotSupportedException): ...
default_parser_list = ... # type: List[str]
def make_parser(parser_list: List[str]) -> xml.sax.xmlreader.XMLReader: ...
def parse(source: str, handler: xml.sax.handler.ContentHandler,
errorHandler: xml.sax.handler.ErrorHandler=...): ...
def parseString(string: str, handler: xml.sax.handler.ContentHandler,
errorHandler: xml.sax.handler.ErrorHandler=...): ...
def _create_parser(parser_name: str) -> xml.sax.xmlreader.XMLReader: ...
mypy-0.470/typeshed/stdlib/2and3/xml/sax/saxutils.pyi 0000644 0000000 0000000 00000004375 13023631176 021242 0 ustar root root # Stubs for xml.sax.saxutils (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Mapping
from xml.sax import handler
from xml.sax import xmlreader
def escape(data: str, entities: Mapping[str, str] = ...) -> str: ...
def unescape(data: str, entities: Mapping[str, str] = ...) -> str: ...
def quoteattr(data: str, entities: Mapping[str, str] = ...) -> str: ...
class XMLGenerator(handler.ContentHandler):
def __init__(self, out=..., encoding=...) -> None: ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, content): ...
def processingInstruction(self, target, data): ...
class XMLFilterBase(xmlreader.XMLReader):
def __init__(self, parent=...) -> None: ...
def error(self, exception): ...
def fatalError(self, exception): ...
def warning(self, exception): ...
def setDocumentLocator(self, locator): ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, chars): ...
def processingInstruction(self, target, data): ...
def skippedEntity(self, name): ...
def notationDecl(self, name, publicId, systemId): ...
def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
def resolveEntity(self, publicId, systemId): ...
def parse(self, source): ...
def setLocale(self, locale): ...
def getFeature(self, name): ...
def setFeature(self, name, state): ...
def getProperty(self, name): ...
def setProperty(self, name, value): ...
def getParent(self): ...
def setParent(self, parent): ...
def prepare_input_source(source, base=...): ...
mypy-0.470/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi 0000644 0000000 0000000 00000004617 13023631176 021350 0 ustar root root # Stubs for xml.sax.xmlreader (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class XMLReader:
def __init__(self) -> None: ...
def parse(self, source): ...
def getContentHandler(self): ...
def setContentHandler(self, handler): ...
def getDTDHandler(self): ...
def setDTDHandler(self, handler): ...
def getEntityResolver(self): ...
def setEntityResolver(self, resolver): ...
def getErrorHandler(self): ...
def setErrorHandler(self, handler): ...
def setLocale(self, locale): ...
def getFeature(self, name): ...
def setFeature(self, name, state): ...
def getProperty(self, name): ...
def setProperty(self, name, value): ...
class IncrementalParser(XMLReader):
def __init__(self, bufsize=...) -> None: ...
def parse(self, source): ...
def feed(self, data): ...
def prepareParser(self, source): ...
def close(self): ...
def reset(self): ...
class Locator:
def getColumnNumber(self): ...
def getLineNumber(self): ...
def getPublicId(self): ...
def getSystemId(self): ...
class InputSource:
def __init__(self, system_id=...) -> None: ...
def setPublicId(self, public_id): ...
def getPublicId(self): ...
def setSystemId(self, system_id): ...
def getSystemId(self): ...
def setEncoding(self, encoding): ...
def getEncoding(self): ...
def setByteStream(self, bytefile): ...
def getByteStream(self): ...
def setCharacterStream(self, charfile): ...
def getCharacterStream(self): ...
class AttributesImpl:
def __init__(self, attrs) -> None: ...
def getLength(self): ...
def getType(self, name): ...
def getValue(self, name): ...
def getValueByQName(self, name): ...
def getNameByQName(self, name): ...
def getQNameByName(self, name): ...
def getNames(self): ...
def getQNames(self): ...
def __len__(self): ...
def __getitem__(self, name): ...
def keys(self): ...
def has_key(self, name): ...
def __contains__(self, name): ...
def get(self, name, alternative=...): ...
def copy(self): ...
def items(self): ...
def values(self): ...
class AttributesNSImpl(AttributesImpl):
def __init__(self, attrs, qnames) -> None: ...
def getValueByQName(self, name): ...
def getNameByQName(self, name): ...
def getQNameByName(self, name): ...
def getQNames(self): ...
def copy(self): ...
mypy-0.470/typeshed/stdlib/2and3/xml/sax/handler.pyi 0000644 0000000 0000000 00000003267 13035744274 021011 0 ustar root root # Stubs for xml.sax.handler (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
version = ... # type: Any
class ErrorHandler:
def error(self, exception): ...
def fatalError(self, exception): ...
def warning(self, exception): ...
class ContentHandler:
def __init__(self) -> None: ...
def setDocumentLocator(self, locator): ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, whitespace): ...
def processingInstruction(self, target, data): ...
def skippedEntity(self, name): ...
class DTDHandler:
def notationDecl(self, name, publicId, systemId): ...
def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
class EntityResolver:
def resolveEntity(self, publicId, systemId): ...
feature_namespaces = ... # type: Any
feature_namespace_prefixes = ... # type: Any
feature_string_interning = ... # type: Any
feature_validation = ... # type: Any
feature_external_ges = ... # type: Any
feature_external_pes = ... # type: Any
all_features = ... # type: Any
property_lexical_handler = ... # type: Any
property_declaration_handler = ... # type: Any
property_dom_node = ... # type: Any
property_xml_string = ... # type: Any
property_encoding = ... # type: Any
property_interning_dict = ... # type: Any
all_properties = ... # type: Any
mypy-0.470/typeshed/stdlib/2and3/hmac.pyi 0000644 0000000 0000000 00000002036 13023631176 016673 0 ustar root root # Stubs for hmac
from typing import Any, Callable, Optional, Union, overload
from types import ModuleType
import sys
_B = Union[bytes, bytearray]
# TODO more precise type for object of hashlib
_Hash = Any
if sys.version_info >= (3, 4):
def new(key: _B, msg: Optional[_B] = ...,
digestmod: Optional[Union[str, Callable[[], _Hash], ModuleType]] = ...) -> HMAC: ...
else:
def new(key: _B, msg: Optional[_B] = ...,
digestmod: Optional[Union[Callable[[], _Hash], ModuleType]] = ...) -> HMAC: ...
class HMAC:
if sys.version_info >= (3,):
digest_size = ... # type: int
if sys.version_info >= (3, 4):
block_size = ... # type: int
name = ... # type: str
def update(self, msg: _B) -> None: ...
def digest(self) -> bytes: ...
def hexdigest(self) -> str: ...
def copy(self) -> HMAC: ...
@overload
def compare_digest(a: str, b: str) -> bool: ...
@overload
def compare_digest(a: bytes, b: bytes) -> bool: ...
@overload
def compare_digest(a: bytearray, b: bytearray) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/pkgutil.pyi 0000644 0000000 0000000 00000002166 13035744274 017455 0 ustar root root # Stubs for pkgutil
from typing import Any, Callable, Generator, IO, Iterable, List, Optional, Tuple
import sys
if sys.version_info >= (3,):
from importlib.abc import Loader
else:
Loader = Any
_YMFNI = Generator[Tuple[Any, str, bool], None, None]
def extend_path(path: Iterable[str], name: str) -> Iterable[str]: ...
class ImpImporter:
def __init__(self, dirname: Optional[str] = ...) -> None: ...
class ImpLoader:
def __init__(self, fullname: str, file: IO[str], filename: str,
etc: Tuple[str, str, int]) -> None: ...
def find_loader(fullname: str) -> Loader: ...
def get_importer(path_item: str) -> Any: ... # TODO precise type
def get_loader(module_or_name: str) -> Loader: ...
def iter_importers(fullname: str = ...) -> Generator[Any, None, None]: ... # TODO precise type
def iter_modules(path: Optional[List[str]] = ...,
prefix: str = ...) -> _YMFNI: ... # TODO precise type
def walk_packages(path: Optional[str] = ..., prefix: str = ...,
onerror: Optional[Callable[[str], None]] = ...) -> _YMFNI: ...
def get_data(package: str, resource: str) -> bytes: ...
mypy-0.470/typeshed/stdlib/2and3/cProfile.pyi 0000644 0000000 0000000 00000001673 13035744274 017543 0 ustar root root from typing import Any, Callable, Dict, Optional, TypeVar
def run(statement: str, filename: Optional[str] = ..., sort: int = ...) -> None: ...
def runctx(statement: str, globals: Dict[str, Any], locals: Dict[str, Any], filename: Optional[str] = ..., sort: int = ...) -> None: ...
_SelfT = TypeVar('_SelfT', bound='Profile')
_T = TypeVar('_T')
class Profile:
def __init__(self, custom_timer: Callable[[], float] = ..., time_unit: float = ..., subcalls: bool = ..., builtins: bool = ...) -> None: ...
def enable(self) -> None: ...
def disable(self) -> None: ...
def print_stats(self, sort: int = ...) -> None: ...
def dump_stats(self, file: str) -> None: ...
def create_stats(self) -> None: ...
def run(self: _SelfT, cmd: str) -> _SelfT: ...
def runctx(self: _SelfT, cmd: str, globals: Dict[str, Any], locals: Dict[str, Any]) -> _SelfT: ...
def runcall(self, func: Callable[..., _T], *args: Any, **kw: Any) -> _T: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/ 0000755 0000000 0000000 00000000000 13044320557 017264 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021533 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/util.pyi 0000644 0000000 0000000 00000001574 13035744274 021001 0 ustar root root # Stubs for distutils.util
from typing import Any, Callable, List, Mapping, Optional, Tuple
def get_platform() -> str: ...
def convert_path(pathname: str) -> str: ...
def change_root(new_root: str, pathname: str) -> str: ...
def check_environ() -> None: ...
def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ...
def split_quoted(s: str) -> List[str]: ...
def execute(func: Callable[..., None], args: Tuple[Any, ...],
msg: Optional[str] = ..., verbose: bool = ...,
dry_run: bool = ...) -> None: ...
def strtobool(val: str) -> bool: ...
def byte_compile(py_files: List[str], optimize: int = ..., force: bool = ...,
prefix: Optional[str] = ..., base_dir: Optional[str] = ...,
verbose: bool = ..., dry_run: bool = ...,
direct: Optional[bool] = ...) -> None: ...
def rfc822_escape(header: str) -> str: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/extension.pyi 0000644 0000000 0000000 00000003261 13023631176 022024 0 ustar root root # Stubs for distutils.extension
from typing import List, Optional, Tuple
import sys
class Extension:
if sys.version_info >= (3,):
def __init__(self,
name: str,
sources: List[str],
include_dirs: List[str] = ...,
define_macros: List[Tuple[str, Optional[str]]] = ...,
undef_macros: List[str] = ...,
library_dirs: List[str] = ...,
libraries: List[str] = ...,
runtime_library_dirs: List[str] = ...,
extra_objects: List[str] = ...,
extra_compile_args: List[str] = ...,
extra_link_args: List[str] = ...,
export_symbols: List[str] = ...,
depends: List[str] = ...,
language: str = ...,
optional: bool = ...) -> None: ...
else:
def __init__(self,
name: str,
sources: List[str],
include_dirs: List[str] = ...,
define_macros: List[Tuple[str, Optional[str]]] = ...,
undef_macros: List[str] = ...,
library_dirs: List[str] = ...,
libraries: List[str] = ...,
runtime_library_dirs: List[str] = ...,
extra_objects: List[str] = ...,
extra_compile_args: List[str] = ...,
extra_link_args: List[str] = ...,
export_symbols: List[str] = ...,
depends: List[str] = ...,
language: str = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/dist.pyi 0000644 0000000 0000000 00000000252 13023631176 020750 0 ustar root root # Stubs for distutils.dist
from typing import Any, Mapping, Optional
class Distribution:
def __init__(self, attrs: Optional[Mapping[str, Any]] = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/fancy_getopt.pyi 0000644 0000000 0000000 00000001670 13023631176 022474 0 ustar root root # Stubs for distutils.fancy_getopt
from typing import (
Any, List, Mapping, Optional, Tuple, Union,
TypeVar, overload,
)
_Option = Tuple[str, str, str]
_GR = Tuple[List[str], OptionDummy]
def fancy_getopt(options: List[_Option],
negative_opt: Mapping[_Option, _Option],
object: Any,
args: Optional[List[str]]) -> Union[List[str], _GR]: ...
def wrap_text(text: str, width: int) -> List[str]: ...
class FancyGetopt:
def __init__(self, option_table: Optional[List[_Option]] = ...) -> None: ...
# TODO kinda wrong, `getopt(object=object())` is invalid
@overload
def getopt(self, args: Optional[List[str]] = ...) -> _GR: ...
@overload
def getopt(self, args: Optional[List[str]], object: Any) -> List[str]: ...
def get_option_order(self) -> List[Tuple[str, str]]: ...
def generate_help(self, header: Optional[str] = ...) -> List[str]: ...
class OptionDummy: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/version.pyi 0000644 0000000 0000000 00000001665 13023631176 021503 0 ustar root root # Stubs for distutils.version (Python 2 and 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
import sys
from typing import Any
class Version:
def __init__(self, vstring=None): ...
if sys.version_info >= (3,):
def __eq__(self, other): ...
def __lt__(self, other): ...
def __le__(self, other): ...
def __gt__(self, other): ...
def __ge__(self, other): ...
class StrictVersion(Version):
version_re = ... # type: Any
version = ... # type: Any
prerelease = ... # type: Any
def parse(self, vstring): ...
if sys.version_info < (3,):
def __cmp__(self, other): ...
class LooseVersion(Version):
component_re = ... # type: Any
def __init__(self, vstring=None): ...
vstring = ... # type: Any
version = ... # type: Any
def parse(self, vstring): ...
if sys.version_info < (3,):
def __cmp__(self, other): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/file_util.pyi 0000644 0000000 0000000 00000000756 13023631176 021772 0 ustar root root # Stubs for distutils.file_util
from typing import Optional, Sequence, Tuple
def copy_file(src: str, dst: str, preserve_mode: bool = ...,
preserve_times: bool = ..., update: bool = ...,
link: Optional[str] = ..., verbose: bool = ...,
dry_run: bool = ...) -> Tuple[str, str]: ...
def move_file(src: str, dst: str, verbose: bool = ...,
dry_run: bool = ...) -> str: ...
def write_file(filename: str, contents: Sequence[str]) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/dir_util.pyi 0000644 0000000 0000000 00000001176 13023631176 021626 0 ustar root root # Stubs for distutils.dir_util
from typing import List
def mkpath(name: str, mode: int = ..., verbose: int = ...,
dry_run: int = ...) -> List[str]: ...
def create_tree(base_dir: str, files: List[str], mode: int = ...,
verbose: int = ..., dry_run: int = ...) -> None: ...
def copy_tree(src: str, dst: str, preserve_mode: int = ...,
preserve_times: int = ..., preserve_symlinks: int = ...,
update: int = ..., verbose: int = ...,
dry_run: int = ...) -> List[str]: ...
def remove_tree(directory: str, verbose: int = ...,
dry_run: int = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/filelist.pyi 0000644 0000000 0000000 00000000064 13023631176 021621 0 ustar root root # Stubs for distutils.filelist
class FileList: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/sysconfig.pyi 0000644 0000000 0000000 00000001320 13023631176 022006 0 ustar root root # Stubs for distutils.sysconfig
from typing import Mapping, Optional, Union
from distutils.ccompiler import CCompiler
PREFIX = ... # type: str
EXEC_PREFIX = ... # type: str
def get_config_var(name: str) -> Union[int, str, None]: ...
def get_config_vars(*args: str) -> Mapping[str, Union[int, str]]: ...
def get_config_h_filename() -> str: ...
def get_makefile_filename() -> str: ...
def get_python_inc(plat_specific: bool = ...,
prefix: Optional[str] = ...) -> str: ...
def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ...,
prefix: Optional[str] = ...) -> str: ...
def customize_compiler(compiler: CCompiler) -> None: ...
def set_python_build() -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/text_file.pyi 0000644 0000000 0000000 00000001370 13035744274 022001 0 ustar root root # Stubs for distutils.text_file
from typing import IO, List, Optional, Tuple, Union
class TextFile:
def __init__(self, filename: Optional[str] = ...,
file: Optional[IO[str]] = ...,
*, strip_comments: bool = ...,
lstrip_ws: bool = ..., rstrip_ws: bool = ...,
skip_blanks: bool = ..., join_lines: bool = ...,
collapse_join: bool = ...) -> None: ...
def open(self, filename: str) -> None: ...
def close(self) -> None: ...
def warn(self, msg: str,
line: Union[List[int], Tuple[int, int], int] = ...) -> None: ...
def readline(self) -> Optional[str]: ...
def readlines(self) -> List[str]: ...
def unreadline(self, line: str) -> str: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/log.pyi 0000644 0000000 0000000 00000000000 13023631176 020555 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/bcppcompiler.pyi 0000644 0000000 0000000 00000000163 13023631176 022465 0 ustar root root # Stubs for distutils.bcppcompiler
from distutils.ccompiler import CCompiler
class BCPPCompiler(CCompiler): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/command/ 0000755 0000000 0000000 00000000000 13044320557 020702 5 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 023151 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/install_headers.pyi 0000644 0000000 0000000 00000000000 13023631176 024553 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/build_clib.pyi 0000644 0000000 0000000 00000000000 13023631176 023502 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/install_lib.pyi 0000644 0000000 0000000 00000000000 13023631176 023706 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/install.pyi 0000644 0000000 0000000 00000000000 13023631176 023060 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/check.pyi 0000644 0000000 0000000 00000000000 13023631176 022467 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist.pyi 0000644 0000000 0000000 00000000000 13023631176 022517 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/build.pyi 0000644 0000000 0000000 00000000000 13023631176 022511 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/install_data.pyi 0000644 0000000 0000000 00000000000 13023631176 024051 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist_rpm.pyi 0000644 0000000 0000000 00000000000 13023631176 023375 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/sdist.pyi 0000644 0000000 0000000 00000000000 13023631176 022540 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/build_scripts.pyi 0000644 0000000 0000000 00000000000 13023631176 024260 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/clean.pyi 0000644 0000000 0000000 00000000000 13023631176 022474 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist_packager.pyi 0000644 0000000 0000000 00000000000 13023631176 024354 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist_wininst.pyi 0000644 0000000 0000000 00000000000 13023631176 024272 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/install_scripts.pyi 0000644 0000000 0000000 00000000000 13023631176 024627 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/build_py.pyi 0000644 0000000 0000000 00000000273 13023631176 023235 0 ustar root root # Stubs for distutils.command.bdist_msi
from distutils.cmd import Command
import sys
if sys.version_info >= (3,):
class build_py(Command): ...
class build_py_2to3(Command): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist_msi.pyi 0000644 0000000 0000000 00000000152 13023631176 023377 0 ustar root root # Stubs for distutils.command.bdist_msi
from distutils.cmd import Command
class bdist_msi(Command): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/command/bdist_dumb.pyi 0000644 0000000 0000000 00000000000 13023631176 023526 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/build_ext.pyi 0000644 0000000 0000000 00000000000 13023631176 023371 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/register.pyi 0000644 0000000 0000000 00000000000 13023631176 023236 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/command/config.pyi 0000644 0000000 0000000 00000000000 13023631176 022657 0 ustar root root mypy-0.470/typeshed/stdlib/2and3/distutils/dep_util.pyi 0000644 0000000 0000000 00000000457 13023631176 021621 0 ustar root root # Stubs for distutils.dep_util
from typing import List, Tuple
def newer(source: str, target: str) -> bool: ...
def newer_pairwise(sources: List[str],
targets: List[str]) -> List[Tuple[str, str]]: ...
def newer_group(sources: List[str], target: str, missing: str = ...) -> bool: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/spawn.pyi 0000644 0000000 0000000 00000000436 13035744274 021150 0 ustar root root # Stubs for distutils.spawn
from typing import List, Optional
def spawn(cmd: List[str], search_path: bool = ...,
verbose: bool = ..., dry_run: bool = ...) -> None: ...
def find_executable(executable: str,
path: Optional[str] = ...) -> Optional[str]: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/errors.pyi 0000644 0000000 0000000 00000000160 13023631176 021317 0 ustar root root # Stubs for distutils.errors
class DistutilsExecError(Exception): ...
class DistutilsFileError(Exception): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/debug.pyi 0000644 0000000 0000000 00000000067 13023631176 021077 0 ustar root root # Stubs for distutils.debug
DEBUG = ... # type: bool
mypy-0.470/typeshed/stdlib/2and3/distutils/core.pyi 0000644 0000000 0000000 00000002547 13023631176 020746 0 ustar root root # Stubs for distutils.core
from typing import Any, List, Mapping, Optional, Tuple, Type, Union
from distutils.cmd import Command as Command
from distutils.dist import Distribution as Distribution
from distutils.extension import Extension as Extension
def setup(name: str = ...,
version: str = ...,
description: str = ...,
long_description: str = ...,
author: str = ...,
author_email: str = ...,
maintainer: str = ...,
maintainer_email: str = ...,
url: str = ...,
download_url: str = ...,
packages: List[str] = ...,
py_modules: List[str] = ...,
scripts: List[str] = ...,
ext_modules: List[Extension] = ...,
classifiers: List[str] = ...,
distclass: Type[Distribution] = ...,
script_name: str = ...,
script_args: List[str] = ...,
options: Mapping[str, Any] = ...,
license: str = ...,
keywords: Union[List[str], str] = ...,
platforms: Union[List[str], str] = ...,
cmdclass: Mapping[str, Command] = ...,
data_files: List[Tuple[str, List[str]]] = ...,
package_dir: Mapping[str, str] = ...) -> None: ...
def run_setup(script_name: str,
script_args: Optional[List[str]] = ...,
stop_after: str = ...) -> Distribution: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/cmd.pyi 0000644 0000000 0000000 00000000746 13023631176 020560 0 ustar root root # Stubs for distutils.cmd
from typing import Callable, List, Tuple, Union
from abc import abstractmethod
from distutils.dist import Distribution
class Command:
sub_commands = ... # type: List[Tuple[str, Union[Callable[[], bool], str, None]]]
def __init__(self, dist: Distribution) -> None: ...
@abstractmethod
def initialize_options(self) -> None: ...
@abstractmethod
def finalize_options(self) -> None: ...
@abstractmethod
def run(self) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/unixccompiler.pyi 0000644 0000000 0000000 00000000165 13023631176 022671 0 ustar root root # Stubs for distutils.unixccompiler
from distutils.ccompiler import CCompiler
class UnixCCompiler(CCompiler): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/msvccompiler.pyi 0000644 0000000 0000000 00000000163 13023631176 022511 0 ustar root root # Stubs for distutils.msvccompiler
from distutils.ccompiler import CCompiler
class MSVCCompiler(CCompiler): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/archive_util.pyi 0000644 0000000 0000000 00000001015 13023631176 022461 0 ustar root root # Stubs for distutils.archive_util
from typing import Optional
def make_archive(base_name: str, format: str, root_dir: Optional[str] = ...,
base_dir: Optional[str] = ..., verbose: int = ...,
dry_run: int = ...) -> str: ...
def make_tarball(base_name: str, base_dir: str, compress: Optional[str] = ...,
verbose: int = ..., dry_run: int = ...) -> str: ...
def make_zipfile(base_name: str, base_dir: str, verbose: int = ...,
dry_run: int = ...) -> str: ...
mypy-0.470/typeshed/stdlib/2and3/distutils/cygwinccompiler.pyi 0000644 0000000 0000000 00000000262 13023631176 023204 0 ustar root root # Stubs for distutils.cygwinccompiler
from distutils.unixccompiler import UnixCCompiler
class CygwinCCompiler(UnixCCompiler): ...
class Mingw32CCompiler(CygwinCCompiler): ...
mypy-0.470/typeshed/stdlib/2and3/distutils/ccompiler.pyi 0000644 0000000 0000000 00000015461 13023631176 021772 0 ustar root root # Stubs for distutils.ccompiler
from typing import Any, Callable, List, Optional, Tuple, Union
_Macro = Union[Tuple[str], Tuple[str, str]]
def gen_lib_options(compiler: CCompiler, library_dirs: List[str],
runtime_library_dirs: List[str],
libraries: List[str]) -> List[str]: ...
def gen_preprocess_options(macros: List[_Macro],
include_dirs: List[str]) -> List[str]: ...
def get_default_compiler(osname: Optional[str] = ...,
platform: Optional[str] = ...) -> str: ...
def new_compiler(plat: Optional[str] = ..., compiler: Optional[str] = ...,
verbose: int = ..., dry_run: int = ...,
force: int = ...) -> CCompiler: ...
def show_compilers() -> None: ...
class CCompiler:
def __init__(self, verbose: int = ..., dry_run: int = ...,
force: int = ...) -> None: ...
def add_include_dir(self, dir: str) -> None: ...
def set_include_dirs(self, dirs: List[str]) -> None: ...
def add_library(self, libname: str) -> None: ...
def set_libraries(self, libnames: List[str]) -> None: ...
def add_library_dir(self, dir: str) -> None: ...
def set_library_dirs(self, dirs: List[str]) -> None: ...
def add_runtime_library_dir(self, dir: str) -> None: ...
def set_runtime_library_dirs(self, dirs: List[str]) -> None: ...
def define_macro(self, name: str, value: Optional[str] = ...) -> None: ...
def undefine_macro(self, name: str) -> None: ...
def add_link_object(self, object: str) -> None: ...
def set_link_objects(self, objects: List[str]) -> None: ...
def detect_language(self, sources: Union[str, List[str]]) -> Optional[str]: ...
def find_library_file(self, dirs: List[str], lib: str,
debug: bool = ...) -> Optional[str]: ...
def has_function(self, funcname: str, includes: Optional[List[str]] = ...,
include_dirs: Optional[List[str]] = ...,
libraries: Optional[List[str]] = ...,
library_dirs: Optional[List[str]] = ...) -> bool: ...
def library_dir_option(self, dir: str) -> str: ...
def library_option(self, lib: str) -> str: ...
def runtime_library_dir_option(self, dir: str) -> str: ...
def set_executables(self, **args: str) -> None: ...
def compile(self, sources: List[str], output_dir: Optional[str] = ...,
macros: Optional[_Macro] = ...,
include_dirs: Optional[List[str]] = ..., debug: bool = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...,
depends: Optional[List[str]] = ...) -> List[str]: ...
def create_static_lib(self, objects: List[str], output_libname: str,
output_dir: Optional[str] = ..., debug: bool = ...,
target_lang: Optional[str] = ...) -> None: ...
def link(self, target_desc: str, objects: List[str], output_filename: str,
output_dir: Optional[str] = ...,
libraries: Optional[List[str]] = ...,
library_dirs: Optional[List[str]] = ...,
runtime_library_dirs: Optional[List[str]] = ...,
export_symbols: Optional[List[str]] = ..., debug: bool = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...,
build_temp: Optional[str] = ...,
target_lang: Optional[str] = ...) -> None: ...
def link_executable(self, objects: List[str], output_progname: str,
output_dir: Optional[str] = ...,
libraries: Optional[List[str]] = ...,
library_dirs: Optional[List[str]] = ...,
runtime_library_dirs: Optional[List[str]] = ...,
debug: bool = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...,
target_lang: Optional[str] = ...) -> None: ...
def link_shared_lib(self, objects: List[str], output_libname: str,
output_dir: Optional[str] = ...,
libraries: Optional[List[str]] = ...,
library_dirs: Optional[List[str]] = ...,
runtime_library_dirs: Optional[List[str]] = ...,
export_symbols: Optional[List[str]] = ...,
debug: bool = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...,
build_temp: Optional[str] = ...,
target_lang: Optional[str] = ...) -> None: ...
def link_shared_object(self, objects: List[str], output_filename: str,
output_dir: Optional[str] = ...,
libraries: Optional[List[str]] = ...,
library_dirs: Optional[List[str]] = ...,
runtime_library_dirs: Optional[List[str]] = ...,
export_symbols: Optional[List[str]] = ...,
debug: bool = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...,
build_temp: Optional[str] = ...,
target_lang: Optional[str] = ...) -> None: ...
def preprocess(self, source: str, output_file: Optional[str] = ...,
macros: Optional[List[_Macro]] = ...,
include_dirs: Optional[List[str]] = ...,
extra_preargs: Optional[List[str]] = ...,
extra_postargs: Optional[List[str]] = ...) -> None: ...
def executable_filename(self, basename: str, strip_dir: int = ...,
output_dir: str = ...) -> str: ...
def library_filename(self, libname: str, lib_type: str = ...,
strip_dir: int = ...,
output_dir: str = ...) -> str: ...
def object_filenames(self, source_filenames: List[str],
strip_dir: int = ...,
output_dir: str = ...) -> List[str]: ...
def shared_object_filename(self, basename: str, strip_dir: int = ...,
output_dir: str = ...) -> str: ...
def execute(self, func: Callable[..., None], args: Tuple[Any, ...],
msg: Optional[str] = ..., level: int = ...) -> None: ...
def spawn(self, cmd: List[str]) -> None: ...
def mkpath(self, name: str, mode: int = ...) -> None: ...
def move_file(self, src: str, dst: str) -> str: ...
def announce(self, msg: str, level: int = ...) -> None: ...
def warn(self, msg: str) -> None: ...
def debug_print(self, msg: str) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/code.pyi 0000644 0000000 0000000 00000002243 13023631176 016675 0 ustar root root # Stubs for code
from typing import Any, Callable, Mapping, Optional
from types import CodeType
class InteractiveInterpreter:
def __init__(self, locals: Optional[Mapping[str, Any]] = ...) -> None: ...
def runsource(self, source: str, filename: str = ...,
symbol: str = ...) -> bool: ...
def runcode(self, code: CodeType) -> None: ...
def showsyntaxerror(self, filename: Optional[str] = ...) -> None: ...
def showtraceback(self) -> None: ...
def write(self, data: str) -> None: ...
class InteractiveConsole(InteractiveInterpreter):
def __init__(self, locals: Optional[Mapping[str, Any]] = ...,
filename: str = ...) -> None: ...
def interact(self, banner: Optional[str] = ...) -> None: ...
def push(self, line: str) -> bool: ...
def resetbuffer(self) -> None: ...
def raw_input(self, prompt: str = ...) -> str: ...
def interact(banner: Optional[str] = ...,
readfunc: Optional[Callable[[str], str]] = ...,
local: Optional[Mapping[str, Any]] = ...) -> None: ...
def compile_command(source: str, filename: str = ...,
symbol: str = ...) -> Optional[CodeType]: ...
mypy-0.470/typeshed/stdlib/2and3/mmap.pyi 0000644 0000000 0000000 00000005705 13035744274 016732 0 ustar root root # Stubs for mmap
import sys
from types import TracebackType
from typing import (Optional, Sequence, Union, Generic, TypeVar, overload,
Iterable, Container, Sized, Reversible, Type)
_T = TypeVar('_T', str, bytes)
# TODO already in PEP, have to get added to mypy
_C = TypeVar('_C')
class _ContextManager(Generic[_C]):
def __enter__(self) -> _C: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
ACCESS_READ = ... # type: int
ACCESS_WRITE = ... # type: int
ACCESS_COPY = ... # type: int
ALLOCATIONGRANULARITY = ... # type: int
if sys.platform != 'win32':
MAP_PRIVATE = ... # type: int
MAP_SHARED = ... # type: int
PROT_READ = ... # type: int
PROT_WRITE = ... # type: int
PAGESIZE = ... # type: int
class _mmap(Generic[_T]):
if sys.platform == 'win32':
def __init__(self, fileno: int, length: int,
tagname: Optional[str] = ..., access: int = ...,
offset: int = ...) -> None: ...
else:
def __init__(self,
fileno: int, length: int, flags: int = ...,
prot: int = ..., access: int = ...,
offset: int = ...) -> None: ...
def close(self) -> None: ...
def find(self, sub: _T,
start: int = ..., end: int = ...) -> int: ...
def flush(self, offset: int = ..., size: int = ...) -> int: ...
def move(self, dest: int, src: int, count: int) -> None: ...
def read(self, n: int = ...) -> _T: ...
def read_byte(self) -> _T: ...
def readline(self) -> _T: ...
def resize(self, newsize: int) -> None: ...
def seek(self, pos: int, whence: int = ...) -> None: ...
def size(self) -> int: ...
def tell(self) -> int: ...
def write(self, bytes: _T) -> None: ...
def write_byte(self, byte: _T) -> None: ...
def __len__(self) -> int: ...
if sys.version_info >= (3,):
class mmap(_mmap, _ContextManager[mmap], Iterable[bytes], Container[bytes],
Sized, Reversible[bytes]):
closed = ... # type: bool
def rfind(self, sub: bytes, start: int = ..., stop: int = ...) -> int: ...
@overload
def __getitem__(self, index: int) -> int: ...
@overload
def __getitem__(self, index: slice) -> bytes: ...
def __delitem__(self, index: Union[int, slice]) -> None: ...
@overload
def __setitem__(self, index: int, object: int) -> None: ...
@overload
def __setitem__(self, index: slice, object: bytes) -> None: ...
else:
class mmap(_mmap, Sequence[bytes]):
def rfind(self, string: bytes, start: int = ..., stop: int = ...) -> int: ...
def __getitem__(self, index: Union[int, slice]) -> bytes: ...
def __delitem__(self, index: Union[int, slice]) -> None: ...
def __setitem__(self, index: Union[int, slice], object: bytes) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/asynchat.pyi 0000644 0000000 0000000 00000003005 13035744274 017601 0 ustar root root from abc import abstractmethod
import asyncore
import socket
import sys
from typing import Union, Tuple, Sequence
class simple_producer:
def __init__(self, data: str, buffer_size: int = ...) -> None: ...
def more(self) -> str: ...
class async_chat (asyncore.dispatcher):
ac_in_buffer_size = ... # type: int
ac_out_buffer_size = ... # type: int
def __init__(self, sock: socket.socket = None, map: asyncore._maptype = None) -> None: ...
@abstractmethod
def collect_incoming_data(self, data: str) -> None: ...
@abstractmethod
def found_terminator(self) -> None: ...
def set_terminator(self, term: Union[str, int, None]) -> None: ...
def get_terminator(self) -> Union[str, int, None]: ...
def handle_read(self) -> None: ...
def handle_write(self) -> None: ...
def handle_close(self) -> None: ...
def push(self, data: str) -> None: ...
def push_with_producer(self, producer: simple_producer) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def close_when_done(self) -> None: ...
def initiate_send(self) -> None: ...
def discard_buffers(self) -> None: ...
if sys.version_info < (3, 0, 0):
class fifo:
def __init__(self, list: Sequence[Union[str, simple_producer]] = ...) -> None: ...
def __len__(self) -> int: ...
def is_empty(self) -> bool: ...
def first(self) -> str: ...
def push(self, data: Union[str, simple_producer]) -> None: ...
def pop(self) -> Tuple[int, str]: ...
mypy-0.470/typeshed/stdlib/2and3/mimetypes.pyi 0000644 0000000 0000000 00000003263 13035744274 020011 0 ustar root root # Stubs for mimetypes
from typing import Dict, IO, List, Optional, Sequence, Text, Tuple
import sys
def guess_type(url: Text,
strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
def guess_all_extensions(type: str, strict: bool = ...) -> List[str]: ...
def guess_extension(type: str, strict: bool = ...) -> Optional[str]: ...
def init(files: Optional[Sequence[str]] = ...) -> None: ...
def read_mime_types(filename: str) -> Optional[Dict[str, str]]: ...
def add_type(type: str, ext: str, strict: bool = ...) -> None: ...
inited = ... # type: bool
knownfiles = ... # type: List[str]
suffix_map = ... # type: Dict[str, str]
encodings_map = ... # type: Dict[str, str]
types_map = ... # type: Dict[str, str]
common_types = ... # type: Dict[str, str]
class MimeTypes:
suffix_map = ... # type: Dict[str, str]
encodings_map = ... # type: Dict[str, str]
types_map = ... # type: Tuple[Dict[str, str], Dict[str, str]]
types_map_inv = ... # type: Tuple[Dict[str, str], Dict[str, str]]
def __init__(self, filenames: Tuple[str, ...] = ...,
strict: bool = ...) -> None: ...
def guess_extension(self, type: str,
strict: bool = ...) -> Optional[str]: ...
def guess_type(self, url: str,
strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
def guess_all_extensions(self, type: str,
strict: bool = ...) -> List[str]: ...
def read(self, filename: str, strict: bool = ...) -> None: ...
def readfp(self, fp: IO[str], strict: bool = ...) -> None: ...
if sys.platform == 'win32':
def read_windows_registry(self, strict: bool = ...) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/pstats.pyi 0000644 0000000 0000000 00000003441 13035744274 017311 0 ustar root root from profile import Profile
from cProfile import Profile as cProfile
from typing import Any, AnyStr, Dict, IO, Iterable, List, Text, Tuple, TypeVar, Union, overload
_Selector = Union[str, float, int]
_T = TypeVar('_T', bound='Stats')
class Stats:
def __init__(self: _T, __arg: Union[None, str, Text, Profile, cProfile] = ...,
*args: Union[None, str, Text, Profile, cProfile, _T],
stream: IO[Any]) -> None: ...
def init(self, arg: Union[None, str, Text, Profile, cProfile]) -> None: ...
def load_stats(self, arg: Union[None, str, Text, Profile, cProfile]) -> None: ...
def get_top_level_stats(self) -> None: ...
def add(self: _T, *arg_list: Union[None, str, Text, Profile, cProfile, _T]) -> _T: ...
def dump_stats(self, filename: AnyStr) -> None: ...
def get_sort_arg_defs(self) -> Dict[str, Tuple[Tuple[Tuple[int, int], ...], str]]: ...
@overload
def sort_stats(self: _T, field: int) -> _T: ...
@overload
def sort_stats(self: _T, *field: str) -> _T: ...
def reverse_order(self: _T) -> _T: ...
def strip_dirs(self: _T) -> _T: ...
def calc_callees(self) -> None: ...
def eval_print_amount(self, sel: _Selector, list: List[str], msg: str) -> Tuple[List[str], str]: ...
def get_print_list(self, sel_list: Iterable[_Selector]) -> Tuple[int, List[str]]: ...
def print_stats(self: _T, *amount: _Selector) -> _T: ...
def print_callees(self: _T, *amount: _Selector) -> _T: ...
def print_callers(self: _T, *amount: _Selector) -> _T: ...
def print_call_heading(self, name_size: int, column_title: str) -> None: ...
def print_call_line(self, name_size: int, source: str, call_dict: Dict[str, Any], arrow: str = ...) -> None: ...
def print_title(self) -> None: ...
def print_line(self, func: str) -> None: ...
mypy-0.470/typeshed/stdlib/2and3/site.pyi 0000644 0000000 0000000 00000001032 13023631176 016722 0 ustar root root # Stubs for site
from typing import List, Iterable, Optional
import sys
PREFIXES = ... # type: List[str]
ENABLE_USER_SITE = ... # type: Optional[bool]
USER_SITE = ... # type: Optional[str]
USER_BASE = ... # type: Optional[str]
if sys.version_info < (3,):
def main() -> None: ...
def addsitedir(sitedir: str,
known_paths: Optional[Iterable[str]] = ...) -> None: ...
def getsitepackages(prefixes: Optional[Iterable[str]] = ...) -> List[str]: ...
def getuserbase() -> str: ...
def getusersitepackages() -> str: ...
mypy-0.470/typeshed/stdlib/3/ 0000755 0000000 0000000 00000000000 13044320557 014473 5 ustar root root mypy-0.470/typeshed/stdlib/3/socket.pyi 0000644 0000000 0000000 00000021305 13035744274 016515 0 ustar root root # Stubs for socket
# Ron Murawski
# based on: http://docs.python.org/3.2/library/socket.html
# see: http://hg.python.org/cpython/file/3d0686d90f55/Lib/socket.py
# see: http://nullege.com/codes/search/socket
from typing import Any, Tuple, List, Optional, Union, overload
# ----- variables and constants -----
AF_UNIX = 0
AF_INET = 0
AF_INET6 = 0
SOCK_STREAM = 0
SOCK_DGRAM = 0
SOCK_RAW = 0
SOCK_RDM = 0
SOCK_SEQPACKET = 0
SOCK_CLOEXEC = 0
SOCK_NONBLOCK = 0
SOMAXCONN = 0
has_ipv6 = False
_GLOBAL_DEFAULT_TIMEOUT = 0.0
SocketType = ... # type: Any
SocketIO = ... # type: Any
# the following constants are included with Python 3.2.3 (Ubuntu)
# some of the constants may be Linux-only
# all Windows/Mac-specific constants are absent
AF_APPLETALK = 0
AF_ASH = 0
AF_ATMPVC = 0
AF_ATMSVC = 0
AF_AX25 = 0
AF_BLUETOOTH = 0
AF_BRIDGE = 0
AF_DECnet = 0
AF_ECONET = 0
AF_IPX = 0
AF_IRDA = 0
AF_KEY = 0
AF_LLC = 0
AF_NETBEUI = 0
AF_NETLINK = 0
AF_NETROM = 0
AF_PACKET = 0
AF_PPPOX = 0
AF_ROSE = 0
AF_ROUTE = 0
AF_SECURITY = 0
AF_SNA = 0
AF_TIPC = 0
AF_UNSPEC = 0
AF_WANPIPE = 0
AF_X25 = 0
AI_ADDRCONFIG = 0
AI_ALL = 0
AI_CANONNAME = 0
AI_NUMERICHOST = 0
AI_NUMERICSERV = 0
AI_PASSIVE = 0
AI_V4MAPPED = 0
BDADDR_ANY = 0
BDADDR_LOCAL = 0
BTPROTO_HCI = 0
BTPROTO_L2CAP = 0
BTPROTO_RFCOMM = 0
BTPROTO_SCO = 0
CAPI = 0
EAGAIN = 0
EAI_ADDRFAMILY = 0
EAI_AGAIN = 0
EAI_BADFLAGS = 0
EAI_FAIL = 0
EAI_FAMILY = 0
EAI_MEMORY = 0
EAI_NODATA = 0
EAI_NONAME = 0
EAI_OVERFLOW = 0
EAI_SERVICE = 0
EAI_SOCKTYPE = 0
EAI_SYSTEM = 0
EBADF = 0
EINTR = 0
EWOULDBLOCK = 0
HCI_DATA_DIR = 0
HCI_FILTER = 0
HCI_TIME_STAMP = 0
INADDR_ALLHOSTS_GROUP = 0
INADDR_ANY = 0
INADDR_BROADCAST = 0
INADDR_LOOPBACK = 0
INADDR_MAX_LOCAL_GROUP = 0
INADDR_NONE = 0
INADDR_UNSPEC_GROUP = 0
IPPORT_RESERVED = 0
IPPORT_USERRESERVED = 0
IPPROTO_AH = 0
IPPROTO_DSTOPTS = 0
IPPROTO_EGP = 0
IPPROTO_ESP = 0
IPPROTO_FRAGMENT = 0
IPPROTO_GRE = 0
IPPROTO_HOPOPTS = 0
IPPROTO_ICMP = 0
IPPROTO_ICMPV6 = 0
IPPROTO_IDP = 0
IPPROTO_IGMP = 0
IPPROTO_IP = 0
IPPROTO_IPIP = 0
IPPROTO_IPV6 = 0
IPPROTO_NONE = 0
IPPROTO_PIM = 0
IPPROTO_PUP = 0
IPPROTO_RAW = 0
IPPROTO_ROUTING = 0
IPPROTO_RSVP = 0
IPPROTO_TCP = 0
IPPROTO_TP = 0
IPPROTO_UDP = 0
IPV6_CHECKSUM = 0
IPV6_DSTOPTS = 0
IPV6_HOPLIMIT = 0
IPV6_HOPOPTS = 0
IPV6_JOIN_GROUP = 0
IPV6_LEAVE_GROUP = 0
IPV6_MULTICAST_HOPS = 0
IPV6_MULTICAST_IF = 0
IPV6_MULTICAST_LOOP = 0
IPV6_NEXTHOP = 0
IPV6_PKTINFO = 0
IPV6_RECVDSTOPTS = 0
IPV6_RECVHOPLIMIT = 0
IPV6_RECVHOPOPTS = 0
IPV6_RECVPKTINFO = 0
IPV6_RECVRTHDR = 0
IPV6_RECVTCLASS = 0
IPV6_RTHDR = 0
IPV6_RTHDRDSTOPTS = 0
IPV6_RTHDR_TYPE_0 = 0
IPV6_TCLASS = 0
IPV6_UNICAST_HOPS = 0
IPV6_V6ONLY = 0
IP_ADD_MEMBERSHIP = 0
IP_DEFAULT_MULTICAST_LOOP = 0
IP_DEFAULT_MULTICAST_TTL = 0
IP_DROP_MEMBERSHIP = 0
IP_HDRINCL = 0
IP_MAX_MEMBERSHIPS = 0
IP_MULTICAST_IF = 0
IP_MULTICAST_LOOP = 0
IP_MULTICAST_TTL = 0
IP_OPTIONS = 0
IP_RECVOPTS = 0
IP_RECVRETOPTS = 0
IP_RETOPTS = 0
IP_TOS = 0
IP_TTL = 0
MSG_CTRUNC = 0
MSG_DONTROUTE = 0
MSG_DONTWAIT = 0
MSG_EOR = 0
MSG_OOB = 0
MSG_PEEK = 0
MSG_TRUNC = 0
MSG_WAITALL = 0
NETLINK_DNRTMSG = 0
NETLINK_FIREWALL = 0
NETLINK_IP6_FW = 0
NETLINK_NFLOG = 0
NETLINK_ROUTE = 0
NETLINK_USERSOCK = 0
NETLINK_XFRM = 0
NI_DGRAM = 0
NI_MAXHOST = 0
NI_MAXSERV = 0
NI_NAMEREQD = 0
NI_NOFQDN = 0
NI_NUMERICHOST = 0
NI_NUMERICSERV = 0
PACKET_BROADCAST = 0
PACKET_FASTROUTE = 0
PACKET_HOST = 0
PACKET_LOOPBACK = 0
PACKET_MULTICAST = 0
PACKET_OTHERHOST = 0
PACKET_OUTGOING = 0
PF_PACKET = 0
SHUT_RD = 0
SHUT_RDWR = 0
SHUT_WR = 0
SOL_HCI = 0
SOL_IP = 0
SOL_SOCKET = 0
SOL_TCP = 0
SOL_TIPC = 0
SOL_UDP = 0
SO_ACCEPTCONN = 0
SO_BROADCAST = 0
SO_DEBUG = 0
SO_DONTROUTE = 0
SO_ERROR = 0
SO_KEEPALIVE = 0
SO_LINGER = 0
SO_OOBINLINE = 0
SO_RCVBUF = 0
SO_RCVLOWAT = 0
SO_RCVTIMEO = 0
SO_REUSEADDR = 0
SO_SNDBUF = 0
SO_SNDLOWAT = 0
SO_SNDTIMEO = 0
SO_TYPE = 0
TCP_CORK = 0
TCP_DEFER_ACCEPT = 0
TCP_INFO = 0
TCP_KEEPCNT = 0
TCP_KEEPIDLE = 0
TCP_KEEPINTVL = 0
TCP_LINGER2 = 0
TCP_MAXSEG = 0
TCP_NODELAY = 0
TCP_QUICKACK = 0
TCP_SYNCNT = 0
TCP_WINDOW_CLAMP = 0
TIPC_ADDR_ID = 0
TIPC_ADDR_NAME = 0
TIPC_ADDR_NAMESEQ = 0
TIPC_CFG_SRV = 0
TIPC_CLUSTER_SCOPE = 0
TIPC_CONN_TIMEOUT = 0
TIPC_CRITICAL_IMPORTANCE = 0
TIPC_DEST_DROPPABLE = 0
TIPC_HIGH_IMPORTANCE = 0
TIPC_IMPORTANCE = 0
TIPC_LOW_IMPORTANCE = 0
TIPC_MEDIUM_IMPORTANCE = 0
TIPC_NODE_SCOPE = 0
TIPC_PUBLISHED = 0
TIPC_SRC_DROPPABLE = 0
TIPC_SUBSCR_TIMEOUT = 0
TIPC_SUB_CANCEL = 0
TIPC_SUB_PORTS = 0
TIPC_SUB_SERVICE = 0
TIPC_TOP_SRV = 0
TIPC_WAIT_FOREVER = 0
TIPC_WITHDRAWN = 0
TIPC_ZONE_SCOPE = 0
# ----- exceptions -----
class error(IOError):
...
class herror(error):
def __init__(self, herror: int, string: str) -> None: ...
class gaierror(error):
def __init__(self, error: int, string: str) -> None: ...
class timeout(error):
...
# Addresses can be either tuples of varying lengths (AF_INET, AF_INET6,
# AF_NETLINK, AF_TIPC) or strings (AF_UNIX).
# TODO AF_PACKET and AF_BLUETOOTH address objects
# ----- classes -----
class socket:
family = 0
type = 0
proto = 0
def __init__(self, family: int = ..., type: int = ...,
proto: int = ..., fileno: Optional[int] = ...) -> None: ...
# --- methods ---
# second tuple item is an address
def accept(self) -> Tuple['socket', Any]: ...
def bind(self, address: Union[tuple, str]) -> None: ...
def close(self) -> None: ...
def connect(self, address: Union[tuple, str]) -> None: ...
def connect_ex(self, address: Union[tuple, str]) -> int: ...
def detach(self) -> int: ...
def fileno(self) -> int: ...
# return value is an address
def getpeername(self) -> Any: ...
def getsockname(self) -> Any: ...
@overload
def getsockopt(self, level: int, optname: int) -> int: ...
@overload
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
def gettimeout(self) -> float: ...
def ioctl(self, control: object,
option: Tuple[int, int, int]) -> None: ...
def listen(self, backlog: int) -> None: ...
# TODO the return value may be BinaryIO or TextIO, depending on mode
def makefile(self, mode: str = ..., buffering: int = ...,
encoding: str = ..., errors: str = ...,
newline: str = ...) -> Any:
...
def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
# return type is an address
def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ...
def recvfrom_into(self, buffer: bytes, nbytes: int,
flags: int = ...) -> Any: ...
def recv_into(self, buffer: bytes, nbytes: int,
flags: int = ...) -> Any: ...
def send(self, data: bytes, flags: int = ...) -> int: ...
def sendall(self, data: bytes, flags: int =...) -> None:
... # return type: None on success
def sendto(self, data: bytes, address: Union[tuple, str], flags: int = ...) -> int: ...
def setblocking(self, flag: bool) -> None: ...
def settimeout(self, value: Union[float, None]) -> None: ...
def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ...
def shutdown(self, how: int) -> None: ...
# ----- functions -----
def create_connection(address: Tuple[str, int],
timeout: float = ...,
source_address: Tuple[str, int] = ...) -> socket: ...
# the 5th tuple item is an address
def getaddrinfo(
host: str, port: int, family: int = ..., type: int = ..., proto: int = ...,
flags: int = ...) -> List[Tuple[int, int, int, str, tuple]]:
...
def getfqdn(name: str = ...) -> str: ...
def gethostbyname(hostname: str) -> str: ...
def gethostbyname_ex(hostname: str) -> Tuple[str, List[str], List[str]]: ...
def gethostname() -> str: ...
def gethostbyaddr(ip_address: str) -> Tuple[str, List[str], List[str]]: ...
def getnameinfo(sockaddr: tuple, flags: int) -> Tuple[str, int]: ...
def getprotobyname(protocolname: str) -> int: ...
def getservbyname(servicename: str, protocolname: str = ...) -> int: ...
def getservbyport(port: int, protocolname: str = ...) -> str: ...
def socketpair(family: int = ...,
type: int = ...,
proto: int = ...) -> Tuple[socket, socket]: ...
def fromfd(fd: int, family: int, type: int, proto: int = ...) -> socket: ...
def ntohl(x: int) -> int: ... # param & ret val are 32-bit ints
def ntohs(x: int) -> int: ... # param & ret val are 16-bit ints
def htonl(x: int) -> int: ... # param & ret val are 32-bit ints
def htons(x: int) -> int: ... # param & ret val are 16-bit ints
def inet_aton(ip_string: str) -> bytes: ... # ret val 4 bytes in length
def inet_ntoa(packed_ip: bytes) -> str: ...
def inet_pton(address_family: int, ip_string: str) -> bytes: ...
def inet_ntop(address_family: int, packed_ip: bytes) -> str: ...
def getdefaulttimeout() -> Union[float, None]: ...
def setdefaulttimeout(timeout: float) -> None: ...
mypy-0.470/typeshed/stdlib/3/opcode.pyi 0000644 0000000 0000000 00000001030 13023631176 016460 0 ustar root root from typing import List, Dict, Sequence
cmp_op = ... # type: Sequence[str]
hasconst = ... # type: List[int]
hasname = ... # type: List[int]
hasjrel = ... # type: List[int]
hasjabs = ... # type: List[int]
haslocal = ... # type: List[int]
hascompare = ... # type: List[int]
hasfree = ... # type: List[int]
opname = ... # type: List[str]
opmap = ... # Dict[str, int]
HAVE_ARGUMENT = ... # type: int
EXTENDED_ARG = ... # type: int
hasnargs = ... # type: List[int]
def stack_effect(opcode: int, oparg: int = ...) -> int: ...
mypy-0.470/typeshed/stdlib/3/uuid.pyi 0000644 0000000 0000000 00000003066 13035744274 016177 0 ustar root root # Stubs for uuid
from typing import Tuple
Int = __builtins__.int
Bytes = __builtins__.bytes
FieldsType = Tuple[Int, Int, Int, Int, Int, Int]
class UUID:
def __init__(self, hex: str=..., bytes: Bytes=..., bytes_le: Bytes=..., fields: FieldsType=..., int: Int=..., version: Int=...) -> None: ...
@property
def bytes(self) -> Bytes: ...
@property
def bytes_le(self) -> Bytes: ...
@property
def clock_seq(self) -> Int: ...
@property
def clock_seq_hi_variant(self) -> Int: ...
@property
def clock_seq_low(self) -> Int: ...
@property
def fields(self) -> FieldsType: ...
@property
def hex(self) -> str: ...
@property
def int(self) -> Int: ...
@property
def node(self) -> Int: ...
@property
def time(self) -> Int: ...
@property
def time_hi_version(self) -> Int: ...
@property
def time_low(self) -> Int: ...
@property
def time_mid(self) -> Int: ...
@property
def urn(self) -> str: ...
@property
def variant(self) -> str: ...
@property
def version(self) -> str: ...
def getnode() -> Int: ...
def uuid1(node: Int=..., clock_seq: Int=...) -> UUID: ...
def uuid3(namespace: UUID, name: str) -> UUID: ...
def uuid4() -> UUID: ...
def uuid5(namespace: UUID, name: str) -> UUID: ...
NAMESPACE_DNS = ... # type: UUID
NAMESPACE_URL = ... # type: UUID
NAMESPACE_OID = ... # type: UUID
NAMESPACE_X500 = ... # type: UUID
RESERVED_NCS = ... # type: str
RFC_4122 = ... # type: str
RESERVED_MICROSOFT = ... # type: str
RESERVED_FUTURE = ... # type: str
mypy-0.470/typeshed/stdlib/3/gc.pyi 0000644 0000000 0000000 00000001625 13035744274 015621 0 ustar root root # Stubs for gc
from typing import Any, Dict, List, Tuple
DEBUG_COLLECTABLE = ... # type: int
DEBUG_LEAK = ... # type: int
DEBUG_SAVEALL = ... # type: int
DEBUG_STATS = ... # type: int
DEBUG_UNCOLLECTABLE = ... # type: int
callbacks = ... # type: List[Any]
garbage = ... # type: List[Any]
def collect(generations: int = ...) -> int: ...
def disable() -> None: ...
def enable() -> None: ...
def get_count() -> Tuple[int, int, int]: ...
def get_debug() -> int: ...
def get_objects() -> List[Any]: ...
def get_referents(*objs: Any) -> List[Any]: ...
def get_referrers(*objs: Any) -> List[Any]: ...
def get_stats() -> List[Dict[str, Any]]: ...
def get_threshold() -> Tuple[int, int, int]: ...
def is_tracked(obj: Any) -> bool: ...
def isenabled() -> bool: ...
def set_debug(flags: int) -> None: ...
def set_threshold(threshold0: int, threshold1: int = ...,
threshold2: int = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/pwd.pyi 0000644 0000000 0000000 00000000606 13023631176 016011 0 ustar root root # Stubs for pwd
# NOTE: These are incomplete!
import typing
class struct_passwd:
# TODO use namedtuple
pw_name = ... # type: str
pw_passwd = ... # type: str
pw_uid = 0
pw_gid = 0
pw_gecos = ... # type: str
pw_dir = ... # type: str
pw_shell = ... # type: str
def getpwuid(uid: int) -> struct_passwd: ...
def getpwnam(name: str) -> struct_passwd: ...
mypy-0.470/typeshed/stdlib/3/atexit.pyi 0000644 0000000 0000000 00000000471 13023631176 016515 0 ustar root root """Stub file for the 'atexit' module."""
from typing import Any, Callable
def _clear() -> None: ...
def _ncallbacks() -> int: ...
def _run_exitfuncs() -> None: ...
def register(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]: ...
def unregister(func: Callable[..., Any]) -> None: ...
mypy-0.470/typeshed/stdlib/3/resource.pyi 0000644 0000000 0000000 00000001637 13035744274 017062 0 ustar root root # Stubs for resource
# NOTE: These are incomplete!
from typing import Tuple
RLIMIT_AS = ... # type: int
RLIMIT_CORE = ... # type: int
RLIMIT_CPU = ... # type: int
RLIMIT_DATA = ... # type: int
RLIMIT_FSIZE = ... # type: int
RLIMIT_MEMLOCK = ... # type: int
RLIMIT_MSGQUEUE = ... # type: int
RLIMIT_NICE = ... # type: int
RLIMIT_NOFILE = ... # type: int
RLIMIT_NPROC = ... # type: int
RLIMIT_OFILE = ... # type: int
RLIMIT_RSS = ... # type: int
RLIMIT_RTPRIO = ... # type: int
RLIMIT_RTTIME = ... # type: int
RLIMIT_SIGPENDING = ... # type: int
RLIMIT_STACK = ... # type: int
RLIM_INFINITY = ... # type: int
RUSAGE_CHILDREN = ... # type: int
RUSAGE_SELF = ... # type: int
RUSAGE_THREAD = ... # type: int
def getrlimit(resource: int) -> Tuple[int, int]: ...
def setrlimit(resource: int, limits: Tuple[int, int]) -> None: ...
# NOTE: This is an alias of OSError in Python 3.3.
class error(Exception): ...
mypy-0.470/typeshed/stdlib/3/encodings/ 0000755 0000000 0000000 00000000000 13044320557 016444 5 ustar root root mypy-0.470/typeshed/stdlib/3/encodings/__init__.pyi 0000644 0000000 0000000 00000000136 13023631176 020725 0 ustar root root import codecs
import typing
def search_function(encoding: str) -> codecs.CodecInfo:
...
mypy-0.470/typeshed/stdlib/3/encodings/utf_8.pyi 0000644 0000000 0000000 00000000626 13023631176 020217 0 ustar root root import codecs
class IncrementalEncoder(codecs.IncrementalEncoder):
pass
class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
pass
class StreamWriter(codecs.StreamWriter):
pass
class StreamReader(codecs.StreamReader):
pass
def getregentry() -> codecs.CodecInfo: pass
def encode(input: str, errors: str = ...) -> bytes: pass
def decode(input: bytes, errors: str = ...) -> str: pass
mypy-0.470/typeshed/stdlib/3/doctest.pyi 0000644 0000000 0000000 00000000352 13023631176 016662 0 ustar root root # Stubs for doctest
# NOTE: These are incomplete!
from typing import Any, Tuple
# TODO arguments missing
def testmod(module: Any = ..., *, name: str = ..., globs: Any = ...,
verbose: bool = ...) -> Tuple[int, int]: ...
mypy-0.470/typeshed/stdlib/3/posixpath.pyi 0000644 0000000 0000000 00000003212 13035744274 017241 0 ustar root root # Stubs for os.path
# Ron Murawski
# based on http://docs.python.org/3.2/library/os.path.html
from typing import Any, List, Tuple, IO
# ----- os.path variables -----
supports_unicode_filenames = False
# ----- os.path function stubs -----
def abspath(path: str) -> str: ...
def basename(path) -> str: ...
def commonprefix(list: List[str]) -> str: ...
def dirname(path: str) -> str: ...
def exists(path: str) -> bool: ...
def lexists(path: str) -> bool: ...
def expanduser(path: str) -> str: ...
def expandvars(path: str) -> str: ...
def getatime(path: str) -> int:
... # return float if os.stat_float_times() returns True
def getmtime(path: str) -> int:
... # return float if os.stat_float_times() returns True
def getctime(path: str) -> int:
... # return float if os.stat_float_times() returns True
def getsize(path: str) -> int: ...
def isabs(path: str) -> bool: ...
def isfile(path: str) -> bool: ...
def isdir(path: str) -> bool: ...
def islink(path: str) -> bool: ...
def ismount(path: str) -> bool: ...
def join(path: str, *paths: str) -> str: ...
def normcase(path: str) -> str: ...
def normpath(path: str) -> str: ...
def realpath(path: str) -> str: ...
def relpath(path: str, start: str = ...) -> str: ...
def samefile(path1: str, path2: str) -> bool: ...
def sameopenfile(fp1: IO[Any], fp2: IO[Any]) -> bool: ...
# def samestat(stat1: stat_result, stat2: stat_result) -> bool:
# ... # Unix only
def split(path: str) -> Tuple[str, str]: ...
def splitdrive(path: str) -> Tuple[str, str]: ...
def splitext(path: str) -> Tuple[str, str]: ...
# def splitunc(path: str) -> Tuple[str, str] : ... # Windows only, deprecated
mypy-0.470/typeshed/stdlib/3/cgi.pyi 0000644 0000000 0000000 00000000216 13035744274 015765 0 ustar root root from typing import Dict, Tuple
def escape(s: str, quote: bool = ...) -> str: ...
def parse_header(s: str) -> Tuple[str, Dict[str, str]]: ...
mypy-0.470/typeshed/stdlib/3/getopt.pyi 0000644 0000000 0000000 00000001100 13023631176 016507 0 ustar root root # Stubs for getopt
# Based on http://docs.python.org/3.2/library/getopt.html
from typing import List, Tuple
def getopt(args: List[str], shortopts: str,
longopts: List[str]=...) -> Tuple[List[Tuple[str, str]],
List[str]]: ...
def gnu_getopt(args: List[str], shortopts: str,
longopts: List[str]=...) -> Tuple[List[Tuple[str, str]],
List[str]]: ...
class GetoptError(Exception):
msg = ... # type: str
opt = ... # type: str
error = GetoptError
mypy-0.470/typeshed/stdlib/3/shlex.pyi 0000644 0000000 0000000 00000002363 13023631176 016344 0 ustar root root # Stubs for shlex
# Based on http://docs.python.org/3.2/library/shlex.html
from typing import List, Tuple, Any, TextIO
def split(s: str, comments: bool = ...,
posix: bool = ...) -> List[str]: ...
# Added in 3.3, use (undocumented) pipes.quote in previous versions.
def quote(s: str) -> str: ...
class shlex:
commenters = ... # type: str
wordchars = ... # type: str
whitespace = ... # type: str
escape = ... # type: str
quotes = ... # type: str
escapedquotes = ... # type: str
whitespace_split = ... # type: bool
infile = ... # type: str
instream = ... # type: TextIO
source = ... # type: str
debug = 0
lineno = 0
token = ... # type: str
eof = ... # type: str
def __init__(self, instream=..., infile=...,
posix: bool = ...) -> None: ...
def get_token(self) -> str: ...
def push_token(self, tok: str) -> None: ...
def read_token(self) -> str: ...
def sourcehook(self, filename: str) -> Tuple[str, TextIO]: ...
# TODO argument types
def push_source(self, newstream: Any, newfile: Any = ...) -> None: ...
def pop_source(self) -> None: ...
def error_leader(self, infile: str = ...,
lineno: int = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/heapq.pyi 0000644 0000000 0000000 00000001514 13023631176 016314 0 ustar root root # Stubs for heapq
# Based on http://docs.python.org/3.2/library/heapq.html
import sys
from typing import TypeVar, List, Iterable, Any, Callable
_T = TypeVar('_T')
def heappush(heap: List[_T], item: _T) -> None: ...
def heappop(heap: List[_T]) -> _T: ...
def heappushpop(heap: List[_T], item: _T) -> _T: ...
def heapify(x: List[_T]) -> None: ...
def heapreplace(heap: List[_T], item: _T) -> _T: ...
if sys.version_info >= (3, 5):
def merge(*iterables: Iterable[_T], key: Callable[[_T], Any] = ...,
reverse: bool = ...) -> Iterable[_T]: ...
else:
def merge(*iterables: Iterable[_T]) -> Iterable[_T]: ...
def nlargest(n: int, iterable: Iterable[_T],
key: Callable[[_T], Any] = ...) -> List[_T]: ...
def nsmallest(n: int, iterable: Iterable[_T],
key: Callable[[_T], Any] = ...) -> List[_T]: ...
mypy-0.470/typeshed/stdlib/3/posix.pyi 0000644 0000000 0000000 00000000133 13035744274 016363 0 ustar root root # Stubs for posix
# NOTE: These are incomplete!
import typing
from os import stat_result
mypy-0.470/typeshed/stdlib/3/fnmatch.pyi 0000644 0000000 0000000 00000000556 13023631176 016643 0 ustar root root # Stubs for fnmatch
# Based on http://docs.python.org/3.2/library/fnmatch.html and
# python-lib/fnmatch.py
from typing import Iterable, List, AnyStr
def fnmatch(name: AnyStr, pat: AnyStr) -> bool: ...
def fnmatchcase(name: AnyStr, pat: AnyStr) -> bool: ...
def filter(names: Iterable[AnyStr], pat: AnyStr) -> List[AnyStr]: ...
def translate(pat: str) -> str: ...
mypy-0.470/typeshed/stdlib/3/token.pyi 0000644 0000000 0000000 00000001547 13035744274 016353 0 ustar root root from typing import Dict
ENDMARKER = 0
NAME = 0
NUMBER = 0
STRING = 0
NEWLINE = 0
INDENT = 0
DEDENT = 0
LPAR = 0
RPAR = 0
LSQB = 0
RSQB = 0
COLON = 0
COMMA = 0
SEMI = 0
PLUS = 0
MINUS = 0
STAR = 0
SLASH = 0
VBAR = 0
AMPER = 0
LESS = 0
GREATER = 0
EQUAL = 0
DOT = 0
PERCENT = 0
LBRACE = 0
RBRACE = 0
EQEQUAL = 0
NOTEQUAL = 0
LESSEQUAL = 0
GREATEREQUAL = 0
TILDE = 0
CIRCUMFLEX = 0
LEFTSHIFT = 0
RIGHTSHIFT = 0
DOUBLESTAR = 0
PLUSEQUAL = 0
MINEQUAL = 0
STAREQUAL = 0
SLASHEQUAL = 0
PERCENTEQUAL = 0
AMPEREQUAL = 0
VBAREQUAL = 0
CIRCUMFLEXEQUAL = 0
LEFTSHIFTEQUAL = 0
RIGHTSHIFTEQUAL = 0
DOUBLESTAREQUAL = 0
DOUBLESLASH = 0
DOUBLESLASHEQUAL = 0
AT = 0
RARROW = 0
ELLIPSIS = 0
OP = 0
ERRORTOKEN = 0
N_TOKENS = 0
NT_OFFSET = 0
tok_name = ... # type: Dict[int, str]
def ISTERMINAL(x: int) -> bool: pass
def ISNONTERMINAL(x: int) -> bool: pass
def ISEOF(x: int) -> bool: pass
mypy-0.470/typeshed/stdlib/3/base64.pyi 0000644 0000000 0000000 00000003277 13035744274 016321 0 ustar root root # Stubs for base64
from typing import IO, Union
import sys
if sys.version_info <= (3, 2):
_encodable = bytes
_decodable = bytes
elif sys.version_info[:2] == (3, 3):
_encodable = bytes
_decodable = Union[bytes, str]
elif sys.version_info >= (3, 4):
_encodable = Union[bytes, bytearray, memoryview]
_decodable = Union[bytes, bytearray, memoryview, str]
def b64encode(s: _encodable, altchars: bytes = ...) -> bytes: ...
def b64decode(s: _decodable, altchars: bytes = ...,
validate: bool = ...) -> bytes: ...
def standard_b64encode(s: _encodable) -> bytes: ...
def standard_b64decode(s: _decodable) -> bytes: ...
def urlsafe_b64encode(s: _encodable) -> bytes: ...
def urlsafe_b64decode(s: _decodable) -> bytes: ...
def b32encode(s: _encodable) -> bytes: ...
def b32decode(s: _decodable, casefold: bool = ...,
map01: bytes = ...) -> bytes: ...
def b16encode(s: _encodable) -> bytes: ...
def b16decode(s: _decodable, casefold: bool = ...) -> bytes: ...
if sys.version_info >= (3, 4):
def a85encode(b: _encodable, *, foldspaces: bool = ..., wrapcol: int = ...,
pad: bool = ..., adobe: bool = ...) -> bytes: ...
def a85decode(b: _decodable, *, foldspaces: bool = ...,
adobe: bool = ..., ignorechars: Union[str, bytes] = ...) -> bytes: ...
def b85encode(b: _encodable, pad: bool = ...) -> bytes: ...
def b85decode(b: _decodable) -> bytes: ...
def decode(input: IO[bytes], output: IO[bytes]) -> None: ...
def decodebytes(s: bytes) -> bytes: ...
def decodestring(s: bytes) -> bytes: ...
def encode(input: IO[bytes], output: IO[bytes]) -> None: ...
def encodebytes(s: bytes) -> bytes: ...
def encodestring(s: bytes) -> bytes: ...
mypy-0.470/typeshed/stdlib/3/ast.pyi 0000644 0000000 0000000 00000003542 13044257024 016007 0 ustar root root # Python 3.5 ast
import typing
from typing import Any, Union, Iterator
from _ast import (
Add, alias, And, arg, arguments, Assert, Assign, AST, AsyncFor,
AsyncFunctionDef, AsyncWith, Attribute, AugAssign, AugLoad, AugStore,
Await, BinOp, BitAnd, BitOr, BitXor, BoolOp, boolop, Break, Bytes, Call,
ClassDef, cmpop, Compare, comprehension, Continue, Del, Delete, Dict,
DictComp, Div, Ellipsis, Eq, ExceptHandler, Expr, expr, Expression,
expr_context, ExtSlice, FloorDiv, For, FunctionDef, GeneratorExp, Global,
Gt, GtE, If, IfExp, Import, ImportFrom, In, Index, Interactive, Invert, Is,
IsNot, keyword, Lambda, List, ListComp, Load, LShift, Lt, LtE, MatMult,
Mod, mod, Module, Mult, Name, NameConstant, Nonlocal, Not, NotEq, NotIn,
Num, operator, Or, Param, Pass, Pow, Raise, Return, RShift, Set, SetComp,
Slice, slice, Starred, stmt, Store, Str, Sub, Subscript, Suite, Try, Tuple,
UAdd, UnaryOp, unaryop, USub, While, With, withitem, Yield, YieldFrom
)
class NodeVisitor():
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> str: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
PyCF_ONLY_AST = ... # type: int
mypy-0.470/typeshed/stdlib/3/string.pyi 0000644 0000000 0000000 00000003361 13023631176 016526 0 ustar root root # Stubs for string
# Based on http://docs.python.org/3.2/library/string.html
from typing import Mapping, Sequence, Any, Optional, Union, List, Tuple, Iterable, AnyStr
ascii_letters = ... # type: str
ascii_lowercase = ... # type: str
ascii_uppercase = ... # type: str
digits = ... # type: str
hexdigits = ... # type: str
octdigits = ... # type: str
punctuation = ... # type: str
printable = ... # type: str
whitespace = ... # type: str
def capwords(s: str, sep: str = ...) -> str: ...
class Template:
template = ... # type: str
def __init__(self, template: str) -> None: ...
def substitute(self, mapping: Mapping[str, str] = ..., **kwds: str) -> str: ...
def safe_substitute(self, mapping: Mapping[str, str] = ...,
**kwds: str) -> str: ...
# TODO(MichalPokorny): This is probably badly and/or loosely typed.
class Formatter(object):
def format(self, format_string: str, *args, **kwargs) -> str: ...
def vformat(self, format_string: str, args: Sequence[Any],
kwargs: Mapping[str, Any]) -> str: ...
def parse(self, format_string: str) -> Iterable[Tuple[str, Optional[str], Optional[str], Optional[str]]]: ...
def get_field(self, field_name: str, args: Sequence[Any],
kwargs: Mapping[str, Any]) -> Any: ...
def get_value(self, key: Union[int, str], args: Sequence[Any],
kwargs: Mapping[str, Any]) -> Any:
raise IndexError()
raise KeyError()
def check_unused_args(self, used_args: Sequence[Union[int, str]], args: Sequence[Any],
kwargs: Mapping[str, Any]) -> None: ...
def format_field(self, value: Any, format_spec: str) -> Any: ...
def convert_field(self, value: Any, conversion: str) -> Any: ...
mypy-0.470/typeshed/stdlib/3/codecs.pyi 0000644 0000000 0000000 00000016327 13044257024 016465 0 ustar root root # Better codecs stubs hand-written by o11c.
# https://docs.python.org/3/library/codecs.html
from typing import (
BinaryIO,
Callable,
Iterable,
Iterator,
List,
Tuple,
Union,
)
from abc import abstractmethod
# TODO: this only satisfies the most common interface, where
# bytes is the raw form and str is the cooked form.
# In the long run, both should become template parameters maybe?
# There *are* bytes->bytes and str->str encodings in the standard library.
# Python 3.5 supposedly might change something there.
_decoded = str
_encoded = bytes
# TODO: It is not possible to specify these signatures correctly, because
# they have an optional positional or keyword argument for errors=.
_encode_type = Callable[[_decoded], _encoded] # signature of Codec().encode
_decode_type = Callable[[_encoded], _decoded] # signature of Codec().decode
_stream_reader_type = Callable[[BinaryIO], 'StreamReader'] # signature of StreamReader __init__
_stream_writer_type = Callable[[BinaryIO], 'StreamWriter'] # signature of StreamWriter __init__
_incremental_encoder_type = Callable[[], 'IncrementalEncoder'] # signature of IncrementalEncoder __init__
_incremental_decode_type = Callable[[], 'IncrementalDecoder'] # signature of IncrementalDecoder __init__
def encode(obj: _decoded, encoding: str = ..., errors: str = ...) -> _encoded:
...
def decode(obj: _encoded, encoding: str = ..., errors: str = ...) -> _decoded:
...
def lookup(encoding: str) -> 'CodecInfo':
...
class CodecInfo(Tuple[_encode_type, _decode_type, _stream_reader_type, _stream_writer_type]):
def __init__(self, encode: _encode_type, decode: _decode_type, streamreader: _stream_reader_type = ..., streamwriter: _stream_writer_type = ..., incrementalencoder: _incremental_encoder_type = ..., incrementaldecoder: _incremental_decode_type = ..., name: str = ...) -> None:
self.encode = encode
self.decode = decode
self.streamreader = streamreader
self.streamwriter = streamwriter
self.incrementalencoder = incrementalencoder
self.incrementaldecoder = incrementaldecoder
self.name = name
def getencoder(encoding: str) -> _encode_type:
...
def getdecoder(encoding: str) -> _encode_type:
...
def getincrementalencoder(encoding: str) -> _incremental_encoder_type:
...
def getincrementaldecoder(encoding: str) -> _incremental_encoder_type:
...
def getreader(encoding: str) -> _stream_reader_type:
...
def getwriter(encoding: str) -> _stream_writer_type:
...
def register(search_function: Callable[[str], CodecInfo]) -> None:
...
def open(filename: str, mode: str = ..., encoding: str = ..., errors: str = ..., buffering: int = ...) -> StreamReaderWriter:
...
def EncodedFile(file: BinaryIO, data_encoding: str, file_encoding: str = ..., errors: str = ...) -> 'StreamRecoder':
...
def iterencode(iterator: Iterable[_decoded], encoding: str, errors: str = ...) -> Iterator[_encoded]:
...
def iterdecode(iterator: Iterable[_encoded], encoding: str, errors: str = ...) -> Iterator[_decoded]:
...
BOM = b''
BOM_BE = b''
BOM_LE = b''
BOM_UTF8 = b''
BOM_UTF16 = b''
BOM_UTF16_BE = b''
BOM_UTF16_LE = b''
BOM_UTF32 = b''
BOM_UTF32_BE = b''
BOM_UTF32_LE = b''
# It is expected that different actions be taken depending on which of the
# three subclasses of `UnicodeError` is actually ...ed. However, the Union
# is still needed for at least one of the cases.
def register_error(name: str, error_handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None:
...
def lookup_error(name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]:
...
def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]:
...
class Codec:
# These are sort of @abstractmethod but sort of not.
# The StreamReader and StreamWriter subclasses only implement one.
def encode(self, input: _decoded, errors: str = ...) -> Tuple[_encoded, int]:
...
def decode(self, input: _encoded, errors: str = ...) -> Tuple[_decoded, int]:
...
class IncrementalEncoder:
def __init__(self, errors: str = ...) -> None:
self.errors = errors
@abstractmethod
def encode(self, object: _decoded, final: bool = ...) -> _encoded:
...
def reset(self) -> None:
...
# documentation says int but str is needed for the subclass.
def getstate(self) -> Union[int, _decoded]:
...
def setstate(self, state: Union[int, _decoded]) -> None:
...
class IncrementalDecoder:
def __init__(self, errors: str = ...) -> None:
self.errors = errors
@abstractmethod
def decode(self, object: _encoded, final: bool = ...) -> _decoded:
...
def reset(self) -> None:
...
def getstate(self) -> Tuple[_encoded, int]:
...
def setstate(self, state: Tuple[_encoded, int]) -> None:
...
# These are not documented but used in encodings/*.py implementations.
class BufferedIncrementalEncoder(IncrementalEncoder):
def __init__(self, errors: str = ...) -> None:
IncrementalEncoder.__init__(self, errors)
self.buffer = ''
@abstractmethod
def _buffer_encode(self, input: _decoded, errors: str, final: bool) -> _encoded:
...
def encode(self, input: _decoded, final: bool = ...) -> _encoded:
...
class BufferedIncrementalDecoder(IncrementalDecoder):
def __init__(self, errors: str = ...) -> None:
IncrementalDecoder.__init__(self, errors)
self.buffer = b''
@abstractmethod
def _buffer_decode(self, input: _encoded, errors: str, final: bool) -> Tuple[_decoded, int]:
...
def decode(self, object: _encoded, final: bool = ...) -> _decoded:
...
# TODO: it is not possible to specify the requirement that all other
# attributes and methods are passed-through from the stream.
class StreamWriter(Codec):
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
self.errors = errors
def write(self, obj: _decoded) -> None:
...
def writelines(self, list: List[str]) -> None:
...
def reset(self) -> None:
...
class StreamReader(Codec):
def __init__(self, stream: BinaryIO, errors: str = ...) -> None:
self.errors = errors
def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _decoded:
...
def readline(self, size: int = ..., keepends: bool = ...) -> _decoded:
...
def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_decoded]:
...
def reset(self) -> None:
...
class StreamReaderWriter:
def __init__(self, stream: BinaryIO, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
class StreamRecoder(BinaryIO):
def __init__(self, stream: BinaryIO, encode: _encode_type, decode: _decode_type, Reader: _stream_reader_type, Writer: _stream_writer_type, errors: str = ...) -> None:
...
mypy-0.470/typeshed/stdlib/3/abc.pyi 0000644 0000000 0000000 00000000511 13023631176 015737 0 ustar root root from typing import Any
import sys
# Stubs for abc.
# Thesee definitions have special processing in type checker.
class ABCMeta(type):
def register(cls: "ABCMeta", subclass: Any) -> None: ...
abstractmethod = object()
abstractproperty = object()
if sys.version_info >= (3, 4):
class ABC(metaclass=ABCMeta):
pass
mypy-0.470/typeshed/stdlib/3/fcntl.pyi 0000644 0000000 0000000 00000005334 13023631176 016330 0 ustar root root # Stubs for fcntl
from typing import Any, IO, Union
import typing
FASYNC = ... # type: int
FD_CLOEXEC = ... # type: int
DN_ACCESS = ... # type: int
DN_ATTRIB = ... # type: int
DN_CREATE = ... # type: int
DN_DELETE = ... # type: int
DN_MODIFY = ... # type: int
DN_MULTISHOT = ... # type: int
DN_RENAME = ... # type: int
F_DUPFD = ... # type: int
F_DUPFD_CLOEXEC = ... # type: int
F_FULLFSYNC = ... # type: int
F_EXLCK = ... # type: int
F_GETFD = ... # type: int
F_GETFL = ... # type: int
F_GETLEASE = ... # type: int
F_GETLK = ... # type: int
F_GETLK64 = ... # type: int
F_GETOWN = ... # type: int
F_NOCACHE = ... # type: int
F_GETSIG = ... # type: int
F_NOTIFY = ... # type: int
F_RDLCK = ... # type: int
F_SETFD = ... # type: int
F_SETFL = ... # type: int
F_SETLEASE = ... # type: int
F_SETLK = ... # type: int
F_SETLK64 = ... # type: int
F_SETLKW = ... # type: int
F_SETLKW64 = ... # type: int
F_SETOWN = ... # type: int
F_SETSIG = ... # type: int
F_SHLCK = ... # type: int
F_UNLCK = ... # type: int
F_WRLCK = ... # type: int
I_ATMARK = ... # type: int
I_CANPUT = ... # type: int
I_CKBAND = ... # type: int
I_FDINSERT = ... # type: int
I_FIND = ... # type: int
I_FLUSH = ... # type: int
I_FLUSHBAND = ... # type: int
I_GETBAND = ... # type: int
I_GETCLTIME = ... # type: int
I_GETSIG = ... # type: int
I_GRDOPT = ... # type: int
I_GWROPT = ... # type: int
I_LINK = ... # type: int
I_LIST = ... # type: int
I_LOOK = ... # type: int
I_NREAD = ... # type: int
I_PEEK = ... # type: int
I_PLINK = ... # type: int
I_POP = ... # type: int
I_PUNLINK = ... # type: int
I_PUSH = ... # type: int
I_RECVFD = ... # type: int
I_SENDFD = ... # type: int
I_SETCLTIME = ... # type: int
I_SETSIG = ... # type: int
I_SRDOPT = ... # type: int
I_STR = ... # type: int
I_SWROPT = ... # type: int
I_UNLINK = ... # type: int
LOCK_EX = ... # type: int
LOCK_MAND = ... # type: int
LOCK_NB = ... # type: int
LOCK_READ = ... # type: int
LOCK_RW = ... # type: int
LOCK_SH = ... # type: int
LOCK_UN = ... # type: int
LOCK_WRITE = ... # type: int
_AnyFile = Union[int, IO[Any]]
# TODO All these return either int or bytes depending on the value of
# cmd (not on the type of arg).
def fcntl(fd: _AnyFile,
cmd: int,
arg: Union[int, bytes] = ...) -> Any: ...
# TODO This function accepts any object supporting a buffer interface,
# as arg, is there a better way to express this than bytes?
def ioctl(fd: _AnyFile,
request: int,
arg: Union[int, bytes] = ...,
mutate_flag: bool = ...) -> Any: ...
def flock(fd: _AnyFile, operation: int) -> None: ...
def lockf(fd: _AnyFile,
cmd: int,
len: int = ...,
start: int = ...,
whence: int = ...) -> Any: ...
mypy-0.470/typeshed/stdlib/3/io.pyi 0000644 0000000 0000000 00000023430 13035744274 015635 0 ustar root root # Stubs for io
from typing import (
List, BinaryIO, TextIO, Iterator, Union, Optional, Callable, Tuple, Any, IO
)
import builtins
import codecs
import sys
from types import TracebackType
DEFAULT_BUFFER_SIZE = ... # type: int
SEEK_SET = ... # type: int
SEEK_CUR = ... # type: int
SEEK_END = ... # type: int
open = builtins.open
# FIXME when mypy handle condtional, we can uncomment the next block and remove
# the temporary fix
# if sys.version_info >= (3, 3):
# BlockingIOError = BlockingIOError
# class UnsupportedOperation(OSError, ValueError): ...
# else:
# class BlockingIOError(IOError):
# characters_written = ... # type: int
# class UnsupportedOperation(IOError, ValueError): ...
class BlockingIOError(OSError):
characters_written = ... # type: int
class UnsupportedOperation(OSError, ValueError): ...
class IOBase:
def __iter__(self) -> Iterator[bytes]: ...
def __next__(self) -> bytes: ...
def __enter__(self) -> 'IOBase': ...
def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def readable(self) -> bool: ...
def readlines(self, hint: int = ...) -> List[bytes]: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: Optional[int] = ...) -> int: ...
def writable(self) -> bool: ...
def writelines(self, lines: List[Union[bytes, bytearray]]) -> None: ...
if sys.version_info >= (3, 4):
def readline(self, size: int = ...) -> bytes: ...
def __del__(self) -> None: ...
else:
def readline(self, limit: int = ...) -> bytes: ...
if sys.version_info >= (3, 2):
closed = ... # type: bool
else:
def closed(self) -> bool: ...
class RawIOBase(IOBase):
def readall(self) -> bytes: ...
def readinto(self, b: bytearray) -> Optional[int]: ...
def write(self, b: Union[bytes, bytearray]) -> Optional[int]: ...
if sys.version_info >= (3, 4):
def read(self, size: int = ...) -> Optional[bytes]: ...
else:
def read(self, n: int = ...) -> Optional[bytes]: ...
class BufferedIOBase(IOBase):
def detach(self) -> RawIOBase: ...
def readinto(self, b: bytearray) -> int: ...
def write(self, b: Union[bytes, bytearray]) -> int: ...
if sys.version_info >= (3, 5):
def readinto1(self, b: bytearray) -> int: ...
if sys.version_info >= (3, 4):
def read(self, size: Optional[int] = ...) -> bytes: ...
def read1(self, size: int = ...) -> bytes: ...
else:
def read(self, n: Optional[int] = ...) -> bytes: ...
def read1(self, n: int = ...) -> bytes: ...
class FileIO(RawIOBase):
mode = ... # type: str
name = ... # type: Union[int, str]
if sys.version_info >= (3, 3):
def __init__(
self,
name: Union[str, bytes, int],
mode: str = ...,
closefd: bool = ...,
opener: Optional[Callable[[Union[int, str], str], int]] = ...
) -> None: ...
else:
def __init__(self, name: Union[str, bytes, int],
mode: str = ..., closefd: bool = ...) -> None: ...
# TODO should extend from BufferedIOBase
class BytesIO(BinaryIO):
def __init__(self, initial_bytes: bytes = ...) -> None: ...
def getvalue(self) -> bytes: ...
if sys.version_info >= (3, 2):
def getbuffer(self) -> memoryview: ...
# copied from IOBase
def __iter__(self) -> Iterator[bytes]: ...
def __next__(self) -> bytes: ...
def __enter__(self) -> 'BytesIO': ...
def __exit__(self, t: type = None, value: BaseException = None,
traceback: Any = None) -> bool: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def readable(self) -> bool: ...
def readlines(self, hint: int = ...) -> List[bytes]: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, size: Optional[int] = ...) -> int: ...
def writable(self) -> bool: ...
# TODO should be the next line instead
# def writelines(self, lines: List[Union[bytes, bytearray]]) -> None: ...
def writelines(self, lines: Any) -> None: ...
if sys.version_info >= (3, 4):
def readline(self, size: int = ...) -> bytes: ...
def __del__(self) -> None: ...
else:
def readline(self, limit: int = ...): ...
if sys.version_info >= (3, 2):
closed = ... # type: bool
else:
def closed(self) -> bool: ...
# copied from BufferedIOBase
def detach(self) -> RawIOBase: ...
def readinto(self, b: bytearray) -> int: ...
def write(self, b: Union[bytes, bytearray]) -> int: ...
if sys.version_info >= (3, 5):
def readinto1(self, b: bytearray) -> int: ...
if sys.version_info >= (3, 4):
def read(self, size: Optional[int] = ...) -> bytes: ...
def read1(self, size: int = ...) -> bytes: ...
else:
def read(self, n: Optional[int] = ...) -> bytes: ...
def read1(self, n: int = ...) -> bytes: ...
class BufferedReader(BufferedIOBase):
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
if sys.version_info >= (3, 4):
def peek(self, size: int = ...) -> bytes: ...
else:
def peek(self, n: int = ...) -> bytes: ...
class BufferedWriter(BufferedIOBase):
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
def flush(self) -> None: ...
def write(self, b: Union[bytes, bytearray]) -> int: ...
class BufferedRandom(BufferedReader, BufferedWriter):
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def tell(self) -> int: ...
class BufferedRWPair(BufferedIOBase):
def __init__(self, reader: RawIOBase, writer: RawIOBase,
buffer_size: int = ...) -> None: ...
class TextIOBase(IOBase):
encoding = ... # type: str
errors = ... # type: Optional[str]
newlines = ... # type: Union[str, Tuple[str, ...], None]
def __iter__(self) -> Iterator[str]: ... # type: ignore
def __next__(self) -> str: ... # type: ignore
def __enter__(self) -> 'TextIOBase': ...
def detach(self) -> IOBase: ...
def write(self, s: str) -> int: ...
if sys.version_info >= (3, 4):
def readline(self, size: int = ...) -> str: ... # type: ignore
def read(self, size: Optional[int] = ...) -> str: ...
elif sys.version_info >= (3, 2):
def readline(self, limit: int = ...) -> str: ... # type: ignore
else:
def readline(self) -> str: ...
if sys.version_info >= (3, 2):
def seek(self, offset: int, whence: int = ...) -> int: ...
def tell(self) -> int: ...
# TODO should extend from TextIOBase
class TextIOWrapper(TextIO):
line_buffering = ... # type: bool
# TODO uncomment after fixing mypy about using write_through
# if sys.version_info >= (3, 3):
# def __init__(self, buffer: IO[bytes], encoding: str = ...,
# errors: Optional[str] = ..., newline: Optional[str] = ...,
# line_buffering: bool = ..., write_through: bool = ...) \
# -> None: ...
# else:
# def __init__(self, buffer: IO[bytes],
# encoding: str = ..., errors: Optional[str] = ...,
# newline: Optional[str] = ..., line_buffering: bool = ...) \
# -> None: ...
def __init__(
self,
buffer: IO[bytes],
encoding: str = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
line_buffering: bool = ...,
write_through: bool = ...
) -> None: ...
# copied from IOBase
def __exit__(self, t: type = None, value: BaseException = None,
traceback: Any = None) -> bool: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def readable(self) -> bool: ...
def readlines(self, hint: int = ...) -> List[str]: ...
def seekable(self) -> bool: ...
def truncate(self, size: Optional[int] = ...) -> int: ...
def writable(self) -> bool: ...
# TODO should be the next line instead
# def writelines(self, lines: List[str]) -> None: ...
def writelines(self, lines: Any) -> None: ...
if sys.version_info >= (3, 4):
def __del__(self) -> None: ...
if sys.version_info >= (3, 2):
closed = ... # type: bool
else:
def closed(self) -> bool: ...
# copied from TextIOBase
encoding = ... # type: str
errors = ... # type: Optional[str]
newlines = ... # type: Union[str, Tuple[str, ...], None]
def __iter__(self) -> Iterator[str]: ...
def __next__(self) -> str: ...
def __enter__(self) -> 'TextIO': ...
def detach(self) -> IOBase: ...
def write(self, s: str) -> int: ...
if sys.version_info >= (3, 4):
def readline(self, size: int = ...) -> str: ...
def read(self, size: Optional[int] = ...) -> str: ...
elif sys.version_info >= (3, 2):
def readline(self, limit: int = ...) -> str: ...
else:
def readline(self) -> str: ...
if sys.version_info >= (3, 2):
def seek(self, offset: int, whence: int = ...) -> int: ...
def tell(self) -> int: ...
class StringIO(TextIOWrapper):
def __init__(self, initial_value: str = ...,
newline: Optional[str] = ...) -> None: ...
name = ... # type: str
def getvalue(self) -> str: ...
class IncrementalNewlineDecoder(codecs.IncrementalDecoder): ...
mypy-0.470/typeshed/stdlib/3/sqlite3/ 0000755 0000000 0000000 00000000000 13044320557 016057 5 ustar root root mypy-0.470/typeshed/stdlib/3/sqlite3/__init__.pyi 0000644 0000000 0000000 00000000233 13035744274 020345 0 ustar root root # Stubs for sqlite3 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from sqlite3.dbapi2 import * # noqa: F403
mypy-0.470/typeshed/stdlib/3/sqlite3/dbapi2.pyi 0000644 0000000 0000000 00000023244 13044257024 017746 0 ustar root root # Filip Hron
# based heavily on Andrey Vlasovskikh's python-skeletons https://github.com/JetBrains/python-skeletons/blob/master/sqlite3.py
from typing import Any, Union, List, AnyStr, Iterator, Optional
from numbers import Integral
from datetime import time, datetime
from collections import Iterable
paramstyle = ... # type: str
threadsafety = ... # type: int
apilevel = ... # type: str
Date = ... # type: datetime
Time = ... # type: time
Timestamp = ... # type: datetime
def DateFromTicks(ticks): ...
def TimeFromTicks(ticks): ...
def TimestampFromTicks(ticks): ...
version_info = ... # type: Any
sqlite_version_info = ... # type: Any
Binary = ... # type: Any
def register_adapters_and_converters(): ...
# The remaining definitions are imported from _sqlite3.
PARSE_COLNAMES = ... # type: int
PARSE_DECLTYPES = ... # type: int
SQLITE_ALTER_TABLE = ... # type: int
SQLITE_ANALYZE = ... # type: int
SQLITE_ATTACH = ... # type: int
SQLITE_CREATE_INDEX = ... # type: int
SQLITE_CREATE_TABLE = ... # type: int
SQLITE_CREATE_TEMP_INDEX = ... # type: int
SQLITE_CREATE_TEMP_TABLE = ... # type: int
SQLITE_CREATE_TEMP_TRIGGER = ... # type: int
SQLITE_CREATE_TEMP_VIEW = ... # type: int
SQLITE_CREATE_TRIGGER = ... # type: int
SQLITE_CREATE_VIEW = ... # type: int
SQLITE_DELETE = ... # type: int
SQLITE_DENY = ... # type: int
SQLITE_DETACH = ... # type: int
SQLITE_DROP_INDEX = ... # type: int
SQLITE_DROP_TABLE = ... # type: int
SQLITE_DROP_TEMP_INDEX = ... # type: int
SQLITE_DROP_TEMP_TABLE = ... # type: int
SQLITE_DROP_TEMP_TRIGGER = ... # type: int
SQLITE_DROP_TEMP_VIEW = ... # type: int
SQLITE_DROP_TRIGGER = ... # type: int
SQLITE_DROP_VIEW = ... # type: int
SQLITE_IGNORE = ... # type: int
SQLITE_INSERT = ... # type: int
SQLITE_OK = ... # type: int
SQLITE_PRAGMA = ... # type: int
SQLITE_READ = ... # type: int
SQLITE_REINDEX = ... # type: int
SQLITE_SELECT = ... # type: int
SQLITE_TRANSACTION = ... # type: int
SQLITE_UPDATE = ... # type: int
adapters = ... # type: Any
converters = ... # type: Any
sqlite_version = ... # type: str
version = ... # type: str
# TODO: adapt needs to get probed
def adapt(obj, protocol, alternate): ...
def complete_statement(sql: str) -> bool: ...
def connect(database: Union[bytes, AnyStr],
timeout: float = ...,
detect_types: int = ...,
isolation_level: Union[str, None] = ...,
check_same_thread: bool = ...,
factory: Union[Connection, None] = ...,
cached_statements: int = ...) -> Connection: ...
def enable_callback_tracebacks(flag: bool) -> None: ...
def enable_shared_cache(do_enable: int) -> None: ...
def register_adapter(type: type, callable: Any) -> None: ...
# TODO: sqlite3.register_converter.__doc__ specifies callable as unknown
def register_converter(typename: str, callable: bytes) -> None: ...
class Cache:
def __init__(self, *args, **kwargs) -> None: ...
def display(self, *args, **kwargs) -> None: ...
def get(self, *args, **kwargs) -> None: ...
class Connection:
DataError = ... # type: Any
DatabaseError = ... # type: Any
Error = ... # type: Any
IntegrityError = ... # type: Any
InterfaceError = ... # type: Any
InternalError = ... # type: Any
NotSupportedError = ... # type: Any
OperationalError = ... # type: Any
ProgrammingError = ... # type: Any
Warning = ... # type: Any
in_transaction = ... # type: Any
isolation_level = ... # type: Any
row_factory = ... # type: Any
text_factory = ... # type: Any
total_changes = ... # type: Any
def __init__(self, *args, **kwargs): ...
def close(self) -> None: ...
def commit(self) -> None: ...
def create_aggregate(self, name: str, num_params: int, aggregate_class: type) -> None: ...
def create_collation(self, name: str, callable: Any) -> None: ...
def create_function(self, name: str, num_params: int, func: Any) -> None: ...
def cursor(self, cursorClass: Optional[type] = ...) -> Cursor: ...
def execute(self, sql: str, parameters: Iterable = ...) -> Cursor: ...
# TODO: please check in executemany() if seq_of_parameters type is possible like this
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable]) -> Cursor: ...
def executescript(self, sql_script: Union[bytes, AnyStr]) -> Cursor: ...
def interrupt(self, *args, **kwargs) -> None: ...
def iterdump(self, *args, **kwargs) -> None: ...
def rollback(self, *args, **kwargs) -> None: ...
# TODO: set_authorizer(authorzer_callback)
# see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_authorizer
# returns [SQLITE_OK, SQLITE_DENY, SQLITE_IGNORE] so perhaps int
def set_authorizer(self, *args, **kwargs) -> None: ...
# set_progress_handler(handler, n) -> see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_progress_handler
def set_progress_handler(self, *args, **kwargs) -> None: ...
def set_trace_callback(self, *args, **kwargs): ...
def __call__(self, *args, **kwargs): ...
def __enter__(self, *args, **kwargs): ...
def __exit__(self, *args, **kwargs): ...
class Cursor(Iterator[Any]):
arraysize = ... # type: Any
connection = ... # type: Any
description = ... # type: Any
lastrowid = ... # type: Any
row_factory = ... # type: Any
rowcount = ... # type: Any
# TODO: Cursor class accepts exactly 1 argument
# required type is sqlite3.Connection (which is imported as _Connection)
# however, the name of the __init__ variable is unknown
def __init__(self, *args, **kwargs): ...
def close(self, *args, **kwargs): ...
def execute(self, sql: str, parameters: Iterable = ...) -> Cursor: ...
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable]): ...
def executescript(self, sql_script: Union[bytes, AnyStr]) -> Cursor: ...
def fetchall(self) -> List[Any]: ...
def fetchmany(self, size: Integral = ...) -> List[Any]: ...
def fetchone(self) -> Any: ...
def setinputsizes(self, *args, **kwargs): ...
def setoutputsize(self, *args, **kwargs): ...
def __iter__(self) -> Cursor: ...
def __next__(self) -> Any: ...
class DataError(DatabaseError): ...
class DatabaseError(Error): ...
class Error(Exception): ...
class IntegrityError(DatabaseError): ...
class InterfaceError(Error): ...
class InternalError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
class OperationalError(DatabaseError): ...
class OptimizedUnicode:
maketrans = ... # type: Any
def __init__(self, *args, **kwargs): ...
def capitalize(self, *args, **kwargs): ...
def casefold(self, *args, **kwargs): ...
def center(self, *args, **kwargs): ...
def count(self, *args, **kwargs): ...
def encode(self, *args, **kwargs): ...
def endswith(self, *args, **kwargs): ...
def expandtabs(self, *args, **kwargs): ...
def find(self, *args, **kwargs): ...
def format(self, *args, **kwargs): ...
def format_map(self, *args, **kwargs): ...
def index(self, *args, **kwargs): ...
def isalnum(self, *args, **kwargs): ...
def isalpha(self, *args, **kwargs): ...
def isdecimal(self, *args, **kwargs): ...
def isdigit(self, *args, **kwargs): ...
def isidentifier(self, *args, **kwargs): ...
def islower(self, *args, **kwargs): ...
def isnumeric(self, *args, **kwargs): ...
def isprintable(self, *args, **kwargs): ...
def isspace(self, *args, **kwargs): ...
def istitle(self, *args, **kwargs): ...
def isupper(self, *args, **kwargs): ...
def join(self, *args, **kwargs): ...
def ljust(self, *args, **kwargs): ...
def lower(self, *args, **kwargs): ...
def lstrip(self, *args, **kwargs): ...
def partition(self, *args, **kwargs): ...
def replace(self, *args, **kwargs): ...
def rfind(self, *args, **kwargs): ...
def rindex(self, *args, **kwargs): ...
def rjust(self, *args, **kwargs): ...
def rpartition(self, *args, **kwargs): ...
def rsplit(self, *args, **kwargs): ...
def rstrip(self, *args, **kwargs): ...
def split(self, *args, **kwargs): ...
def splitlines(self, *args, **kwargs): ...
def startswith(self, *args, **kwargs): ...
def strip(self, *args, **kwargs): ...
def swapcase(self, *args, **kwargs): ...
def title(self, *args, **kwargs): ...
def translate(self, *args, **kwargs): ...
def upper(self, *args, **kwargs): ...
def zfill(self, *args, **kwargs): ...
def __add__(self, other): ...
def __contains__(self, *args, **kwargs): ...
def __eq__(self, other): ...
def __format__(self, *args, **kwargs): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __getnewargs__(self, *args, **kwargs): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args, **kwargs): ...
def __lt__(self, other): ...
def __mod__(self, other): ...
def __mul__(self, other): ...
def __ne__(self, other): ...
def __rmod__(self, other): ...
def __rmul__(self, other): ...
def __sizeof__(self): ...
class PrepareProtocol:
def __init__(self, *args, **kwargs): ...
class ProgrammingError(DatabaseError): ...
class Row:
def __init__(self, *args, **kwargs): ...
def keys(self, *args, **kwargs): ...
def __eq__(self, other): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args, **kwargs): ...
def __lt__(self, other): ...
def __ne__(self, other): ...
class Statement:
def __init__(self, *args, **kwargs): ...
class Warning(Exception): ...
mypy-0.470/typeshed/stdlib/3/unittest/ 0000755 0000000 0000000 00000000000 13044320557 016352 5 ustar root root mypy-0.470/typeshed/stdlib/3/unittest/__init__.pyi 0000644 0000000 0000000 00000036672 13035744274 020660 0 ustar root root # Stubs for unittest
from typing import (
Any, Callable, Dict, Iterable, Iterator, List, Optional, Pattern, Sequence,
Set, TextIO, Tuple, Type, TypeVar, Union,
overload,
)
import logging
import sys
from types import ModuleType, TracebackType
from contextlib import ContextManager
_T = TypeVar('_T')
_FT = TypeVar('_FT', Callable[[Any], Any])
def skip(reason: str) -> Callable[[_FT], _FT]: ...
def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
def expectedFailure(func: _FT) -> _FT: ...
class SkipTest(Exception):
def __init__(self, reason: str) -> None: ...
class TestCase:
failureException = ... # type: Type[BaseException]
longMessage = ... # type: bool
maxDiff = ... # type: Optional[int]
def __init__(self, methodName: str = ...) -> None: ...
def setUp(self) -> None: ...
def tearDown(self) -> None: ...
@classmethod
def setUpClass(cls) -> None: ...
@classmethod
def tearDownClass(cls) -> None: ...
def run(self, result: Optional[TestResult] = ...) -> TestCase: ...
def skipTest(self, reason: Any) -> None: ...
if sys.version_info >= (3, 4):
def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ...
def debug(self) -> None: ...
def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertNotEqual(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...
def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...
def assertIs(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertIsNot(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def assertIsNone(self, expr: Any, msg: Any = ...) -> None: ...
def assertIsNotNone(self, expr: Any, msg: Any = ...) -> None: ...
def assertIn(self, first: _T, second: Iterable[_T],
msg: Any = ...) -> None: ...
def assertNotIn(self, first: _T, second: Iterable[_T],
msg: Any = ...) -> None: ...
def assertIsInstance(self, obj: Any,
cls: Union[type, Tuple[type, ...]],
msg: Any = ...) -> None: ...
def assertNotIsInstance(self, obj: Any,
cls: Union[type, Tuple[type, ...]],
msg: Any = ...) -> None: ...
def assertGreater(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def assertGreaterEqual(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def assertLess(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertLessEqual(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
@overload
def assertRaises(self, # type: ignore
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def assertRaises(self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
msg: Any = ...) -> _AssertRaisesContext: ...
@overload
def assertRaisesRegex(self, # type: ignore
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def assertRaisesRegex(self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
msg: Any = ...) -> _AssertRaisesContext: ...
@overload
def assertWarns(self, # type: ignore
exception: Union[Type[Warning], Tuple[Type[Warning], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def assertWarns(self,
exception: Union[Type[Warning], Tuple[Type[Warning], ...]],
msg: Any = ...) -> _AssertWarnsContext: ...
@overload
def assertWarnsRegex(self, # type: ignore
exception: Union[Type[Warning], Tuple[Type[Warning], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def assertWarnsRegex(self,
exception: Union[Type[Warning], Tuple[Type[Warning], ...]],
msg: Any = ...) -> _AssertWarnsContext: ...
if sys.version_info >= (3, 4):
def assertLogs(
self, logger: Optional[logging.Logger] = ...,
level: Union[int, str, None] = ...
) -> _AssertLogsContext: ...
def assertAlmostEqual(self, first: float, second: float, places: int = ...,
msg: Any = ..., delta: float = ...) -> None: ...
def assertNotAlmostEqual(self, first: float, second: float,
places: int = ..., msg: Any = ...,
delta: float = ...) -> None: ...
def assertRegex(self, text: str, regex: Union[str, Pattern[str]],
msg: Any = ...) -> None: ...
def assertNotRegex(self, text: str, regex: Union[str, Pattern[str]],
msg: Any = ...) -> None: ...
def assertCountEqual(self, first: Sequence[Any], second: Sequence[Any],
msg: Any = ...) -> None: ...
def addTypeEqualityFunc(self, typeobj: Type[Any],
function: Callable[..., None]) -> None: ...
def assertMultiLineEqual(self, first: str, second: str,
msg: Any = ...) -> None: ...
def assertSequenceEqual(self, first: Sequence[Any], second: Sequence[Any],
msg: Any = ...,
seq_type: Type[Sequence[Any]] = ...) -> None: ...
def assertListEqual(self, first: List[Any], second: List[Any],
msg: Any = ...) -> None: ...
def assertTupleEqual(self, first: Tuple[Any, ...], second: Tuple[Any, ...],
msg: Any = ...) -> None: ...
def assertSetEqual(self, first: Set[Any], second: Set[Any],
msg: Any = ...) -> None: ...
def assertDictEqual(self, first: Dict[Any, Any], second: Dict[Any, Any],
msg: Any = ...) -> None: ...
def fail(self, msg: Any = ...) -> None: ...
def countTestCases(self) -> int: ...
def defaultTestResult(self) -> TestResult: ...
def id(self) -> str: ...
def shortDescription(self) -> Optional[str]: ...
def addCleanup(self, function: Callable[..., Any], *args: Any,
**kwargs: Any) -> None: ...
def doCleanups(self) -> None: ...
# below is deprecated
def failUnlessEqual(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertNotEquals(self, first: Any, second: Any,
msg: Any = ...) -> None: ...
def failUnless(self, expr: bool, msg: Any = ...) -> None: ...
def assert_(self, expr: bool, msg: Any = ...) -> None: ...
def failIf(self, expr: bool, msg: Any = ...) -> None: ...
@overload
def failUnlessRaises(self, # type: ignore
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def failUnlessRaises(self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
msg: Any = ...) -> _AssertRaisesContext: ...
def failUnlessAlmostEqual(self, first: float, second: float,
places: int = ..., msg: Any = ...) -> None: ...
def assertAlmostEquals(self, first: float, second: float, places: int = ...,
msg: Any = ..., delta: float = ...) -> None: ...
def failIfAlmostEqual(self, first: float, second: float, places: int = ...,
msg: Any = ...) -> None: ...
def assertNotAlmostEquals(self, first: float, second: float,
places: int = ..., msg: Any = ...,
delta: float = ...) -> None: ...
def assertRegexpMatches(self, text: str, regex: Union[str, Pattern[str]],
msg: Any = ...) -> None: ...
@overload
def assertRaisesRegexp(self, # type: ignore
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any] = ...,
*args: Any, **kwargs: Any) -> None: ...
@overload
def assertRaisesRegexp(self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
msg: Any = ...) -> _AssertRaisesContext: ...
class FunctionTestCase(TestCase):
def __init__(self, testFunc: Callable[[], None],
setUp: Optional[Callable[[], None]] = ...,
tearDown: Optional[Callable[[], None]] = ...,
description: Optional[str] = ...) -> None: ...
class _AssertRaisesContext:
exception = ... # type: Exception
def __enter__(self) -> _AssertRaisesContext: ...
def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
class _AssertWarnsContext:
warning = ... # type: Warning
filename = ... # type: str
lineno = ... # type: int
def __enter__(self) -> _AssertWarnsContext: ...
def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
class _AssertLogsContext:
records = ... # type: List[logging.LogRecord]
output = ... # type: List[str]
def __enter__(self) -> _AssertLogsContext: ...
def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
_TestType = Union[TestCase, TestSuite]
class TestSuite(Iterable[_TestType]):
def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...
def addTest(self, test: _TestType) -> None: ...
def addTests(self, tests: Iterable[_TestType]) -> None: ...
def run(self, result: TestResult) -> TestResult: ...
def debug(self) -> None: ...
def countTestCases(self) -> int: ...
def __iter__(self) -> Iterator[_TestType]: ...
class TestLoader:
if sys.version_info >= (3, 5):
errors = ... # type: List[Type[BaseException]]
testMethodPrefix = ... # type: str
sortTestMethodsUsing = ... # type: Callable[[str, str], bool]
suiteClass = ... # type: Callable[[List[TestCase]], TestSuite]
def loadTestsFromTestCase(self,
testCaseClass: Type[TestCase]) -> TestSuite: ...
if sys.version_info >= (3, 5):
def loadTestsFromModule(self, module: ModuleType,
*, pattern: Any = ...) -> TestSuite: ...
else:
def loadTestsFromModule(self,
module: ModuleType) -> TestSuite: ...
def loadTestsFromName(self, name: str,
module: Optional[ModuleType] = ...) -> TestSuite: ...
def loadTestsFromNames(self, names: Sequence[str],
module: Optional[ModuleType] = ...) -> TestSuite: ...
def getTestCaseNames(self,
testCaseClass: Type[TestCase]) -> Sequence[str]: ...
def discover(self, start_dir: str, pattern: str = ...,
top_level_dir: Optional[str] = ...) -> TestSuite: ...
_SysExcInfoType = Tuple[Optional[Type[BaseException]],
Optional[BaseException],
Optional[TracebackType]]
class TestResult:
errors = ... # type: List[Tuple[TestCase, str]]
failures = ... # type: List[Tuple[TestCase, str]]
skipped = ... # type: List[Tuple[TestCase, str]]
expectedFailures = ... # type: List[Tuple[TestCase, str]]
unexpectedSuccesses = ... # type: List[TestCase]
shouldStop = ... # type: bool
testsRun = ... # type: int
buffer = ... # type: bool
failfast = ... # type: bool
tb_locals = ... # type: bool
def wasSuccessful(self) -> bool: ...
def stop(self) -> None: ...
def startTest(self, test: TestCase) -> None: ...
def stopTest(self, test: TestCase) -> None: ...
def startTestRun(self) -> None: ...
def stopTestRun(self) -> None: ...
def addError(self, test: TestCase, err: _SysExcInfoType) -> None: ...
def addFailure(self, test: TestCase, err: _SysExcInfoType) -> None: ...
def addSuccess(self, test: TestCase) -> None: ...
def addSkip(self, test: TestCase, reason: str) -> None: ...
def addExpectedFailure(self, test: TestCase,
err: _SysExcInfoType) -> None: ...
def addUnexpectedSuccess(self, test: TestCase) -> None: ...
if sys.version_info >= (3, 4):
def addSubTest(self, test: TestCase, subtest: TestCase,
outcome: Optional[_SysExcInfoType]) -> None: ...
class TextTestResult(TestResult):
def __init__(self, stream: TextIO = ..., descriptions: bool = ...,
verbosity: int = ...) -> None: ...
_TextTestResult = TextTestResult
defaultTestLoader = ... # type: TestLoader
_ResultClassType = Callable[[TextIO, bool, int], TestResult]
class TestRunner:
def run(self, test: Union[TestSuite, TestCase]) -> TestResult: ...
class TextTestRunner(TestRunner):
if sys.version_info >= (3, 5):
def __init__(self, stream: Optional[TextIO] = ...,
descriptions: bool = ..., verbosity: int = ...,
failfast: bool = ..., buffer: bool = ...,
resultclass: Optional[_ResultClassType] = ...,
warnings: Optional[Type[Warning]] = ...,
*, tb_locals: bool = ...) -> None: ...
else:
def __init__(self,
stream: Optional[TextIO] = ...,
descriptions: bool = ..., verbosity: int = ...,
failfast: bool = ..., buffer: bool = ...,
resultclass: Optional[_ResultClassType] = ...,
warnings: Optional[Type[Warning]] = ...) -> None: ...
def _makeResult(self) -> TestResult: ...
if sys.version_info >= (3, 4):
_DefaultTestType = Union[str, Iterable[str], None]
else:
_DefaultTestType = Union[str, None]
# not really documented
class TestProgram:
result = ... # type: TestResult
def main(module: str = ..., defaultTest: _DefaultTestType = ...,
argv: Optional[List[str]] = ...,
testRunner: Union[Type[TestRunner], TestRunner, None] = ...,
testLoader: TestLoader = ..., exit: bool = ..., verbosity: int = ...,
failfast: Optional[bool] = ..., catchbreak: Optional[bool] = ...,
buffer: Optional[bool] = ...,
warnings: Optional[str] = ...) -> TestProgram: ...
def installHandler() -> None: ...
def registerResult(result: TestResult) -> None: ...
def removeResult(result: TestResult) -> None: ...
@overload
def removeHandler() -> None: ...
@overload
def removeHandler(function: _FT) -> _FT: ...
mypy-0.470/typeshed/stdlib/3/unittest/mock.pyi 0000644 0000000 0000000 00000013313 13035744274 020035 0 ustar root root # Stubs for unittest.mock
import sys
from typing import Any
if sys.version_info >= (3, 3):
FILTER_DIR = ... # type: Any
class _slotted: ...
class _SentinelObject:
name = ... # type: Any
def __init__(self, name): ...
class _Sentinel:
def __init__(self): ...
def __getattr__(self, name): ...
sentinel = ... # type: Any
DEFAULT = ... # type: Any
class _CallList(list):
def __contains__(self, value): ...
class _MockIter:
obj = ... # type: Any
def __init__(self, obj): ...
def __iter__(self): ...
def __next__(self): ...
class Base:
def __init__(self, *args, **kwargs): ...
class NonCallableMock(Base):
def __new__(cls, *args, **kw): ...
def __init__(self, spec=None, wraps=None, name=None, spec_set=None, parent=None, _spec_state=None, _new_name='', _new_parent=None, _spec_as_instance=False, _eat_self=None, unsafe=False, **kwargs): ...
def attach_mock(self, mock, attribute): ...
def mock_add_spec(self, spec, spec_set=False): ...
return_value = ... # type: Any
@property
def __class__(self): ...
called = ... # type: Any
call_count = ... # type: Any
call_args = ... # type: Any
call_args_list = ... # type: Any
mock_calls = ... # type: Any
side_effect = ... # type: Any
method_calls = ... # type: Any
def reset_mock(self, visited=None): ...
def configure_mock(self, **kwargs): ...
def __getattr__(self, name): ...
def __dir__(self): ...
def __setattr__(self, name, value): ...
def __delattr__(self, name): ...
def assert_not_called(_mock_self): ...
def assert_called_with(_mock_self, *args, **kwargs): ...
def assert_called_once_with(_mock_self, *args, **kwargs): ...
def assert_has_calls(self, calls, any_order=False): ...
def assert_any_call(self, *args, **kwargs): ...
class CallableMixin(Base):
side_effect = ... # type: Any
def __init__(self, spec=None, side_effect=None, return_value=..., wraps=None, name=None, spec_set=None, parent=None, _spec_state=None, _new_name='', _new_parent=None, **kwargs): ...
def __call__(_mock_self, *args, **kwargs): ...
class Mock(CallableMixin, NonCallableMock): ...
class _patch:
attribute_name = ... # type: Any
getter = ... # type: Any
attribute = ... # type: Any
new = ... # type: Any
new_callable = ... # type: Any
spec = ... # type: Any
create = ... # type: Any
has_local = ... # type: Any
spec_set = ... # type: Any
autospec = ... # type: Any
kwargs = ... # type: Any
additional_patchers = ... # type: Any
def __init__(self, getter, attribute, new, spec, create, spec_set, autospec, new_callable, kwargs): ...
def copy(self): ...
def __call__(self, func): ...
def decorate_class(self, klass): ...
def decorate_callable(self, func): ...
def get_original(self): ...
target = ... # type: Any
temp_original = ... # type: Any
is_local = ... # type: Any
def __enter__(self): ...
def __exit__(self, *exc_info): ...
def start(self): ...
def stop(self): ...
def patch(target, new=..., spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs): ...
class _patch_dict:
in_dict = ... # type: Any
values = ... # type: Any
clear = ... # type: Any
def __init__(self, in_dict, values=..., clear=False, **kwargs): ...
def __call__(self, f): ...
def decorate_class(self, klass): ...
def __enter__(self): ...
def __exit__(self, *args): ...
start = ... # type: Any
stop = ... # type: Any
class MagicMixin:
def __init__(self, *args, **kw): ...
class NonCallableMagicMock(MagicMixin, NonCallableMock):
def mock_add_spec(self, spec, spec_set=False): ...
class MagicMock(MagicMixin, Mock):
def mock_add_spec(self, spec, spec_set=False): ...
class MagicProxy:
name = ... # type: Any
parent = ... # type: Any
def __init__(self, name, parent): ...
def __call__(self, *args, **kwargs): ...
def create_mock(self): ...
def __get__(self, obj, _type=None): ...
class _ANY:
def __eq__(self, other): ...
def __ne__(self, other): ...
ANY = ... # type: Any
class _Call(tuple):
def __new__(cls, value=..., name=None, parent=None, two=False, from_kall=True): ...
name = ... # type: Any
parent = ... # type: Any
from_kall = ... # type: Any
def __init__(self, value=..., name=None, parent=None, two=False, from_kall=True): ...
def __eq__(self, other): ...
__ne__ = ... # type: Any
def __call__(self, *args, **kwargs): ...
def __getattr__(self, attr): ...
def count(self, *args, **kwargs): ...
def index(self, *args, **kwargs): ...
def call_list(self): ...
call = ... # type: Any
def create_autospec(spec, spec_set=False, instance=False, _parent=None, _name=None, **kwargs): ...
class _SpecState:
spec = ... # type: Any
ids = ... # type: Any
spec_set = ... # type: Any
parent = ... # type: Any
instance = ... # type: Any
name = ... # type: Any
def __init__(self, spec, spec_set=False, parent=None, name=None, ids=None, instance=False): ...
def mock_open(mock=None, read_data=''): ...
class PropertyMock(Mock):
def __get__(self, obj, obj_type): ...
def __set__(self, obj, val): ...
mypy-0.470/typeshed/stdlib/3/_thread.pyi 0000644 0000000 0000000 00000000433 13035744274 016632 0 ustar root root # Stubs for _thread
# NOTE: These are incomplete!
from typing import Any
def _count() -> int: ...
_dangling = ... # type: Any
class LockType:
def acquire(self) -> None: ...
def release(self) -> None: ...
def allocate_lock() -> LockType: ...
def get_ident() -> int: ...
mypy-0.470/typeshed/stdlib/3/gzip.pyi 0000644 0000000 0000000 00000002726 13035744274 016204 0 ustar root root # Stubs for gzip (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import _compression
def open(filename, mode='', compresslevel=9, encoding=None, errors=None, newline=None): ...
class _PaddedFile:
file = ... # type: Any
def __init__(self, f, prepend=b''): ...
def read(self, size): ...
def prepend(self, prepend=b''): ...
def seek(self, off): ...
def seekable(self): ...
class GzipFile(_compression.BaseStream):
myfileobj = ... # type: Any
mode = ... # type: Any
name = ... # type: Any
compress = ... # type: Any
fileobj = ... # type: Any
def __init__(self, filename=None, mode=None, compresslevel=9, fileobj=None, mtime=None): ...
@property
def filename(self): ...
@property
def mtime(self): ...
crc = ... # type: Any
def write(self, data): ...
def read(self, size=-1): ...
def read1(self, size=-1): ...
def peek(self, n): ...
@property
def closed(self): ...
def close(self): ...
def flush(self, zlib_mode=...): ...
def fileno(self): ...
def rewind(self): ...
def readable(self): ...
def writable(self): ...
def seekable(self): ...
def seek(self, offset, whence=...): ...
def readline(self, size=-1): ...
class _GzipReader(_compression.DecompressReader):
def __init__(self, fp): ...
def read(self, size=-1): ...
def compress(data, compresslevel=9): ...
def decompress(data): ...
mypy-0.470/typeshed/stdlib/3/queue.pyi 0000644 0000000 0000000 00000001307 13023631176 016342 0 ustar root root # Stubs for queue
# NOTE: These are incomplete!
from typing import Any, TypeVar, Generic, Optional
_T = TypeVar('_T')
class Empty(Exception): ...
class Full(Exception): ...
class Queue(Generic[_T]):
def __init__(self, maxsize: int = ...) -> None: ...
def full(self) -> bool: ...
def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
def get_nowait(self) -> _T: ...
def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
def put_nowait(self, item: _T) -> None: ...
def join(self) -> None: ...
def qsize(self) -> int: ...
def task_done(self) -> None: pass
class PriorityQueue(Queue): ...
class LifoQueue(Queue): ...
mypy-0.470/typeshed/stdlib/3/sys.pyi 0000644 0000000 0000000 00000012573 13044257024 016042 0 ustar root root # Stubs for sys
# Ron Murawski
# based on http://docs.python.org/3.2/library/sys.html
from typing import (
List, Sequence, Any, Dict, Tuple, TextIO, overload, Optional, Union,
TypeVar, Callable, Type,
)
from types import TracebackType
from mypy_extensions import NoReturn
_T = TypeVar('_T')
# ----- sys variables -----
abiflags = ... # type: str
argv = ... # type: List[str]
byteorder = ... # type: str
builtin_module_names = ... # type: Sequence[str] # actually a tuple of strings
copyright = ... # type: str
# dllhandle = 0 # Windows only
dont_write_bytecode = False
__displayhook__ = ... # type: Any # contains the original value of displayhook
__excepthook__ = ... # type: Any # contains the original value of excepthook
exec_prefix = ... # type: str
executable = ... # type: str
float_repr_style = ... # type: str
hexversion = 0 # this is a 32-bit int
last_type = ... # type: Any
last_value = ... # type: Any
last_traceback = ... # type: Any
maxsize = 0
maxunicode = 0
meta_path = ... # type: List[Any]
modules = ... # type: Dict[str, Any]
path = ... # type: List[str]
path_hooks = ... # type: List[Any] # TODO precise type; function, path to finder
path_importer_cache = ... # type: Dict[str, Any] # TODO precise type
platform = ... # type: str
prefix = ... # type: str
ps1 = ... # type: str
ps2 = ... # type: str
stdin = ... # type: TextIO
stdout = ... # type: TextIO
stderr = ... # type: TextIO
__stdin__ = ... # type: TextIO
__stdout__ = ... # type: TextIO
__stderr__ = ... # type: TextIO
# deprecated and removed in Python 3.3:
subversion = ... # type: Tuple[str, str, str]
tracebacklimit = 0
version = ... # type: str
api_version = 0
warnoptions = ... # type: Any
# Each entry is a tuple of the form (action, message, category, module,
# lineno)
# winver = '' # Windows only
_xoptions = ... # type: Dict[Any, Any]
flags = ... # type: _flags
class _flags:
debug = 0
division_warning = 0
inspect = 0
interactive = 0
optimize = 0
dont_write_bytecode = 0
no_user_site = 0
no_site = 0
ignore_environment = 0
verbose = 0
bytes_warning = 0
quiet = 0
hash_randomization = 0
float_info = ... # type: _float_info
class _float_info:
epsilon = 0.0 # DBL_EPSILON
dig = 0 # DBL_DIG
mant_dig = 0 # DBL_MANT_DIG
max = 0.0 # DBL_MAX
max_exp = 0 # DBL_MAX_EXP
max_10_exp = 0 # DBL_MAX_10_EXP
min = 0.0 # DBL_MIN
min_exp = 0 # DBL_MIN_EXP
min_10_exp = 0 # DBL_MIN_10_EXP
radix = 0 # FLT_RADIX
rounds = 0 # FLT_ROUNDS
hash_info = ... # type: _hash_info
class _hash_info:
width = 0 # width in bits used for hash values
modulus = 0 # prime modulus P used for numeric hash scheme
inf = 0 # hash value returned for a positive infinity
nan = 0 # hash value returned for a nan
imag = 0 # multiplier used for the imaginary part of a complex number
int_info = ... # type: _int_info
class _int_info:
bits_per_digit = 0 # number of bits held in each digit. Python integers are stored internally in base 2**int_info.bits_per_digit
sizeof_digit = 0 # size in bytes of C type used to represent a digit
class _version_info(Tuple[int, int, int, str, int]):
major = 0
minor = 0
micro = 0
releaselevel = ... # type: str
serial = 0
version_info = ... # type: _version_info
# ----- sys function stubs -----
def call_tracing(fn: Callable[..., _T], args: Any) -> _T: ...
def _clear_type_cache() -> None: ...
def _current_frames() -> Dict[int, Any]: ...
def displayhook(value: Optional[int]) -> None: ...
def excepthook(type_: Type[BaseException], value: BaseException,
traceback: TracebackType) -> None: ...
# TODO should be a union of tuple, see mypy#1178
def exc_info() -> Tuple[Optional[Type[BaseException]],
Optional[BaseException],
Optional[TracebackType]]: ...
# sys.exit() accepts an optional argument of anything printable
def exit(arg: Any = ...) -> NoReturn:
raise SystemExit()
def getcheckinterval() -> int: ... # deprecated
def getdefaultencoding() -> str: ...
def getdlopenflags() -> int: ... # Unix only
def getfilesystemencoding() -> str: ... # cannot return None
def getrefcount(arg: Any) -> int: ...
def getrecursionlimit() -> int: ...
@overload
def getsizeof(obj: object) -> int: ...
@overload
def getsizeof(obj: object, default: int) -> int: ...
def getswitchinterval() -> float: ...
@overload
def _getframe() -> Any: ...
@overload
def _getframe(depth: int) -> Any: ...
def getprofile() -> Any: ... # TODO return type
def gettrace() -> Any: ... # TODO return
def getwindowsversion() -> Any: ... # Windows only, TODO return type
def intern(string: str) -> str: ...
def setcheckinterval(interval: int) -> None: ... # deprecated
def setdlopenflags(n: int) -> None: ... # Linux only
def setprofile(profilefunc: Any) -> None: ... # TODO type
def setrecursionlimit(limit: int) -> None: ...
def setswitchinterval(interval: float) -> None: ...
def settrace(tracefunc: Any) -> None: ... # TODO type
# Trace functions should have three arguments: frame, event, and arg. frame
# is the current stack frame. event is a string: 'call', 'line', 'return',
# 'exception', 'c_call', 'c_return', or 'c_exception'. arg depends on the
# event type.
def settscdump(on_flag: bool) -> None: ...
def gettotalrefcount() -> int: ... # Debug builds only
mypy-0.470/typeshed/stdlib/3/pickle.pyi 0000644 0000000 0000000 00000003417 13023631176 016471 0 ustar root root # Stubs for pickle
from typing import Any, IO, Union, Tuple, Callable, Optional, Iterator
# Imports used in type comments only.
from typing import Mapping # noqa
HIGHEST_PROTOCOL = ... # type: int
DEFAULT_PROTOCOL = ... # type: int
def dump(obj: Any, file: IO[bytes], protocol: int = None, *,
fix_imports: bool = ...) -> None: ...
def dumps(obj: Any, protocol: int = ..., *,
fix_imports: bool = ...) -> bytes: ...
def loads(bytes_object: bytes, *, fix_imports: bool = ...,
encoding: str = ..., errors: str = ...) -> Any: ...
def load(file: IO[bytes], *, fix_imports: bool = ..., encoding: str = ...,
errors: str = ...) -> Any: ...
class PickleError(Exception):
pass
class PicklingError(PickleError):
pass
class UnpicklingError(PickleError):
pass
_reducedtype = Union[str,
Tuple[Callable[..., Any], Tuple],
Tuple[Callable[..., Any], Tuple, Any],
Tuple[Callable[..., Any], Tuple, Any,
Optional[Iterator]],
Tuple[Callable[..., Any], Tuple, Any,
Optional[Iterator], Optional[Iterator]]]
class Pickler:
dispatch_table = ... # type: Mapping[type, Callable[[Any], _reducedtype]]
def __init__(self, file: IO[bytes], protocol: int = None, *,
fix_imports: bool = ...) -> None: ...
def dump(self, obj: Any) -> None: ...
def persistent_id(self, obj: Any) -> Any: ...
class Unpickler:
def __init__(self, file: IO[bytes], *, fix_imports: bool = ...,
encoding: str = ..., errors: str = ...) -> None: ...
def load(self) -> Any: ...
def persistent_load(self, pid: Any) -> Any: ...
def find_class(self, module: str, name: str) -> Any: ...
mypy-0.470/typeshed/stdlib/3/html/ 0000755 0000000 0000000 00000000000 13044320557 015437 5 ustar root root mypy-0.470/typeshed/stdlib/3/html/__init__.pyi 0000644 0000000 0000000 00000000172 13023631176 017720 0 ustar root root from typing import AnyStr
def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ...
def unescape(s: AnyStr) -> AnyStr: ...
mypy-0.470/typeshed/stdlib/3/html/parser.pyi 0000644 0000000 0000000 00000002473 13023631176 017463 0 ustar root root from typing import List, Tuple
from _markupbase import ParserBase
import sys
class HTMLParser(ParserBase):
if sys.version_info >= (3, 5):
def __init__(self, *, convert_charrefs: bool = ...) -> None: ...
elif sys.version_info >= (3, 4):
def __init__(self, strict: bool = ..., *,
convert_charrefs: bool = ...) -> None: ...
else:
def __init__(self, strict: bool = ...) -> None: ...
def feed(self, feed: str) -> None: ...
def close(self) -> None: ...
def reset(self) -> None: ...
def getpos(self) -> Tuple[int, int]: ...
def get_starttag_text(self) -> str: ...
def handle_starttag(self, tag: str,
attrs: List[Tuple[str, str]]) -> None: ...
def handle_endtag(self, tag: str) -> None: ...
def handle_startendtag(self, tag: str,
attrs: List[Tuple[str, str]]) -> None: ...
def handle_data(self, data: str) -> None: ...
def handle_entityref(self, name: str) -> None: ...
def handle_charref(self, name: str) -> None: ...
def handle_comment(self, data: str) -> None: ...
def handle_decl(self, decl: str) -> None: ...
def handle_pi(self, data: str) -> None: ...
def unknown_decl(self, data: str) -> None: ...
if sys.version_info < (3, 5):
class HTMLParseError(Exception): ...
mypy-0.470/typeshed/stdlib/3/html/entities.pyi 0000644 0000000 0000000 00000000411 13035744274 020010 0 ustar root root # Stubs for html.entities (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
name2codepoint = ... # type: Any
html5 = ... # type: Any
codepoint2name = ... # type: Any
entitydefs = ... # type: Any
mypy-0.470/typeshed/stdlib/3/shutil.pyi 0000644 0000000 0000000 00000004551 13035744274 016541 0 ustar root root # Stubs for shutil
import sys
# Based on http://docs.python.org/3.2/library/shutil.html
# 'bytes' paths are not properly supported: they don't work with all functions,
# sometimes they only work partially (broken exception messages), and the test
# cases don't use them.
from typing import List, Iterable, Callable, Any, Tuple, Sequence, IO, AnyStr, Optional
def copyfileobj(fsrc: IO[AnyStr], fdst: IO[AnyStr],
length: int = ...) -> None: ...
def copyfile(src: str, dst: str) -> None: ...
def copymode(src: str, dst: str) -> None: ...
def copystat(src: str, dst: str) -> None: ...
def copy(src: str, dst: str) -> None: ...
def copy2(src: str, dst: str) -> None: ...
def ignore_patterns(*patterns: str) -> Callable[[str, List[str]],
Iterable[str]]: ...
def copytree(src: str, dst: str, symlinks: bool = ...,
ignore: Optional[Callable[[str, List[str]], Iterable[str]]] = ...,
copy_function: Callable[[str, str], None] = ...,
ignore_dangling_symlinks: bool = ...) -> None: ...
def rmtree(path: str, ignore_errors: bool = ...,
onerror: Callable[[Any, str, Any], None] = ...) -> None: ...
def move(src: str, dst: str) -> None: ...
class Error(Exception): ...
if sys.version_info >= (3, 4):
class SameFileError(Error): ...
def make_archive(base_name: str, format: str, root_dir: str = ...,
base_dir: str = ..., verbose: bool = ...,
dry_run: bool = ..., owner: str = ..., group: str = ...,
logger: Any = ...) -> str: ...
def get_archive_formats() -> List[Tuple[str, str]]: ...
def register_archive_format(name: str, function: Any,
extra_args: Sequence[Tuple[str, Any]] = ...,
description: str = ...) -> None: ...
def unregister_archive_format(name: str) -> None: ...
def unpack_archive(filename: str, extract_dir: str = ...,
format: str = ...) -> None: ...
def register_unpack_format(name: str, extensions: List[str], function: Any,
extra_args: Sequence[Tuple[str, Any]] = ...,
description: str = ...) -> None: ...
def unregister_unpack_format(name: str) -> None: ...
def get_unpack_formats() -> List[Tuple[str, List[str], str]]: ...
def which(cmd: str, mode: int = ..., path: str = ...) -> Optional[str]: ...
mypy-0.470/typeshed/stdlib/3/_operator.pyi 0000644 0000000 0000000 00000003365 13023631176 017216 0 ustar root root # Stubs for _operator (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def _compare_digest(*args, **kwargs): ...
def abs(a): ...
def add(a, b): ...
def and_(a, b): ...
def concat(a, b): ...
def contains(a, b): ...
def countOf(a, b): ...
def delitem(a, b): ...
def eq(a, b): ...
def floordiv(a, b): ...
def ge(a, b): ...
def getitem(a, b): ...
def gt(a, b): ...
def iadd(*args, **kwargs): ...
def iand(*args, **kwargs): ...
def iconcat(*args, **kwargs): ...
def ifloordiv(*args, **kwargs): ...
def ilshift(*args, **kwargs): ...
def imatmul(*args, **kwargs): ...
def imod(*args, **kwargs): ...
def imul(*args, **kwargs): ...
def index(a): ...
def indexOf(a, b): ...
def inv(a): ...
def invert(a): ...
def ior(*args, **kwargs): ...
def ipow(*args, **kwargs): ...
def irshift(*args, **kwargs): ...
def is_(a, b): ...
def is_not(a, b): ...
def isub(*args, **kwargs): ...
def itruediv(*args, **kwargs): ...
def ixor(*args, **kwargs): ...
def le(a, b): ...
def length_hint(obj, default=0): ...
def lshift(a, b): ...
def lt(a, b): ...
def matmul(a, b): ...
def mod(a, b): ...
def mul(a, b): ...
def ne(a, b): ...
def neg(a): ...
def not_(a): ...
def or_(a, b): ...
def pos(a): ...
def pow(a, b): ...
def rshift(a, b): ...
def setitem(a, b, c): ...
def sub(a, b): ...
def truediv(a, b): ...
def truth(a): ...
def xor(a, b): ...
class attrgetter:
def __init__(self, *args, **kwargs): ...
def __call__(self, *args, **kwargs): ...
def __reduce__(self): ...
class itemgetter:
def __init__(self, *args, **kwargs): ...
def __call__(self, *args, **kwargs): ...
def __reduce__(self): ...
class methodcaller:
def __init__(self, *args, **kwargs): ...
def __call__(self, *args, **kwargs): ...
def __reduce__(self): ...
mypy-0.470/typeshed/stdlib/3/csv.pyi 0000644 0000000 0000000 00000004477 13023631176 016024 0 ustar root root # Stubs for csv (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Iterable
QUOTE_ALL = ... # type: int
QUOTE_MINIMAL = ... # type: int
QUOTE_NONE = ... # type: int
QUOTE_NONNUMERIC = ... # type: int
class Error(Exception): ...
def writer(csvfile, dialect=..., **fmtparams): ...
def reader(csvfile, dialect=..., **fmtparams): ...
def register_dialect(name, dialect=..., **fmtparams): ...
def unregister_dialect(name): ...
def get_dialect(name): ...
def list_dialects(): ...
def field_size_limit(new_limit=...): ...
class Dialect:
delimiter = ... # type: Any
quotechar = ... # type: Any
escapechar = ... # type: Any
doublequote = ... # type: Any
skipinitialspace = ... # type: Any
lineterminator = ... # type: Any
quoting = ... # type: Any
def __init__(self) -> None: ...
class excel(Dialect):
delimiter = ... # type: Any
quotechar = ... # type: Any
doublequote = ... # type: Any
skipinitialspace = ... # type: Any
lineterminator = ... # type: Any
quoting = ... # type: Any
class excel_tab(excel):
delimiter = ... # type: Any
class unix_dialect(Dialect):
delimiter = ... # type: Any
quotechar = ... # type: Any
doublequote = ... # type: Any
skipinitialspace = ... # type: Any
lineterminator = ... # type: Any
quoting = ... # type: Any
class DictReader(Iterable):
restkey = ... # type: Any
restval = ... # type: Any
reader = ... # type: Any
dialect = ... # type: Any
line_num = ... # type: Any
fieldnames = ... # type: Any # Actually a property
def __init__(self, f, fieldnames=..., restkey=..., restval=..., dialect=...,
*args, **kwds): ...
def __iter__(self): ...
def __next__(self): ...
class DictWriter:
fieldnames = ... # type: Any
restval = ... # type: Any
extrasaction = ... # type: Any
writer = ... # type: Any
def __init__(self, f, fieldnames, restval=..., extrasaction=..., dialect=..., *args, **kwds) -> None: ...
def writeheader(self): ...
def writerow(self, rowdict): ...
def writerows(self, rowdicts): ...
class Sniffer:
preferred = ... # type: Any
def __init__(self) -> None: ...
def sniff(self, sample, delimiters=...): ...
def has_header(self, sample): ...
mypy-0.470/typeshed/stdlib/3/pdb.pyi 0000644 0000000 0000000 00000001146 13023631176 015764 0 ustar root root # Stub for pdb (incomplete, only some global functions)
from typing import Any, Dict
def run(statement: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> None:
...
def runeval(expression: str,
globals: Dict[str, Any] = None,
locals: Dict[str, Any] = None) -> Any:
...
def runctx(statement: str,
globals: Dict[str, Any],
locals: Dict[str, Any]) -> None:
...
def runcall(*args: Any, **kwds: Any) -> Any:
...
def set_trace() -> None:
...
def post_mortem(t: Any = None) -> None:
...
def pm() -> None:
...
mypy-0.470/typeshed/stdlib/3/builtins.pyi 0000644 0000000 0000000 00000112204 13044257024 017045 0 ustar root root # Stubs for builtins (Python 3)
from typing import (
TypeVar, Iterator, Iterable, overload, Container,
Sequence, MutableSequence, Mapping, MutableMapping, Tuple, List, Any, Dict, Callable, Generic,
Set, AbstractSet, FrozenSet, MutableSet, Sized, Reversible, SupportsInt, SupportsFloat,
SupportsBytes, SupportsAbs, SupportsRound, IO, Union, ItemsView, KeysView, ValuesView,
ByteString, Optional
)
from abc import abstractmethod, ABCMeta
from types import TracebackType
import sys
from mypy_extensions import NoReturn
# Note that names imported above are not automatically made visible via the
# implicit builtins import.
_T = TypeVar('_T')
_T_co = TypeVar('_T_co', covariant=True)
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
_S = TypeVar('_S')
_T1 = TypeVar('_T1')
_T2 = TypeVar('_T2')
_T3 = TypeVar('_T3')
_T4 = TypeVar('_T4')
_TT = TypeVar('_TT', bound='type')
class staticmethod: pass # Special, only valid as a decorator.
class classmethod: pass # Special, only valid as a decorator.
class object:
__doc__ = ... # type: Optional[str]
__class__ = ... # type: type
__dict__ = ... # type: Dict[str, Any]
__slots__ = ... # type: Optional[Union[str, Iterable[str]]]
def __init__(self) -> None: ...
def __new__(cls) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __eq__(self, o: object) -> bool: ...
def __ne__(self, o: object) -> bool: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __hash__(self) -> int: ...
def __format__(self, format_spec: str) -> str: ...
def __getattribute__(self, name: str) -> Any: ...
def __delattr__(self, name: str) -> None: ...
if sys.version_info >= (3, 6):
def __init_subclass__(cls) -> None: ...
class type:
__bases__ = ... # type: Tuple[type, ...]
__name__ = ... # type: str
__qualname__ = ... # type: str
__module__ = ... # type: str
__dict__ = ... # type: Dict[str, Any]
__mro__ = ... # type: Tuple[type, ...]
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
@overload
def __new__(cls, o: object) -> type: ...
@overload
def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
def __call__(self, *args: Any, **kwds: Any) -> Any: ...
def __subclasses__(self: _TT) -> List[_TT]: ...
# Note: the documentation doesnt specify what the return type is, the standard
# implementation seems to be returning a list.
def mro(self) -> List[type]: ...
class int(SupportsInt, SupportsFloat, SupportsAbs[int]):
def __init__(self, x: Union[SupportsInt, str, bytes] = ..., base: int = ...) -> None: ...
def bit_length(self) -> int: ...
def to_bytes(self, length: int, byteorder: str, *, signed: bool = ...) -> bytes: ...
@classmethod
def from_bytes(cls, bytes: Sequence[int], byteorder: str, *,
signed: bool = ...) -> int: ... # TODO buffer object argument
def __add__(self, x: int) -> int: ...
def __sub__(self, x: int) -> int: ...
def __mul__(self, x: int) -> int: ...
def __floordiv__(self, x: int) -> int: ...
def __truediv__(self, x: int) -> float: ...
def __mod__(self, x: int) -> int: ...
def __radd__(self, x: int) -> int: ...
def __rsub__(self, x: int) -> int: ...
def __rmul__(self, x: int) -> int: ...
def __rfloordiv__(self, x: int) -> int: ...
def __rtruediv__(self, x: int) -> float: ...
def __rmod__(self, x: int) -> int: ...
def __pow__(self, x: int) -> Any: ... # Return type can be int or float, depending on x.
def __rpow__(self, x: int) -> Any: ...
def __and__(self, n: int) -> int: ...
def __or__(self, n: int) -> int: ...
def __xor__(self, n: int) -> int: ...
def __lshift__(self, n: int) -> int: ...
def __rshift__(self, n: int) -> int: ...
def __rand__(self, n: int) -> int: ...
def __ror__(self, n: int) -> int: ...
def __rxor__(self, n: int) -> int: ...
def __rlshift__(self, n: int) -> int: ...
def __rrshift__(self, n: int) -> int: ...
def __neg__(self) -> int: ...
def __pos__(self) -> int: ...
def __invert__(self) -> int: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: int) -> bool: ...
def __le__(self, x: int) -> bool: ...
def __gt__(self, x: int) -> bool: ...
def __ge__(self, x: int) -> bool: ...
def __str__(self) -> str: ...
def __float__(self) -> float: ...
def __int__(self) -> int: return self
def __abs__(self) -> int: ...
def __hash__(self) -> int: ...
class float(SupportsFloat, SupportsInt, SupportsAbs[float]):
def __init__(self, x: Union[SupportsFloat, str, bytes] = ...) -> None: ...
def as_integer_ratio(self) -> Tuple[int, int]: ...
def hex(self) -> str: ...
def is_integer(self) -> bool: ...
@classmethod
def fromhex(cls, s: str) -> float: ...
def __add__(self, x: float) -> float: ...
def __sub__(self, x: float) -> float: ...
def __mul__(self, x: float) -> float: ...
def __floordiv__(self, x: float) -> float: ...
def __truediv__(self, x: float) -> float: ...
def __mod__(self, x: float) -> float: ...
def __pow__(self, x: float) -> float: ...
def __radd__(self, x: float) -> float: ...
def __rsub__(self, x: float) -> float: ...
def __rmul__(self, x: float) -> float: ...
def __rfloordiv__(self, x: float) -> float: ...
def __rtruediv__(self, x: float) -> float: ...
def __rmod__(self, x: float) -> float: ...
def __rpow__(self, x: float) -> float: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: float) -> bool: ...
def __le__(self, x: float) -> bool: ...
def __gt__(self, x: float) -> bool: ...
def __ge__(self, x: float) -> bool: ...
def __neg__(self) -> float: ...
def __pos__(self) -> float: ...
def __str__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class complex(SupportsAbs[float]):
@overload
def __init__(self, re: float = 0.0, im: float = 0.0) -> None: ...
@overload
def __init__(self, s: str) -> None: ...
@property
def real(self) -> float: ...
@property
def imag(self) -> float: ...
def conjugate(self) -> complex: ...
def __add__(self, x: complex) -> complex: ...
def __sub__(self, x: complex) -> complex: ...
def __mul__(self, x: complex) -> complex: ...
def __pow__(self, x: complex) -> complex: ...
def __truediv__(self, x: complex) -> complex: ...
def __radd__(self, x: complex) -> complex: ...
def __rsub__(self, x: complex) -> complex: ...
def __rmul__(self, x: complex) -> complex: ...
def __rpow__(self, x: complex) -> complex: ...
def __rtruediv__(self, x: complex) -> complex: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __neg__(self) -> complex: ...
def __pos__(self) -> complex: ...
def __str__(self) -> str: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
class str(Sequence[str]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, o: bytes, encoding: str = ..., errors: str = 'strict') -> None: ...
def capitalize(self) -> str: ...
def center(self, width: int, fillchar: str = ' ') -> str: ...
def count(self, x: str) -> int: ...
def encode(self, encoding: str = 'utf-8', errors: str = 'strict') -> bytes: ...
def endswith(self, suffix: Union[str, Tuple[str, ...]], start: int = None,
end: int = None) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> str: ...
def find(self, sub: str, start: int = 0, end: int = 0) -> int: ...
def format(self, *args: Any, **kwargs: Any) -> str: ...
def format_map(self, map: Mapping[str, Any]) -> str: ...
def index(self, sub: str, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def isidentifier(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isprintable(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[str]) -> str: ...
def ljust(self, width: int, fillchar: str = ' ') -> str: ...
def lower(self) -> str: ...
def lstrip(self, chars: str = None) -> str: ...
def partition(self, sep: str) -> Tuple[str, str, str]: ...
def replace(self, old: str, new: str, count: int = -1) -> str: ...
def rfind(self, sub: str, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: str, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: str = ' ') -> str: ...
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
def rsplit(self, sep: str = None, maxsplit: int = -1) -> List[str]: ...
def rstrip(self, chars: str = None) -> str: ...
def split(self, sep: str = None, maxsplit: int = -1) -> List[str]: ...
def splitlines(self, keepends: bool = ...) -> List[str]: ...
def startswith(self, prefix: Union[str, Tuple[str, ...]], start: int = None,
end: int = None) -> bool: ...
def strip(self, chars: str = None) -> str: ...
def swapcase(self) -> str: ...
def title(self) -> str: ...
def translate(self, table: Dict[int, Any]) -> str: ...
def upper(self) -> str: ...
def zfill(self, width: int) -> str: ...
@staticmethod
@overload
def maketrans(x: Union[Dict[int, Any], Dict[str, Any]]) -> Dict[int, Any]: ...
@staticmethod
@overload
def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Any]: ...
def __getitem__(self, i: Union[int, slice]) -> str: ...
def __add__(self, s: str) -> str: ...
def __mul__(self, n: int) -> str: ...
def __rmul__(self, n: int) -> str: ...
def __mod__(self, *args: Any) -> str: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: str) -> bool: ...
def __le__(self, x: str) -> bool: ...
def __gt__(self, x: str) -> bool: ...
def __ge__(self, x: str) -> bool: ...
def __len__(self) -> int: ...
def __contains__(self, s: object) -> bool: ...
def __iter__(self) -> Iterator[str]: ...
def __str__(self) -> str: return self
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
class bytes(ByteString):
@overload
def __init__(self, ints: Iterable[int]) -> None: ...
@overload
def __init__(self, string: str, encoding: str,
errors: str = 'strict') -> None: ...
@overload
def __init__(self, length: int) -> None: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, o: SupportsBytes) -> None: ...
def capitalize(self) -> bytes: ...
def center(self, width: int, fillchar: bytes = ...) -> bytes: ...
def count(self, x: bytes) -> int: ...
def decode(self, encoding: str = 'utf-8', errors: str = 'strict') -> str: ...
def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> bytes: ...
def find(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
if sys.version_info >= (3, 5):
def hex(self) -> str: ...
def index(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[bytes]) -> bytes: ...
def ljust(self, width: int, fillchar: bytes = ...) -> bytes: ...
def lower(self) -> bytes: ...
def lstrip(self, chars: bytes = None) -> bytes: ...
def partition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
def replace(self, old: bytes, new: bytes, count: int = -1) -> bytes: ...
def rfind(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: bytes = ...) -> bytes: ...
def rpartition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
def rsplit(self, sep: bytes = None, maxsplit: int = -1) -> List[bytes]: ...
def rstrip(self, chars: bytes = None) -> bytes: ...
def split(self, sep: bytes = None, maxsplit: int = -1) -> List[bytes]: ...
def splitlines(self, keepends: bool = ...) -> List[bytes]: ...
def startswith(self, prefix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
def strip(self, chars: bytes = None) -> bytes: ...
def swapcase(self) -> bytes: ...
def title(self) -> bytes: ...
def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytes: ...
def upper(self) -> bytes: ...
def zfill(self, width: int) -> bytes: ...
@classmethod
def fromhex(cls, s: str) -> bytes: ...
@classmethod
def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytes: ...
def __add__(self, s: bytes) -> bytes: ...
def __mul__(self, n: int) -> bytes: ...
def __rmul__(self, n: int) -> bytes: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: bytes) -> bool: ...
def __le__(self, x: bytes) -> bool: ...
def __gt__(self, x: bytes) -> bool: ...
def __ge__(self, x: bytes) -> bool: ...
class bytearray(MutableSequence[int], ByteString):
@overload
def __init__(self, ints: Iterable[int]) -> None: ...
@overload
def __init__(self, string: str, encoding: str, errors: str = 'strict') -> None: ...
@overload
def __init__(self, length: int) -> None: ...
@overload
def __init__(self) -> None: ...
def capitalize(self) -> bytearray: ...
def center(self, width: int, fillchar: bytes = ...) -> bytearray: ...
def count(self, x: bytes) -> int: ...
def decode(self, encoding: str = 'utf-8', errors: str = 'strict') -> str: ...
def endswith(self, suffix: bytes) -> bool: ...
def expandtabs(self, tabsize: int = 8) -> bytearray: ...
def find(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
if sys.version_info >= (3, 5):
def hex(self) -> str: ...
def index(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def insert(self, index: int, object: int) -> None: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, iterable: Iterable[bytes]) -> bytearray: ...
def ljust(self, width: int, fillchar: bytes = ...) -> bytearray: ...
def lower(self) -> bytearray: ...
def lstrip(self, chars: bytes = None) -> bytearray: ...
def partition(self, sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
def replace(self, old: bytes, new: bytes, count: int = -1) -> bytearray: ...
def rfind(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def rindex(self, sub: bytes, start: int = 0, end: int = 0) -> int: ...
def rjust(self, width: int, fillchar: bytes = ...) -> bytearray: ...
def rpartition(self, sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
def rsplit(self, sep: bytes = None, maxsplit: int = -1) -> List[bytearray]: ...
def rstrip(self, chars: bytes = None) -> bytearray: ...
def split(self, sep: bytes = None, maxsplit: int = -1) -> List[bytearray]: ...
def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
def startswith(self, prefix: bytes) -> bool: ...
def strip(self, chars: bytes = None) -> bytearray: ...
def swapcase(self) -> bytearray: ...
def title(self) -> bytearray: ...
def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytearray: ...
def upper(self) -> bytearray: ...
def zfill(self, width: int) -> bytearray: ...
@classmethod
def fromhex(cls, s: str) -> bytearray: ...
@classmethod
def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytearray: ...
@overload
def __setitem__(self, i: int, x: int) -> None: ...
@overload
def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __add__(self, s: bytes) -> bytearray: ...
def __iadd__(self, s: Iterable[int]) -> bytearray: ...
def __mul__(self, n: int) -> bytearray: ...
def __rmul__(self, n: int) -> bytearray: ...
def __imul__(self, n: int) -> bytearray: ...
def __contains__(self, o: object) -> bool: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: bytes) -> bool: ...
def __le__(self, x: bytes) -> bool: ...
def __gt__(self, x: bytes) -> bool: ...
def __ge__(self, x: bytes) -> bool: ...
class memoryview(Sized, Container[bytes]):
format = ... # type: str
itemsize = ... # type: int
shape = ... # type: Optional[Tuple[int, ...]]
strides = ... # type: Optional[Tuple[int, ...]]
suboffsets = ... # type: Optional[Tuple[int, ...]]
readonly = ... # type: bool
ndim = ... # type: int
def __init__(self, obj: Union[str, bytes, bytearray, memoryview]) -> None: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> memoryview: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
def __len__(self) -> int: ...
@overload
def __setitem__(self, i: int, o: bytes) -> None: ...
@overload
def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
@overload
def __setitem__(self, s: slice, o: memoryview) -> None: ...
def tobytes(self) -> bytes: ...
def tolist(self) -> List[int]: ...
if sys.version_info >= (3, 5):
def hex(self) -> str: ...
class bool(int, SupportsInt, SupportsFloat):
def __init__(self, o: object = ...) -> None: ...
class slice:
start = 0
step = 0
stop = 0
def __init__(self, start: int, stop: int = 0, step: int = 0) -> None: ...
class tuple(Sequence[_T_co], Generic[_T_co]):
def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, x: object) -> bool: ...
@overload
def __getitem__(self, x: int) -> _T_co: ...
@overload
def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
def count(self, x: Any) -> int: ...
if sys.version_info >= (3, 5):
def index(self, x: Any, start: int = 0, end: int = 0) -> int: ...
else:
def index(self, x: Any) -> int: ...
class function:
# TODO not defined in builtins!
__name__ = ... # type: str
__qualname__ = ... # type: str
__module__ = ... # type: str
__code__ = ... # type: Any
class list(MutableSequence[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def clear(self) -> None: ...
def copy(self) -> List[_T]: ...
def append(self, object: _T) -> None: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def pop(self, index: int = -1) -> _T: ...
def index(self, object: _T, start: int = 0, stop: int = ...) -> int: ...
def count(self, object: _T) -> int: ...
def insert(self, index: int, object: _T) -> None: ...
def remove(self, object: _T) -> None: ...
def reverse(self) -> None: ...
def sort(self, *, key: Callable[[_T], Any] = None, reverse: bool = ...) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> List[_T]: ...
@overload
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __add__(self, x: List[_T]) -> List[_T]: ...
def __iadd__(self, x: Iterable[_T]) -> List[_T]: ...
def __mul__(self, n: int) -> List[_T]: ...
def __rmul__(self, n: int) -> List[_T]: ...
def __imul__(self, n: int) -> List[_T]: ...
def __contains__(self, o: object) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
def __gt__(self, x: List[_T]) -> bool: ...
def __ge__(self, x: List[_T]) -> bool: ...
def __lt__(self, x: List[_T]) -> bool: ...
def __le__(self, x: List[_T]) -> bool: ...
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
# NOTE: Keyword arguments are special. If they are used, _KT must include
# str, but we have no way of enforcing it here.
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
def get(self, k: _KT, default: _VT = None) -> _VT: ...
def pop(self, k: _KT, default: _VT = None) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = None) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT]) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]]) -> None: ...
def keys(self) -> KeysView[_KT]: ...
def values(self) -> ValuesView[_VT]: ...
def items(self) -> ItemsView[_KT, _VT]: ...
@staticmethod
@overload
def fromkeys(seq: Sequence[_T]) -> Dict[_T, Any]: ... # TODO: Actually a class method (mypy/issues#328)
@staticmethod
@overload
def fromkeys(seq: Sequence[_T], value: _S) -> Dict[_T, _S]: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
class set(MutableSet[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
def add(self, element: _T) -> None: ...
def clear(self) -> None: ...
def copy(self) -> set[_T]: ...
def difference(self, *s: Iterable[Any]) -> set[_T]: ...
def difference_update(self, *s: Iterable[Any]) -> None: ...
def discard(self, element: _T) -> None: ...
def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
def intersection_update(self, *s: Iterable[Any]) -> None: ...
def isdisjoint(self, s: Iterable[Any]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def symmetric_difference(self, s: Iterable[_T]) -> set[_T]: ...
def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
def union(self, *s: Iterable[_T]) -> set[_T]: ...
def update(self, *s: Iterable[_T]) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __iand__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ior__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __isub__(self, s: AbstractSet[Any]) -> set[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __ixor__(self, s: AbstractSet[_S]) -> set[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
# TODO more set operations
class frozenset(FrozenSet[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
def copy(self) -> frozenset[_T]: ...
def difference(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def intersection(self, *s: Iterable[Any]) -> frozenset[_T]: ...
def isdisjoint(self, s: Iterable[_T]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def symmetric_difference(self, s: Iterable[_T]) -> frozenset[_T]: ...
def union(self, *s: Iterable[_T]) -> frozenset[_T]: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[_T]) -> frozenset[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> frozenset[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
def __init__(self, iterable: Iterable[_T], start: int = 0) -> None: ...
def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
def __next__(self) -> Tuple[int, _T]: ...
class range(Sequence[int]):
@overload
def __init__(self, stop: int) -> None: ...
@overload
def __init__(self, start: int, stop: int, step: int = 1) -> None: ...
def count(self, value: int) -> int: ...
def index(self, value: int, start: int = 0, stop: int = None) -> int: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[int]: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> range: ...
def __repr__(self) -> str: ...
def __reversed__(self) -> Iterator[int]: ...
class module:
# TODO not defined in builtins!
__name__ = ... # type: str
__file__ = ... # type: str
__dict__ = ... # type: Dict[str, Any]
class property:
def __init__(self, fget: Callable[[Any], Any] = None,
fset: Callable[[Any, Any], None] = None,
fdel: Callable[[Any], None] = None, doc: str = None) -> None: ...
def getter(self, fget: Callable[[Any], Any]) -> property: ...
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
def __get__(self, obj: Any, type: type=None) -> Any: ...
def __set__(self, obj: Any, value: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
NotImplemented = ... # type: Any
def abs(n: SupportsAbs[_T]) -> _T: ...
def all(i: Iterable) -> bool: ...
def any(i: Iterable) -> bool: ...
def ascii(o: object) -> str: ...
def bin(number: int) -> str: ...
def callable(o: object) -> bool: ...
def chr(code: int) -> str: ...
def compile(source: Any, filename: Union[str, bytes], mode: str, flags: int = 0,
dont_inherit: int = 0) -> Any: ...
def copyright() -> None: ...
def credits() -> None: ...
def delattr(o: Any, name: str) -> None: ...
def dir(o: object = ...) -> List[str]: ...
_N = TypeVar('_N', int, float)
def divmod(a: _N, b: _N) -> Tuple[_N, _N]: ...
def eval(source: str, globals: Dict[str, Any] = None,
locals: Mapping[str, Any] = None) -> Any: ... # TODO code object as source
def exec(object: str, globals: Dict[str, Any] = None,
locals: Mapping[str, Any] = None) -> Any: ... # TODO code object as source
def exit(code: int = None) -> NoReturn: ...
@overload
def filter(function: Callable[[_T], Any], iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def filter(function: None, iterable: Iterable[Optional[_T]]) -> Iterator[_T]: ...
def format(o: object, format_spec: str = '') -> str: ...
def getattr(o: Any, name: str, default: Any = ...) -> Any: ...
def globals() -> Dict[str, Any]: ...
def hasattr(o: Any, name: str) -> bool: ...
def hash(o: object) -> int: ...
def help(*args: Any, **kwds: Any) -> None: ...
def hex(i: int) -> str: ... # TODO __index__
def id(o: object) -> int: ...
def input(prompt: str = None) -> str: ...
@overload
def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def iter(function: Callable[[], _T], sentinel: _T) -> Iterator[_T]: ...
def isinstance(o: object, t: Union[type, Tuple[type, ...]]) -> bool: ...
def issubclass(cls: type, classinfo: Union[type, Tuple[type, ...]]) -> bool: ...
def len(o: Sized) -> int: ...
def license() -> None: ...
def locals() -> Dict[str, Any]: ...
@overload
def map(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> Iterator[_S]: ...
@overload
def map(func: Callable[[_T1, _T2], _S], iter1: Iterable[_T1],
iter2: Iterable[_T2]) -> Iterator[_S]: ... # TODO more than two iterables
@overload
def max(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def max(iterable: Iterable[_T], key: Callable[[_T], Any] = ..., default: _T = ...) -> _T: ...
@overload
def min(arg1: _T, arg2: _T, *args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
@overload
def min(iterable: Iterable[_T], key: Callable[[_T], Any] = ..., default: _T = ...) -> _T: ...
@overload
def next(i: Iterator[_T]) -> _T: ...
@overload
def next(i: Iterator[_T], default: _T) -> _T: ...
def oct(i: int) -> str: ... # TODO __index__
if sys.version_info >= (3, 6):
from pathlib import Path
def open(file: Union[str, bytes, int, Path], mode: str = 'r', buffering: int = -1, encoding: str = None,
errors: str = None, newline: str = None, closefd: bool = ...) -> IO[Any]: ...
else:
def open(file: Union[str, bytes, int], mode: str = 'r', buffering: int = -1, encoding: str = None,
errors: str = None, newline: str = None, closefd: bool = ...) -> IO[Any]: ...
def ord(c: Union[str, bytes, bytearray]) -> int: ...
# TODO: in Python 3.2, print() does not support flush
def print(*values: Any, sep: str = ' ', end: str = '\n', file: IO[str] = None, flush: bool = False) -> None: ...
@overload
def pow(x: int, y: int) -> Any: ... # The return type can be int or float, depending on y
@overload
def pow(x: int, y: int, z: int) -> Any: ...
@overload
def pow(x: float, y: float) -> float: ...
@overload
def pow(x: float, y: float, z: float) -> float: ...
def quit(code: int = None) -> None: ...
@overload
def reversed(object: Reversible[_T]) -> Iterator[_T]: ...
@overload
def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
def repr(o: object) -> str: ...
@overload
def round(number: float) -> int: ...
@overload
def round(number: float, ndigits: int) -> float: ... # Always return a float if given ndigits.
@overload
def round(number: SupportsRound[_T]) -> _T: ...
@overload
def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
def setattr(object: Any, name: str, value: Any) -> None: ...
def sorted(iterable: Iterable[_T], *, key: Callable[[_T], Any] = None,
reverse: bool = False) -> List[_T]: ...
def sum(iterable: Iterable[_T], start: _T = ...) -> _T: ...
def vars(object: Any = ...) -> Dict[str, Any]: ...
@overload
def zip(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2],
iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
@overload
def zip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3],
iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2,
_T3, _T4]]: ... # TODO more than four iterables
def __import__(name: str, globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...,
fromlist: List[str] = ..., level: int = -1) -> Any: ...
# Ellipsis
# Actually the type of Ellipsis is , but since it's
# not exposed anywhere under that name, we make it private here.
class ellipsis: ...
Ellipsis = ... # type: ellipsis
# Exceptions
class BaseException:
args = ... # type: Tuple[Any, ...]
__cause__ = ... # type: BaseException
__context__ = ... # type: BaseException
__traceback__ = ... # type: TracebackType
def __init__(self, *args: Any) -> None: ...
def with_traceback(self, tb: Any) -> BaseException: ...
class GeneratorExit(BaseException): ...
class KeyboardInterrupt(BaseException): ...
class SystemExit(BaseException):
code = 0
class Exception(BaseException): ...
class ArithmeticError(Exception): ...
class EnvironmentError(Exception):
errno = 0
strerror = ... # type: str
# TODO can this be bytes?
filename = ... # type: str
class LookupError(Exception): ...
class RuntimeError(Exception): ...
class ValueError(Exception): ...
class AssertionError(Exception): ...
class AttributeError(Exception): ...
class BufferError(Exception): ...
class EOFError(Exception): ...
class FloatingPointError(ArithmeticError): ...
class IOError(EnvironmentError): ...
class ImportError(Exception): ...
class IndexError(LookupError): ...
class KeyError(LookupError): ...
class MemoryError(Exception): ...
class NameError(Exception): ...
class NotImplementedError(RuntimeError): ...
class OSError(EnvironmentError): ...
class BlockingIOError(OSError):
characters_written = 0
class ChildProcessError(OSError): ...
class ConnectionError(OSError): ...
class BrokenPipeError(ConnectionError): ...
class ConnectionAbortedError(ConnectionError): ...
class ConnectionRefusedError(ConnectionError): ...
class ConnectionResetError(ConnectionError): ...
class FileExistsError(OSError): ...
class FileNotFoundError(OSError): ...
class InterruptedError(OSError): ...
class IsADirectoryError(OSError): ...
class NotADirectoryError(OSError): ...
class PermissionError(OSError): ...
class ProcessLookupError(OSError): ...
class TimeoutError(OSError): ...
class WindowsError(OSError):
winerror = ... # type: int
class OverflowError(ArithmeticError): ...
class ReferenceError(Exception): ...
class StopIteration(Exception):
value = ... # type: Any
if sys.version_info >= (3, 5):
class StopAsyncIteration(Exception):
value = ... # type: Any
class RecursionError(RuntimeError): ...
class SyntaxError(Exception):
msg = ... # type: str
lineno = ... # type: int
offset = ... # type: int
text = ... # type: str
class IndentationError(SyntaxError): ...
class TabError(IndentationError): ...
class SystemError(Exception): ...
class TypeError(Exception): ...
class UnboundLocalError(NameError): ...
class UnicodeError(ValueError): ...
class UnicodeDecodeError(UnicodeError):
encoding = ... # type: str
object = ... # type: bytes
start = ... # type: int
end = ... # type: int
reason = ... # type: str
def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int,
__reason: str) -> None: ...
class UnicodeEncodeError(UnicodeError):
encoding = ... # type: str
object = ... # type: str
start = ... # type: int
end = ... # type: int
reason = ... # type: str
def __init__(self, __encoding: str, __object: str, __start: int, __end: int,
__reason: str) -> None: ...
class UnicodeTranslateError(UnicodeError): ...
class ZeroDivisionError(ArithmeticError): ...
class Warning(Exception): ...
class UserWarning(Warning): ...
class DeprecationWarning(Warning): ...
class SyntaxWarning(Warning): ...
class RuntimeWarning(Warning): ...
class FutureWarning(Warning): ...
class PendingDeprecationWarning(Warning): ...
class ImportWarning(Warning): ...
class UnicodeWarning(Warning): ...
class BytesWarning(Warning): ...
class ResourceWarning(Warning): ...
mypy-0.470/typeshed/stdlib/3/types.pyi 0000644 0000000 0000000 00000012371 13044257024 016364 0 ustar root root # Stubs for types
# Note, all classes "defined" here require special handling.
# TODO parts of this should be conditional on version
import sys
from typing import (
Any, Callable, Dict, Generic, Iterator, Mapping, Optional, Tuple, TypeVar,
Union, overload
)
# ModuleType is exported from this module, but for circular import
# reasons exists in its own stub file (with ModuleSpec and Loader).
from _importlib_modulespec import ModuleType as ModuleType # Exported
_T = TypeVar('_T')
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
class _Cell:
cell_contents = ... # type: Any
class FunctionType:
__closure__ = ... # type: Optional[Tuple[_Cell, ...]]
__code__ = ... # type: CodeType
__defaults__ = ... # type: Optional[Tuple[Any, ...]]
__dict__ = ... # type: Dict[str, Any]
__globals__ = ... # type: Dict[str, Any]
__name__ = ... # type: str
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Optional[object], type: Optional[type]) -> 'MethodType': ...
LambdaType = FunctionType
class CodeType:
"""Create a code object. Not for the faint of heart."""
co_argcount = ... # type: int
co_kwonlyargcount = ... # type: int
co_nlocals = ... # type: int
co_stacksize = ... # type: int
co_flags = ... # type: int
co_code = ... # type: bytes
co_consts = ... # type: Tuple[Any, ...]
co_names = ... # type: Tuple[str, ...]
co_varnames = ... # type: Tuple[str, ...]
co_filename = ... # type: Optional[str]
co_name = ... # type: str
co_firstlineno = ... # type: int
co_lnotab = ... # type: bytes
co_freevars = ... # type: Tuple[str, ...]
co_cellvars = ... # type: Tuple[str, ...]
def __init__(
self,
argcount: int,
kwonlyargcount: int,
nlocals: int,
stacksize: int,
flags: int,
codestring: bytes,
constants: Tuple[Any, ...],
names: Tuple[str, ...],
varnames: Tuple[str, ...],
filename: str,
name: str,
firstlineno: int,
lnotab: bytes,
freevars: Tuple[str, ...] = ...,
cellvars: Tuple[str, ...] = ...,
) -> None: ...
class MappingProxyType(Mapping[_KT, _VT], Generic[_KT, _VT]):
def __init__(self, mapping: Mapping[_KT, _VT]) -> None: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __iter__(self) -> Iterator[_KT]: ...
def __len__(self) -> int: ...
# TODO: use __getattr__ and __setattr__ instead of inheriting from Any, pending mypy#521.
class SimpleNamespace(Any): ... # type: ignore
class GeneratorType:
gi_code = ... # type: CodeType
gi_frame = ... # type: FrameType
gi_running = ... # type: bool
gi_yieldfrom = ... # type: Optional[GeneratorType]
def __iter__(self) -> 'GeneratorType': ...
def __next__(self) -> Any: ...
def close(self) -> None: ...
def send(self, arg: Any) -> Any: ...
@overload
def throw(self, val: BaseException) -> Any: ...
@overload
def throw(self, typ: type, val: BaseException = ..., tb: 'TracebackType' = ...) -> Any: ...
class CoroutineType:
cr_await = ... # type: Optional[Any]
cr_code = ... # type: CodeType
cr_frame = ... # type: FrameType
cr_running = ... # type: bool
def close(self) -> None: ...
def send(self, arg: Any) -> Any: ...
@overload
def throw(self, val: BaseException) -> Any: ...
@overload
def throw(self, typ: type, val: BaseException = ..., tb: 'TracebackType' = ...) -> Any: ...
class MethodType:
__func__ = ... # type: FunctionType
__self__ = ... # type: object
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
class BuiltinFunctionType:
__self__ = ... # type: Union[object, ModuleType]
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
BuiltinMethodType = BuiltinFunctionType
class TracebackType:
tb_frame = ... # type: FrameType
tb_lasti = ... # type: int
tb_lineno = ... # type: int
tb_next = ... # type: TracebackType
class FrameType:
f_back = ... # type: FrameType
f_builtins = ... # type: Dict[str, Any]
f_code = ... # type: CodeType
f_globals = ... # type: Dict[str, Any]
f_lasti = ... # type: int
f_lineno = ... # type: int
f_locals = ... # type: Dict[str, Any]
f_trace = ... # type: Callable[[], None]
def clear(self) -> None: pass
class GetSetDescriptorType:
__name__ = ... # type: str
__objclass__ = ... # type: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
class MemberDescriptorType:
__name__ = ... # type: str
__objclass__ = ... # type: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
def new_class(name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ..., exec_body: Callable[[Dict[str, Any]], None] = ...) -> type: ...
def prepare_class(name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ...) -> Tuple[type, Dict[str, Any], Dict[str, Any]]: ...
# Actually a different type, but `property` is special and we want that too.
DynamicClassAttribute = property
def coroutine(f: Callable[..., Any]) -> CoroutineType: ...
mypy-0.470/typeshed/stdlib/3/inspect.pyi 0000644 0000000 0000000 00000024252 13023631176 016667 0 ustar root root # Stubs for inspect
from typing import (AbstractSet, Any, Tuple, List, Dict, Callable, Generator,
Mapping, MutableMapping, NamedTuple, Optional, Sequence, Union,
)
from types import FrameType, ModuleType, TracebackType
#
# Types and members
#
ModuleInfo = NamedTuple('ModuleInfo', [('name', str),
('suffix', str),
('mode', str),
('module_type', int),
])
def getmembers(object: object,
predicate: Callable[[Any], bool] = ...,
) -> List[Tuple[str, Any]]: ...
def getmoduleinfo(path: str) -> Optional[ModuleInfo]: ...
def getmodulename(path: str) -> Optional[str]: ...
def ismodule(object: object) -> bool: ...
def isclass(object: object) -> bool: ...
def ismethod(object: object) -> bool: ...
def isfunction(object: object) -> bool: ...
def isgeneratorfunction(object: object) -> bool: ...
def isgenerator(object: object) -> bool: ...
# Python 3.5+
def iscoroutinefunction(object: object) -> bool: ...
def iscoroutine(object: object) -> bool: ...
def isawaitable(object: object) -> bool: ...
def istraceback(object: object) -> bool: ...
def isframe(object: object) -> bool: ...
def iscode(object: object) -> bool: ...
def isbuiltin(object: object) -> bool: ...
def isroutine(object: object) -> bool: ...
def isabstract(object: object) -> bool: ...
def ismethoddescriptor(object: object) -> bool: ...
def isdatadescriptor(object: object) -> bool: ...
def isgetsetdescriptor(object: object) -> bool: ...
def ismemberdescriptor(object: object) -> bool: ...
#
# Retrieving source code
#
def getdoc(object: object) -> str: ...
def getcomments(object: object) -> str: ...
def getfile(object: object) -> str: ...
def getmodule(object: object) -> ModuleType: ...
def getsourcefile(object: object) -> str: ...
# TODO restrict to "module, class, method, function, traceback, frame,
# or code object"
def getsourcelines(object: object) -> Tuple[List[str], int]: ...
# TODO restrict to "a module, class, method, function, traceback, frame,
# or code object"
def getsource(object: object) -> str: ...
def cleandoc(doc: str) -> str: ...
#
# Introspecting callables with the Signature object (Python 3.3+)
#
def signature(callable: Callable[..., Any],
*,
follow_wrapped: bool = True) -> 'Signature': ...
class Signature:
def __init__(self,
parameters: Optional[Sequence['Parameter']] = ...,
*,
return_annotation: Any = ...) -> None: ...
# TODO: can we be more specific here?
empty = ... # type: object
parameters = ... # type: Mapping[str, 'Parameter']
# TODO: can we be more specific here?
return_annotation = ... # type: Any
def bind(self, *args: Any, **kwargs: Any) -> 'BoundArguments': ...
def bind_partial(self, *args: Any, **kwargs: Any) -> 'BoundArguments': ...
def replace(self,
*,
parameters: Optional[Sequence['Parameter']] = ...,
return_annotation: Any = ...) -> 'Signature': ...
# Python 3.5+
@classmethod
def from_callable(cls,
obj: Callable[..., Any],
*,
follow_wrapped: bool = True) -> 'Signature': ...
# The name is the same as the enum's name in CPython
class _ParameterKind: pass
class Parameter:
def __init__(self,
name: str,
kind: _ParameterKind,
*,
default: Any = ...,
annotation: Any = ...) -> None: ...
empty = ... # type: Any
name = ... # type: str
default = ... # type: Any
annotation = ... # type: Any
kind = ... # type: _ParameterKind
POSITIONAL_ONLY = ... # type: _ParameterKind
POSITIONAL_OR_KEYWORD = ... # type: _ParameterKind
VAR_POSITIONAL = ... # type: _ParameterKind
KEYWORD_ONLY = ... # type: _ParameterKind
VAR_KEYWORD = ... # type: _ParameterKind
def replace(self,
*,
name: Optional[str] = ...,
kind: Optional[_ParameterKind] = ...,
default: Any = ...,
annotation: Any = ...) -> 'Parameter': ...
class BoundArguments:
arguments = ... # type: MutableMapping[str, Any]
args = ... # Tuple[Any, ...]
kwargs = ... # Dict[str, Any]
signature = ... # type: Signature
# Python 3.5+
def apply_defaults(self) -> None: ...
#
# Classes and functions
#
# TODO: The actual return type should be List[_ClassTreeItem] but mypy doesn't
# seem to be supporting this at the moment:
# _ClassTreeItem = Union[List['_ClassTreeItem'], Tuple[type, Tuple[type, ...]]]
def getclasstree(classes: List[type], unique: bool = ...) -> Any: ...
ArgSpec = NamedTuple('ArgSpec', [('args', List[str]),
('varargs', str),
('keywords', str),
('defaults', tuple),
])
def getargspec(func: object) -> ArgSpec: ...
FullArgSpec = NamedTuple('FullArgSpec', [('args', List[str]),
('varargs', str),
('varkw', str),
('defaults', tuple),
('kwonlyargs', List[str]),
('kwonlydefaults', Dict[str, Any]),
('annotations', Dict[str, Any]),
])
def getfullargspec(func: object) -> FullArgSpec: ...
# TODO make the field types more specific here
ArgInfo = NamedTuple('ArgInfo', [('args', List[str]),
('varargs', Optional[str]),
('keywords', Optional[str]),
('locals', Dict[str, Any]),
])
def getargvalues(frame: FrameType) -> ArgInfo: ...
def formatargspec(args: List[str],
varargs: Optional[str] = ...,
varkw: Optional[str] = ...,
defaults: Optional[Tuple[Any]] = ...,
kwonlyargs: Optional[List[str]] = ...,
kwonlydefaults: Optional[Dict[str, Any]] = ...,
annotations: Optional[Dict[str, Any]] = ...,
formatarg: Optional[Callable[[str], str]] = ...,
formatvarargs: Optional[Callable[[str], str]] = ...,
formatvarkw: Optional[Callable[[str], str]] = ...,
formatvalue: Optional[Callable[[Any], str]] = ...,
formatreturns: Optional[Callable[[Any], str]] = ...,
formatannotations: Optional[Callable[[Any], str]] = ...,
) -> str: ...
def formatargvalues(args: List[str],
varargs: Optional[str] = ...,
varkw: Optional[str] = ...,
locals: Optional[Dict[str, Any]] = ...,
formatarg: Optional[Callable[[str], str]] = ...,
formatvarargs: Optional[Callable[[str], str]] = ...,
formatvarkw: Optional[Callable[[str], str]] = ...,
formatvalue: Optional[Callable[[Any], str]] = ...,
) -> str: ...
def getmro(cls: type) -> Tuple[type, ...]: ...
# Python 3.2+
def getcallargs(func: Callable[..., Any],
*args: Any,
**kwds: Any) -> Dict[str, Any]: ...
# Python 3.3+
ClosureVars = NamedTuple('ClosureVars', [('nonlocals', Mapping[str, Any]),
('globals', Mapping[str, Any]),
('builtins', Mapping[str, Any]),
('unbound', AbstractSet[str]),
])
def getclosurevars(func: Callable[..., Any]) -> ClosureVars: ...
# Python 3.4+
def unwrap(func: Callable[..., Any],
*,
stop: Callable[[Any], Any]) -> Any: ...
#
# The interpreter stack
#
# Python 3.5+ (functions returning it used to return regular tuples)
FrameInfo = NamedTuple('FrameInfo', [('frame', FrameType),
('filename', str),
('lineno', int),
('function', str),
('code_context', List[str]),
('index', int),
])
# TODO make the frame type more specific
def getframeinfo(frame: Any, context: int = 1) -> FrameInfo: ...
def getouterframes(frame: Any, context: int = 1) -> List[FrameInfo]: ...
def getinnerframes(traceback: TracebackType, context: int = 1) -> List[FrameInfo]:
...
def currentframe() -> Optional[FrameType]: ...
def stack(context: int = 1) -> List[FrameInfo]: ...
def trace(context: int = 1) -> List[FrameInfo]: ...
#
# Fetching attributes statically
#
# Python 3.2+
def getattr_static(obj: object, attr: str, default: Optional[Any] = ...) -> Any: ...
#
# Current State of Generators and Coroutines
#
# TODO In the next two blocks of code, can we be more specific regarding the
# type of the "enums"?
# Python 3.2+
GEN_CREATED = ... # type: str
GEN_RUNNING = ... # type: str
GEN_SUSPENDED = ... # type: str
GEN_CLOSED = ... # type: str
def getgeneratorstate(generator: Generator[Any, Any, Any]) -> str: ...
# Python 3.5+
CORO_CREATED = ... # type: str
CORO_RUNNING = ... # type: str
CORO_SUSPENDED = ... # type: str
CORO_CLOSED = ... # type: str
# TODO can we be more specific than "object"?
def getcoroutinestate(coroutine: object) -> str: ...
# Python 3.3+
def getgeneratorlocals(generator: Generator[Any, Any, Any]) -> Dict[str, Any]: ...
# Python 3.5+
# TODO can we be more specific than "object"?
def getcoroutinelocals(coroutine: object) -> Dict[str, Any]: ...
#
# The following seems undocumented but it was already present in this file
#
_object = object
# namedtuple('Attribute', 'name kind defining_class object')
class Attribute(tuple):
name = ... # type: str
kind = ... # type: str
defining_class = ... # type: type
object = ... # type: _object
def classify_class_attrs(cls: type) -> List[Attribute]: ...
mypy-0.470/typeshed/stdlib/3/_warnings.pyi 0000644 0000000 0000000 00000000663 13035744274 017220 0 ustar root root from typing import Any, List
_defaultaction = ... # type: str
_onceregistry = ... # type: dict
filters = ... # type: List[tuple]
def warn(message: Warning, category: type = ..., stacklevel: int = ...) -> None: ...
def warn_explicit(message: Warning, category: type,
filename: str, lineno: int,
module: Any = ..., registry: dict = ...,
module_globals: dict = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/http/ 0000755 0000000 0000000 00000000000 13044320557 015452 5 ustar root root mypy-0.470/typeshed/stdlib/3/http/__init__.pyi 0000644 0000000 0000000 00000005510 13023631176 017734 0 ustar root root import sys
from enum import IntEnum
if sys.version_info >= (3, 5):
class HTTPStatus(IntEnum):
def __init__(self, *a) -> None:
self.phrase = ... # type: str
self.description = ... # type: str
CONTINUE = ... # type: object
SWITCHING_PROTOCOLS = ... # type: object
PROCESSING = ... # type: object
OK = ... # type: object
CREATED = ... # type: object
ACCEPTED = ... # type: object
NON_AUTHORITATIVE_INFORMATION = ... # type: object
NO_CONTENT = ... # type: object
RESET_CONTENT = ... # type: object
PARTIAL_CONTENT = ... # type: object
MULTI_STATUS = ... # type: object
ALREADY_REPORTED = ... # type: object
IM_USED = ... # type: object
MULTIPLE_CHOICES = ... # type: object
MOVED_PERMANENTLY = ... # type: object
FOUND = ... # type: object
SEE_OTHER = ... # type: object
NOT_MODIFIED = ... # type: object
USE_PROXY = ... # type: object
TEMPORARY_REDIRECT = ... # type: object
PERMANENT_REDIRECT = ... # type: object
BAD_REQUEST = ... # type: object
UNAUTHORIZED = ... # type: object
PAYMENT_REQUIRED = ... # type: object
FORBIDDEN = ... # type: object
NOT_FOUND = ... # type: object
METHOD_NOT_ALLOWED = ... # type: object
NOT_ACCEPTABLE = ... # type: object
PROXY_AUTHENTICATION_REQUIRED = ... # type: object
REQUEST_TIMEOUT = ... # type: object
CONFLICT = ... # type: object
GONE = ... # type: object
LENGTH_REQUIRED = ... # type: object
PRECONDITION_FAILED = ... # type: object
REQUEST_ENTITY_TOO_LARGE = ... # type: object
REQUEST_URI_TOO_LONG = ... # type: object
UNSUPPORTED_MEDIA_TYPE = ... # type: object
REQUESTED_RANGE_NOT_SATISFIABLE = ... # type: object
EXPECTATION_FAILED = ... # type: object
UNPROCESSABLE_ENTITY = ... # type: object
LOCKED = ... # type: object
FAILED_DEPENDENCY = ... # type: object
UPGRADE_REQUIRED = ... # type: object
PRECONDITION_REQUIRED = ... # type: object
TOO_MANY_REQUESTS = ... # type: object
REQUEST_HEADER_FIELDS_TOO_LARGE = ... # type: object
INTERNAL_SERVER_ERROR = ... # type: object
NOT_IMPLEMENTED = ... # type: object
BAD_GATEWAY = ... # type: object
SERVICE_UNAVAILABLE = ... # type: object
GATEWAY_TIMEOUT = ... # type: object
HTTP_VERSION_NOT_SUPPORTED = ... # type: object
VARIANT_ALSO_NEGOTIATES = ... # type: object
INSUFFICIENT_STORAGE = ... # type: object
LOOP_DETECTED = ... # type: object
NOT_EXTENDED = ... # type: object
NETWORK_AUTHENTICATION_REQUIRED = ... # type: object
mypy-0.470/typeshed/stdlib/3/http/server.pyi 0000644 0000000 0000000 00000005270 13023631176 017506 0 ustar root root # Stubs for http.server (Python 3.4)
from typing import Any, BinaryIO, Dict, List, Mapping, Optional, Tuple, Union
import socketserver
import email.message
class HTTPServer(socketserver.TCPServer):
server_name = ... # type: str
server_port = ... # type: int
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type) -> None: ...
class BaseHTTPRequestHandler:
client_address = ... # type: Tuple[str, int]
server = ... # type: socketserver.BaseServer
close_connection = ... # type: bool
requestline = ... # type: str
command = ... # type: str
path = ... # type: str
request_version = ... # type: str
headers = ... # type: email.message.Message
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
server_version = ... # type: str
sys_version = ... # type: str
error_message_format = ... # type: str
error_content_type = ... # type: str
protocol_version = ... # type: str
MessageClass = ... # type: type
responses = ... # type: Mapping[int, Tuple[str, str]]
def __init__(self, request: bytes, client_address: Tuple[str, int],
server: socketserver.BaseServer) -> None: ...
def handle(self) -> None: ...
def handle_one_request(self) -> None: ...
def handle_expect_100(self) -> bool: ...
def send_error(self, code: int, message: Optional[str] = ...,
explain: Optional[str] = ...) -> None: ...
def send_response(self, code: int,
message: Optional[str] = ...) -> None: ...
def send_header(self, keyword: str, value: str) -> None: ...
def send_response_only(self, code: int,
message: Optional[str] = ...) -> None: ...
def end_headers(self) -> None: ...
def flush_headers(self) -> None: ...
def log_request(self, code: Union[int, str] = ...,
size: Union[int, str] = ...) -> None: ...
def log_error(self, format: str, *args: Any) -> None: ...
def log_message(self, format: str, *args: Any) -> None: ...
def version_string(self) -> str: ...
def date_time_string(self, timestamp: Optional[int] = ...) -> str: ...
def log_date_time_string(self) -> str: ...
def address_string(self) -> str: ...
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
extensions_map = ... # type: Dict[str, str]
def __init__(self, request: bytes, client_address: Tuple[str, int],
server: socketserver.BaseServer) -> None: ...
def do_GET(self) -> None: ...
def do_HEAD(self) -> None: ...
class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
cgi_directories = ... # type: List[str]
def do_POST(self) -> None: ...
mypy-0.470/typeshed/stdlib/3/http/cookies.pyi 0000644 0000000 0000000 00000002443 13035744274 017642 0 ustar root root # Stubs for http.cookies (Python 3.5)
from typing import Generic, Dict, List, Mapping, MutableMapping, Optional, TypeVar, Union
_DataType = Union[str, Mapping[str, Union[str, 'Morsel']]]
_T = TypeVar('_T')
class CookieError(Exception): ...
class Morsel(Dict[str, str], Generic[_T]):
value = ... # type: str
coded_value = ... # type: _T
key = ... # type: str
def set(self, key: str, val: str, coded_val: _T) -> None: ...
def isReservedKey(self, K: str) -> bool: ...
def output(self, attrs: Optional[List[str]] = ...,
header: str = ...) -> str: ...
def js_output(self, attrs: Optional[List[str]] = ...) -> str: ...
def OutputString(self, attrs: Optional[List[str]] = ...) -> str: ...
class BaseCookie(MutableMapping[str, Morsel], Generic[_T]):
def __init__(self, input: Optional[_DataType] = ...) -> None: ...
def value_decode(self, val: str) -> _T: ...
def value_encode(self, val: _T) -> str: ...
def output(self, attrs: Optional[List[str]] = ..., header: str = ...,
sep: str = ...) -> str: ...
def js_output(self, attrs: Optional[List[str]] = ...) -> str: ...
def load(self, rawdata: _DataType) -> None: ...
def __setitem__(self, key: str, value: Union[str, Morsel]) -> None: ...
class SimpleCookie(BaseCookie): ...
mypy-0.470/typeshed/stdlib/3/http/cookiejar.pyi 0000644 0000000 0000000 00000011306 13023631176 020143 0 ustar root root # Stubs for http.cookiejar (Python 3.4)
from typing import Iterable, Iterator, Optional, Sequence, Tuple, TypeVar, Union, overload
from http.client import HTTPResponse
import sys
from urllib.request import Request
_T = TypeVar('_T')
if sys.version_info >= (3, 3):
class LoadError(OSError): ...
else:
class LoadError(IOError): ...
class CookieJar(Iterable['Cookie']):
def __init__(self, policy: Optional['CookiePolicy'] = ...) -> None: ...
def add_cookie_header(self, request: Request) -> None: ...
def extract_cookies(self, response: HTTPResponse,
request: Request) -> None: ...
def set_policy(self, policy: 'CookiePolicy') -> None: ...
def make_cookies(self, response: HTTPResponse,
request: Request) -> Sequence['Cookie']: ...
def set_cookie(self, cookie: 'Cookie') -> None: ...
def set_cookie_if_ok(self, cookie: 'Cookie',
request: Request) -> None: ...
def clear(self, domain: str = ..., path: str = ...,
name: str = ...) -> None: ...
def clear_session_cookies(self) -> None: ...
def __iter__(self) -> Iterator['Cookie']: ...
class FileCookieJar(CookieJar):
filename = ... # type: str
delayload = ... # type: bool
def __init__(self, filename: str = ..., delayload: bool = ...,
policy: Optional['CookiePolicy'] = ...) -> None: ...
def save(self, filename: Optional[str] = ..., ignore_discard: bool = ...,
ignore_expires: bool = ...) -> None: ...
def load(self, filename: Optional[str] = ..., ignore_discard: bool = ...,
ignore_expires: bool = ...) -> None: ...
def revert(self, filename: Optional[str] = ..., ignore_discard: bool = ...,
ignore_expires: bool = ...) -> None: ...
class MozillaCookieJar(FileCookieJar): ...
class LWPCookieJar(FileCookieJar): ...
class CookiePolicy:
netscape = ... # type: bool
rfc2965 = ... # type: bool
hide_cookie2 = ... # type: bool
def set_ok(self, cookie: 'Cookie', request: Request) -> bool: ...
def return_ok(self, cookie: 'Cookie', request: Request) -> bool: ...
def domain_return_ok(self, domain: str, request: Request) -> bool: ...
def path_return_ok(self, path: str, request: Request) -> bool: ...
class DefaultCookiePolicy(CookiePolicy):
rfc2109_as_netscape = ... # type: bool
strict_domain = ... # type: bool
strict_rfc2965_unverifiable = ... # type: bool
strict_ns_unverifiable = ... # type: bool
strict_ns_domain = ... # type: int
strict_ns_set_initial_dollar = ... # type: bool
strict_ns_set_path = ... # type: bool
DomainStrictNoDots = ... # type: int
DomainStrictNonDomain = ... # type: int
DomainRFC2965Match = ... # type: int
DomainLiberal = ... # type: int
DomainStrict = ... # type: int
def __init__(self, blocked_domains: Optional[Sequence[str]] = ...,
allowed_domains: Optional[Sequence[str]] = ...,
netscape: bool = ...,
rfc2965: bool = ...,
rfc2109_as_netscape: Optional[bool] = ...,
hide_cookie2: bool = ..., strict_domain: bool = ...,
strict_rfc2965_unverifiable: bool =...,
strict_ns_unverifiable: bool = ...,
strict_ns_domain: int = ...,
strict_ns_set_initial_dollar: bool = ...,
strict_ns_set_path: bool = ...) -> None: ...
def blocked_domains(self) -> Tuple[str, ...]: ...
def set_blocked_domains(self, blocked_domains: Sequence[str]) -> None: ...
def is_blocked(self, domain: str) -> bool: ...
def allowed_domains(self) -> Optional[Tuple[str, ...]]: ...
def set_allowed_domains(self, allowed_domains: Optional[Sequence[str]]) \
-> None: ...
def is_not_allowed(self, domain: str) -> bool: ...
class Cookie:
version = ... # type: Optional[int]
name = ... # type: str
value = ... # type: Optional[str]
port = ... # type: Optional[str]
path = ... # type: str
secure = ... # type: bool
expires = ... # type: Optional[int]
discard = ... # type: bool
comment = ... # type: Optional[str]
comment_url = ... # type: Optional[str]
rfc2109 = ... # type: bool
port_specified = ... # type: bool
domain_specified = ... # type: bool
domain_initial_dot = ... # type: bool
def has_nonstandard_attr(self, name: str) -> bool: ...
@overload
def get_nonstandard_attr(self, name: str) -> Optional[str]: ...
@overload
def get_nonstandard_attr(self, name: str, default: _T = ...) -> Union[str, _T]: ...
def set_nonstandard_attr(self, name: str, value: str) -> None: ...
def is_expired(self, now: int = ...) -> bool: ...
mypy-0.470/typeshed/stdlib/3/http/client.pyi 0000644 0000000 0000000 00000016055 13035744274 017470 0 ustar root root # Stubs for http.client (Python 3.4)
from typing import (
Any, Dict, IO, Iterable, List, Iterator, Mapping, Optional, Tuple, TypeVar,
Union,
overload,
)
import email.message
import io
import sys
import ssl
import types
_DataType = Union[bytes, IO[Any], Iterable[bytes], str]
_T = TypeVar('_T')
HTTP_PORT = ... # type: int
HTTPS_PORT = ... # type: int
CONTINUE = ... # type: int
SWITCHING_PROTOCOLS = ... # type: int
PROCESSING = ... # type: int
OK = ... # type: int
CREATED = ... # type: int
ACCEPTED = ... # type: int
NON_AUTHORITATIVE_INFORMATION = ... # type: int
NO_CONTENT = ... # type: int
RESET_CONTENT = ... # type: int
PARTIAL_CONTENT = ... # type: int
MULTI_STATUS = ... # type: int
IM_USED = ... # type: int
MULTIPLE_CHOICES = ... # type: int
MOVED_PERMANENTLY = ... # type: int
FOUND = ... # type: int
SEE_OTHER = ... # type: int
NOT_MODIFIED = ... # type: int
USE_PROXY = ... # type: int
TEMPORARY_REDIRECT = ... # type: int
BAD_REQUEST = ... # type: int
UNAUTHORIZED = ... # type: int
PAYMENT_REQUIRED = ... # type: int
FORBIDDEN = ... # type: int
NOT_FOUND = ... # type: int
METHOD_NOT_ALLOWED = ... # type: int
NOT_ACCEPTABLE = ... # type: int
PROXY_AUTHENTICATION_REQUIRED = ... # type: int
REQUEST_TIMEOUT = ... # type: int
CONFLICT = ... # type: int
GONE = ... # type: int
LENGTH_REQUIRED = ... # type: int
PRECONDITION_FAILED = ... # type: int
REQUEST_ENTITY_TOO_LARGE = ... # type: int
REQUEST_URI_TOO_LONG = ... # type: int
UNSUPPORTED_MEDIA_TYPE = ... # type: int
REQUESTED_RANGE_NOT_SATISFIABLE = ... # type: int
EXPECTATION_FAILED = ... # type: int
UNPROCESSABLE_ENTITY = ... # type: int
LOCKED = ... # type: int
FAILED_DEPENDENCY = ... # type: int
UPGRADE_REQUIRED = ... # type: int
PRECONDITION_REQUIRED = ... # type: int
TOO_MANY_REQUESTS = ... # type: int
REQUEST_HEADER_FIELDS_TOO_LARGE = ... # type: int
INTERNAL_SERVER_ERROR = ... # type: int
NOT_IMPLEMENTED = ... # type: int
BAD_GATEWAY = ... # type: int
SERVICE_UNAVAILABLE = ... # type: int
GATEWAY_TIMEOUT = ... # type: int
HTTP_VERSION_NOT_SUPPORTED = ... # type: int
INSUFFICIENT_STORAGE = ... # type: int
NOT_EXTENDED = ... # type: int
NETWORK_AUTHENTICATION_REQUIRED = ... # type: int
responses = ... # type: Dict[int, str]
class HTTPMessage(email.message.Message): ...
if sys.version_info >= (3, 5):
class HTTPResponse(io.BufferedIOBase):
msg = ... # type: HTTPMessage
version = ... # type: int
debuglevel = ... # type: int
closed = ... # type: bool
status = ... # type: int
reason = ... # type: str
def read(self, amt: Optional[int] = ...) -> bytes: ...
def readinto(self, b: bytearray) -> int: ...
@overload
def getheader(self, name: str) -> Optional[str]: ...
@overload
def getheader(self, name: str, default: _T) -> Union[str, _T]: ...
def getheaders(self) -> List[Tuple[str, str]]: ...
def fileno(self) -> int: ...
def __iter__(self) -> Iterator[bytes]: ...
def __enter__(self) -> 'HTTPResponse': ...
def __exit__(self, exc_type: Optional[type],
exc_val: Optional[Exception],
exc_tb: Optional[types.TracebackType]) -> bool: ...
else:
class HTTPResponse:
msg = ... # type: HTTPMessage
version = ... # type: int
debuglevel = ... # type: int
closed = ... # type: bool
status = ... # type: int
reason = ... # type: str
def read(self, amt: Optional[int] = ...) -> bytes: ...
if sys.version_info >= (3, 3):
def readinto(self, b: bytearray) -> int: ...
@overload
def getheader(self, name: str) -> Optional[str]: ...
@overload
def getheader(self, name: str, default: _T) -> Union[str, _T]: ...
def getheaders(self) -> List[Tuple[str, str]]: ...
def fileno(self) -> int: ...
def __iter__(self) -> Iterator[bytes]: ...
def __enter__(self) -> 'HTTPResponse': ...
def __exit__(self, exc_type: Optional[type],
exc_val: Optional[Exception],
exc_tb: Optional[types.TracebackType]) -> bool: ...
class HTTPConnection:
if sys.version_info >= (3, 4):
def __init__(
self,
host: str, port: Optional[int] = ...,
timeout: int = ...,
source_address: Optional[Tuple[str, int]] = ...
) -> None: ...
else:
def __init__(
self,
host: str, port: Optional[int] = ...,
strict: bool = ..., timeout: int = ...,
source_address: Optional[Tuple[str, int]] = ...
)-> None: ...
def request(self, method: str, url: str,
body: Optional[_DataType] = ...,
headers: Mapping[str, str] = ...) -> None: ...
def getresponse(self) -> HTTPResponse: ...
def set_debuglevel(self, level: int) -> None: ...
def set_tunnel(self, host: str, port: Optional[int] = ...,
headers: Optional[Mapping[str, str]] = ...) -> None: ...
def connect(self) -> None: ...
def close(self) -> None: ...
def putrequest(self, request: str, selector: str, skip_host: bool = ...,
skip_accept_encoding: bool = ...) -> None: ...
def putheader(self, header: str, *argument: str) -> None: ...
def endheaders(self, message_body: Optional[_DataType] = ...) -> None: ...
def send(self, data: _DataType) -> None: ...
class HTTPSConnection(HTTPConnection):
if sys.version_info >= (3, 4):
def __init__(self,
host: str, port: Optional[int] = ...,
key_file: Optional[str] = ...,
cert_file: Optional[str] = ...,
timeout: int = ...,
source_address: Optional[Tuple[str, int]] = ...,
*, context: Optional[ssl.SSLContext] = ...,
check_hostname: Optional[bool] = ...) -> None: ...
else:
def __init__(self,
host: str, port: Optional[int] = ...,
key_file: Optional[str] = ...,
cert_file: Optional[str] = ...,
strict: bool = ..., timeout: int = ...,
source_address: Optional[Tuple[str, int]] = ...,
*, context: Optional[ssl.SSLContext] = ...,
check_hostname: Optional[bool] = ...) -> None: ...
class HTTPException(Exception): ...
class NotConnected(HTTPException): ...
class InvalidURL(HTTPException): ...
class UnknownProtocol(HTTPException): ...
class UnknownTransferEncoding(HTTPException): ...
class UnimplementedFileMode(HTTPException): ...
class IncompleteRead(HTTPException): ...
class ImproperConnectionState(HTTPException): ...
class CannotSendRequest(ImproperConnectionState): ...
class CannotSendHeader(ImproperConnectionState): ...
class ResponseNotReady(ImproperConnectionState): ...
class BadStatusLine(HTTPException): ...
class LineTooLong(HTTPException): ...
if sys.version_info >= (3, 5):
class RemoteDisconnected(ConnectionResetError, BadStatusLine): ...
mypy-0.470/typeshed/stdlib/3/_dummy_thread.pyi 0000644 0000000 0000000 00000000316 13023631176 020036 0 ustar root root # Stubs for _dummy_thread
# NOTE: These are incomplete!
from typing import Any
class LockType:
def acquire(self) -> None: ...
def release(self) -> None: ...
def allocate_lock() -> LockType: ...
mypy-0.470/typeshed/stdlib/3/collections/ 0000755 0000000 0000000 00000000000 13044320557 017011 5 ustar root root mypy-0.470/typeshed/stdlib/3/collections/__init__.pyi 0000644 0000000 0000000 00000013752 13044257024 021301 0 ustar root root # Stubs for collections
# Based on http://docs.python.org/3.2/library/collections.html
# TODO more abstract base classes (interfaces in mypy)
# These are not exported.
from typing import (
TypeVar, Generic, Dict, overload, List, Tuple,
Callable, Any, Type, Optional, Union
)
# These are exported.
# TODO reexport more.
from typing import (
Container as Container,
Hashable as Hashable,
Iterable as Iterable,
Iterator as Iterator,
Sized as Sized,
Generator as Generator,
ByteString as ByteString,
Awaitable as Awaitable,
Coroutine as Coroutine,
AsyncIterable as AsyncIterable,
AsyncIterator as AsyncIterator,
Reversible as Reversible,
Mapping as Mapping,
MappingView as MappingView,
ItemsView as ItemsView,
KeysView as KeysView,
ValuesView as ValuesView,
MutableMapping as MutableMapping,
Sequence as Sequence,
MutableSequence as MutableSequence,
MutableSet as MutableSet,
AbstractSet as Set,
)
_T = TypeVar('_T')
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
# namedtuple is special-cased in the type checker; the initializer is ignored.
def namedtuple(typename: str, field_names: Union[str, Iterable[Any]], *,
verbose: bool = ..., rename: bool = ..., module: str = None) -> Type[tuple]: ...
class UserDict(MutableMapping): ...
class UserList(MutableSequence): ...
class UserString(Sequence): ...
class MutableString(UserString, MutableSequence): ...
# Technically, deque only derives from MutableSequence in 3.5.
# But in practice it's not worth losing sleep over.
class deque(MutableSequence[_T], Generic[_T]):
maxlen = ... # type: Optional[int] # TODO readonly
def __init__(self, iterable: Iterable[_T] = ...,
maxlen: int = ...) -> None: ...
def append(self, x: _T) -> None: ...
def appendleft(self, x: _T) -> None: ...
def insert(self, i: int, x: _T) -> None: ...
def clear(self) -> None: ...
def count(self, x: _T) -> int: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def extendleft(self, iterable: Iterable[_T]) -> None: ...
def pop(self, i: int = ...) -> _T: ...
def popleft(self) -> _T: ...
def remove(self, value: _T) -> None: ...
def reverse(self) -> None: ...
def rotate(self, n: int) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
# These methods of deque don't really take slices, but we need to
# define them as taking a slice to satisfy MutableSequence.
@overload
def __getitem__(self, index: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> Sequence[_T]: raise TypeError
@overload
def __setitem__(self, i: int, x: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: raise TypeError
@overload
def __delitem__(self, i: int) -> None: ...
@overload
def __delitem__(self, s: slice) -> None: raise TypeError
def __contains__(self, o: object) -> bool: ...
# TODO __reversed__
class Counter(Dict[_T, int], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, Mapping: Mapping[_T, int]) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
# TODO keyword arguments
def elements(self) -> Iterator[_T]: ...
@overload
def most_common(self) -> List[_T]: ...
@overload
def most_common(self, n: int) -> List[_T]: ...
@overload
def subtract(self, Mapping: Mapping[_T, int]) -> None: ...
@overload
def subtract(self, iterable: Iterable[_T]) -> None: ...
# The Iterable[Tuple[...]] argument type is not actually desirable
# (the tuples will be added as keys, breaking type safety) but
# it's included so that the signature is compatible with
# Dict.update. Not sure if we should use '# type: ignore' instead
# and omit the type from the union.
@overload
def update(self, m: Mapping[_T, int]) -> None: ...
@overload
def update(self, m: Union[Iterable[_T], Iterable[Tuple[_T, int]]]) -> None: ...
def __add__(self, other: Counter[_T]) -> Counter[_T]: ...
def __sub__(self, other: Counter[_T]) -> Counter[_T]: ...
def __and__(self, other: Counter[_T]) -> Counter[_T]: ...
def __or__(self, other: Counter[_T]) -> Counter[_T]: ...
def __pos__(self) -> Counter[_T]: ...
def __neg__(self) -> Counter[_T]: ...
def __iadd__(self, other: Counter[_T]) -> Counter[_T]: ...
def __isub__(self, other: Counter[_T]) -> Counter[_T]: ...
def __iand__(self, other: Counter[_T]) -> Counter[_T]: ...
def __ior__(self, other: Counter[_T]) -> Counter[_T]: ...
class OrderedDict(Dict[_KT, _VT], Generic[_KT, _VT]):
def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ...
def move_to_end(self, key: _KT, last: bool = ...) -> None: ...
class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
default_factory = ... # type: Callable[[], _VT]
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT],
map: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, default_factory: Callable[[], _VT],
iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
# TODO __init__ keyword args
def __missing__(self, key: _KT) -> _VT: ...
# TODO __reversed__
class ChainMap(Dict[_KT, _VT], Generic[_KT, _VT]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, *maps: Mapping[_KT, _VT]) -> None: ...
@property
def maps(self) -> List[Mapping[_KT, _VT]]: ...
def new_child(self, m: Mapping[_KT, _VT] = ...) -> ChainMap[_KT, _VT]: ...
@property
def parents(self) -> ChainMap[_KT, _VT]: ...
mypy-0.470/typeshed/stdlib/3/collections/abc.pyi 0000644 0000000 0000000 00000002000 13044257024 020247 0 ustar root root # Stubs for collections.abc (introduced from Python 3.3)
#
# https://docs.python.org/3.3/whatsnew/3.3.html#collections
import sys
if sys.version_info >= (3, 3):
from . import (
Container as Container,
Hashable as Hashable,
Iterable as Iterable,
Iterator as Iterator,
Sized as Sized,
Mapping as Mapping,
MutableMapping as MutableMapping,
Sequence as Sequence,
MutableSequence as MutableSequence,
Set as Set,
MutableSet as MutableSet,
MappingView as MappingView,
ItemsView as ItemsView,
KeysView as KeysView,
ValuesView as ValuesView,
)
if sys.version_info >= (3, 5):
from . import (
Generator as Generator,
ByteString as ByteString,
Awaitable as Awaitable,
Coroutine as Coroutine,
AsyncIterable as AsyncIterable,
AsyncIterator as AsyncIterator,
)
if sys.version_info >= (3, 6):
from . import (
Reversible as Reversible,
)
mypy-0.470/typeshed/stdlib/3/imp.pyi 0000644 0000000 0000000 00000000347 13035744274 016015 0 ustar root root # Stubs for imp
# NOTE: These are incomplete!
from typing import TypeVar
_T = TypeVar('_T')
def cache_from_source(path: str, debug_override: bool = ...) -> str: ...
def reload(module: _T) -> _T: ... # TODO imprecise signature
mypy-0.470/typeshed/stdlib/3/pprint.pyi 0000644 0000000 0000000 00000001646 13023631176 016540 0 ustar root root # Stubs for pprint
# Based on http://docs.python.org/3.2/library/pprint.html
from typing import Any, Dict, Tuple, IO
def pformat(o: object, indent: int = ..., width: int = ...,
depth: int = ...) -> str: ...
def pprint(o: object, stream: IO[str] = ..., indent: int = ..., width: int = ...,
depth: int = ...) -> None: ...
def isreadable(o: object) -> bool: ...
def isrecursive(o: object) -> bool: ...
def saferepr(o: object) -> str: ...
class PrettyPrinter:
def __init__(self, indent: int = ..., width: int = ..., depth: int = ...,
stream: IO[str] = ...) -> None: ...
def pformat(self, o: object) -> str: ...
def pprint(self, o: object) -> None: ...
def isreadable(self, o: object) -> bool: ...
def isrecursive(self, o: object) -> bool: ...
def format(self, o: object, context: Dict[int, Any], maxlevels: int,
level: int) -> Tuple[str, bool, bool]: ...
mypy-0.470/typeshed/stdlib/3/weakref.pyi 0000644 0000000 0000000 00000006455 13035744274 016662 0 ustar root root # Stubs for weakref
# NOTE: These are incomplete!
from typing import (
TypeVar, Generic, Any, Callable, overload, Mapping, Iterator, Dict, Tuple,
Iterable, Optional
)
_T = TypeVar('_T')
_KT = TypeVar('_KT')
_VT = TypeVar('_VT')
class ReferenceType(Generic[_T]):
# TODO rest of members
def __init__(self, o: _T, callback: Callable[[ReferenceType[_T]],
Any] = ...) -> None: ...
def __call__(self) -> Optional[_T]: ...
ref = ReferenceType
# TODO callback
def proxy(object: _T) -> _T: ...
class WeakValueDictionary(Generic[_KT, _VT]):
# TODO tuple iterable argument?
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT]) -> None: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
@overload
def get(self, k: _KT) -> _VT: ...
@overload
def get(self, k: _KT, default: _VT) -> _VT: ...
@overload
def pop(self, k: _KT) -> _VT: ...
@overload
def pop(self, k: _KT, default: _VT) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
@overload
def setdefault(self, k: _KT) -> _VT: ...
@overload
def setdefault(self, k: _KT, default: _VT) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT]) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]]) -> None: ...
# NOTE: incompatible with Mapping
def keys(self) -> Iterator[_KT]: ...
def values(self) -> Iterator[_VT]: ...
def items(self) -> Iterator[Tuple[_KT, _VT]]: ...
# TODO return type
def valuerefs(self) -> Iterable[Any]: ...
class WeakKeyDictionary(Generic[_KT, _VT]):
# TODO tuple iterable argument?
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT]) -> None: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
@overload
def get(self, k: _KT) -> _VT: ...
@overload
def get(self, k: _KT, default: _VT) -> _VT: ...
@overload
def pop(self, k: _KT) -> _VT: ...
@overload
def pop(self, k: _KT, default: _VT) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
@overload
def setdefault(self, k: _KT) -> _VT: ...
@overload
def setdefault(self, k: _KT, default: _VT) -> _VT: ...
@overload
def update(self, m: Mapping[_KT, _VT]) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]]) -> None: ...
# NOTE: incompatible with Mapping
def keys(self) -> Iterator[_KT]: ...
def values(self) -> Iterator[_VT]: ...
def items(self) -> Iterator[Tuple[_KT, _VT]]: ...
# TODO return type
def valuerefs(self) -> Iterable[Any]: ...
mypy-0.470/typeshed/stdlib/3/copy.pyi 0000644 0000000 0000000 00000000302 13023631176 016162 0 ustar root root # Stubs for copy
# NOTE: These are incomplete!
from typing import TypeVar, Dict, Any
_T = TypeVar('_T')
def deepcopy(x: _T, memo: Dict[Any, Any] = ...) -> _T: ...
def copy(x: _T) -> _T: ...
mypy-0.470/typeshed/stdlib/3/email/ 0000755 0000000 0000000 00000000000 13044320557 015562 5 ustar root root mypy-0.470/typeshed/stdlib/3/email/policy.pyi 0000644 0000000 0000000 00000005533 13035744274 017620 0 ustar root root # Stubs for email.policy (Python 3.4)
from abc import abstractmethod
from typing import Any, List, Optional, Tuple, Union, Callable
import sys
from email.message import Message
from email.errors import MessageDefect
from email.header import Header
if sys.version_info >= (3, 4):
from email.contentmanager import ContentManager
if sys.version_info >= (3, 3):
class Policy:
max_line_length = ... # type: Optional[int]
linesep = ... # type: str
cte_type = ... # type: str
raise_on_defect = ... # type: bool
if sys.version_info >= (3, 5):
mange_from = ... # type: bool
def __init__(**kw: Any) -> None: ...
def clone(**kw: Any) -> 'Policy': ...
def handle_defect(self, obj: Message,
defect: MessageDefect) -> None: ...
def register_defect(self, obj: Message,
defect: MessageDefect) -> None: ...
def header_max_count(self, name: str) -> Optional[int]: ...
@abstractmethod
def header_source_parse(self, sourcelines: List[str]) -> str: ...
@abstractmethod
def header_store_parse(self, name: str,
value: str) -> Tuple[str, str]: ...
@abstractmethod
def header_fetch_parse(self, name: str,
value: str) -> str: ...
@abstractmethod
def fold(self, name: str, value: str) -> str: ...
@abstractmethod
def fold_binary(self, name: str, value: str) -> bytes: ...
class Compat32(Policy):
def header_source_parse(self, sourcelines: List[str]) -> str: ...
def header_store_parse(self, name: str,
value: str) -> Tuple[str, str]: ...
def header_fetch_parse(self, name: str, # type: ignore
value: str) -> Union[str, Header]: ...
def fold(self, name: str, value: str) -> str: ...
def fold_binary(self, name: str, value: str) -> bytes: ...
compat32 = ... # type: Compat32
class EmailPolicy(Policy):
utf8 = ... # type: bool
refold_source = ... # type: str
header_factory = ... # type: Callable[[str, str], str]
if sys.version_info >= (3, 4):
content_manager = ... # type: ContentManager
def header_source_parse(self, sourcelines: List[str]) -> str: ...
def header_store_parse(self, name: str,
value: str) -> Tuple[str, str]: ...
def header_fetch_parse(self, name: str, value: str) -> str: ...
def fold(self, name: str, value: str) -> str: ...
def fold_binary(self, name: str, value: str) -> bytes: ...
default = ... # type: EmailPolicy
SMTP = ... # type: EmailPolicy
SMTPUTF8 = ... # type: EmailPolicy
HTTP = ... # type: EmailPolicy
strict = ... # type: EmailPolicy
mypy-0.470/typeshed/stdlib/3/email/header.pyi 0000644 0000000 0000000 00000002166 13023631176 017541 0 ustar root root # Stubs for email.header (Python 3.4)
from typing import Union, Optional, Any, List, Tuple
from email.charset import Charset
class Header:
def __init__(self, s: Union[bytes, str, None] = ...,
charset: Union[Charset, str, None] = ...,
maxlinelen: Optional[int] = ...,
header_name: Optional[str] = ..., continuation_ws: str = ...,
errors: str = ...) -> None: ...
def append(self, s: Union[bytes, str],
charset: Union[Charset, str, None] = ...,
errors: str = ...) -> None: ...
def encode(self, splitchars: str = ..., maxlinelen: Optional[int] = ...,
linesep: str = ...) -> str: ...
def __str__(self) -> str: ...
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
def decode_header(header: Union[Header, str]) -> List[Tuple[bytes, Optional[str]]]: ...
def make_header(decoded_seq: List[Tuple[bytes, Optional[str]]],
maxlinelen: Optional[int] =...,
header_name: Optional[str] = ...,
continuation_ws: str = ...) -> Header: ...
mypy-0.470/typeshed/stdlib/3/email/generator.pyi 0000644 0000000 0000000 00000003435 13023631176 020277 0 ustar root root # Stubs for email.generator (Python 3.4)
from typing import TextIO, Optional
import sys
from email.message import Message
if sys.version_info >= (3, 3):
from email.policy import Policy
class Generator:
def clone(self, fp: TextIO) -> 'Generator': ...
def write(self, s: str) -> None: ...
if sys.version_info >= (3, 3):
def __init__(self, outfp: TextIO, mangle_from_: bool = ...,
maxheaderlen: int = ..., *,
policy: Policy = ...) -> None: ...
else:
def __init__(self, outfp: TextIO,
mangle_from_: bool = ...,
maxheaderlen: int = ...) -> None: ...
if sys.version_info >= (3, 2):
def flatten(self, msg: Message, unixfrom: bool = ...,
linesep: Optional[str] =...) -> None: ...
else:
def flatten(self, msg: Message,
unixfrom: bool = ...) -> None: ...
if sys.version_info >= (3, 2):
class BytesGenerator:
def clone(self, fp: TextIO) -> 'Generator': ...
def write(self, s: str) -> None: ...
if sys.version_info >= (3, 3):
def __init__(self, outfp: TextIO, mangle_from_: bool = ...,
maxheaderlen: int = ..., *,
policy: Policy = ...) -> None: ...
else:
def __init__(self, outfp: TextIO,
mangle_from_: bool = ...,
maxheaderlen: int = ...) -> None: ...
def flatten(self, msg: Message, unixfrom: bool = ...,
linesep: Optional[str] =...) -> None: ...
class DecodedGenerator(Generator):
# TODO `fmt` is positional
def __init__(self, outfp: TextIO, mangle_from_: bool = ...,
maxheaderlen: int = ..., *, fmt: Optional[str]) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/charset.pyi 0000644 0000000 0000000 00000002211 13035744274 017740 0 ustar root root # Stubs for email.charset (Python 3.4)
from typing import List, Optional, Iterator, Any
class Charset:
input_charset = ... # type: str
header_encoding = ... # type: int
body_encoding = ... # type: int
output_charset = ... # type: Optional[str]
input_codec = ... # type: Optional[str]
output_codec = ... # type: Optional[str]
def __init__(self, input_charset: str = ...) -> None: ...
def get_body_encoding(self) -> str: ...
def get_output_charset(self) -> Optional[str]: ...
def header_encode(self, string: str) -> str: ...
def header_encode_lines(self, string: str,
maxlengths: Iterator[int]) -> List[str]: ...
def body_encode(self, string: str) -> str: ...
def __str__(self) -> str: ...
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
def add_charset(charset: Charset, header_enc: Optional[int] = ...,
body_enc: Optional[int] = ...,
output_charset: Optional[str] = ...) -> None: ...
def add_alias(alias: str, canonical: str) -> None: ...
def add_codec(charset: str, codecname: str) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/__init__.pyi 0000644 0000000 0000000 00000003415 13023631176 020046 0 ustar root root # Stubs for email (Python 3.4)
from typing import Callable, Optional, IO
import sys
from email.message import Message
if sys.version_info >= (3, 3):
from email.policy import Policy
if sys.version_info >= (3, 3):
def message_from_string(s: str, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> Message: ...
def message_from_bytes(s: bytes, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> Message: ...
def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> Message: ...
def message_from_binary_file(fp: IO[bytes],
_class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> Message: ...
elif sys.version_info >= (3, 2):
def message_from_string(s: str,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool] = ...) -> Message: ...
def message_from_bytes(s: bytes,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool] = ...) -> Message: ...
def message_from_file(fp: IO[str],
_class: Callable[[], Message] = ..., *,
strict: Optional[bool] = ...) -> Message: ...
def message_from_binary_file(fp: IO[bytes],
_class: Callable[[], Message] = ..., *,
strict: Optional[bool] = ...) -> Message: ...
# Names in __all__ with no definition:
# base64mime
# charset
# encoders
# errors
# feedparser
# generator
# header
# iterators
# message
# mime
# parser
# quoprimime
# utils
mypy-0.470/typeshed/stdlib/3/email/parser.pyi 0000644 0000000 0000000 00000005025 13035744274 017611 0 ustar root root # Stubs for email.parser (Python 3.4)
import email.feedparser
from email.message import Message
import sys
from typing import Callable, Optional, TextIO, BinaryIO
if sys.version_info >= (3, 3):
from email.policy import Policy
FeedParser = email.feedparser.FeedParser
BytesFeedParser = email.feedparser.BytesFeedParser
class Parser:
if sys.version_info >= (3, 3):
def __init__(self, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
# TODO `strict` is positional
def __init__(self,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool]) -> None: ...
def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
class HeaderParser(Parser):
if sys.version_info >= (3, 3):
def __init__(self, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
# TODO `strict` is positional
def __init__(self,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool]) -> None: ...
def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
if sys.version_info >= (3, 3):
class BytesHeaderParser(BytesParser):
if sys.version_info >= (3, 3):
def __init__(self, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
# TODO `strict` is positional
def __init__(self,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool]) -> None: ...
def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
if sys.version_info >= (3, 2):
class BytesParser:
if sys.version_info >= (3, 3):
def __init__(self, _class: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
# TODO `strict` is positional
def __init__(self,
_class: Callable[[], Message] = ..., *,
strict: Optional[bool]) -> None: ...
def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
mypy-0.470/typeshed/stdlib/3/email/message.pyi 0000644 0000000 0000000 00000013766 13035744274 017754 0 ustar root root # Stubs for email.message (Python 3.4)
from typing import (
List, Optional, Union, Tuple, TypeVar, Generator, Sequence, Iterator, Any
)
import sys
from email.charset import Charset
from email.errors import MessageDefect
if sys.version_info >= (3, 3):
from email.policy import Policy
if sys.version_info >= (3, 4):
from email.contentmanager import ContentManager
else:
ContentManager = object # Hack so we can reference it in argument types.
_T = TypeVar('_T')
_PayloadType = Union[List[Message], str, bytes]
_CharsetType = Union[Charset, str, None]
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
class Message:
preamble = ... # type: Optional[str]
epilogue = ... # type: Optional[str]
defects = ... # type: List[MessageDefect]
def __str__(self) -> str: ...
def is_multipart(self) -> bool: ...
def set_unixfrom(self, unixfrom: str) -> None: ...
def get_unixfrom(self) -> Optional[str]: ...
def attach(self, payload: 'Message') -> None: ...
def get_payload(self, i: int = ..., decode: bool = ...) \
-> Optional[_PayloadType]: ...
def set_payload(self, payload: _PayloadType,
charset: _CharsetType = ...) -> None: ...
def set_charset(self, charset: _CharsetType) -> None: ...
def get_charset(self) -> _CharsetType: ...
def __len__(self) -> int: ...
def __contains__(self, name: str) -> bool: ...
def __getitem__(self, name: str) -> Optional[str]: ...
def __setitem__(self, name: str, val: str) -> None: ...
def __delitem__(self, name: str) -> None: ...
def keys(self) -> List[str]: ...
def values(self) -> List[str]: ...
def items(self) -> List[Tuple[str, str]]: ...
def get(self, name: str, failobj: _T = ...) -> Union[str, _T]: ...
def get_all(self, name: str, failobj: _T = ...) -> Union[List[str], _T]: ...
def add_header(self, _name: str, _value: str, **_params: _ParamsType) \
-> None: ...
def replace_header(self, _name: str, _value: str) -> None: ...
def get_content_type(self) -> str: ...
def get_content_maintype(self) -> str: ...
def get_content_subtype(self) -> str: ...
def get_default_type(self) -> str: ...
def set_default_type(self, ctype: str) -> None: ...
def get_params(self, failobj: _T = ..., header: str = ...,
unquote: bool = ...) -> Union[List[Tuple[str, str]], _T]: ...
def get_param(self, param: str, failobj: _T = ..., header: str = ...,
unquote: bool = ...) -> Union[_T, _ParamType]: ...
def del_param(self, param: str, header: str = ...,
requote: bool = ...) -> None: ...
def set_type(self, type: str, header: str = ...,
requote: bool = ...) -> None: ...
def get_filename(self, failobj: _T = ...) -> Union[_T, str]: ...
def get_boundary(self, failobj: _T = ...) -> Union[_T, str]: ...
def set_boundary(self, boundary: str) -> None: ...
def get_content_charset(self, failobj: _T = ...) -> Union[_T, str]: ...
def get_charsets(self, failobj: _T = ...) -> Union[_T, List[str]]: ...
def walk(self) -> Generator['Message', None, None]: ...
if sys.version_info >= (3, 5):
def get_content_disposition(self) -> Optional[str]: ...
if sys.version_info >= (3, 4):
def as_string(self, unixfrom: bool = ..., maxheaderlen: int = ...,
policy: Optional[Policy] = ...) -> str: ...
def as_bytes(self, unixfrom: bool = ...,
policy: Optional[Policy] = ...) -> bytes: ...
def __bytes__(self) -> bytes: ...
def set_param(self, param: str, value: str, header: str = ...,
requote: bool = ..., charset: str = ...,
language: str = ..., replace: bool = ...) -> None: ...
else:
def as_string(self, unixfrom: bool = ...,
maxheaderlen: int = ...) -> str: ...
def set_param(self, param: str, value: str,
header: str = ..., requote: bool = ...,
charset: str = ..., language: str = ...) -> None: ...
if sys.version_info >= (3, 3):
def __init__(self, policy: Policy = ...) -> None: ...
else:
def __init__(self) -> None: ...
class MIMEPart:
if sys.version_info >= (3, 3):
def __init__(self, policy: Policy = ...) -> None: ...
else:
def __init__(self) -> None: ...
def get_body(self,
preferencelist: Sequence[str] = ...) -> Optional[Message]: ...
def iter_attachments(self) -> Iterator[Message]: ...
def iter_parts(self) -> Iterator[Message]: ...
def get_content(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> Any: ...
def set_content(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> None: ...
def make_related(self, boundary: Optional[str] = ...) -> None: ...
def make_alternative(self, boundary: Optional[str] = ...) -> None: ...
def make_mixed(self, boundary: Optional[str] = ...) -> None: ...
def add_related(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> None: ...
def add_alternative(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> None: ...
def add_attachement(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> None: ...
def clear(self) -> None: ...
def clear_content(self) -> None: ...
if sys.version_info >= (3, 4, 2):
def is_attachment(self) -> bool: ...
else:
@property
def is_attachment(self) -> bool: ...
class EmailMessage(MIMEPart):
def set_content(self, *args: Any,
content_manager: Optional[ContentManager] = ...,
**kw: Any) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/utils.pyi 0000644 0000000 0000000 00000003112 13035744274 017450 0 ustar root root # Stubs for email.utils (Python 3.4)
from typing import List, Optional, Tuple, Union
from email.charset import Charset
import datetime
_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
_PDTZ = Tuple[int, int, int, int, int, int, int, int, int, Optional[int]]
def quote(str: str) -> str: ...
def unquote(str: str) -> str: ...
def parseaddr(address: str) -> Tuple[str, str]: ...
def formataddr(pair: Tuple[str, str],
charset: Union[str, Charset] = ...) -> str: ...
def getaddresses(fieldvalues: List[str]) -> List[Tuple[str, str]]: ...
def parsedate(date: str) -> Optional[Tuple[int, int, int, int, int, int, int, int, int]]: ...
def parsedate_tz(date: str) -> Optional[_PDTZ]: ...
def parsedate_to_datetime(date: str) -> datetime.datetime: ...
def mktime_tz(tuple: _PDTZ) -> int: ...
def formatdate(timeval: Optional[float] = ..., localtime: bool = ...,
usegmt: bool = ...) -> str: ...
def format_datetime(dt: datetime.datetime, usegmt: bool = ...) -> str: ...
def localtime(dt: Optional[datetime.datetime] = ...) -> datetime.datetime: ...
def make_msgid(idstring: Optional[str] = ...,
domain: Optional[str] = ...) -> str: ...
def decode_rfc2231(s: str) -> Tuple[Optional[str], Optional[str], str]: ...
def encode_rfc2231(s: str, charset: Optional[str] = ...,
language: Optional[str] = ...) -> str: ...
def collapse_rfc2231_value(value: _ParamType, errors: str = ...,
fallback_charset: str = ...) -> str: ...
def decode_params(
params: List[Tuple[str, str]]
) -> List[Tuple[str, _ParamType]]: ...
mypy-0.470/typeshed/stdlib/3/email/feedparser.pyi 0000644 0000000 0000000 00000001737 13023631176 020434 0 ustar root root # Stubs for email.feedparser (Python 3.4)
from typing import Callable
import sys
from email.message import Message
if sys.version_info >= (3, 3):
from email.policy import Policy
class FeedParser:
if sys.version_info >= (3, 3):
def __init__(self, _factory: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
def __init__(self,
_factory: Callable[[], Message] = ...) -> None: ...
def feed(self, data: str) -> None: ...
def close(self) -> Message: ...
if sys.version_info >= (3, 2):
class BytesFeedParser:
if sys.version_info >= (3, 3):
def __init__(self, _factory: Callable[[], Message] = ..., *,
policy: Policy = ...) -> None: ...
else:
def __init__(self,
_factory: Callable[[], Message] = ...) -> None: ...
def feed(self, data: str) -> None: ...
def close(self) -> Message: ...
mypy-0.470/typeshed/stdlib/3/email/iterators.pyi 0000644 0000000 0000000 00000000517 13023631176 020323 0 ustar root root # Stubs for email.iterators (Python 3.4)
from typing import Iterator, Optional
from email.message import Message
def body_line_iterator(msg: Message, decode: bool = ...) -> Iterator[str]: ...
def typed_subpart_iterator(msg: Message, maintype: str = ...,
subtype: Optional[str] = ...) -> Iterator[str]: ...
mypy-0.470/typeshed/stdlib/3/email/errors.pyi 0000644 0000000 0000000 00000001622 13023631176 017621 0 ustar root root # Stubs for email.errors (Python 3.4)
import sys
class MessageError(Exception): ...
class MessageParseError(MessageError): ...
class HeaderParseError(MessageParseError): ...
class BoundaryError(MessageParseError): ...
class MultipartConversionError(MessageError, TypeError): ...
class MessageDefect(ValueError): ...
class NoBoundaryInMultipartDefect(MessageDefect): ...
class StartBoundaryNotFoundDefect(MessageDefect): ...
class FirstHeaderLineIsContinuationDefect(MessageDefect): ...
class MisplacedEnvelopeHeaderDefect(MessageDefect): ...
class MalformedHeaderDefect(MessageDefect): ...
class MultipartInvariantViolationDefect(MessageDefect): ...
class InvalidBase64PaddingDefect(MessageDefect): ...
class InvalidBase64CharactersDefect(MessageDefect): ...
if sys.version_info >= (3, 3):
class CloseBoundaryNotFoundDefect(MessageDefect): ...
class MissingHeaderBodySeparatorDefect(MessageDefect): ...
mypy-0.470/typeshed/stdlib/3/email/headerregistry.pyi 0000644 0000000 0000000 00000007005 13035744274 021336 0 ustar root root # Stubs for email.headerregistry (Python 3.4)
import datetime as dt
import sys
from typing import Dict, Tuple, Optional, Any, Union, Mapping
from email.errors import MessageDefect
if sys.version_info >= (3, 3):
from email.policy import Policy
if sys.version_info >= (3, 3):
class BaseHeader(str):
@property
def name(self) -> str: ...
@property
def defects(self) -> Tuple[MessageDefect, ...]: ...
@property
def max_count(self) -> Optional[int]: ...
def __new__(cls, name: str, value: Any) -> 'BaseHeader': ...
def init(self, *args: Any, **kw: Any) -> None: ...
def fold(self, *, policy: Policy) -> str: ...
class UnstructuredHeader:
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class UniqueUnstructuredHeader(UnstructuredHeader): ...
class DateHeader:
datetime = ... # type: dt.datetime
@classmethod
def parse(cls, string: Union[str, dt.datetime],
kwds: Dict[str, Any]) -> None: ...
class UniqueDateHeader(DateHeader): ...
class AddressHeader:
groups = ... # type: Tuple[Group, ...]
addresses = ... # type: Tuple[Address, ...]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class UniqueAddressHeader(AddressHeader): ...
class SingleAddressHeader(AddressHeader):
@property
def address(self) -> Address: ...
class UniqueSingleAddressHeader(SingleAddressHeader): ...
class MIMEVersionHeader:
version = ... # type: Optional[str]
major = ... # type: Optional[int]
minor = ... # type: Optional[int]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class ParameterizedMIMEHeader:
params = ... # type: Mapping[str, Any]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class ContentTypeHeader(ParameterizedMIMEHeader):
content_type = ... # type: str
maintype = ... # type: str
subtype = ... # type: str
class ContentDispositionHeader(ParameterizedMIMEHeader):
content_disposition = ... # type: str
class ContentTransferEncoding:
cte = ... # type: str
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class HeaderRegistry:
def __init__(self, base_class: BaseHeader = ...,
default_class: BaseHeader = ...,
use_default_map: bool = ...) -> None: ...
def map_to_type(self, name: str, cls: BaseHeader) -> None: ...
def __getitem__(self, name: str) -> BaseHeader: ...
def __call__(self, name: str, value: Any) -> BaseHeader: ...
class Address:
display_name = ... # type: str
username = ... # type: str
domain = ... # type: str
@property
def addr_spec(self) -> str: ...
def __init__(self, display_name: str = ...,
username: Optional[str] = ...,
domain: Optional[str] = ...,
addr_spec: Optional[str]=...) -> None: ...
def __str__(self) -> str: ...
class Group:
display_name = ... # type: Optional[str]
addresses = ... # type: Tuple[Address, ...]
def __init__(self, display_name: Optional[str] = ...,
addresses: Optional[Tuple[Address, ...]] = ...) \
-> None: ...
def __str__(self) -> str: ...
mypy-0.470/typeshed/stdlib/3/email/contentmanager.pyi 0000644 0000000 0000000 00000001413 13023631176 021310 0 ustar root root # Stubs for email.contentmanager (Python 3.4)
from typing import Any, Callable
import sys
import email.message
from email.message import Message
if sys.version_info >= (3, 4):
EmailMessage = email.message.EmailMessage
MIMEPart = email.message.MIMEPart
class ContentManager:
def __init__(self) -> None: ...
def get_content(self, msg: Message, *args: Any, **kw: Any) -> Any: ...
def set_content(self, msg: Message, obj: Any, *args: Any,
**kw: Any) -> Any: ...
def add_get_handler(self, key: str, handler: Callable[..., Any]) -> None: ...
def add_set_handler(self, typekey: type,
handler: Callable[..., Any]) -> None: ...
raw_data_manager = ... # type: ContentManager
mypy-0.470/typeshed/stdlib/3/email/mime/ 0000755 0000000 0000000 00000000000 13044320557 016511 5 ustar root root mypy-0.470/typeshed/stdlib/3/email/mime/image.pyi 0000644 0000000 0000000 00000000665 13023631176 020324 0 ustar root root # Stubs for email.mime.image (Python 3.4)
from typing import Callable, Optional, Tuple, Union
from email.mime.nonmultipart import MIMENonMultipart
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEImage(MIMENonMultipart):
def __init__(self, _imagedata: bytes, _subtype: Optional[str] = ...,
_encoder: Callable[[MIMEImage], None] = ...,
**_params: _ParamsType) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/text.pyi 0000644 0000000 0000000 00000000423 13023631176 020216 0 ustar root root # Stubs for email.mime.text (Python 3.4)
from typing import Optional
from email.mime.nonmultipart import MIMENonMultipart
class MIMEText(MIMENonMultipart):
def __init__(self, _text: str, _subtype: str = ...,
_charset: Optional[str] = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/__init__.py 0000644 0000000 0000000 00000000000 13023631176 020607 0 ustar root root mypy-0.470/typeshed/stdlib/3/email/mime/message.pyi 0000644 0000000 0000000 00000000362 13023631176 020660 0 ustar root root # Stubs for email.mime.message (Python 3.4)
from email.message import Message
from email.mime.nonmultipart import MIMENonMultipart
class MIMEMessage(MIMENonMultipart):
def __init__(self, _msg: Message, _subtype: str = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/application.pyi 0000644 0000000 0000000 00000000670 13023631176 021541 0 ustar root root # Stubs for email.mime.application (Python 3.4)
from typing import Callable, Optional, Tuple, Union
from email.mime.nonmultipart import MIMENonMultipart
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEApplication(MIMENonMultipart):
def __init__(self, _data: bytes, _subtype: str = ...,
_encoder: Callable[[MIMEApplication], None] = ...,
**_params: _ParamsType) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/multipart.pyi 0000644 0000000 0000000 00000000712 13023631176 021254 0 ustar root root # Stubs for email.mime.multipart (Python 3.4)
from typing import Optional, Sequence, Tuple, Union
from email.message import Message
from email.mime.base import MIMEBase
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEMultipart(MIMEBase):
def __init__(self, _subtype: str = ..., boundary: Optional[str] = ...,
_subparts: Optional[Sequence[Message]] = ...,
**_params: _ParamsType) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/audio.pyi 0000644 0000000 0000000 00000000665 13023631176 020343 0 ustar root root # Stubs for email.mime.audio (Python 3.4)
from typing import Callable, Optional, Tuple, Union
from email.mime.nonmultipart import MIMENonMultipart
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEAudio(MIMENonMultipart):
def __init__(self, _audiodata: bytes, _subtype: Optional[str] = ...,
_encoder: Callable[[MIMEAudio], None] = ...,
**_params: _ParamsType) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/base.pyi 0000644 0000000 0000000 00000000475 13023631176 020153 0 ustar root root # Stubs for email.mime.base (Python 3.4)
from typing import Optional, Tuple, Union
import email.message
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEBase(email.message.Message):
def __init__(self, _maintype: str, _subtype: str,
**_params: _ParamsType) -> None: ...
mypy-0.470/typeshed/stdlib/3/email/mime/nonmultipart.pyi 0000644 0000000 0000000 00000000176 13023631176 021773 0 ustar root root # Stubs for email.mime.nonmultipart (Python 3.4)
from email.mime.base import MIMEBase
class MIMENonMultipart(MIMEBase): ...
mypy-0.470/typeshed/stdlib/3/email/encoders.pyi 0000644 0000000 0000000 00000000377 13023631176 020115 0 ustar root root # Stubs for email.encoders (Python 3.4)
from email.message import Message
def encode_base64(msg: Message) -> None: ...
def encode_quopri(msg: Message) -> None: ...
def encode_7or8bit(msg: Message) -> None: ...
def encode_noop(msg: Message) -> None: ...
mypy-0.470/typeshed/stdlib/3/grp.pyi 0000644 0000000 0000000 00000000515 13023631176 016006 0 ustar root root from typing import List
# TODO group database entry object type
class struct_group:
gr_name = ... # type: str
gr_passwd = ... # type: str
gr_gid = 0
gr_mem = ... # type: List[str]
def getgrgid(gid: int) -> struct_group: ...
def getgrnam(name: str) -> struct_group: ...
def getgrall() -> List[struct_group]: ...
mypy-0.470/typeshed/stdlib/3/_ast.pyi 0000644 0000000 0000000 00000020316 13035744274 016154 0 ustar root root # Python 3.5 _ast
import typing
from typing import Any, Optional, Union
PyCF_ONLY_AST = ... # type: int
identifier = str
class AST:
_attributes = ... # type: typing.Tuple[str, ...]
_fields = ... # type: typing.Tuple[str, ...]
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
class mod(AST):
...
class Module(mod):
body = ... # type: typing.List[stmt]
class Interactive(mod):
body = ... # type: typing.List[stmt]
class Expression(mod):
body = ... # type: expr
class Suite(mod):
body = ... # type: typing.List[stmt]
class stmt(AST):
lineno = ... # type: int
col_offset = ... # type: int
class FunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
returns = ... # type: Optional[expr]
class AsyncFunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
returns = ... # type: Optional[expr]
class ClassDef(stmt):
name = ... # type: identifier
bases = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
class Return(stmt):
value = ... # type: Optional[expr]
class Delete(stmt):
targets = ... # type: typing.List[expr]
class Assign(stmt):
targets = ... # type: typing.List[expr]
value = ... # type: expr
class AugAssign(stmt):
target = ... # type: expr
op = ... # type: operator
value = ... # type: expr
class For(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class AsyncFor(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class While(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class If(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class With(stmt):
items = ... # type: typing.List[withitem]
body = ... # type: typing.List[stmt]
class AsyncWith(stmt):
items = ... # type: typing.List[withitem]
body = ... # type: typing.List[stmt]
class Raise(stmt):
exc = ... # type: Optional[expr]
cause = ... # type: Optional[expr]
class Try(stmt):
body = ... # type: typing.List[stmt]
handlers = ... # type: typing.List[ExceptHandler]
orelse = ... # type: typing.List[stmt]
finalbody = ... # type: typing.List[stmt]
class Assert(stmt):
test = ... # type: expr
msg = ... # type: Optional[expr]
class Import(stmt):
names = ... # type: typing.List[alias]
class ImportFrom(stmt):
module = ... # type: Optional[identifier]
names = ... # type: typing.List[alias]
level = ... # type: Optional[int]
class Global(stmt):
names = ... # type: typing.List[identifier]
class Nonlocal(stmt):
names = ... # type: typing.List[identifier]
class Expr(stmt):
value = ... # type: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class slice(AST):
...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower = ... # type: Optional[expr]
upper = ... # type: Optional[expr]
step = ... # type: Optional[expr]
class ExtSlice(slice):
dims = ... # type: typing.List[slice]
class Index(slice):
value = ... # type: expr
class expr(AST):
lineno = ... # type: int
col_offset = ... # type: int
class BoolOp(expr):
op = ... # type: boolop
values = ... # type: typing.List[expr]
class BinOp(expr):
left = ... # type: expr
op = ... # type: operator
right = ... # type: expr
class UnaryOp(expr):
op = ... # type: unaryop
operand = ... # type: expr
class Lambda(expr):
args = ... # type: arguments
body = ... # type: expr
class IfExp(expr):
test = ... # type: expr
body = ... # type: expr
orelse = ... # type: expr
class Dict(expr):
keys = ... # type: typing.List[expr]
values = ... # type: typing.List[expr]
class Set(expr):
elts = ... # type: typing.List[expr]
class ListComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class SetComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class DictComp(expr):
key = ... # type: expr
value = ... # type: expr
generators = ... # type: typing.List[comprehension]
class GeneratorExp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class Await(expr):
value = ... # type: expr
class Yield(expr):
value = ... # type: Optional[expr]
class YieldFrom(expr):
value = ... # type: expr
class Compare(expr):
left = ... # type: expr
ops = ... # type: typing.List[cmpop]
comparators = ... # type: typing.List[expr]
class Call(expr):
func = ... # type: expr
args = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
class Num(expr):
n = ... # type: Union[int, float]
class Str(expr):
s = ... # type: str
class Bytes(expr):
s = ... # type: bytes
class NameConstant(expr):
value = ... # type: Any
class Ellipsis(expr): ...
class Attribute(expr):
value = ... # type: expr
attr = ... # type: identifier
ctx = ... # type: expr_context
class Subscript(expr):
value = ... # type: expr
slice = ... # type: _slice
ctx = ... # type: expr_context
class Starred(expr):
value = ... # type: expr
ctx = ... # type: expr_context
class Name(expr):
id = ... # type: identifier
ctx = ... # type: expr_context
class List(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class Tuple(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class expr_context(AST):
...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(expr_context): ...
class Store(expr_context): ...
class boolop(AST):
...
class And(boolop): ...
class Or(boolop): ...
class operator(AST):
...
class Add(operator): ...
class BitAnd(operator): ...
class BitOr(operator): ...
class BitXor(operator): ...
class Div(operator): ...
class FloorDiv(operator): ...
class LShift(operator): ...
class Mod(operator): ...
class Mult(operator): ...
class MatMult(operator): ...
class Pow(operator): ...
class RShift(operator): ...
class Sub(operator): ...
class unaryop(AST):
...
class Invert(unaryop): ...
class Not(unaryop): ...
class UAdd(unaryop): ...
class USub(unaryop): ...
class cmpop(AST):
...
class Eq(cmpop): ...
class Gt(cmpop): ...
class GtE(cmpop): ...
class In(cmpop): ...
class Is(cmpop): ...
class IsNot(cmpop): ...
class Lt(cmpop): ...
class LtE(cmpop): ...
class NotEq(cmpop): ...
class NotIn(cmpop): ...
class comprehension(AST):
target = ... # type: expr
iter = ... # type: expr
ifs = ... # type: typing.List[expr]
class ExceptHandler(AST):
type = ... # type: Optional[expr]
name = ... # type: Optional[identifier]
body = ... # type: typing.List[stmt]
lineno = ... # type: int
col_offset = ... # type: int
class arguments(AST):
args = ... # type: typing.List[arg]
vararg = ... # type: Optional[arg]
kwonlyargs = ... # type: typing.List[arg]
kw_defaults = ... # type: typing.List[expr]
kwarg = ... # type: Optional[arg]
defaults = ... # type: typing.List[expr]
class arg(AST):
arg = ... # type: identifier
annotation = ... # type: Optional[expr]
lineno = ... # type: int
col_offset = ... # type: int
class keyword(AST):
arg = ... # type: Optional[identifier]
value = ... # type: expr
class alias(AST):
name = ... # type: identifier
asname = ... # type: Optional[identifier]
class withitem(AST):
context_expr = ... # type: expr
optional_vars = ... # type: Optional[expr]
mypy-0.470/typeshed/stdlib/3/json.pyi 0000644 0000000 0000000 00000006450 13035744274 016202 0 ustar root root from typing import Any, IO, Iterator, Optional, Tuple, Callable, Dict, List, Union
class JSONDecodeError(ValueError):
def dumps(self, obj: Any) -> str: ...
def dump(self, obj: Any, fp: IO[str], *args: Any, **kwds: Any) -> None: ...
def loads(self, s: str) -> Any: ...
def load(self, fp: IO[str]) -> Any: ...
def dumps(obj: Any,
skipkeys: bool = ...,
ensure_ascii: bool = ...,
check_circular: bool = ...,
allow_nan: bool = ...,
cls: Any = ...,
indent: Union[None, int, str] = ...,
separators: Optional[Tuple[str, str]] = ...,
default: Optional[Callable[[Any], Any]] = ...,
sort_keys: bool = ...,
**kwds: Any) -> str: ...
def dump(obj: Any,
fp: IO[str],
skipkeys: bool = ...,
ensure_ascii: bool = ...,
check_circular: bool = ...,
allow_nan: bool = ...,
cls: Any = ...,
indent: Union[None, int, str] = ...,
separators: Optional[Tuple[str, str]] = ...,
default: Optional[Callable[[Any], Any]] = ...,
sort_keys: bool = ...,
**kwds: Any) -> None: ...
def loads(s: str,
encoding: Any = ..., # ignored and deprecated
cls: Any = ...,
object_hook: Optional[Callable[[Dict], Any]] = ...,
parse_float: Optional[Callable[[str], Any]] = ...,
parse_int: Optional[Callable[[str], Any]] = ...,
parse_constant: Optional[Callable[[str], Any]] = ...,
object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ...,
**kwds: Any) -> Any: ...
def load(fp: IO[str],
cls: Any = ...,
object_hook: Optional[Callable[[Dict], Any]] = ...,
parse_float: Optional[Callable[[str], Any]] = ...,
parse_int: Optional[Callable[[str], Any]] = ...,
parse_constant: Optional[Callable[[str], Any]] = ...,
object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ...,
**kwds: Any) -> Any: ...
class JSONEncoder(object):
item_separator = ... # type: str
key_separator = ... # type: str
skipkeys = ... # type: bool
ensure_ascii = ... # type: bool
check_circular = ... # type: bool
allow_nan = ... # type: bool
sort_keys = ... # type: bool
indent = None # type: int
def __init__(self, skipkeys: bool=..., ensure_ascii: bool=...,
check_circular: bool=..., allow_nan: bool=..., sort_keys: bool=...,
indent: int=None, separators: Tuple[str, str]=None, default: Callable=None) -> None: ...
def default(self, o: Any) -> Any: ...
def encode(self, o: Any) -> str: ...
def iterencode(self, o: Any, _one_shot: bool=False) -> Iterator[str]: ...
class JSONDecoder(object):
object_hook = None # type: Callable[[Dict[str, Any]], Any]
parse_float = ... # Callable[[str], Any]
parse_int = ... # Callable[[str], Any]
parse_constant = ... # Callable[[str], Any]
strict = ... # type: bool
object_pairs_hook = None # type: Callable[[List[Tuple[str, Any]]], Any]
def __init__(self, object_hook: Callable[[Dict[str, Any]], Any]=None,
parse_float: Callable[[str], Any]=None,
parse_int: Callable[[str], Any]=None,
parse_constant: Callable[[str], Any]=None,
strict: bool=True,
object_pairs_hook: Callable[[List[Tuple[str, Any]]], Any]=None) -> None: ...
def decode(self, s: str) -> Any: ...
def raw_decode(self, s: str, idx: int=...) -> Tuple[Any, int]: ...
mypy-0.470/typeshed/stdlib/3/linecache.pyi 0000644 0000000 0000000 00000000310 13035744274 017131 0 ustar root root from typing import Any
def getline(filename: str, lineno: int, module_globals: Any=...) -> str: pass
def clearcache() -> None: pass
def getlines(filename: str, module_globals: Any=...) -> None: pass
mypy-0.470/typeshed/stdlib/3/sysconfig.pyi 0000644 0000000 0000000 00000000222 13023631176 017215 0 ustar root root # Stubs for sysconfig
# NOTE: These are incomplete!
import typing
def get_config_var(name: str) -> str: ...
def is_python_build() -> bool: ...
mypy-0.470/typeshed/stdlib/3/os/ 0000755 0000000 0000000 00000000000 13044320557 015114 5 ustar root root mypy-0.470/typeshed/stdlib/3/os/path.pyi 0000644 0000000 0000000 00000004153 13035744274 016604 0 ustar root root # Stubs for os.path
# Ron Murawski
# based on http://docs.python.org/3.2/library/os.path.html
import sys
from typing import overload, List, Any, AnyStr, Sequence, Tuple, BinaryIO, TextIO
# ----- os.path variables -----
supports_unicode_filenames = False
# aliases (also in os)
curdir = ... # type: str
pardir = ... # type: str
sep = ... # type: str
altsep = ... # type: str
extsep = ... # type: str
pathsep = ... # type: str
defpath = ... # type: str
devnull = ... # type: str
# ----- os.path function stubs -----
def abspath(path: AnyStr) -> AnyStr: ...
def basename(path: AnyStr) -> AnyStr: ...
if sys.version_info >= (3, 5):
def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ...
# NOTE: Empty List[bytes] results in '' (str) => fall back to Any return type.
def commonprefix(list: List[AnyStr]) -> Any: ...
def dirname(path: AnyStr) -> AnyStr: ...
def exists(path: AnyStr) -> bool: ...
def lexists(path: AnyStr) -> bool: ...
def expanduser(path: AnyStr) -> AnyStr: ...
def expandvars(path: AnyStr) -> AnyStr: ...
# These return float if os.stat_float_times() == True
def getatime(path: AnyStr) -> Any: ...
def getmtime(path: AnyStr) -> Any: ...
def getctime(path: AnyStr) -> Any: ...
def getsize(path: AnyStr) -> int: ...
def isabs(path: AnyStr) -> bool: ...
def isfile(path: AnyStr) -> bool: ...
def isdir(path: AnyStr) -> bool: ...
def islink(path: AnyStr) -> bool: ...
def ismount(path: AnyStr) -> bool: ...
def join(path: AnyStr, *paths: AnyStr) -> AnyStr: ...
def normcase(path: AnyStr) -> AnyStr: ...
def normpath(path: AnyStr) -> AnyStr: ...
def realpath(path: AnyStr) -> AnyStr: ...
def relpath(path: AnyStr, start: AnyStr = ...) -> AnyStr: ...
def samefile(path1: AnyStr, path2: AnyStr) -> bool: ...
def sameopenfile(fp1: int, fp2: int) -> bool: ...
# def samestat(stat1: stat_result,
# stat2: stat_result) -> bool: ... # Unix only
def split(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitdrive(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitext(path: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
# def splitunc(path: str) -> Tuple[str, str]: ... # Windows only, deprecated
mypy-0.470/typeshed/stdlib/3/os/__init__.pyi 0000644 0000000 0000000 00000035466 13044257024 017412 0 ustar root root # Stubs for os
# Ron Murawski
# based on http: //docs.python.org/3.2/library/os.html
from builtins import OSError as error
from io import TextIOWrapper as _TextIOWrapper
import sys
from typing import (
Mapping, MutableMapping, Dict, List, Any, Tuple, Iterator, overload, Union, AnyStr,
Optional, Generic, Set, Callable
)
from . import path
from mypy_extensions import NoReturn
# ----- os variables -----
supports_bytes_environ = False # TODO: True when bytes implemented?
SEEK_SET = 0
SEEK_CUR = 0
SEEK_END = 0
O_RDONLY = 0
O_WRONLY = 0
O_RDWR = 0
O_APPEND = 0
O_CREAT = 0
O_EXCL = 0
O_TRUNC = 0
O_DSYNC = 0 # Unix only
O_RSYNC = 0 # Unix only
O_SYNC = 0 # Unix only
O_NDELAY = 0 # Unix only
O_NONBLOCK = 0 # Unix only
O_NOCTTY = 0 # Unix only
O_SHLOCK = 0 # Unix only
O_EXLOCK = 0 # Unix only
O_BINARY = 0 # Windows only
O_NOINHERIT = 0 # Windows only
O_SHORT_LIVED = 0 # Windows only
O_TEMPORARY = 0 # Windows only
O_RANDOM = 0 # Windows only
O_SEQUENTIAL = 0 # Windows only
O_TEXT = 0 # Windows only
O_ASYNC = 0 # Gnu extension if in C library
O_DIRECT = 0 # Gnu extension if in C library
O_DIRECTORY = 0 # Gnu extension if in C library
O_NOFOLLOW = 0 # Gnu extension if in C library
O_NOATIME = 0 # Gnu extension if in C library
curdir = ... # type: str
pardir = ... # type: str
sep = ... # type: str
altsep = ... # type: str
extsep = ... # type: str
pathsep = ... # type: str
defpath = ... # type: str
linesep = ... # type: str
devnull = ... # type: str
name = ... # type: str
F_OK = 0
R_OK = 0
W_OK = 0
X_OK = 0
class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]):
def copy(self) -> Dict[AnyStr, AnyStr]: ...
environ = ... # type: _Environ[str]
environb = ... # type: _Environ[bytes]
confstr_names = ... # type: Dict[str, int] # Unix only
pathconf_names = ... # type: Dict[str, int] # Unix only
sysconf_names = ... # type: Dict[str, int] # Unix only
EX_OK = 0 # Unix only
EX_USAGE = 0 # Unix only
EX_DATAERR = 0 # Unix only
EX_NOINPUT = 0 # Unix only
EX_NOUSER = 0 # Unix only
EX_NOHOST = 0 # Unix only
EX_UNAVAILABLE = 0 # Unix only
EX_SOFTWARE = 0 # Unix only
EX_OSERR = 0 # Unix only
EX_OSFILE = 0 # Unix only
EX_CANTCREAT = 0 # Unix only
EX_IOERR = 0 # Unix only
EX_TEMPFAIL = 0 # Unix only
EX_PROTOCOL = 0 # Unix only
EX_NOPERM = 0 # Unix only
EX_CONFIG = 0 # Unix only
EX_NOTFOUND = 0 # Unix only
P_NOWAIT = 0
P_NOWAITO = 0
P_WAIT = 0
# P_DETACH = 0 # Windows only
# P_OVERLAY = 0 # Windows only
# wait()/waitpid() options
WNOHANG = 0 # Unix only
# WCONTINUED = 0 # some Unix systems
# WUNTRACED = 0 # Unix only
TMP_MAX = 0 # Undocumented, but used by tempfile
# ----- os classes (structures) -----
if sys.version_info >= (3, 6):
class PathLike:
def __fspath__(self) -> AnyStr: ...
if sys.version_info >= (3, 5):
class DirEntry:
# This is what the scandir interator yields
# The constructor is hidden
name = ''
path = ''
def inode(self) -> int: ...
def is_dir(self, follow_symlinks: bool = ...) -> bool: ...
def is_file(self, follow_symlinks: bool = ...) -> bool: ...
def is_symlink(self) -> bool: ...
def stat(self) -> stat_result: ...
class stat_result:
# For backward compatibility, the return value of stat() is also
# accessible as a tuple of at least 10 integers giving the most important
# (and portable) members of the stat structure, in the order st_mode,
# st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime, st_mtime,
# st_ctime. More items may be added at the end by some implementations.
st_mode = 0 # protection bits,
st_ino = 0 # inode number,
st_dev = 0 # device,
st_nlink = 0 # number of hard links,
st_uid = 0 # user id of owner,
st_gid = 0 # group id of owner,
st_size = 0 # size of file, in bytes,
st_atime = 0.0 # time of most recent access,
st_mtime = 0.0 # time of most recent content modification,
st_ctime = 0.0 # platform dependent (time of most recent metadata change on Unix, or the time of creation on Windows)
if sys.version_info >= (3, 3):
st_atime_ns = 0 # time of most recent access, in nanoseconds
st_mtime_ns = 0 # time of most recent content modification in nanoseconds
st_ctime_ns = 0 # platform dependent (time of most recent metadata change on Unix, or the time of creation on Windows) in nanoseconds
# not documented
def __init__(self, tuple: Tuple[int, ...]) -> None: ...
# On some Unix systems (such as Linux), the following attributes may also
# be available:
st_blocks = 0 # number of blocks allocated for file
st_blksize = 0 # filesystem blocksize
st_rdev = 0 # type of device if an inode device
st_flags = 0 # user defined flags for file
# On other Unix systems (such as FreeBSD), the following attributes may be
# available (but may be only filled out if root tries to use them):
st_gen = 0 # file generation number
st_birthtime = 0 # time of file creation
# On Mac OS systems, the following attributes may also be available:
st_rsize = 0
st_creator = 0
st_type = 0
class statvfs_result: # Unix only
f_bsize = 0
f_frsize = 0
f_blocks = 0
f_bfree = 0
f_bavail = 0
f_files = 0
f_ffree = 0
f_favail = 0
f_flag = 0
f_namemax = 0
# ----- os function stubs -----
def fsencode(filename: str) -> bytes: ...
def fsdecode(filename: bytes) -> str: ...
def get_exec_path(env: Optional[Mapping[str, str]] = ...) -> List[str]: ...
# NOTE: get_exec_path(): returns List[bytes] when env not None
def ctermid() -> str: ... # Unix only
def getegid() -> int: ... # Unix only
def geteuid() -> int: ... # Unix only
def getgid() -> int: ... # Unix only
def getgroups() -> List[int]: ... # Unix only, behaves differently on Mac
def initgroups(username: str, gid: int) -> None: ... # Unix only
def getlogin() -> str: ...
def getpgid(pid: int) -> int: ... # Unix only
def getpgrp() -> int: ... # Unix only
def getpid() -> int: ...
def getppid() -> int: ...
def getresuid() -> Tuple[int, int, int]: ... # Unix only
def getresgid() -> Tuple[int, int, int]: ... # Unix only
def getuid() -> int: ... # Unix only
def getenv(key: str, default: str = ...) -> str: ...
def getenvb(key: bytes, default: bytes = ...) -> bytes: ...
# TODO mixed str/bytes putenv arguments
def putenv(key: AnyStr, value: AnyStr) -> None: ...
def setegid(egid: int) -> None: ... # Unix only
def seteuid(euid: int) -> None: ... # Unix only
def setgid(gid: int) -> None: ... # Unix only
def setgroups(groups: List[int]) -> None: ... # Unix only
def setpgrp() -> int: ... # Unix only
def setpgid(pid: int, pgrp: int) -> int: ... # Unix only
def setregid(rgid: int, egid: int) -> None: ... # Unix only
def setresgid(rgid: int, egid: int, sgid: int) -> None: ... # Unix only
def setresuid(ruid: int, euid: int, suid: int) -> None: ... # Unix only
def setreuid(ruid: int, euid: int) -> None: ... # Unix only
def getsid(pid: int) -> int: ... # Unix only
def setsid() -> int: ... # Unix only
def setuid(uid: int) -> None: ... # Unix only
def strerror(code: int) -> str: ...
def umask(mask: int) -> int: ...
def uname() -> Tuple[str, str, str, str, str]: ... # Unix only
def unsetenv(key: AnyStr) -> None: ...
# Return IO or TextIO
def fdopen(fd: int, mode: str = ..., buffering: int = ..., encoding: str = ...,
errors: str = ..., newline: str = ..., closefd: bool = ...) -> Any: ...
def close(fd: int) -> None: ...
def closerange(fd_low: int, fd_high: int) -> None: ...
def device_encoding(fd: int) -> Optional[str]: ...
def dup(fd: int) -> int: ...
def dup2(fd: int, fd2: int) -> None: ...
def fchmod(fd: int, mode: int) -> None: ... # Unix only
def fchown(fd: int, uid: int, gid: int) -> None: ... # Unix only
def fdatasync(fd: int) -> None: ... # Unix only, not Mac
def fpathconf(fd: int, name: str) -> int: ... # Unix only
def fstat(fd: int) -> stat_result: ...
def fstatvfs(fd: int) -> statvfs_result: ... # Unix only
def fsync(fd: int) -> None: ...
def ftruncate(fd: int, length: int) -> None: ... # Unix only
def isatty(fd: int) -> bool: ... # Unix only
def lseek(fd: int, pos: int, how: int) -> int: ...
def open(file: AnyStr, flags: int, mode: int = ...) -> int: ...
def openpty() -> Tuple[int, int]: ... # some flavors of Unix
def pipe() -> Tuple[int, int]: ...
def read(fd: int, n: int) -> bytes: ...
def tcgetpgrp(fd: int) -> int: ... # Unix only
def tcsetpgrp(fd: int, pg: int) -> None: ... # Unix only
def ttyname(fd: int) -> str: ... # Unix only
def write(fd: int, string: bytes) -> int: ...
def access(path: AnyStr, mode: int) -> bool: ...
def chdir(path: AnyStr) -> None: ...
def fchdir(fd: int) -> None: ...
def getcwd() -> str: ...
def getcwdb() -> bytes: ...
def chflags(path: str, flags: int) -> None: ... # Unix only
def chroot(path: str) -> None: ... # Unix only
def chmod(path: AnyStr, mode: int) -> None: ...
def chown(path: AnyStr, uid: int, gid: int) -> None: ... # Unix only
def lchflags(path: str, flags: int) -> None: ... # Unix only
def lchmod(path: str, mode: int) -> None: ... # Unix only
def lchown(path: str, uid: int, gid: int) -> None: ... # Unix only
def link(src: AnyStr, link_name: AnyStr) -> None: ...
@overload
def listdir(path: str = ...) -> List[str]: ...
@overload
def listdir(path: bytes) -> List[bytes]: ...
def lstat(path: AnyStr) -> stat_result: ...
def mkfifo(path: str, mode: int = ...) -> None: ... # Unix only
def mknod(filename: AnyStr, mode: int = ..., device: int = ...) -> None: ...
def major(device: int) -> int: ...
def minor(device: int) -> int: ...
def makedev(major: int, minor: int) -> int: ...
def mkdir(path: AnyStr, mode: int = ...) -> None: ...
def makedirs(path: AnyStr, mode: int = ...,
exist_ok: bool = ...) -> None: ...
def pathconf(path: str, name: str) -> int: ... # Unix only
def readlink(path: AnyStr) -> AnyStr: ...
def remove(path: AnyStr) -> None: ...
def removedirs(path: AnyStr) -> None: ...
def rename(src: AnyStr, dst: AnyStr) -> None: ...
def renames(old: AnyStr, new: AnyStr) -> None: ...
if sys.version_info >= (3, 3):
def replace(src: AnyStr, dst: AnyStr) -> None: ...
def rmdir(path: AnyStr) -> None: ...
if sys.version_info >= (3, 5):
@overload
def scandir(path: str = ...) -> Iterator[DirEntry]: ...
@overload
def scandir(path: bytes) -> Iterator[DirEntry]: ...
def stat(path: AnyStr) -> stat_result: ...
def stat_float_times(newvalue: Union[bool, None] = ...) -> bool: ...
def statvfs(path: str) -> statvfs_result: ... # Unix only
def symlink(source: AnyStr, link_name: AnyStr,
target_is_directory: bool = ...) -> None:
... # final argument in Windows only
def unlink(path: AnyStr) -> None: ...
def utime(path: AnyStr, times: Union[Tuple[int, int], Tuple[float, float]] = ...) -> None: ...
# TODO onerror: function from OSError to void
def walk(top: AnyStr, topdown: bool = ..., onerror: Any = ...,
followlinks: bool = ...) -> Iterator[Tuple[AnyStr, List[AnyStr],
List[AnyStr]]]: ...
def abort() -> 'None': ...
def execl(path: AnyStr, arg0: AnyStr, *args: AnyStr) -> None: ...
def execle(path: AnyStr, arg0: AnyStr,
*args: Any) -> None: ... # Imprecise signature
def execlp(path: AnyStr, arg0: AnyStr, *args: AnyStr) -> None: ...
def execlpe(path: AnyStr, arg0: AnyStr,
*args: Any) -> None: ... # Imprecise signature
def execv(path: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]]) -> None: ...
def execve(path: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]], env: Mapping[AnyStr, AnyStr]) -> None: ...
def execvp(file: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]]) -> None: ...
def execvpe(file: AnyStr, args: Union[Tuple[AnyStr], List[AnyStr]],
env: Mapping[str, str]) -> None: ...
def _exit(n: int) -> NoReturn: ...
def fork() -> int: ... # Unix only
def forkpty() -> Tuple[int, int]: ... # some flavors of Unix
def kill(pid: int, sig: int) -> None: ...
def killpg(pgid: int, sig: int) -> None: ... # Unix only
def nice(increment: int) -> int: ... # Unix only
def plock(op: int) -> None: ... # Unix only ???op is int?
class popen(_TextIOWrapper):
# TODO 'b' modes or bytes command not accepted?
def __init__(self, command: str, mode: str = ...,
bufsize: int = ...) -> None: ...
def close(self) -> Any: ... # may return int
def spawnl(mode: int, path: AnyStr, arg0: AnyStr, *args: AnyStr) -> int: ...
def spawnle(mode: int, path: AnyStr, arg0: AnyStr,
*args: Any) -> int: ... # Imprecise sig
def spawnlp(mode: int, file: AnyStr, arg0: AnyStr,
*args: AnyStr) -> int: ... # Unix only TODO
def spawnlpe(mode: int, file: AnyStr, arg0: AnyStr, *args: Any) -> int:
... # Imprecise signature; Unix only TODO
def spawnv(mode: int, path: AnyStr, args: List[AnyStr]) -> int: ...
def spawnve(mode: int, path: AnyStr, args: List[AnyStr],
env: Mapping[str, str]) -> int: ...
def spawnvp(mode: int, file: AnyStr, args: List[AnyStr]) -> int: ... # Unix only
def spawnvpe(mode: int, file: AnyStr, args: List[AnyStr],
env: Mapping[str, str]) -> int:
... # Unix only
def startfile(path: str, operation: Union[str, None] = ...) -> None: ... # Windows only
def system(command: AnyStr) -> int: ...
def times() -> Tuple[float, float, float, float, float]: ...
def wait() -> Tuple[int, int]: ... # Unix only
def waitpid(pid: int, options: int) -> Tuple[int, int]: ...
def wait3(options: Union[int, None] = ...) -> Tuple[int, int, Any]: ... # Unix only
def wait4(pid: int, options: int) -> Tuple[int, int, Any]:
... # Unix only
def WCOREDUMP(status: int) -> bool: ... # Unix only
def WIFCONTINUED(status: int) -> bool: ... # Unix only
def WIFSTOPPED(status: int) -> bool: ... # Unix only
def WIFSIGNALED(status: int) -> bool: ... # Unix only
def WIFEXITED(status: int) -> bool: ... # Unix only
def WEXITSTATUS(status: int) -> bool: ... # Unix only
def WSTOPSIG(status: int) -> bool: ... # Unix only
def WTERMSIG(status: int) -> bool: ... # Unix only
def confstr(name: str) -> str: ... # Unix only
def getloadavg() -> Tuple[float, float, float]: ... # Unix only
def sysconf(name: str) -> int: ... # Unix only
def urandom(n: int) -> bytes: ...
def sched_getaffinity(id: int) -> Set[int]: ...
class waitresult:
si_pid = 0
def waitid(idtype: int, id: int, options: int) -> waitresult: ...
P_ALL = 0
WEXITED = 0
WNOWAIT = 0
if sys.version_info >= (3, 3):
def sync() -> None: ... # Unix only
def truncate(path: Union[AnyStr, int], length: int) -> None: ... # Unix only up to version 3.4
def fwalk(top: AnyStr = ..., topdown: bool = ...,
onerror: Callable = ..., *, follow_symlinks: bool = ...,
dir_fd: int = ...) -> Iterator[Tuple[AnyStr, List[AnyStr],
List[AnyStr], int]]: ... # Unix only
if sys.version_info >= (3, 4):
def cpu_count() -> Optional[int]: ...
mypy-0.470/typeshed/stdlib/3/ssl.pyi 0000644 0000000 0000000 00000027573 13035744274 016043 0 ustar root root # Stubs for ssl (Python 3.4)
from typing import (
Any, Dict, Callable, List, NamedTuple, Optional, Set, Tuple, Union,
)
import socket
import sys
_PCTRTT = Tuple[Tuple[str, str], ...]
_PCTRTTT = Tuple[_PCTRTT, ...]
_PeerCertRetDictType = Dict[str, Union[str, _PCTRTTT, _PCTRTT]]
_PeerCertRetType = Union[_PeerCertRetDictType, bytes, None]
_EnumRetType = List[Tuple[bytes, str, Union[Set[str], bool]]]
_PasswordType = Union[Callable[[], Union[str, bytes]], str, bytes]
if sys.version_info >= (3, 5):
_SC1ArgT = Union[SSLSocket, SSLObject]
else:
_SC1ArgT = SSLSocket
_SrvnmeCbType = Callable[[_SC1ArgT, Optional[str], 'SSLSocket'], Optional[int]]
class SSLError(OSError):
library = ... # type: str
reason = ... # type: str
class SSLZeroReturnError(SSLError): ...
class SSLWantReadError(SSLError): ...
class SSLWantWriteError(SSLError): ...
class SSLSyscallError(SSLError): ...
class SSLEOFError(SSLError): ...
class CertificateError(Exception): ...
def wrap_socket(sock: socket.socket, keyfile: Optional[str] = ...,
certfile: Optional[str] = ..., server_side: bool = ...,
cert_reqs: int = ..., ssl_version: int = ...,
ca_certs: Optional[str] = ...,
do_handshake_on_connect: bool = ...,
suppress_ragged_eofs: bool = ...,
ciphers: Optional[str] = ...) -> 'SSLSocket': ...
if sys.version_info >= (3, 4):
def create_default_context(purpose: Any = ..., *,
cafile: Optional[str] = ...,
capath: Optional[str] = ...,
cadata: Optional[str] = ...) -> 'SSLContext': ...
if sys.version_info >= (3, 4, 3):
def _create_unverified_context(protocol: int = ..., *,
cert_reqs: int = ...,
check_hostname: bool = ...,
purpose: Any = ...,
certfile: Optional[str] = ...,
keyfile: Optional[str] = ...,
cafile: Optional[str] = ...,
capath: Optional[str] = ...,
cadata: Optional[str] = ...) -> 'SSLContext': ...
_create_default_https_context = ... # type: Callable[..., 'SSLContext']
def RAND_bytes(num: int) -> bytes: ...
def RAND_pseudo_bytes(num: int) -> Tuple[bytes, bool]: ...
def RAND_status() -> bool: ...
def RAND_egd(path: str) -> None: ...
def RAND_add(bytes: bytes, entropy: float) -> None: ...
def match_hostname(cert: _PeerCertRetType, hostname: str) -> None: ...
def cert_time_to_seconds(cert_time: str) -> int: ...
def get_server_certificate(addr: Tuple[str, int], ssl_version: int = ...,
ca_certs: Optional[str] = ...) -> str: ...
def DER_cert_to_PEM_cert(der_cert_bytes: bytes) -> str: ...
def PEM_cert_to_DER_cert(pem_cert_string: str) -> bytes: ...
if sys.version_info >= (3, 4):
DefaultVerifyPaths = NamedTuple('DefaultVerifyPaths',
[('cafile', str), ('capath', str),
('openssl_cafile_env', str),
('openssl_cafile', str),
('openssl_capath_env', str),
('openssl_capath', str)])
def get_default_verify_paths() -> DefaultVerifyPaths: ...
if sys.version_info >= (3, 4) and sys.platform == 'win32':
def enum_certificates(store_name: str) -> _EnumRetType: ...
def enum_crls(store_name: str) -> _EnumRetType: ...
CERT_NONE = ... # type: int
CERT_OPTIONAL = ... # type: int
CERT_REQUIRED = ... # type: int
if sys.version_info >= (3, 4):
VERIFY_DEFAULT = ... # type: int
VERIFY_CRL_CHECK_LEAF = ... # type: int
VERIFY_CRL_CHECK_CHAIN = ... # type: int
VERIFY_X509_STRICT = ... # type: int
if sys.version_info >= (3, 4, 4):
VERIFY_X509_TRUSTED_FIRST = ... # type: int
PROTOCOL_SSLv23 = ... # type: int
PROTOCOL_SSLv2 = ... # type: int
PROTOCOL_SSLv3 = ... # type: int
PROTOCOL_TLSv1 = ... # type: int
if sys.version_info >= (3, 4):
PROTOCOL_TLSv1_1 = ... # type: int
PROTOCOL_TLSv1_2 = ... # type: int
OP_ALL = ... # type: int
OP_NO_SSLv2 = ... # type: int
OP_NO_SSLv3 = ... # type: int
OP_NO_TLSv1 = ... # type: int
if sys.version_info >= (3, 4):
OP_NO_TLSv1_1 = ... # type: int
OP_NO_TLSv1_2 = ... # type: int
OP_CIPHER_SERVER_PREFERENCE = ... # type: int
OP_SINGLE_DH_USE = ... # type: int
OP_SINGLE_ECDH_USE = ... # type: int
OP_NO_COMPRESSION = ... # type: int
if sys.version_info >= (3, 5):
HAS_ALPN = ... # type: int
HAS_ECDH = ... # type: bool
HAS_SNI = ... # type: bool
HAS_NPN = ... # type: bool
CHANNEL_BINDING_TYPES = ... # type: List[str]
OPENSSL_VERSION = ... # type: str
OPENSSL_VERSION_INFO = ... # type: Tuple[int, int, int, int, int]
OPENSSL_VERSION_NUMBER = ... # type: int
if sys.version_info >= (3, 4):
ALERT_DESCRIPTION_HANDSHAKE_FAILURE = ... # type: int
ALERT_DESCRIPTION_INTERNAL_ERROR = ... # type: int
ALERT_DESCRIPTION_ACCESS_DENIED = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE = ... # type: int
ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE = ... # type: int
ALERT_DESCRIPTION_BAD_RECORD_MAC = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_EXPIRED = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_REVOKED = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN = ... # type: int
ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE = ... # type: int
ALERT_DESCRIPTION_CLOSE_NOTIFY = ... # type: int
ALERT_DESCRIPTION_DECODE_ERROR = ... # type: int
ALERT_DESCRIPTION_DECOMPRESSION_FAILURE = ... # type: int
ALERT_DESCRIPTION_DECRYPT_ERROR = ... # type: int
ALERT_DESCRIPTION_ILLEGAL_PARAMETER = ... # type: int
ALERT_DESCRIPTION_INSUFFICIENT_SECURITY = ... # type: int
ALERT_DESCRIPTION_NO_RENEGOTIATION = ... # type: int
ALERT_DESCRIPTION_PROTOCOL_VERSION = ... # type: int
ALERT_DESCRIPTION_RECORD_OVERFLOW = ... # type: int
ALERT_DESCRIPTION_UNEXPECTED_MESSAGE = ... # type: int
ALERT_DESCRIPTION_UNKNOWN_CA = ... # type: int
ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY = ... # type: int
ALERT_DESCRIPTION_UNRECOGNIZED_NAME = ... # type: int
ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE = ... # type: int
ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION = ... # type: int
ALERT_DESCRIPTION_USER_CANCELLED = ... # type: int
if sys.version_info >= (3, 4):
_PurposeType = NamedTuple('_PurposeType',
[('nid', int), ('shortname', str),
('longname', str), ('oid', str)])
class Purpose:
SERVER_AUTH = ... # type: _PurposeType
CLIENT_AUTH = ... # type: _PurposeType
class SSLSocket(socket.socket):
context = ... # type: SSLContext
server_side = ... # type: bool
server_hostname = ... # type: Optional[str]
def read(self, len: int = ...,
buffer: Optional[bytearray] = ...) -> bytes: ...
def write(self, buf: bytes) -> int: ...
def do_handshake(self) -> None: ...
def getpeercert(self, binary_form: bool = ...) -> _PeerCertRetType: ...
def cipher(self) -> Tuple[str, int, int]: ...
if sys.version_info >= (3, 5):
def shared_cipher(self) -> Optional[List[Tuple[str, int, int]]]: ...
def compression(self) -> Optional[str]: ...
def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ...
if sys.version_info >= (3, 5):
def selected_alpn_protocol(self) -> Optional[str]: ...
def selected_npn_protocol(self) -> Optional[str]: ...
def unwrap(self) -> socket.socket: ...
if sys.version_info >= (3, 5):
def version(self) -> Optional[str]: ...
def pending(self) -> int: ...
class SSLContext:
if sys.version_info >= (3, 4):
check_hostname = ... # type: bool
options = ... # type: int
@property
def protocol(self) -> int: ...
if sys.version_info >= (3, 4):
verify_flags = ... # type: int
verify_mode = ... # type: int
def __init__(self, protocol: int) -> None: ...
if sys.version_info >= (3, 4):
def cert_store_stats(self) -> Dict[str, int]: ...
def load_cert_chain(self, certfile: str, keyfile: Optional[str] = ...,
password: _PasswordType = ...) -> None: ...
if sys.version_info >= (3, 4):
def load_default_certs(self, purpose: _PurposeType = ...) -> None: ...
def load_verify_locations(self, cafile: Optional[str] = ...,
capath: Optional[str] = ...,
cadata: Union[str, bytes, None] = ...) \
-> None: ...
def get_ca_certs(self,
binary_form: bool = ...) \
-> Union[List[_PeerCertRetDictType], List[bytes]]: ...
else:
def load_verify_locations(self,
cafile: Optional[str] = ...,
capath: Optional[str] = ...) -> None: ...
def set_default_verify_paths(self) -> None: ...
def set_ciphers(self, ciphers: str) -> None: ...
if sys.version_info >= (3, 5):
def set_alpn_protocols(self, protocols: List[str]) -> None: ...
def set_npn_protocols(self, protocols: List[str]) -> None: ...
def set_servername_callback(self,
server_name_callback: Optional[_SrvnmeCbType]) \
-> None: ...
def load_dh_params(self, dhfile: str) -> None: ...
def set_ecdh_curve(self, curve_name: str) -> None: ...
def wrap_socket(self, sock: socket.socket, server_side: bool = ...,
do_handshake_on_connect: bool = ...,
suppress_ragged_eofs: bool = ...,
server_hostname: Optional[str] = ...) -> 'SSLContext': ...
if sys.version_info >= (3, 5):
def wrap_bio(self, incoming: 'MemoryBIO', outgoing: 'MemoryBIO',
server_side: bool = ...,
server_hostname: Optional[str] = ...) -> 'SSLObject': ...
def session_stats(self) -> Dict[str, int]: ...
if sys.version_info >= (3, 5):
class SSLObject:
context = ... # type: SSLContext
server_side = ... # type: bool
server_hostname = ... # type: Optional[str]
def read(self, len: int = ...,
buffer: Optional[bytearray] = ...) -> bytes: ...
def write(self, buf: bytes) -> int: ...
def getpeercert(self, binary_form: bool = ...) -> _PeerCertRetType: ...
def selected_npn_protocol(self) -> Optional[str]: ...
def cipher(self) -> Tuple[str, int, int]: ...
def shared_cipher(self) -> Optional[List[Tuple[str, int, int]]]: ...
def compression(self) -> Optional[str]: ...
def pending(self) -> int: ...
def do_handshake(self) -> None: ...
def unwrap(self) -> None: ...
def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ...
class MemoryBIO:
pending = ... # type: int
eof = ... # type: bool
def read(self, n: int = ...) -> bytes: ...
def write(self, buf: bytes) -> int: ...
def write_eof(self) -> None: ...
# TODO below documented in cpython but not in docs.python.org
# taken from python 3.4
SSL_ERROR_EOF = ... # type: int
SSL_ERROR_INVALID_ERROR_CODE = ... # type: int
SSL_ERROR_SSL = ... # type: int
SSL_ERROR_SYSCALL = ... # type: int
SSL_ERROR_WANT_CONNECT = ... # type: int
SSL_ERROR_WANT_READ = ... # type: int
SSL_ERROR_WANT_WRITE = ... # type: int
SSL_ERROR_WANT_X509_LOOKUP = ... # type: int
SSL_ERROR_ZERO_RETURN = ... # type: int
def get_protocol_name(protocol_code: int) -> str: ...
AF_INET = ... # type: int
PEM_FOOTER = ... # type: str
PEM_HEADER = ... # type: str
SOCK_STREAM = ... # type: int
SOL_SOCKET = ... # type: int
SO_TYPE = ... # type: int
mypy-0.470/typeshed/stdlib/3/select.pyi 0000644 0000000 0000000 00000001340 13023631176 016472 0 ustar root root # Stubs for select
# NOTE: These are incomplete!
from typing import Any, Tuple, List, Sequence
class error(Exception): ...
POLLIN = 0
POLLPRI = 0
POLLOUT = 0
POLLERR = 0
POLLHUP = 0
POLLNVAL = 0
class poll:
def __init__(self) -> None: ...
def register(self, fd: Any,
eventmask: int = ...) -> None: ...
def modify(self, fd: Any, eventmask: int) -> None: ...
def unregister(self, fd: Any) -> None: ...
def poll(self, timeout: int = ...) -> List[Tuple[int, int]]: ...
def select(rlist: Sequence, wlist: Sequence, xlist: Sequence,
timeout: float = ...) -> Tuple[List[Any],
List[Any],
List[Any]]: ...
mypy-0.470/typeshed/stdlib/3/platform.pyi 0000644 0000000 0000000 00000003534 13035744274 017055 0 ustar root root # Stubs for platform (Python 3.5)
from os import devnull as DEV_NULL
from os import popen
from typing import Tuple, NamedTuple
def libc_ver(executable: str = ..., lib: str = ..., version: str = ..., chunksize: int = ...) -> Tuple[str, str]: ...
def linux_distribution(distname: str = ..., version: str = ..., id: str = ..., supported_dists: Tuple[str, ...] = ..., full_distribution_name: bool = ...) -> Tuple[str, str, str]: ...
def dist(distname: str = ..., version: str = ..., id: str = ..., supported_dists: Tuple[str, ...] = ...) -> Tuple[str, str, str]: ...
def win32_ver(release: str = ..., version: str = ..., csd: str = ..., ptype: str = ...) -> Tuple[str, str, str, str]: ...
def mac_ver(release: str = ..., versioninfo: Tuple[str, str, str] = ..., machine: str = ...) -> Tuple[str, Tuple[str, str, str], str]: ...
def java_ver(release: str = ..., vendor: str = ..., vminfo: Tuple[str, str, str] = ..., osinfo: Tuple[str, str, str] = ...) -> Tuple[str, str, Tuple[str, str, str], Tuple[str, str, str]]: ...
def system_alias(system: str, release: str, version: str) -> Tuple[str, str, str]: ...
def architecture(executable: str = ..., bits: str = ..., linkage: str = ...) -> Tuple[str, str]: ...
uname_result = NamedTuple('uname_result', [('system', str), ('node', str), ('release', str), ('version', str), ('machine', str), ('processor', str)])
def uname() -> uname_result: ...
def system() -> str: ...
def node() -> str: ...
def release() -> str: ...
def version() -> str: ...
def machine() -> str: ...
def processor() -> str: ...
def python_implementation() -> str: ...
def python_version() -> str: ...
def python_version_tuple() -> Tuple[str, str, str]: ...
def python_branch() -> str: ...
def python_revision() -> str: ...
def python_build() -> Tuple[str, str]: ...
def python_compiler() -> str: ...
def platform(aliased: bool = ..., terse: bool = ...) -> str: ...
mypy-0.470/typeshed/stdlib/3/random.pyi 0000644 0000000 0000000 00000005764 13023631176 016511 0 ustar root root # Stubs for random
# Ron Murawski
# Updated by Jukka Lehtosalo
# based on http://docs.python.org/3.2/library/random.html
# ----- random classes -----
import _random
from typing import (
Any, TypeVar, Sequence, List, Callable, AbstractSet, Union
)
_T = TypeVar('_T')
class Random(_random.Random):
def __init__(self, x: Any = ...) -> None: ...
def seed(self, a: Any = ..., version: int = ...) -> None: ...
def getstate(self) -> tuple: ...
def setstate(self, state: tuple) -> None: ...
def getrandbits(self, k: int) -> int: ...
def randrange(self, start: int, stop: Union[int, None] = ..., step: int = ...) -> int: ...
def randint(self, a: int, b: int) -> int: ...
def choice(self, seq: Sequence[_T]) -> _T: ...
def shuffle(self, x: List[Any], random: Union[Callable[[], float], None] = ...) -> None: ...
def sample(self, population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random(self) -> float: ...
def uniform(self, a: float, b: float) -> float: ...
def triangular(self, low: float = ..., high: float = ...,
mode: float = ...) -> float: ...
def betavariate(self, alpha: float, beta: float) -> float: ...
def expovariate(self, lambd: float) -> float: ...
def gammavariate(self, alpha: float, beta: float) -> float: ...
def gauss(self, mu: float, sigma: float) -> float: ...
def lognormvariate(self, mu: float, sigma: float) -> float: ...
def normalvariate(self, mu: float, sigma: float) -> float: ...
def vonmisesvariate(self, mu: float, kappa: float) -> float: ...
def paretovariate(self, alpha: float) -> float: ...
def weibullvariate(self, alpha: float, beta: float) -> float: ...
# SystemRandom is not implemented for all OS's; good on Windows & Linux
class SystemRandom(Random):
...
# ----- random function stubs -----
def seed(a: Any = ..., version: int = ...) -> None: ...
def getstate() -> object: ...
def setstate(state: object) -> None: ...
def getrandbits(k: int) -> int: ...
def randrange(start: int, stop: Union[None, int] = ..., step: int = ...) -> int: ...
def randint(a: int, b: int) -> int: ...
def choice(seq: Sequence[_T]) -> _T: ...
def shuffle(x: List[Any], random: Union[Callable[[], float], None] = ...) -> None: ...
def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random() -> float: ...
def uniform(a: float, b: float) -> float: ...
def triangular(low: float = ..., high: float = ...,
mode: float = ...) -> float: ...
def betavariate(alpha: float, beta: float) -> float: ...
def expovariate(lambd: float) -> float: ...
def gammavariate(alpha: float, beta: float) -> float: ...
def gauss(mu: float, sigma: float) -> float: ...
def lognormvariate(mu: float, sigma: float) -> float: ...
def normalvariate(mu: float, sigma: float) -> float: ...
def vonmisesvariate(mu: float, kappa: float) -> float: ...
def paretovariate(alpha: float) -> float: ...
def weibullvariate(alpha: float, beta: float) -> float: ...
mypy-0.470/typeshed/stdlib/3/socketserver.pyi 0000644 0000000 0000000 00000006754 13023631176 017750 0 ustar root root # Stubs for socketserver
from typing import Any, BinaryIO, Optional, Tuple
from socket import SocketType
import sys
import types
class BaseServer:
address_family = ... # type: int
RequestHandlerClass = ... # type: type
server_address = ... # type: Tuple[str, int]
socket = ... # type: SocketType
allow_reuse_address = ... # type: bool
request_queue_size = ... # type: int
socket_type = ... # type: int
timeout = ... # type: Optional[float]
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type) -> None: ...
def fileno(self) -> int: ...
def handle_request(self) -> None: ...
def serve_forever(self, poll_interval: float = ...) -> None: ...
def shutdown(self) -> None: ...
def server_close(self) -> None: ...
def finish_request(self) -> None: ...
def get_request(self) -> None: ...
def handle_error(self, request: bytes,
client_address: Tuple[str, int]) -> None: ...
def handle_timeout(self) -> None: ...
def process_request(self, request: bytes,
client_address: Tuple[str, int]) -> None: ...
def server_activate(self) -> None: ...
def server_bind(self) -> None: ...
def verify_request(self, request: bytes,
client_address: Tuple[str, int]) -> bool: ...
if sys.version_info >= (3, 6):
def __enter__(self) -> 'BaseServer': ...
def __exit__(self, exc_type: Optional[type],
exc_val: Optional[Exception],
exc_tb: Optional[types.TracebackType]) -> bool: ...
if sys.version_info >= (3, 3):
def service_actions(self) -> None: ...
class TCPServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UDPServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UnixStreamServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class UnixDatagramServer(BaseServer):
def __init__(self, server_address: Tuple[str, int],
RequestHandlerClass: type,
bind_and_activate: bool = ...) -> None: ...
class ForkingMixIn: ...
class ThreadingMixIn: ...
class ForkingTCPServer(ForkingMixIn, TCPServer): ...
class ForkingUDPServer(ForkingMixIn, UDPServer): ...
class ThreadingTCPServer(ThreadingMixIn, TCPServer): ...
class ThreadingUDPServer(ThreadingMixIn, UDPServer): ...
class BaseRequestHandler:
# Those are technically of types, respectively:
# * Union[SocketType, Tuple[bytes, SocketType]]
# * Union[Tuple[str, int], str]
# But there are some concerns that having unions here would cause
# too much inconvenience to people using it (see
# https://github.com/python/typeshed/pull/384#issuecomment-234649696)
request = ... # type: Any
client_address = ... # type: Any
server = ... # type: BaseServer
def setup(self) -> None: ...
def handle(self) -> None: ...
def finish(self) -> None: ...
class StreamRequestHandler(BaseRequestHandler):
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
class DatagramRequestHandler(BaseRequestHandler):
rfile = ... # type: BinaryIO
wfile = ... # type: BinaryIO
mypy-0.470/typeshed/stdlib/3/decimal.pyi 0000644 0000000 0000000 00000024305 13044257024 016616 0 ustar root root # Stubs for decimal (Python 3.4)
from typing import (
Any, Union, SupportsInt, SupportsFloat, SupportsAbs, SupportsRound, Sequence,
Tuple, NamedTuple, Dict
)
_Decimal = Union[Decimal, int]
_ComparableNum = Union[Decimal, int, float]
BasicContext = ... # type: Context
DefaultContext = ... # type: Context
ExtendedContext = ... # type: Context
HAVE_THREADS = ... # type: bool
MAX_EMAX = ... # type: int
MAX_PREC = ... # type: int
MIN_EMIN = ... # type: int
MIN_ETINY = ... # type: int
ROUND_05UP = ... # type: str
ROUND_CEILING = ... # type: str
ROUND_DOWN = ... # type: str
ROUND_FLOOR = ... # type: str
ROUND_HALF_DOWN = ... # type: str
ROUND_HALF_EVEN = ... # type: str
ROUND_HALF_UP = ... # type: str
ROUND_UP = ... # type: str
def getcontext() -> Context: ...
def localcontext(ctx: Context = ...) -> _ContextManager: ...
def setcontext(c: Context) -> None: ...
DecimalTuple = NamedTuple('DecimalTuple',
[('sign', int),
('digits', Sequence[int]), # TODO: Use Tuple[int, ...]
('exponent', int)])
class _ContextManager:
def __enter__(self) -> Context: ...
def __exit__(self, t, v, tb) -> None: ...
class Context:
Emax = ... # type: int
Emin = ... # type: int
capitals = ... # type: int
clamp = ... # type: int
prec = ... # type: int
rounding = ... # type: str
traps = ... # type: Dict[type, bool]
def __init__(self, prec: int = ..., rounding: str = ..., Emin: int = ..., Emax: int = ...,
capitals: int = ..., clamp: int = ..., flags=..., traps=...,
_ignored_flags=...) -> None: ...
def Etiny(self): ...
def Etop(self): ...
def abs(self, x: _Decimal) -> Decimal: ...
def add(self, x: _Decimal, y: _Decimal) -> Decimal: ...
def canonical(self, x): ...
def clear_flags(self): ...
def clear_traps(self): ...
def compare(self, x, y): ...
def compare_signal(self, x, y): ...
def compare_total(self, x, y): ...
def compare_total_mag(self, x, y): ...
def copy(self): ...
def copy_abs(self, x): ...
def copy_decimal(self, x): ...
def copy_negate(self, x): ...
def copy_sign(self, x, y): ...
def create_decimal(self, x): ...
def create_decimal_from_float(self, f): ...
def divide(self, x, y): ...
def divide_int(self, x, y): ...
def divmod(self, x, y): ...
def exp(self, x): ...
def fma(self, x, y, z): ...
def is_canonical(self, x): ...
def is_finite(self, x): ...
def is_infinite(self, x): ...
def is_nan(self, x): ...
def is_normal(self, x): ...
def is_qnan(self, x): ...
def is_signed(self, x): ...
def is_snan(self): ...
def is_subnormal(self, x): ...
def is_zero(self, x): ...
def ln(self, x): ...
def log10(self, x): ...
def logb(self, x): ...
def logical_and(self, x, y): ...
def logical_invert(self, x): ...
def logical_or(self, x, y): ...
def logical_xor(self, x, y): ...
def max(self, x, y): ...
def max_mag(self, x, y): ...
def min(self, x, y): ...
def min_mag(self, x, y): ...
def minus(self, x): ...
def multiply(self, x, y): ...
def next_minus(self, x): ...
def next_plus(self, x): ...
def next_toward(self, x): ...
def normalize(self, x): ...
def number_class(self, x): ...
def plus(self, x): ...
def power(self, x, y): ...
def quantize(self, x, y): ...
def radix(self): ...
def remainder(self, x, y): ...
def remainder_near(self, x, y): ...
def rotate(self, x, y): ...
def same_quantum(self, x, y): ...
def scaleb(self, x, y): ...
def shift(self, x, y): ...
def sqrt(self, x): ...
def subtract(self, x, y): ...
def to_eng_string(self, x): ...
def to_integral(self, x): ...
def to_integral_exact(self, x): ...
def to_integral_value(self, x): ...
def to_sci_string(self, x): ...
def __copy__(self) -> Context: ...
def __delattr__(self, name): ...
def __reduce__(self): ...
class ConversionSyntax(InvalidOperation): ...
class Decimal(SupportsInt, SupportsFloat, SupportsAbs[Decimal], SupportsRound[int]):
# TODO: SupportsCeil, SupportsFloor, SupportsTrunc?
def __init__(cls, value: Union[_Decimal, float, str,
Tuple[int, Sequence[int], int]] = ...,
context: Context = ...) -> None: ...
@property
def imag(self) -> Decimal: ...
@property
def real(self) -> Decimal: ...
def adjusted(self) -> int: ...
def as_tuple(self) -> DecimalTuple: ...
def canonical(self) -> Decimal: ...
def compare(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def compare_signal(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def compare_total(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def compare_total_mag(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def conjugate(self) -> Decimal: ...
def copy_abs(self) -> Decimal: ...
def copy_negate(self) -> Decimal: ...
def copy_sign(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def exp(self, context: Context = ...) -> Decimal: ...
def fma(self, other: _Decimal, third: _Decimal, context: Context = ...) -> Decimal: ...
@classmethod
def from_float(cls, f: float) -> Decimal: ...
def is_canonical(self) -> bool: ...
def is_finite(self) -> bool: ...
def is_infinite(self) -> bool: ...
def is_nan(self) -> bool: ...
def is_normal(self, context: Context = ...) -> bool: ...
def is_qnan(self) -> bool: ...
def is_signed(self) -> bool: ...
def is_snan(self) -> bool: ...
def is_subnormal(self, context: Context = ...) -> bool: ...
def is_zero(self) -> bool: ...
def ln(self, context: Context = ...) -> Decimal: ...
def log10(self, context: Context = ...) -> Decimal: ...
def logb(self, context: Context = ...) -> Decimal: ...
def logical_and(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def logical_invert(self, context: Context = ...) -> Decimal: ...
def logical_or(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def logical_xor(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def max(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def max_mag(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def min(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def min_mag(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def next_minus(self, context: Context = ...) -> Decimal: ...
def next_plus(self, context: Context = ...) -> Decimal: ...
def next_toward(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def normalize(self, context: Context = ...) -> Decimal: ...
def number_class(self, context: Context = ...) -> str: ...
def quantize(self, exp: _Decimal, rounding: str = ...,
context: Context = ...) -> Decimal: ...
def radix(self) -> Decimal: ...
def remainder_near(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def rotate(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def same_quantum(self, other: _Decimal, context: Context = ...) -> bool: ...
def scaleb(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def shift(self, other: _Decimal, context: Context = ...) -> Decimal: ...
def sqrt(self, context: Context = ...) -> Decimal: ...
def to_eng_string(self, context: Context = ...) -> str: ...
def to_integral(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def to_integral_exact(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def to_integral_value(self, rounding: str = ..., context: Context = ...) -> Decimal: ...
def __abs__(self) -> Decimal: ...
def __add__(self, other: _Decimal) -> Decimal: ...
def __bool__(self) -> bool: ...
def __ceil__(self) -> int: ...
def __complex__(self) -> complex: ...
def __copy__(self) -> Decimal: ...
def __deepcopy__(self) -> Decimal: ...
def __divmod__(self, other: _Decimal) -> Tuple[Decimal, Decimal]: ...
def __eq__(self, other: object) -> bool: ...
def __float__(self) -> float: ...
def __floor__(self) -> int: ...
def __floordiv__(self, other: _Decimal) -> Decimal: ...
def __format__(self, specifier, context=..., _localeconv=...) -> str: ...
def __ge__(self, other: _ComparableNum) -> bool: ...
def __gt__(self, other: _ComparableNum) -> bool: ...
def __hash__(self) -> int: ...
def __int__(self) -> int: ...
def __le__(self, other: _ComparableNum) -> bool: ...
def __lt__(self, other: _ComparableNum) -> bool: ...
def __mod__(self, other: _Decimal) -> Decimal: ...
def __mul__(self, other: _Decimal) -> Decimal: ...
def __ne__(self, other: object) -> bool: ...
def __neg__(self) -> Decimal: ...
def __pos__(self) -> Decimal: ...
def __pow__(self, other: _Decimal) -> Decimal: ...
def __radd__(self, other: int) -> Decimal: ...
def __rdivmod__(self, other: int) -> Tuple[Decimal, Decimal]: ...
def __reduce__(self): ...
def __rfloordiv__(self, other: int) -> Decimal: ...
def __rmod__(self, other: int) -> Decimal: ...
def __rmul__(self, other: int) -> Decimal: ...
def __round__(self, n=...) -> int: ...
def __rpow__(self, other: int) -> Decimal: ...
def __rsub__(self, other: int) -> Decimal: ...
def __rtruediv__(self, other: int) -> Decimal: ...
def __sizeof__(self) -> int: ...
def __sub__(self, other: _Decimal) -> Decimal: ...
def __truediv__(self, other: _Decimal) -> Decimal: ...
def __trunc__(self) -> int: ...
class DecimalException(ArithmeticError): ...
class Clamped(DecimalException): ...
class DivisionByZero(DecimalException, ZeroDivisionError): ...
class DivisionImpossible(InvalidOperation): ...
class DivisionUndefined(InvalidOperation, ZeroDivisionError): ...
class FloatOperation(DecimalException, TypeError): ...
class Inexact(DecimalException): ...
class InvalidContext(InvalidOperation): ...
class InvalidOperation(DecimalException): ...
class Overflow(Inexact, Rounded): ...
class Rounded(DecimalException): ...
class Subnormal(DecimalException): ...
class Underflow(Inexact, Rounded, Subnormal): ...
mypy-0.470/typeshed/stdlib/3/textwrap.pyi 0000644 0000000 0000000 00000006500 13035744274 017103 0 ustar root root # Better textwrap stubs hand-written by o11c.
# https://docs.python.org/3/library/textwrap.html
from typing import (
Callable,
List,
)
class TextWrapper:
def __init__(
self,
width: int = ...,
*,
initial_indent: str = ...,
subsequent_indent: str = ...,
expand_tabs: bool = ...,
tabsize: int = ...,
replace_whitespace: bool = ...,
fix_sentence_endings: bool = ...,
break_long_words: bool = ...,
break_on_hyphens: bool = ...,
drop_whitespace: bool = ...,
max_lines: int = ...,
placeholder: str = ...
) -> None:
self.width = width
self.initial_indent = initial_indent
self.subsequent_indent = subsequent_indent
self.expand_tabs = expand_tabs
self.tabsize = tabsize
self.replace_whitespace = replace_whitespace
self.fix_sentence_endings = fix_sentence_endings
self.break_long_words = break_long_words
self.break_on_hyphens = break_on_hyphens
self.drop_whitespace = drop_whitespace
self.max_lines = max_lines
self.placeholder = placeholder
# Private methods *are* part of the documented API for subclasses.
def _munge_whitespace(self, text: str) -> str:
...
def _split(self, text: str) -> List[str]:
...
def _fix_sentence_endings(self, chunks: List[str]) -> None:
...
def _handle_long_word(self, reversed_chunks: List[str], cur_line: List[str], cur_len: int, width: int) -> None:
...
def _wrap_chunks(self, chunks: List[str]) -> List[str]:
...
def _split_chunks(self, text: str) -> List[str]:
...
def wrap(self, text: str) -> List[str]:
...
def fill(self, text: str) -> str:
...
def wrap(
text: str = ...,
width: int = ...,
*,
initial_indent: str = ...,
subsequent_indent: str = ...,
expand_tabs: bool = ...,
tabsize: int = ...,
replace_whitespace: bool = ...,
fix_sentence_endings: bool = ...,
break_long_words: bool = ...,
break_on_hyphens: bool = ...,
drop_whitespace: bool = ...,
max_lines: int = ...,
placeholder: str = ...
) -> List[str]:
...
def fill(
text: str,
width: int = ...,
*,
initial_indent: str = ...,
subsequent_indent: str = ...,
expand_tabs: bool = ...,
tabsize: int = ...,
replace_whitespace: bool = ...,
fix_sentence_endings: bool = ...,
break_long_words: bool = ...,
break_on_hyphens: bool = ...,
drop_whitespace: bool = ...,
max_lines: int = ...,
placeholder: str = ...
):
...
def shorten(
text: str,
width: int,
*,
initial_indent: str = ...,
subsequent_indent: str = ...,
expand_tabs: bool = ...,
tabsize: int = ...,
replace_whitespace: bool = ...,
fix_sentence_endings: bool = ...,
break_long_words: bool = ...,
break_on_hyphens: bool = ...,
drop_whitespace: bool = ...,
# Omit `max_lines: int = None`, it is forced to 1 here.
placeholder: str = ...
):
...
def dedent(text: str) -> str:
...
def indent(text: str, prefix: str, predicate: Callable[[str], bool] = ...) -> str:
...
mypy-0.470/typeshed/stdlib/3/runpy.pyi 0000644 0000000 0000000 00000001145 13035744274 016402 0 ustar root root # Stubs for runpy (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _TempModule:
mod_name = ... # type: Any
module = ... # type: Any
def __init__(self, mod_name): ...
def __enter__(self): ...
def __exit__(self, *args): ...
class _ModifiedArgv0:
value = ... # type: Any
def __init__(self, value): ...
def __enter__(self): ...
def __exit__(self, *args): ...
def run_module(mod_name, init_globals=None, run_name=None, alter_sys=False): ...
def run_path(path_name, init_globals=None, run_name=None): ...
mypy-0.470/typeshed/stdlib/3/_codecs.pyi 0000644 0000000 0000000 00000007144 13035744274 016631 0 ustar root root """Stub file for the '_codecs' module."""
from typing import Any, AnyStr, Callable, Tuple, Optional, Dict
import codecs
# For convenience:
_Handler = Callable[[Exception], Tuple[str, int]]
def register(search_function: Callable[[str], Any]) -> None: ...
def register_error(errors: str, handler: _Handler) -> None: ...
def lookup(a: str) -> codecs.CodecInfo: ...
def lookup_error(a: str) -> _Handler: ...
def decode(obj: Any, encoding: str = ..., errors: str = ...) -> Any: ...
def encode(obj: Any, encoding: str = ..., errors: str = ...) -> Any: ...
def charmap_build(a: str) -> Dict[int, int]: ...
def ascii_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def ascii_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def charbuffer_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def charmap_decode(data: AnyStr, errors: str = ..., mapping: Optional[Dict[int, int]] = ...) -> Tuple[str, int]: ...
def charmap_encode(data: AnyStr, errors: str, mapping: Optional[Dict[int, int]] = ...) -> Tuple[bytes, int]: ...
def escape_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def escape_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def latin_1_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def latin_1_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def raw_unicode_escape_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def raw_unicode_escape_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def readbuffer_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def unicode_escape_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def unicode_escape_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def unicode_internal_decode(data: AnyStr, errors: str = ...) -> Tuple[str, int]: ...
def unicode_internal_encode(data: AnyStr, errors: str = ...) -> Tuple[bytes, int]: ...
def utf_16_be_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_be_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_16_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_16_ex_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_le_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_16_le_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_32_be_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_be_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_32_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_32_ex_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_le_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_32_le_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_7_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_7_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
def utf_8_decode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[str, int]: ...
def utf_8_encode(data: AnyStr, errors: str = ..., final: int = ...) -> Tuple[bytes, int]: ...
mypy-0.470/typeshed/stdlib/3/__future__.pyi 0000644 0000000 0000000 00000000754 13023631176 017331 0 ustar root root import sys
class _Feature:
def getOptionalRelease(self) -> sys._version_info: ...
def getMandatoryRelease(self) -> sys._version_info: ...
absolute_import = ... # type: _Feature
division = ... # type: _Feature
generators = ... # type: _Feature
nested_scopes = ... # type: _Feature
print_function = ... # type: _Feature
unicode_literals = ... # type: _Feature
with_statement = ... # type: _Feature
if sys.version_info[:2] >= (3, 5):
generator_stop = ... # type: _Feature
mypy-0.470/typeshed/stdlib/3/typing.pyi 0000644 0000000 0000000 00000036353 13044257024 016540 0 ustar root root # Stubs for typing
import sys
from abc import abstractmethod, ABCMeta
# Definitions of special type checking related constructs. Their definition
# are not used, so their value does not matter.
overload = object()
Any = object()
TypeVar = object()
Generic = object()
Tuple = object()
Callable = object()
Type = object()
_promote = object()
no_type_check = object()
class GenericMeta(type): ...
# Type aliases and type constructors
class TypeAlias:
# Class for defining generic aliases for library types.
def __init__(self, target_type: type) -> None: ...
def __getitem__(self, typeargs: Any) -> Any: ...
Union = TypeAlias(object)
Optional = TypeAlias(object)
List = TypeAlias(object)
Dict = TypeAlias(object)
DefaultDict = TypeAlias(object)
Set = TypeAlias(object)
# Predefined type variables.
AnyStr = TypeVar('AnyStr', str, bytes)
# Abstract base classes.
# These type variables are used by the container types.
_T = TypeVar('_T')
_S = TypeVar('_S')
_KT = TypeVar('_KT') # Key type.
_VT = TypeVar('_VT') # Value type.
_T_co = TypeVar('_T_co', covariant=True) # Any type covariant containers.
_V_co = TypeVar('_V_co', covariant=True) # Any type covariant containers.
_KT_co = TypeVar('_KT_co', covariant=True) # Key type covariant containers.
_VT_co = TypeVar('_VT_co', covariant=True) # Value type covariant containers.
_T_contra = TypeVar('_T_contra', contravariant=True) # Ditto contravariant.
class SupportsInt(metaclass=ABCMeta):
@abstractmethod
def __int__(self) -> int: ...
class SupportsFloat(metaclass=ABCMeta):
@abstractmethod
def __float__(self) -> float: ...
class SupportsComplex(metaclass=ABCMeta):
@abstractmethod
def __complex__(self) -> complex: pass
class SupportsBytes(metaclass=ABCMeta):
@abstractmethod
def __bytes__(self) -> bytes: pass
class SupportsAbs(Generic[_T]):
@abstractmethod
def __abs__(self) -> _T: ...
class SupportsRound(Generic[_T]):
@abstractmethod
def __round__(self, ndigits: int = ...) -> _T: ...
class Reversible(Generic[_T_co]):
@abstractmethod
def __reversed__(self) -> Iterator[_T_co]: ...
class Sized(metaclass=ABCMeta):
@abstractmethod
def __len__(self) -> int: ...
class Hashable(metaclass=ABCMeta):
# TODO: This is special, in that a subclass of a hashable class may not be hashable
# (for example, list vs. object). It's not obvious how to represent this. This class
# is currently mostly useless for static checking.
@abstractmethod
def __hash__(self) -> int: ...
class Iterable(Generic[_T_co]):
@abstractmethod
def __iter__(self) -> Iterator[_T_co]: ...
class Iterator(Iterable[_T_co], Generic[_T_co]):
@abstractmethod
def __next__(self) -> _T_co: ...
def __iter__(self) -> 'Iterator[_T_co]': ...
class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]):
@abstractmethod
def __next__(self) -> _T_co: ...
@abstractmethod
def send(self, value: _T_contra) -> _T_co: ...
@abstractmethod
def throw(self, typ: Type[BaseException], val: Optional[BaseException] = None,
# TODO: tb should be TracebackType but that's defined in types
tb: Any = None) -> None: ...
@abstractmethod
def close(self) -> None: ...
@abstractmethod
def __iter__(self) -> 'Generator[_T_co, _T_contra, _V_co]': ...
# TODO: Several types should only be defined if sys.python_version >= (3, 5):
# Awaitable, AsyncIterator, AsyncIterable, Coroutine, Collection, ContextManager.
# See https: //github.com/python/typeshed/issues/655 for why this is not easy.
class Awaitable(Generic[_T_co]):
@abstractmethod
def __await__(self) -> Generator[Any, None, _T_co]: ...
class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]):
@abstractmethod
def send(self, value: _T_contra) -> _T_co: ...
@abstractmethod
def throw(self, typ: Type[BaseException], val: Optional[BaseException] = None,
# TODO: tb should be TracebackType but that's defined in types
tb: Any = None) -> None: ...
@abstractmethod
def close(self) -> None: ...
# NOTE: This type does not exist in typing.py or PEP 484.
# The parameters corrrespond to Generator, but the 4th is the original type.
class AwaitableGenerator(Generator[_T_co, _T_contra, _V_co], Awaitable[_V_co],
Generic[_T_co, _T_contra, _V_co, _S]):
pass
class AsyncIterable(Generic[_T_co]):
@abstractmethod
def __anext__(self) -> Awaitable[_T_co]: ...
class AsyncIterator(AsyncIterable[_T_co],
Generic[_T_co]):
@abstractmethod
def __anext__(self) -> Awaitable[_T_co]: ...
def __aiter__(self) -> 'AsyncIterator[_T_co]': ...
class Container(Generic[_T_co]):
@abstractmethod
def __contains__(self, x: object) -> bool: ...
class Sequence(Iterable[_T_co], Container[_T_co], Sized, Reversible[_T_co], Generic[_T_co]):
@overload
@abstractmethod
def __getitem__(self, i: int) -> _T_co: ...
@overload
@abstractmethod
def __getitem__(self, s: slice) -> Sequence[_T_co]: ...
# Mixin methods
if sys.version_info >= (3, 5):
def index(self, x: Any, start: int = 0, end: int = 0) -> int: ...
else:
def index(self, x: Any) -> int: ...
def count(self, x: Any) -> int: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __reversed__(self) -> Iterator[_T_co]: ...
class MutableSequence(Sequence[_T], Generic[_T]):
@abstractmethod
def insert(self, index: int, object: _T) -> None: ...
@overload
@abstractmethod
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
@abstractmethod
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
@overload
@abstractmethod
def __delitem__(self, i: int) -> None: ...
@overload
@abstractmethod
def __delitem__(self, i: slice) -> None: ...
# Mixin methods
def append(self, object: _T) -> None: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def reverse(self) -> None: ...
def pop(self, index: int = ...) -> _T: ...
def remove(self, object: _T) -> None: ...
def __iadd__(self, x: Iterable[_T]) -> MutableSequence[_T]: ...
class AbstractSet(Iterable[_T_co], Container[_T_co], Sized, Generic[_T_co]):
@abstractmethod
def __contains__(self, x: object) -> bool: ...
# Mixin methods
def __le__(self, s: AbstractSet[Any]) -> bool: ...
def __lt__(self, s: AbstractSet[Any]) -> bool: ...
def __gt__(self, s: AbstractSet[Any]) -> bool: ...
def __ge__(self, s: AbstractSet[Any]) -> bool: ...
def __and__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
def __or__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ...
def __sub__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ...
# TODO: Argument can be a more general ABC?
def isdisjoint(self, s: AbstractSet[Any]) -> bool: ...
class FrozenSet(AbstractSet[_T_co], Generic[_T_co]): ...
class MutableSet(AbstractSet[_T], Generic[_T]):
@abstractmethod
def add(self, x: _T) -> None: ...
@abstractmethod
def discard(self, x: _T) -> None: ...
# Mixin methods
def clear(self) -> None: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def __ior__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ...
def __iand__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ...
def __ixor__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ...
def __isub__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ...
class MappingView(Sized):
def __len__(self) -> int: ...
class ItemsView(AbstractSet[Tuple[_KT_co, _VT_co]], MappingView, Generic[_KT_co, _VT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ...
class KeysView(AbstractSet[_KT_co], MappingView, Generic[_KT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_KT_co]: ...
class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]):
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_VT_co]: ...
# TODO: ContextManager (only if contextlib.AbstractContextManager exists)
class Mapping(Iterable[_KT], Container[_KT], Sized, Generic[_KT, _VT_co]):
# TODO: We wish the key type could also be covariant, but that doesn't work,
# see discussion in https: //github.com/python/typing/pull/273.
@abstractmethod
def __getitem__(self, k: _KT) -> _VT_co:
...
# Mixin methods
def get(self, k: _KT, default: _VT_co = ...) -> _VT_co: # type: ignore
...
def items(self) -> AbstractSet[Tuple[_KT, _VT_co]]: ...
def keys(self) -> AbstractSet[_KT]: ...
def values(self) -> ValuesView[_VT_co]: ...
def __contains__(self, o: object) -> bool: ...
class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
@abstractmethod
def __setitem__(self, k: _KT, v: _VT) -> None: ...
@abstractmethod
def __delitem__(self, v: _KT) -> None: ...
def clear(self) -> None: ...
def pop(self, k: _KT, default: _VT = ...) -> _VT: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
# 'update' used to take a Union, but using overloading is better.
# The second overloaded type here is a bit too general, because
# Mapping[Tuple[_KT, _VT], W] is a subclass of Iterable[Tuple[_KT, _VT]],
# but will always have the behavior of the first overloaded type
# at runtime, leading to keys of a mix of types _KT and Tuple[_KT, _VT].
# We don't currently have any way of forcing all Mappings to use
# the first overload, but by using overloading rather than a Union,
# mypy will commit to using the first overload when the argument is
# known to be a Mapping with unknown type parameters, which is closer
# to the behavior we want. See mypy issue #1430.
@overload
def update(self, m: Mapping[_KT, _VT]) -> None: ...
@overload
def update(self, m: Iterable[Tuple[_KT, _VT]]) -> None: ...
Text = str
TYPE_CHECKING = True
class IO(Iterator[AnyStr], Generic[AnyStr]):
# TODO detach
# TODO use abstract properties
@property
def mode(self) -> str: ...
@property
def name(self) -> str: ...
@abstractmethod
def close(self) -> None: ...
@property
def closed(self) -> bool: ...
@abstractmethod
def fileno(self) -> int: ...
@abstractmethod
def flush(self) -> None: ...
@abstractmethod
def isatty(self) -> bool: ...
# TODO what if n is None?
@abstractmethod
def read(self, n: int = ...) -> AnyStr: ...
@abstractmethod
def readable(self) -> bool: ...
@abstractmethod
def readline(self, limit: int = ...) -> AnyStr: ...
@abstractmethod
def readlines(self, hint: int = ...) -> list[AnyStr]: ...
@abstractmethod
def seek(self, offset: int, whence: int = ...) -> int: ...
@abstractmethod
def seekable(self) -> bool: ...
@abstractmethod
def tell(self) -> int: ...
# TODO None should not be compatible with int
@abstractmethod
def truncate(self, size: int = ...) -> int: ...
@abstractmethod
def writable(self) -> bool: ...
# TODO buffer objects
@abstractmethod
def write(self, s: AnyStr) -> int: ...
@abstractmethod
def writelines(self, lines: Iterable[AnyStr]) -> None: ...
@abstractmethod
def __next__(self) -> AnyStr: ...
@abstractmethod
def __iter__(self) -> Iterator[AnyStr]: ...
@abstractmethod
def __enter__(self) -> 'IO[AnyStr]': ...
@abstractmethod
def __exit__(self, t: Optional[Type[BaseException]], value: Optional[BaseException],
# TODO: traceback should be TracebackType but that's defined in types
traceback: Optional[Any]) -> bool: ...
class BinaryIO(IO[bytes]):
# TODO readinto
# TODO read1?
# TODO peek?
@overload
@abstractmethod
def write(self, s: bytes) -> int: ...
@overload
@abstractmethod
def write(self, s: bytearray) -> int: ...
@abstractmethod
def __enter__(self) -> BinaryIO: ...
class TextIO(IO[str]):
# TODO use abstractproperty
@property
def buffer(self) -> BinaryIO: ...
@property
def encoding(self) -> str: ...
@property
def errors(self) -> Optional[str]: ...
@property
def line_buffering(self) -> int: ... # int on PyPy, bool on CPython
@property
def newlines(self) -> Any: ... # None, str or tuple
@abstractmethod
def __enter__(self) -> TextIO: ...
class ByteString(Sequence[int]): ...
class Match(Generic[AnyStr]):
pos = 0
endpos = 0
lastindex = 0
lastgroup = ... # type: AnyStr
string = ... # type: AnyStr
# The regular expression object whose match() or search() method produced
# this match instance.
re = ... # type: 'Pattern[AnyStr]'
def expand(self, template: AnyStr) -> AnyStr: ...
@overload
def group(self, group1: int = ...) -> AnyStr: ...
@overload
def group(self, group1: str) -> AnyStr: ...
@overload
def group(self, group1: int, group2: int,
*groups: int) -> Sequence[AnyStr]: ...
@overload
def group(self, group1: str, group2: str,
*groups: str) -> Sequence[AnyStr]: ...
def groups(self, default: AnyStr = ...) -> Sequence[AnyStr]: ...
def groupdict(self, default: AnyStr = ...) -> dict[str, AnyStr]: ...
def start(self, group: Union[int, str] = ...) -> int: ...
def end(self, group: Union[int, str] = ...) -> int: ...
def span(self, group: Union[int, str] = ...) -> Tuple[int, int]: ...
class Pattern(Generic[AnyStr]):
flags = 0
groupindex = 0
groups = 0
pattern = ... # type: AnyStr
def search(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Match[AnyStr]: ...
def match(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Match[AnyStr]: ...
# New in Python 3.4
def fullmatch(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Optional[Match[AnyStr]]: ...
def split(self, string: AnyStr, maxsplit: int = ...) -> list[AnyStr]: ...
def findall(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> list[Any]: ...
def finditer(self, string: AnyStr, pos: int = ...,
endpos: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def sub(self, repl: AnyStr, string: AnyStr,
count: int = ...) -> AnyStr: ...
@overload
def sub(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr,
count: int = ...) -> AnyStr: ...
@overload
def subn(self, repl: AnyStr, string: AnyStr,
count: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr,
count: int = ...) -> Tuple[AnyStr, int]: ...
# Functions
def get_type_hints(obj: Callable) -> dict[str, Any]: ...
def cast(tp: Type[_T], obj: Any) -> _T: ...
# Type constructors
# NamedTuple is special-cased in the type checker; the initializer is ignored.
def NamedTuple(typename: str, fields: Iterable[Tuple[str, Any]], *,
verbose: bool = ..., rename: bool = ..., module: str = None) -> Type[tuple]: ...
def NewType(name: str, tp: Type[_T]) -> Type[_T]: ...
mypy-0.470/typeshed/stdlib/3/wsgiref/ 0000755 0000000 0000000 00000000000 13044320557 016141 5 ustar root root mypy-0.470/typeshed/stdlib/3/wsgiref/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020410 0 ustar root root mypy-0.470/typeshed/stdlib/3/wsgiref/validate.pyi 0000644 0000000 0000000 00000002355 13035744274 020470 0 ustar root root # Stubs for wsgiref.validate (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class WSGIWarning(Warning): ...
def validator(application): ...
class InputWrapper:
input = ... # type: Any
def __init__(self, wsgi_input): ...
def read(self, *args): ...
def readline(self, *args): ...
def readlines(self, *args): ...
def __iter__(self): ...
def close(self): ...
class ErrorWrapper:
errors = ... # type: Any
def __init__(self, wsgi_errors): ...
def write(self, s): ...
def flush(self): ...
def writelines(self, seq): ...
def close(self): ...
class WriteWrapper:
writer = ... # type: Any
def __init__(self, wsgi_writer): ...
def __call__(self, s): ...
class PartialIteratorWrapper:
iterator = ... # type: Any
def __init__(self, wsgi_iterator): ...
def __iter__(self): ...
class IteratorWrapper:
original_iterator = ... # type: Any
iterator = ... # type: Any
closed = ... # type: Any
check_start_response = ... # type: Any
def __init__(self, wsgi_iterator, check_start_response): ...
def __iter__(self): ...
def __next__(self): ...
def close(self): ...
def __del__(self): ...
mypy-0.470/typeshed/stdlib/3/tkinter/ 0000755 0000000 0000000 00000000000 13044320557 016153 5 ustar root root mypy-0.470/typeshed/stdlib/3/tkinter/__init__.pyi 0000644 0000000 0000000 00000056123 13035744274 020452 0 ustar root root # Stubs for tkinter (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tkinter.constants import * # noqa: F403
TclError = ... # type: Any
wantobjects = ... # type: Any
TkVersion = ... # type: Any
TclVersion = ... # type: Any
READABLE = ... # type: Any
WRITABLE = ... # type: Any
EXCEPTION = ... # type: Any
class Event: ...
def NoDefaultRoot(): ...
class Variable:
def __init__(self, master=None, value=None, name=None): ...
def __del__(self): ...
def set(self, value): ...
initialize = ... # type: Any
def get(self): ...
def trace_variable(self, mode, callback): ...
trace = ... # type: Any
def trace_vdelete(self, mode, cbname): ...
def trace_vinfo(self): ...
def __eq__(self, other): ...
class StringVar(Variable):
def __init__(self, master=None, value=None, name=None): ...
def get(self): ...
class IntVar(Variable):
def __init__(self, master=None, value=None, name=None): ...
def get(self): ...
class DoubleVar(Variable):
def __init__(self, master=None, value=None, name=None): ...
def get(self): ...
class BooleanVar(Variable):
def __init__(self, master=None, value=None, name=None): ...
def set(self, value): ...
initialize = ... # type: Any
def get(self): ...
def mainloop(n=0): ...
getint = ... # type: Any
getdouble = ... # type: Any
def getboolean(s): ...
class Misc:
def destroy(self): ...
def deletecommand(self, name): ...
def tk_strictMotif(self, boolean=None): ...
def tk_bisque(self): ...
def tk_setPalette(self, *args, **kw): ...
def tk_menuBar(self, *args): ...
def wait_variable(self, name=''): ...
waitvar = ... # type: Any
def wait_window(self, window=None): ...
def wait_visibility(self, window=None): ...
def setvar(self, name='', value=''): ...
def getvar(self, name=''): ...
def getint(self, s): ...
def getdouble(self, s): ...
def getboolean(self, s): ...
def focus_set(self): ...
focus = ... # type: Any
def focus_force(self): ...
def focus_get(self): ...
def focus_displayof(self): ...
def focus_lastfor(self): ...
def tk_focusFollowsMouse(self): ...
def tk_focusNext(self): ...
def tk_focusPrev(self): ...
def after(self, ms, func=None, *args): ...
def after_idle(self, func, *args): ...
def after_cancel(self, id): ...
def bell(self, displayof=0): ...
def clipboard_get(self, **kw): ...
def clipboard_clear(self, **kw): ...
def clipboard_append(self, string, **kw): ...
def grab_current(self): ...
def grab_release(self): ...
def grab_set(self): ...
def grab_set_global(self): ...
def grab_status(self): ...
def option_add(self, pattern, value, priority=None): ...
def option_clear(self): ...
def option_get(self, name, className): ...
def option_readfile(self, fileName, priority=None): ...
def selection_clear(self, **kw): ...
def selection_get(self, **kw): ...
def selection_handle(self, command, **kw): ...
def selection_own(self, **kw): ...
def selection_own_get(self, **kw): ...
def send(self, interp, cmd, *args): ...
def lower(self, belowThis=None): ...
def tkraise(self, aboveThis=None): ...
lift = ... # type: Any
def winfo_atom(self, name, displayof=0): ...
def winfo_atomname(self, id, displayof=0): ...
def winfo_cells(self): ...
def winfo_children(self): ...
def winfo_class(self): ...
def winfo_colormapfull(self): ...
def winfo_containing(self, rootX, rootY, displayof=0): ...
def winfo_depth(self): ...
def winfo_exists(self): ...
def winfo_fpixels(self, number): ...
def winfo_geometry(self): ...
def winfo_height(self): ...
def winfo_id(self): ...
def winfo_interps(self, displayof=0): ...
def winfo_ismapped(self): ...
def winfo_manager(self): ...
def winfo_name(self): ...
def winfo_parent(self): ...
def winfo_pathname(self, id, displayof=0): ...
def winfo_pixels(self, number): ...
def winfo_pointerx(self): ...
def winfo_pointerxy(self): ...
def winfo_pointery(self): ...
def winfo_reqheight(self): ...
def winfo_reqwidth(self): ...
def winfo_rgb(self, color): ...
def winfo_rootx(self): ...
def winfo_rooty(self): ...
def winfo_screen(self): ...
def winfo_screencells(self): ...
def winfo_screendepth(self): ...
def winfo_screenheight(self): ...
def winfo_screenmmheight(self): ...
def winfo_screenmmwidth(self): ...
def winfo_screenvisual(self): ...
def winfo_screenwidth(self): ...
def winfo_server(self): ...
def winfo_toplevel(self): ...
def winfo_viewable(self): ...
def winfo_visual(self): ...
def winfo_visualid(self): ...
def winfo_visualsavailable(self, includeids=0): ...
def winfo_vrootheight(self): ...
def winfo_vrootwidth(self): ...
def winfo_vrootx(self): ...
def winfo_vrooty(self): ...
def winfo_width(self): ...
def winfo_x(self): ...
def winfo_y(self): ...
def update(self): ...
def update_idletasks(self): ...
def bindtags(self, tagList=None): ...
def bind(self, sequence=None, func=None, add=None): ...
def unbind(self, sequence, funcid=None): ...
def bind_all(self, sequence=None, func=None, add=None): ...
def unbind_all(self, sequence): ...
def bind_class(self, className, sequence=None, func=None, add=None): ...
def unbind_class(self, className, sequence): ...
def mainloop(self, n=0): ...
def quit(self): ...
def nametowidget(self, name): ...
register = ... # type: Any
def configure(self, cnf=None, **kw): ...
config = ... # type: Any
def cget(self, key): ...
__getitem__ = ... # type: Any
def __setitem__(self, key, value): ...
def keys(self): ...
def pack_propagate(self, flag=...): ...
propagate = ... # type: Any
def pack_slaves(self): ...
slaves = ... # type: Any
def place_slaves(self): ...
def grid_anchor(self, anchor=None): ...
anchor = ... # type: Any
def grid_bbox(self, column=None, row=None, col2=None, row2=None): ...
bbox = ... # type: Any
def grid_columnconfigure(self, index, cnf=..., **kw): ...
columnconfigure = ... # type: Any
def grid_location(self, x, y): ...
def grid_propagate(self, flag=...): ...
def grid_rowconfigure(self, index, cnf=..., **kw): ...
rowconfigure = ... # type: Any
def grid_size(self): ...
size = ... # type: Any
def grid_slaves(self, row=None, column=None): ...
def event_add(self, virtual, *sequences): ...
def event_delete(self, virtual, *sequences): ...
def event_generate(self, sequence, **kw): ...
def event_info(self, virtual=None): ...
def image_names(self): ...
def image_types(self): ...
class CallWrapper:
func = ... # type: Any
subst = ... # type: Any
widget = ... # type: Any
def __init__(self, func, subst, widget): ...
def __call__(self, *args): ...
class XView:
def xview(self, *args): ...
def xview_moveto(self, fraction): ...
def xview_scroll(self, number, what): ...
class YView:
def yview(self, *args): ...
def yview_moveto(self, fraction): ...
def yview_scroll(self, number, what): ...
class Wm:
def wm_aspect(self, minNumer=None, minDenom=None, maxNumer=None, maxDenom=None): ...
aspect = ... # type: Any
def wm_attributes(self, *args): ...
attributes = ... # type: Any
def wm_client(self, name=None): ...
client = ... # type: Any
def wm_colormapwindows(self, *wlist): ...
colormapwindows = ... # type: Any
def wm_command(self, value=None): ...
command = ... # type: Any
def wm_deiconify(self): ...
deiconify = ... # type: Any
def wm_focusmodel(self, model=None): ...
focusmodel = ... # type: Any
def wm_forget(self, window): ...
forget = ... # type: Any
def wm_frame(self): ...
frame = ... # type: Any
def wm_geometry(self, newGeometry=None): ...
geometry = ... # type: Any
def wm_grid(self, baseWidth=None, baseHeight=None, widthInc=None, heightInc=None): ...
grid = ... # type: Any
def wm_group(self, pathName=None): ...
group = ... # type: Any
def wm_iconbitmap(self, bitmap=None, default=None): ...
iconbitmap = ... # type: Any
def wm_iconify(self): ...
iconify = ... # type: Any
def wm_iconmask(self, bitmap=None): ...
iconmask = ... # type: Any
def wm_iconname(self, newName=None): ...
iconname = ... # type: Any
def wm_iconphoto(self, default=False, *args): ...
iconphoto = ... # type: Any
def wm_iconposition(self, x=None, y=None): ...
iconposition = ... # type: Any
def wm_iconwindow(self, pathName=None): ...
iconwindow = ... # type: Any
def wm_manage(self, widget): ...
manage = ... # type: Any
def wm_maxsize(self, width=None, height=None): ...
maxsize = ... # type: Any
def wm_minsize(self, width=None, height=None): ...
minsize = ... # type: Any
def wm_overrideredirect(self, boolean=None): ...
overrideredirect = ... # type: Any
def wm_positionfrom(self, who=None): ...
positionfrom = ... # type: Any
def wm_protocol(self, name=None, func=None): ...
protocol = ... # type: Any
def wm_resizable(self, width=None, height=None): ...
resizable = ... # type: Any
def wm_sizefrom(self, who=None): ...
sizefrom = ... # type: Any
def wm_state(self, newstate=None): ...
state = ... # type: Any
def wm_title(self, string=None): ...
title = ... # type: Any
def wm_transient(self, master=None): ...
transient = ... # type: Any
def wm_withdraw(self): ...
withdraw = ... # type: Any
class Tk(Misc, Wm):
master = ... # type: Any
children = ... # type: Any
tk = ... # type: Any
def __init__(self, screenName=None, baseName=None, className='', useTk=1, sync=0, use=None): ...
def loadtk(self): ...
def destroy(self): ...
def readprofile(self, baseName, className): ...
def report_callback_exception(self, exc, val, tb): ...
def __getattr__(self, attr): ...
def Tcl(screenName=None, baseName=None, className='', useTk=0): ...
class Pack:
def pack_configure(self, cnf=..., **kw): ...
pack = ... # type: Any
def pack_forget(self): ...
forget = ... # type: Any
def pack_info(self): ...
info = ... # type: Any
propagate = ... # type: Any
slaves = ... # type: Any
class Place:
def place_configure(self, cnf=..., **kw): ...
place = ... # type: Any
def place_forget(self): ...
forget = ... # type: Any
def place_info(self): ...
info = ... # type: Any
slaves = ... # type: Any
class Grid:
def grid_configure(self, cnf=..., **kw): ...
grid = ... # type: Any
bbox = ... # type: Any
columnconfigure = ... # type: Any
def grid_forget(self): ...
forget = ... # type: Any
def grid_remove(self): ...
def grid_info(self): ...
info = ... # type: Any
location = ... # type: Any
propagate = ... # type: Any
rowconfigure = ... # type: Any
size = ... # type: Any
slaves = ... # type: Any
class BaseWidget(Misc):
widgetName = ... # type: Any
def __init__(self, master, widgetName, cnf=..., kw=..., extra=...): ...
def destroy(self): ...
class Widget(BaseWidget, Pack, Place, Grid): ...
class Toplevel(BaseWidget, Wm):
def __init__(self, master=None, cnf=..., **kw): ...
class Button(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def flash(self): ...
def invoke(self): ...
class Canvas(Widget, XView, YView):
def __init__(self, master=None, cnf=..., **kw): ...
def addtag(self, *args): ...
def addtag_above(self, newtag, tagOrId): ...
def addtag_all(self, newtag): ...
def addtag_below(self, newtag, tagOrId): ...
def addtag_closest(self, newtag, x, y, halo=None, start=None): ...
def addtag_enclosed(self, newtag, x1, y1, x2, y2): ...
def addtag_overlapping(self, newtag, x1, y1, x2, y2): ...
def addtag_withtag(self, newtag, tagOrId): ...
def bbox(self, *args): ...
def tag_unbind(self, tagOrId, sequence, funcid=None): ...
def tag_bind(self, tagOrId, sequence=None, func=None, add=None): ...
def canvasx(self, screenx, gridspacing=None): ...
def canvasy(self, screeny, gridspacing=None): ...
def coords(self, *args): ...
def create_arc(self, *args, **kw): ...
def create_bitmap(self, *args, **kw): ...
def create_image(self, *args, **kw): ...
def create_line(self, *args, **kw): ...
def create_oval(self, *args, **kw): ...
def create_polygon(self, *args, **kw): ...
def create_rectangle(self, *args, **kw): ...
def create_text(self, *args, **kw): ...
def create_window(self, *args, **kw): ...
def dchars(self, *args): ...
def delete(self, *args): ...
def dtag(self, *args): ...
def find(self, *args): ...
def find_above(self, tagOrId): ...
def find_all(self): ...
def find_below(self, tagOrId): ...
def find_closest(self, x, y, halo=None, start=None): ...
def find_enclosed(self, x1, y1, x2, y2): ...
def find_overlapping(self, x1, y1, x2, y2): ...
def find_withtag(self, tagOrId): ...
def focus(self, *args): ...
def gettags(self, *args): ...
def icursor(self, *args): ...
def index(self, *args): ...
def insert(self, *args): ...
def itemcget(self, tagOrId, option): ...
def itemconfigure(self, tagOrId, cnf=None, **kw): ...
itemconfig = ... # type: Any
def tag_lower(self, *args): ...
lower = ... # type: Any
def move(self, *args): ...
def postscript(self, cnf=..., **kw): ...
def tag_raise(self, *args): ...
lift = ... # type: Any
def scale(self, *args): ...
def scan_mark(self, x, y): ...
def scan_dragto(self, x, y, gain=10): ...
def select_adjust(self, tagOrId, index): ...
def select_clear(self): ...
def select_from(self, tagOrId, index): ...
def select_item(self): ...
def select_to(self, tagOrId, index): ...
def type(self, tagOrId): ...
class Checkbutton(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def deselect(self): ...
def flash(self): ...
def invoke(self): ...
def select(self): ...
def toggle(self): ...
class Entry(Widget, XView):
def __init__(self, master=None, cnf=..., **kw): ...
def delete(self, first, last=None): ...
def get(self): ...
def icursor(self, index): ...
def index(self, index): ...
def insert(self, index, string): ...
def scan_mark(self, x): ...
def scan_dragto(self, x): ...
def selection_adjust(self, index): ...
select_adjust = ... # type: Any
def selection_clear(self): ...
select_clear = ... # type: Any
def selection_from(self, index): ...
select_from = ... # type: Any
def selection_present(self): ...
select_present = ... # type: Any
def selection_range(self, start, end): ...
select_range = ... # type: Any
def selection_to(self, index): ...
select_to = ... # type: Any
class Frame(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
class Label(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
class Listbox(Widget, XView, YView):
def __init__(self, master=None, cnf=..., **kw): ...
def activate(self, index): ...
def bbox(self, index): ...
def curselection(self): ...
def delete(self, first, last=None): ...
def get(self, first, last=None): ...
def index(self, index): ...
def insert(self, index, *elements): ...
def nearest(self, y): ...
def scan_mark(self, x, y): ...
def scan_dragto(self, x, y): ...
def see(self, index): ...
def selection_anchor(self, index): ...
select_anchor = ... # type: Any
def selection_clear(self, first, last=None): ...
select_clear = ... # type: Any
def selection_includes(self, index): ...
select_includes = ... # type: Any
def selection_set(self, first, last=None): ...
select_set = ... # type: Any
def size(self): ...
def itemcget(self, index, option): ...
def itemconfigure(self, index, cnf=None, **kw): ...
itemconfig = ... # type: Any
class Menu(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def tk_popup(self, x, y, entry=''): ...
def tk_bindForTraversal(self): ...
def activate(self, index): ...
def add(self, itemType, cnf=..., **kw): ...
def add_cascade(self, cnf=..., **kw): ...
def add_checkbutton(self, cnf=..., **kw): ...
def add_command(self, cnf=..., **kw): ...
def add_radiobutton(self, cnf=..., **kw): ...
def add_separator(self, cnf=..., **kw): ...
def insert(self, index, itemType, cnf=..., **kw): ...
def insert_cascade(self, index, cnf=..., **kw): ...
def insert_checkbutton(self, index, cnf=..., **kw): ...
def insert_command(self, index, cnf=..., **kw): ...
def insert_radiobutton(self, index, cnf=..., **kw): ...
def insert_separator(self, index, cnf=..., **kw): ...
def delete(self, index1, index2=None): ...
def entrycget(self, index, option): ...
def entryconfigure(self, index, cnf=None, **kw): ...
entryconfig = ... # type: Any
def index(self, index): ...
def invoke(self, index): ...
def post(self, x, y): ...
def type(self, index): ...
def unpost(self): ...
def xposition(self, index): ...
def yposition(self, index): ...
class Menubutton(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
class Message(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
class Radiobutton(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def deselect(self): ...
def flash(self): ...
def invoke(self): ...
def select(self): ...
class Scale(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def get(self): ...
def set(self, value): ...
def coords(self, value=None): ...
def identify(self, x, y): ...
class Scrollbar(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def activate(self, index=None): ...
def delta(self, deltax, deltay): ...
def fraction(self, x, y): ...
def identify(self, x, y): ...
def get(self): ...
def set(self, first, last): ...
class Text(Widget, XView, YView):
def __init__(self, master=None, cnf=..., **kw): ...
def bbox(self, index): ...
def compare(self, index1, op, index2): ...
def count(self, index1, index2, *args): ...
def debug(self, boolean=None): ...
def delete(self, index1, index2=None): ...
def dlineinfo(self, index): ...
def dump(self, index1, index2=None, command=None, **kw): ...
def edit(self, *args): ...
def edit_modified(self, arg=None): ...
def edit_redo(self): ...
def edit_reset(self): ...
def edit_separator(self): ...
def edit_undo(self): ...
def get(self, index1, index2=None): ...
def image_cget(self, index, option): ...
def image_configure(self, index, cnf=None, **kw): ...
def image_create(self, index, cnf=..., **kw): ...
def image_names(self): ...
def index(self, index): ...
def insert(self, index, chars, *args): ...
def mark_gravity(self, markName, direction=None): ...
def mark_names(self): ...
def mark_set(self, markName, index): ...
def mark_unset(self, *markNames): ...
def mark_next(self, index): ...
def mark_previous(self, index): ...
def peer_create(self, newPathName, cnf=..., **kw): ...
def peer_names(self): ...
def replace(self, index1, index2, chars, *args): ...
def scan_mark(self, x, y): ...
def scan_dragto(self, x, y): ...
def search(self, pattern, index, stopindex=None, forwards=None, backwards=None, exact=None, regexp=None, nocase=None, count=None, elide=None): ...
def see(self, index): ...
def tag_add(self, tagName, index1, *args): ...
def tag_unbind(self, tagName, sequence, funcid=None): ...
def tag_bind(self, tagName, sequence, func, add=None): ...
def tag_cget(self, tagName, option): ...
def tag_configure(self, tagName, cnf=None, **kw): ...
tag_config = ... # type: Any
def tag_delete(self, *tagNames): ...
def tag_lower(self, tagName, belowThis=None): ...
def tag_names(self, index=None): ...
def tag_nextrange(self, tagName, index1, index2=None): ...
def tag_prevrange(self, tagName, index1, index2=None): ...
def tag_raise(self, tagName, aboveThis=None): ...
def tag_ranges(self, tagName): ...
def tag_remove(self, tagName, index1, index2=None): ...
def window_cget(self, index, option): ...
def window_configure(self, index, cnf=None, **kw): ...
window_config = ... # type: Any
def window_create(self, index, cnf=..., **kw): ...
def window_names(self): ...
def yview_pickplace(self, *what): ...
class _setit:
def __init__(self, var, value, callback=None): ...
def __call__(self, *args): ...
class OptionMenu(Menubutton):
widgetName = ... # type: Any
menuname = ... # type: Any
def __init__(self, master, variable, value, *values, **kwargs): ...
def __getitem__(self, name): ...
def destroy(self): ...
class Image:
name = ... # type: Any
tk = ... # type: Any
def __init__(self, imgtype, name=None, cnf=..., master=None, **kw): ...
def __del__(self): ...
def __setitem__(self, key, value): ...
def __getitem__(self, key): ...
def configure(self, **kw): ...
config = ... # type: Any
def height(self): ...
def type(self): ...
def width(self): ...
class PhotoImage(Image):
def __init__(self, name=None, cnf=..., master=None, **kw): ...
def blank(self): ...
def cget(self, option): ...
def __getitem__(self, key): ...
def copy(self): ...
def zoom(self, x, y=''): ...
def subsample(self, x, y=''): ...
def get(self, x, y): ...
def put(self, data, to=None): ...
def write(self, filename, format=None, from_coords=None): ...
class BitmapImage(Image):
def __init__(self, name=None, cnf=..., master=None, **kw): ...
def image_names(): ...
def image_types(): ...
class Spinbox(Widget, XView):
def __init__(self, master=None, cnf=..., **kw): ...
def bbox(self, index): ...
def delete(self, first, last=None): ...
def get(self): ...
def icursor(self, index): ...
def identify(self, x, y): ...
def index(self, index): ...
def insert(self, index, s): ...
def invoke(self, element): ...
def scan(self, *args): ...
def scan_mark(self, x): ...
def scan_dragto(self, x): ...
def selection(self, *args): ...
def selection_adjust(self, index): ...
def selection_clear(self): ...
def selection_element(self, element=None): ...
class LabelFrame(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
class PanedWindow(Widget):
def __init__(self, master=None, cnf=..., **kw): ...
def add(self, child, **kw): ...
def remove(self, child): ...
forget = ... # type: Any
def identify(self, x, y): ...
def proxy(self, *args): ...
def proxy_coord(self): ...
def proxy_forget(self): ...
def proxy_place(self, x, y): ...
def sash(self, *args): ...
def sash_coord(self, index): ...
def sash_mark(self, index): ...
def sash_place(self, index, x, y): ...
def panecget(self, child, option): ...
def paneconfigure(self, tagOrId, cnf=None, **kw): ...
paneconfig = ... # type: Any
def panes(self): ...
mypy-0.470/typeshed/stdlib/3/tkinter/constants.pyi 0000644 0000000 0000000 00000004040 13035744274 020716 0 ustar root root # Stubs for tkinter.constants (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
NO = ... # type: Any
YES = ... # type: Any
TRUE = ... # type: Any
FALSE = ... # type: Any
ON = ... # type: Any
OFF = ... # type: Any
N = ... # type: Any
S = ... # type: Any
W = ... # type: Any
E = ... # type: Any
NW = ... # type: Any
SW = ... # type: Any
NE = ... # type: Any
SE = ... # type: Any
NS = ... # type: Any
EW = ... # type: Any
NSEW = ... # type: Any
CENTER = ... # type: Any
NONE = ... # type: Any
X = ... # type: Any
Y = ... # type: Any
BOTH = ... # type: Any
LEFT = ... # type: Any
TOP = ... # type: Any
RIGHT = ... # type: Any
BOTTOM = ... # type: Any
RAISED = ... # type: Any
SUNKEN = ... # type: Any
FLAT = ... # type: Any
RIDGE = ... # type: Any
GROOVE = ... # type: Any
SOLID = ... # type: Any
HORIZONTAL = ... # type: Any
VERTICAL = ... # type: Any
NUMERIC = ... # type: Any
CHAR = ... # type: Any
WORD = ... # type: Any
BASELINE = ... # type: Any
INSIDE = ... # type: Any
OUTSIDE = ... # type: Any
SEL = ... # type: Any
SEL_FIRST = ... # type: Any
SEL_LAST = ... # type: Any
END = ... # type: Any
INSERT = ... # type: Any
CURRENT = ... # type: Any
ANCHOR = ... # type: Any
ALL = ... # type: Any
NORMAL = ... # type: Any
DISABLED = ... # type: Any
ACTIVE = ... # type: Any
HIDDEN = ... # type: Any
CASCADE = ... # type: Any
CHECKBUTTON = ... # type: Any
COMMAND = ... # type: Any
RADIOBUTTON = ... # type: Any
SEPARATOR = ... # type: Any
SINGLE = ... # type: Any
BROWSE = ... # type: Any
MULTIPLE = ... # type: Any
EXTENDED = ... # type: Any
DOTBOX = ... # type: Any
UNDERLINE = ... # type: Any
PIESLICE = ... # type: Any
CHORD = ... # type: Any
ARC = ... # type: Any
FIRST = ... # type: Any
LAST = ... # type: Any
BUTT = ... # type: Any
PROJECTING = ... # type: Any
ROUND = ... # type: Any
BEVEL = ... # type: Any
MITER = ... # type: Any
MOVETO = ... # type: Any
SCROLL = ... # type: Any
UNITS = ... # type: Any
PAGES = ... # type: Any
mypy-0.470/typeshed/stdlib/3/tkinter/ttk.pyi 0000644 0000000 0000000 00000012276 13023631176 017507 0 ustar root root # Stubs for tkinter.ttk (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import tkinter
def tclobjs_to_py(adict): ...
def setup_master(master=None): ...
class Style:
master = ... # type: Any
tk = ... # type: Any
def __init__(self, master=None): ...
def configure(self, style, query_opt=None, **kw): ...
def map(self, style, query_opt=None, **kw): ...
def lookup(self, style, option, state=None, default=None): ...
def layout(self, style, layoutspec=None): ...
def element_create(self, elementname, etype, *args, **kw): ...
def element_names(self): ...
def element_options(self, elementname): ...
def theme_create(self, themename, parent=None, settings=None): ...
def theme_settings(self, themename, settings): ...
def theme_names(self): ...
def theme_use(self, themename=None): ...
class Widget(tkinter.Widget):
def __init__(self, master, widgetname, kw=None): ...
def identify(self, x, y): ...
def instate(self, statespec, callback=None, *args, **kw): ...
def state(self, statespec=None): ...
class Button(Widget):
def __init__(self, master=None, **kw): ...
def invoke(self): ...
class Checkbutton(Widget):
def __init__(self, master=None, **kw): ...
def invoke(self): ...
class Entry(Widget, tkinter.Entry):
def __init__(self, master=None, widget=None, **kw): ...
def bbox(self, index): ...
def identify(self, x, y): ...
def validate(self): ...
class Combobox(Entry):
def __init__(self, master=None, **kw): ...
def current(self, newindex=None): ...
def set(self, value): ...
class Frame(Widget):
def __init__(self, master=None, **kw): ...
class Label(Widget):
def __init__(self, master=None, **kw): ...
class Labelframe(Widget):
def __init__(self, master=None, **kw): ...
LabelFrame = ... # type: Any
class Menubutton(Widget):
def __init__(self, master=None, **kw): ...
class Notebook(Widget):
def __init__(self, master=None, **kw): ...
def add(self, child, **kw): ...
def forget(self, tab_id): ...
def hide(self, tab_id): ...
def identify(self, x, y): ...
def index(self, tab_id): ...
def insert(self, pos, child, **kw): ...
def select(self, tab_id=None): ...
def tab(self, tab_id, option=None, **kw): ...
def tabs(self): ...
def enable_traversal(self): ...
class Panedwindow(Widget, tkinter.PanedWindow):
def __init__(self, master=None, **kw): ...
forget = ... # type: Any
def insert(self, pos, child, **kw): ...
def pane(self, pane, option=None, **kw): ...
def sashpos(self, index, newpos=None): ...
PanedWindow = ... # type: Any
class Progressbar(Widget):
def __init__(self, master=None, **kw): ...
def start(self, interval=None): ...
def step(self, amount=None): ...
def stop(self): ...
class Radiobutton(Widget):
def __init__(self, master=None, **kw): ...
def invoke(self): ...
class Scale(Widget, tkinter.Scale):
def __init__(self, master=None, **kw): ...
def configure(self, cnf=None, **kw): ...
def get(self, x=None, y=None): ...
class Scrollbar(Widget, tkinter.Scrollbar):
def __init__(self, master=None, **kw): ...
class Separator(Widget):
def __init__(self, master=None, **kw): ...
class Sizegrip(Widget):
def __init__(self, master=None, **kw): ...
class Treeview(Widget, tkinter.XView, tkinter.YView):
def __init__(self, master=None, **kw): ...
def bbox(self, item, column=None): ...
def get_children(self, item=None): ...
def set_children(self, item, *newchildren): ...
def column(self, column, option=None, **kw): ...
def delete(self, *items): ...
def detach(self, *items): ...
def exists(self, item): ...
def focus(self, item=None): ...
def heading(self, column, option=None, **kw): ...
def identify(self, component, x, y): ...
def identify_row(self, y): ...
def identify_column(self, x): ...
def identify_region(self, x, y): ...
def identify_element(self, x, y): ...
def index(self, item): ...
def insert(self, parent, index, iid=None, **kw): ...
def item(self, item, option=None, **kw): ...
def move(self, item, parent, index): ...
reattach = ... # type: Any
def next(self, item): ...
def parent(self, item): ...
def prev(self, item): ...
def see(self, item): ...
def selection(self, selop=None, items=None): ...
def selection_set(self, items): ...
def selection_add(self, items): ...
def selection_remove(self, items): ...
def selection_toggle(self, items): ...
def set(self, item, column=None, value=None): ...
def tag_bind(self, tagname, sequence=None, callback=None): ...
def tag_configure(self, tagname, option=None, **kw): ...
def tag_has(self, tagname, item=None): ...
class LabeledScale(Frame):
label = ... # type: Any
scale = ... # type: Any
def __init__(self, master=None, variable=None, from_=0, to=10, **kw): ...
def destroy(self): ...
value = ... # type: Any
class OptionMenu(Menubutton):
def __init__(self, master, variable, default=None, *values, **kwargs): ...
def __getitem__(self, item): ...
def set_menu(self, default=None, *values): ...
def destroy(self): ...
mypy-0.470/typeshed/stdlib/3/fileinput.pyi 0000644 0000000 0000000 00000002734 13035744274 017231 0 ustar root root from typing import Iterable, Callable, IO, AnyStr, Generic, Any, Union, Iterator
def input(
files: Union[str, Iterable[str]]=None,
inplace: bool=...,
backup: str=...,
bufsize: int=...,
mode: str=...,
openhook: Callable[[str, str], IO[AnyStr]]=...) -> Iterable[AnyStr]: ...
def close() -> None: ...
def nextfile() -> None: ...
def filename() -> str: ...
def lineno() -> int: ...
def isfirstline() -> bool: ...
def isstdin() -> bool: ...
class FileInput(Iterable[AnyStr], Generic[AnyStr]):
def __init__(
self,
files: Union[str, Iterable[str]]=None,
inplace: bool=...,
backup: str=...,
bufsize: int=...,
mode: str=...,
openhook: Callable[[str, str], IO[AnyStr]]=...
) -> None: ...
def __del__(self) -> None: ...
def close(self) -> None: ...
def __enter__(self) -> 'FileInput[AnyStr]': ...
def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ...
def __iter__(self) -> Iterator[AnyStr]: ...
def __next__(self) -> AnyStr: ...
def __getitem__(self, i) -> AnyStr: ...
def nextfile(self) -> None: ...
def readline(self) -> AnyStr: ...
def filename(self) -> str: ...
def lineno(self) -> int: ...
def filelineno(self) -> int: ...
def fileno(self) -> int: ...
def isfirstline(self) -> bool: ...
def isstdin(self) -> bool: ...
def hook_compressed(filename: str, mode: str) -> IO[AnyStr]: ...
def hook_encoded(encoding: str) -> IO[AnyStr]: ...
mypy-0.470/typeshed/stdlib/3/smtplib.pyi 0000644 0000000 0000000 00000006354 13035744274 016706 0 ustar root root # Stubs for smtplib (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class SMTPException(OSError): ...
class SMTPServerDisconnected(SMTPException): ...
class SMTPResponseException(SMTPException):
smtp_code = ... # type: Any
smtp_error = ... # type: Any
args = ... # type: Any
def __init__(self, code, msg) -> None: ...
class SMTPSenderRefused(SMTPResponseException):
smtp_code = ... # type: Any
smtp_error = ... # type: Any
sender = ... # type: Any
args = ... # type: Any
def __init__(self, code, msg, sender) -> None: ...
class SMTPRecipientsRefused(SMTPException):
recipients = ... # type: Any
args = ... # type: Any
def __init__(self, recipients) -> None: ...
class SMTPDataError(SMTPResponseException): ...
class SMTPConnectError(SMTPResponseException): ...
class SMTPHeloError(SMTPResponseException): ...
class SMTPAuthenticationError(SMTPResponseException): ...
def quoteaddr(addrstring): ...
def quotedata(data): ...
class SMTP:
debuglevel = ... # type: Any
file = ... # type: Any
helo_resp = ... # type: Any
ehlo_msg = ... # type: Any
ehlo_resp = ... # type: Any
does_esmtp = ... # type: Any
default_port = ... # type: Any
timeout = ... # type: Any
esmtp_features = ... # type: Any
source_address = ... # type: Any
local_hostname = ... # type: Any
def __init__(self, host=..., port=..., local_hostname=..., timeout=...,
source_address=...): ...
def __enter__(self): ...
def __exit__(self, *args): ...
def set_debuglevel(self, debuglevel): ...
sock = ... # type: Any
def connect(self, host=..., port=..., source_address=...): ...
def send(self, s): ...
def putcmd(self, cmd, args=...): ...
def getreply(self): ...
def docmd(self, cmd, args=...): ...
def helo(self, name=...): ...
def ehlo(self, name=...): ...
def has_extn(self, opt): ...
def help(self, args=...): ...
def rset(self): ...
def noop(self): ...
def mail(self, sender, options=...): ...
def rcpt(self, recip, options=...): ...
def data(self, msg): ...
def verify(self, address): ...
vrfy = ... # type: Any
def expn(self, address): ...
def ehlo_or_helo_if_needed(self): ...
def login(self, user, password): ...
def starttls(self, keyfile=..., certfile=..., context=...): ...
def sendmail(self, from_addr, to_addrs, msg, mail_options=...,
rcpt_options=...): ...
def send_message(self, msg, from_addr=..., to_addrs=..., mail_options=...,
rcpt_options=...): ...
def close(self): ...
def quit(self): ...
class SMTP_SSL(SMTP):
default_port = ... # type: Any
keyfile = ... # type: Any
certfile = ... # type: Any
context = ... # type: Any
def __init__(self, host=..., port=..., local_hostname=..., keyfile=..., certfile=...,
timeout=..., source_address=..., context=...): ...
class LMTP(SMTP):
ehlo_msg = ... # type: Any
def __init__(self, host=..., port=..., local_hostname=..., source_address=...) -> None: ...
sock = ... # type: Any
file = ... # type: Any
def connect(self, host=..., port=..., source_address=...): ...
mypy-0.470/typeshed/stdlib/3/shelve.pyi 0000644 0000000 0000000 00000003055 13023631176 016506 0 ustar root root from typing import Any, Dict, Iterator, Optional, Tuple
import collections
class Shelf(collections.MutableMapping):
def __init__(self, dict: Dict[bytes, Any], protocol: Optional[int] = None, writeback: bool = ..., keyencoding: str = 'utf-8') -> None: ...
def __iter__(self) -> Iterator[str]: ...
def __len__(self) -> int: ...
def __contains__(self, key: Any) -> bool: ... # key should be str, but it would conflict with superclass's type signature
def get(self, key: str, default: Any = None) -> Any: ...
def __getitem__(self, key: str) -> Any: ...
def __setitem__(self, key: str, value: Any) -> None: ...
def __delitem__(self, key: str) -> None: ...
def __enter__(self) -> Shelf: ...
def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ...
def close(self) -> None: ...
def __del__(self) -> None: ...
def sync(self) -> None: ...
class BsdDbShelf(Shelf):
def __init__(self, dict: Dict[bytes, Any], protocol: Optional[int] = None, writeback: bool = ..., keyencoding: str = 'utf-8') -> None: ...
def set_location(self, key: Any) -> Tuple[str, Any]: ...
def next(self) -> Tuple[str, Any]: ...
def previous(self) -> Tuple[str, Any]: ...
def first(self) -> Tuple[str, Any]: ...
def last(self) -> Tuple[str, Any]: ...
class DbfilenameShelf(Shelf):
def __init__(self, filename: str, flag: str = 'c', protocol: Optional[int] = None, writeback: bool = ...) -> None: ...
def open(filename: str, flag: str = 'c', protocol: Optional[int] = None, writeback: bool = ...) -> DbfilenameShelf: ...
mypy-0.470/typeshed/stdlib/3/multiprocessing/ 0000755 0000000 0000000 00000000000 13044320557 017722 5 ustar root root mypy-0.470/typeshed/stdlib/3/multiprocessing/__init__.pyi 0000644 0000000 0000000 00000007750 13035744274 022223 0 ustar root root # Stubs for multiprocessing
from typing import Any, Callable, Iterable, Mapping, Optional, Dict, List
from multiprocessing.process import current_process as current_process
class Lock():
def acquire(self, block: bool = ..., timeout: int = ...) -> None: ...
def release(self) -> None: ...
class AsyncResult():
def get(self, timeout: float = -1) -> Any: ...
def wait(self, timeout: float = -1) -> None: ...
def ready(self) -> bool: ...
def successful(self) -> bool: ...
class Pool():
def __init__(self, processes: Optional[int] = None,
initializer: Optional[Callable[..., None]] = None,
initargs: Iterable[Any] = (),
maxtasksperchild: Optional[int] = None,
context: Any = None) -> None: ...
def apply(self,
func: Callable[..., Any],
args: Iterable[Any]=(),
kwds: Dict[str, Any]=...) -> Any: ...
def apply_async(self,
func: Callable[..., Any],
args: Iterable[Any]=(),
kwds: Dict[str, Any]=...,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def map(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> List[Any]: ...
def map_async(self, func: Callable[..., Any],
iterable: Iterable[Any] = (),
chunksize: Optional[int] = None,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def imap(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> Iterable[Any]: ...
def imap_unordered(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> Iterable[Any]: ...
def starmap(self,
func: Callable[..., Any],
iterable: Iterable[Iterable[Any]]=(),
chunksize: Optional[int] = None) -> List[Any]: ...
def starmap_async(self,
func: Callable[..., Any],
iterable: Iterable[Iterable[Any]] = (),
chunksize: Optional[int] = None,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def close(self) -> None: ...
def terminate(self) -> None: ...
def join(self) -> None: ...
def __enter__(self) -> 'Pool': ...
def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
class Process():
# TODO: set type of group to None
def __init__(self,
group: Any = ...,
target: Callable = ...,
name: str = ...,
args: Iterable[Any] = ...,
kwargs: Mapping[Any, Any] = ...,
daemon: bool = ...) -> None: ...
def start(self) -> None: ...
def run(self) -> None: ...
def terminate(self) -> None: ...
def is_alive(self) -> bool: ...
def join(self, timeout: float = ...) -> None: ...
class Queue():
def __init__(self, maxsize: int = ...) -> None: ...
def get(self, block: bool = ..., timeout: float = ...) -> Any: ...
def put(self, item: Any, block: bool = ..., timeout: float = ...) -> None: ...
def qsize(self) -> int: ...
def empty(self) -> bool: ...
def full(self) -> bool: ...
def put_nowait(self, item: Any) -> None: ...
def get_nowait(self) -> Any: ...
def close(self) -> None: ...
def join_thread(self) -> None: ...
def cancel_join_thread(self) -> None: ...
class Value():
def __init__(self, typecode_or_type: str, *args: Any, lock: bool = ...) -> None: ...
# ----- multiprocessing function stubs -----
def cpu_count() -> int: ...
def freeze_support() -> None: ...
mypy-0.470/typeshed/stdlib/3/multiprocessing/process.pyi 0000644 0000000 0000000 00000000217 13035744274 022131 0 ustar root root from typing import List
from multiprocessing import Process
def current_process() -> Process: ...
def active_children() -> List[Process]: ...
mypy-0.470/typeshed/stdlib/3/multiprocessing/pool.pyi 0000644 0000000 0000000 00000005005 13035744274 021424 0 ustar root root # Stubs for multiprocessing.pool
# NOTE: These are incomplete!
from typing import Any, Callable, Iterable, Mapping, Optional, Dict, List
class AsyncResult():
def get(self, timeout: float = -1) -> Any: ...
def wait(self, timeout: float = -1) -> None: ...
def ready(self) -> bool: ...
def successful(self) -> bool: ...
class ThreadPool():
def __init__(self, processes: Optional[int] = None,
initializer: Optional[Callable[..., None]] = None,
initargs: Iterable[Any] = ()) -> None: ...
def apply(self,
func: Callable[..., Any],
args: Iterable[Any]=(),
kwds: Dict[str, Any]=...) -> Any: ...
def apply_async(self,
func: Callable[..., Any],
args: Iterable[Any]=(),
kwds: Dict[str, Any]=...,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def map(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> List[Any]: ...
def map_async(self, func: Callable[..., Any],
iterable: Iterable[Any] = (),
chunksize: Optional[int] = None,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def imap(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> Iterable[Any]: ...
def imap_unordered(self,
func: Callable[..., Any],
iterable: Iterable[Any]=(),
chunksize: Optional[int] = None) -> Iterable[Any]: ...
def starmap(self,
func: Callable[..., Any],
iterable: Iterable[Iterable[Any]]=(),
chunksize: Optional[int] = None) -> List[Any]: ...
def starmap_async(self,
func: Callable[..., Any],
iterable: Iterable[Iterable[Any]] = (),
chunksize: Optional[int] = None,
callback: Callable[..., None] = None,
error_callback: Callable[[BaseException], None] = None) -> AsyncResult: ...
def close(self) -> None: ...
def terminate(self) -> None: ...
def join(self) -> None: ...
def __enter__(self) -> 'ThreadPool': ...
def __exit__(self, exc_type, exc_val, exc_tb) -> None: ...
mypy-0.470/typeshed/stdlib/3/multiprocessing/managers.pyi 0000644 0000000 0000000 00000000331 13023631176 022236 0 ustar root root # Stubs for multiprocessing.managers
# NOTE: These are incomplete!
from typing import Any
class BaseManager:
def register(self, typeid: str, callable: Any = ...) -> None: ...
class RemoteError(Exception): ...
mypy-0.470/typeshed/stdlib/3/_json.pyi 0000644 0000000 0000000 00000002152 13035744274 016334 0 ustar root root """Stub file for the '_json' module."""
from typing import Any, Tuple
class make_encoder:
sort_keys = ... # type: Any
skipkeys = ... # type: Any
key_separator = ... # type: Any
indent = ... # type: Any
markers = ... # type: Any
default = ... # type: Any
encoder = ... # type: Any
item_separator = ... # type: Any
def __init__(self, markers, default, encoder, indent, key_separator,
item_separator, sort_keys, skipkeys, allow_nan) -> None: ...
def __call__(self, *args, **kwargs) -> Any: ...
class make_scanner:
object_hook = ... # type: Any
object_pairs_hook = ... # type: Any
parse_int = ... # type: Any
parse_constant = ... # type: Any
parse_float = ... # type: Any
strict = ... # type: bool
# TODO: 'context' needs the attrs above (ducktype), but not __call__.
def __init__(self, context: "make_scanner") -> None: ...
def __call__(self, string: str, index: int) -> Tuple[Any, int]: ...
def encode_basestring_ascii(s: str) -> str: ...
def scanstring(string: str, end: int, strict: bool = ...) -> Tuple[str, int]: ...
mypy-0.470/typeshed/stdlib/3/concurrent/ 0000755 0000000 0000000 00000000000 13044320557 016655 5 ustar root root mypy-0.470/typeshed/stdlib/3/concurrent/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021124 0 ustar root root mypy-0.470/typeshed/stdlib/3/concurrent/futures/ 0000755 0000000 0000000 00000000000 13044320557 020352 5 ustar root root mypy-0.470/typeshed/stdlib/3/concurrent/futures/_base.pyi 0000644 0000000 0000000 00000003441 13035744274 022156 0 ustar root root from typing import TypeVar, Generic, Any, Iterable, Iterator, Callable, Tuple, Optional, Set
from collections import namedtuple
FIRST_COMPLETED = ... # type: Any
FIRST_EXCEPTION = ... # type: Any
ALL_COMPLETED = ... # type: Any
PENDING = ... # type: Any
RUNNING = ... # type: Any
CANCELLED = ... # type: Any
CANCELLED_AND_NOTIFIED = ... # type: Any
FINISHED = ... # type: Any
LOGGER = ... # type: Any
class Error(Exception): ...
class CancelledError(Error): ...
class TimeoutError(Error): ...
DoneAndNotDoneFutures = namedtuple('DoneAndNotDoneFutures', 'done not_done')
_T = TypeVar('_T')
class Future(Generic[_T]):
def __init__(self) -> None: ...
def cancel(self) -> bool: ...
def cancelled(self) -> bool: ...
def running(self) -> bool: ...
def done(self) -> bool: ...
def add_done_callback(self, fn: Callable[[Future], Any]) -> None: ...
def result(self, timeout: Optional[float] = ...) -> _T: ...
def exception(self, timeout: Optional[float] = ...) -> Exception: ...
def set_running_or_notify_cancel(self) -> None: ...
def set_result(self, result: _T) -> None: ...
def set_exception(self, exception: Exception) -> None: ...
class Executor:
def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
def map(self, func: Callable[..., _T], *iterables: Any, timeout: Optional[float] = ..., chunksize: int = ...) -> Iterable[_T]: ...
def shutdown(self, wait: bool = ...) -> None: ...
def __enter__(self) -> Executor: ...
def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool: ...
def as_completed(fs: Iterable[Future], timeout: Optional[float] = ...) -> Iterator[Future]: ...
def wait(fs: Iterable[Future], timeout: Optional[float] = ..., return_when: str = ...) -> Tuple[Set[Future], Set[Future]]: ...
mypy-0.470/typeshed/stdlib/3/concurrent/futures/__init__.pyi 0000644 0000000 0000000 00000000154 13035744274 022642 0 ustar root root from ._base import * # noqa: F403
from .thread import * # noqa: F403
from .process import * # noqa: F403
mypy-0.470/typeshed/stdlib/3/concurrent/futures/thread.pyi 0000644 0000000 0000000 00000000770 13035744274 022356 0 ustar root root from typing import Any, TypeVar, Callable, Iterable, Optional
from ._base import Executor, Future
_T = TypeVar('_T')
class ThreadPoolExecutor(Executor):
def __init__(self, max_workers: Optional[int] = ...) -> None: ...
def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
def map(self, func: Callable[..., _T], *iterables: Any, timeout: Optional[float] = ..., chunksize: int = ...) -> Iterable[_T]: ...
def shutdown(self, wait: bool = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/concurrent/futures/process.pyi 0000644 0000000 0000000 00000001114 13035744274 022556 0 ustar root root from typing import Any, Callable, TypeVar, Iterable, Optional
from ._base import Future, Executor
EXTRA_QUEUED_CALLS = ... # type: Any
class BrokenProcessPool(RuntimeError): ...
_T = TypeVar('_T')
class ProcessPoolExecutor(Executor):
def __init__(self, max_workers: Optional[int] = ...) -> None: ...
def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
def map(self, func: Callable[..., _T], *iterables: Any, timeout: Optional[float] = ..., chunksize: int = ...) -> Iterable[_T]: ...
def shutdown(self, wait: bool = ...) -> None: ...
mypy-0.470/typeshed/stdlib/3/_random.pyi 0000644 0000000 0000000 00000000460 13023631176 016634 0 ustar root root # Stubs for _random
# NOTE: These are incomplete!
from typing import Any
class Random:
def seed(self, x: Any = ...) -> None: ...
def getstate(self) -> tuple: ...
def setstate(self, state: tuple) -> None: ...
def random(self) -> float: ...
def getrandbits(self, k: int) -> int: ...
mypy-0.470/typeshed/stdlib/3/pipes.pyi 0000644 0000000 0000000 00000001111 13023631176 016327 0 ustar root root # Stubs for pipes
# Based on http://docs.python.org/3.5/library/pipes.html
import os
class Template:
def __init__(self) -> None: ...
def reset(self) -> None: ...
def clone(self) -> 'Template': ...
def debug(self, flag: bool) -> None: ...
def append(self, cmd: str, kind: str) -> None: ...
def prepend(self, cmd: str, kind: str) -> None: ...
def open(self, file: str, rw: str) -> os.popen: ...
def copy(self, file: str, rw: str) -> os.popen: ...
# Not documented, but widely used.
# Documented as shlex.quote since 3.3.
def quote(s: str) -> str: ...
mypy-0.470/typeshed/stdlib/3/itertools.pyi 0000644 0000000 0000000 00000004673 13044257024 017252 0 ustar root root # Stubs for itertools
# Based on http://docs.python.org/3.2/library/itertools.html
from typing import (Iterator, TypeVar, Iterable, overload, Any, Callable, Tuple,
Union, Sequence, Generic, Optional)
_T = TypeVar('_T')
_S = TypeVar('_S')
def count(start: int = ...,
step: int = ...) -> Iterator[int]: ... # more general types?
def cycle(iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def repeat(object: _T) -> Iterator[_T]: ...
@overload
def repeat(object: _T, times: int) -> Iterator[_T]: ...
def accumulate(iterable: Iterable[_T]) -> Iterator[_T]: ...
class chain(Iterator[_T], Generic[_T]):
def __init__(self, *iterables: Iterable[_T]) -> None: ...
def __next__(self) -> _T: ...
def __iter__(self) -> Iterator[_T]: ...
@staticmethod
def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ...
def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ...
def dropwhile(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
def filterfalse(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def groupby(iterable: Iterable[_T]) -> Iterator[Tuple[_T, Iterator[_T]]]: ...
@overload
def groupby(iterable: Iterable[_T],
key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ...
@overload
def islice(iterable: Iterable[_T], stop: int) -> Iterator[_T]: ...
@overload
def islice(iterable: Iterable[_T], start: int, stop: Optional[int],
step: int = ...) -> Iterator[_T]: ...
def starmap(func: Any, iterable: Iterable[Any]) -> Iterator[Any]: ...
def takewhile(predicate: Callable[[_T], Any],
iterable: Iterable[_T]) -> Iterator[_T]: ...
def tee(iterable: Iterable[Any], n: int = ...) -> Iterator[Any]: ...
def zip_longest(*p: Iterable[Any],
fillvalue: Any = ...) -> Iterator[Any]: ...
# TODO: Return type should be Iterator[Tuple[..]], but unknown tuple shape.
# Iterator[Sequence[_T]] loses this type information.
def product(*p: Iterable[_T], repeat: int = ...) -> Iterator[Sequence[_T]]: ...
def permutations(iterable: Iterable[_T],
r: Union[int, None] = ...) -> Iterator[Sequence[_T]]: ...
def combinations(iterable: Iterable[_T],
r: int) -> Iterable[Sequence[_T]]: ...
def combinations_with_replacement(iterable: Iterable[_T],
r: int) -> Iterable[Sequence[_T]]: ...
mypy-0.470/typeshed/stdlib/3/msvcrt.pyi 0000644 0000000 0000000 00000000303 13023631176 016527 0 ustar root root # Stubs for msvcrt
# NOTE: These are incomplete!
from typing import overload, BinaryIO, TextIO
def get_osfhandle(file: int) -> int: ...
def open_osfhandle(handle: int, flags: int) -> int: ...
mypy-0.470/typeshed/stdlib/3/urllib/ 0000755 0000000 0000000 00000000000 13044320557 015764 5 ustar root root mypy-0.470/typeshed/stdlib/3/urllib/error.pyi 0000644 0000000 0000000 00000000512 13023631176 017635 0 ustar root root from typing import Any, Dict, Union
from urllib.response import addinfourl
# Stubs for urllib.error
class URLError(IOError):
reason = ... # type: Union[str, BaseException]
class HTTPError(URLError, addinfourl):
code = ... # type: int
headers = ... # type: Dict[str, str]
class ContentTooShortError(URLError): ...
mypy-0.470/typeshed/stdlib/3/urllib/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020233 0 ustar root root mypy-0.470/typeshed/stdlib/3/urllib/request.pyi 0000644 0000000 0000000 00000020745 13035744274 020215 0 ustar root root # Stubs for urllib.request (Python 3.4)
from typing import (
Any, Callable, Dict, List, IO, Mapping, Optional, Sequence, Tuple, TypeVar,
Union, overload,
)
from http.client import HTTPResponse, HTTPMessage
from http.cookiejar import CookieJar
from email.message import Message
from urllib.response import addinfourl
import ssl
import sys
_T = TypeVar('_T')
_UrlopenRet = Union[HTTPResponse, addinfourl]
def urlopen(
url: Union[str, 'Request'], data: Optional[bytes] = ...,
timeout: float = ..., *, cafile: Optional[str] = ...,
capath: Optional[str] = ..., cadefault: bool = ...,
context: Optional[ssl.SSLContext] = ...
) -> _UrlopenRet: ...
def install_opener(opener: OpenerDirector) -> None: ...
def build_opener(
*handlers: Union[BaseHandler, Callable[[], BaseHandler]]
) -> OpenerDirector: ...
def url2pathname(path: str) -> str: ...
def pathname2url(path: str) -> str: ...
def getproxies() -> Dict[str, str]: ...
def parse_http_list(s: str) -> List[str]: ...
class Request:
if sys.version_info >= (3, 4):
@property
def full_url(self) -> str: ...
@full_url.setter
def full_url(self, value: str) -> None: ...
@full_url.deleter
def full_url(self) -> None: ...
else:
full_url = ... # type: str
type = ... # type: str
host = ... # type: str
origin_req_host = ... # type: str
selector = ... # type: str
data = ... # type: Optional[bytes]
unverifiable = ... # type: bool
method = ... # type: Optional[str]
def __init__(self, url: str, data: Optional[bytes] = ...,
headers: Dict[str, str] =..., origin_req_host: Optional[str] = ...,
unverifiable: bool = ..., method: Optional[str] = ...) -> None: ...
def get_method(self) -> str: ...
def add_header(self, key: str, val: str) -> None: ...
def add_unredirected_header(self, key: str, val: str) -> None: ...
def has_header(self, header_name: str) -> bool: ...
if sys.version_info >= (3, 4):
def remove_header(self, header_name: str) -> None: ...
def get_full_url(self) -> str: ...
def set_proxy(self, host: str, type: str) -> None: ...
@overload
def get_header(self, header_name: str) -> Optional[str]: ...
@overload
def get_header(self, header_name: str, default: _T) -> Union[str, _T]: ...
def header_items(self) -> List[Tuple[str, str]]: ...
class OpenerDirector:
def add_handler(self, handler: BaseHandler) -> None: ...
def open(self, url: Union[str, Request], data: Optional[bytes] = None,
timeout: float = ...) -> _UrlopenRet: ...
def error(self, proto: str, *args: Any) -> _UrlopenRet: ...
class BaseHandler:
parent = ... # type: OpenerDirector
def add_parent(self, parent: OpenerDirector) -> None: ...
def close(self) -> None: ...
def http_error_nnn(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> _UrlopenRet: ...
class HTTPDefaultErrorHandler(BaseHandler): ...
class HTTPRedirectHandler(BaseHandler):
def redirect_request(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str],
newurl: str) -> Optional[Request]: ...
def http_error_301(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
def http_error_302(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
def http_error_303(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
def http_error_307(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
class HTTPCookieProcessor(BaseHandler):
cookiejar = ... # type: CookieJar
def __init__(self, cookiejar: Optional[CookieJar] = ...) -> None: ...
class ProxyHandler(BaseHandler):
def __init__(self, proxies: Optional[Dict[str, str]] = ...) -> None: ...
# TODO add a method for every (common) proxy protocol
class HTTPPasswordMgr:
def add_password(self, realm: str, uri: Union[str, Sequence[str]],
user: str, passwd: str) -> None: ...
def find_user_password(self, realm: str, authuri: str) \
-> Tuple[Optional[str], Optional[str]]: ...
class HTTPPasswordMgrWithDefaultRealm:
def add_password(self, realm: str, uri: Union[str, Sequence[str]],
user: str, passwd: str) -> None: ...
def find_user_password(self, realm: str, authuri: str) \
-> Tuple[Optional[str], Optional[str]]: ...
if sys.version_info >= (3, 5):
class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
def add_password(self, realm: str, uri: Union[str, Sequence[str]],
user: str, passwd: str,
is_authenticated: bool = ...) -> None: ...
def update_authenticated(self, uri: Union[str, Sequence[str]],
is_authenticated: bool = ...) -> None: ...
def is_authenticated(self, authuri: str) -> bool: ...
class AbstractBasicAuthHandler:
def __init__(self,
password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ...
def http_error_auth_reqed(self, authreq: str, host: str, req: Request,
headers: Mapping[str, str]) -> None: ...
class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
def http_error_401(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
def http_error_407(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
class AbstractDigestAuthHandler:
def __init__(self,
password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ...
def http_error_auth_reqed(self, auth_header: str, host: str, req: Request,
headers: Mapping[str, str]) -> None: ...
class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
def http_error_401(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
def http_error_407(self, req: Request, fp: IO[str], code: int, msg: int,
hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...
class HTTPHandler(BaseHandler):
def http_open(self, req: Request) -> _UrlopenRet: ...
class HTTPSHandler(BaseHandler):
def __init__(self, debuglevel: int = 0,
context: Optional[ssl.SSLContext] = ...,
check_hostname: bool = ...) -> None: ...
def https_open(self, req: Request) -> _UrlopenRet: ...
class FileHandler(BaseHandler):
def file_open(self, req: Request) -> _UrlopenRet: ...
class DataHandler(BaseHandler):
def data_open(self, req: Request) -> _UrlopenRet: ...
class FTPHandler(BaseHandler):
def ftp_open(self, req: Request) -> _UrlopenRet: ...
class CacheFTPHandler(FTPHandler):
def setTimeout(self, t: float) -> None: ...
def setMaxConns(self, m: int) -> None: ...
class UnknownHandler(BaseHandler):
def unknown_open(self, req: Request) -> _UrlopenRet: ...
class HTTPErrorProcessor(BaseHandler):
def http_response(self) -> _UrlopenRet: ...
def https_response(self) -> _UrlopenRet: ...
def urlretrieve(url: str, filename: Optional[str] = ...,
reporthook: Optional[Callable[[int, int, int], None]] = ...,
data: Optional[bytes] = ...) -> Tuple[str, HTTPMessage]: ...
def urlcleanup() -> None: ...
class URLopener:
version = ... # type: str
def __init__(self, proxies: Optional[Dict[str, str]] = ...,
**x509: str) -> None: ...
def open(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...
def open_unknown(self, fullurl: str,
data: Optional[bytes] = ...) -> _UrlopenRet: ...
def retrieve(self, url: str, filename: Optional[str] = ...,
reporthook: Optional[Callable[[int, int, int], None]] = ...,
data: Optional[bytes] = ...) -> Tuple[str, Optional[Message]]: ...
class FancyURLopener(URLopener):
def prompt_user_passwd(self, host: str, realm: str) -> Tuple[str, str]: ...
mypy-0.470/typeshed/stdlib/3/urllib/parse.pyi 0000644 0000000 0000000 00000011560 13044257024 017622 0 ustar root root # Stubs for urllib.parse
from typing import Any, List, Dict, Tuple, AnyStr, Generic, overload, Sequence, Mapping, Union, NamedTuple
__all__ = (
'urlparse',
'urlunparse',
'urljoin',
'urldefrag',
'urlsplit',
'urlunsplit',
'urlencode',
'parse_qs',
'parse_qsl',
'quote',
'quote_plus',
'quote_from_bytes',
'unquote',
'unquote_plus',
'unquote_to_bytes'
)
uses_relative = ... # type: List[str]
uses_netloc = ... # type: List[str]
uses_params = ... # type: List[str]
non_hierarchical = ... # type: List[str]
uses_query = ... # type: List[str]
uses_fragment = ... # type: List[str]
scheme_chars = ... # type: str
MAX_CACHE_SIZE = 0
class _ResultMixinBase(Generic[AnyStr]):
def geturl(self) -> AnyStr: ...
class _ResultMixinStr(_ResultMixinBase[str]):
def encode(self, encoding: str = ..., errors: str = ...) -> '_ResultMixinBytes': ...
class _ResultMixinBytes(_ResultMixinBase[str]):
def decode(self, encoding: str = ..., errors: str = ...) -> '_ResultMixinStr': ...
class _NetlocResultMixinBase(Generic[AnyStr]):
username = ... # type: AnyStr
password = ... # type: AnyStr
hostname = ... # type: AnyStr
port = ... # type: int
class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ...
class _NetlocResultMixinBytes(_NetlocResultMixinBase[str], _ResultMixinBytes): ...
class _DefragResultBase(tuple, Generic[AnyStr]):
url = ... # type: AnyStr
fragment = ... # type: AnyStr
_SplitResultBase = NamedTuple(
'_SplitResultBase',
[
('scheme', str), ('netloc', str), ('path', str), ('query', str), ('fragment', str)
]
)
_SplitResultBytesBase = NamedTuple(
'_SplitResultBytesBase',
[
('scheme', bytes), ('netloc', bytes), ('path', bytes), ('query', bytes), ('fragment', bytes)
]
)
_ParseResultBase = NamedTuple(
'_ParseResultBase',
[
('scheme', str), ('netloc', str), ('path', str), ('params', str), ('query', str), ('fragment', str)
]
)
_ParseResultBytesBase = NamedTuple(
'_ParseResultBytesBase',
[
('scheme', bytes), ('netloc', bytes), ('path', bytes), ('params', bytes), ('query', bytes), ('fragment', bytes)
]
)
# Structured result objects for string data
class DefragResult(_DefragResultBase[str], _ResultMixinStr): ...
class SplitResult(_SplitResultBase, _NetlocResultMixinStr): ...
class ParseResult(_ParseResultBase, _NetlocResultMixinStr): ...
# Structured result objects for bytes data
class DefragResultBytes(_DefragResultBase[bytes], _ResultMixinBytes): ...
class SplitResultBytes(_SplitResultBytesBase, _NetlocResultMixinBytes): ...
class ParseResultBytes(_ParseResultBytesBase, _NetlocResultMixinBytes): ...
def parse_qs(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ...) -> Dict[str, List[str]]: ...
def parse_qsl(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ...) -> List[Tuple[str, str]]: ...
@overload
def quote(string: str, safe: AnyStr = ..., encoding: str = ..., errors: str = ...) -> str: ...
@overload
def quote(string: bytes, safe: AnyStr = ...) -> str: ...
def quote_from_bytes(bs: bytes, safe: AnyStr = ...) -> str: ...
@overload
def quote_plus(string: str, safe: AnyStr = ..., encoding: str = ..., errors: str = ...) -> str: ...
@overload
def quote_plus(string: bytes, safe: AnyStr = ...) -> str: ...
def unquote(string: str, encoding: str = ..., errors: str = ...) -> str: ...
def unquote_to_bytes(string: AnyStr) -> bytes: ...
def unquote_plus(string: str, encoding: str = ..., errors: str = ...) -> str: ...
@overload
def urldefrag(url: str) -> DefragResult: ...
@overload
def urldefrag(url: bytes) -> DefragResultBytes: ...
def urlencode(query: Union[Mapping[Any, Any],
Mapping[Any, Sequence[Any]],
Sequence[Tuple[Any, Any]],
Sequence[Tuple[Any, Sequence[Any]]]],
doseq: bool = ..., safe: AnyStr = ..., encoding: str = ..., errors: str = ...) -> str: ...
def urljoin(base: AnyStr, url: AnyStr, allow_fragments: bool = ...) -> AnyStr: ...
@overload
def urlparse(url: str, scheme: str = ..., allow_fragments: bool = ...) -> ParseResult: ...
@overload
def urlparse(url: bytes, scheme: bytes = ..., allow_fragments: bool = ...) -> ParseResultBytes: ...
@overload
def urlsplit(url: str, scheme: str = ..., allow_fragments: bool = ...) -> SplitResult: ...
@overload
def urlsplit(url: bytes, scheme: bytes = ..., allow_fragments: bool = ...) -> SplitResultBytes: ...
@overload
def urlunparse(components: Sequence[AnyStr]) -> AnyStr: ...
@overload
def urlunparse(components: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...
@overload
def urlunsplit(components: Sequence[AnyStr]) -> AnyStr: ...
@overload
def urlunsplit(components: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...
mypy-0.470/typeshed/stdlib/3/urllib/response.pyi 0000644 0000000 0000000 00000000352 13023631176 020344 0 ustar root root # private module, we only expose what's needed
from typing import BinaryIO, Mapping, Optional
from types import TracebackType
class addinfourl(BinaryIO):
def info(self) -> Mapping[str, str]: ...
def geturl(self) -> str: ...
mypy-0.470/typeshed/stdlib/3/urllib/robotparser.pyi 0000644 0000000 0000000 00000001305 13035744274 021056 0 ustar root root # Stubs for urllib.robotparser (Python 3.4)
from typing import Iterable, NamedTuple, Optional
import sys
_RequestRate = NamedTuple('_RequestRate', [('requests', int), ('seconds', int)])
class RobotFileParser:
def __init__(self, url: str = ...) -> None: ...
def set_url(self, url: str) -> None: ...
def read(self) -> None: ...
def parse(self, lines: Iterable[str]) -> None: ...
def can_fetch(self, user_agent: str, url: str) -> bool: ...
def mtime(self) -> int: ...
def modified(self) -> None: ...
if sys.version_info >= (3, 6):
def crawl_delay(self, useragent: str) -> Optional[str]: ...
def request_rate(self, useragent: str) -> Optional[_RequestRate]: ...
mypy-0.470/typeshed/stdlib/3/xml/ 0000755 0000000 0000000 00000000000 13044320557 015273 5 ustar root root mypy-0.470/typeshed/stdlib/3/xml/etree/ 0000755 0000000 0000000 00000000000 13044320557 016377 5 ustar root root mypy-0.470/typeshed/stdlib/3/xml/etree/__init__.pyi 0000644 0000000 0000000 00000000000 13044257024 020645 0 ustar root root mypy-0.470/typeshed/stdlib/3/xml/etree/ElementTree.pyi 0000644 0000000 0000000 00000011640 13044257024 021333 0 ustar root root # Stubs for xml.etree.ElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, AnyStr, Union, IO, Callable, Dict, List, Tuple, Sequence, Iterator, TypeVar, Optional, KeysView, ItemsView, Generator
import io
VERSION = ... # type: str
_Ss = TypeVar('_Ss', str, bytes)
_T = TypeVar('_T')
_str_or_bytes = Union[str, bytes]
class _ElementInterface(Sequence['_ElementInterface']):
tag = ... # type: _str_or_bytes
attrib = ... # type: Dict[_str_or_bytes, _str_or_bytes]
text = ... # type: Optional[_str_or_bytes]
tail = ... # type: Optional[_str_or_bytes]
def __init__(self, tag: Union[AnyStr, Callable[..., '_ElementInterface']], attrib: Dict[AnyStr, AnyStr]) -> None: ...
def makeelement(self, tag: _Ss, attrib: Dict[_Ss, _Ss]) -> '_ElementInterface': ...
def __len__(self) -> int: ...
def __getitem__(self, index: int) -> '_ElementInterface': ...
def __setitem__(self, index: int, element: '_ElementInterface') -> None: ...
def __delitem__(self, index: int) -> None: ...
def __getslice__(self, start: int, stop: int) -> Sequence['_ElementInterface']: ...
def __setslice__(self, start: int, stop: int, elements: Sequence['_ElementInterface']) -> None: ...
def __delslice__(self, start: int, stop: int) -> None: ...
def append(self, element: '_ElementInterface') -> None: ...
def insert(self, index: int, element: '_ElementInterface') -> None: ...
def remove(self, element: '_ElementInterface') -> None: ...
def getchildren(self) -> List['_ElementInterface']: ...
def find(self, path: str) -> Optional['_ElementInterface']: ...
def findtext(self, path: str, default: _T=...) -> Union[str, _T]: ...
def findall(self, path: str) -> List['_ElementInterface']: ...
def clear(self) -> None: ...
def get(self, key: AnyStr, default: _T=...) -> Union[AnyStr, _T]: ...
def set(self, key: AnyStr, value: AnyStr) -> None: ...
def keys(self) -> KeysView[AnyStr]: ...
def items(self) -> ItemsView[AnyStr, AnyStr]: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List['_ElementInterface']: ...
def Element(tag: Union[AnyStr, Callable[..., _ElementInterface]], attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> _ElementInterface: ...
def SubElement(parent: _ElementInterface, tag: AnyStr, attrib: Dict[AnyStr, AnyStr]=..., **extra: AnyStr) -> _ElementInterface: ...
def Comment(text: _str_or_bytes=...) -> _ElementInterface: ...
def ProcessingInstruction(target: str, text: str=...) -> _ElementInterface: ...
PI = ... # type: Callable[..., _ElementInterface]
class QName:
text = ... # type: str
def __init__(self, text_or_uri: str, tag: str=...) -> None: ...
_file_or_filename = Union[str, bytes, int, IO[Any]]
class ElementTree:
def __init__(self, element: _ElementInterface=..., file: _file_or_filename=...) -> None: ...
def getroot(self) -> _ElementInterface: ...
def parse(self, source: _file_or_filename, parser: 'XMLTreeBuilder'=...) -> _ElementInterface: ...
def getiterator(self, tag: Union[str, AnyStr]=...) -> List[_ElementInterface]: ...
def find(self, path: str) -> Optional[_ElementInterface]: ...
def findtext(self, path: str, default: _T=...) -> Union[_T, str]: ...
def findall(self, path: str) -> List[_ElementInterface]: ...
def write(self, file_or_filename: _file_or_filename, encoding: str=...) -> None: ...
def iselement(element: _ElementInterface) -> bool: ...
def dump(elem: _ElementInterface) -> None: ...
def fixtag(tag: Union[str, QName], namespaces: Dict[str, str]) -> Tuple[str, Optional[str]]: ...
def parse(source: _file_or_filename, parser: 'XMLTreeBuilder'=...) -> ElementTree: ...
class iterparse:
def __init__(self, source: _file_or_filename, events: Sequence[str]=...) -> None: ...
# TODO-figure out this type...
def __next__(self) -> Tuple[str, _ElementInterface]: ...
def XML(text: AnyStr) -> _ElementInterface: ...
def XMLID(text: AnyStr) -> Tuple[_ElementInterface, Dict[str, _ElementInterface]]: ...
# TODO-improve this type
fromstring = ... # type: Callable[..., _ElementInterface]
def tostring(element: _ElementInterface, encoding: str=...) -> AnyStr: ...
class TreeBuilder:
def __init__(self, element_factory: Callable[[AnyStr, Dict[AnyStr, AnyStr]], _ElementInterface]=...) -> None: ...
def close(self) -> _ElementInterface: ...
def data(self, data: AnyStr) -> None: ...
def start(self, tag: AnyStr, attrs: Dict[AnyStr, AnyStr]) -> _ElementInterface: ...
def end(self, tag: AnyStr) -> _ElementInterface: ...
class XMLTreeBuilder:
# TODO-what is entity used for???
entity = ... # type: Any
def __init__(self, html: int=..., target: TreeBuilder=...) -> None: ...
def doctype(self, name: str, pubid: str, system: str) -> None: ...
def close(self) -> Any: ... # TODO-most of the time, this will be Element, but it can be anything target.close() returns
def feed(self, data: AnyStr)-> None: ...
mypy-0.470/typeshed/stdlib/3/xml/etree/ElementPath.pyi 0000644 0000000 0000000 00000001660 13044257024 021331 0 ustar root root # Stubs for xml.etree.ElementPath (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Tuple, List, Union, TypeVar, Callable, Optional
from .ElementTree import _ElementInterface
xpath_tokenizer_re = ... # type: Callable[..., List[Tuple[str, str]]]
class xpath_descendant_or_self: ...
_T = TypeVar('_T')
class Path:
def __init__(self, path: str) -> None: ...
def find(self, element: _ElementInterface) -> Optional[_ElementInterface]: ...
def findtext(self, element: _ElementInterface, default: _T=...) -> Union[str, _T]: ...
def findall(self, element: _ElementInterface) -> List[_ElementInterface]: ...
def find(element: _ElementInterface, path: str) -> Optional[_ElementInterface]: ...
def findtext(element: _ElementInterface, path: str, default: _T=...) -> Union[str, _T]: ...
def findall(element: _ElementInterface, path: str) -> List[_ElementInterface]: ...
mypy-0.470/typeshed/stdlib/3/xml/etree/cElementTree.pyi 0000644 0000000 0000000 00000000261 13044257024 021473 0 ustar root root # Stubs for xml.etree.cElementTree (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from xml.etree.ElementTree import * # noqa: F403
mypy-0.470/typeshed/stdlib/3/xml/etree/ElementInclude.pyi 0000644 0000000 0000000 00000001442 13044257024 022016 0 ustar root root # Stubs for xml.etree.ElementInclude (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Union, Optional, Callable
from .ElementTree import _ElementInterface
XINCLUDE = ... # type: str
XINCLUDE_INCLUDE = ... # type: str
XINCLUDE_FALLBACK = ... # type: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str]=...) -> Union[str, _ElementInterface]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
def include(elem: _ElementInterface, loader: Callable[..., Union[str, _ElementInterface]]=...) -> None: ...
mypy-0.470/typeshed/stdlib/3/unicodedata.pyi 0000644 0000000 0000000 00000002162 13035744274 017505 0 ustar root root # Stubs for unicodedata (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
ucd_3_2_0 = ... # type: Any
ucnhash_CAPI = ... # type: Any
unidata_version = ... # type: str
def bidirectional(unichr): ...
def category(unichr): ...
def combining(unichr): ...
def decimal(chr, default=...): ...
def decomposition(unichr): ...
def digit(chr, default=...): ...
def east_asian_width(unichr): ...
def lookup(name): ...
def mirrored(unichr): ...
def name(chr, default=...): ...
def normalize(form, unistr): ...
def numeric(chr, default=...): ...
class UCD:
unidata_version = ... # type: Any
def bidirectional(self, unichr): ...
def category(self, unichr): ...
def combining(self, unichr): ...
def decimal(self, chr, default=...): ...
def decomposition(self, unichr): ...
def digit(self, chr, default=...): ...
def east_asian_width(self, unichr): ...
def lookup(self, name): ...
def mirrored(self, unichr): ...
def name(self, chr, default=...): ...
def normalize(self, form, unistr): ...
def numeric(self, chr, default=...): ...
mypy-0.470/typeshed/stdlib/3/time.pyi 0000644 0000000 0000000 00000005777 13035744274 016202 0 ustar root root # Stubs for time
# Ron Murawski
# based on: http://docs.python.org/3.3/library/time.html#module-time
# see: http://nullege.com/codes/search?cq=time
import sys
from typing import Any, NamedTuple, Tuple, Union
from types import SimpleNamespace
TimeTuple = Tuple[int, int, int, int, int, int, int, int, int]
# ----- variables and constants -----
accept2dyear = False
altzone = 0
daylight = 0
timezone = 0
tzname = ... # type: Tuple[str, str]
if sys.version_info >= (3, 3) and sys.platform != 'win32':
CLOCK_HIGHRES = 0 # Solaris only
CLOCK_MONOTONIC = 0 # Unix only
CLOCK_MONOTONIC_RAW = 0 # Linux 2.6.28 or later
CLOCK_PROCESS_CPUTIME_ID = 0 # Unix only
CLOCK_REALTIME = 0 # Unix only
CLOCK_THREAD_CPUTIME_ID = 0 # Unix only
if sys.version_info >= (3, 3):
class struct_time(
NamedTuple(
'_struct_time',
[('tm_year', int), ('tm_mon', int), ('tm_mday', int),
('tm_hour', int), ('tm_min', int), ('tm_sec', int),
('tm_wday', int), ('tm_yday', int), ('tm_isdst', int),
('tm_zone', str), ('tm_gmtoff', int)]
)
):
def __init__(
self,
o: Union[
Tuple[int, int, int, int, int, int, int, int, int],
Tuple[int, int, int, int, int, int, int, int, int, str],
Tuple[int, int, int, int, int, int, int, int, int, str, int]
],
_arg: Any = ...,
) -> None: ...
else:
class struct_time(
NamedTuple(
'_struct_time',
[('tm_year', int), ('tm_mon', int), ('tm_mday', int),
('tm_hour', int), ('tm_min', int), ('tm_sec', int),
('tm_wday', int), ('tm_yday', int), ('tm_isdst', int)]
)
):
def __init__(self, o: TimeTuple, _arg: Any = ...) -> None: ...
# ----- functions -----
def asctime(t: Union[TimeTuple, struct_time, None] = ...) -> str: ... # return current time
def clock() -> float: ...
def ctime(secs: Union[float, None] = ...) -> str: ... # return current time
def gmtime(secs: Union[float, None] = ...) -> struct_time: ... # return current time
def localtime(secs: Union[float, None] = ...) -> struct_time: ... # return current time
def mktime(t: Union[TimeTuple, struct_time]) -> float: ...
def sleep(secs: Union[int, float]) -> None: ...
def strftime(format: str,
t: Union[TimeTuple, struct_time, None] = ...) -> str: ... # return current time
def strptime(string: str,
format: str = ...) -> struct_time: ...
def time() -> float: ...
if sys.platform != 'win32':
def tzset() -> None: ... # Unix only
if sys.version_info >= (3, 3):
def get_clock_info(str) -> SimpleNamespace: ...
def monotonic() -> float: ...
def perf_counter() -> float: ...
def process_time() -> float: ...
if sys.platform != 'win32':
def clock_getres(int) -> float: ... # Unix only
def clock_gettime(int) -> float: ... # Unix only
def clock_settime(int, struct_time) -> float: ... # Unix only
mypy-0.470/typeshed/stdlib/3/stat.pyi 0000644 0000000 0000000 00000002152 13035744274 016177 0 ustar root root # Stubs for stat
# Based on http://docs.python.org/3.2/library/stat.html
import sys
import typing
def S_ISDIR(mode: int) -> bool: ...
def S_ISCHR(mode: int) -> bool: ...
def S_ISBLK(mode: int) -> bool: ...
def S_ISREG(mode: int) -> bool: ...
def S_ISFIFO(mode: int) -> bool: ...
def S_ISLNK(mode: int) -> bool: ...
def S_ISSOCK(mode: int) -> bool: ...
def S_IMODE(mode: int) -> int: ...
def S_IFMT(mode: int) -> int: ...
ST_MODE = 0
ST_INO = 0
ST_DEV = 0
ST_NLINK = 0
ST_UID = 0
ST_GID = 0
ST_SIZE = 0
ST_ATIME = 0
ST_MTIME = 0
ST_CTIME = 0
S_IFSOCK = 0
S_IFLNK = 0
S_IFREG = 0
S_IFBLK = 0
S_IFDIR = 0
S_IFCHR = 0
S_IFIFO = 0
S_ISUID = 0
S_ISGID = 0
S_ISVTX = 0
S_IRWXU = 0
S_IRUSR = 0
S_IWUSR = 0
S_IXUSR = 0
S_IRWXG = 0
S_IRGRP = 0
S_IWGRP = 0
S_IXGRP = 0
S_IRWXO = 0
S_IROTH = 0
S_IWOTH = 0
S_IXOTH = 0
S_ENFMT = 0
S_IREAD = 0
S_IWRITE = 0
S_IEXEC = 0
UF_NODUMP = 0
UF_IMMUTABLE = 0
UF_APPEND = 0
UF_OPAQUE = 0
UF_NOUNLINK = 0
if sys.platform == 'darwin':
UF_COMPRESSED = 0 # OS X 10.6+ only
UF_HIDDEN = 0 # OX X 10.5+ only
SF_ARCHIVED = 0
SF_IMMUTABLE = 0
SF_APPEND = 0
SF_NOUNLINK = 0
SF_SNAPSHOT = 0
mypy-0.470/typeshed/stdlib/3/tokenize.pyi 0000644 0000000 0000000 00000003263 13035744274 017060 0 ustar root root # Stubs for tokenize (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, TextIO
from builtins import open as _builtin_open
from token import * # noqa: F403
COMMENT = ... # type: Any
NL = ... # type: Any
ENCODING = ... # type: Any
class TokenInfo:
@property
def exact_type(self): ...
class TokenError(Exception): ...
class StopTokenizing(Exception): ...
class Untokenizer:
tokens = ... # type: Any
prev_row = ... # type: Any
prev_col = ... # type: Any
encoding = ... # type: Any
def __init__(self): ...
def add_whitespace(self, start): ...
def untokenize(self, iterable): ...
def compat(self, token, iterable): ...
def untokenize(iterable): ...
def detect_encoding(readline): ...
def tokenize(readline): ...
def open(filename: Union[str, bytes, int]) -> TextIO: ...
# Names in __all__ with no definition:
# AMPER
# AMPEREQUAL
# ASYNC
# AT
# ATEQUAL
# AWAIT
# CIRCUMFLEX
# CIRCUMFLEXEQUAL
# COLON
# COMMA
# DEDENT
# DOT
# DOUBLESLASH
# DOUBLESLASHEQUAL
# DOUBLESTAR
# DOUBLESTAREQUAL
# ELLIPSIS
# ENDMARKER
# EQEQUAL
# EQUAL
# ERRORTOKEN
# GREATER
# GREATEREQUAL
# INDENT
# ISEOF
# ISNONTERMINAL
# ISTERMINAL
# LBRACE
# LEFTSHIFT
# LEFTSHIFTEQUAL
# LESS
# LESSEQUAL
# LPAR
# LSQB
# MINEQUAL
# MINUS
# NAME
# NEWLINE
# NOTEQUAL
# NT_OFFSET
# NUMBER
# N_TOKENS
# OP
# PERCENT
# PERCENTEQUAL
# PLUS
# PLUSEQUAL
# RARROW
# RBRACE
# RIGHTSHIFT
# RIGHTSHIFTEQUAL
# RPAR
# RSQB
# SEMI
# SLASH
# SLASHEQUAL
# STAR
# STAREQUAL
# STRING
# TILDE
# VBAR
# VBAREQUAL
# tok_name
mypy-0.470/typeshed/stdlib/3/glob.pyi 0000644 0000000 0000000 00000001001 13023631176 016130 0 ustar root root # Stubs for glob
# Based on http://docs.python.org/3/library/glob.html
from typing import List, Iterator, AnyStr
import sys
if sys.version_info >= (3, 5):
def glob(pathname: AnyStr, *, recursive: bool = ...) -> List[AnyStr]: ...
def iglob(pathname: AnyStr, *, recursive: bool = ...) -> Iterator[AnyStr]: ...
else:
def glob(pathname: AnyStr) -> List[AnyStr]: ...
def iglob(pathname: AnyStr) -> Iterator[AnyStr]: ...
if sys.version_info >= (3, 4):
def escape(pathname: AnyStr) -> AnyStr: ...
mypy-0.470/typeshed/stdlib/3/_subprocess.pyi 0000644 0000000 0000000 00000002364 13023631176 017551 0 ustar root root # Stubs for _subprocess
# NOTE: These are incomplete!
from typing import Mapping, Any, Tuple
CREATE_NEW_CONSOLE = 0
CREATE_NEW_PROCESS_GROUP = 0
STD_INPUT_HANDLE = 0
STD_OUTPUT_HANDLE = 0
STD_ERROR_HANDLE = 0
SW_HIDE = 0
STARTF_USESTDHANDLES = 0
STARTF_USESHOWWINDOW = 0
INFINITE = 0
DUPLICATE_SAME_ACCESS = 0
WAIT_OBJECT_0 = 0
# TODO not exported by the Python module
class Handle:
def Close(self) -> None: ...
def GetVersion() -> int: ...
def GetExitCodeProcess(handle: Handle) -> int: ...
def WaitForSingleObject(handle: Handle, timeout: int) -> int: ...
def CreateProcess(executable: str, cmd_line: str,
proc_attrs, thread_attrs,
inherit: int, flags: int,
env_mapping: Mapping[str, str],
curdir: str,
startupinfo: Any) -> Tuple[Any, Handle, int, int]: ...
def GetModuleFileName(module: int) -> str: ...
def GetCurrentProcess() -> Handle: ...
def DuplicateHandle(source_proc: Handle, source: Handle, target_proc: Handle,
target: Any, access: int, inherit: int) -> int: ...
def CreatePipe(pipe_attrs, size: int) -> Tuple[Handle, Handle]: ...
def GetStdHandle(arg: int) -> int: ...
def TerminateProcess(handle: Handle, exit_code: int) -> None: ...
mypy-0.470/typeshed/stdlib/3/_curses.pyi 0000644 0000000 0000000 00000022212 13035744274 016666 0 ustar root root # Stubs for _curses (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, BinaryIO, Tuple, Union
chtype = Union[str, bytes, int]
ALL_MOUSE_EVENTS = ... # type: int
A_ALTCHARSET = ... # type: int
A_ATTRIBUTES = ... # type: int
A_BLINK = ... # type: int
A_BOLD = ... # type: int
A_CHARTEXT = ... # type: int
A_COLOR = ... # type: int
A_DIM = ... # type: int
A_HORIZONTAL = ... # type: int
A_INVIS = ... # type: int
A_LEFT = ... # type: int
A_LOW = ... # type: int
A_NORMAL = ... # type: int
A_PROTECT = ... # type: int
A_REVERSE = ... # type: int
A_RIGHT = ... # type: int
A_STANDOUT = ... # type: int
A_TOP = ... # type: int
A_UNDERLINE = ... # type: int
A_VERTICAL = ... # type: int
BUTTON1_CLICKED = ... # type: int
BUTTON1_DOUBLE_CLICKED = ... # type: int
BUTTON1_PRESSED = ... # type: int
BUTTON1_RELEASED = ... # type: int
BUTTON1_TRIPLE_CLICKED = ... # type: int
BUTTON2_CLICKED = ... # type: int
BUTTON2_DOUBLE_CLICKED = ... # type: int
BUTTON2_PRESSED = ... # type: int
BUTTON2_RELEASED = ... # type: int
BUTTON2_TRIPLE_CLICKED = ... # type: int
BUTTON3_CLICKED = ... # type: int
BUTTON3_DOUBLE_CLICKED = ... # type: int
BUTTON3_PRESSED = ... # type: int
BUTTON3_RELEASED = ... # type: int
BUTTON3_TRIPLE_CLICKED = ... # type: int
BUTTON4_CLICKED = ... # type: int
BUTTON4_DOUBLE_CLICKED = ... # type: int
BUTTON4_PRESSED = ... # type: int
BUTTON4_RELEASED = ... # type: int
BUTTON4_TRIPLE_CLICKED = ... # type: int
BUTTON_ALT = ... # type: int
BUTTON_CTRL = ... # type: int
BUTTON_SHIFT = ... # type: int
COLOR_BLACK = ... # type: int
COLOR_BLUE = ... # type: int
COLOR_CYAN = ... # type: int
COLOR_GREEN = ... # type: int
COLOR_MAGENTA = ... # type: int
COLOR_RED = ... # type: int
COLOR_WHITE = ... # type: int
COLOR_YELLOW = ... # type: int
ERR = ... # type: int
KEY_A1 = ... # type: int
KEY_A3 = ... # type: int
KEY_B2 = ... # type: int
KEY_BACKSPACE = ... # type: int
KEY_BEG = ... # type: int
KEY_BREAK = ... # type: int
KEY_BTAB = ... # type: int
KEY_C1 = ... # type: int
KEY_C3 = ... # type: int
KEY_CANCEL = ... # type: int
KEY_CATAB = ... # type: int
KEY_CLEAR = ... # type: int
KEY_CLOSE = ... # type: int
KEY_COMMAND = ... # type: int
KEY_COPY = ... # type: int
KEY_CREATE = ... # type: int
KEY_CTAB = ... # type: int
KEY_DC = ... # type: int
KEY_DL = ... # type: int
KEY_DOWN = ... # type: int
KEY_EIC = ... # type: int
KEY_END = ... # type: int
KEY_ENTER = ... # type: int
KEY_EOL = ... # type: int
KEY_EOS = ... # type: int
KEY_EXIT = ... # type: int
KEY_F0 = ... # type: int
KEY_F1 = ... # type: int
KEY_F10 = ... # type: int
KEY_F11 = ... # type: int
KEY_F12 = ... # type: int
KEY_F13 = ... # type: int
KEY_F14 = ... # type: int
KEY_F15 = ... # type: int
KEY_F16 = ... # type: int
KEY_F17 = ... # type: int
KEY_F18 = ... # type: int
KEY_F19 = ... # type: int
KEY_F2 = ... # type: int
KEY_F20 = ... # type: int
KEY_F21 = ... # type: int
KEY_F22 = ... # type: int
KEY_F23 = ... # type: int
KEY_F24 = ... # type: int
KEY_F25 = ... # type: int
KEY_F26 = ... # type: int
KEY_F27 = ... # type: int
KEY_F28 = ... # type: int
KEY_F29 = ... # type: int
KEY_F3 = ... # type: int
KEY_F30 = ... # type: int
KEY_F31 = ... # type: int
KEY_F32 = ... # type: int
KEY_F33 = ... # type: int
KEY_F34 = ... # type: int
KEY_F35 = ... # type: int
KEY_F36 = ... # type: int
KEY_F37 = ... # type: int
KEY_F38 = ... # type: int
KEY_F39 = ... # type: int
KEY_F4 = ... # type: int
KEY_F40 = ... # type: int
KEY_F41 = ... # type: int
KEY_F42 = ... # type: int
KEY_F43 = ... # type: int
KEY_F44 = ... # type: int
KEY_F45 = ... # type: int
KEY_F46 = ... # type: int
KEY_F47 = ... # type: int
KEY_F48 = ... # type: int
KEY_F49 = ... # type: int
KEY_F5 = ... # type: int
KEY_F50 = ... # type: int
KEY_F51 = ... # type: int
KEY_F52 = ... # type: int
KEY_F53 = ... # type: int
KEY_F54 = ... # type: int
KEY_F55 = ... # type: int
KEY_F56 = ... # type: int
KEY_F57 = ... # type: int
KEY_F58 = ... # type: int
KEY_F59 = ... # type: int
KEY_F6 = ... # type: int
KEY_F60 = ... # type: int
KEY_F61 = ... # type: int
KEY_F62 = ... # type: int
KEY_F63 = ... # type: int
KEY_F7 = ... # type: int
KEY_F8 = ... # type: int
KEY_F9 = ... # type: int
KEY_FIND = ... # type: int
KEY_HELP = ... # type: int
KEY_HOME = ... # type: int
KEY_IC = ... # type: int
KEY_IL = ... # type: int
KEY_LEFT = ... # type: int
KEY_LL = ... # type: int
KEY_MARK = ... # type: int
KEY_MAX = ... # type: int
KEY_MESSAGE = ... # type: int
KEY_MIN = ... # type: int
KEY_MOUSE = ... # type: int
KEY_MOVE = ... # type: int
KEY_NEXT = ... # type: int
KEY_NPAGE = ... # type: int
KEY_OPEN = ... # type: int
KEY_OPTIONS = ... # type: int
KEY_PPAGE = ... # type: int
KEY_PREVIOUS = ... # type: int
KEY_PRINT = ... # type: int
KEY_REDO = ... # type: int
KEY_REFERENCE = ... # type: int
KEY_REFRESH = ... # type: int
KEY_REPLACE = ... # type: int
KEY_RESET = ... # type: int
KEY_RESIZE = ... # type: int
KEY_RESTART = ... # type: int
KEY_RESUME = ... # type: int
KEY_RIGHT = ... # type: int
KEY_SAVE = ... # type: int
KEY_SBEG = ... # type: int
KEY_SCANCEL = ... # type: int
KEY_SCOMMAND = ... # type: int
KEY_SCOPY = ... # type: int
KEY_SCREATE = ... # type: int
KEY_SDC = ... # type: int
KEY_SDL = ... # type: int
KEY_SELECT = ... # type: int
KEY_SEND = ... # type: int
KEY_SEOL = ... # type: int
KEY_SEXIT = ... # type: int
KEY_SF = ... # type: int
KEY_SFIND = ... # type: int
KEY_SHELP = ... # type: int
KEY_SHOME = ... # type: int
KEY_SIC = ... # type: int
KEY_SLEFT = ... # type: int
KEY_SMESSAGE = ... # type: int
KEY_SMOVE = ... # type: int
KEY_SNEXT = ... # type: int
KEY_SOPTIONS = ... # type: int
KEY_SPREVIOUS = ... # type: int
KEY_SPRINT = ... # type: int
KEY_SR = ... # type: int
KEY_SREDO = ... # type: int
KEY_SREPLACE = ... # type: int
KEY_SRESET = ... # type: int
KEY_SRIGHT = ... # type: int
KEY_SRSUME = ... # type: int
KEY_SSAVE = ... # type: int
KEY_SSUSPEND = ... # type: int
KEY_STAB = ... # type: int
KEY_SUNDO = ... # type: int
KEY_SUSPEND = ... # type: int
KEY_UNDO = ... # type: int
KEY_UP = ... # type: int
OK = ... # type: int
REPORT_MOUSE_POSITION = ... # type: int
_C_API = ... # type: Any
version = ... # type: bytes
def baudrate() -> int: ...
def beep() -> None: ...
def can_change_color() -> bool: ...
def cbreak(flag: bool = ...) -> None: ...
def color_content(color_number: int) -> Tuple[int, int, int]: ...
def color_pair(color_number: int) -> int: ...
def curs_set(visibility: int) -> int: ...
def def_prog_mode() -> None: ...
def def_shell_mode() -> None: ...
def delay_output(ms: int) -> None: ...
def doupdate() -> None: ...
def echo(flag: bool = ...) -> None: ...
def endwin() -> None: ...
def erasechar() -> bytes: ...
def filter() -> None: ...
def flash() -> None: ...
def flushinp() -> None: ...
def getmouse() -> Tuple[int, int, int, int, int]: ...
def getsyx() -> Tuple[int, int]: ...
def getwin(f: BinaryIO): ...
def halfdelay(tenths: int) -> None: ...
def has_colors() -> bool: ...
def has_ic() -> bool: ...
def has_il() -> bool: ...
def has_key(ch: int) -> bool: ...
def init_color(color_number: int, r: int, g: int, b: int) -> None: ...
def init_pair(pair_number: int, fg: int, bg: int) -> None: ...
def initscr(): ...
def intrflush(ch: bool) -> None: ...
def is_term_resized(nlines: int, ncols: int) -> bool: ...
def isendwin() -> bool: ...
def keyname(k: int) -> bytes: ...
def killchar() -> bytes: ...
def longname() -> bytes: ...
def meta(yes: bool) -> None: ...
def mouseinterval(interval: int) -> None: ...
def mousemask(mousemask: int) -> Tuple[int, int]: ...
def napms(ms: int) -> int: ...
def newpad(nlines: int, ncols: int): ...
def newwin(nlines: int, ncols: int, begin_y: int = ..., begin_x: int = ...): ...
def nl(flag: bool = ...) -> None: ...
def nocbreak() -> None: ...
def noecho() -> None: ...
def nonl() -> None: ...
def noqiflush() -> None: ...
def noraw() -> None: ...
def pair_content(pair_number: int) -> Tuple[int, int]: ...
def pair_number(attr: int) -> int: ...
def putp(string: bytes) -> None: ...
def qiflush(flag: bool = ...) -> None: ...
def raw(flag: bool = ...) -> None: ...
def reset_prog_mode() -> None: ...
def reset_shell_mode() -> None: ...
def resetty() -> None: ...
def resize_term(nlines: int, ncols: int) -> None: ...
def resizeterm(nlines: int, ncols: int) -> None: ...
def savetty() -> None: ...
def setsyx(y: int, x: int) -> None: ...
def setupterm(termstr: str = ..., fd: int = ...) -> None: ...
def start_color() -> None: ...
def termattrs() -> int: ...
def termname() -> bytes: ...
def tigetflag(capname: str) -> int: ...
def tigetnum(capname: str) -> int: ...
def tigetstr(capname: str) -> bytes: ...
def tparm(fmt: str, i1: int = ..., i2: int = ..., i3: int = ..., i4: int = ..., i5: int = ..., i6: int = ..., i7: int = ..., i8: int = ..., i9: int = ...) -> str: ...
def typeahead(fd: int) -> None: ...
def unctrl(ch: chtype) -> bytes: ...
def unget_wch(ch: chtype) -> None: ...
def ungetch(ch: chtype) -> None: ...
def ungetmouse(id: int, x: int, y: int, z: int, bstate: int) -> None: ...
def update_lines_cols() -> int: ...
def use_default_colors() -> None: ...
def use_env(flag: bool) -> None: ...
class error(Exception): ...
mypy-0.470/typeshed/stdlib/3/functools.pyi 0000644 0000000 0000000 00000004710 13035744274 017242 0 ustar root root # Stubs for functools (Python 3)
# NOTE: These are incomplete!
from abc import ABCMeta, abstractmethod
import sys
from typing import Any, Callable, Generic, Dict, Iterable, Mapping, Optional, Sequence, Tuple, TypeVar, NamedTuple, overload
from collections import namedtuple
_AnyCallable = Callable[..., Any]
_T = TypeVar("_T")
_S = TypeVar("_S")
@overload
def reduce(function: Callable[[_T, _S], _T],
sequence: Iterable[_S], initial: _T) -> _T: ...
@overload
def reduce(function: Callable[[_T, _T], _T],
sequence: Iterable[_T]) -> _T: ...
class CacheInfo(NamedTuple('CacheInfo', [
('hits', int), ('misses', int), ('maxsize', int), ('currsize', int)])
):
...
class _lru_cache_wrapper(Generic[_T]):
__wrapped__ = ... # type: Callable[..., _T]
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
def cache_info(self) -> CacheInfo: ...
class lru_cache():
def __init__(self, maxsize: Optional[int] = ..., typed: bool = ...) -> None: ...
def __call__(self, f: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ...
WRAPPER_ASSIGNMENTS = ... # type: Sequence[str]
WRAPPER_UPDATES = ... # type: Sequence[str]
def update_wrapper(wrapper: _AnyCallable, wrapped: _AnyCallable, assigned: Sequence[str] = ...,
updated: Sequence[str] = ...) -> None: ...
def wraps(wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> Callable[[_AnyCallable], _AnyCallable]: ...
def total_ordering(cls: type) -> type: ...
def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], Any]: ...
class partial(Generic[_T]):
func = ... # type: Callable[..., _T]
args = ... # type: Tuple[Any, ...]
keywords = ... # type: Dict[str, Any]
def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
if sys.version_info >= (3, 4):
class _SingleDispatchCallable(Generic[_T]):
registry = ... # type: Mapping[Any, Callable[..., _T]]
def dispatch(self, cls: Any) -> Callable[..., _T]: ...
@overload
def register(self, cls: Any) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
@overload
def register(self, cls: Any, func: Callable[..., _T]) -> Callable[..., _T]: ...
def _clear_cache(self) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
mypy-0.470/typeshed/stdlib/3/pyclbr.pyi 0000644 0000000 0000000 00000002046 13023631176 016512 0 ustar root root from typing import List, Union, Sequence, Optional, Dict
class Class:
module = ... # type: str
name = ... # type: str
super = Optional[List[Union["Class", str]]]
methods = ... # type: Dict[str, int]
file = ... # type: int
lineno = ... # type: int
def __init__(self,
module: str,
name: str,
super: Optional[List[Union["Class", str]]],
file: str,
lineno: int) -> None: ...
class Function:
module = ... # type: str
name = ... # type: str
file = ... # type: int
lineno = ... # type: int
def __init__(self,
module: str,
name: str,
file: str,
lineno: int) -> None: ...
def readmodule(module: str,
path: Optional[Sequence[str]] = ...
) -> Dict[str, Class]: ...
def readmodule_ex(module: str,
path: Optional[Sequence[str]] = ...
) -> Dict[str, Union[Class, Function, List[str]]]: ...
mypy-0.470/typeshed/stdlib/3/calendar.pyi 0000644 0000000 0000000 00000010666 13044257024 016776 0 ustar root root from typing import Any, Iterable, List, Optional, Tuple, Sequence
import datetime
LocaleType = Tuple[Optional[str], Optional[str]]
class IllegalMonthError(ValueError):
def __init__(self, month: int) -> None: ...
def __str__(self) -> str: ...
class IllegalWeekdayError(ValueError):
def __init__(self, weekday: int) -> None: ...
def __str__(self) -> str: ...
def isleap(year: int) -> bool: ...
def leapdays(y1: int, y2: int) -> int: ...
def weekday(year: int, month: int, day: int) -> int: ...
def monthrange(year: int, month: int) -> Tuple[int, int]: ...
class Calendar(object):
def __init__(self, firstweekday: int = 0) -> None: ...
def getfirstweekday(self) -> int: ...
def setfirstweekday(self, firstweekday: int) -> None: ...
def iterweekdays(self) -> Iterable[int]: ...
def itermonthdates(self, year: int, month: int) -> Iterable[datetime.date]: ...
def itermonthdays2(self, year: int, month: int) -> Iterable[Tuple[int, int]]: ...
def itermonthdays(self, year: int, month: int) -> Iterable[int]: ...
def monthdatescalendar(self, year: int, month: int) -> List[List[datetime.date]]: ...
def monthdays2calendar(self, year: int, month: int) -> List[List[Tuple[int, int]]]: ...
def monthdayscalendar(self, year: int, month: int) -> List[List[int]]: ...
def yeardatescalendar(self, year: int, width: int = 3) -> List[List[int]]: ...
def yeardays2calendar(self, year: int, width: int = 3) -> List[List[Tuple[int, int]]]: ...
def yeardayscalendar(self, year: int, width: int = 3) -> List[List[int]]: ...
class TextCalendar(Calendar):
def prweek(self, theweek: int, width: int) -> None: ...
def formatday(self, day: int, weekday: int, width: int) -> str: ...
def formatweek(self, theweek: int, width: int) -> str: ...
def formatweekday(self, day: int, width: int) -> str: ...
def formatweekheader(self, width: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ...
def prmonth(self, theyear: int, themonth: int, w: Any=0, l: Any = 0) -> None: ...
def formatmonth(self, theyear: int, themonth: int, w: int = 0, l: int = 0) -> str: ...
def formatyear(self, theyear: int, w: int = 2, l: int = 1, c: int = 6, m: int = 3) -> str: ...
def pryear(self, theyear: int, w: Any = 0, l: Any = 0, c: Any = 6, m: Any = 3) -> None: ...
class HTMLCalendar(Calendar):
def formatday(self, day: int, weekday: int) -> str: ...
def formatweek(self, theweek: int) -> str: ...
def formatweekday(self, day: int) -> str: ...
def formatweekheader(self) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
def formatmonth(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
def formatyear(self, theyear: int, width: int = 3) -> str: ...
def formatyearpage(self, theyear: int, width: int = 3, css: Optional[str] = 'calendar.css', encoding: Optional[str] = ...) -> str: ...
class different_locale:
def __init__(self, locale: LocaleType) -> None: ...
def __enter__(self) -> LocaleType: ...
def __exit__(self, *args) -> None: ...
class LocaleTextCalendar(TextCalendar):
def __init__(self, firstweekday: int = 0, locale: Optional[LocaleType] = ...) -> None: ...
def formatweekday(self, day: int, width: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ...
class LocaleHTMLCalendar(HTMLCalendar):
def __init__(self, firstweekday: int = 0, locale: Optional[LocaleType] = ...) -> None: ...
def formatweekday(self, day: int) -> str: ...
def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ...
c = ... # type: TextCalendar
def setfirstweekday(firstweekday: int) -> None: ...
def format(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ...
def formatstring(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ...
def timegm(tuple: Tuple[int, ...]) -> int: ...
# Data attributes
day_name = ... # type: Sequence[str]
day_abbr = ... # type: Sequence[str]
month_name = ... # type: Sequence[str]
month_abbr = ... # type: Sequence[str]
# Below constants are not in docs or __all__, but enough people have used them
# they are now effectively public.
MONDAY = ... # type: int
TUESDAY = ... # type: int
WEDNESDAY = ... # type: int
THURSDAY = ... # type: int
FRIDAY = ... # type: int
SATURDAY = ... # type: int
SUNDAY = ... # type: int
mypy-0.470/typeshed/stdlib/3/array.pyi 0000644 0000000 0000000 00000003356 13023631176 016342 0 ustar root root # Stubs for array
# Based on http://docs.python.org/3.2/library/array.html
from typing import Any, Iterable, Tuple, List, Iterator, BinaryIO, overload
typecodes = ... # type: str
class array:
typecode = ... # type: str
itemsize = ... # type: int
def __init__(self, typecode: str,
initializer: Iterable[Any] = ...) -> None: ...
def append(self, x: Any) -> None: ...
def buffer_info(self) -> Tuple[int, int]: ...
def byteswap(self) -> None: ...
def count(self, x: Any) -> int: ...
def extend(self, iterable: Iterable[Any]) -> None: ...
def frombytes(self, s: bytes) -> None: ...
def fromfile(self, f: BinaryIO, n: int) -> None: ...
def fromlist(self, list: List[Any]) -> None: ...
def fromstring(self, s: bytes) -> None: ...
def fromunicode(self, s: str) -> None: ...
def index(self, x: Any) -> int: ...
def insert(self, i: int, x: Any) -> None: ...
def pop(self, i: int = ...) -> Any: ...
def remove(self, x: Any) -> None: ...
def reverse(self) -> None: ...
def tobytes(self) -> bytes: ...
def tofile(self, f: BinaryIO) -> None: ...
def tolist(self) -> List[Any]: ...
def tostring(self) -> bytes: ...
def tounicode(self) -> str: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[Any]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> Any: ...
@overload
def __getitem__(self, s: slice) -> 'array': ...
def __setitem__(self, i: int, o: Any) -> None: ...
def __delitem__(self, i: int) -> None: ...
def __add__(self, x: 'array') -> 'array': ...
def __mul__(self, n: int) -> 'array': ...
def __contains__(self, o: object) -> bool: ...
mypy-0.470/typeshed/stdlib/3/_posixsubprocess.pyi 0000644 0000000 0000000 00000000753 13023631176 020634 0 ustar root root # Stubs for _posixsubprocess
# NOTE: These are incomplete!
from typing import Tuple, Sequence
def cloexec_pipe() -> Tuple[int, int]: ...
def fork_exec(args: Sequence[str],
executable_list, close_fds, fds_to_keep, cwd: str, env_list,
p2cread: int, p2cwrite: int, c2pred: int, c2pwrite: int,
errread: int, errwrite: int, errpipe_read: int,
errpipe_write: int, restore_signals, start_new_session,
preexec_fn) -> int: ...
mypy-0.470/typeshed/stdlib/3/gettext.pyi 0000644 0000000 0000000 00000003602 13035744274 016711 0 ustar root root # Stubs for gettext (Python 3.4)
from typing import Any, IO, List, Optional, Union, Callable
class NullTranslations:
def __init__(self, fp: IO[str] = ...) -> None: ...
def add_fallback(self, fallback: NullTranslations) -> None: ...
def gettext(self, message: str) -> str: ...
def lgettext(self, message: str) -> str: ...
def ngettext(self, singular: str, plural: str, n: int) -> str: ...
def lngettext(self, singular: str, plural: str, n: int) -> str: ...
def info(self) -> Any: ...
def charset(self) -> Any: ...
def output_charset(self) -> Any: ...
def set_output_charset(self, charset: Any) -> None: ...
def install(self, names: List[str] = ...) -> None: ...
class GNUTranslations(NullTranslations):
LE_MAGIC = ... # type: int
BE_MAGIC = ... # type: int
def find(domain: str, localedir: str = ..., languages: List[str] = ...,
all: bool = ...): ...
def translation(domain: str, localedir: str = ..., languages: List[str] = ...,
class_: Callable[[IO[str]], NullTranslations] = ...,
fallback: bool =..., codeset: Any = ...) -> NullTranslations: ...
def install(domain: str, localedir: str = ..., codeset: Any = ...,
names: List[str] = ...): ...
def textdomain(domain: str = ...) -> str: ...
def bindtextdomain(domain: str, localedir: str = ...) -> str: ...
def bind_textdomain_codeset(domain: str, codeset: str = ...) -> str: ...
def dgettext(domain: str, message: str) -> str: ...
def ldgettext(domain: str, message: str) -> str: ...
def dngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
def ldngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
def gettext(message: str) -> str: ...
def lgettext(message: str) -> str: ...
def ngettext(singular: str, plural: str, n: int) -> str: ...
def lngettext(singular: str, plural: str, n: int) -> str: ...
Catalog = translation
mypy-0.470/typeshed/stdlib/3/configparser.pyi 0000644 0000000 0000000 00000013057 13035744274 017714 0 ustar root root # Stubs for configparser
# Based on http://docs.python.org/3.5/library/configparser.html and on
# reading configparser.py.
from typing import (MutableMapping, Mapping, Dict, Sequence, List, Union,
Iterable, Iterator, Callable, Any, IO, overload, Optional)
# Types only used in type comments only
from typing import Optional, Tuple # noqa
# Internal type aliases
_section = Dict[str, str]
_parser = MutableMapping[str, _section]
_converters = Dict[str, Callable[[str], Any]]
DEFAULTSECT = ... # type: str
class Interpolation:
def before_get(self, parser: _parser,
section: str,
option: str,
value: str,
defaults: _section) -> str: ...
def before_set(self, parser: _parser,
section: str,
option: str,
value: str) -> str: ...
def before_read(self, parser: _parser,
section: str,
option: str,
value: str) -> str: ...
def before_write(self, parser: _parser,
section: str,
option: str,
value: str) -> str: ...
class BasicInterpolation(Interpolation):
pass
class ExtendedInterpolation(Interpolation):
pass
class RawConfigParser(_parser):
def __init__(self,
defaults: _section = None,
dict_type: Mapping[str, str] = ...,
allow_no_value: bool = ...,
*,
delimiters: Sequence[str] = ...,
comment_prefixes: Sequence[str] = ...,
inline_comment_prefixes: Sequence[str] = None,
strict: bool = ...,
empty_lines_in_values: bool = ...,
default_section: str = ...,
interpolation: Interpolation = None) -> None: ...
def __len__(self) -> int: ...
def __getitem__(self, section: str) -> _section: ...
def __setitem__(self, section: str, options: _section) -> None: ...
def __delitem__(self, section: str) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def defaults(self) -> _section: ...
def sections(self) -> List[str]: ...
def add_section(self, section: str) -> None: ...
def has_section(self, section: str) -> bool: ...
def options(self, section: str) -> List[str]: ...
def has_option(self, section: str, option: str) -> bool: ...
def read(self, filenames: Union[str, Sequence[str]],
encoding: str = None) -> List[str]: ...
def read_file(self, f: Iterable[str], source: str = None) -> None: ...
def read_string(self, string: str, source: str = ...) -> None: ...
def read_dict(self, dictionary: Mapping[str, Mapping[str, Any]],
source: str = ...) -> None: ...
def getint(self, section: str, option: str, *, raw: bool = ..., vars: _section = ..., fallback: int = ...) -> int: ...
def getfloat(self, section: str, option: str, *, raw: bool = ..., vars: _section = ..., fallback: float = ...) -> float: ...
def getboolean(self, section: str, option: str, *, raw: bool = ..., vars: _section = ..., fallback: bool = ...) -> bool: ...
# This is incompatible with MutableMapping so we ignore the type
def get(self, section: str, option: str, *, raw: bool = ..., vars: _section = ..., fallback: str = ...) -> str: # type: ignore
...
# This is incompatible with Mapping so we ignore the type.
def items(self, section: str = ..., raw: bool = ..., vars: _section = ...) -> Iterable[Tuple[str, _section]]: ... # type: ignore
def set(self, section: str, option: str, value: str) -> None: ...
def write(self,
fileobject: IO[str],
space_around_delimiters: bool = True) -> None: ...
def remove_option(self, section: str, option: str) -> bool: ...
def remove_section(self, section: str) -> bool: ...
def optionxform(self, option: str) -> str: ...
class ConfigParser(RawConfigParser):
def __init__(self,
defaults: _section = None,
dict_type: Mapping[str, str] = ...,
allow_no_value: bool = ...,
delimiters: Sequence[str] = ...,
comment_prefixes: Sequence[str] = ...,
inline_comment_prefixes: Sequence[str] = None,
strict: bool = ...,
empty_lines_in_values: bool = ...,
default_section: str = ...,
interpolation: Interpolation = None,
converters: _converters = ...) -> None: ...
class Error(Exception):
pass
class NoSectionError(Error):
pass
class DuplicateSectionError(Error):
section = ... # type: str
source = ... # type: Optional[str]
lineno = ... # type: Optional[int]
class DuplicateOptionError(Error):
section = ... # type: str
option = ... # type: str
source = ... # type: Optional[str]
lineno = ... # type: Optional[int]
class NoOptionError(Error):
section = ... # type: str
option = ... # type: str
class InterpolationError(Error):
section = ... # type: str
option = ... # type: str
class InterpolationDepthError(InterpolationError):
pass
class InterpolationMissingOptionError(InterpolationError):
reference = ... # type: str
class InterpolationSyntaxError(InterpolationError):
pass
class ParsingError:
source = ... # type: str
errors = ... # type: Sequence[Tuple[int, str]]
class MissingSectionHeaderError(ParsingError):
lineno = ... # type: int
line = ... # type: str
mypy-0.470/typeshed/stdlib/3/zlib.pyi 0000644 0000000 0000000 00000002775 13035744274 016177 0 ustar root root # Stubs for zlib
DEFLATED = ... # type: int
DEF_BUF_SIZE = ... # type: int
DEF_MEM_LEVEL = ... # type: int
MAX_WBITS = ... # type: int
ZLIB_RUNTIME_VERSION = ... # type: str
ZLIB_VERSION = ... # type: str
Z_BEST_COMPRESSION = ... # type: int
Z_BEST_SPEED = ... # type: int
Z_DEFAULT_COMPRESSION = ... # type: int
Z_DEFAULT_STRATEGY = ... # type: int
Z_FILTERED = ... # type: int
Z_FINISH = ... # type: int
Z_FULL_FLUSH = ... # type: int
Z_HUFFMAN_ONLY = ... # type: int
Z_NO_FLUSH = ... # type: int
Z_SYNC_FLUSH = ... # type: int
class error(Exception): ...
class Compress:
def compress(self, data: bytes) -> bytes: ...
def flush(self, mode: int = ...) -> bytes: ...
def copy(self) -> "Compress": ...
class Decompress:
unused_data = ... # type: bytes
unconsumed_tail = ... # type: bytes
eof = ... # type: bool
def decompress(self, data: bytes, max_length: int = ...) -> bytes: ...
def flush(self, length: int = ...) -> bytes: ...
def copy(self) -> "Decompress": ...
def adler32(data: bytes, value: int = ...) -> int: ...
def compress(data: bytes, level: int = ...) -> bytes: ...
def compressobj(level: int = ..., method: int = ..., wbits: int = ...,
memlevel: int = ..., strategy: int = ...,
zdict: bytes = ...) -> Compress: ...
def crc32(data: bytes, value: int = ...) -> int: ...
def decompress(data: bytes, wbits: int = ..., bufsize: int = ...) -> bytes: ...
def decompressobj(wbits: int = ..., zdict: bytes = ...) -> Decompress: ...
mypy-0.470/typeshed/stdlib/3/getpass.pyi 0000644 0000000 0000000 00000000275 13023631176 016667 0 ustar root root # Stubs for getpass
from typing import TextIO
def getpass(prompt: str = ..., stream: TextIO = None) -> str: ...
def getuser() -> str: ...
class GetPassWarning(UserWarning):
pass
mypy-0.470/typeshed/stdlib/3/struct.pyi 0000644 0000000 0000000 00000001552 13023631176 016544 0 ustar root root # Stubs for struct
# Based on http://docs.python.org/3.2/library/struct.html
from typing import overload, Any, Tuple
class error(Exception): ...
def pack(fmt: str, *v: Any) -> bytes: ...
# TODO buffer type
def pack_into(fmt: str, buffer: Any, offset: int, *v: Any) -> None: ...
# TODO buffer type
def unpack(fmt: str, buffer: Any) -> Tuple[Any, ...]: ...
def unpack_from(fmt: str, buffer: Any, offset: int = ...) -> Tuple[Any, ...]: ...
def calcsize(fmt: str) -> int: ...
class Struct:
format = b''
size = 0
def __init__(self, format: str) -> None: ...
def pack(self, *v: Any) -> bytes: ...
# TODO buffer type
def pack_into(self, buffer: Any, offset: int, *v: Any) -> None: ...
# TODO buffer type
def unpack(self, buffer: Any) -> Tuple[Any, ...]: ...
def unpack_from(self, buffer: Any, offset: int = ...) -> Tuple[Any, ...]: ...
mypy-0.470/typeshed/stdlib/3/difflib.pyi 0000644 0000000 0000000 00000005611 13023631176 016617 0 ustar root root # Stubs for difflib
# Based on https://docs.python.org/3.2/library/difflib.html
from typing import (
TypeVar, Callable, Iterable, Iterator, List, NamedTuple, Sequence, Tuple,
Generic, Optional
)
_T = TypeVar('_T')
class SequenceMatcher(Generic[_T]):
def __init__(self, isjunk: Optional[Callable[[_T], bool]] = ...,
a: Sequence[_T] = ..., b: Sequence[_T] = ...,
autojunk: bool = ...) -> None: ...
def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ...
def set_seq1(self, a: Sequence[_T]) -> None: ...
def set_seq2(self, b: Sequence[_T]) -> None: ...
def find_longest_match(self, alo: int, ahi: int, blo: int,
bhi: int) -> Tuple[int, int, int]: ...
def get_matching_blocks(self) -> List[Tuple[int, int, int]]: ...
def get_opcodes(self) -> List[Tuple[str, int, int, int, int]]: ...
def get_grouped_opcodes(self, n: int = ...
) -> Iterable[Tuple[str, int, int, int, int]]: ...
def ratio(self) -> float: ...
def quick_ratio(self) -> float: ...
def real_quick_ratio(self) -> float: ...
def get_close_matches(word: Sequence[_T], possibilities: List[Sequence[_T]],
n: int = ..., cutoff: float = ...) -> List[Sequence[_T]]: ...
class Differ:
def __init__(self, linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...) -> None: ...
def compare(self, a: Sequence[str], b: Sequence[str]) -> Iterator[str]: ...
def IS_LINE_JUNK(str) -> bool: ...
def IS_CHARACTER_JUNK(str) -> bool: ...
def unified_diff(a: Sequence[str], b: Sequence[str], fromfile: str = ...,
tofile: str = ..., fromfiledate: str = ..., tofiledate: str = ...,
n: int = ..., lineterm: str = ...) -> Iterator[str]: ...
def context_diff(a: Sequence[str], b: Sequence[str], fromfile: str=...,
tofile: str = ..., fromfiledate: str = ..., tofiledate: str = ...,
n: int = ..., lineterm: str = ...) -> Iterator[str]: ...
def ndiff(a: Sequence[str], b: Sequence[str],
linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...
) -> Iterator[str]: ...
class HtmlDiff(object):
def __init__(self, tabsize: int = ..., wrapcolumn: int = ...,
linejunk: Callable[[str], bool] = ...,
charjunk: Callable[[str], bool] = ...
) -> None: ...
def make_file(self, fromlines: Sequence[str], tolines: Sequence[str],
fromdesc: str = ..., todesc: str = ..., context: bool = ...,
numlines: int = ...) -> str: ...
def make_table(self, fromlines: Sequence[str], tolines: Sequence[str],
fromdesc: str = ..., todesc: str = ..., context: bool = ...,
numlines: int = ...) -> str: ...
def restore(delta: Iterable[str], which: int) -> Iterator[int]: ...
mypy-0.470/typeshed/stdlib/3/_importlib_modulespec.pyi 0000644 0000000 0000000 00000003275 13035744274 021613 0 ustar root root # ModuleSpec, ModuleType, Loader are part of a dependency cycle.
# They are officially defined/exported in other places:
#
# - ModuleType in types
# - Loader in importlib.abc
# - ModuleSpec in importlib.machinery (3.4 and later only)
from abc import ABCMeta
import sys
from typing import Any, Optional
if sys.version_info >= (3, 4):
class ModuleSpec:
def __init__(self, name: str, loader: Optional['Loader'], *,
origin: str = None, loader_state: Any = None,
is_package: bool = None) -> None: ...
name = ... # type: str
loader = ... # type: Optional[Loader]
origin = ... # type: Optional[str]
submodule_search_locations = ... # type: Optional[List[str]]
loader_state = ... # type: Any
cached = ... # type: Optional[str]
parent = ... # type: Optional[str]
has_location = ... # type: bool
class ModuleType:
__name__ = ... # type: str
__file__ = ... # type: str
if sys.version_info >= (3, 4):
__loader__ = ... # type: Optional[Loader]
__package__ = ... # type: Optional[str]
__spec__ = ... # type: Optional[ModuleSpec]
def __init__(self, name: str, doc: str) -> None: ...
class Loader(metaclass=ABCMeta):
def load_module(self, fullname: str) -> ModuleType: ...
if sys.version_info >= (3, 3):
def module_repr(self, module: ModuleType) -> str: ...
if sys.version_info >= (3, 4):
def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]: ...
# Not defined on the actual class for backwards-compatibility reasons,
# but expected in new code.
def exec_module(self, module: ModuleType) -> None: ...
mypy-0.470/typeshed/stdlib/3/dis.pyi 0000644 0000000 0000000 00000004105 13035744274 016003 0 ustar root root from typing import List, Union, Iterator, Tuple, Optional, Any, IO, NamedTuple
from opcode import (hasconst, hasname, hasjrel, hasjabs, haslocal, hascompare,
hasfree, hasnargs, cmp_op, opname, opmap, HAVE_ARGUMENT,
EXTENDED_ARG, stack_effect)
import types
_have_code = Union[types.MethodType, types.FunctionType, types.CodeType, type]
_have_code_or_string = Union[_have_code, str, bytes]
Instruction = NamedTuple(
"Instruction",
[
('opname', str),
('opcode', int),
('arg', Optional[int]),
('argval', Any),
('argrepr', str),
('offset', int),
('starts_line', Optional[int]),
('is_jump_target', bool)
]
)
# if sys.version_info >= (3, 4):
class Bytecode:
codeobj = ... # type: types.CodeType
first_line = ... # type: int
def __init__(self, x: _have_code_or_string, *, first_line: int=...,
current_offset: int=...) -> None: ...
def __iter__(self) -> Iterator[Instruction]: ...
def __repr__(self) -> str: ...
def info(self) -> str: ...
def dis(self) -> str: ...
@classmethod
def from_traceback(cls, tb: types.TracebackType) -> Bytecode: ...
COMPILER_FLAG_NAMES = ... # type: Dict[int, str]
def pretty_flags(flags: int) -> str: ...
def findlabels(code: _have_code) -> List[int]: ...
def findlinestarts(code: _have_code) -> Iterator[Tuple[int, int]]: ...
# Signature changes are not allowed by mypy
# 'All conditional function variants must have identical signatures'
# TODO: mypy issue #698
# if sys.version_info >= (3, 2):
def code_info(x: _have_code_or_string) -> str: ...
# `file` parameter requires sys.version_info >= (3, 4):
def dis(x: _have_code_or_string = ..., *, file: IO[str] = None) -> None: ...
def distb(tb: types.TracebackType = ..., *, file: IO[str] = None) -> None: ...
def disassemble(co: _have_code, lasti: int = ..., *, file: IO[str] = None) -> None: ...
def show_code(co: _have_code, *, file: IO[str] = None) -> None: ...
def get_instructions(x: _have_code, *, first_line: int = ...) -> Iterator[Instruction]: ...
mypy-0.470/typeshed/stdlib/3/hashlib.pyi 0000644 0000000 0000000 00000002531 13023631176 016630 0 ustar root root # Stubs for hashlib
from abc import abstractmethod, ABCMeta
from typing import AbstractSet
class Hash(metaclass=ABCMeta):
digest_size = ... # type: int
block_size = ... # type: int
# [Python documentation note] Changed in version 3.4: The name attribute has
# been present in CPython since its inception, but until Python 3.4 was not
# formally specified, so may not exist on some platforms
name = ... # type: str
@abstractmethod
def update(self, arg: bytes) -> None: ...
@abstractmethod
def digest(self) -> bytes: ...
@abstractmethod
def hexdigest(self) -> str: ...
@abstractmethod
def copy(self) -> 'Hash': ...
def md5(arg: bytes = ...) -> Hash: ...
def sha1(arg: bytes = ...) -> Hash: ...
def sha224(arg: bytes = ...) -> Hash: ...
def sha256(arg: bytes = ...) -> Hash: ...
def sha384(arg: bytes = ...) -> Hash: ...
def sha512(arg: bytes = ...) -> Hash: ...
def new(name: str, data: bytes = ...) -> Hash: ...
# New in version 3.2
algorithms_guaranteed = ... # type: AbstractSet[str]
algorithms_available = ... # type: AbstractSet[str]
# New in version 3.4
# TODO The documentation says "password and salt are interpreted as buffers of
# bytes", should we declare something other than bytes here?
def pbkdf2_hmac(name: str, password: bytes, salt: bytes, rounds: int, dklen: int = ...) -> bytes: ...
mypy-0.470/typeshed/stdlib/3/subprocess.pyi 0000644 0000000 0000000 00000022576 13044257024 017420 0 ustar root root # Stubs for subprocess
# Based on http://docs.python.org/3.5/library/subprocess.html
import sys
from typing import Sequence, Any, AnyStr, Mapping, Callable, Tuple, IO, Optional, Union, List, Type
from types import TracebackType
if sys.version_info >= (3, 5):
class CompletedProcess:
args = ... # type: Union[List, str]
returncode = ... # type: int
stdout = ... # type: Any
stderr = ... # type: Any
def __init__(self, args: Union[List, str],
returncode: int,
stdout: Union[str, bytes],
stderr: Union[str, bytes]) -> None: ...
def check_returncode(self) -> None: ...
# Nearly same args as Popen.__init__ except for timeout, input, and check
def run(args: Union[str, Sequence[str]],
timeout: float = ...,
input: Union[str, bytes] = ...,
check: bool = ...,
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stdout: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...) -> CompletedProcess: ...
# Same args as Popen.__init__
if sys.version_info >= (3, 3):
# 3.3 added timeout
def call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stdout: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
timeout: float = ...) -> int: ...
else:
def call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stdout: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...) -> int: ...
# Same args as Popen.__init__
if sys.version_info >= (3, 3):
# 3.3 added timeout
def check_call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stdout: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
timeout: float = ...) -> int: ...
else:
def check_call(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stdout: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...) -> int: ...
if sys.version_info >= (3, 4):
# 3.4 added input
def check_output(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
timeout: float = ...,
input: Union[str, bytes] = ...) -> Any: ...
elif sys.version_info >= (3, 3):
# 3.3 added timeout
def check_output(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
timeout: float = ...) -> Any: ...
else:
# Same args as Popen.__init__, except for stdout
def check_output(args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: str = ...,
stdin: Any = ...,
stderr: Any = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: str = ...,
env: Mapping[str, str] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...) -> Any: ...
# TODO types
PIPE = ... # type: Any
STDOUT = ... # type: Any
if sys.version_info >= (3, 3):
DEVNULL = ... # type: Any
class SubprocessError(Exception): ...
class TimeoutExpired(SubprocessError): ...
class CalledProcessError(Exception):
returncode = 0
cmd = ... # type: str
output = b'' # May be None
if sys.version_info >= (3, 5):
stdout = b''
stderr = b''
def __init__(self, returncode: int, cmd: str, output: Optional[str] = ...,
stderr: Optional[str] = ...) -> None: ...
class Popen:
stdin = ... # type: IO[Any]
stdout = ... # type: IO[Any]
stderr = ... # type: IO[Any]
pid = 0
returncode = 0
def __init__(self,
args: Union[str, Sequence[str]],
bufsize: int = ...,
executable: Optional[str] = ...,
stdin: Optional[Any] = ...,
stdout: Optional[Any] = ...,
stderr: Optional[Any] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[str] = ...,
env: Optional[Mapping[str, str]] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...) -> None: ...
def poll(self) -> int: ...
if sys.version_info >= (3, 3):
# 3.3 added timeout
def wait(self, timeout: Optional[float] = ...) -> int: ...
else:
def wait(self) ->int: ...
# Return str/bytes
if sys.version_info >= (3, 3):
def communicate(self, input: Optional[AnyStr] = ..., timeout: Optional[float] = ...) -> Tuple[Any, Any]: ...
else:
def communicate(self, input: Optional[AnyStr] = ...) -> Tuple[Any, Any]: ...
def send_signal(self, signal: int) -> None: ...
def terminate(self) -> None: ...
def kill(self) -> None: ...
def __enter__(self) -> 'Popen': ...
def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool: ...
def getstatusoutput(cmd: str) -> Tuple[int, str]: ...
def getoutput(cmd: str) -> str: ...
# Windows-only: STARTUPINFO etc.
mypy-0.470/typeshed/stdlib/3/binascii.pyi 0000644 0000000 0000000 00000001762 13023631176 017004 0 ustar root root # Stubs for binascii
# Based on http://docs.python.org/3.2/library/binascii.html
from typing import Union
def a2b_uu(string: Union[str, bytes]) -> bytes: ...
def b2a_uu(data: bytes) -> bytes: ...
def a2b_base64(string: Union[str, bytes]) -> bytes: ...
def b2a_base64(data: bytes) -> bytes: ...
def a2b_qp(string: Union[str, bytes], header: bool = ...) -> bytes: ...
def b2a_qp(data: bytes, quotetabs: bool = ..., istext: bool = ...,
header: bool = ...) -> bytes: ...
def a2b_hqx(string: Union[str, bytes]) -> bytes: ...
def rledecode_hqx(data: bytes) -> bytes: ...
def rlecode_hqx(data: bytes) -> bytes: ...
def b2a_hqx(data: bytes) -> bytes: ...
def crc_hqx(data: bytes, crc: int) -> int: ...
def crc32(data: bytes, crc: int = ...) -> int: ...
def b2a_hex(data: bytes) -> bytes: ...
def hexlify(data: bytes) -> bytes: ...
def a2b_hex(hexstr: Union[str, bytes]) -> bytes: ...
def unhexlify(hexlify: Union[str, bytes]) -> bytes: ...
class Error(Exception): ...
class Incomplete(Exception): ...
mypy-0.470/typeshed/stdlib/3/datetime.pyi 0000644 0000000 0000000 00000017346 13035744274 017033 0 ustar root root # Stubs for datetime
# NOTE: These are incomplete!
from typing import Optional, SupportsAbs, Tuple, overload
MINYEAR = 0
MAXYEAR = 0
TimeTuple = Tuple[int, int, int, int, int, int, int, int, int]
class tzinfo:
def tzname(self, dt: Optional[datetime]) -> str: ...
def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ...
def fromutc(self, dt: datetime) -> datetime: ...
class timezone(tzinfo):
utc = ... # type: timezone
min = ... # type: timezone
max = ... # type: timezone
def __init__(self, offset: timedelta, name: str = ...) -> None: ...
def __hash__(self) -> int: ...
_tzinfo = tzinfo
_timezone = timezone
class date:
min = ... # type: date
max = ... # type: date
resolution = ... # type: timedelta
def __init__(self, year: int, month: int = ..., day: int = ...) -> None: ...
@classmethod
def fromtimestamp(cls, t: float) -> date: ...
@classmethod
def today(cls) -> date: ...
@classmethod
def fromordinal(cls, n: int) -> date: ...
@property
def year(self) -> int: ...
@property
def month(self) -> int: ...
@property
def day(self) -> int: ...
def ctime(self) -> str: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: str) -> str: ...
def isoformat(self) -> str: ...
def timetuple(self) -> tuple: ... # TODO return type
def toordinal(self) -> int: ...
def replace(self, year: int = ..., month: int = ..., day: int = ...) -> date: ...
def __le__(self, other: date) -> bool: ...
def __lt__(self, other: date) -> bool: ...
def __ge__(self, other: date) -> bool: ...
def __gt__(self, other: date) -> bool: ...
def __add__(self, other: timedelta) -> date: ...
@overload
def __sub__(self, other: timedelta) -> date: ...
@overload
def __sub__(self, other: date) -> timedelta: ...
def __hash__(self) -> int: ...
def weekday(self) -> int: ...
def isoweekday(self) -> int: ...
def isocalendar(self) -> Tuple[int, int, int]: ...
class time:
min = ... # type: time
max = ... # type: time
resolution = ... # type: timedelta
def __init__(self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ...,
tzinfo: Optional[tzinfo] = ...) -> None: ...
@property
def hour(self) -> int: ...
@property
def minute(self) -> int: ...
@property
def second(self) -> int: ...
@property
def microsecond(self) -> int: ...
@property
def tzinfo(self) -> Optional[_tzinfo]: ...
def __le__(self, other: time) -> bool: ...
def __lt__(self, other: time) -> bool: ...
def __ge__(self, other: time) -> bool: ...
def __gt__(self, other: time) -> bool: ...
def __hash__(self) -> int: ...
def isoformat(self) -> str: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: str) -> str: ...
def utcoffset(self) -> Optional[timedelta]: ...
def tzname(self) -> Optional[str]: ...
def dst(self) -> Optional[int]: ...
def replace(self, hour: int = ..., minute: int = ..., second: int = ...,
microsecond: int = ..., tzinfo: Optional[_tzinfo] = None) -> time: ...
_date = date
_time = time
class timedelta(SupportsAbs[timedelta]):
min = ... # type: timedelta
max = ... # type: timedelta
resolution = ... # type: timedelta
def __init__(self, days: float = ..., seconds: float = ..., microseconds: float = ...,
milliseconds: float = ..., minutes: float = ..., hours: float = ...,
weeks: float = ...) -> None: ...
@property
def days(self) -> int: ...
@property
def seconds(self) -> int: ...
@property
def microseconds(self) -> int: ...
def total_seconds(self) -> float: ...
def __add__(self, other: timedelta) -> timedelta: ...
def __radd__(self, other: timedelta) -> timedelta: ...
def __sub__(self, other: timedelta) -> timedelta: ...
def __rsub(self, other: timedelta) -> timedelta: ...
def __neg__(self) -> timedelta: ...
def __pos__(self) -> timedelta: ...
def __abs__(self) -> timedelta: ...
def __mul__(self, other: float) -> timedelta: ...
def __rmul__(self, other: float) -> timedelta: ...
@overload
def __floordiv__(self, other: timedelta) -> int: ...
@overload
def __floordiv__(self, other: int) -> timedelta: ...
@overload
def __truediv__(self, other: timedelta) -> float: ...
@overload
def __truediv__(self, other: float) -> timedelta: ...
def __mod__(self, other: timedelta) -> timedelta: ...
def __divmod__(self, other: timedelta) -> Tuple[int, timedelta]: ...
def __le__(self, other: timedelta) -> bool: ...
def __lt__(self, other: timedelta) -> bool: ...
def __ge__(self, other: timedelta) -> bool: ...
def __gt__(self, other: timedelta) -> bool: ...
def __hash__(self) -> int: ...
class datetime:
# TODO: Is a subclass of date, but this would make some types incompatible.
min = ... # type: datetime
max = ... # type: datetime
resolution = ... # type: timedelta
def __init__(self, year: int, month: int = ..., day: int = ..., hour: int = ...,
minute: int = ..., second: int = ..., microsecond: int = ...,
tzinfo: Optional[tzinfo] = ...) -> None: ...
@property
def year(self) -> int: ...
@property
def month(self) -> int: ...
@property
def day(self) -> int: ...
@property
def hour(self) -> int: ...
@property
def minute(self) -> int: ...
@property
def second(self) -> int: ...
@property
def microsecond(self) -> int: ...
@property
def tzinfo(self) -> Optional[_tzinfo]: ...
@classmethod
def fromtimestamp(cls, t: float, tz: Optional[_tzinfo] = ...) -> datetime: ...
@classmethod
def utcfromtimestamp(cls, t: float) -> datetime: ...
@classmethod
def today(cls) -> datetime: ...
@classmethod
def fromordinal(cls, n: int) -> datetime: ...
@classmethod
def now(cls, tz: Optional[_tzinfo] = ...) -> datetime: ...
@classmethod
def utcnow(cls) -> datetime: ...
@classmethod
def combine(cls, date: date, time: time) -> datetime: ...
def strftime(self, fmt: str) -> str: ...
def __format__(self, fmt: str) -> str: ...
def toordinal(self) -> int: ...
def timetuple(self) -> TimeTuple: ... # TODO return type
def timestamp(self) -> float: ...
def utctimetuple(self) -> TimeTuple: ... # TODO return type
def date(self) -> _date: ...
def time(self) -> _time: ...
def timetz(self) -> _time: ...
def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int = ...,
minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo:
Optional[_tzinfo] = None) -> datetime: ...
def astimezone(self, tz: Optional[_tzinfo] = ...) -> datetime: ...
def ctime(self) -> str: ...
def isoformat(self, sep: str = ...) -> str: ...
@classmethod
def strptime(cls, date_string: str, format: str) -> datetime: ...
def utcoffset(self) -> Optional[timedelta]: ...
def tzname(self) -> Optional[str]: ...
def dst(self) -> Optional[int]: ...
def __le__(self, other: datetime) -> bool: ...
def __lt__(self, other: datetime) -> bool: ...
def __ge__(self, other: datetime) -> bool: ...
def __gt__(self, other: datetime) -> bool: ...
def __add__(self, other: timedelta) -> datetime: ...
@overload
def __sub__(self, other: datetime) -> timedelta: ...
@overload
def __sub__(self, other: timedelta) -> datetime: ...
def __hash__(self) -> int: ...
def weekday(self) -> int: ...
def isoweekday(self) -> int: ...
def isocalendar(self) -> Tuple[int, int, int]: ...
mypy-0.470/typeshed/stdlib/3/tempfile.pyi 0000644 0000000 0000000 00000003225 13035744274 017033 0 ustar root root # Stubs for tempfile
# Ron Murawski
# based on http://docs.python.org/3.3/library/tempfile.html
from types import TracebackType
from typing import BinaryIO, Optional, Tuple, Type
# global variables
tempdir = ... # type: str
template = ... # type: str
# TODO text files
# function stubs
def TemporaryFile(
mode: str = ..., buffering: int = ..., encoding: str = ...,
newline: str = ..., suffix: str = ..., prefix: str = ...,
dir: str = ...
) -> BinaryIO:
...
def NamedTemporaryFile(
mode: str = ..., buffering: int = ..., encoding: str = ...,
newline: str = ..., suffix: str = ..., prefix: str = ...,
dir: str = ..., delete: bool =...
) -> BinaryIO:
...
def SpooledTemporaryFile(
max_size: int = ..., mode: str = ..., buffering: int = ...,
encoding: str = ..., newline: str = ..., suffix: str = ...,
prefix: str = ..., dir: str = ...
) -> BinaryIO:
...
class TemporaryDirectory:
name = ... # type: str
def __init__(self, suffix: str = ..., prefix: str = ...,
dir: str = ...) -> None: ...
def cleanup(self) -> None: ...
def __enter__(self) -> str: ...
def __exit__(self, exc_type: Optional[Type[BaseException]],
exc_val: Optional[Exception],
exc_tb: Optional[TracebackType]) -> bool: ...
def mkstemp(suffix: str = ..., prefix: str = ..., dir: str = ...,
text: bool = ...) -> Tuple[int, str]: ...
def mkdtemp(suffix: str = ..., prefix: str = ...,
dir: str = ...) -> str: ...
def mktemp(suffix: str = ..., prefix: str = ..., dir: str = ...) -> str: ...
def gettempdir() -> str: ...
def gettempprefix() -> str: ...
mypy-0.470/typeshed/stdlib/3/re.pyi 0000644 0000000 0000000 00000007062 13023631176 015630 0 ustar root root # Stubs for re
# Ron Murawski
# 'bytes' support added by Jukka Lehtosalo
# based on: http://docs.python.org/3.2/library/re.html
# and http://hg.python.org/cpython/file/618ea5612e83/Lib/re.py
from typing import (
List, Iterator, overload, Callable, Tuple, Sequence, Dict,
Generic, AnyStr, Match, Pattern, Any, Optional
)
# ----- re variables and constants -----
A = 0
ASCII = 0
DEBUG = 0
I = 0
IGNORECASE = 0
L = 0
LOCALE = 0
M = 0
MULTILINE = 0
S = 0
DOTALL = 0
X = 0
VERBOSE = 0
U = 0
UNICODE = 0
class error(Exception): ...
@overload
def compile(pattern: AnyStr, flags: int = ...) -> Pattern[AnyStr]: ...
@overload
def compile(pattern: Pattern[AnyStr], flags: int = ...) -> Pattern[AnyStr]: ...
@overload
def search(pattern: AnyStr, string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def search(pattern: Pattern[AnyStr], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def match(pattern: AnyStr, string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
@overload
def match(pattern: Pattern[AnyStr], string: AnyStr, flags: int = ...) -> Match[AnyStr]: ...
# New in Python 3.4
@overload
def fullmatch(pattern: AnyStr, string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ...
@overload
def fullmatch(pattern: Pattern[AnyStr], string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ...
@overload
def split(pattern: AnyStr, string: AnyStr,
maxsplit: int = ..., flags: int = ...) -> List[AnyStr]: ...
@overload
def split(pattern: Pattern[AnyStr], string: AnyStr,
maxsplit: int = ..., flags: int = ...) -> List[AnyStr]: ...
@overload
def findall(pattern: AnyStr, string: AnyStr, flags: int = ...) -> List[Any]: ...
@overload
def findall(pattern: Pattern[AnyStr], string: AnyStr, flags: int = ...) -> List[Any]: ...
# Return an iterator yielding match objects over all non-overlapping matches
# for the RE pattern in string. The string is scanned left-to-right, and
# matches are returned in the order found. Empty matches are included in the
# result unless they touch the beginning of another match.
@overload
def finditer(pattern: AnyStr, string: AnyStr,
flags: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def finditer(pattern: Pattern[AnyStr], string: AnyStr,
flags: int = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def sub(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ..., flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> AnyStr: ...
@overload
def sub(pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ..., flags: int = ...) -> AnyStr: ...
@overload
def subn(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr],
string: AnyStr, count: int = ...,
flags: int = ...) -> Tuple[AnyStr, int]: ...
def escape(string: AnyStr) -> AnyStr: ...
def purge() -> None: ...
mypy-0.470/typeshed/stdlib/3/signal.pyi 0000644 0000000 0000000 00000010624 13035744274 016504 0 ustar root root """Stub file for the 'signal' module."""
import sys
from enum import IntEnum
from typing import Any, Callable, List, Tuple, Dict, Generic, Union, Optional, Iterable, Set
from types import FrameType
class ItimerError(IOError): ...
ITIMER_PROF = ... # type: int
ITIMER_REAL = ... # type: int
ITIMER_VIRTUAL = ... # type: int
NSIG = ... # type: int
if sys.version_info >= (3, 5):
class Signals(IntEnum):
SIGABRT = ...
SIGALRM = ...
SIGBUS = ...
SIGCHLD = ...
SIGCLD = ...
SIGCONT = ...
SIGFPE = ...
SIGHUP = ...
SIGILL = ...
SIGINT = ...
SIGIO = ...
SIGIOT = ...
SIGKILL = ...
SIGPIPE = ...
SIGPOLL = ...
SIGPROF = ...
SIGPWR = ...
SIGQUIT = ...
SIGRTMAX = ...
SIGRTMIN = ...
SIGSEGV = ...
SIGSTOP = ...
SIGSYS = ...
SIGTERM = ...
SIGTRAP = ...
SIGTSTP = ...
SIGTTIN = ...
SIGTTOU = ...
SIGURG = ...
SIGUSR1 = ...
SIGUSR2 = ...
SIGVTALRM = ...
SIGWINCH = ...
SIGXCPU = ...
SIGXFSZ = ...
class Handlers(IntEnum):
SIG_DFL = ...
SIG_IGN = ...
SIG_DFL = Handlers.SIG_DFL
SIG_IGN = Handlers.SIG_IGN
class Sigmasks(IntEnum):
SIG_BLOCK = ...
SIG_UNBLOCK = ...
SIG_SETMASK = ...
SIG_BLOCK = Sigmasks.SIG_BLOCK
SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
SIG_SETMASK = Sigmasks.SIG_SETMASK
_SIG = Signals
_SIGNUM = Union[int, Signals]
_HANDLER = Union[Callable[[Signals, FrameType], None], int, Handlers, None]
else:
SIG_DFL = ... # type: int
SIG_IGN = ... # type: int
SIG_BLOCK = ... # type: int
SIG_UNBLOCK = ... # type: int
SIG_SETMASK = ... # type: int
_SIG = int
_SIGNUM = int
_HANDLER = Union[Callable[[int, FrameType], None], int, None]
SIGABRT = ... # type: _SIG
SIGALRM = ... # type: _SIG
SIGBUS = ... # type: _SIG
SIGCHLD = ... # type: _SIG
SIGCLD = ... # type: _SIG
SIGCONT = ... # type: _SIG
SIGFPE = ... # type: _SIG
SIGHUP = ... # type: _SIG
SIGILL = ... # type: _SIG
SIGINT = ... # type: _SIG
SIGIO = ... # type: _SIG
SIGIOT = ... # type: _SIG
SIGKILL = ... # type: _SIG
SIGPIPE = ... # type: _SIG
SIGPOLL = ... # type: _SIG
SIGPROF = ... # type: _SIG
SIGPWR = ... # type: _SIG
SIGQUIT = ... # type: _SIG
SIGRTMAX = ... # type: _SIG
SIGRTMIN = ... # type: _SIG
SIGSEGV = ... # type: _SIG
SIGSTOP = ... # type: _SIG
SIGSYS = ... # type: _SIG
SIGTERM = ... # type: _SIG
SIGTRAP = ... # type: _SIG
SIGTSTP = ... # type: _SIG
SIGTTIN = ... # type: _SIG
SIGTTOU = ... # type: _SIG
SIGURG = ... # type: _SIG
SIGUSR1 = ... # type: _SIG
SIGUSR2 = ... # type: _SIG
SIGVTALRM = ... # type: _SIG
SIGWINCH = ... # type: _SIG
SIGXCPU = ... # type: _SIG
SIGXFSZ = ... # type: _SIG
CTRL_C_EVENT = 0 # Windows
CTRL_BREAK_EVENT = 0 # Windows
class struct_siginfo(Tuple[int, int, int, int, int, int, int]):
def __init__(self, sequence: Iterable[int]) -> None: ...
@property
def si_signo(self) -> int: ...
@property
def si_code(self) -> int: ...
@property
def si_errno(self) -> int: ...
@property
def si_pid(self) -> int: ...
@property
def si_uid(self) -> int: ...
@property
def si_status(self) -> int: ...
@property
def si_band(self) -> int: ...
def alarm(time: int) -> int: ...
def default_int_handler(signum: int, frame: FrameType) -> None:
raise KeyboardInterrupt()
def getitimer(which: int) -> Tuple[float, float]: ...
def getsignal(signalnum: _SIGNUM) -> _HANDLER:
raise ValueError()
def pause() -> None: ...
def pthread_kill(thread_id: int, signum: int) -> None:
raise OSError()
def pthread_sigmask(how: int, mask: Iterable[int]) -> Set[_SIGNUM]:
raise OSError()
def set_wakeup_fd(fd: int) -> int: ...
def setitimer(which: int, seconds: float, interval: float = ...) -> Tuple[float, float]: ...
def siginterrupt(signalnum: int, flag: bool) -> None:
raise OSError()
def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER:
raise OSError()
def sigpending() -> Any:
raise OSError()
def sigtimedwait(sigset: Iterable[int], timeout: float) -> Optional[struct_siginfo]:
raise OSError()
raise ValueError()
def sigwait(sigset: Iterable[int]) -> _SIGNUM:
raise OSError()
def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo:
raise OSError()
mypy-0.470/typeshed/stdlib/3/_markupbase.pyi 0000644 0000000 0000000 00000000410 13023631176 017501 0 ustar root root from typing import Tuple
class ParserBase(object):
def __init__(self) -> None: ...
def error(self, message: str) -> None: ...
def reset(self) -> None: ...
def getpos(self) -> Tuple[int, int]: ...
def unkown_decl(self, data: str) -> None: ...
mypy-0.470/typeshed/stdlib/3/importlib/ 0000755 0000000 0000000 00000000000 13044320557 016474 5 ustar root root mypy-0.470/typeshed/stdlib/3/importlib/machinery.pyi 0000644 0000000 0000000 00000015652 13035744274 021215 0 ustar root root import importlib.abc
import sys
import types
from typing import Any, Callable, List, Optional, Sequence, Tuple, Union
# ModuleSpec is exported from this module, but for circular import
# reasons exists in its own stub file (with Loader and ModuleType).
if sys.version_info >= (3, 4):
from _importlib_modulespec import ModuleSpec as ModuleSpec # Exported
if sys.version_info >= (3, 3):
class BuiltinImporter(importlib.abc.MetaPathFinder,
importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
if sys.version_info >= (3, 4):
@classmethod
def find_spec(cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]],
target: types.ModuleType = None) -> Optional[ModuleSpec]:
...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ... # type: ignore
@classmethod
def get_source(cls, fullname: str) -> None: ... # type: ignore
# Loader
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
if sys.version_info >= (3, 3):
@staticmethod
def module_repr(module: types.ModuleType) -> str: ... # type: ignore
if sys.version_info >= (3, 4):
@classmethod
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ...
@classmethod
def exec_module(cls, module: types.ModuleType) -> None: ...
else:
class BuiltinImporter(importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ... # type: ignore
@classmethod
def get_source(cls, fullname: str) -> None: ... # type: ignore
# Loader
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
if sys.version_info >= (3, 3):
class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
if sys.version_info >= (3, 4):
@classmethod
def find_spec(cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]],
target: types.ModuleType = None) -> Optional[ModuleSpec]:
...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ... # type: ignore
@classmethod
def get_source(cls, fullname: str) -> None: ... # type: ignore
# Loader
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
if sys.version_info >= (3, 3):
@staticmethod
def module_repr(module: types.ModuleType) -> str: ... # type: ignore
if sys.version_info >= (3, 4):
@classmethod
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]:
...
@staticmethod
def exec_module(module: types.ModuleType) -> None: ... # type: ignore
else:
class FrozenImporter(importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ... # type: ignore
@classmethod
def get_source(cls, fullname: str) -> None: ... # type: ignore
# Loader
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
if sys.version_info >= (3, 3):
class WindowsRegisteryFinder(importlib.abc.MetaPathFinder):
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
if sys.version_info >= (3, 4):
@classmethod
def find_spec(cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]],
target: types.ModuleType = None) -> Optional[ModuleSpec]:
...
else:
class WindowsRegisteryFinder:
@classmethod
def find_module(
cls, fullname: str,
path: Optional[Sequence[importlib.abc._Path]]
) -> Optional[importlib.abc.Loader]:
...
if sys.version_info >= (3, 3):
class PathFinder(importlib.abc.MetaPathFinder): ...
else:
class PathFinder: ...
if sys.version_info >= (3, 3):
SOURCE_SUFFIXES = ... # type: List[str]
DEBUG_BYTECODE_SUFFIXES = ... # type: List[str]
OPTIMIZED_BYTECODE_SUFFIXES = ... # type: List[str]
BYTECODE_SUFFIXES = ... # type: List[str]
EXTENSION_SUFFIXES = ... # type: List[str]
def all_suffixes() -> List[str]: ...
class FileFinder(importlib.abc.PathEntryFinder):
path = ... # type: str
def __init__(
self, path: str,
*loader_details: Tuple[importlib.abc.Loader, List[str]]
) -> None: ...
@classmethod
def path_hook(
*loader_details: Tuple[importlib.abc.Loader, List[str]]
) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
class SourceFileLoader(importlib.abc.FileLoader,
importlib.abc.SourceLoader):
...
class SourcelessFileLoader(importlib.abc.FileLoader,
importlib.abc.SourceLoader):
...
class ExtensionFileLoader(importlib.abc.ExecutionLoader):
def get_filename(self, fullname: str) -> importlib.abc._Path: ...
def get_source(self, fullname: str) -> None: ... # type: ignore
mypy-0.470/typeshed/stdlib/3/importlib/__init__.pyi 0000644 0000000 0000000 00000001164 13023631176 020757 0 ustar root root from importlib.abc import Loader
import sys
import types
from typing import Any, Mapping, Optional, Sequence
def __import__(name: str, globals: Mapping[str, Any] = None,
locals: Mapping[str, Any] = None, fromlist: Sequence[str] = (),
level: int = 0) -> types.ModuleType: ...
def import_module(name: str, package: str = None) -> types.ModuleType: ...
if sys.version_info >= (3, 3):
def find_loader(name: str, path: str = None) -> Optional[Loader]: ...
def invalidate_caches() -> None: ...
if sys.version_info >= (3, 4):
def reload(module: types.ModuleType) -> types.ModuleType: ...
mypy-0.470/typeshed/stdlib/3/importlib/util.pyi 0000644 0000000 0000000 00000003621 13035744274 020204 0 ustar root root import importlib.abc
import importlib.machinery
import sys
import types
from typing import Any, Callable, List, Optional
def module_for_loader(
fxn: Callable[..., types.ModuleType]
) -> Callable[..., types.ModuleType]: ...
def set_loader(
fxn: Callable[..., types.ModuleType]
) -> Callable[..., types.ModuleType]: ...
def set_package(
fxn: Callable[..., types.ModuleType]
) -> Callable[..., types.ModuleType]: ...
if sys.version_info >= (3, 3):
def resolve_name(name: str, package: str) -> str: ...
if sys.version_info >= (3, 4):
MAGIC_NUMBER = ... # type: bytes
def cache_from_source(path: str, debug_override: bool = None, *,
optimization: Any = None) -> str: ...
def source_from_cache(path: str) -> str: ...
def decode_source(source_bytes: bytes) -> str: ...
def find_spec(
name: str, package: str = None
) -> importlib.machinery.ModuleSpec: ...
def spec_from_loader(
name: str, loader: Optional[importlib.abc.Loader], *,
origin: str = None, loader_state: Any = None,
is_package: bool = None
) -> importlib.machinery.ModuleSpec: ...
def spec_from_file_location(
name: str, location: str, *,
loader: importlib.abc.Loader = None,
submodule_search_locations: List[str]=None
) -> importlib.machinery.ModuleSpec: ...
if sys.version_info >= (3, 5):
def module_from_spec(
spec: importlib.machinery.ModuleSpec
) -> types.ModuleType: ...
class LazyLoader(importlib.abc.Loader):
def __init__(self, loader: importlib.abc.Loader) -> None: ...
@classmethod
def factory(
cls, loader: importlib.abc.Loader
) -> Callable[..., 'LazyLoader']: ...
def create_module(
self, spec: importlib.machinery.ModuleSpec
) -> Optional[types.ModuleType]: ...
def exec_module(self, module: types.ModuleType) -> None: ...
mypy-0.470/typeshed/stdlib/3/importlib/abc.pyi 0000644 0000000 0000000 00000007064 13035744274 017761 0 ustar root root from abc import ABCMeta, abstractmethod
import sys
import types
from typing import Any, Mapping, Optional, Sequence, Tuple, Union
# Loader is exported from this module, but for circular import reasons
# exists in its own stub file (with ModuleSpec and ModuleType).
from _importlib_modulespec import Loader as Loader # Exported
if sys.version_info >= (3, 4):
from _importlib_modulespec import ModuleSpec
_Path = Union[bytes, str]
class Finder(metaclass=ABCMeta):
...
# Technically this class defines the following method, but its subclasses
# in this module violate its signature. Since this class is deprecated, it's
# easier to simply ignore that this method exists.
# @abstractmethod
# def find_module(self, fullname: str,
# path: Sequence[_Path] = None) -> Optional[Loader]: ...
class ResourceLoader(Loader):
@abstractmethod
def get_data(self, path: _Path) -> bytes: ...
class InspectLoader(Loader):
def is_package(self, fullname: str) -> bool: ...
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
def load_module(self, fullname: str) -> types.ModuleType: ...
@abstractmethod
def get_source(self, fullname: str) -> Optional[str]: ...
if sys.version_info >= (3, 4):
def exec_module(self, module: types.ModuleType) -> None: ...
if sys.version_info[:2] == (3, 4):
def source_to_code(self, data: Union[bytes, str],
path: str = '') -> types.CodeType: ...
elif sys.version_info >= (3, 5):
@staticmethod
def source_to_code(data: Union[bytes, str],
path: str = '') -> types.CodeType: ...
class ExecutionLoader(InspectLoader):
@abstractmethod
def get_filename(self, fullname: str) -> _Path: ...
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
class SourceLoader(ResourceLoader, ExecutionLoader):
def path_mtime(self, path: _Path) -> Union[int, float]: ...
def set_data(self, path: _Path, data: bytes) -> None: ...
def get_source(self, fullname: str) -> Optional[str]: ...
if sys.version_info >= (3, 3):
def path_stats(self, path: _Path) -> Mapping[str, Any]: ...
if sys.version_info >= (3, 3):
class MetaPathFinder(Finder):
def find_module(self, fullname: str,
path: Optional[Sequence[_Path]]) -> Optional[Loader]:
...
def invalidate_caches(self) -> None: ...
if sys.version_info >= (3, 4):
# Not defined on the actual class, but expected to exist.
def find_spec(
self, fullname: str, path: Optional[Sequence[_Path]],
target: types.ModuleType = None
) -> Optional[ModuleSpec]:
...
class PathEntryFinder(Finder):
def find_module(self, fullname: str) -> Optional[Loader]: ...
def find_loader(
self, fullname: str
) -> Tuple[Optional[Loader], Sequence[_Path]]: ...
def invalidate_caches(self) -> None: ...
if sys.version_info >= (3, 4):
# Not defined on the actual class, but expected to exist.
def find_spec(
self, fullname: str,
target: types.ModuleType = None
) -> Optional[ModuleSpec]: ...
class FileLoader(ResourceLoader, ExecutionLoader):
name = ... # type: str
path = ... # type: _Path
def __init__(self, fullname: str, path: _Path) -> None: ...
def get_data(self, path: _Path) -> bytes: ...
def get_filename(self, fullname: str) -> _Path: ...
mypy-0.470/typeshed/stdlib/3/curses/ 0000755 0000000 0000000 00000000000 13044320557 015777 5 ustar root root mypy-0.470/typeshed/stdlib/3/curses/__init__.pyi 0000644 0000000 0000000 00000000575 13035744274 020276 0 ustar root root # Stubs for curses (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from _curses import * # noqa: F403
# Stubgen imports a python version of has_key only if it's not present
# in _curses (which it is in this stub)
# from .has_key import has_key as has_key
def initscr(): ...
def start_color(): ...
def wrapper(func, *args, **kwds): ...
mypy-0.470/typeshed/stdlib/3/_compression.pyi 0000644 0000000 0000000 00000001057 13035744274 017727 0 ustar root root # Stubs for _compression (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import io
BUFFER_SIZE = ... # type: Any
class BaseStream(io.BufferedIOBase): ...
class DecompressReader(io.RawIOBase):
def readable(self): ...
def __init__(self, fp, decomp_factory, trailing_error=..., **decomp_args): ...
def close(self): ...
def seekable(self): ...
def readinto(self, b): ...
def read(self, size=-1): ...
def seek(self, offset, whence=...): ...
def tell(self): ...
mypy-0.470/typeshed/tests/ 0000755 0000000 0000000 00000000000 13044320557 014212 5 ustar root root mypy-0.470/typeshed/tests/mypy_test.py 0000755 0000000 0000000 00000012046 13035744274 016635 0 ustar root root #!/usr/bin/env python3
"""Test runner for typeshed.
Depends on mypy being installed.
Approach:
1. Parse sys.argv
2. Compute appropriate arguments for mypy
3. Stuff those arguments into sys.argv
4. Run mypy.main('')
5. Repeat steps 2-4 for other mypy runs (e.g. --py2)
"""
import os
import re
import sys
import argparse
parser = argparse.ArgumentParser(description="Test runner for typeshed. "
"Patterns are unanchored regexps on the full path.")
parser.add_argument('-v', '--verbose', action='count', default=0, help="More output")
parser.add_argument('-n', '--dry-run', action='store_true', help="Don't actually run mypy")
parser.add_argument('-x', '--exclude', type=str, nargs='*', help="Exclude pattern")
parser.add_argument('-p', '--python-version', type=str, nargs='*',
help="These versions only (major[.minor])")
parser.add_argument('filter', type=str, nargs='*', help="Include pattern (default all)")
def log(args, *varargs):
if args.verbose >= 2:
print(*varargs)
def match(fn, args, blacklist):
if blacklist.match(fn):
log(args, fn, 'exluded by blacklist')
return False
if not args.filter and not args.exclude:
log(args, fn, 'accept by default')
return True
if args.exclude:
for f in args.exclude:
if re.search(f, fn):
log(args, fn, 'excluded by pattern', f)
return False
if args.filter:
for f in args.filter:
if re.search(f, fn):
log(args, fn, 'accepted by pattern', f)
return True
if args.filter:
log(args, fn, 'rejected (no pattern matches)')
return False
log(args, fn, 'accepted (no exclude pattern matches)')
return True
def libpath(major, minor):
versions = ['%d.%d' % (major, minor)
for minor in reversed(range(minor + 1))]
versions.append(str(major))
versions.append('2and3')
paths = []
for v in versions:
for top in ['stdlib', 'third_party']:
p = os.path.join(top, v)
if os.path.isdir(p):
paths.append(p)
return paths
def main():
args = parser.parse_args()
with open(os.path.join(os.path.dirname(__file__), "mypy_blacklist.txt")) as f:
blacklist = re.compile("(%s)$" % "|".join(
re.findall(r"^\s*([^\s#]+)\s*(?:#.*)?$", f.read(), flags=re.M)))
try:
from mypy.main import main as mypy_main
except ImportError:
print("Cannot import mypy. Did you install it?")
sys.exit(1)
versions = [(3, 6), (3, 5), (3, 4), (3, 3), (3, 2), (2, 7)]
if args.python_version:
versions = [v for v in versions
if any(('%d.%d' % v).startswith(av) for av in args.python_version)]
if not versions:
print("--- no versions selected ---")
sys.exit(1)
code = 0
runs = 0
for major, minor in versions:
roots = libpath(major, minor)
files = []
seen = {'__builtin__', 'builtins', 'typing'} # Always ignore these.
for root in roots:
names = os.listdir(root)
for name in names:
full = os.path.join(root, name)
mod, ext = os.path.splitext(name)
if mod in seen or mod.startswith('.'):
continue
if ext in ['.pyi', '.py']:
if match(full, args, blacklist):
seen.add(mod)
files.append(full)
elif (os.path.isfile(os.path.join(full, '__init__.pyi')) or
os.path.isfile(os.path.join(full, '__init__.py'))):
for r, ds, fs in os.walk(full):
ds.sort()
fs.sort()
for f in fs:
m, x = os.path.splitext(f)
if x in ['.pyi', '.py']:
fn = os.path.join(r, f)
if match(fn, args, blacklist):
seen.add(mod)
files.append(fn)
if files:
runs += 1
flags = ['--python-version', '%d.%d' % (major, minor)]
flags.append('--strict-optional')
if (major, minor) >= (3, 6):
flags.append('--fast-parser')
# flags.append('--warn-unused-ignores') # Fast parser and regular parser disagree.
sys.argv = ['mypy'] + flags + files
if args.verbose:
print("running", ' '.join(sys.argv))
else:
print("running mypy", ' '.join(flags), "# with", len(files), "files")
try:
if not args.dry_run:
mypy_main('')
except SystemExit as err:
code = max(code, err.code)
if code:
print("--- exit status", code, "---")
sys.exit(code)
if not runs:
print("--- nothing to do; exit 1 ---")
sys.exit(1)
if __name__ == '__main__':
main()
mypy-0.470/typeshed/tests/pytype_test.py 0000755 0000000 0000000 00000005575 13035744274 017202 0 ustar root root #!/usr/bin/env python
"""Test runner for typeshed.
Depends on mypy and pytype being installed.
If pytype is installed:
1. For every pyi, run "pytd " in a separate process
"""
import os
import re
import sys
import argparse
import subprocess
import collections
parser = argparse.ArgumentParser(description="Pytype tests.")
parser.add_argument('-n', '--dry-run', action='store_true', help="Don't actually run tests")
parser.add_argument('--num-parallel', type=int, default=1,
help="Number of test processes to spawn")
def main():
args = parser.parse_args()
code, runs = pytype_test(args)
if code:
print("--- exit status %d ---" % code)
sys.exit(code)
if not runs:
print("--- nothing to do; exit 1 ---")
sys.exit(1)
def load_blacklist():
filename = os.path.join(os.path.dirname(__file__), "pytype_blacklist.txt")
regex = r"^\s*([^\s#]+)\s*(?:#.*)?$"
with open(filename) as f:
return re.findall(regex, f.read(), flags=re.M)
class PytdRun(object):
def __init__(self, args, dry_run=False):
self.args = args
self.dry_run = dry_run
self.results = None
if dry_run:
self.results = (0, "", "")
else:
self.proc = subprocess.Popen(
["pytd"] + args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def communicate(self):
if self.results:
return self.results
stdout, stderr = self.proc.communicate()
self.results = self.proc.returncode, stdout, stderr
return self.results
def pytype_test(args):
try:
PytdRun(["-h"]).communicate()
except OSError:
print("Cannot run pytd. Did you install pytype?")
return 0, 0
wanted = re.compile(r"stdlib/(2|2\.7|2and3)/.*\.pyi$")
skipped = re.compile("(%s)$" % "|".join(load_blacklist()))
files = []
for root, _, filenames in os.walk("stdlib"):
for f in sorted(filenames):
f = os.path.join(root, f)
if wanted.search(f) and not skipped.search(f):
files.append(f)
running_tests = collections.deque()
max_code, runs, errors = 0, 0, 0
print("Running pytype tests...")
while 1:
while files and len(running_tests) < args.num_parallel:
test_run = PytdRun([files.pop()], dry_run=args.dry_run)
running_tests.append(test_run)
if not running_tests:
break
test_run = running_tests.popleft()
code, stdout, stderr = test_run.communicate()
max_code = max(max_code, code)
runs += 1
if code:
print("pytd error processing \"%s\":" % test_run.args[0])
print(stderr)
errors += 1
print("Ran pytype with %d pyis, got %d errors." % (runs, errors))
return max_code, runs
if __name__ == '__main__':
main()
mypy-0.470/typeshed/third_party/ 0000755 0000000 0000000 00000000000 13044320557 015401 5 ustar root root mypy-0.470/typeshed/third_party/3.6/ 0000755 0000000 0000000 00000000000 13044320557 015707 5 ustar root root mypy-0.470/typeshed/third_party/3.6/click/ 0000755 0000000 0000000 00000000000 13044320557 016774 5 ustar root root mypy-0.470/typeshed/third_party/3.6/click/__init__.pyi 0000644 0000000 0000000 00000005441 13035744274 021270 0 ustar root root # -*- coding: utf-8 -*-
"""
click
~~~~~
Click is a simple Python module that wraps the stdlib's optparse to make
writing command line scripts fun. Unlike other modules, it's based around
a simple API that does not come with too much magic and is composable.
In case optparse ever gets removed from the stdlib, it will be shipped by
this module.
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
# Core classes
from .core import Context, BaseCommand, Command, MultiCommand, Group, \
CommandCollection, Parameter, Option, Argument
# Globals
from .globals import get_current_context
# Decorators
from .decorators import pass_context, pass_obj, make_pass_decorator, \
command, group, argument, option, confirmation_option, \
password_option, version_option, help_option
# Types
from .types import ParamType, File, Path, Choice, IntRange, Tuple, \
STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED
# Utilities
from .utils import echo, get_binary_stream, get_text_stream, open_file, \
format_filename, get_app_dir, get_os_args
# Terminal functions
from .termui import prompt, confirm, get_terminal_size, echo_via_pager, \
progressbar, clear, style, unstyle, secho, edit, launch, getchar, \
pause
# Exceptions
from .exceptions import ClickException, UsageError, BadParameter, \
FileError, Abort, NoSuchOption, BadOptionUsage, BadArgumentUsage, \
MissingParameter
# Formatting
from .formatting import HelpFormatter, wrap_text
# Parsing
from .parser import OptionParser
__all__ = [
# Core classes
'Context', 'BaseCommand', 'Command', 'MultiCommand', 'Group',
'CommandCollection', 'Parameter', 'Option', 'Argument',
# Globals
'get_current_context',
# Decorators
'pass_context', 'pass_obj', 'make_pass_decorator', 'command', 'group',
'argument', 'option', 'confirmation_option', 'password_option',
'version_option', 'help_option',
# Types
'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple', 'STRING',
'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
# Utilities
'echo', 'get_binary_stream', 'get_text_stream', 'open_file',
'format_filename', 'get_app_dir', 'get_os_args',
# Terminal functions
'prompt', 'confirm', 'get_terminal_size', 'echo_via_pager',
'progressbar', 'clear', 'style', 'unstyle', 'secho', 'edit', 'launch',
'getchar', 'pause',
# Exceptions
'ClickException', 'UsageError', 'BadParameter', 'FileError',
'Abort', 'NoSuchOption', 'BadOptionUsage', 'BadArgumentUsage',
'MissingParameter',
# Formatting
'HelpFormatter', 'wrap_text',
# Parsing
'OptionParser',
]
# Controls if click should emit the warning about the use of unicode
# literals.
disable_unicode_literals_warning = False
__version__ = '6.6'
mypy-0.470/typeshed/third_party/3.6/click/termui.pyi 0000644 0000000 0000000 00000004770 13035744274 021042 0 ustar root root from contextlib import contextmanager
from typing import (
Any,
Callable,
Generator,
Iterable,
IO,
List,
Optional,
Tuple,
TypeVar,
)
def hidden_prompt_func(prompt: str) -> str:
...
def _build_prompt(
text: str,
suffix: str,
show_default: bool = False,
default: str = None,
) -> str:
...
def prompt(
text: str,
default: str = None,
hide_input: bool = False,
confirmation_prompt: bool = False,
type: Any = None,
value_proc: Callable[[Optional[str]], Any] = None,
prompt_suffix: str = ': ',
show_default: bool = True,
err: bool = False,
) -> Any:
...
def confirm(
text: str,
default: bool = False,
abort: bool = False,
prompt_suffix: str = ': ',
show_default: bool = True,
err: bool = False,
) -> bool:
...
def get_terminal_size() -> Tuple[int, int]:
...
def echo_via_pager(text: str, color: bool = None) -> None:
...
T = TypeVar('T')
@contextmanager
def progressbar(
iterable=Iterable[T],
length: int = None,
label: str = None,
show_eta: bool = True,
show_percent: bool = None,
show_pos: bool = False,
item_show_func: Callable[[T], str] = None,
fill_char: str = '#',
empty_char: str = '-',
bar_template: str = '%(label)s [%(bar)s] %(info)s',
info_sep: str = ' ',
width: int = 36,
file: IO = None,
color: bool = None,
) -> Generator[T, None, None]:
...
def clear() -> None:
...
def style(
text: str,
fg: str = None,
bg: str = None,
bold: bool = None,
dim: bool = None,
underline: bool = None,
blink: bool = None,
reverse: bool = None,
reset: bool = True,
):
...
def unstyle(text: str) -> str:
...
# Styling options copied from style() for nicer type checking.
def secho(
text: str,
file: IO = None,
nl: bool =True,
err: bool = False,
color: bool = None,
fg: str = None,
bg: str = None,
bold: bool = None,
dim: bool = None,
underline: bool = None,
blink: bool = None,
reverse: bool = None,
reset: bool = True,
):
...
def edit(
text: str = None,
editor: str = None,
env: str = None,
require_save: bool = True,
extension: str = '.txt',
filename: str = None,
) -> str:
...
def launch(url: str, wait: bool = False, locate: bool = False) -> int:
...
def getchar(echo: bool = False) -> str:
...
def pause(
info: str ='Press any key to continue ...', err: bool = False
) -> None:
...
mypy-0.470/typeshed/third_party/3.6/click/types.pyi 0000644 0000000 0000000 00000012520 13035744274 020671 0 ustar root root from typing import Any, Callable, IO, Iterable, List, Optional, TypeVar, Union
import uuid
from click.core import Context, Parameter
class ParamType:
name: str
is_composite: bool
envvar_list_splitter: Optional[str]
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> Any:
...
def get_metavar(self, param: Parameter) -> str:
...
def get_missing_message(self, param: Parameter) -> str:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> Any:
...
def split_envvar_value(self, rv: str) -> List[str]:
...
def fail(self, message: str, param: Parameter = None, ctx: Context = None) -> None:
...
class BoolParamType(ParamType):
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> bool:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> bool:
...
class CompositeParamType(ParamType):
arity: int
class Choice(ParamType):
choices: Iterable[str]
def __init__(self, choices: Iterable[str]) -> None:
...
class FloatParamType(ParamType):
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> float:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> float:
...
class FloatRange(FloatParamType):
...
class File(ParamType):
def __init__(
self,
mode: str = 'r',
encoding: str = None,
errors: str = None,
lazy: bool = None,
atomic: bool = None,
) -> None:
...
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> IO:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> IO:
...
def resolve_lazy_flag(self, value: str) -> bool:
...
F = TypeVar('F') # result of the function
Func = Callable[[Optional[str]], F]
class FuncParamType(ParamType):
func: Func
def __init__(self, func: Func) -> None:
...
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> F:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> F:
...
class IntParamType(ParamType):
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> int:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> int:
...
class IntRange(IntParamType):
def __init__(
self, min: int = None, max: int = None, clamp: bool = False
) -> None:
...
PathType = TypeVar('PathType', str, bytes)
class Path(ParamType):
def __init__(
self,
exists: bool = False,
file_okay: bool = True,
dir_okay: bool = True,
writable: bool = False,
readable: bool = True,
resolve_path: bool = False,
allow_dash: bool = False,
path_type: PathType = None,
) -> None:
...
def coerce_path_result(self, rv: Union[str, bytes]) -> PathType:
...
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> PathType:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> PathType:
...
class StringParamType(ParamType):
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> str:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> str:
...
class Tuple(CompositeParamType):
types: List[ParamType]
def __init__(self, types: Iterable[Any]) -> None:
...
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> Tuple:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> Tuple:
...
class UnprocessedParamType(ParamType):
...
class UUIDParameterType(ParamType):
def __call__(
self,
value: Optional[str],
param: Parameter = None,
ctx: Context = None,
) -> uuid.UUID:
...
def convert(
self,
value: str,
param: Optional[Parameter],
ctx: Optional[Context],
) -> uuid.UUID:
...
def convert_type(ty: Any, default: Any = None) -> ParamType:
...
# parameter type shortcuts
BOOL = BoolParamType()
FLOAT = FloatParamType()
INT = IntParamType()
STRING = StringParamType()
UNPROCESSED = UnprocessedParamType()
UUID = UUIDParameterType()
mypy-0.470/typeshed/third_party/3.6/click/parser.pyi 0000644 0000000 0000000 00000003761 13035744274 021030 0 ustar root root from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
from click.core import Context
def _unpack_args(
args: Iterable[str], nargs_spec: Iterable[int]
) -> Tuple[Tuple[Optional[Tuple[str, ...]], ...], List[str]]:
...
def split_opt(opt: str) -> Tuple[str, str]:
...
def normalize_opt(opt: str, ctx: Context) -> str:
...
def split_arg_string(string: str) -> List[str]:
...
class Option:
dest: str
action: str
nargs: int
const: Any
obj: Any
prefixes: Set[str]
_short_opts: List[str]
_long_opts: List[str]
# properties
takes_value: bool
def __init__(
self,
opts: Iterable[str],
dest: str,
action: str = None,
nargs: int = 1,
const: Any = None,
obj: Any = None
) -> None:
...
def process(self, value: Any, state: 'ParsingState') -> None:
...
class Argument:
dest: str
nargs: int
obj: Any
def __init__(self, dest: str, nargs: int = 1, obj: Any = None) -> None:
...
def process(self, value: Any, state: 'ParsingState') -> None:
...
class ParsingState:
opts: Dict[str, Any]
largs: List[str]
rargs: List[str]
order: List[Any]
def __init__(self, rargs: List[str]) -> None:
...
class OptionParser:
ctx: Optional[Context]
allow_interspersed_args: bool
ignore_unknown_options: bool
_short_opt: Dict[str, Option]
_long_opt: Dict[str, Option]
_opt_prefixes: Set[str]
_args: List[Argument]
def __init__(self, ctx: Context = None) -> None:
...
def add_option(
self,
opts: Iterable[str],
dest: str,
action: str = None,
nargs: int = 1,
const: Any = None,
obj: Any = None
) -> None:
...
def add_argument(self, dest: str, nargs: int = 1, obj: Any = None) -> None:
...
def parse_args(
self, args: List[str]
) -> Tuple[Dict[str, Any], List[str], List[Any]]:
...
mypy-0.470/typeshed/third_party/3.6/click/formatting.pyi 0000644 0000000 0000000 00000003210 13035744274 021673 0 ustar root root from contextlib import contextmanager
from typing import Generator, Iterable, List, Optional, Tuple
FORCED_WIDTH: Optional[int]
def measure_table(rows: Iterable[Iterable[str]]) -> Tuple[int, ...]:
...
def iter_rows(
rows: Iterable[Iterable[str]], col_count: int
) -> Generator[Tuple[str, ...], None, None]:
...
def wrap_text(
text: str,
width: int = 78,
initial_indent: str = '',
subsequent_indent: str = '',
preserve_paragraphs: bool = False
) -> str:
...
class HelpFormatter:
indent_increment: int
width: Optional[int]
current_indent: int
buffer: List[str]
def __init__(
self,
indent_increment: int = 2,
width: int = None,
max_width: int = None,
) -> None:
...
def write(self, string: str) -> None:
...
def indent(self) -> None:
...
def dedent(self) -> None:
...
def write_usage(
self,
prog: str,
args: str = '',
prefix: str = 'Usage: ',
):
...
def write_heading(self, heading: str) -> None:
...
def write_paragraph(self) -> None:
...
def write_text(self, text: str) -> None:
...
def write_dl(
self,
rows: Iterable[Iterable[str]],
col_max: int = 30,
col_spacing: int = 2,
) -> None:
...
@contextmanager
def section(self, name) -> Generator[None, None, None]:
...
@contextmanager
def indentation(self) -> Generator[None, None, None]:
...
def getvalue(self) -> str:
...
def join_options(options: List[str]) -> Tuple[str, bool]:
...
mypy-0.470/typeshed/third_party/3.6/click/globals.pyi 0000644 0000000 0000000 00000000417 13035744274 021152 0 ustar root root from click.core import Optional, Context
def get_current_context(silent: bool = False) -> Context:
...
def push_context(ctx: Context) -> None:
...
def pop_context() -> None:
...
def resolve_color_default(color: bool = None) -> Optional[bool]:
...
mypy-0.470/typeshed/third_party/3.6/click/decorators.pyi 0000644 0000000 0000000 00000012566 13035744274 021704 0 ustar root root from typing import Any, Callable, Dict, List, TypeVar, Union
from click.core import Command, Group, Argument, Option, Parameter, Context
from click.types import ParamType
T = TypeVar('T')
Decorator = Callable[[T], T]
def pass_context(T) -> T:
...
def pass_obj(T) -> T:
...
def make_pass_decorator(
object_type: type, ensure: bool = False
) -> Callable[[T], T]:
...
# NOTE: Decorators below have **attrs converted to concrete constructor
# arguments from core.pyi to help with type checking.
def command(
name: str = None,
cls: type = Command,
# Command
help: str = None,
epilog: str = None,
short_help: str = None,
options_metavar: str = '[OPTIONS]',
add_help_option: bool = True,
) -> Decorator:
...
# This inherits attrs from Group, MultiCommand and Command.
def group(
name: str = None,
cls: type = Group,
# Group
commands: Dict[str, Command] = None,
# MultiCommand
invoke_without_command: bool = False,
no_args_is_help: bool = None,
subcommand_metavar: str = None,
chain: bool = False,
result_callback: Callable = None,
# Command
help: str = None,
epilog: str = None,
short_help: str = None,
options_metavar: str = '[OPTIONS]',
add_help_option: bool = True,
) -> Decorator:
...
def argument(
*param_decls: str,
cls: type = Argument,
# Argument
required: bool = None,
# Parameter
type: Union[type, ParamType] = None,
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = True,
is_eager: bool = False,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
def option(
*param_decls: str,
cls: type = Option,
# Option
show_default: bool = False,
prompt: bool = False,
confirmation_prompt: bool = False,
hide_input: bool = False,
is_flag: bool = None,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, ParamType] = None,
help: str = None,
# Parameter
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = True,
is_eager: bool = False,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
# Defaults copied from the decorator body.
def confirmation_option(
*param_decls: str,
cls: type = Option,
# Option
show_default: bool = False,
prompt: str = 'Do you want to continue?',
confirmation_prompt: bool = False,
hide_input: bool = False,
is_flag: bool = True,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, ParamType] = None,
help: str = 'Confirm the action without prompting.',
# Parameter
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = False,
is_eager: bool = False,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
# Defaults copied from the decorator body.
def password_option(
*param_decls: str,
cls: type = Option,
# Option
show_default: bool = False,
prompt: bool = True,
confirmation_prompt: bool = True,
hide_input: bool = True,
is_flag: bool = None,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, ParamType] = None,
help: str = None,
# Parameter
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = True,
is_eager: bool = False,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
# Defaults copied from the decorator body.
def version_option(
version: str = None,
*param_decls: str,
cls: type = Option,
# Option
show_default: bool = False,
prompt: bool = False,
confirmation_prompt: bool = False,
hide_input: bool = False,
is_flag: bool = True,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, ParamType] = None,
help: str = 'Show the version and exit.',
# Parameter
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = False,
is_eager: bool = True,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
# Defaults copied from the decorator body.
def help_option(
*param_decls: str,
cls: type = Option,
# Option
show_default: bool = False,
prompt: bool = False,
confirmation_prompt: bool = False,
hide_input: bool = False,
is_flag: bool = True,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, ParamType] = None,
help: str = 'Show this message and exit.',
# Parameter
default: Any = None,
callback: Callable[[Context, Parameter, str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = False,
is_eager: bool = True,
envvar: Union[str, List[str]] = None
) -> Decorator:
...
mypy-0.470/typeshed/third_party/3.6/click/utils.pyi 0000644 0000000 0000000 00000003614 13035744274 020671 0 ustar root root from typing import Any, Callable, Iterator, IO, List, Optional, TypeVar, Union
T = TypeVar('T')
Decorator = Callable[[T], T]
def _posixify(name: str) -> str:
...
def safecall(func: T) -> T:
...
def make_str(value: Any) -> str:
...
def make_default_short_help(help: str, max_length: int = 45):
...
class LazyFile:
name: str
mode: str
encoding: Optional[str]
errors: str
atomic: bool
def __init__(
self,
filename: str,
mode: str = 'r',
encoding: str = None,
errors: str = 'strict',
atomic: bool = False
) -> None:
...
def open(self) -> IO:
...
def close(self) -> None:
...
def close_intelligently(self) -> None:
...
def __enter__(self) -> 'LazyFile':
...
def __exit__(self, exc_type, exc_value, tb):
...
def __iter__(self) -> Iterator:
...
class KeepOpenFile(object):
_file: IO
def __init__(self, file: IO) -> None:
...
def __enter__(self) -> 'KeepOpenFile':
...
def __exit__(self, exc_type, exc_value, tb):
...
def __iter__(self) -> Iterator:
...
def echo(
message: str = None,
file: IO = None,
nl: bool = True,
err: bool = False,
color: bool = None,
) -> None:
...
def get_binary_stream(name: str) -> IO[bytes]:
...
def get_text_stream(
name: str, encoding: str = None, errors: str = 'strict'
) -> IO[str]:
...
def open_file(
filename: str,
mode: str = 'r',
encoding: str = None,
errors: str = 'strict',
lazy: bool = False,
atomic: bool = False
) -> Union[IO, LazyFile, KeepOpenFile]:
...
def get_os_args() -> List[str]:
...
def format_filename(filename: str, shorten: bool = False) -> str:
...
def get_app_dir(
app_name: str, roaming: bool = True, force_posix: bool = False
) -> str:
...
mypy-0.470/typeshed/third_party/3.6/click/core.pyi 0000644 0000000 0000000 00000023602 13035744274 020460 0 ustar root root from contextlib import contextmanager
from typing import (
Any,
Callable,
Dict,
Generator,
Iterable,
List,
Mapping,
Optional,
Sequence,
Set,
Tuple,
TypeVar,
Union,
)
from click.formatting import HelpFormatter
from click.parser import OptionParser
def invoke_param_callback(
callback: Callable[['Context', 'Parameter', Optional[str]], Any],
ctx: 'Context',
param: 'Parameter',
value: Optional[str]
) -> Any:
...
@contextmanager
def augment_usage_errors(
ctx: 'Context', param: 'Parameter' = None
) -> Generator[None, None, None]:
...
def iter_params_for_processing(
invocation_order: Sequence['Parameter'],
declaration_order: Iterable['Parameter'],
) -> Iterable['Parameter']:
...
class Context:
parent: Optional['Context']
command: 'Command'
info_name: Optional[str]
params: Dict
args: List[str]
protected_args: List[str]
obj: Any
default_map: Mapping[str, Any]
invoked_subcommand: Optional[str]
terminal_width: Optional[int]
max_content_width: Optional[int]
allow_extra_args: bool
allow_interspersed_args: bool
ignore_unknown_options: bool
help_option_names: List[str]
token_normalize_func: Optional[Callable[[str], str]]
resilient_parsing: bool
auto_envvar_prefix: Optional[str]
color: Optional[bool]
_meta: Dict[str, Any]
_close_callbacks: List
_depth: int
# properties
meta: Dict[str, Any]
command_path: str
def __init__(
self,
command: 'Command',
parent: 'Context' = None,
info_name: str = None,
obj: Any = None,
auto_envvar_prefix: str = None,
default_map: Mapping[str, Any] = None,
terminal_width: int = None,
max_content_width: int = None,
resilient_parsing: bool = False,
allow_extra_args: bool = None,
allow_interspersed_args: bool = None,
ignore_unknown_options: bool = None,
help_option_names: List[str] = None,
token_normalize_func: Callable[[str], str] = None,
color: bool = None
) -> None:
...
@contextmanager
def scope(self, cleanup: bool = True) -> Generator['Context', None, None]:
...
def make_formatter(self) -> HelpFormatter:
...
def call_on_close(self, f: Callable) -> Callable:
...
def close(self) -> None:
...
def find_root(self) -> 'Context':
...
def find_object(self, object_type: type) -> Any:
...
def ensure_object(self, object_type: type) -> Any:
...
def lookup_default(self, name: str) -> Any:
...
def fail(self, message: str) -> None:
...
def abort(self) -> None:
...
def exit(self, code: Union[int, str] = 0) -> None:
...
def get_usage(self) -> str:
...
def get_help(self) -> str:
...
def invoke(
self, callback: Union['Command', Callable], *args, **kwargs
) -> Any:
...
def forward(
self, callback: Union['Command', Callable], *args, **kwargs
) -> Any:
...
class BaseCommand:
allow_extra_args: bool
allow_interspersed_args: bool
ignore_unknown_options: bool
name: str
context_settings: Dict
def __init__(self, name: str, context_settings: Dict = None) -> None:
...
def get_usage(self, ctx: Context) -> str:
...
def get_help(self, ctx: Context) -> str:
...
def make_context(
self, info_name: str, args: List[str], parent: Context = None, **extra
) -> Context:
...
def parse_args(self, ctx: Context, args: List[str]) -> List[str]:
...
def invoke(self, ctx: Context) -> Any:
...
def main(
self,
args: List[str] = None,
prog_name: str = None,
complete_var: str = None,
standalone_mode: bool = True,
**extra
) -> Any:
...
def __call__(self, *args, **kwargs) -> Any:
...
class Command(BaseCommand):
callback: Optional[Callable]
params: List['Parameter']
help: Optional[str]
epilog: Optional[str]
short_help: Optional[str]
options_metavar: str
add_help_option: bool
def __init__(
self,
name: str,
context_settings: Dict = None,
callback: Callable = None,
params: List['Parameter'] = None,
help: str = None,
epilog: str = None,
short_help: str = None,
options_metavar: str = '[OPTIONS]',
add_help_option: bool = True
) -> None:
...
def get_params(self, ctx: Context) -> List['Parameter']:
...
def format_usage(
self,
ctx: Context,
formatter: HelpFormatter
) -> None:
...
def collect_usage_pieces(self, ctx: Context) -> List[str]:
...
def get_help_option_names(self, ctx: Context) -> Set[str]:
...
def get_help_option(self, ctx: Context) -> Optional['Option']:
...
def make_parser(self, ctx: Context) -> OptionParser:
...
def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
...
def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
...
def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
...
def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
...
T = TypeVar('T')
Decorator = Callable[[T], T]
class MultiCommand(Command):
no_args_is_help: bool
invoke_without_command: bool
subcommand_metavar: str
chain: bool
result_callback: Callable
def __init__(
self,
name: str = None,
invoke_without_command: bool = False,
no_args_is_help: bool = None,
subcommand_metavar: str = None,
chain: bool = False,
result_callback: Callable = None,
**attrs
) -> None:
...
def resultcallback(
self, replace: bool = False
) -> Decorator:
...
def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
...
def resolve_command(
self, ctx: Context, args: List[str]
) -> Tuple[str, Command, List[str]]:
...
def get_command(self, ctx: Context, cmd_name: str) -> Optional[Command]:
...
def list_commands(self, ctx: Context) -> Iterable[Command]:
...
class Group(MultiCommand):
commands: Dict[str, Command]
def __init__(
self, name: str = None, commands: Dict[str, Command] = None, **attrs
) -> None:
...
def add_command(self, cmd: Command, name: str = None):
...
def command(self, *args, **kwargs) -> Decorator:
...
def group(self, *args, **kwargs) -> Decorator:
...
class CommandCollection(MultiCommand):
sources: List[MultiCommand]
def __init__(
self, name: str = None, sources: List[MultiCommand] = None, **attrs
) -> None:
...
def add_source(self, multi_cmd: MultiCommand) -> None:
...
class Parameter:
param_type_name: str
name: str
opts: List[str]
secondary_opts: List[str]
type: 'ParamType'
required: bool
callback: Optional[Callable[[Context, 'Parameter', str], Any]]
nargs: int
multiple: bool
expose_value: bool
default: Any
is_eager: bool
metavar: Optional[str]
envvar: Union[str, List[str], None]
# properties
human_readable_name: str
def __init__(
self,
param_decls: List[str] = None,
type: Union[type, 'ParamType'] = None,
required: bool = False,
default: Any = None,
callback: Callable[[Context, 'Parameter', str], Any] = None,
nargs: int = None,
metavar: str = None,
expose_value: bool = True,
is_eager: bool = False,
envvar: Union[str, List[str]] = None
) -> None:
...
def make_metavar(self) -> str:
...
def get_default(self, ctx: Context) -> Any:
...
def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
...
def consume_value(self, ctx: Context, opts: Dict[str, Any]) -> Any:
...
def type_cast_value(self, ctx: Context, value: Any) -> Any:
...
def process_value(self, ctx: Context, value: Any) -> Any:
...
def value_is_missing(self, value: Any) -> bool:
...
def full_process_value(self, ctx: Context, value: Any) -> Any:
...
def resolve_envvar_value(self, ctx: Context) -> str:
...
def value_from_envvar(self, ctx: Context) -> Union[str, List[str]]:
...
def handle_parse_result(
self, ctx: Context, opts: Dict[str, Any], args: List[str]
) -> Tuple[Any, List[str]]:
...
def get_help_record(self, ctx: Context) -> Tuple[str, str]:
...
def get_usage_pieces(self, ctx: Context) -> List[str]:
...
class Option(Parameter):
prompt: str # sic
confirmation_prompt: bool
hide_input: bool
is_flag: bool
flag_value: Any
is_bool_flag: bool
count: bool
multiple: bool
allow_from_autoenv: bool
help: Optional[str]
show_default: bool
def __init__(
self,
param_decls: List[str] = None,
show_default: bool = False,
prompt: Union[bool, str] = False,
confirmation_prompt: bool = False,
hide_input: bool = False,
is_flag: bool = None,
flag_value: Any = None,
multiple: bool = False,
count: bool = False,
allow_from_autoenv: bool = True,
type: Union[type, 'ParamType'] = None,
help: str = None,
**attrs
) -> None:
...
def prompt_for_value(self, ctx: Context) -> Any:
...
class Argument(Parameter):
def __init__(
self,
param_decls: List[str] = None,
required: bool = None,
**attrs
) -> None:
...
# cyclic dependency
from click.types import ParamType # noqa: E402
mypy-0.470/typeshed/third_party/3.6/click/exceptions.pyi 0000644 0000000 0000000 00000003420 13035744274 021705 0 ustar root root from typing import IO, List, Optional
from click.core import Context, Parameter
class ClickException(Exception):
exit_code: int
message: str
def __init__(self, message: str) -> None:
...
def format_message(self) -> str:
...
def show(self, file=None) -> None:
...
class UsageError(ClickException):
ctx: Optional[Context]
def __init__(self, message: str, ctx: Context = None) -> None:
...
def show(self, file: IO = None) -> None:
...
class BadParameter(UsageError):
param: Optional[Parameter]
param_hint: Optional[str]
def __init__(
self,
message: str,
ctx: Context = None,
param: Parameter = None,
param_hint: str = None
) -> None:
...
class MissingParameter(BadParameter):
param_type: str # valid values: 'parameter', 'option', 'argument'
def __init__(
self,
message: str = None,
ctx: Context = None,
param: Parameter = None,
param_hint: str = None,
param_type: str = None
) -> None:
...
class NoSuchOption(UsageError):
option_name: str
possibilities: Optional[List[str]]
def __init__(
self,
option_name: str,
message: str = None,
possibilities: List[str] = None,
ctx: Context = None
) -> None:
...
class BadOptionUsage(UsageError):
def __init__(self, message: str, ctx: Context = None) -> None:
...
class BadArgumentUsage(UsageError):
def __init__(self, message: str, ctx: Context = None) -> None:
...
class FileError(ClickException):
ui_filename: str
filename: str
def __init__(self, filename: str, hint: str = None) -> None:
...
class Abort(RuntimeError):
...
mypy-0.470/typeshed/third_party/2/ 0000755 0000000 0000000 00000000000 13044320557 015542 5 ustar root root mypy-0.470/typeshed/third_party/2/yaml/ 0000755 0000000 0000000 00000000000 13044320557 016504 5 ustar root root mypy-0.470/typeshed/third_party/2/yaml/emitter.pyi 0000644 0000000 0000000 00000010522 13035744274 020706 0 ustar root root # Stubs for yaml.emitter (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import YAMLError
class EmitterError(YAMLError): ...
class ScalarAnalysis:
scalar = ... # type: Any
empty = ... # type: Any
multiline = ... # type: Any
allow_flow_plain = ... # type: Any
allow_block_plain = ... # type: Any
allow_single_quoted = ... # type: Any
allow_double_quoted = ... # type: Any
allow_block = ... # type: Any
def __init__(self, scalar, empty, multiline, allow_flow_plain, allow_block_plain, allow_single_quoted, allow_double_quoted, allow_block) -> None: ...
class Emitter:
DEFAULT_TAG_PREFIXES = ... # type: Any
stream = ... # type: Any
encoding = ... # type: Any
states = ... # type: Any
state = ... # type: Any
events = ... # type: Any
event = ... # type: Any
indents = ... # type: Any
indent = ... # type: Any
flow_level = ... # type: Any
root_context = ... # type: Any
sequence_context = ... # type: Any
mapping_context = ... # type: Any
simple_key_context = ... # type: Any
line = ... # type: Any
column = ... # type: Any
whitespace = ... # type: Any
indention = ... # type: Any
open_ended = ... # type: Any
canonical = ... # type: Any
allow_unicode = ... # type: Any
best_indent = ... # type: Any
best_width = ... # type: Any
best_line_break = ... # type: Any
tag_prefixes = ... # type: Any
prepared_anchor = ... # type: Any
prepared_tag = ... # type: Any
analysis = ... # type: Any
style = ... # type: Any
def __init__(self, stream, canonical=..., indent=..., width=..., allow_unicode=..., line_break=...) -> None: ...
def dispose(self): ...
def emit(self, event): ...
def need_more_events(self): ...
def need_events(self, count): ...
def increase_indent(self, flow=..., indentless=...): ...
def expect_stream_start(self): ...
def expect_nothing(self): ...
def expect_first_document_start(self): ...
def expect_document_start(self, first=...): ...
def expect_document_end(self): ...
def expect_document_root(self): ...
def expect_node(self, root=..., sequence=..., mapping=..., simple_key=...): ...
def expect_alias(self): ...
def expect_scalar(self): ...
def expect_flow_sequence(self): ...
def expect_first_flow_sequence_item(self): ...
def expect_flow_sequence_item(self): ...
def expect_flow_mapping(self): ...
def expect_first_flow_mapping_key(self): ...
def expect_flow_mapping_key(self): ...
def expect_flow_mapping_simple_value(self): ...
def expect_flow_mapping_value(self): ...
def expect_block_sequence(self): ...
def expect_first_block_sequence_item(self): ...
def expect_block_sequence_item(self, first=...): ...
def expect_block_mapping(self): ...
def expect_first_block_mapping_key(self): ...
def expect_block_mapping_key(self, first=...): ...
def expect_block_mapping_simple_value(self): ...
def expect_block_mapping_value(self): ...
def check_empty_sequence(self): ...
def check_empty_mapping(self): ...
def check_empty_document(self): ...
def check_simple_key(self): ...
def process_anchor(self, indicator): ...
def process_tag(self): ...
def choose_scalar_style(self): ...
def process_scalar(self): ...
def prepare_version(self, version): ...
def prepare_tag_handle(self, handle): ...
def prepare_tag_prefix(self, prefix): ...
def prepare_tag(self, tag): ...
def prepare_anchor(self, anchor): ...
def analyze_scalar(self, scalar): ...
def flush_stream(self): ...
def write_stream_start(self): ...
def write_stream_end(self): ...
def write_indicator(self, indicator, need_whitespace, whitespace=..., indention=...): ...
def write_indent(self): ...
def write_line_break(self, data=...): ...
def write_version_directive(self, version_text): ...
def write_tag_directive(self, handle_text, prefix_text): ...
def write_single_quoted(self, text, split=...): ...
ESCAPE_REPLACEMENTS = ... # type: Any
def write_double_quoted(self, text, split=...): ...
def determine_block_hints(self, text): ...
def write_folded(self, text): ...
def write_literal(self, text): ...
def write_plain(self, text, split=...): ...
mypy-0.470/typeshed/third_party/2/yaml/constructor.pyi 0000644 0000000 0000000 00000005622 13035744274 021627 0 ustar root root # Stubs for yaml.constructor (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from yaml.error import Mark, YAMLError, MarkedYAMLError
from yaml.nodes import Node, ScalarNode, CollectionNode, SequenceNode, MappingNode
from typing import Any
class ConstructorError(MarkedYAMLError): ...
class BaseConstructor:
yaml_constructors = ... # type: Any
yaml_multi_constructors = ... # type: Any
constructed_objects = ... # type: Any
recursive_objects = ... # type: Any
state_generators = ... # type: Any
deep_construct = ... # type: Any
def __init__(self) -> None: ...
def check_data(self): ...
def get_data(self): ...
def get_single_data(self): ...
def construct_document(self, node): ...
def construct_object(self, node, deep=...): ...
def construct_scalar(self, node): ...
def construct_sequence(self, node, deep=...): ...
def construct_mapping(self, node, deep=...): ...
def construct_pairs(self, node, deep=...): ...
def add_constructor(cls, tag, constructor): ...
def add_multi_constructor(cls, tag_prefix, multi_constructor): ...
class SafeConstructor(BaseConstructor):
def construct_scalar(self, node): ...
def flatten_mapping(self, node): ...
def construct_mapping(self, node, deep=...): ...
def construct_yaml_null(self, node): ...
bool_values = ... # type: Any
def construct_yaml_bool(self, node): ...
def construct_yaml_int(self, node): ...
inf_value = ... # type: Any
nan_value = ... # type: Any
def construct_yaml_float(self, node): ...
def construct_yaml_binary(self, node): ...
timestamp_regexp = ... # type: Any
def construct_yaml_timestamp(self, node): ...
def construct_yaml_omap(self, node): ...
def construct_yaml_pairs(self, node): ...
def construct_yaml_set(self, node): ...
def construct_yaml_str(self, node): ...
def construct_yaml_seq(self, node): ...
def construct_yaml_map(self, node): ...
def construct_yaml_object(self, node, cls): ...
def construct_undefined(self, node): ...
class Constructor(SafeConstructor):
def construct_python_str(self, node): ...
def construct_python_unicode(self, node): ...
def construct_python_long(self, node): ...
def construct_python_complex(self, node): ...
def construct_python_tuple(self, node): ...
def find_python_module(self, name, mark): ...
def find_python_name(self, name, mark): ...
def construct_python_name(self, suffix, node): ...
def construct_python_module(self, suffix, node): ...
class classobj: ...
def make_python_instance(self, suffix, node, args=..., kwds=..., newobj=...): ...
def set_python_instance_state(self, instance, state): ...
def construct_python_object(self, suffix, node): ...
def construct_python_object_apply(self, suffix, node, newobj=...): ...
def construct_python_object_new(self, suffix, node): ...
mypy-0.470/typeshed/third_party/2/yaml/error.pyi 0000644 0000000 0000000 00000001442 13035744274 020367 0 ustar root root # Stubs for yaml.error (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class Mark:
name = ... # type: Any
index = ... # type: Any
line = ... # type: Any
column = ... # type: Any
buffer = ... # type: Any
pointer = ... # type: Any
def __init__(self, name, index, line, column, buffer, pointer) -> None: ...
def get_snippet(self, indent=..., max_length=...): ...
class YAMLError(Exception): ...
class MarkedYAMLError(YAMLError):
context = ... # type: Any
context_mark = ... # type: Any
problem = ... # type: Any
problem_mark = ... # type: Any
note = ... # type: Any
def __init__(self, context=..., context_mark=..., problem=..., problem_mark=..., note=...) -> None: ...
mypy-0.470/typeshed/third_party/2/yaml/__init__.pyi 0000644 0000000 0000000 00000004306 13035744274 020777 0 ustar root root # Stubs for yaml (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
# from yaml.error import *
# from yaml.tokens import *
# from yaml.events import *
# from yaml.nodes import *
# from yaml.loader import *
# from yaml.dumper import *
# TODO: stubs for cyaml?
# from cyaml import *
__with_libyaml__ = ... # type: Any
def scan(stream, Loader=...): ...
def parse(stream, Loader=...): ...
def compose(stream, Loader=...): ...
def compose_all(stream, Loader=...): ...
def load(stream, Loader=...): ...
def load_all(stream, Loader=...): ...
def safe_load(stream): ...
def safe_load_all(stream): ...
def emit(events, stream=..., Dumper=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=...): ...
def serialize_all(nodes, stream=..., Dumper=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...): ...
def serialize(node, stream=..., Dumper=..., **kwds): ...
def dump_all(documents, stream=..., Dumper=..., default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...): ...
def dump(data, stream=..., Dumper=..., **kwds): ...
def safe_dump_all(documents, stream=..., **kwds): ...
def safe_dump(data, stream=..., **kwds): ...
def add_implicit_resolver(tag, regexp, first=..., Loader=..., Dumper=...): ...
def add_path_resolver(tag, path, kind=..., Loader=..., Dumper=...): ...
def add_constructor(tag, constructor, Loader=...): ...
def add_multi_constructor(tag_prefix, multi_constructor, Loader=...): ...
def add_representer(data_type, representer, Dumper=...): ...
def add_multi_representer(data_type, multi_representer, Dumper=...): ...
class YAMLObjectMetaclass(type):
def __init__(cls, name, bases, kwds) -> None: ...
class YAMLObject:
__metaclass__ = ... # type: Any
yaml_loader = ... # type: Any
yaml_dumper = ... # type: Any
yaml_tag = ... # type: Any
yaml_flow_style = ... # type: Any
@classmethod
def from_yaml(cls, loader, node): ...
@classmethod
def to_yaml(cls, dumper, data): ...
mypy-0.470/typeshed/third_party/2/yaml/tokens.pyi 0000644 0000000 0000000 00000004714 13035744274 020546 0 ustar root root # Stubs for yaml.tokens (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class Token:
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, start_mark, end_mark) -> None: ...
class DirectiveToken(Token):
id = ... # type: Any
name = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, name, value, start_mark, end_mark) -> None: ...
class DocumentStartToken(Token):
id = ... # type: Any
class DocumentEndToken(Token):
id = ... # type: Any
class StreamStartToken(Token):
id = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
encoding = ... # type: Any
def __init__(self, start_mark=..., end_mark=..., encoding=...) -> None: ...
class StreamEndToken(Token):
id = ... # type: Any
class BlockSequenceStartToken(Token):
id = ... # type: Any
class BlockMappingStartToken(Token):
id = ... # type: Any
class BlockEndToken(Token):
id = ... # type: Any
class FlowSequenceStartToken(Token):
id = ... # type: Any
class FlowMappingStartToken(Token):
id = ... # type: Any
class FlowSequenceEndToken(Token):
id = ... # type: Any
class FlowMappingEndToken(Token):
id = ... # type: Any
class KeyToken(Token):
id = ... # type: Any
class ValueToken(Token):
id = ... # type: Any
class BlockEntryToken(Token):
id = ... # type: Any
class FlowEntryToken(Token):
id = ... # type: Any
class AliasToken(Token):
id = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, value, start_mark, end_mark) -> None: ...
class AnchorToken(Token):
id = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, value, start_mark, end_mark) -> None: ...
class TagToken(Token):
id = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, value, start_mark, end_mark) -> None: ...
class ScalarToken(Token):
id = ... # type: Any
value = ... # type: Any
plain = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
style = ... # type: Any
def __init__(self, value, plain, start_mark, end_mark, style=...) -> None: ...
mypy-0.470/typeshed/third_party/2/yaml/scanner.pyi 0000644 0000000 0000000 00000007507 13035744274 020677 0 ustar root root # Stubs for yaml.scanner (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import MarkedYAMLError
class ScannerError(MarkedYAMLError): ...
class SimpleKey:
token_number = ... # type: Any
required = ... # type: Any
index = ... # type: Any
line = ... # type: Any
column = ... # type: Any
mark = ... # type: Any
def __init__(self, token_number, required, index, line, column, mark) -> None: ...
class Scanner:
done = ... # type: Any
flow_level = ... # type: Any
tokens = ... # type: Any
tokens_taken = ... # type: Any
indent = ... # type: Any
indents = ... # type: Any
allow_simple_key = ... # type: Any
possible_simple_keys = ... # type: Any
def __init__(self) -> None: ...
def check_token(self, *choices): ...
def peek_token(self): ...
def get_token(self): ...
def need_more_tokens(self): ...
def fetch_more_tokens(self): ...
def next_possible_simple_key(self): ...
def stale_possible_simple_keys(self): ...
def save_possible_simple_key(self): ...
def remove_possible_simple_key(self): ...
def unwind_indent(self, column): ...
def add_indent(self, column): ...
def fetch_stream_start(self): ...
def fetch_stream_end(self): ...
def fetch_directive(self): ...
def fetch_document_start(self): ...
def fetch_document_end(self): ...
def fetch_document_indicator(self, TokenClass): ...
def fetch_flow_sequence_start(self): ...
def fetch_flow_mapping_start(self): ...
def fetch_flow_collection_start(self, TokenClass): ...
def fetch_flow_sequence_end(self): ...
def fetch_flow_mapping_end(self): ...
def fetch_flow_collection_end(self, TokenClass): ...
def fetch_flow_entry(self): ...
def fetch_block_entry(self): ...
def fetch_key(self): ...
def fetch_value(self): ...
def fetch_alias(self): ...
def fetch_anchor(self): ...
def fetch_tag(self): ...
def fetch_literal(self): ...
def fetch_folded(self): ...
def fetch_block_scalar(self, style): ...
def fetch_single(self): ...
def fetch_double(self): ...
def fetch_flow_scalar(self, style): ...
def fetch_plain(self): ...
def check_directive(self): ...
def check_document_start(self): ...
def check_document_end(self): ...
def check_block_entry(self): ...
def check_key(self): ...
def check_value(self): ...
def check_plain(self): ...
def scan_to_next_token(self): ...
def scan_directive(self): ...
def scan_directive_name(self, start_mark): ...
def scan_yaml_directive_value(self, start_mark): ...
def scan_yaml_directive_number(self, start_mark): ...
def scan_tag_directive_value(self, start_mark): ...
def scan_tag_directive_handle(self, start_mark): ...
def scan_tag_directive_prefix(self, start_mark): ...
def scan_directive_ignored_line(self, start_mark): ...
def scan_anchor(self, TokenClass): ...
def scan_tag(self): ...
def scan_block_scalar(self, style): ...
def scan_block_scalar_indicators(self, start_mark): ...
def scan_block_scalar_ignored_line(self, start_mark): ...
def scan_block_scalar_indentation(self): ...
def scan_block_scalar_breaks(self, indent): ...
def scan_flow_scalar(self, style): ...
ESCAPE_REPLACEMENTS = ... # type: Any
ESCAPE_CODES = ... # type: Any
def scan_flow_scalar_non_spaces(self, double, start_mark): ...
def scan_flow_scalar_spaces(self, double, start_mark): ...
def scan_flow_scalar_breaks(self, double, start_mark): ...
def scan_plain(self): ...
def scan_plain_spaces(self, indent, start_mark): ...
def scan_tag_handle(self, name, start_mark): ...
def scan_tag_uri(self, name, start_mark): ...
def scan_uri_escapes(self, name, start_mark): ...
def scan_line_break(self): ...
mypy-0.470/typeshed/third_party/2/yaml/parser.pyi 0000644 0000000 0000000 00000003523 13035744274 020534 0 ustar root root # Stubs for yaml.parser (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import MarkedYAMLError
class ParserError(MarkedYAMLError): ...
class Parser:
DEFAULT_TAGS = ... # type: Any
current_event = ... # type: Any
yaml_version = ... # type: Any
tag_handles = ... # type: Any
states = ... # type: Any
marks = ... # type: Any
state = ... # type: Any
def __init__(self) -> None: ...
def dispose(self): ...
def check_event(self, *choices): ...
def peek_event(self): ...
def get_event(self): ...
def parse_stream_start(self): ...
def parse_implicit_document_start(self): ...
def parse_document_start(self): ...
def parse_document_end(self): ...
def parse_document_content(self): ...
def process_directives(self): ...
def parse_block_node(self): ...
def parse_flow_node(self): ...
def parse_block_node_or_indentless_sequence(self): ...
def parse_node(self, block=..., indentless_sequence=...): ...
def parse_block_sequence_first_entry(self): ...
def parse_block_sequence_entry(self): ...
def parse_indentless_sequence_entry(self): ...
def parse_block_mapping_first_key(self): ...
def parse_block_mapping_key(self): ...
def parse_block_mapping_value(self): ...
def parse_flow_sequence_first_entry(self): ...
def parse_flow_sequence_entry(self, first=...): ...
def parse_flow_sequence_entry_mapping_key(self): ...
def parse_flow_sequence_entry_mapping_value(self): ...
def parse_flow_sequence_entry_mapping_end(self): ...
def parse_flow_mapping_first_key(self): ...
def parse_flow_mapping_key(self, first=...): ...
def parse_flow_mapping_value(self): ...
def parse_flow_mapping_empty_value(self): ...
def process_empty_scalar(self, mark): ...
mypy-0.470/typeshed/third_party/2/yaml/events.pyi 0000644 0000000 0000000 00000004206 13035744274 020543 0 ustar root root # Stubs for yaml.events (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class Event:
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, start_mark=..., end_mark=...) -> None: ...
class NodeEvent(Event):
anchor = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, anchor, start_mark=..., end_mark=...) -> None: ...
class CollectionStartEvent(NodeEvent):
anchor = ... # type: Any
tag = ... # type: Any
implicit = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
flow_style = ... # type: Any
def __init__(self, anchor, tag, implicit, start_mark=..., end_mark=..., flow_style=...) -> None: ...
class CollectionEndEvent(Event): ...
class StreamStartEvent(Event):
start_mark = ... # type: Any
end_mark = ... # type: Any
encoding = ... # type: Any
def __init__(self, start_mark=..., end_mark=..., encoding=...) -> None: ...
class StreamEndEvent(Event): ...
class DocumentStartEvent(Event):
start_mark = ... # type: Any
end_mark = ... # type: Any
explicit = ... # type: Any
version = ... # type: Any
tags = ... # type: Any
def __init__(self, start_mark=..., end_mark=..., explicit=..., version=..., tags=...) -> None: ...
class DocumentEndEvent(Event):
start_mark = ... # type: Any
end_mark = ... # type: Any
explicit = ... # type: Any
def __init__(self, start_mark=..., end_mark=..., explicit=...) -> None: ...
class AliasEvent(NodeEvent): ...
class ScalarEvent(NodeEvent):
anchor = ... # type: Any
tag = ... # type: Any
implicit = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
style = ... # type: Any
def __init__(self, anchor, tag, implicit, value, start_mark=..., end_mark=..., style=...) -> None: ...
class SequenceStartEvent(CollectionStartEvent): ...
class SequenceEndEvent(CollectionEndEvent): ...
class MappingStartEvent(CollectionStartEvent): ...
class MappingEndEvent(CollectionEndEvent): ...
mypy-0.470/typeshed/third_party/2/yaml/dumper.pyi 0000644 0000000 0000000 00000002274 13023631176 020527 0 ustar root root # Stubs for yaml.dumper (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from yaml.emitter import Emitter
from yaml.serializer import Serializer
from yaml.representer import BaseRepresenter, Representer, SafeRepresenter
from yaml.resolver import BaseResolver, Resolver
class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
def __init__(self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...) -> None: ...
class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
def __init__(self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...) -> None: ...
class Dumper(Emitter, Serializer, Representer, Resolver):
def __init__(self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...) -> None: ...
mypy-0.470/typeshed/third_party/2/yaml/serializer.pyi 0000644 0000000 0000000 00000001633 13035744274 021411 0 ustar root root # Stubs for yaml.serializer (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import YAMLError
class SerializerError(YAMLError): ...
class Serializer:
ANCHOR_TEMPLATE = ... # type: Any
use_encoding = ... # type: Any
use_explicit_start = ... # type: Any
use_explicit_end = ... # type: Any
use_version = ... # type: Any
use_tags = ... # type: Any
serialized_nodes = ... # type: Any
anchors = ... # type: Any
last_anchor_id = ... # type: Any
closed = ... # type: Any
def __init__(self, encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...) -> None: ...
def open(self): ...
def close(self): ...
def serialize(self, node): ...
def anchor_node(self, node): ...
def generate_anchor(self, node): ...
def serialize_node(self, node, parent, index): ...
mypy-0.470/typeshed/third_party/2/yaml/composer.pyi 0000644 0000000 0000000 00000001325 13035744274 021065 0 ustar root root # Stubs for yaml.composer (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import Mark, YAMLError, MarkedYAMLError
from yaml.nodes import Node, ScalarNode, CollectionNode, SequenceNode, MappingNode
class ComposerError(MarkedYAMLError): ...
class Composer:
anchors = ... # type: Any
def __init__(self) -> None: ...
def check_node(self): ...
def get_node(self): ...
def get_single_node(self): ...
def compose_document(self): ...
def compose_node(self, parent, index): ...
def compose_scalar_node(self, anchor): ...
def compose_sequence_node(self, anchor): ...
def compose_mapping_node(self, anchor): ...
mypy-0.470/typeshed/third_party/2/yaml/representer.pyi 0000644 0000000 0000000 00000004231 13035744274 021573 0 ustar root root # Stubs for yaml.representer (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import YAMLError
class RepresenterError(YAMLError): ...
class BaseRepresenter:
yaml_representers = ... # type: Any
yaml_multi_representers = ... # type: Any
default_style = ... # type: Any
default_flow_style = ... # type: Any
represented_objects = ... # type: Any
object_keeper = ... # type: Any
alias_key = ... # type: Any
def __init__(self, default_style=..., default_flow_style=...) -> None: ...
def represent(self, data): ...
def get_classobj_bases(self, cls): ...
def represent_data(self, data): ...
def add_representer(cls, data_type, representer): ...
def add_multi_representer(cls, data_type, representer): ...
def represent_scalar(self, tag, value, style=...): ...
def represent_sequence(self, tag, sequence, flow_style=...): ...
def represent_mapping(self, tag, mapping, flow_style=...): ...
def ignore_aliases(self, data): ...
class SafeRepresenter(BaseRepresenter):
def ignore_aliases(self, data): ...
def represent_none(self, data): ...
def represent_str(self, data): ...
def represent_unicode(self, data): ...
def represent_bool(self, data): ...
def represent_int(self, data): ...
def represent_long(self, data): ...
inf_value = ... # type: Any
def represent_float(self, data): ...
def represent_list(self, data): ...
def represent_dict(self, data): ...
def represent_set(self, data): ...
def represent_date(self, data): ...
def represent_datetime(self, data): ...
def represent_yaml_object(self, tag, data, cls, flow_style=...): ...
def represent_undefined(self, data): ...
class Representer(SafeRepresenter):
def represent_str(self, data): ...
def represent_unicode(self, data): ...
def represent_long(self, data): ...
def represent_complex(self, data): ...
def represent_tuple(self, data): ...
def represent_name(self, data): ...
def represent_module(self, data): ...
def represent_instance(self, data): ...
def represent_object(self, data): ...
mypy-0.470/typeshed/third_party/2/yaml/nodes.pyi 0000644 0000000 0000000 00000002014 13035744274 020342 0 ustar root root # Stubs for yaml.nodes (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class Node:
tag = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
def __init__(self, tag, value, start_mark, end_mark) -> None: ...
class ScalarNode(Node):
id = ... # type: Any
tag = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
style = ... # type: Any
def __init__(self, tag, value, start_mark=..., end_mark=..., style=...) -> None: ...
class CollectionNode(Node):
tag = ... # type: Any
value = ... # type: Any
start_mark = ... # type: Any
end_mark = ... # type: Any
flow_style = ... # type: Any
def __init__(self, tag, value, start_mark=..., end_mark=..., flow_style=...) -> None: ...
class SequenceNode(CollectionNode):
id = ... # type: Any
class MappingNode(CollectionNode):
id = ... # type: Any
mypy-0.470/typeshed/third_party/2/yaml/reader.pyi 0000644 0000000 0000000 00000002255 13035744274 020503 0 ustar root root # Stubs for yaml.reader (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import YAMLError
class ReaderError(YAMLError):
name = ... # type: Any
character = ... # type: Any
position = ... # type: Any
encoding = ... # type: Any
reason = ... # type: Any
def __init__(self, name, position, character, encoding, reason) -> None: ...
class Reader:
name = ... # type: Any
stream = ... # type: Any
stream_pointer = ... # type: Any
eof = ... # type: Any
buffer = ... # type: Any
pointer = ... # type: Any
raw_buffer = ... # type: Any
raw_decode = ... # type: Any
encoding = ... # type: Any
index = ... # type: Any
line = ... # type: Any
column = ... # type: Any
def __init__(self, stream) -> None: ...
def peek(self, index=...): ...
def prefix(self, length=...): ...
def forward(self, length=...): ...
def get_mark(self): ...
def determine_encoding(self): ...
NON_PRINTABLE = ... # type: Any
def check_printable(self, data): ...
def update(self, length): ...
def update_raw(self, size=...): ...
mypy-0.470/typeshed/third_party/2/yaml/resolver.pyi 0000644 0000000 0000000 00000001705 13035744274 021101 0 ustar root root # Stubs for yaml.resolver (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from yaml.error import YAMLError
class ResolverError(YAMLError): ...
class BaseResolver:
DEFAULT_SCALAR_TAG = ... # type: Any
DEFAULT_SEQUENCE_TAG = ... # type: Any
DEFAULT_MAPPING_TAG = ... # type: Any
yaml_implicit_resolvers = ... # type: Any
yaml_path_resolvers = ... # type: Any
resolver_exact_paths = ... # type: Any
resolver_prefix_paths = ... # type: Any
def __init__(self) -> None: ...
def add_implicit_resolver(cls, tag, regexp, first): ...
def add_path_resolver(cls, tag, path, kind=...): ...
def descend_resolver(self, current_node, current_index): ...
def ascend_resolver(self): ...
def check_resolver_prefix(self, depth, path, kind, current_node, current_index): ...
def resolve(self, kind, value, implicit): ...
class Resolver(BaseResolver): ...
mypy-0.470/typeshed/third_party/2/yaml/loader.pyi 0000644 0000000 0000000 00000001343 13023631176 020475 0 ustar root root # Stubs for yaml.loader (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from yaml.reader import Reader
from yaml.scanner import Scanner
from yaml.parser import Parser
from yaml.composer import Composer
from yaml.constructor import BaseConstructor, SafeConstructor, Constructor
from yaml.resolver import BaseResolver, Resolver
class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
def __init__(self, stream) -> None: ...
class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
def __init__(self, stream) -> None: ...
class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
def __init__(self, stream) -> None: ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/ 0000755 0000000 0000000 00000000000 13044320557 017704 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/__init__.pyi 0000644 0000000 0000000 00000003450 13044257024 022166 0 ustar root root # Stubs for sqlalchemy (Python 2)
from .sql import (
alias,
and_,
asc,
between,
bindparam,
case,
cast,
collate,
column,
delete,
desc,
distinct,
except_,
except_all,
exists,
extract,
false,
func,
funcfilter,
insert,
intersect,
intersect_all,
join,
literal,
literal_column,
modifier,
not_,
null,
or_,
outerjoin,
outparam,
over,
select,
subquery,
table,
text,
true,
tuple_,
type_coerce,
union,
union_all,
update,
)
from .types import (
BIGINT,
BINARY,
BLOB,
BOOLEAN,
BigInteger,
Binary,
Boolean,
CHAR,
CLOB,
DATE,
DATETIME,
DECIMAL,
Date,
DateTime,
Enum,
FLOAT,
Float,
INT,
INTEGER,
Integer,
Interval,
LargeBinary,
NCHAR,
NVARCHAR,
NUMERIC,
Numeric,
PickleType,
REAL,
SMALLINT,
SmallInteger,
String,
TEXT,
TIME,
TIMESTAMP,
Text,
Time,
TypeDecorator,
Unicode,
UnicodeText,
VARBINARY,
VARCHAR,
)
from .schema import (
CheckConstraint,
Column,
ColumnDefault,
Constraint,
DefaultClause,
FetchedValue,
ForeignKey,
ForeignKeyConstraint,
Index,
MetaData,
PassiveDefault,
PrimaryKeyConstraint,
Sequence,
Table,
ThreadLocalMetaData,
UniqueConstraint,
DDL,
)
from . import sql as sql
from . import schema as schema
from . import types as types
from . import exc as exc
from . import dialects as dialects
from . import pool as pool
# This should re-export orm but orm is totally broken right now
# from . import orm as orm
from .inspection import inspect
from .engine import create_engine, engine_from_config
__version__ = ... # type: int
mypy-0.470/typeshed/third_party/2/sqlalchemy/util/ 0000755 0000000 0000000 00000000000 13044320557 020661 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/util/langhelpers.pyi 0000644 0000000 0000000 00000007646 13044257024 023723 0 ustar root root # Stubs for sqlalchemy.util.langhelpers (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import compat
def md5_hex(x): ...
class safe_reraise:
def __enter__(self): ...
def __exit__(self, type_, value, traceback): ...
def decode_slice(slc): ...
def map_bits(fn, n): ...
def decorator(target): ...
def public_factory(target, location): ...
class PluginLoader:
group = ... # type: Any
impls = ... # type: Any
auto_fn = ... # type: Any
def __init__(self, group, auto_fn=...) -> None: ...
def load(self, name): ...
def register(self, name, modulepath, objname): ...
def get_cls_kwargs(cls, _set=...): ...
def inspect_func_args(fn): ...
def get_func_kwargs(func): ...
def get_callable_argspec(fn, no_self=..., _is_init=...): ...
def format_argspec_plus(fn, grouped=...): ...
def format_argspec_init(method, grouped=...): ...
def getargspec_init(method): ...
def unbound_method_to_callable(func_or_cls): ...
def generic_repr(obj, additional_kw=..., to_inspect=..., omit_kwarg=...): ...
class portable_instancemethod:
target = ... # type: Any
name = ... # type: Any
def __init__(self, meth) -> None: ...
def __call__(self, *arg, **kw): ...
def class_hierarchy(cls): ...
def iterate_attributes(cls): ...
def monkeypatch_proxied_specials(into_cls, from_cls, skip=..., only=..., name=..., from_instance=...): ...
def methods_equivalent(meth1, meth2): ...
def as_interface(obj, cls=..., methods=..., required=...): ...
class memoized_property:
fget = ... # type: Any
__name__ = ... # type: Any
def __init__(self, fget, doc=...) -> None: ...
def __get__(self, obj, cls): ...
@classmethod
def reset(cls, obj, name): ...
def memoized_instancemethod(fn): ...
class group_expirable_memoized_property:
attributes = ... # type: Any
def __init__(self, attributes=...) -> None: ...
def expire_instance(self, instance): ...
def __call__(self, fn): ...
def method(self, fn): ...
class MemoizedSlots:
def __getattr__(self, key): ...
def dependency_for(modulename): ...
class dependencies:
import_deps = ... # type: Any
def __init__(self, *deps) -> None: ...
def __call__(self, fn): ...
@classmethod
def resolve_all(cls, path): ...
class _importlater:
def __new__(cls, path, addtl): ...
def __init__(self, path, addtl) -> None: ...
def module(self): ...
def __getattr__(self, key): ...
def asbool(obj): ...
def bool_or_str(*text): ...
def asint(value): ...
def coerce_kw_type(kw, key, type_, flexi_bool=...): ...
def constructor_copy(obj, cls, *args, **kw): ...
def counter(): ...
def duck_type_collection(specimen, default=...): ...
def assert_arg_type(arg, argtype, name): ...
def dictlike_iteritems(dictlike): ...
class classproperty:
def __init__(self, fget, *arg, **kw) -> None: ...
def __get__(desc, self, cls): ...
class hybridproperty:
func = ... # type: Any
def __init__(self, func) -> None: ...
def __get__(self, instance, owner): ...
class hybridmethod:
func = ... # type: Any
def __init__(self, func) -> None: ...
def __get__(self, instance, owner): ...
class _symbol(int):
def __new__(self, name, doc=..., canonical=...): ...
def __reduce__(self): ...
class symbol:
symbols = ... # type: Any
def __new__(cls, name, doc=..., canonical=...): ...
def set_creation_order(instance): ...
def warn_exception(func, *args, **kwargs): ...
def ellipses_string(value, len_=...): ...
class _hash_limit_string(compat.text_type):
def __new__(cls, value, num, args): ...
def __hash__(self): ...
def __eq__(self, other): ...
def warn(msg): ...
def warn_limited(msg, args): ...
def only_once(fn): ...
def chop_traceback(tb, exclude_prefix=..., exclude_suffix=...): ...
NoneType = ... # type: Any
def attrsetter(attrname): ...
class EnsureKWArgType(type):
def __init__(cls, clsname, bases, clsdict) -> None: ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/util/_collections.pyi 0000644 0000000 0000000 00000014573 13044257024 024071 0 ustar root root # Stubs for sqlalchemy.util._collections (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import compat
threading = compat.threading
itertools_filterfalse = compat.itertools_filterfalse
string_types = compat.string_types
EMPTY_SET = ... # type: Any
class AbstractKeyedTuple(tuple):
def keys(self): ...
class KeyedTuple(AbstractKeyedTuple):
def __new__(cls, vals, labels=...): ...
def __setattr__(self, key, value): ...
class _LW(AbstractKeyedTuple):
def __new__(cls, vals): ...
def __reduce__(self): ...
class ImmutableContainer:
__delitem__ = ... # type: Any
class immutabledict(ImmutableContainer, dict):
clear = ... # type: Any
def __new__(cls, *args): ...
def __init__(self, *args) -> None: ...
def __reduce__(self): ...
def union(self, d): ...
class Properties:
def __init__(self, data) -> None: ...
def __len__(self): ...
def __iter__(self): ...
def __add__(self, other): ...
def __setitem__(self, key, object): ...
def __getitem__(self, key): ...
def __delitem__(self, key): ...
def __setattr__(self, key, obj): ...
def __getattr__(self, key): ...
def __contains__(self, key): ...
def as_immutable(self): ...
def update(self, value): ...
def get(self, key, default=...): ...
def keys(self): ...
def values(self): ...
def items(self): ...
def has_key(self, key): ...
def clear(self): ...
class OrderedProperties(Properties):
def __init__(self) -> None: ...
class ImmutableProperties(ImmutableContainer, Properties): ...
class OrderedDict(dict):
def __reduce__(self): ...
def __init__(self, ____sequence=..., **kwargs) -> None: ...
def clear(self): ...
def copy(self): ...
def __copy__(self): ...
def sort(self, *arg, **kw): ...
def update(self, ____sequence=..., **kwargs): ...
def setdefault(self, key, value): ...
def __iter__(self): ...
def keys(self): ...
def values(self): ...
def items(self): ...
def itervalues(self): ...
def iterkeys(self): ...
def iteritems(self): ...
def __setitem__(self, key, object): ...
def __delitem__(self, key): ...
def pop(self, key, *default): ...
def popitem(self): ...
class OrderedSet(set):
def __init__(self, d=...) -> None: ...
def add(self, element): ...
def remove(self, element): ...
def insert(self, pos, element): ...
def discard(self, element): ...
def clear(self): ...
def __getitem__(self, key): ...
def __iter__(self): ...
def __add__(self, other): ...
def update(self, iterable): ...
__ior__ = ... # type: Any
def union(self, other): ...
__or__ = ... # type: Any
def intersection(self, other): ...
__and__ = ... # type: Any
def symmetric_difference(self, other): ...
__xor__ = ... # type: Any
def difference(self, other): ...
__sub__ = ... # type: Any
def intersection_update(self, other): ...
__iand__ = ... # type: Any
def symmetric_difference_update(self, other): ...
__ixor__ = ... # type: Any
def difference_update(self, other): ...
__isub__ = ... # type: Any
class IdentitySet:
def __init__(self, iterable=...) -> None: ...
def add(self, value): ...
def __contains__(self, value): ...
def remove(self, value): ...
def discard(self, value): ...
def pop(self): ...
def clear(self): ...
def __cmp__(self, other): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def issubset(self, iterable): ...
def __le__(self, other): ...
def __lt__(self, other): ...
def issuperset(self, iterable): ...
def __ge__(self, other): ...
def __gt__(self, other): ...
def union(self, iterable): ...
def __or__(self, other): ...
def update(self, iterable): ...
def __ior__(self, other): ...
def difference(self, iterable): ...
def __sub__(self, other): ...
def difference_update(self, iterable): ...
def __isub__(self, other): ...
def intersection(self, iterable): ...
def __and__(self, other): ...
def intersection_update(self, iterable): ...
def __iand__(self, other): ...
def symmetric_difference(self, iterable): ...
def __xor__(self, other): ...
def symmetric_difference_update(self, iterable): ...
def __ixor__(self, other): ...
def copy(self): ...
__copy__ = ... # type: Any
def __len__(self): ...
def __iter__(self): ...
def __hash__(self): ...
class WeakSequence:
def __init__(self, __elements=...) -> None: ...
def append(self, item): ...
def __len__(self): ...
def __iter__(self): ...
def __getitem__(self, index): ...
class OrderedIdentitySet(IdentitySet):
class _working_set(OrderedSet):
__sa_hash_exempt__ = ... # type: Any
def __init__(self, iterable=...) -> None: ...
class PopulateDict(dict):
creator = ... # type: Any
def __init__(self, creator) -> None: ...
def __missing__(self, key): ...
column_set = set
column_dict = dict
ordered_column_set = OrderedSet
populate_column_dict = PopulateDict
def unique_list(seq, hashfunc=...): ...
class UniqueAppender:
data = ... # type: Any
def __init__(self, data, via=...) -> None: ...
def append(self, item): ...
def __iter__(self): ...
def coerce_generator_arg(arg): ...
def to_list(x, default=...): ...
def has_intersection(set_, iterable): ...
def to_set(x): ...
def to_column_set(x): ...
def update_copy(d, _new=..., **kw): ...
def flatten_iterator(x): ...
class LRUCache(dict):
capacity = ... # type: Any
threshold = ... # type: Any
def __init__(self, capacity=..., threshold=...) -> None: ...
def get(self, key, default=...): ...
def __getitem__(self, key): ...
def values(self): ...
def setdefault(self, key, value): ...
def __setitem__(self, key, value): ...
def lightweight_named_tuple(name, fields): ...
class ScopedRegistry:
createfunc = ... # type: Any
scopefunc = ... # type: Any
registry = ... # type: Any
def __init__(self, createfunc, scopefunc) -> None: ...
def __call__(self): ...
def has(self): ...
def set(self, obj): ...
def clear(self): ...
class ThreadLocalRegistry(ScopedRegistry):
createfunc = ... # type: Any
registry = ... # type: Any
def __init__(self, createfunc) -> None: ...
def __call__(self): ...
def has(self): ...
def set(self, obj): ...
def clear(self): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/util/__init__.pyi 0000644 0000000 0000000 00000011746 13044257024 023152 0 ustar root root # Stubs for sqlalchemy.util (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import compat
from . import _collections
from . import langhelpers
from . import deprecations
callable = compat.callable
cmp = compat.cmp
reduce = compat.reduce
threading = compat.threading
py3k = compat.py3k
py33 = compat.py33
py2k = compat.py2k
jython = compat.jython
pypy = compat.pypy
cpython = compat.cpython
win32 = compat.win32
pickle = compat.pickle
dottedgetter = compat.dottedgetter
parse_qsl = compat.parse_qsl
namedtuple = compat.namedtuple
next = compat.next
reraise = compat.reraise
raise_from_cause = compat.raise_from_cause
text_type = compat.text_type
safe_kwarg = compat.safe_kwarg
string_types = compat.string_types
int_types = compat.int_types
binary_type = compat.binary_type
nested = compat.nested
quote_plus = compat.quote_plus
with_metaclass = compat.with_metaclass
print_ = compat.print_
itertools_filterfalse = compat.itertools_filterfalse
u = compat.u
ue = compat.ue
b = compat.b
unquote_plus = compat.unquote_plus
unquote = compat.unquote
b64decode = compat.b64decode
b64encode = compat.b64encode
byte_buffer = compat.byte_buffer
itertools_filter = compat.itertools_filter
iterbytes = compat.iterbytes
StringIO = compat.StringIO
inspect_getargspec = compat.inspect_getargspec
zip_longest = compat.zip_longest
KeyedTuple = _collections.KeyedTuple
ImmutableContainer = _collections.ImmutableContainer
immutabledict = _collections.immutabledict
Properties = _collections.Properties
OrderedProperties = _collections.OrderedProperties
ImmutableProperties = _collections.ImmutableProperties
OrderedDict = _collections.OrderedDict
OrderedSet = _collections.OrderedSet
IdentitySet = _collections.IdentitySet
OrderedIdentitySet = _collections.OrderedIdentitySet
column_set = _collections.column_set
column_dict = _collections.column_dict
ordered_column_set = _collections.ordered_column_set
populate_column_dict = _collections.populate_column_dict
unique_list = _collections.unique_list
UniqueAppender = _collections.UniqueAppender
PopulateDict = _collections.PopulateDict
EMPTY_SET = _collections.EMPTY_SET
to_list = _collections.to_list
to_set = _collections.to_set
to_column_set = _collections.to_column_set
update_copy = _collections.update_copy
flatten_iterator = _collections.flatten_iterator
has_intersection = _collections.has_intersection
LRUCache = _collections.LRUCache
ScopedRegistry = _collections.ScopedRegistry
ThreadLocalRegistry = _collections.ThreadLocalRegistry
WeakSequence = _collections.WeakSequence
coerce_generator_arg = _collections.coerce_generator_arg
lightweight_named_tuple = _collections.lightweight_named_tuple
iterate_attributes = langhelpers.iterate_attributes
class_hierarchy = langhelpers.class_hierarchy
portable_instancemethod = langhelpers.portable_instancemethod
unbound_method_to_callable = langhelpers.unbound_method_to_callable
getargspec_init = langhelpers.getargspec_init
format_argspec_init = langhelpers.format_argspec_init
format_argspec_plus = langhelpers.format_argspec_plus
get_func_kwargs = langhelpers.get_func_kwargs
get_cls_kwargs = langhelpers.get_cls_kwargs
decorator = langhelpers.decorator
as_interface = langhelpers.as_interface
memoized_property = langhelpers.memoized_property
memoized_instancemethod = langhelpers.memoized_instancemethod
md5_hex = langhelpers.md5_hex
group_expirable_memoized_property = langhelpers.group_expirable_memoized_property
dependencies = langhelpers.dependencies
decode_slice = langhelpers.decode_slice
monkeypatch_proxied_specials = langhelpers.monkeypatch_proxied_specials
asbool = langhelpers.asbool
bool_or_str = langhelpers.bool_or_str
coerce_kw_type = langhelpers.coerce_kw_type
duck_type_collection = langhelpers.duck_type_collection
assert_arg_type = langhelpers.assert_arg_type
symbol = langhelpers.symbol
dictlike_iteritems = langhelpers.dictlike_iteritems
classproperty = langhelpers.classproperty
set_creation_order = langhelpers.set_creation_order
warn_exception = langhelpers.warn_exception
warn = langhelpers.warn
NoneType = langhelpers.NoneType
constructor_copy = langhelpers.constructor_copy
methods_equivalent = langhelpers.methods_equivalent
chop_traceback = langhelpers.chop_traceback
asint = langhelpers.asint
generic_repr = langhelpers.generic_repr
counter = langhelpers.counter
PluginLoader = langhelpers.PluginLoader
hybridproperty = langhelpers.hybridproperty
hybridmethod = langhelpers.hybridmethod
safe_reraise = langhelpers.safe_reraise
get_callable_argspec = langhelpers.get_callable_argspec
only_once = langhelpers.only_once
attrsetter = langhelpers.attrsetter
ellipses_string = langhelpers.ellipses_string
warn_limited = langhelpers.warn_limited
map_bits = langhelpers.map_bits
MemoizedSlots = langhelpers.MemoizedSlots
EnsureKWArgType = langhelpers.EnsureKWArgType
warn_deprecated = deprecations.warn_deprecated
warn_pending_deprecation = deprecations.warn_pending_deprecation
deprecated = deprecations.deprecated
pending_deprecation = deprecations.pending_deprecation
inject_docstring_text = deprecations.inject_docstring_text
mypy-0.470/typeshed/third_party/2/sqlalchemy/util/deprecations.pyi 0000644 0000000 0000000 00000001000 13044257024 024051 0 ustar root root # Stubs for sqlalchemy.util.deprecations (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import langhelpers
decorator = langhelpers.decorator
def warn_deprecated(msg, stacklevel=...): ...
def warn_pending_deprecation(msg, stacklevel=...): ...
def deprecated(version, message=..., add_deprecation_to_docstring=...): ...
def pending_deprecation(version, message=..., add_deprecation_to_docstring=...): ...
def inject_docstring_text(doctext, injecttext, pos): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/util/compat.pyi 0000644 0000000 0000000 00000002776 13044257024 022701 0 ustar root root # Stubs for sqlalchemy.util.compat (Python 2)
from typing import Any
from collections import namedtuple
import threading
import pickle
from six.moves.urllib.parse import (quote_plus, unquote_plus,
parse_qsl, quote, unquote)
# import configparser
from six.moves import StringIO
from io import BytesIO as byte_buffer
from operator import attrgetter as dottedgetter
from six.moves import zip_longest
py33 = ... # type: Any
py32 = ... # type: Any
py3k = ... # type: Any
py2k = ... # type: Any
py265 = ... # type: Any
jython = ... # type: Any
pypy = ... # type: Any
win32 = ... # type: Any
cpython = ... # type: Any
next = ... # type: Any
safe_kwarg = ... # type: Any
ArgSpec = namedtuple('ArgSpec', ['args', 'varargs', 'keywords', 'defaults'])
def inspect_getargspec(func): ...
string_types = ... # type: Any
binary_type = ... # type: Any
text_type = unicode
int_types = ... # type: Any
def callable(fn): ...
def cmp(a, b): ...
itertools_filterfalse = ... # type: Any
itertools_filter = ... # type: Any
itertools_imap = ... # type: Any
def b64encode(x): ...
def b64decode(x): ...
def iterbytes(buf): ...
def u(s): ...
def ue(s): ...
def b(s): ...
def import_(*args): ...
reduce = ... # type: Any
def print_(*args, **kwargs): ...
time_func = ... # type: Any
def reraise(tp, value, tb=..., cause=...): ...
def raise_from_cause(exception, exc_info=...): ...
def exec_(func_text, globals_, lcl=...): ...
def with_metaclass(meta, *bases): ...
def nested(*managers): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/databases/ 0000755 0000000 0000000 00000000000 13044320557 021633 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/databases/mysql.pyi 0000644 0000000 0000000 00000000073 13044257024 023521 0 ustar root root from sqlalchemy.dialects.mysql.base import * # noqa: F403
mypy-0.470/typeshed/third_party/2/sqlalchemy/databases/__init__.pyi 0000644 0000000 0000000 00000000363 13044257024 024115 0 ustar root root # Stubs for sqlalchemy.databases (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# firebird
# mssql
# mysql
# oracle
# postgresql
# sqlite
# sybase
mypy-0.470/typeshed/third_party/2/sqlalchemy/schema.pyi 0000644 0000000 0000000 00000003103 13044257024 021662 0 ustar root root # Stubs for sqlalchemy.schema (Python 2)
from .sql import base
from .sql import schema
from .sql import naming
from .sql import ddl
from .sql import elements
SchemaVisitor = base.SchemaVisitor
CheckConstraint = schema.CheckConstraint
Column = schema.Column
ColumnDefault = schema.ColumnDefault
Constraint = schema.Constraint
DefaultClause = schema.DefaultClause
DefaultGenerator = schema.DefaultGenerator
FetchedValue = schema.FetchedValue
ForeignKey = schema.ForeignKey
ForeignKeyConstraint = schema.ForeignKeyConstraint
Index = schema.Index
MetaData = schema.MetaData
PassiveDefault = schema.PassiveDefault
PrimaryKeyConstraint = schema.PrimaryKeyConstraint
SchemaItem = schema.SchemaItem
Sequence = schema.Sequence
Table = schema.Table
ThreadLocalMetaData = schema.ThreadLocalMetaData
UniqueConstraint = schema.UniqueConstraint
_get_table_key = schema._get_table_key
ColumnCollectionConstraint = schema.ColumnCollectionConstraint
ColumnCollectionMixin = schema.ColumnCollectionMixin
conv = elements.conv
DDL = ddl.DDL
CreateTable = ddl.CreateTable
DropTable = ddl.DropTable
CreateSequence = ddl.CreateSequence
DropSequence = ddl.DropSequence
CreateIndex = ddl.CreateIndex
DropIndex = ddl.DropIndex
CreateSchema = ddl.CreateSchema
DropSchema = ddl.DropSchema
_DropView = ddl._DropView
CreateColumn = ddl.CreateColumn
AddConstraint = ddl.AddConstraint
DropConstraint = ddl.DropConstraint
DDLBase = ddl.DDLBase
DDLElement = ddl.DDLElement
_CreateDropBase = ddl._CreateDropBase
_DDLCompiles = ddl._DDLCompiles
sort_tables = ddl.sort_tables
sort_tables_and_constraints = ddl.sort_tables_and_constraints
mypy-0.470/typeshed/third_party/2/sqlalchemy/types.pyi 0000644 0000000 0000000 00000002526 13044257024 021576 0 ustar root root # Stubs for sqlalchemy.types (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .sql import type_api
from .sql import sqltypes
TypeEngine = type_api.TypeEngine
TypeDecorator = type_api.TypeDecorator
UserDefinedType = type_api.UserDefinedType
BIGINT = sqltypes.BIGINT
BINARY = sqltypes.BINARY
BLOB = sqltypes.BLOB
BOOLEAN = sqltypes.BOOLEAN
BigInteger = sqltypes.BigInteger
Binary = sqltypes.Binary
Boolean = sqltypes.Boolean
CHAR = sqltypes.CHAR
CLOB = sqltypes.CLOB
Concatenable = sqltypes.Concatenable
DATE = sqltypes.DATE
DATETIME = sqltypes.DATETIME
DECIMAL = sqltypes.DECIMAL
Date = sqltypes.Date
DateTime = sqltypes.DateTime
Enum = sqltypes.Enum
FLOAT = sqltypes.FLOAT
Float = sqltypes.Float
INT = sqltypes.INT
INTEGER = sqltypes.INTEGER
Integer = sqltypes.Integer
Interval = sqltypes.Interval
LargeBinary = sqltypes.LargeBinary
NCHAR = sqltypes.NCHAR
NVARCHAR = sqltypes.NVARCHAR
NUMERIC = sqltypes.NUMERIC
Numeric = sqltypes.Numeric
PickleType = sqltypes.PickleType
REAL = sqltypes.REAL
SMALLINT = sqltypes.SMALLINT
SmallInteger = sqltypes.SmallInteger
String = sqltypes.String
TEXT = sqltypes.TEXT
TIME = sqltypes.TIME
TIMESTAMP = sqltypes.TIMESTAMP
Text = sqltypes.Text
Time = sqltypes.Time
Unicode = sqltypes.Unicode
UnicodeText = sqltypes.UnicodeText
VARBINARY = sqltypes.VARBINARY
VARCHAR = sqltypes.VARCHAR
mypy-0.470/typeshed/third_party/2/sqlalchemy/exc.pyi 0000644 0000000 0000000 00000005346 13044257024 021214 0 ustar root root # Stubs for sqlalchemy.exc (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class SQLAlchemyError(Exception): ...
class ArgumentError(SQLAlchemyError): ...
class NoSuchModuleError(ArgumentError): ...
class NoForeignKeysError(ArgumentError): ...
class AmbiguousForeignKeysError(ArgumentError): ...
class CircularDependencyError(SQLAlchemyError):
cycles = ... # type: Any
edges = ... # type: Any
def __init__(self, message, cycles, edges, msg=...) -> None: ...
def __reduce__(self): ...
class CompileError(SQLAlchemyError): ...
class UnsupportedCompilationError(CompileError):
def __init__(self, compiler, element_type) -> None: ...
class IdentifierError(SQLAlchemyError): ...
class DisconnectionError(SQLAlchemyError): ...
class TimeoutError(SQLAlchemyError): ...
class InvalidRequestError(SQLAlchemyError): ...
class NoInspectionAvailable(InvalidRequestError): ...
class ResourceClosedError(InvalidRequestError): ...
class NoSuchColumnError(KeyError, InvalidRequestError): ...
class NoReferenceError(InvalidRequestError): ...
class NoReferencedTableError(NoReferenceError):
table_name = ... # type: Any
def __init__(self, message, tname) -> None: ...
def __reduce__(self): ...
class NoReferencedColumnError(NoReferenceError):
table_name = ... # type: Any
column_name = ... # type: Any
def __init__(self, message, tname, cname) -> None: ...
def __reduce__(self): ...
class NoSuchTableError(InvalidRequestError): ...
class UnboundExecutionError(InvalidRequestError): ...
class DontWrapMixin: ...
UnmappedColumnError = ... # type: Any
class StatementError(SQLAlchemyError):
statement = ... # type: Any
params = ... # type: Any
orig = ... # type: Any
detail = ... # type: Any
def __init__(self, message, statement, params, orig) -> None: ...
def add_detail(self, msg): ...
def __reduce__(self): ...
def __unicode__(self): ...
class DBAPIError(StatementError):
@classmethod
def instance(cls, statement, params, orig, dbapi_base_err, connection_invalidated=..., dialect=...): ...
def __reduce__(self): ...
connection_invalidated = ... # type: Any
def __init__(self, statement, params, orig, connection_invalidated=...) -> None: ...
class InterfaceError(DBAPIError): ...
class DatabaseError(DBAPIError): ...
class DataError(DatabaseError): ...
class OperationalError(DatabaseError): ...
class IntegrityError(DatabaseError): ...
class InternalError(DatabaseError): ...
class ProgrammingError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
class SADeprecationWarning(DeprecationWarning): ...
class SAPendingDeprecationWarning(PendingDeprecationWarning): ...
class SAWarning(RuntimeWarning): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/ 0000755 0000000 0000000 00000000000 13044320557 020503 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/__init__.pyi 0000644 0000000 0000000 00000003545 13044257024 022772 0 ustar root root # Stubs for sqlalchemy.sql (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import expression
from . import visitors
Alias = expression.Alias
ClauseElement = expression.ClauseElement
ColumnCollection = expression.ColumnCollection
ColumnElement = expression.ColumnElement
CompoundSelect = expression.CompoundSelect
Delete = expression.Delete
FromClause = expression.FromClause
Insert = expression.Insert
Join = expression.Join
Select = expression.Select
Selectable = expression.Selectable
TableClause = expression.TableClause
Update = expression.Update
alias = expression.alias
and_ = expression.and_
asc = expression.asc
between = expression.between
bindparam = expression.bindparam
case = expression.case
cast = expression.cast
collate = expression.collate
column = expression.column
delete = expression.delete
desc = expression.desc
distinct = expression.distinct
except_ = expression.except_
except_all = expression.except_all
exists = expression.exists
extract = expression.extract
false = expression.false
False_ = expression.False_
func = expression.func
funcfilter = expression.funcfilter
insert = expression.insert
intersect = expression.intersect
intersect_all = expression.intersect_all
join = expression.join
label = expression.label
literal = expression.literal
literal_column = expression.literal_column
modifier = expression.modifier
not_ = expression.not_
null = expression.null
or_ = expression.or_
outerjoin = expression.outerjoin
outparam = expression.outparam
over = expression.over
select = expression.select
subquery = expression.subquery
table = expression.table
text = expression.text
true = expression.true
True_ = expression.True_
tuple_ = expression.tuple_
type_coerce = expression.type_coerce
union = expression.union
union_all = expression.union_all
update = expression.update
ClauseVisitor = visitors.ClauseVisitor
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/expression.pyi 0000644 0000000 0000000 00000004767 13044257024 023441 0 ustar root root # Stubs for sqlalchemy.sql.expression (Python 2)
from typing import Any
from . import functions
from . import elements
from . import base
from . import selectable
from . import dml
from .visitors import Visitable
from .elements import ClauseElement, ColumnElement,\
BindParameter, UnaryExpression, BooleanClauseList, \
Label, Cast, Case, ColumnClause, TextClause, Over, Null, \
True_, False_, BinaryExpression, Tuple, TypeClause, Extract, \
Grouping, not_, \
collate, literal_column, between,\
literal, outparam, type_coerce, ClauseList, FunctionFilter
from .elements import SavepointClause, RollbackToSavepointClause, \
ReleaseSavepointClause
from .base import ColumnCollection, Generative, Executable
from .selectable import Alias, Join, Select, Selectable, TableClause, \
CompoundSelect, CTE, FromClause, FromGrouping, SelectBase, \
alias, GenerativeSelect, \
subquery, HasPrefixes, HasSuffixes, Exists, ScalarSelect, TextAsFrom
from .dml import Insert, Update, Delete, UpdateBase, ValuesBase
func = functions.func # type: functions._FunctionGenerator
modifier = functions.modifier # type: functions._FunctionGenerator
and_ = ... # type: Any
or_ = ... # type: Any
bindparam = ... # type: Any
select = ... # type: Any
text = ... # type: Any
table = ... # type: Any
column = ... # type: Any
over = ... # type: Any
label = ... # type: Any
case = ... # type: Any
cast = ... # type: Any
extract = ... # type: Any
tuple_ = ... # type: Any
except_ = ... # type: Any
except_all = ... # type: Any
intersect = ... # type: Any
intersect_all = ... # type: Any
union = ... # type: Any
union_all = ... # type: Any
exists = ... # type: Any
nullsfirst = ... # type: Any
nullslast = ... # type: Any
asc = ... # type: Any
desc = ... # type: Any
distinct = ... # type: Any
true = ... # type: Any
false = ... # type: Any
null = ... # type: Any
join = ... # type: Any
outerjoin = ... # type: Any
insert = ... # type: Any
update = ... # type: Any
delete = ... # type: Any
funcfilter = ... # type: Any
# old names for compatibility
_Executable = Executable
_BindParamClause = BindParameter
_Label = Label
_SelectBase = SelectBase
_BinaryExpression = BinaryExpression
_Cast = Cast
_Null = Null
_False = False_
_True = True_
_TextClause = TextClause
_UnaryExpression = UnaryExpression
_Case = Case
_Tuple = Tuple
_Over = Over
_Generative = Generative
_TypeClause = TypeClause
_Extract = Extract
_Exists = Exists
_Grouping = Grouping
_FromGrouping = FromGrouping
_ScalarSelect = ScalarSelect
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/type_api.pyi 0000644 0000000 0000000 00000001143 13044257024 023035 0 ustar root root from .. import util
from .visitors import Visitable, VisitableType
class TypeEngine(Visitable):
@property
def python_type(self): ...
def get_dbapi_type(self, dbapi): ...
def literal_processor(self, dialect): ...
def bind_processor(self, dialect): ...
def result_processor(self, dialect, coltype): ...
class VisitableCheckKWArg(util.EnsureKWArgType, VisitableType): ...
# TODO: class UserDefinedType(util.with_metaclass(VisitableCheckKWArg, TypeEngine)):
class UserDefinedType(VisitableCheckKWArg, TypeEngine): ...
class TypeDecorator(TypeEngine): ...
class Variant(TypeDecorator): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/schema.pyi 0000644 0000000 0000000 00000011051 13044257024 022462 0 ustar root root from typing import Any, AnyStr
from .base import SchemaEventTarget, DialectKWArgs
from .base import ColumnCollection
from .elements import ClauseElement, ColumnClause, TextClause, \
ColumnElement
from .selectable import TableClause
from . import visitors
class SchemaItem(SchemaEventTarget, visitors.Visitable):
def _execute_on_connection(self, connection, multiparams, params): ...
@property
def info(self): ...
@property
def quote(self): ...
def get_children(self, **kwargs): ...
def _init_items(self, *args): ...
def _schema_item_copy(self, schema_item): ...
def __repr__(self): ...
class Table(DialectKWArgs, SchemaItem, TableClause):
def __init__(self, name, metadata, *args, **kwargs): ...
@property
def key(self): ...
@property
def primary_key(self): ...
def __repr__(self): ...
def __str__(self): ...
def append_column(self, column): ...
def append_constraint(self, constraint): ...
def append_ddl_listener(self, event, listener): ...
def get_children(self, column_collections=True, schema_visitor=False, **kwargs): ...
def exists(self, bind=None): ...
def create(self, bind=None, checkfirst=False): ...
def drop(self, bind=None, checkfirst=False): ...
def tometadata(self, metadata, schema=None): ...
c = ... # type: ColumnCollection
constraints = ... # type: Set[Constraint]
class Column(SchemaItem, ColumnClause):
primary_key = ... # type: Any
def __init__(self, *args, **kwargs): ...
def references(self, column): ...
def append_foreign_key(self, fk): ...
def __repr__(self): ...
def _set_parent(self, table): ...
def _setup_on_memoized_fks(self, fn): ...
def _on_table_attach(self, fn): ...
def copy(self, **kw): ...
def _make_proxy(self, selectable, name=None, key=None,
name_is_truncatable=False, **kw): ...
def get_children(self, schema_visitor=False, **kwargs): ...
class ForeignKey(DialectKWArgs, SchemaItem):
def __init__(self, column, _constraint=None, use_alter=False, name=None,
onupdate=None, ondelete=None, deferrable=None,
initially=None, link_to_name=False, match=None,
info=None, **dialect_kw) -> None: ...
def __repr__(self): ...
def copy(self, schema=None): ...
def _get_colspec(self, schema=None, table_name=None): ...
@property
def _referred_schema(self): ...
def _table_key(self): ...
def references(self, table): ...
def get_referent(self, table): ...
@property
def _column_tokens(self): ...
def _resolve_col_tokens(self): ...
def _link_to_col_by_colstring(self, parenttable, table, colname): ...
def _set_target_column(self, column): ...
@property
def column(self): ...
def _set_parent(self, column): ...
def _set_remote_table(self, table): ...
def _remove_from_metadata(self, metadata): ...
def _set_table(self, column, table): ...
class _NotAColumnExpr(object): ...
class DefaultGenerator(_NotAColumnExpr, SchemaItem): ...
class ColumnDefault(DefaultGenerator): ...
class Sequence(DefaultGenerator): ...
class FetchedValue(_NotAColumnExpr, SchemaEventTarget): ...
class DefaultClause(FetchedValue): ...
class PassiveDefault(DefaultClause): ...
class Constraint(DialectKWArgs, SchemaItem):
def __init__(self, name=None, deferrable=None, initially=None): ...
def __contains__(self, x): ...
def contains_column(self, col): ...
def keys(self): ...
def __add__(self, other): ...
def __iter__(self): ...
def __len__(self): ...
def copy(self, **kw): ...
class ColumnCollectionMixin(object):
columns = ... # type: Any
def __init__(self, *columns, **kw): ...
@classmethod
def _extract_col_expression_collection(cls, expressions): ...
def _check_attach(self, evt=False): ...
def _set_parent(self, table): ...
class ColumnCollectionConstraint(ColumnCollectionMixin, Constraint):
def __init__(self, *columns, **kw): ...
def _set_parent(self, table): ...
def __contains__(self, x): ...
def copy(self, **kw): ...
def contains_column(self, col): ...
def __iter__(self): ...
def __len__(self): ...
class CheckConstraint(ColumnCollectionConstraint): ...
class ForeignKeyConstraint(ColumnCollectionConstraint): ...
class PrimaryKeyConstraint(ColumnCollectionConstraint): ...
class UniqueConstraint(ColumnCollectionConstraint): ...
class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): ...
class MetaData(SchemaItem): ...
class ThreadLocalMetaData(MetaData): ...
def _get_table_key(name: AnyStr, schema: AnyStr): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/visitors.pyi 0000644 0000000 0000000 00000001750 13044257024 023111 0 ustar root root # Stubs for sqlalchemy.sql.visitors (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class VisitableType(type):
def __init__(cls, clsname, bases, clsdict) -> None: ...
class Visitable: ...
class ClauseVisitor:
__traverse_options__ = ... # type: Any
def traverse_single(self, obj, **kw): ...
def iterate(self, obj): ...
def traverse(self, obj): ...
def chain(self, visitor): ...
class CloningVisitor(ClauseVisitor):
def copy_and_process(self, list_): ...
def traverse(self, obj): ...
class ReplacingCloningVisitor(CloningVisitor):
def replace(self, elem): ...
def traverse(self, obj): ...
def iterate(obj, opts): ...
def iterate_depthfirst(obj, opts): ...
def traverse_using(iterator, obj, visitors): ...
def traverse(obj, opts, visitors): ...
def traverse_depthfirst(obj, opts, visitors): ...
def cloned_traverse(obj, opts, visitors): ...
def replacement_traverse(obj, opts, replace): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/elements.pyi 0000644 0000000 0000000 00000004066 13044257024 023046 0 ustar root root
from .visitors import Visitable
from .annotation import Annotated
from .base import Executable, Immutable
from .operators import ColumnOperators
from .. import util
class ClauseElement(Visitable): ...
class ColumnElement(ColumnOperators, ClauseElement): ...
class BindParameter(ColumnElement): ...
class BinaryExpression(ColumnElement): ...
class TypeClause(ClauseElement): ...
class TextClause(Executable, ClauseElement): ...
class Null(ColumnElement): ...
class False_(ColumnElement): ...
class True_(ColumnElement): ...
class ClauseList(ClauseElement): ...
class BooleanClauseList(ClauseList, ColumnElement): ...
class Tuple(ClauseList, ColumnElement): ...
class Case(ColumnElement): ...
class Cast(ColumnElement): ...
class Extract(ColumnElement): ...
class _label_reference(ColumnElement): ...
class _textual_label_reference(ColumnElement): ...
class UnaryExpression(ColumnElement): ...
class AsBoolean(UnaryExpression): ...
class Grouping(ColumnElement): ...
class Over(ColumnElement): ...
class FunctionFilter(ColumnElement): ...
class Label(ColumnElement): ...
class ColumnClause(Immutable, ColumnElement): ...
class _IdentifiedClause(Executable, ClauseElement): ...
class SavepointClause(_IdentifiedClause): ...
class RollbackToSavepointClause(_IdentifiedClause): ...
class ReleaseSavepointClause(_IdentifiedClause): ...
class quoted_name(util.MemoizedSlots, util.text_type): ...
class _truncated_label(quoted_name): ...
class conv(_truncated_label): ...
class _defer_name(_truncated_label): ...
class _defer_none_name(_defer_name): ...
class _anonymous_label(_truncated_label): ...
class AnnotatedColumnElement(Annotated): ...
def _clone(element, **kw): ...
def _type_from_args(args): ...
def _literal_as_binds(element, name, type_=None): ...
def collate(expression, collation) -> BinaryExpression: ...
def between(expr, lower_bound, upper_bound, symmetric: bool=...): ...
def literal(value, type_=None) -> BindParameter: ...
def outparam(key, type_=None) -> BindParameter: ...
def type_coerce(expression, type_): ...
def not_(clause): ...
def literal_column(text, type_=None): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/functions.pyi 0000644 0000000 0000000 00000003103 13044257024 023231 0 ustar root root
from .base import Executable, ColumnCollection
from .elements import ClauseList, Cast, Extract, _literal_as_binds, \
literal_column, _type_from_args, ColumnElement, _clone,\
Over, BindParameter, FunctionFilter
from .selectable import FromClause, Select, Alias
from .visitors import VisitableType
class FunctionElement(Executable, ColumnElement, FromClause): ...
class _FunctionGenerator(object):
def __init__(self, **opts): ...
def __getattr__(self, name): ...
def __call__(self, *c, **kwargs) -> Function: ...
func = ... # type: _FunctionGenerator
modifier = ... # type: _FunctionGenerator
class Function(FunctionElement): ...
class _GenericMeta(VisitableType): ...
# TODO: Use GenericFunction(util.with_metaclass(_GenericMeta, Function))
class GenericFunction(_GenericMeta, Function): ...
class next_value(GenericFunction): ...
class AnsiFunction(GenericFunction): ...
class ReturnTypeFromArgs(GenericFunction): ...
class coalesce(ReturnTypeFromArgs): ...
class max(ReturnTypeFromArgs): ...
class min(ReturnTypeFromArgs): ...
class sum(ReturnTypeFromArgs): ...
class now(GenericFunction): ...
class concat(GenericFunction): ...
class char_length(GenericFunction): ...
class random(GenericFunction): ...
class count(GenericFunction): ...
class current_date(AnsiFunction): ...
class current_time(AnsiFunction): ...
class current_timestamp(AnsiFunction): ...
class current_user(AnsiFunction): ...
class localtime(AnsiFunction): ...
class localtimestamp(AnsiFunction): ...
class session_user(AnsiFunction): ...
class sysdate(AnsiFunction): ...
class user(AnsiFunction): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/annotation.pyi 0000644 0000000 0000000 00000000632 13044257024 023377 0 ustar root root class Annotated(object):
def __new__(cls, *args): ...
def __init__(self, element, values): ...
def _annotate(self, values): ...
def _with_annotations(self, values): ...
def _deannotate(self, values=..., clone: bool=...): ...
def _compiler_dispatch(self, visitor, **kw): ...
def _constructor(self): ...
def _clone(self): ...
def __hash__(self): ...
def __eq__(self): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/sqltypes.pyi 0000644 0000000 0000000 00000003366 13044257024 023120 0 ustar root root from .type_api import TypeEngine, TypeDecorator
from .base import SchemaEventTarget
class _DateAffinity(object): ...
class Concatenable(object): ...
class String(TypeEngine, Concatenable):
def __init__(self, length=None, collation=None,
convert_unicode=False,
unicode_error=None,
_warn_on_bytestring=False): ...
class Text(String): ...
class Unicode(String): ...
class UnicodeText(Text): ...
class Integer(TypeEngine, _DateAffinity): ...
class SmallInteger(Integer): ...
class BigInteger(Integer): ...
class Numeric(TypeEngine, _DateAffinity): ...
class Float(Numeric): ...
class DateTime(TypeEngine, _DateAffinity):
def __init__(self, timezone=None): ...
class Date(TypeEngine, _DateAffinity): ...
class Time(TypeEngine, _DateAffinity): ...
class _Binary(TypeEngine): ...
class LargeBinary(_Binary): ...
class Binary(LargeBinary): ...
class SchemaType(SchemaEventTarget): ...
class Enum(String, SchemaType): ...
class PickleType(TypeDecorator): ...
class Boolean(TypeEngine, SchemaType): ...
class Interval(_DateAffinity, TypeDecorator): ...
class REAL(Float): ...
class FLOAT(Float): ...
class NUMERIC(Numeric): ...
class DECIMAL(Numeric): ...
class INTEGER(Integer): ...
# In code it's INT=INTEGER
class INT(Integer): ...
class SMALLINT(SmallInteger): ...
class BIGINT(BigInteger): ...
class TIMESTAMP(DateTime): ...
class DATETIME(DateTime): ...
class DATE(Date): ...
class TIME(Time): ...
class TEXT(Text): ...
class CLOB(Text): ...
class VARCHAR(String): ...
class NVARCHAR(Unicode): ...
class CHAR(String): ...
class NCHAR(Unicode): ...
class BLOB(LargeBinary): ...
class BINARY(_Binary): ...
class VARBINARY(_Binary): ...
class BOOLEAN(Boolean): ...
class NullType(TypeEngine): ...
class MatchType(Boolean): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/naming.pyi 0000644 0000000 0000000 00000000042 13044257024 022471 0 ustar root root class ConventionDict(object): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/selectable.pyi 0000644 0000000 0000000 00000005200 13044257024 023324 0 ustar root root from .base import Immutable, Executable, \
ColumnCollection, ColumnSet, Generative
from .elements import ClauseElement, TextClause, ClauseList, \
Grouping, UnaryExpression, BindParameter
from .annotation import Annotated
from .visitors import Visitable
from .. import util
def subquery(alias, *args, **kwargs): ...
def alias(selectable, name=..., flat: bool=...): ...
class Selectable(ClauseElement):
def selectable(self): ...
class HasPrefixes(object):
def prefix_with(self, *expr, **kw): ...
class HasSuffixes(object):
def suffix_with(self, *expr, **kw): ...
class FromClause(Selectable):
def count(self, functions, whereclause=None, **params): ...
def select(self, whereclause=None, **params): ...
def join(self, right, onclause=None, isouter: bool=False): ...
def outerjoin(self, right, onclause=None): ...
def alias(self, name=None, flat: bool=False): ...
def is_derived_from(self, fromclause): ...
def _is_lexical_equivalent(self, other): ...
def replace_selectable(self, sqlutil, old, alias): ...
def correspond_on_equivalents(self, column, equivalents): ...
def corresponding_column(self, column, require_embedded: bool=False): ...
@property
def description(self): ...
def _reset_exported(self): ...
@property
def columns(self): ...
@property
def primary_key(self): ...
@property
def foreign_keys(self): ...
def _init_collections(self): ...
@property
def _cols_populated(self): ...
def _populate_column_collection(self): ...
def _refresh_for_new_column(self, column): ...
class Join(FromClause): ...
class Alias(FromClause): ...
class CTE(Generative, HasSuffixes, Alias): ...
class FromGrouping(FromClause): ...
class TableClause(Immutable, FromClause):
def __init__(self, name, *columns): ...
def _export_columns(self): ...
@util.memoized_property
def description(self): ...
def append_column(self, c): ...
def get_children(self, **kwargs): ...
def count(self, whereclause=None, **params): ...
def insert(self, values=None, inline=False, **kwargs): ...
def update(self, whereclause=None, values=None, inline=False, **kwargs): ...
def delete(self, whereclause=None, **kwargs): ...
@property
def _from_objects(self): ...
class ForUpdateArg(ClauseElement): ...
class SelectBase(Executable, FromClause): ...
class GenerativeSelect(SelectBase): ...
class CompoundSelect(GenerativeSelect): ...
class Select(HasPrefixes, HasSuffixes, GenerativeSelect): ...
class ScalarSelect(Generative, Grouping): ...
class Exists(UnaryExpression): ...
class TextAsFrom(SelectBase): ...
class AnnotatedFromClause(Annotated): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/base.pyi 0000644 0000000 0000000 00000002351 13044257024 022137 0 ustar root root from typing import Any, Iterable
from .visitors import ClauseVisitor
from .. import util
class Immutable(object):
def unique_params(self, *optionaldict, **kwargs): ...
def params(self, *optionaldict, **kwargs): ...
def _clone(self) -> Immutable: ...
class DialectKWArgs(object):
def argument_for(cls, dialect_name, argument_name, default): ...
def kwargs(self): ...
def dialect_options(self): ...
class Generative(object): ...
class Executable(Generative):
def execution_options(self, **kw): ...
def execute(self, *multiparams, **params): ...
def scalar(self, *multiparams, **params): ...
@property
def bind(self): ...
class SchemaEventTarget(object): ...
class SchemaVisitor(ClauseVisitor): ...
class ColumnCollection(util.OrderedProperties):
def replace(self, column): ...
def add(self, column): ...
def clear(self): ...
def remove(self, column): ...
def update(self, iter: Iterable[Any]): ...
def extend(self, iter: Iterable[Any]): ...
def contains_column(self, col): ...
def as_immutable(self): ...
class ImmutableColumnCollection(util.ImmutableProperties, ColumnCollection): ...
class ColumnSet(util.ordered_column_set): ...
def _bind_or_error(schemaitem, msg): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/ddl.pyi 0000644 0000000 0000000 00000001712 13044257024 021770 0 ustar root root from .elements import ClauseElement
from .base import Executable, SchemaVisitor
class _DDLCompiles(ClauseElement): ...
class DDLElement(Executable, _DDLCompiles): ...
class DDL(DDLElement): ...
class _CreateDropBase(DDLElement): ...
class CreateSchema(_CreateDropBase): ...
class DropSchema(_CreateDropBase): ...
class CreateTable(_CreateDropBase): ...
class _DropView(_CreateDropBase): ...
class CreateColumn(_DDLCompiles): ...
class DropTable(_CreateDropBase): ...
class CreateSequence(_CreateDropBase): ...
class DropSequence(_CreateDropBase): ...
class CreateIndex(_CreateDropBase): ...
class DropIndex(_CreateDropBase): ...
class AddConstraint(_CreateDropBase): ...
class DropConstraint(_CreateDropBase): ...
class DDLBase(SchemaVisitor): ...
class SchemaGenerator(DDLBase): ...
class SchemaDropper(DDLBase): ...
def sort_tables(tables, skip_fn=..., extra_dependencies=...): ...
def sort_tables_and_constraints(tables, filter_fn=..., extra_dependencies=...): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/operators.pyi 0000644 0000000 0000000 00000005674 13044257024 023256 0 ustar root root from typing import Any, AnyStr, Callable
class Operators(object):
def op(self, opstring: AnyStr, precedence: int, is_comparison: bool): ...
def operate(self, op: Callable[[Any], Any], *other, **kwargs): ...
def reverse_operator(self, op: Callable[[Any], Any], *other, **kwargs): ...
def __and__(self, other): ...
def __or__(self, other): ...
def __invert__(self): ...
class ColumnOperators(Operators):
def concat(self, other): ...
def like(self, other, escape=None): ...
def ilike(self, other, escape=None): ...
def notlike(self, other, escape=None): ...
def notilike(self, other, escape=None): ...
def in_(self, other): ...
def notin_(self, other): ...
def is_(self, other): ...
def startswith(self, other, **kwargs): ...
def endswith(self, other, **kwargs): ...
def contains(self, other, **kwargs): ...
def match(self, other, **kwargs): ...
def desc(self): ...
def asc(self): ...
def nullsfirst(self): ...
def nullslast(self): ...
def collate(self, collation): ...
def between(self, cleft, cright, symmetric: bool = ...): ...
def distinct(self): ...
def __lt__(self, other): ...
def __le__(self, other): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def __gt__(self, other): ...
def __ge__(self, other): ...
def __neg__(self, other): ...
def __getitem__(self, index): ...
def __lshift__(self, other): ...
def __rshift__(self, other): ...
def __radd__(self, other): ...
def __rsub__(self, other): ...
def __rmul__(self, other): ...
def __rdiv__(self, other): ...
def __rmod__(self, other): ...
def __add__(self, other): ...
def __sub__(self, other): ...
def __mul__(self, other): ...
def __div__(self, other): ...
def __mod__(self, other): ...
def __truediv__(self, other): ...
def __rtruediv__(self, other): ...
def from_(): ...
def as_(): ...
def exists(): ...
def istrue(a): ...
def isfalse(a): ...
def is_(a, b): ...
def isnot(a, b): ...
def collate(a, b): ...
def op(a, opstring, b): ...
def like_op(a, b, escape=None): ...
def notlike_op(a, b, escape=None): ...
def ilike_op(a, b, escape=None): ...
def notilike_op(a, b, escape=None): ...
def between_op(a, b, symmetric: bool): ...
def notbetween_(a, b, symmetric: bool): ...
def in_op(a, b): ...
def notin_op(a, b): ...
def distinct_op(a): ...
def startswith_op(a, b, escape=None): ...
def notstartswith_op(a, b, escape=None): ...
def endswith_op(a, b, escape=None): ...
def notendswith_op(a, b, escape=None): ...
def contains_op(a, b, escape=None): ...
def notcontains_op(a, b, escape=None): ...
def match_op(a, b, **kw): ...
def notmatch_op(a, b, **kw): ...
def comma_op(a, b): ...
def concat_op(a, b): ...
def desc_op(a): ...
def asc_op(a): ...
def nullsfirst_op(a): ...
def nullslast_op(a): ...
def is_comparison(op): ...
def is_commutative(op): ...
def is_ordering_modified(op): ...
def is_precedent(operator, against): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/sql/dml.pyi 0000644 0000000 0000000 00000001145 13044257024 022001 0 ustar root root from typing import AnyStr
from .base import Executable, DialectKWArgs
from .elements import ClauseElement
from .selectable import HasPrefixes
class UpdateBase(DialectKWArgs, HasPrefixes, Executable, ClauseElement):
def params(self, *arg, **kw): ...
@property
def bind(self): ...
def returning(self, *cols): ...
def with_hint(self, text, selectable=..., dialect_name: AnyStr=...): ...
class ValuesBase(UpdateBase):
def values(self, *args, **kwargs): ...
def return_defaults(self, *cols): ...
class Insert(ValuesBase): ...
class Update(ValuesBase): ...
class Delete(UpdateBase): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/log.pyi 0000644 0000000 0000000 00000000464 13044257024 021212 0 ustar root root import logging
from typing import Any
rootlogger = ... # type: Any
class Identified(object):
def _should_log_debug(self) -> bool: ...
def _should_log_info(self) -> bool: ...
class InstanceLogger(object): ...
def instance_logger(instance, echoflag) -> None: ...
class echo_property(object): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/pool.pyi 0000644 0000000 0000000 00000006677 13044257024 021416 0 ustar root root # Stubs for sqlalchemy.pool (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import log
from . import util
threading = util.threading
memoized_property = util.memoized_property
chop_traceback = util.chop_traceback
proxies = ... # type: Any
def manage(module, **params): ...
def clear_managers(): ...
reset_rollback = ... # type: Any
reset_commit = ... # type: Any
reset_none = ... # type: Any
class _ConnDialect:
def do_rollback(self, dbapi_connection): ...
def do_commit(self, dbapi_connection): ...
def do_close(self, dbapi_connection): ...
class Pool(log.Identified):
logging_name = ... # type: Any
echo = ... # type: Any
def __init__(self, creator, recycle=..., echo=..., use_threadlocal=..., logging_name=..., reset_on_return=..., listeners=..., events=..., _dispatch=..., _dialect=...) -> None: ...
def add_listener(self, listener): ...
def unique_connection(self): ...
def recreate(self): ...
def dispose(self): ...
def connect(self): ...
def status(self): ...
_threadconns = ... # type: Any
_creator = ... # type: Any
_recycle = ... # type: Any
_invalidate_time = ... # type: Any
dispatch = ... # type: Any
_dialect = ... # type: Any
_orig_logging_name = ... # type: Any
_reset_on_return = ... # type: Any
_use_threadlocal = ... # type: Any
class _ConnectionRecord:
connection = ... # type: Any
finalize_callback = ... # type: Any
def __init__(self, pool) -> None: ...
def info(self): ...
@classmethod
def checkout(cls, pool): ...
fairy_ref = ... # type: Any
def checkin(self): ...
def close(self): ...
def invalidate(self, e=..., soft=...): ...
def get_connection(self): ...
class _ConnectionFairy:
connection = ... # type: Any
def __init__(self, dbapi_connection, connection_record, echo) -> None: ...
@property
def is_valid(self): ...
def info(self): ...
def invalidate(self, e=..., soft=...): ...
def cursor(self, *args, **kwargs): ...
def __getattr__(self, key): ...
def detach(self): ...
def close(self): ...
class SingletonThreadPool(Pool):
size = ... # type: Any
def __init__(self, creator, pool_size=..., **kw) -> None: ...
def recreate(self): ...
def dispose(self): ...
def status(self): ...
class QueuePool(Pool):
def __init__(self, creator, pool_size=..., max_overflow=..., timeout=..., **kw) -> None: ...
def recreate(self): ...
def dispose(self): ...
def status(self): ...
def size(self): ...
def checkedin(self): ...
def overflow(self): ...
def checkedout(self): ...
class NullPool(Pool):
def status(self): ...
def recreate(self): ...
def dispose(self): ...
class StaticPool(Pool):
def connection(self): ...
def status(self): ...
def dispose(self): ...
def recreate(self): ...
class AssertionPool(Pool):
def __init__(self, *args, **kw) -> None: ...
def status(self): ...
def dispose(self): ...
def recreate(self): ...
class _DBProxy:
module = ... # type: Any
kw = ... # type: Any
poolclass = ... # type: Any
pools = ... # type: Any
def __init__(self, module, poolclass=..., **kw) -> None: ...
def close(self): ...
def __del__(self): ...
def __getattr__(self, key): ...
def get_pool(self, *args, **kw): ...
def connect(self, *args, **kw): ...
def dispose(self, *args, **kw): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/dialects/ 0000755 0000000 0000000 00000000000 13044320557 021474 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/dialects/__init__.pyi 0000644 0000000 0000000 00000000362 13044257024 023755 0 ustar root root # Stubs for sqlalchemy.dialects (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# firebird
# mssql
# mysql
# oracle
# postgresql
# sqlite
# sybase
mypy-0.470/typeshed/third_party/2/sqlalchemy/dialects/mysql/ 0000755 0000000 0000000 00000000000 13044320557 022641 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/dialects/mysql/__init__.pyi 0000644 0000000 0000000 00000001574 13044257024 025130 0 ustar root root # Stubs for sqlalchemy.dialects.mysql (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import base
BIGINT = base.BIGINT
BINARY = base.BINARY
BIT = base.BIT
BLOB = base.BLOB
BOOLEAN = base.BOOLEAN
CHAR = base.CHAR
DATE = base.DATE
DATETIME = base.DATETIME
DECIMAL = base.DECIMAL
DOUBLE = base.DOUBLE
ENUM = base.ENUM
FLOAT = base.FLOAT
INTEGER = base.INTEGER
LONGBLOB = base.LONGBLOB
LONGTEXT = base.LONGTEXT
MEDIUMBLOB = base.MEDIUMBLOB
MEDIUMINT = base.MEDIUMINT
MEDIUMTEXT = base.MEDIUMTEXT
NCHAR = base.NCHAR
NVARCHAR = base.NVARCHAR
NUMERIC = base.NUMERIC
SET = base.SET
SMALLINT = base.SMALLINT
REAL = base.REAL
TEXT = base.TEXT
TIME = base.TIME
TIMESTAMP = base.TIMESTAMP
TINYBLOB = base.TINYBLOB
TINYINT = base.TINYINT
TINYTEXT = base.TINYTEXT
VARBINARY = base.VARBINARY
VARCHAR = base.VARCHAR
YEAR = base.YEAR
# dialect = base.dialect
mypy-0.470/typeshed/third_party/2/sqlalchemy/dialects/mysql/base.pyi 0000644 0000000 0000000 00000034220 13044257024 024275 0 ustar root root # Stubs for sqlalchemy.dialects.mysql.base (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from ... import sql
from ... import engine
from ... import util
from ... import types
sqltypes = sql.sqltypes
# compiler = sql.compiler
# reflection = engine.reflection
# default = engine.default
# topological = util.topological
DATE = types.DATE
BOOLEAN = types.BOOLEAN
BLOB = types.BLOB
BINARY = types.BINARY
VARBINARY = types.VARBINARY
RESERVED_WORDS = ... # type: Any
AUTOCOMMIT_RE = ... # type: Any
SET_RE = ... # type: Any
class _NumericType:
unsigned = ... # type: Any
zerofill = ... # type: Any
def __init__(self, unsigned=..., zerofill=..., **kw) -> None: ...
class _FloatType(_NumericType,
# sqltypes.Float
):
scale = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
class _IntegerType(_NumericType,
# sqltypes.Integer
):
display_width = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class _StringType(object,
# sqltypes.String
):
charset = ... # type: Any
ascii = ... # type: Any
unicode = ... # type: Any
binary = ... # type: Any
national = ... # type: Any
def __init__(self, charset=..., collation=..., ascii=..., binary=..., unicode=..., national=..., **kw) -> None: ...
class _MatchType(object,
# sqltypes.Float,
# sqltypes.MatchType
):
def __init__(self, **kw) -> None: ...
class NUMERIC(_NumericType,
# sqltypes.NUMERIC
):
__visit_name__ = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
class DECIMAL(_NumericType,
# sqltypes.DECIMAL
):
__visit_name__ = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
class DOUBLE(_FloatType):
__visit_name__ = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
class REAL(_FloatType,
# sqltypes.REAL
):
__visit_name__ = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
class FLOAT(_FloatType,
# sqltypes.FLOAT
):
__visit_name__ = ... # type: Any
def __init__(self, precision=..., scale=..., asdecimal=..., **kw) -> None: ...
def bind_processor(self, dialect): ...
class INTEGER(_IntegerType,
# sqltypes.INTEGER
):
__visit_name__ = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class BIGINT(_IntegerType,
# sqltypes.BIGINT
):
__visit_name__ = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class MEDIUMINT(_IntegerType):
__visit_name__ = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class TINYINT(_IntegerType):
__visit_name__ = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class SMALLINT(_IntegerType,
# sqltypes.SMALLINT
):
__visit_name__ = ... # type: Any
def __init__(self, display_width=..., **kw) -> None: ...
class BIT(object,
# sqltypes.TypeEngine
):
__visit_name__ = ... # type: Any
length = ... # type: Any
def __init__(self, length=...) -> None: ...
def result_processor(self, dialect, coltype): ...
class TIME(object,
# sqltypes.TIME
):
__visit_name__ = ... # type: Any
fsp = ... # type: Any
def __init__(self, timezone=..., fsp=...) -> None: ...
def result_processor(self, dialect, coltype): ...
class TIMESTAMP(object,
# sqltypes.TIMESTAMP
):
__visit_name__ = ... # type: Any
fsp = ... # type: Any
def __init__(self, timezone=..., fsp=...) -> None: ...
class DATETIME(object,
# sqltypes.DATETIME
):
__visit_name__ = ... # type: Any
fsp = ... # type: Any
def __init__(self, timezone=..., fsp=...) -> None: ...
class YEAR(object,
# sqltypes.TypeEngine
):
__visit_name__ = ... # type: Any
display_width = ... # type: Any
def __init__(self, display_width=...) -> None: ...
class TEXT(_StringType,
# sqltypes.TEXT
):
__visit_name__ = ... # type: Any
def __init__(self, length=..., **kw) -> None: ...
class TINYTEXT(_StringType):
__visit_name__ = ... # type: Any
def __init__(self, **kwargs) -> None: ...
class MEDIUMTEXT(_StringType):
__visit_name__ = ... # type: Any
def __init__(self, **kwargs) -> None: ...
class LONGTEXT(_StringType):
__visit_name__ = ... # type: Any
def __init__(self, **kwargs) -> None: ...
class VARCHAR(_StringType,
# sqltypes.VARCHAR
):
__visit_name__ = ... # type: Any
def __init__(self, length=..., **kwargs) -> None: ...
class CHAR(_StringType,
# sqltypes.CHAR
):
__visit_name__ = ... # type: Any
def __init__(self, length=..., **kwargs) -> None: ...
class NVARCHAR(_StringType,
# sqltypes.NVARCHAR
):
__visit_name__ = ... # type: Any
def __init__(self, length=..., **kwargs) -> None: ...
class NCHAR(_StringType,
# sqltypes.NCHAR
):
__visit_name__ = ... # type: Any
def __init__(self, length=..., **kwargs) -> None: ...
class TINYBLOB(object,
# sqltypes._Binary
):
__visit_name__ = ... # type: Any
class MEDIUMBLOB(object,
# sqltypes._Binary
):
__visit_name__ = ... # type: Any
class LONGBLOB(object,
# sqltypes._Binary
):
__visit_name__ = ... # type: Any
class _EnumeratedValues(_StringType): ...
class ENUM( # sqltypes.Enum,
_EnumeratedValues
):
__visit_name__ = ... # type: Any
strict = ... # type: Any
def __init__(self, *enums, **kw) -> None: ...
def bind_processor(self, dialect): ...
def adapt(self, cls, **kw): ...
class SET(_EnumeratedValues):
__visit_name__ = ... # type: Any
retrieve_as_bitwise = ... # type: Any
values = ... # type: Any
def __init__(self, *values, **kw) -> None: ...
def column_expression(self, colexpr): ...
def result_processor(self, dialect, coltype): ...
def bind_processor(self, dialect): ...
def adapt(self, impltype, **kw): ...
MSTime = ... # type: Any
MSSet = ... # type: Any
MSEnum = ... # type: Any
MSLongBlob = ... # type: Any
MSMediumBlob = ... # type: Any
MSTinyBlob = ... # type: Any
MSBlob = ... # type: Any
MSBinary = ... # type: Any
MSVarBinary = ... # type: Any
MSNChar = ... # type: Any
MSNVarChar = ... # type: Any
MSChar = ... # type: Any
MSString = ... # type: Any
MSLongText = ... # type: Any
MSMediumText = ... # type: Any
MSTinyText = ... # type: Any
MSText = ... # type: Any
MSYear = ... # type: Any
MSTimeStamp = ... # type: Any
MSBit = ... # type: Any
MSSmallInteger = ... # type: Any
MSTinyInteger = ... # type: Any
MSMediumInteger = ... # type: Any
MSBigInteger = ... # type: Any
MSNumeric = ... # type: Any
MSDecimal = ... # type: Any
MSDouble = ... # type: Any
MSReal = ... # type: Any
MSFloat = ... # type: Any
MSInteger = ... # type: Any
colspecs = ... # type: Any
ischema_names = ... # type: Any
class MySQLExecutionContext(object,
# default.DefaultExecutionContext
):
def should_autocommit_text(self, statement): ...
class MySQLCompiler(object,
# compiler.SQLCompiler
):
render_table_with_column_in_update_from = ... # type: Any
extract_map = ... # type: Any
def visit_random_func(self, fn, **kw): ...
def visit_utc_timestamp_func(self, fn, **kw): ...
def visit_sysdate_func(self, fn, **kw): ...
def visit_concat_op_binary(self, binary, operator, **kw): ...
def visit_match_op_binary(self, binary, operator, **kw): ...
def get_from_hint_text(self, table, text): ...
def visit_typeclause(self, typeclause, type_=...): ...
def visit_cast(self, cast, **kwargs): ...
def render_literal_value(self, value, type_): ...
def visit_true(self, element, **kw): ...
def visit_false(self, element, **kw): ...
def get_select_precolumns(self, select, **kw): ...
def visit_join(self, join, asfrom=..., **kwargs): ...
def for_update_clause(self, select, **kw): ...
def limit_clause(self, select, **kw): ...
def update_limit_clause(self, update_stmt): ...
def update_tables_clause(self, update_stmt, from_table, extra_froms, **kw): ...
def update_from_clause(self, update_stmt, from_table, extra_froms, from_hints, **kw): ...
class MySQLDDLCompiler(object,
# compiler.DDLCompiler
):
def create_table_constraints(self, table, **kw): ...
def get_column_specification(self, column, **kw): ...
def post_create_table(self, table): ...
def visit_create_index(self, create): ...
def visit_primary_key_constraint(self, constraint): ...
def visit_drop_index(self, drop): ...
def visit_drop_constraint(self, drop): ...
def define_constraint_match(self, constraint): ...
class MySQLTypeCompiler(object,
# compiler.GenericTypeCompiler
):
def visit_NUMERIC(self, type_, **kw): ...
def visit_DECIMAL(self, type_, **kw): ...
def visit_DOUBLE(self, type_, **kw): ...
def visit_REAL(self, type_, **kw): ...
def visit_FLOAT(self, type_, **kw): ...
def visit_INTEGER(self, type_, **kw): ...
def visit_BIGINT(self, type_, **kw): ...
def visit_MEDIUMINT(self, type_, **kw): ...
def visit_TINYINT(self, type_, **kw): ...
def visit_SMALLINT(self, type_, **kw): ...
def visit_BIT(self, type_, **kw): ...
def visit_DATETIME(self, type_, **kw): ...
def visit_DATE(self, type_, **kw): ...
def visit_TIME(self, type_, **kw): ...
def visit_TIMESTAMP(self, type_, **kw): ...
def visit_YEAR(self, type_, **kw): ...
def visit_TEXT(self, type_, **kw): ...
def visit_TINYTEXT(self, type_, **kw): ...
def visit_MEDIUMTEXT(self, type_, **kw): ...
def visit_LONGTEXT(self, type_, **kw): ...
def visit_VARCHAR(self, type_, **kw): ...
def visit_CHAR(self, type_, **kw): ...
def visit_NVARCHAR(self, type_, **kw): ...
def visit_NCHAR(self, type_, **kw): ...
def visit_VARBINARY(self, type_, **kw): ...
def visit_large_binary(self, type_, **kw): ...
def visit_enum(self, type_, **kw): ...
def visit_BLOB(self, type_, **kw): ...
def visit_TINYBLOB(self, type_, **kw): ...
def visit_MEDIUMBLOB(self, type_, **kw): ...
def visit_LONGBLOB(self, type_, **kw): ...
def visit_ENUM(self, type_, **kw): ...
def visit_SET(self, type_, **kw): ...
def visit_BOOLEAN(self, type, **kw): ...
class MySQLIdentifierPreparer(object,
# compiler.IdentifierPreparer
):
reserved_words = ... # type: Any
def __init__(self, dialect, server_ansiquotes=..., **kw) -> None: ...
class MySQLDialect(object,
# default.DefaultDialect
):
name = ... # type: Any
supports_alter = ... # type: Any
supports_native_boolean = ... # type: Any
max_identifier_length = ... # type: Any
max_index_name_length = ... # type: Any
supports_native_enum = ... # type: Any
supports_sane_rowcount = ... # type: Any
supports_sane_multi_rowcount = ... # type: Any
supports_multivalues_insert = ... # type: Any
default_paramstyle = ... # type: Any
colspecs = ... # type: Any
statement_compiler = ... # type: Any
ddl_compiler = ... # type: Any
type_compiler = ... # type: Any
ischema_names = ... # type: Any
preparer = ... # type: Any
construct_arguments = ... # type: Any
isolation_level = ... # type: Any
def __init__(self, isolation_level=..., **kwargs) -> None: ...
def on_connect(self): ...
def set_isolation_level(self, connection, level): ...
def get_isolation_level(self, connection): ...
def do_commit(self, dbapi_connection): ...
def do_rollback(self, dbapi_connection): ...
def do_begin_twophase(self, connection, xid): ...
def do_prepare_twophase(self, connection, xid): ...
def do_rollback_twophase(self, connection, xid, is_prepared=..., recover=...): ...
def do_commit_twophase(self, connection, xid, is_prepared=..., recover=...): ...
def do_recover_twophase(self, connection): ...
def is_disconnect(self, e, connection, cursor): ...
def has_table(self, connection, table_name, schema=...): ...
identifier_preparer = ... # type: Any
def initialize(self, connection): ...
def get_schema_names(self, connection, **kw): ...
def get_table_names(self, connection, schema=..., **kw): ...
def get_view_names(self, connection, schema=..., **kw): ...
def get_table_options(self, connection, table_name, schema=..., **kw): ...
def get_columns(self, connection, table_name, schema=..., **kw): ...
def get_pk_constraint(self, connection, table_name, schema=..., **kw): ...
def get_foreign_keys(self, connection, table_name, schema=..., **kw): ...
def get_indexes(self, connection, table_name, schema=..., **kw): ...
def get_unique_constraints(self, connection, table_name, schema=..., **kw): ...
def get_view_definition(self, connection, view_name, schema=..., **kw): ...
class ReflectedState:
columns = ... # type: Any
table_options = ... # type: Any
table_name = ... # type: Any
keys = ... # type: Any
constraints = ... # type: Any
def __init__(self) -> None: ...
class MySQLTableDefinitionParser:
dialect = ... # type: Any
preparer = ... # type: Any
def __init__(self, dialect, preparer) -> None: ...
def parse(self, show_create, charset): ...
class _DecodingRowProxy:
rowproxy = ... # type: Any
charset = ... # type: Any
def __init__(self, rowproxy, charset) -> None: ...
def __getitem__(self, index): ...
def __getattr__(self, attr): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/orm/ 0000755 0000000 0000000 00000000000 13044320557 020501 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/orm/__init__.pyi 0000644 0000000 0000000 00000005535 13044257024 022771 0 ustar root root # Stubs for sqlalchemy.orm (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
# from . import mapper
# from . import interfaces
# from . import deprecated_interfaces
# from . import util
# from . import properties
# from . import relationships
# from . import descriptor_props
from . import session
# from . import scoping
# from . import query
from ..util import langhelpers
# from . import strategy_options
# Mapper = mapper.Mapper
# class_mapper = mapper.class_mapper
# configure_mappers = mapper.configure_mappers
# reconstructor = mapper.reconstructor
# validates = mapper.validates
# EXT_CONTINUE = interfaces.EXT_CONTINUE
# EXT_STOP = interfaces.EXT_STOP
# PropComparator = interfaces.PropComparator
# MapperExtension = deprecated_interfaces.MapperExtension
# SessionExtension = deprecated_interfaces.SessionExtension
# AttributeExtension = deprecated_interfaces.AttributeExtension
# aliased = util.aliased
# join = util.join
# object_mapper = util.object_mapper
# outerjoin = util.outerjoin
# polymorphic_union = util.polymorphic_union
# was_deleted = util.was_deleted
# with_parent = util.with_parent
# with_polymorphic = util.with_polymorphic
# ColumnProperty = properties.ColumnProperty
# RelationshipProperty = relationships.RelationshipProperty
# ComparableProperty = descriptor_props.ComparableProperty
# CompositeProperty = descriptor_props.CompositeProperty
# SynonymProperty = descriptor_props.SynonymProperty
# foreign = relationships.foreign
# remote = relationships.remote
Session = session.Session
object_session = Session.object_session
sessionmaker = session.sessionmaker
# make_transient = session.make_transient
# make_transient_to_detached = session.make_transient_to_detached
# scoped_session = scoping.scoped_session
# AliasOption = query.AliasOption
# Query = query.Query
# Bundle = query.Bundle
public_factory = langhelpers.public_factory
def create_session(bind=..., **kwargs): ...
relationship = ... # type: Any
def relation(*arg, **kw): ...
def dynamic_loader(argument, **kw): ...
column_property = ... # type: Any
composite = ... # type: Any
def backref(name, **kwargs): ...
def deferred(*columns, **kw): ...
synonym = ... # type: Any
comparable_property = ... # type: Any
def compile_mappers(): ...
def clear_mappers(): ...
joinedload = ... # type: Any
joinedload_all = ... # type: Any
contains_eager = ... # type: Any
defer = ... # type: Any
undefer = ... # type: Any
undefer_group = ... # type: Any
load_only = ... # type: Any
lazyload = ... # type: Any
lazyload_all = ... # type: Any
subqueryload = ... # type: Any
subqueryload_all = ... # type: Any
immediateload = ... # type: Any
noload = ... # type: Any
defaultload = ... # type: Any
# Load = strategy_options.Load
def eagerload(*args, **kwargs): ...
def eagerload_all(*args, **kwargs): ...
contains_alias = ... # type: Any
mypy-0.470/typeshed/third_party/2/sqlalchemy/orm/session.pyi 0000644 0000000 0000000 00000007050 13044257024 022707 0 ustar root root # Stubs for sqlalchemy.orm.session (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _SessionClassMethods:
@classmethod
def close_all(cls): ...
@classmethod
def identity_key(cls, orm_util, *args, **kwargs): ...
@classmethod
def object_session(cls, instance): ...
class SessionTransaction:
session = ... # type: Any
nested = ... # type: Any
def __init__(self, session, parent=..., nested=...) -> None: ...
@property
def is_active(self): ...
def connection(self, bindkey, execution_options=..., **kwargs): ...
def prepare(self): ...
def commit(self): ...
def rollback(self, _capture_exception=...): ...
def close(self, invalidate=...): ...
def __enter__(self): ...
def __exit__(self, type, value, traceback): ...
class Session(_SessionClassMethods):
public_methods = ... # type: Any
identity_map = ... # type: Any
bind = ... # type: Any
transaction = ... # type: Any
hash_key = ... # type: Any
autoflush = ... # type: Any
autocommit = ... # type: Any
expire_on_commit = ... # type: Any
twophase = ... # type: Any
def __init__(self, bind=..., autoflush=..., expire_on_commit=..., _enable_transaction_accounting=..., autocommit=..., twophase=..., weak_identity_map=..., binds=..., extension=..., info=..., query_cls=...) -> None: ...
connection_callable = ... # type: Any
def info(self): ...
def begin(self, subtransactions=..., nested=...): ...
def begin_nested(self): ...
def rollback(self): ...
def commit(self): ...
def prepare(self): ...
def connection(self, mapper=..., clause=..., bind=..., close_with_result=..., execution_options=..., **kw): ...
def execute(self, clause, params=..., mapper=..., bind=..., **kw): ...
def scalar(self, clause, params=..., mapper=..., bind=..., **kw): ...
def close(self): ...
def invalidate(self): ...
def expunge_all(self): ...
def bind_mapper(self, mapper, bind): ...
def bind_table(self, table, bind): ...
def get_bind(self, mapper=..., clause=...): ...
def query(self, *entities, **kwargs): ...
@property
def no_autoflush(self): ...
def refresh(self, instance, attribute_names=..., lockmode=...): ...
def expire_all(self): ...
def expire(self, instance, attribute_names=...): ...
def prune(self): ...
def expunge(self, instance): ...
def add(self, instance, _warn=...): ...
def add_all(self, instances): ...
def delete(self, instance): ...
def merge(self, instance, load=...): ...
def enable_relationship_loading(self, obj): ...
def __contains__(self, instance): ...
def __iter__(self): ...
def flush(self, objects=...): ...
def bulk_save_objects(self, objects, return_defaults=..., update_changed_only=...): ...
def bulk_insert_mappings(self, mapper, mappings, return_defaults=...): ...
def bulk_update_mappings(self, mapper, mappings): ...
def is_modified(self, instance, include_collections=..., passive=...): ...
@property
def is_active(self): ...
@property
def dirty(self): ...
@property
def deleted(self): ...
@property
def new(self): ...
class sessionmaker(_SessionClassMethods):
kw = ... # type: Any
class_ = ... # type: Any
def __init__(self, bind=..., class_=..., autoflush=..., autocommit=..., expire_on_commit=..., info=..., **kw) -> None: ...
def __call__(self, **local_kw): ...
def configure(self, **new_kw): ...
# Names in __all__ with no definition:
# SessionExtension
mypy-0.470/typeshed/third_party/2/sqlalchemy/engine/ 0000755 0000000 0000000 00000000000 13044320557 021151 5 ustar root root mypy-0.470/typeshed/third_party/2/sqlalchemy/engine/strategies.pyi 0000644 0000000 0000000 00000002410 13044257024 024041 0 ustar root root # Stubs for sqlalchemy.engine.strategies (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import base
strategies = ... # type: Any
class EngineStrategy:
def __init__(self) -> None: ...
def create(self, *args, **kwargs): ...
class DefaultEngineStrategy(EngineStrategy):
def create(self, name_or_url, **kwargs): ...
class PlainEngineStrategy(DefaultEngineStrategy):
name = ... # type: Any
engine_cls = ... # type: Any
class ThreadLocalEngineStrategy(DefaultEngineStrategy):
name = ... # type: Any
engine_cls = ... # type: Any
class MockEngineStrategy(EngineStrategy):
name = ... # type: Any
def create(self, name_or_url, executor, **kwargs): ...
class MockConnection(base.Connectable):
def __init__(self, dialect, execute) -> None: ...
engine = ... # type: Any
dialect = ... # type: Any
name = ... # type: Any
def contextual_connect(self, **kwargs): ...
def execution_options(self, **kw): ...
def compiler(self, statement, parameters, **kwargs): ...
def create(self, entity, **kwargs): ...
def drop(self, entity, **kwargs): ...
def execute(self, object, *multiparams, **params): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/engine/__init__.pyi 0000644 0000000 0000000 00000000604 13044257024 023431 0 ustar root root # Stubs for sqlalchemy.engine (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .base import Connection as Connection
from .base import Engine as Engine
from .base import RowProxy as RowProxy
from .base import Transaction as Transaction
def create_engine(*args, **kwargs): ...
def engine_from_config(configuration, prefix=..., **kwargs): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/engine/url.pyi 0000644 0000000 0000000 00000001531 13044257024 022474 0 ustar root root # Stubs for sqlalchemy.engine.url (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import dialects
# registry = dialects.registry
class URL:
drivername = ... # type: Any
username = ... # type: Any
password = ... # type: Any
host = ... # type: Any
port = ... # type: Any
database = ... # type: Any
query = ... # type: Any
def __init__(self, drivername, username=..., password=..., host=..., port=..., database=..., query=...) -> None: ...
def __to_string__(self, hide_password=...): ...
def __hash__(self): ...
def __eq__(self, other): ...
def get_backend_name(self): ...
def get_driver_name(self): ...
def get_dialect(self): ...
def translate_connect_args(self, names=..., **kw): ...
def make_url(name_or_url): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/engine/base.pyi 0000644 0000000 0000000 00000000762 13044257024 022611 0 ustar root root from typing import Any, List, Tuple
# Dummy until I figure out something better.
class Connectable:
pass
class Connection:
def begin(self): ...
def execute(self, object, *multiparams, **params): ...
class Engine(object): ...
class RowProxy:
def items(self) -> List[Tuple[Any, Any]]: ...
def keys(self) -> List[Any]: ...
def values(self) -> List[Any]: ...
def __getitem__(self, key: str): ...
class Transaction:
def commit(self): ...
def rollback(self): ...
mypy-0.470/typeshed/third_party/2/sqlalchemy/inspection.pyi 0000644 0000000 0000000 00000000244 13044257024 022600 0 ustar root root # Stubs for sqlalchemy.inspection (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def inspect(subject, raiseerr=...): ...
mypy-0.470/typeshed/third_party/2/thrift/ 0000755 0000000 0000000 00000000000 13044320557 017042 5 ustar root root mypy-0.470/typeshed/third_party/2/thrift/transport/ 0000755 0000000 0000000 00000000000 13044320557 021076 5 ustar root root mypy-0.470/typeshed/third_party/2/thrift/transport/TSocket.pyi 0000644 0000000 0000000 00000002015 13035744274 023201 0 ustar root root # Stubs for thrift.transport.TSocket (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .TTransport import TTransportBase, TServerTransportBase
from .TTransport import * # noqa: F403
class TSocketBase(TTransportBase):
handle = ... # type: Any
def close(self): ...
class TSocket(TSocketBase):
host = ... # type: Any
port = ... # type: Any
handle = ... # type: Any
def __init__(self, host=..., port=..., unix_socket=..., socket_family=...) -> None: ...
def setHandle(self, h): ...
def isOpen(self): ...
def setTimeout(self, ms): ...
def open(self): ...
def read(self, sz): ...
def write(self, buff): ...
def flush(self): ...
class TServerSocket(TSocketBase, TServerTransportBase):
host = ... # type: Any
port = ... # type: Any
handle = ... # type: Any
def __init__(self, host=..., port=..., unix_socket=..., socket_family=...) -> None: ...
def listen(self): ...
def accept(self): ...
mypy-0.470/typeshed/third_party/2/thrift/transport/__init__.pyi 0000644 0000000 0000000 00000000334 13023631176 023357 0 ustar root root # Stubs for thrift.transport (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# THttpClient
# TSocket
# TTransport
# TZlibTransport
mypy-0.470/typeshed/third_party/2/thrift/transport/TTransport.pyi 0000644 0000000 0000000 00000006320 13035744274 023750 0 ustar root root # Stubs for thrift.transport.TTransport (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from thrift.Thrift import TException
class TTransportException(TException):
UNKNOWN = ... # type: Any
NOT_OPEN = ... # type: Any
ALREADY_OPEN = ... # type: Any
TIMED_OUT = ... # type: Any
END_OF_FILE = ... # type: Any
type = ... # type: Any
def __init__(self, type=..., message=...) -> None: ...
class TTransportBase:
def isOpen(self): ...
def open(self): ...
def close(self): ...
def read(self, sz): ...
def readAll(self, sz): ...
def write(self, buf): ...
def flush(self): ...
class CReadableTransport:
@property
def cstringio_buf(self): ...
def cstringio_refill(self, partialread, reqlen): ...
class TServerTransportBase:
def listen(self): ...
def accept(self): ...
def close(self): ...
class TTransportFactoryBase:
def getTransport(self, trans): ...
class TBufferedTransportFactory:
def getTransport(self, trans): ...
class TBufferedTransport(TTransportBase, CReadableTransport):
DEFAULT_BUFFER = ... # type: Any
def __init__(self, trans, rbuf_size=...) -> None: ...
def isOpen(self): ...
def open(self): ...
def close(self): ...
def read(self, sz): ...
def write(self, buf): ...
def flush(self): ...
@property
def cstringio_buf(self): ...
def cstringio_refill(self, partialread, reqlen): ...
class TMemoryBuffer(TTransportBase, CReadableTransport):
def __init__(self, value=...) -> None: ...
def isOpen(self): ...
def open(self): ...
def close(self): ...
def read(self, sz): ...
def write(self, buf): ...
def flush(self): ...
def getvalue(self): ...
@property
def cstringio_buf(self): ...
def cstringio_refill(self, partialread, reqlen): ...
class TFramedTransportFactory:
def getTransport(self, trans): ...
class TFramedTransport(TTransportBase, CReadableTransport):
def __init__(self, trans) -> None: ...
def isOpen(self): ...
def open(self): ...
def close(self): ...
def read(self, sz): ...
def readFrame(self): ...
def write(self, buf): ...
def flush(self): ...
@property
def cstringio_buf(self): ...
def cstringio_refill(self, prefix, reqlen): ...
class TFileObjectTransport(TTransportBase):
fileobj = ... # type: Any
def __init__(self, fileobj) -> None: ...
def isOpen(self): ...
def close(self): ...
def read(self, sz): ...
def write(self, buf): ...
def flush(self): ...
class TSaslClientTransport(TTransportBase, CReadableTransport):
START = ... # type: Any
OK = ... # type: Any
BAD = ... # type: Any
ERROR = ... # type: Any
COMPLETE = ... # type: Any
transport = ... # type: Any
sasl = ... # type: Any
def __init__(self, transport, host, service, mechanism=..., **sasl_kwargs) -> None: ...
def open(self): ...
def send_sasl_msg(self, status, body): ...
def recv_sasl_msg(self): ...
def write(self, data): ...
def flush(self): ...
def read(self, sz): ...
def close(self): ...
@property
def cstringio_buf(self): ...
def cstringio_refill(self, prefix, reqlen): ...
mypy-0.470/typeshed/third_party/2/thrift/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021311 0 ustar root root mypy-0.470/typeshed/third_party/2/thrift/Thrift.pyi 0000644 0000000 0000000 00000003071 13035744274 021034 0 ustar root root # Stubs for thrift.Thrift (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class TType:
STOP = ... # type: Any
VOID = ... # type: Any
BOOL = ... # type: Any
BYTE = ... # type: Any
I08 = ... # type: Any
DOUBLE = ... # type: Any
I16 = ... # type: Any
I32 = ... # type: Any
I64 = ... # type: Any
STRING = ... # type: Any
UTF7 = ... # type: Any
STRUCT = ... # type: Any
MAP = ... # type: Any
SET = ... # type: Any
LIST = ... # type: Any
UTF8 = ... # type: Any
UTF16 = ... # type: Any
class TMessageType:
CALL = ... # type: Any
REPLY = ... # type: Any
EXCEPTION = ... # type: Any
ONEWAY = ... # type: Any
class TProcessor:
def process(iprot, oprot): ...
class TException(Exception):
message = ... # type: Any
def __init__(self, message=...) -> None: ...
class TApplicationException(TException):
UNKNOWN = ... # type: Any
UNKNOWN_METHOD = ... # type: Any
INVALID_MESSAGE_TYPE = ... # type: Any
WRONG_METHOD_NAME = ... # type: Any
BAD_SEQUENCE_ID = ... # type: Any
MISSING_RESULT = ... # type: Any
INTERNAL_ERROR = ... # type: Any
PROTOCOL_ERROR = ... # type: Any
INVALID_TRANSFORM = ... # type: Any
INVALID_PROTOCOL = ... # type: Any
UNSUPPORTED_CLIENT_TYPE = ... # type: Any
type = ... # type: Any
def __init__(self, type=..., message=...) -> None: ...
message = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
mypy-0.470/typeshed/third_party/2/thrift/protocol/ 0000755 0000000 0000000 00000000000 13044320557 020703 5 ustar root root mypy-0.470/typeshed/third_party/2/thrift/protocol/__init__.pyi 0000644 0000000 0000000 00000000377 13023631176 023173 0 ustar root root # Stubs for thrift.protocol (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# TBase
# TBinaryProtocol
# TCompactProtocol
# TJSONProtocol
# TProtocol
# fastbinary
mypy-0.470/typeshed/third_party/2/thrift/protocol/TProtocol.pyi 0000644 0000000 0000000 00000005315 13035744274 023365 0 ustar root root # Stubs for thrift.protocol.TProtocol (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from thrift.Thrift import TException
from thrift.Thrift import * # noqa: F403
class TProtocolException(TException):
UNKNOWN = ... # type: Any
INVALID_DATA = ... # type: Any
NEGATIVE_SIZE = ... # type: Any
SIZE_LIMIT = ... # type: Any
BAD_VERSION = ... # type: Any
NOT_IMPLEMENTED = ... # type: Any
DEPTH_LIMIT = ... # type: Any
type = ... # type: Any
def __init__(self, type=..., message=...) -> None: ...
class TProtocolBase:
trans = ... # type: Any
def __init__(self, trans) -> None: ...
def writeMessageBegin(self, name, ttype, seqid): ...
def writeMessageEnd(self): ...
def writeStructBegin(self, name): ...
def writeStructEnd(self): ...
def writeFieldBegin(self, name, ttype, fid): ...
def writeFieldEnd(self): ...
def writeFieldStop(self): ...
def writeMapBegin(self, ktype, vtype, size): ...
def writeMapEnd(self): ...
def writeListBegin(self, etype, size): ...
def writeListEnd(self): ...
def writeSetBegin(self, etype, size): ...
def writeSetEnd(self): ...
def writeBool(self, bool_val): ...
def writeByte(self, byte): ...
def writeI16(self, i16): ...
def writeI32(self, i32): ...
def writeI64(self, i64): ...
def writeDouble(self, dub): ...
def writeString(self, str_val): ...
def readMessageBegin(self): ...
def readMessageEnd(self): ...
def readStructBegin(self): ...
def readStructEnd(self): ...
def readFieldBegin(self): ...
def readFieldEnd(self): ...
def readMapBegin(self): ...
def readMapEnd(self): ...
def readListBegin(self): ...
def readListEnd(self): ...
def readSetBegin(self): ...
def readSetEnd(self): ...
def readBool(self): ...
def readByte(self): ...
def readI16(self): ...
def readI32(self): ...
def readI64(self): ...
def readDouble(self): ...
def readString(self): ...
def skip(self, ttype): ...
def readFieldByTType(self, ttype, spec): ...
def readContainerList(self, spec): ...
def readContainerSet(self, spec): ...
def readContainerStruct(self, spec): ...
def readContainerMap(self, spec): ...
def readStruct(self, obj, thrift_spec): ...
def writeContainerStruct(self, val, spec): ...
def writeContainerList(self, val, spec): ...
def writeContainerSet(self, val, spec): ...
def writeContainerMap(self, val, spec): ...
def writeStruct(self, obj, thrift_spec): ...
def writeFieldByTType(self, ttype, val, spec): ...
def checkIntegerLimits(i, bits): ...
class TProtocolFactory:
def getProtocol(self, trans): ...
mypy-0.470/typeshed/third_party/2/thrift/protocol/TBinaryProtocol.pyi 0000644 0000000 0000000 00000004252 13035744274 024531 0 ustar root root # Stubs for thrift.protocol.TBinaryProtocol (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .TProtocol import TProtocolBase
from .TProtocol import * # noqa: F403
class TBinaryProtocol(TProtocolBase):
VERSION_MASK = ... # type: Any
VERSION_1 = ... # type: Any
TYPE_MASK = ... # type: Any
strictRead = ... # type: Any
strictWrite = ... # type: Any
def __init__(self, trans, strictRead=..., strictWrite=...) -> None: ...
def writeMessageBegin(self, name, type, seqid): ...
def writeMessageEnd(self): ...
def writeStructBegin(self, name): ...
def writeStructEnd(self): ...
def writeFieldBegin(self, name, type, id): ...
def writeFieldEnd(self): ...
def writeFieldStop(self): ...
def writeMapBegin(self, ktype, vtype, size): ...
def writeMapEnd(self): ...
def writeListBegin(self, etype, size): ...
def writeListEnd(self): ...
def writeSetBegin(self, etype, size): ...
def writeSetEnd(self): ...
def writeBool(self, bool): ...
def writeByte(self, byte): ...
def writeI16(self, i16): ...
def writeI32(self, i32): ...
def writeI64(self, i64): ...
def writeDouble(self, dub): ...
def writeString(self, str): ...
def readMessageBegin(self): ...
def readMessageEnd(self): ...
def readStructBegin(self): ...
def readStructEnd(self): ...
def readFieldBegin(self): ...
def readFieldEnd(self): ...
def readMapBegin(self): ...
def readMapEnd(self): ...
def readListBegin(self): ...
def readListEnd(self): ...
def readSetBegin(self): ...
def readSetEnd(self): ...
def readBool(self): ...
def readByte(self): ...
def readI16(self): ...
def readI32(self): ...
def readI64(self): ...
def readDouble(self): ...
def readString(self): ...
class TBinaryProtocolFactory:
strictRead = ... # type: Any
strictWrite = ... # type: Any
def __init__(self, strictRead=..., strictWrite=...) -> None: ...
def getProtocol(self, trans): ...
class TBinaryProtocolAccelerated(TBinaryProtocol): ...
class TBinaryProtocolAcceleratedFactory:
def getProtocol(self, trans): ...
mypy-0.470/typeshed/third_party/2/werkzeug/ 0000755 0000000 0000000 00000000000 13044320557 017405 5 ustar root root mypy-0.470/typeshed/third_party/2/werkzeug/routing.pyi 0000644 0000000 0000000 00000014522 13035744274 021631 0 ustar root root # Stubs for werkzeug.routing (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.exceptions import HTTPException
def parse_converter_args(argstr): ...
def parse_rule(rule): ...
class RoutingException(Exception): ...
class RequestRedirect(HTTPException, RoutingException):
code = ... # type: Any
new_url = ... # type: Any
def __init__(self, new_url): ...
def get_response(self, environ): ...
class RequestSlash(RoutingException): ...
class RequestAliasRedirect(RoutingException):
matched_values = ... # type: Any
def __init__(self, matched_values): ...
class BuildError(RoutingException, LookupError):
endpoint = ... # type: Any
values = ... # type: Any
method = ... # type: Any
suggested = ... # type: Any
def __init__(self, endpoint, values, method, adapter=None): ...
def closest_rule(self, adapter): ...
class ValidationError(ValueError): ...
class RuleFactory:
def get_rules(self, map): ...
class Subdomain(RuleFactory):
subdomain = ... # type: Any
rules = ... # type: Any
def __init__(self, subdomain, rules): ...
def get_rules(self, map): ...
class Submount(RuleFactory):
path = ... # type: Any
rules = ... # type: Any
def __init__(self, path, rules): ...
def get_rules(self, map): ...
class EndpointPrefix(RuleFactory):
prefix = ... # type: Any
rules = ... # type: Any
def __init__(self, prefix, rules): ...
def get_rules(self, map): ...
class RuleTemplate:
rules = ... # type: Any
def __init__(self, rules): ...
def __call__(self, *args, **kwargs): ...
class RuleTemplateFactory(RuleFactory):
rules = ... # type: Any
context = ... # type: Any
def __init__(self, rules, context): ...
def get_rules(self, map): ...
class Rule(RuleFactory):
rule = ... # type: Any
is_leaf = ... # type: Any
map = ... # type: Any
strict_slashes = ... # type: Any
subdomain = ... # type: Any
host = ... # type: Any
defaults = ... # type: Any
build_only = ... # type: Any
alias = ... # type: Any
methods = ... # type: Any
endpoint = ... # type: Any
redirect_to = ... # type: Any
arguments = ... # type: Any
def __init__(self, string, defaults=None, subdomain=None, methods=None, build_only=False, endpoint=None, strict_slashes=None, redirect_to=None, alias=False, host=None): ...
def empty(self): ...
def get_empty_kwargs(self): ...
def get_rules(self, map): ...
def refresh(self): ...
def bind(self, map, rebind=False): ...
def get_converter(self, variable_name, converter_name, args, kwargs): ...
def compile(self): ...
def match(self, path): ...
def build(self, values, append_unknown=True): ...
def provides_defaults_for(self, rule): ...
def suitable_for(self, values, method=None): ...
def match_compare_key(self): ...
def build_compare_key(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class BaseConverter:
regex = ... # type: Any
weight = ... # type: Any
map = ... # type: Any
def __init__(self, map): ...
def to_python(self, value): ...
def to_url(self, value): ...
class UnicodeConverter(BaseConverter):
regex = ... # type: Any
def __init__(self, map, minlength=1, maxlength=None, length=None): ...
class AnyConverter(BaseConverter):
regex = ... # type: Any
def __init__(self, map, *items): ...
class PathConverter(BaseConverter):
regex = ... # type: Any
weight = ... # type: Any
class NumberConverter(BaseConverter):
weight = ... # type: Any
fixed_digits = ... # type: Any
min = ... # type: Any
max = ... # type: Any
def __init__(self, map, fixed_digits=0, min=None, max=None): ...
def to_python(self, value): ...
def to_url(self, value): ...
class IntegerConverter(NumberConverter):
regex = ... # type: Any
num_convert = ... # type: Any
class FloatConverter(NumberConverter):
regex = ... # type: Any
num_convert = ... # type: Any
def __init__(self, map, min=None, max=None): ...
class UUIDConverter(BaseConverter):
regex = ... # type: Any
def to_python(self, value): ...
def to_url(self, value): ...
DEFAULT_CONVERTERS = ... # type: Any
class Map:
default_converters = ... # type: Any
default_subdomain = ... # type: Any
charset = ... # type: Any
encoding_errors = ... # type: Any
strict_slashes = ... # type: Any
redirect_defaults = ... # type: Any
host_matching = ... # type: Any
converters = ... # type: Any
sort_parameters = ... # type: Any
sort_key = ... # type: Any
def __init__(self, rules=None, default_subdomain='', charset='', strict_slashes=True, redirect_defaults=True, converters=None, sort_parameters=False, sort_key=None, encoding_errors='', host_matching=False): ...
def is_endpoint_expecting(self, endpoint, *arguments): ...
def iter_rules(self, endpoint=None): ...
def add(self, rulefactory): ...
def bind(self, server_name, script_name=None, subdomain=None, url_scheme='', default_method='', path_info=None, query_args=None): ...
def bind_to_environ(self, environ, server_name=None, subdomain=None): ...
def update(self): ...
class MapAdapter:
map = ... # type: Any
server_name = ... # type: Any
script_name = ... # type: Any
subdomain = ... # type: Any
url_scheme = ... # type: Any
path_info = ... # type: Any
default_method = ... # type: Any
query_args = ... # type: Any
def __init__(self, map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args=None): ...
def dispatch(self, view_func, path_info=None, method=None, catch_http_exceptions=False): ...
def match(self, path_info=None, method=None, return_rule=False, query_args=None): ...
def test(self, path_info=None, method=None): ...
def allowed_methods(self, path_info=None): ...
def get_host(self, domain_part): ...
def get_default_redirect(self, rule, method, values, query_args): ...
def encode_query_args(self, query_args): ...
def make_redirect_url(self, path_info, query_args=None, domain_part=None): ...
def make_alias_redirect_url(self, path, endpoint, values, method, query_args): ...
def build(self, endpoint, values=None, method=None, force_external=False, append_unknown=True): ...
mypy-0.470/typeshed/third_party/2/werkzeug/__init__.pyi 0000644 0000000 0000000 00000013041 13035744274 021674 0 ustar root root # Stubs for werkzeug (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from types import ModuleType
from typing import Any
from werkzeug import _internal
from werkzeug import datastructures
from werkzeug import debug
from werkzeug import exceptions
from werkzeug import formparser
from werkzeug import http
from werkzeug import local
from werkzeug import security
from werkzeug import serving
from werkzeug import test
from werkzeug import testapp
from werkzeug import urls
from werkzeug import useragents
from werkzeug import utils
from werkzeug import wrappers
from werkzeug import wsgi
class module(ModuleType):
def __getattr__(self, name): ...
def __dir__(self): ...
__version__ = ... # type: Any
run_simple = serving.run_simple
test_app = testapp.test_app
UserAgent = useragents.UserAgent
_easteregg = _internal._easteregg
DebuggedApplication = debug.DebuggedApplication
MultiDict = datastructures.MultiDict
CombinedMultiDict = datastructures.CombinedMultiDict
Headers = datastructures.Headers
EnvironHeaders = datastructures.EnvironHeaders
ImmutableList = datastructures.ImmutableList
ImmutableDict = datastructures.ImmutableDict
ImmutableMultiDict = datastructures.ImmutableMultiDict
TypeConversionDict = datastructures.TypeConversionDict
ImmutableTypeConversionDict = datastructures.ImmutableTypeConversionDict
Accept = datastructures.Accept
MIMEAccept = datastructures.MIMEAccept
CharsetAccept = datastructures.CharsetAccept
LanguageAccept = datastructures.LanguageAccept
RequestCacheControl = datastructures.RequestCacheControl
ResponseCacheControl = datastructures.ResponseCacheControl
ETags = datastructures.ETags
HeaderSet = datastructures.HeaderSet
WWWAuthenticate = datastructures.WWWAuthenticate
Authorization = datastructures.Authorization
FileMultiDict = datastructures.FileMultiDict
CallbackDict = datastructures.CallbackDict
FileStorage = datastructures.FileStorage
OrderedMultiDict = datastructures.OrderedMultiDict
ImmutableOrderedMultiDict = datastructures.ImmutableOrderedMultiDict
escape = utils.escape
environ_property = utils.environ_property
append_slash_redirect = utils.append_slash_redirect
redirect = utils.redirect
cached_property = utils.cached_property
import_string = utils.import_string
dump_cookie = http.dump_cookie
parse_cookie = http.parse_cookie
unescape = utils.unescape
format_string = utils.format_string
find_modules = utils.find_modules
header_property = utils.header_property
html = utils.html
xhtml = utils.xhtml
HTMLBuilder = utils.HTMLBuilder
validate_arguments = utils.validate_arguments
ArgumentValidationError = utils.ArgumentValidationError
bind_arguments = utils.bind_arguments
secure_filename = utils.secure_filename
BaseResponse = wrappers.BaseResponse
BaseRequest = wrappers.BaseRequest
Request = wrappers.Request
Response = wrappers.Response
AcceptMixin = wrappers.AcceptMixin
ETagRequestMixin = wrappers.ETagRequestMixin
ETagResponseMixin = wrappers.ETagResponseMixin
ResponseStreamMixin = wrappers.ResponseStreamMixin
CommonResponseDescriptorsMixin = wrappers.CommonResponseDescriptorsMixin
UserAgentMixin = wrappers.UserAgentMixin
AuthorizationMixin = wrappers.AuthorizationMixin
WWWAuthenticateMixin = wrappers.WWWAuthenticateMixin
CommonRequestDescriptorsMixin = wrappers.CommonRequestDescriptorsMixin
Local = local.Local
LocalManager = local.LocalManager
LocalProxy = local.LocalProxy
LocalStack = local.LocalStack
release_local = local.release_local
generate_password_hash = security.generate_password_hash
check_password_hash = security.check_password_hash
Client = test.Client
EnvironBuilder = test.EnvironBuilder
create_environ = test.create_environ
run_wsgi_app = test.run_wsgi_app
get_current_url = wsgi.get_current_url
get_host = wsgi.get_host
pop_path_info = wsgi.pop_path_info
peek_path_info = wsgi.peek_path_info
SharedDataMiddleware = wsgi.SharedDataMiddleware
DispatcherMiddleware = wsgi.DispatcherMiddleware
ClosingIterator = wsgi.ClosingIterator
FileWrapper = wsgi.FileWrapper
make_line_iter = wsgi.make_line_iter
LimitedStream = wsgi.LimitedStream
responder = wsgi.responder
wrap_file = wsgi.wrap_file
extract_path_info = wsgi.extract_path_info
parse_etags = http.parse_etags
parse_date = http.parse_date
http_date = http.http_date
cookie_date = http.cookie_date
parse_cache_control_header = http.parse_cache_control_header
is_resource_modified = http.is_resource_modified
parse_accept_header = http.parse_accept_header
parse_set_header = http.parse_set_header
quote_etag = http.quote_etag
unquote_etag = http.unquote_etag
generate_etag = http.generate_etag
dump_header = http.dump_header
parse_list_header = http.parse_list_header
parse_dict_header = http.parse_dict_header
parse_authorization_header = http.parse_authorization_header
parse_www_authenticate_header = http.parse_www_authenticate_header
remove_entity_headers = http.remove_entity_headers
is_entity_header = http.is_entity_header
remove_hop_by_hop_headers = http.remove_hop_by_hop_headers
parse_options_header = http.parse_options_header
dump_options_header = http.dump_options_header
is_hop_by_hop_header = http.is_hop_by_hop_header
unquote_header_value = http.unquote_header_value
quote_header_value = http.quote_header_value
HTTP_STATUS_CODES = http.HTTP_STATUS_CODES
url_decode = urls.url_decode
url_encode = urls.url_encode
url_quote = urls.url_quote
url_quote_plus = urls.url_quote_plus
url_unquote = urls.url_unquote
url_unquote_plus = urls.url_unquote_plus
url_fix = urls.url_fix
Href = urls.Href
iri_to_uri = urls.iri_to_uri
uri_to_iri = urls.uri_to_iri
parse_form_data = formparser.parse_form_data
abort = exceptions.Aborter
Aborter = exceptions.Aborter
mypy-0.470/typeshed/third_party/2/werkzeug/script.pyi 0000644 0000000 0000000 00000001242 13035744274 021441 0 ustar root root # Stubs for werkzeug.script (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
argument_types = ... # type: Any
converters = ... # type: Any
def run(namespace=None, action_prefix='', args=None): ...
def fail(message, code=-1): ...
def find_actions(namespace, action_prefix): ...
def print_usage(actions): ...
def analyse_action(func): ...
def make_shell(init_func=None, banner=None, use_ipython=True): ...
def make_runserver(app_factory, hostname='', port=5000, use_reloader=False, use_debugger=False, use_evalex=True, threaded=False, processes=1, static_files=None, extra_files=None, ssl_context=None): ...
mypy-0.470/typeshed/third_party/2/werkzeug/posixemulation.pyi 0000644 0000000 0000000 00000000522 13035744274 023215 0 ustar root root # Stubs for werkzeug.posixemulation (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from ._compat import to_unicode as to_unicode
from .filesystem import get_filesystem_encoding as get_filesystem_encoding
can_rename_open_file = ... # type: Any
def rename(src, dst): ...
mypy-0.470/typeshed/third_party/2/werkzeug/urls.pyi 0000644 0000000 0000000 00000004610 13035744274 021124 0 ustar root root # Stubs for werkzeug.urls (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from collections import namedtuple
from typing import Any
_URLTuple = namedtuple(
'_URLTuple',
['scheme', 'netloc', 'path', 'query', 'fragment']
)
class BaseURL(_URLTuple):
def replace(self, **kwargs): ...
@property
def host(self): ...
@property
def ascii_host(self): ...
@property
def port(self): ...
@property
def auth(self): ...
@property
def username(self): ...
@property
def raw_username(self): ...
@property
def password(self): ...
@property
def raw_password(self): ...
def decode_query(self, *args, **kwargs): ...
def join(self, *args, **kwargs): ...
def to_url(self): ...
def decode_netloc(self): ...
def to_uri_tuple(self): ...
def to_iri_tuple(self): ...
def get_file_location(self, pathformat=None): ...
class URL(BaseURL):
def encode_netloc(self): ...
def encode(self, charset='', errors=''): ...
class BytesURL(BaseURL):
def encode_netloc(self): ...
def decode(self, charset='', errors=''): ...
def url_parse(url, scheme=None, allow_fragments=True): ...
def url_quote(string, charset='', errors='', safe='', unsafe=''): ...
def url_quote_plus(string, charset='', errors='', safe=''): ...
def url_unparse(components): ...
def url_unquote(string, charset='', errors='', unsafe=''): ...
def url_unquote_plus(s, charset='', errors=''): ...
def url_fix(s, charset=''): ...
def uri_to_iri(uri, charset='', errors=''): ...
def iri_to_uri(iri, charset='', errors='', safe_conversion=False): ...
def url_decode(s, charset='', decode_keys=False, include_empty=True, errors='', separator='', cls=None): ...
def url_decode_stream(stream, charset='', decode_keys=False, include_empty=True, errors='', separator='', cls=None, limit=None, return_iterator=False): ...
def url_encode(obj, charset='', encode_keys=False, sort=False, key=None, separator=''): ...
def url_encode_stream(obj, stream=None, charset='', encode_keys=False, sort=False, key=None, separator=''): ...
def url_join(base, url, allow_fragments=True): ...
class Href:
base = ... # type: Any
charset = ... # type: Any
sort = ... # type: Any
key = ... # type: Any
def __init__(self, base='', charset='', sort=False, key=None): ...
def __getattr__(self, name): ...
def __call__(self, *path, **query): ...
mypy-0.470/typeshed/third_party/2/werkzeug/formparser.pyi 0000644 0000000 0000000 00000003700 13035744274 022316 0 ustar root root # Stubs for werkzeug.formparser (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def default_stream_factory(total_content_length, filename, content_type, content_length=None): ...
def parse_form_data(environ, stream_factory=None, charset='', errors='', max_form_memory_size=None, max_content_length=None, cls=None, silent=True): ...
def exhaust_stream(f): ...
class FormDataParser:
stream_factory = ... # type: Any
charset = ... # type: Any
errors = ... # type: Any
max_form_memory_size = ... # type: Any
max_content_length = ... # type: Any
cls = ... # type: Any
silent = ... # type: Any
def __init__(self, stream_factory=None, charset='', errors='', max_form_memory_size=None, max_content_length=None, cls=None, silent=True): ...
def get_parse_func(self, mimetype, options): ...
def parse_from_environ(self, environ): ...
def parse(self, stream, mimetype, content_length, options=None): ...
parse_functions = ... # type: Any
def is_valid_multipart_boundary(boundary): ...
def parse_multipart_headers(iterable): ...
class MultiPartParser:
stream_factory = ... # type: Any
charset = ... # type: Any
errors = ... # type: Any
max_form_memory_size = ... # type: Any
cls = ... # type: Any
buffer_size = ... # type: Any
def __init__(self, stream_factory=None, charset='', errors='', max_form_memory_size=None, cls=None, buffer_size=...): ...
def fail(self, message): ...
def get_part_encoding(self, headers): ...
def get_part_charset(self, headers): ...
def start_file_streaming(self, filename, headers, total_content_length): ...
def in_memory_threshold_reached(self, bytes): ...
def validate_boundary(self, boundary): ...
def parse_lines(self, file, boundary, content_length): ...
def parse_parts(self, file, boundary, content_length): ...
def parse(self, file, boundary, content_length): ...
mypy-0.470/typeshed/third_party/2/werkzeug/wsgi.pyi 0000644 0000000 0000000 00000006145 13035744274 021115 0 ustar root root # Stubs for werkzeug.wsgi (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def responder(f): ...
def get_current_url(environ, root_only=False, strip_querystring=False, host_only=False, trusted_hosts=None): ...
def host_is_trusted(hostname, trusted_list): ...
def get_host(environ, trusted_hosts=None): ...
def get_content_length(environ): ...
def get_input_stream(environ, safe_fallback=True): ...
def get_query_string(environ): ...
def get_path_info(environ, charset='', errors=''): ...
def get_script_name(environ, charset='', errors=''): ...
def pop_path_info(environ, charset='', errors=''): ...
def peek_path_info(environ, charset='', errors=''): ...
def extract_path_info(environ_or_baseurl, path_or_url, charset='', errors='', collapse_http_schemes=True): ...
class SharedDataMiddleware:
app = ... # type: Any
exports = ... # type: Any
cache = ... # type: Any
cache_timeout = ... # type: Any
fallback_mimetype = ... # type: Any
def __init__(self, app, exports, disallow=None, cache=True, cache_timeout=..., fallback_mimetype=''): ...
def is_allowed(self, filename): ...
def get_file_loader(self, filename): ...
def get_package_loader(self, package, package_path): ...
def get_directory_loader(self, directory): ...
def generate_etag(self, mtime, file_size, real_filename): ...
def __call__(self, environ, start_response): ...
class DispatcherMiddleware:
app = ... # type: Any
mounts = ... # type: Any
def __init__(self, app, mounts=None): ...
def __call__(self, environ, start_response): ...
class ClosingIterator:
def __init__(self, iterable, callbacks=None): ...
def __iter__(self): ...
def __next__(self): ...
def close(self): ...
def wrap_file(environ, file, buffer_size=8192): ...
class FileWrapper:
file = ... # type: Any
buffer_size = ... # type: Any
def __init__(self, file, buffer_size=8192): ...
def close(self): ...
def seekable(self): ...
def seek(self, *args): ...
def tell(self): ...
def __iter__(self): ...
def __next__(self): ...
class _RangeWrapper:
iterable = ... # type: Any
byte_range = ... # type: Any
start_byte = ... # type: Any
end_byte = ... # type: Any
read_length = ... # type: Any
seekable = ... # type: Any
end_reached = ... # type: Any
def __init__(self, iterable, start_byte=0, byte_range=None): ...
def __iter__(self): ...
def __next__(self): ...
def close(self): ...
def make_line_iter(stream, limit=None, buffer_size=..., cap_at_buffer=False): ...
def make_chunk_iter(stream, separator, limit=None, buffer_size=..., cap_at_buffer=False): ...
class LimitedStream:
limit = ... # type: Any
def __init__(self, stream, limit): ...
def __iter__(self): ...
@property
def is_exhausted(self): ...
def on_exhausted(self): ...
def on_disconnect(self): ...
def exhaust(self, chunk_size=...): ...
def read(self, size=None): ...
def readline(self, size=None): ...
def readlines(self, size=None): ...
def tell(self): ...
def __next__(self): ...
mypy-0.470/typeshed/third_party/2/werkzeug/security.pyi 0000644 0000000 0000000 00000001105 13035744274 022002 0 ustar root root # Stubs for werkzeug.security (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
SALT_CHARS = ... # type: Any
DEFAULT_PBKDF2_ITERATIONS = ... # type: Any
def pbkdf2_hex(data, salt, iterations=..., keylen=None, hashfunc=None): ...
def pbkdf2_bin(data, salt, iterations=..., keylen=None, hashfunc=None): ...
def safe_str_cmp(a, b): ...
def gen_salt(length): ...
def generate_password_hash(password, method='', salt_length=8): ...
def check_password_hash(pwhash, password): ...
def safe_join(directory, filename): ...
mypy-0.470/typeshed/third_party/2/werkzeug/debug/ 0000755 0000000 0000000 00000000000 13044320557 020473 5 ustar root root mypy-0.470/typeshed/third_party/2/werkzeug/debug/__init__.pyi 0000644 0000000 0000000 00000002676 13035744274 022776 0 ustar root root # Stubs for werkzeug.debug (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
PIN_TIME = ... # type: Any
class _ConsoleFrame:
console = ... # type: Any
id = ... # type: Any
def __init__(self, namespace): ...
def get_pin_and_cookie_name(app): ...
class DebuggedApplication:
app = ... # type: Any
evalex = ... # type: Any
frames = ... # type: Any
tracebacks = ... # type: Any
request_key = ... # type: Any
console_path = ... # type: Any
console_init_func = ... # type: Any
show_hidden_frames = ... # type: Any
secret = ... # type: Any
pin_logging = ... # type: Any
pin = ... # type: Any
def __init__(self, app, evalex=False, request_key='', console_path='', console_init_func=None, show_hidden_frames=False, lodgeit_url=None, pin_security=True, pin_logging=True): ...
@property
def pin_cookie_name(self): ...
def debug_application(self, environ, start_response): ...
def execute_command(self, request, command, frame): ...
def display_console(self, request): ...
def paste_traceback(self, request, traceback): ...
def get_resource(self, request, filename): ...
def is_trusted(self, environ): ...
def pin_auth(self, request): ...
def log_pin_request(self): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/2/werkzeug/debug/console.pyi 0000644 0000000 0000000 00000002433 13035744274 022670 0 ustar root root # Stubs for werkzeug.debug.console (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import code
class HTMLStringO:
def __init__(self): ...
def isatty(self): ...
def close(self): ...
def flush(self): ...
def seek(self, n, mode=0): ...
def readline(self): ...
def reset(self): ...
def write(self, x): ...
def writelines(self, x): ...
class ThreadedStream:
@staticmethod
def push(): ...
@staticmethod
def fetch(): ...
@staticmethod
def displayhook(obj): ...
def __setattr__(self, name, value): ...
def __dir__(self): ...
def __getattribute__(self, name): ...
class _ConsoleLoader:
def __init__(self): ...
def register(self, code, source): ...
def get_source_by_code(self, code): ...
class _InteractiveConsole(code.InteractiveInterpreter):
globals = ... # type: Any
more = ... # type: Any
buffer = ... # type: Any
def __init__(self, globals, locals): ...
def runsource(self, source): ...
def runcode(self, code): ...
def showtraceback(self): ...
def showsyntaxerror(self, filename=None): ...
def write(self, data): ...
class Console:
def __init__(self, globals=None, locals=None): ...
def eval(self, code): ...
mypy-0.470/typeshed/third_party/2/werkzeug/debug/tbtools.pyi 0000644 0000000 0000000 00000004077 13035744274 022722 0 ustar root root # Stubs for werkzeug.debug.tbtools (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
UTF8_COOKIE = ... # type: Any
system_exceptions = ... # type: Any
HEADER = ... # type: Any
FOOTER = ... # type: Any
PAGE_HTML = ... # type: Any
CONSOLE_HTML = ... # type: Any
SUMMARY_HTML = ... # type: Any
FRAME_HTML = ... # type: Any
SOURCE_LINE_HTML = ... # type: Any
def render_console_html(secret, evalex_trusted=True): ...
def get_current_traceback(ignore_system_exceptions=False, show_hidden_frames=False, skip=0): ...
class Line:
lineno = ... # type: Any
code = ... # type: Any
in_frame = ... # type: Any
current = ... # type: Any
def __init__(self, lineno, code): ...
def classes(self): ...
def render(self): ...
class Traceback:
exc_type = ... # type: Any
exc_value = ... # type: Any
exception_type = ... # type: Any
frames = ... # type: Any
def __init__(self, exc_type, exc_value, tb): ...
def filter_hidden_frames(self): ...
def is_syntax_error(self): ...
def exception(self): ...
def log(self, logfile=None): ...
def paste(self): ...
def render_summary(self, include_title=True): ...
def render_full(self, evalex=False, secret=None, evalex_trusted=True): ...
def generate_plaintext_traceback(self): ...
def plaintext(self): ...
id = ... # type: Any
class Frame:
lineno = ... # type: Any
function_name = ... # type: Any
locals = ... # type: Any
globals = ... # type: Any
filename = ... # type: Any
module = ... # type: Any
loader = ... # type: Any
code = ... # type: Any
hide = ... # type: Any
info = ... # type: Any
def __init__(self, exc_type, exc_value, tb): ...
def render(self): ...
def render_line_context(self): ...
def get_annotated_lines(self): ...
def eval(self, code, mode=''): ...
def sourcelines(self): ...
def get_context_lines(self, context=5): ...
@property
def current_line(self): ...
def console(self): ...
id = ... # type: Any
mypy-0.470/typeshed/third_party/2/werkzeug/debug/repr.pyi 0000644 0000000 0000000 00000002047 13035744274 022177 0 ustar root root # Stubs for werkzeug.debug.repr (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
deque = ... # type: Any
missing = ... # type: Any
RegexType = ... # type: Any
HELP_HTML = ... # type: Any
OBJECT_DUMP_HTML = ... # type: Any
def debug_repr(obj): ...
def dump(obj=...): ...
class _Helper:
def __call__(self, topic=None): ...
helper = ... # type: Any
class DebugReprGenerator:
def __init__(self): ...
list_repr = ... # type: Any
tuple_repr = ... # type: Any
set_repr = ... # type: Any
frozenset_repr = ... # type: Any
deque_repr = ... # type: Any
def regex_repr(self, obj): ...
def string_repr(self, obj, limit=70): ...
def dict_repr(self, d, recursive, limit=5): ...
def object_repr(self, obj): ...
def dispatch_repr(self, obj, recursive): ...
def fallback_repr(self): ...
def repr(self, obj): ...
def dump_object(self, obj): ...
def dump_locals(self, d): ...
def render_object_dump(self, items, title, repr=None): ...
mypy-0.470/typeshed/third_party/2/werkzeug/testapp.pyi 0000644 0000000 0000000 00000000564 13035744274 021623 0 ustar root root # Stubs for werkzeug.testapp (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
logo = ... # type: Any
TEMPLATE = ... # type: Any
def iter_sys_path(): ...
def render_testapp(req): ...
def test_app(environ, start_response): ...
mypy-0.470/typeshed/third_party/2/werkzeug/_internal.pyi 0000644 0000000 0000000 00000001230 13035744274 022105 0 ustar root root # Stubs for werkzeug._internal (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _Missing:
def __reduce__(self): ...
class _DictAccessorProperty:
read_only = ... # type: Any
name = ... # type: Any
default = ... # type: Any
load_func = ... # type: Any
dump_func = ... # type: Any
__doc__ = ... # type: Any
def __init__(self, name, default=None, load_func=None, dump_func=None, read_only=None, doc=None): ...
def __get__(self, obj, type=None): ...
def __set__(self, obj, value): ...
def __delete__(self, obj): ...
def _easteregg(app=None): ...
mypy-0.470/typeshed/third_party/2/werkzeug/local.pyi 0000644 0000000 0000000 00000006144 13035744274 021235 0 ustar root root # Stubs for werkzeug.local (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def release_local(local): ...
class Local:
def __init__(self): ...
def __iter__(self): ...
def __call__(self, proxy): ...
def __release_local__(self): ...
def __getattr__(self, name): ...
def __setattr__(self, name, value): ...
def __delattr__(self, name): ...
class LocalStack:
def __init__(self): ...
def __release_local__(self): ...
def _get__ident_func__(self): ...
def _set__ident_func__(self, value): ...
__ident_func__ = ... # type: Any
def __call__(self): ...
def push(self, obj): ...
def pop(self): ...
@property
def top(self): ...
class LocalManager:
locals = ... # type: Any
ident_func = ... # type: Any
def __init__(self, locals=None, ident_func=None): ...
def get_ident(self): ...
def cleanup(self): ...
def make_middleware(self, app): ...
def middleware(self, func): ...
class LocalProxy:
def __init__(self, local, name=None): ...
@property
def __dict__(self): ...
def __bool__(self): ...
def __unicode__(self): ...
def __dir__(self): ...
def __getattr__(self, name): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
__getslice__ = ... # type: Any
def __setslice__(self, i, j, seq): ...
def __delslice__(self, i, j): ...
__setattr__ = ... # type: Any
__delattr__ = ... # type: Any
__lt__ = ... # type: Any
__le__ = ... # type: Any
__eq__ = ... # type: Any
__ne__ = ... # type: Any
__gt__ = ... # type: Any
__ge__ = ... # type: Any
__cmp__ = ... # type: Any
__hash__ = ... # type: Any
__call__ = ... # type: Any
__len__ = ... # type: Any
__getitem__ = ... # type: Any
__iter__ = ... # type: Any
__contains__ = ... # type: Any
__add__ = ... # type: Any
__sub__ = ... # type: Any
__mul__ = ... # type: Any
__floordiv__ = ... # type: Any
__mod__ = ... # type: Any
__divmod__ = ... # type: Any
__pow__ = ... # type: Any
__lshift__ = ... # type: Any
__rshift__ = ... # type: Any
__and__ = ... # type: Any
__xor__ = ... # type: Any
__or__ = ... # type: Any
__div__ = ... # type: Any
__truediv__ = ... # type: Any
__neg__ = ... # type: Any
__pos__ = ... # type: Any
__abs__ = ... # type: Any
__invert__ = ... # type: Any
__complex__ = ... # type: Any
__int__ = ... # type: Any
__long__ = ... # type: Any
__float__ = ... # type: Any
__oct__ = ... # type: Any
__hex__ = ... # type: Any
__index__ = ... # type: Any
__coerce__ = ... # type: Any
__enter__ = ... # type: Any
__exit__ = ... # type: Any
__radd__ = ... # type: Any
__rsub__ = ... # type: Any
__rmul__ = ... # type: Any
__rdiv__ = ... # type: Any
__rtruediv__ = ... # type: Any
__rfloordiv__ = ... # type: Any
__rmod__ = ... # type: Any
__rdivmod__ = ... # type: Any
__copy__ = ... # type: Any
__deepcopy__ = ... # type: Any
mypy-0.470/typeshed/third_party/2/werkzeug/utils.pyi 0000644 0000000 0000000 00000003320 13035744274 021274 0 ustar root root # Stubs for werkzeug.utils (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug._internal import _DictAccessorProperty
class cached_property(property):
__name__ = ... # type: Any
__module__ = ... # type: Any
__doc__ = ... # type: Any
func = ... # type: Any
def __init__(self, func, name=None, doc=None): ...
def __set__(self, obj, value): ...
def __get__(self, obj, type=None): ...
class environ_property(_DictAccessorProperty):
read_only = ... # type: Any
def lookup(self, obj): ...
class header_property(_DictAccessorProperty):
def lookup(self, obj): ...
class HTMLBuilder:
def __init__(self, dialect): ...
def __call__(self, s): ...
def __getattr__(self, tag): ...
html = ... # type: Any
xhtml = ... # type: Any
def get_content_type(mimetype, charset): ...
def format_string(string, context): ...
def secure_filename(filename): ...
def escape(s, quote=None): ...
def unescape(s): ...
def redirect(location, code=302, Response=None): ...
def append_slash_redirect(environ, code=301): ...
def import_string(import_name, silent=False): ...
def find_modules(import_path, include_packages=False, recursive=False): ...
def validate_arguments(func, args, kwargs, drop_extra=True): ...
def bind_arguments(func, args, kwargs): ...
class ArgumentValidationError(ValueError):
missing = ... # type: Any
extra = ... # type: Any
extra_positional = ... # type: Any
def __init__(self, missing=None, extra=None, extra_positional=None): ...
class ImportStringError(ImportError):
import_name = ... # type: Any
exception = ... # type: Any
def __init__(self, import_name, exception): ...
mypy-0.470/typeshed/third_party/2/werkzeug/wrappers.pyi 0000644 0000000 0000000 00000014567 13035744274 022016 0 ustar root root # Stubs for werkzeug.wrappers (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class BaseRequest:
charset = ... # type: Any
encoding_errors = ... # type: Any
max_content_length = ... # type: Any
max_form_memory_size = ... # type: Any
parameter_storage_class = ... # type: Any
list_storage_class = ... # type: Any
dict_storage_class = ... # type: Any
form_data_parser_class = ... # type: Any
trusted_hosts = ... # type: Any
disable_data_descriptor = ... # type: Any
environ = ... # type: Any
shallow = ... # type: Any
def __init__(self, environ, populate_request=True, shallow=False): ...
@property
def url_charset(self): ...
@classmethod
def from_values(cls, *args, **kwargs): ...
@classmethod
def application(cls, f): ...
@property
def want_form_data_parsed(self): ...
def make_form_data_parser(self): ...
def close(self): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, tb): ...
def stream(self): ...
input_stream = ... # type: Any
def args(self): ...
def data(self): ...
def get_data(self, cache=True, as_text=False, parse_form_data=False): ...
def form(self): ...
def values(self): ...
def files(self): ...
def cookies(self): ...
def headers(self): ...
def path(self): ...
def full_path(self): ...
def script_root(self): ...
def url(self): ...
def base_url(self): ...
def url_root(self): ...
def host_url(self): ...
def host(self): ...
query_string = ... # type: Any
method = ... # type: Any
def access_route(self): ...
@property
def remote_addr(self): ...
remote_user = ... # type: Any
scheme = ... # type: Any
is_xhr = ... # type: Any
is_secure = ... # type: Any
is_multithread = ... # type: Any
is_multiprocess = ... # type: Any
is_run_once = ... # type: Any
class BaseResponse:
charset = ... # type: Any
default_status = ... # type: Any
default_mimetype = ... # type: Any
implicit_sequence_conversion = ... # type: Any
autocorrect_location_header = ... # type: Any
automatically_set_content_length = ... # type: Any
headers = ... # type: Any
status_code = ... # type: Any
status = ... # type: Any
direct_passthrough = ... # type: Any
response = ... # type: Any
def __init__(self, response=None, status=None, headers=None, mimetype=None, content_type=None, direct_passthrough=False): ...
def call_on_close(self, func): ...
@classmethod
def force_type(cls, response, environ=None): ...
@classmethod
def from_app(cls, app, environ, buffered=False): ...
def get_data(self, as_text=False): ...
def set_data(self, value): ...
data = ... # type: Any
def calculate_content_length(self): ...
def make_sequence(self): ...
def iter_encoded(self): ...
def set_cookie(self, key, value='', max_age=None, expires=None, path='', domain=None, secure=False, httponly=False): ...
def delete_cookie(self, key, path='', domain=None): ...
@property
def is_streamed(self): ...
@property
def is_sequence(self): ...
def close(self): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, tb): ...
def freeze(self): ...
def get_wsgi_headers(self, environ): ...
def get_app_iter(self, environ): ...
def get_wsgi_response(self, environ): ...
def __call__(self, environ, start_response): ...
class AcceptMixin:
def accept_mimetypes(self): ...
def accept_charsets(self): ...
def accept_encodings(self): ...
def accept_languages(self): ...
class ETagRequestMixin:
def cache_control(self): ...
def if_match(self): ...
def if_none_match(self): ...
def if_modified_since(self): ...
def if_unmodified_since(self): ...
def if_range(self): ...
def range(self): ...
class UserAgentMixin:
def user_agent(self): ...
class AuthorizationMixin:
def authorization(self): ...
class StreamOnlyMixin:
disable_data_descriptor = ... # type: Any
want_form_data_parsed = ... # type: Any
class ETagResponseMixin:
@property
def cache_control(self): ...
status_code = ... # type: Any
def make_conditional(self, request_or_environ, accept_ranges=False, complete_length=None): ...
def add_etag(self, overwrite=False, weak=False): ...
def set_etag(self, etag, weak=False): ...
def get_etag(self): ...
def freeze(self, no_etag=False): ...
accept_ranges = ... # type: Any
content_range = ... # type: Any
class ResponseStream:
mode = ... # type: Any
response = ... # type: Any
closed = ... # type: Any
def __init__(self, response): ...
def write(self, value): ...
def writelines(self, seq): ...
def close(self): ...
def flush(self): ...
def isatty(self): ...
@property
def encoding(self): ...
class ResponseStreamMixin:
def stream(self): ...
class CommonRequestDescriptorsMixin:
content_type = ... # type: Any
def content_length(self): ...
content_encoding = ... # type: Any
content_md5 = ... # type: Any
referrer = ... # type: Any
date = ... # type: Any
max_forwards = ... # type: Any
@property
def mimetype(self): ...
@property
def mimetype_params(self): ...
def pragma(self): ...
class CommonResponseDescriptorsMixin:
mimetype = ... # type: Any
mimetype_params = ... # type: Any
location = ... # type: Any
age = ... # type: Any
content_type = ... # type: Any
content_length = ... # type: Any
content_location = ... # type: Any
content_encoding = ... # type: Any
content_md5 = ... # type: Any
date = ... # type: Any
expires = ... # type: Any
last_modified = ... # type: Any
retry_after = ... # type: Any
vary = ... # type: Any
content_language = ... # type: Any
allow = ... # type: Any
class WWWAuthenticateMixin:
@property
def www_authenticate(self): ...
class Request(BaseRequest, AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthorizationMixin, CommonRequestDescriptorsMixin): ...
class PlainRequest(StreamOnlyMixin, Request): ...
class Response(ETagResponseMixin, BaseResponse, ResponseStreamMixin, CommonResponseDescriptorsMixin, WWWAuthenticateMixin): ... # FIXME: This is invalid but works around https://github.com/pallets/werkzeug/issues/1052
mypy-0.470/typeshed/third_party/2/werkzeug/http.pyi 0000644 0000000 0000000 00000003404 13035744274 021116 0 ustar root root # Stubs for werkzeug.http (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from urllib2 import parse_http_list as _parse_list_header
HTTP_STATUS_CODES = ... # type: Any
def wsgi_to_bytes(data): ...
def bytes_to_wsgi(data): ...
def quote_header_value(value, extra_chars='', allow_token=True): ...
def unquote_header_value(value, is_filename=False): ...
def dump_options_header(header, options): ...
def dump_header(iterable, allow_token=True): ...
def parse_list_header(value): ...
def parse_dict_header(value, cls=...): ...
def parse_options_header(value, multiple=False): ...
def parse_accept_header(value, cls=None): ...
def parse_cache_control_header(value, on_update=None, cls=None): ...
def parse_set_header(value, on_update=None): ...
def parse_authorization_header(value): ...
def parse_www_authenticate_header(value, on_update=None): ...
def parse_if_range_header(value): ...
def parse_range_header(value, make_inclusive=True): ...
def parse_content_range_header(value, on_update=None): ...
def quote_etag(etag, weak=False): ...
def unquote_etag(etag): ...
def parse_etags(value): ...
def generate_etag(data): ...
def parse_date(value): ...
def cookie_date(expires=None): ...
def http_date(timestamp=None): ...
def is_resource_modified(environ, etag=None, data=None, last_modified=None): ...
def remove_entity_headers(headers, allowed=...): ...
def remove_hop_by_hop_headers(headers): ...
def is_entity_header(header): ...
def is_hop_by_hop_header(header): ...
def parse_cookie(header, charset='', errors='', cls=None): ...
def dump_cookie(key, value='', max_age=None, expires=None, path='', domain=None, secure=False, httponly=False, charset='', sync_expires=True): ...
def is_byte_range_valid(start, stop, length): ...
mypy-0.470/typeshed/third_party/2/werkzeug/test.pyi 0000644 0000000 0000000 00000006343 13035744274 021123 0 ustar root root # Stubs for werkzeug.test (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from urllib2 import Request as U2Request
from cookielib import CookieJar
def stream_encode_multipart(values, use_tempfile=True, threshold=..., boundary=None, charset=''): ...
def encode_multipart(values, boundary=None, charset=''): ...
def File(fd, filename=None, mimetype=None): ...
class _TestCookieHeaders:
headers = ... # type: Any
def __init__(self, headers): ...
def getheaders(self, name): ...
def get_all(self, name, default=None): ...
class _TestCookieResponse:
headers = ... # type: Any
def __init__(self, headers): ...
def info(self): ...
class _TestCookieJar(CookieJar):
def inject_wsgi(self, environ): ...
def extract_wsgi(self, environ, headers): ...
class EnvironBuilder:
server_protocol = ... # type: Any
wsgi_version = ... # type: Any
request_class = ... # type: Any
charset = ... # type: Any
path = ... # type: Any
base_url = ... # type: Any
query_string = ... # type: Any
args = ... # type: Any
method = ... # type: Any
headers = ... # type: Any
content_type = ... # type: Any
errors_stream = ... # type: Any
multithread = ... # type: Any
multiprocess = ... # type: Any
run_once = ... # type: Any
environ_base = ... # type: Any
environ_overrides = ... # type: Any
input_stream = ... # type: Any
content_length = ... # type: Any
closed = ... # type: Any
def __init__(self, path='', base_url=None, query_string=None, method='', input_stream=None, content_type=None, content_length=None, errors_stream=None, multithread=False, multiprocess=False, run_once=False, headers=None, data=None, environ_base=None, environ_overrides=None, charset=''): ...
def form_property(name, storage, doc): ...
form = ... # type: Any
files = ... # type: Any
@property
def server_name(self): ...
@property
def server_port(self): ...
def __del__(self): ...
def close(self): ...
def get_environ(self): ...
def get_request(self, cls=None): ...
class ClientRedirectError(Exception): ...
class Client:
application = ... # type: Any
response_wrapper = ... # type: Any
cookie_jar = ... # type: Any
allow_subdomain_redirects = ... # type: Any
def __init__(self, application, response_wrapper=None, use_cookies=True, allow_subdomain_redirects=False): ...
def set_cookie(self, server_name, key, value='', max_age=None, expires=None, path='', domain=None, secure=None, httponly=False, charset=''): ...
def delete_cookie(self, server_name, key, path='', domain=None): ...
def run_wsgi_app(self, environ, buffered=False): ...
def resolve_redirect(self, response, new_location, environ, buffered=False): ...
def open(self, *args, **kwargs): ...
def get(self, *args, **kw): ...
def patch(self, *args, **kw): ...
def post(self, *args, **kw): ...
def head(self, *args, **kw): ...
def put(self, *args, **kw): ...
def delete(self, *args, **kw): ...
def options(self, *args, **kw): ...
def trace(self, *args, **kw): ...
def create_environ(*args, **kwargs): ...
def run_wsgi_app(app, environ, buffered=False): ...
mypy-0.470/typeshed/third_party/2/werkzeug/_compat.pyi 0000644 0000000 0000000 00000002436 13035744274 021565 0 ustar root root # Stubs for werkzeug._compat (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import StringIO as BytesIO
PY2 = ... # type: Any
WIN = ... # type: Any
unichr = ... # type: Any
text_type = ... # type: Any
string_types = ... # type: Any
integer_types = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
iteritems = ... # type: Any
iterlists = ... # type: Any
iterlistvalues = ... # type: Any
int_to_byte = ... # type: Any
iter_bytes = ... # type: Any
def fix_tuple_repr(obj): ...
def implements_iterator(cls): ...
def implements_to_string(cls): ...
def native_string_result(func): ...
def implements_bool(cls): ...
range_type = ... # type: Any
NativeStringIO = ... # type: Any
def make_literal_wrapper(reference): ...
def normalize_string_tuple(tup): ...
def try_coerce_native(s): ...
wsgi_get_bytes = ... # type: Any
def wsgi_decoding_dance(s, charset='', errors=''): ...
def wsgi_encoding_dance(s, charset='', errors=''): ...
def to_bytes(x, charset=..., errors=''): ...
def to_native(x, charset=..., errors=''): ...
def reraise(tp, value, tb=None): ...
imap = ... # type: Any
izip = ... # type: Any
ifilter = ... # type: Any
def to_unicode(x, charset=..., errors='', allow_none_charset=False): ...
mypy-0.470/typeshed/third_party/2/werkzeug/exceptions.pyi 0000644 0000000 0000000 00000007402 13035744274 022322 0 ustar root root # Stubs for werkzeug.exceptions (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class HTTPException(Exception):
code = ... # type: Any
description = ... # type: Any
response = ... # type: Any
def __init__(self, description=None, response=None): ...
@classmethod
def wrap(cls, exception, name=None): ...
@property
def name(self): ...
def get_description(self, environ=None): ...
def get_body(self, environ=None): ...
def get_headers(self, environ=None): ...
def get_response(self, environ=None): ...
def __call__(self, environ, start_response): ...
class BadRequest(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ClientDisconnected(BadRequest): ...
class SecurityError(BadRequest): ...
class BadHost(BadRequest): ...
class Unauthorized(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Forbidden(HTTPException):
code = ... # type: Any
description = ... # type: Any
class NotFound(HTTPException):
code = ... # type: Any
description = ... # type: Any
class MethodNotAllowed(HTTPException):
code = ... # type: Any
description = ... # type: Any
valid_methods = ... # type: Any
def __init__(self, valid_methods=None, description=None): ...
def get_headers(self, environ): ...
class NotAcceptable(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestTimeout(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Conflict(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Gone(HTTPException):
code = ... # type: Any
description = ... # type: Any
class LengthRequired(HTTPException):
code = ... # type: Any
description = ... # type: Any
class PreconditionFailed(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestEntityTooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestURITooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class UnsupportedMediaType(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestedRangeNotSatisfiable(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ExpectationFailed(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ImATeapot(HTTPException):
code = ... # type: Any
description = ... # type: Any
class UnprocessableEntity(HTTPException):
code = ... # type: Any
description = ... # type: Any
class PreconditionRequired(HTTPException):
code = ... # type: Any
description = ... # type: Any
class TooManyRequests(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestHeaderFieldsTooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class InternalServerError(HTTPException):
code = ... # type: Any
description = ... # type: Any
class NotImplemented(HTTPException):
code = ... # type: Any
description = ... # type: Any
class BadGateway(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ServiceUnavailable(HTTPException):
code = ... # type: Any
description = ... # type: Any
class GatewayTimeout(HTTPException):
code = ... # type: Any
description = ... # type: Any
class HTTPVersionNotSupported(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Aborter:
mapping = ... # type: Any
def __init__(self, mapping=None, extra=None): ...
def __call__(self, code, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/2/werkzeug/serving.pyi 0000644 0000000 0000000 00000006305 13035744274 021617 0 ustar root root # Stubs for werkzeug.serving (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from ._compat import PY2 as PY2
from SocketServer import ThreadingMixIn, ForkingMixIn
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
class _SslDummy:
def __getattr__(self, name): ...
ssl = ... # type: Any
LISTEN_QUEUE = ... # type: Any
can_open_by_fd = ... # type: Any
class WSGIRequestHandler(BaseHTTPRequestHandler):
@property
def server_version(self): ...
def make_environ(self): ...
environ = ... # type: Any
close_connection = ... # type: Any
def run_wsgi(self): ...
def handle(self): ...
def initiate_shutdown(self): ...
def connection_dropped(self, error, environ=None): ...
raw_requestline = ... # type: Any
def handle_one_request(self): ...
def send_response(self, code, message=None): ...
def version_string(self): ...
def address_string(self): ...
def log_request(self, code='', size=''): ...
def log_error(self, *args): ...
def log_message(self, format, *args): ...
def log(self, type, message, *args): ...
BaseRequestHandler = ... # type: Any
def generate_adhoc_ssl_pair(cn=None): ...
def make_ssl_devcert(base_path, host=None, cn=None): ...
def generate_adhoc_ssl_context(): ...
def load_ssl_context(cert_file, pkey_file=None, protocol=None): ...
class _SSLContext:
def __init__(self, protocol): ...
def load_cert_chain(self, certfile, keyfile=None, password=None): ...
def wrap_socket(self, sock, **kwargs): ...
def is_ssl_error(error=None): ...
def select_ip_version(host, port): ...
class BaseWSGIServer(HTTPServer):
multithread = ... # type: Any
multiprocess = ... # type: Any
request_queue_size = ... # type: Any
address_family = ... # type: Any
app = ... # type: Any
passthrough_errors = ... # type: Any
shutdown_signal = ... # type: Any
host = ... # type: Any
port = ... # type: Any
socket = ... # type: Any
server_address = ... # type: Any
ssl_context = ... # type: Any
def __init__(self, host, port, app, handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def log(self, type, message, *args): ...
def serve_forever(self): ...
def handle_error(self, request, client_address): ...
def get_request(self): ...
class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer):
multithread = ... # type: Any
class ForkingWSGIServer(ForkingMixIn, BaseWSGIServer):
multiprocess = ... # type: Any
max_children = ... # type: Any
def __init__(self, host, port, app, processes=40, handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def make_server(host=None, port=None, app=None, threaded=False, processes=1, request_handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def is_running_from_reloader(): ...
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): ...
def run_with_reloader(*args, **kwargs): ...
def main(): ...
mypy-0.470/typeshed/third_party/2/werkzeug/_reloader.pyi 0000644 0000000 0000000 00000001765 13035744274 022103 0 ustar root root # Stubs for werkzeug._reloader (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class ReloaderLoop:
name = ... # type: Any
extra_files = ... # type: Any
interval = ... # type: Any
def __init__(self, extra_files=None, interval=1): ...
def run(self): ...
def restart_with_reloader(self): ...
def trigger_reload(self, filename): ...
def log_reload(self, filename): ...
class StatReloaderLoop(ReloaderLoop):
name = ... # type: Any
def run(self): ...
class WatchdogReloaderLoop(ReloaderLoop):
observable_paths = ... # type: Any
name = ... # type: Any
observer_class = ... # type: Any
event_handler = ... # type: Any
should_reload = ... # type: Any
def __init__(self, *args, **kwargs): ...
def trigger_reload(self, filename): ...
def run(self): ...
reloader_loops = ... # type: Any
def run_with_reloader(main_func, extra_files=None, interval=1, reloader_type=''): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/ 0000755 0000000 0000000 00000000000 13044320557 021045 5 ustar root root mypy-0.470/typeshed/third_party/2/werkzeug/contrib/fixers.pyi 0000644 0000000 0000000 00000002504 13035744274 023077 0 ustar root root # Stubs for werkzeug.contrib.fixers (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class CGIRootFix:
app = ... # type: Any
app_root = ... # type: Any
def __init__(self, app, app_root=''): ...
def __call__(self, environ, start_response): ...
LighttpdCGIRootFix = ... # type: Any
class PathInfoFromRequestUriFix:
app = ... # type: Any
def __init__(self, app): ...
def __call__(self, environ, start_response): ...
class ProxyFix:
app = ... # type: Any
num_proxies = ... # type: Any
def __init__(self, app, num_proxies=1): ...
def get_remote_addr(self, forwarded_for): ...
def __call__(self, environ, start_response): ...
class HeaderRewriterFix:
app = ... # type: Any
remove_headers = ... # type: Any
add_headers = ... # type: Any
def __init__(self, app, remove_headers=None, add_headers=None): ...
def __call__(self, environ, start_response): ...
class InternetExplorerFix:
app = ... # type: Any
fix_vary = ... # type: Any
fix_attach = ... # type: Any
def __init__(self, app, fix_vary=True, fix_attach=True): ...
def fix_headers(self, environ, headers, status=None): ...
def run_fixed(self, environ, start_response): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/testtools.pyi 0000644 0000000 0000000 00000000524 13035744274 023637 0 ustar root root # Stubs for werkzeug.contrib.testtools (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import Response
class ContentAccessors:
def xml(self): ...
def lxml(self): ...
def json(self): ...
class TestResponse(Response, ContentAccessors): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/__init__.pyi 0000644 0000000 0000000 00000000166 13035744274 023340 0 ustar root root # Stubs for werkzeug.contrib (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/profiler.pyi 0000644 0000000 0000000 00000001140 13035744274 023414 0 ustar root root # Stubs for werkzeug.contrib.profiler (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
available = ... # type: Any
class MergeStream:
streams = ... # type: Any
def __init__(self, *streams): ...
def write(self, data): ...
class ProfilerMiddleware:
def __init__(self, app, stream=None, sort_by=..., restrictions=..., profile_dir=None): ...
def __call__(self, environ, start_response): ...
def make_action(app_factory, hostname='', port=5000, threaded=False, processes=1, stream=None, sort_by=..., restrictions=...): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/lint.pyi 0000644 0000000 0000000 00000002433 13035744274 022546 0 ustar root root # Stubs for werkzeug.contrib.lint (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class WSGIWarning(Warning): ...
class HTTPWarning(Warning): ...
def check_string(context, obj, stacklevel=3): ...
class InputStream:
def __init__(self, stream): ...
def read(self, *args): ...
def readline(self, *args): ...
def __iter__(self): ...
def close(self): ...
class ErrorStream:
def __init__(self, stream): ...
def write(self, s): ...
def flush(self): ...
def writelines(self, seq): ...
def close(self): ...
class GuardedWrite:
def __init__(self, write, chunks): ...
def __call__(self, s): ...
class GuardedIterator:
closed = ... # type: Any
headers_set = ... # type: Any
chunks = ... # type: Any
def __init__(self, iterator, headers_set, chunks): ...
def __iter__(self): ...
def next(self): ...
def close(self): ...
def __del__(self): ...
class LintMiddleware:
app = ... # type: Any
def __init__(self, app): ...
def check_environ(self, environ): ...
def check_start_response(self, status, headers, exc_info): ...
def check_headers(self, headers): ...
def check_iterator(self, app_iter): ...
def __call__(self, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/atom.pyi 0000644 0000000 0000000 00000003140 13035744274 022534 0 ustar root root # Stubs for werkzeug.contrib.atom (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
XHTML_NAMESPACE = ... # type: Any
def format_iso8601(obj): ...
class AtomFeed:
default_generator = ... # type: Any
title = ... # type: Any
title_type = ... # type: Any
url = ... # type: Any
feed_url = ... # type: Any
id = ... # type: Any
updated = ... # type: Any
author = ... # type: Any
icon = ... # type: Any
logo = ... # type: Any
rights = ... # type: Any
rights_type = ... # type: Any
subtitle = ... # type: Any
subtitle_type = ... # type: Any
generator = ... # type: Any
links = ... # type: Any
entries = ... # type: Any
def __init__(self, title=None, entries=None, **kwargs): ...
def add(self, *args, **kwargs): ...
def generate(self): ...
def to_string(self): ...
def get_response(self): ...
def __call__(self, environ, start_response): ...
class FeedEntry:
title = ... # type: Any
title_type = ... # type: Any
content = ... # type: Any
content_type = ... # type: Any
url = ... # type: Any
id = ... # type: Any
updated = ... # type: Any
summary = ... # type: Any
summary_type = ... # type: Any
author = ... # type: Any
published = ... # type: Any
rights = ... # type: Any
links = ... # type: Any
categories = ... # type: Any
xml_base = ... # type: Any
def __init__(self, title=None, content=None, feed_url=None, **kwargs): ...
def generate(self): ...
def to_string(self): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/limiter.pyi 0000644 0000000 0000000 00000000533 13035744274 023244 0 ustar root root # Stubs for werkzeug.contrib.limiter (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class StreamLimitMiddleware:
app = ... # type: Any
maximum_size = ... # type: Any
def __init__(self, app, maximum_size=...): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/cache.pyi 0000644 0000000 0000000 00000005241 13035744274 022643 0 ustar root root # Stubs for werkzeug.contrib.cache (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class BaseCache:
default_timeout = ... # type: Any
def __init__(self, default_timeout=300): ...
def get(self, key): ...
def delete(self, key): ...
def get_many(self, *keys): ...
def get_dict(self, *keys): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def set_many(self, mapping, timeout=None): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
class NullCache(BaseCache): ...
class SimpleCache(BaseCache):
clear = ... # type: Any
def __init__(self, threshold=500, default_timeout=300): ...
def get(self, key): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def delete(self, key): ...
def has(self, key): ...
class MemcachedCache(BaseCache):
key_prefix = ... # type: Any
def __init__(self, servers=None, default_timeout=300, key_prefix=None): ...
def get(self, key): ...
def get_dict(self, *keys): ...
def add(self, key, value, timeout=None): ...
def set(self, key, value, timeout=None): ...
def get_many(self, *keys): ...
def set_many(self, mapping, timeout=None): ...
def delete(self, key): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
def import_preferred_memcache_lib(self, servers): ...
GAEMemcachedCache = ... # type: Any
class RedisCache(BaseCache):
key_prefix = ... # type: Any
def __init__(self, host='', port=6379, password=None, db=0, default_timeout=300, key_prefix=None, **kwargs): ...
def dump_object(self, value): ...
def load_object(self, value): ...
def get(self, key): ...
def get_many(self, *keys): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def set_many(self, mapping, timeout=None): ...
def delete(self, key): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
class FileSystemCache(BaseCache):
def __init__(self, cache_dir, threshold=500, default_timeout=300, mode=384): ...
def clear(self): ...
def get(self, key): ...
def add(self, key, value, timeout=None): ...
def set(self, key, value, timeout=None): ...
def delete(self, key): ...
def has(self, key): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/wrappers.pyi 0000644 0000000 0000000 00000001457 13035744274 023450 0 ustar root root # Stubs for werkzeug.contrib.wrappers (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def is_known_charset(charset): ...
class JSONRequestMixin:
def json(self): ...
class ProtobufRequestMixin:
protobuf_check_initialization = ... # type: Any
def parse_protobuf(self, proto_type): ...
class RoutingArgsRequestMixin:
routing_args = ... # type: Any
routing_vars = ... # type: Any
class ReverseSlashBehaviorRequestMixin:
def path(self): ...
def script_root(self): ...
class DynamicCharsetRequestMixin:
default_charset = ... # type: Any
def unknown_charset(self, charset): ...
def charset(self): ...
class DynamicCharsetResponseMixin:
default_charset = ... # type: Any
charset = ... # type: Any
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/sessions.pyi 0000644 0000000 0000000 00000003745 13035744274 023455 0 ustar root root # Stubs for werkzeug.contrib.sessions (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.datastructures import CallbackDict
def generate_key(salt=None): ...
class ModificationTrackingDict(CallbackDict):
modified = ... # type: Any
def __init__(self, *args, **kwargs): ...
def copy(self): ...
def __copy__(self): ...
class Session(ModificationTrackingDict):
sid = ... # type: Any
new = ... # type: Any
def __init__(self, data, sid, new=False): ...
@property
def should_save(self): ...
class SessionStore:
session_class = ... # type: Any
def __init__(self, session_class=None): ...
def is_valid_key(self, key): ...
def generate_key(self, salt=None): ...
def new(self): ...
def save(self, session): ...
def save_if_modified(self, session): ...
def delete(self, session): ...
def get(self, sid): ...
class FilesystemSessionStore(SessionStore):
path = ... # type: Any
filename_template = ... # type: Any
renew_missing = ... # type: Any
mode = ... # type: Any
def __init__(self, path=None, filename_template='', session_class=None, renew_missing=False, mode=420): ...
def get_session_filename(self, sid): ...
def save(self, session): ...
def delete(self, session): ...
def get(self, sid): ...
def list(self): ...
class SessionMiddleware:
app = ... # type: Any
store = ... # type: Any
cookie_name = ... # type: Any
cookie_age = ... # type: Any
cookie_expires = ... # type: Any
cookie_path = ... # type: Any
cookie_domain = ... # type: Any
cookie_secure = ... # type: Any
cookie_httponly = ... # type: Any
environ_key = ... # type: Any
def __init__(self, app, store, cookie_name='', cookie_age=None, cookie_expires=None, cookie_path='', cookie_domain=None, cookie_secure=None, cookie_httponly=False, environ_key=''): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/iterio.pyi 0000644 0000000 0000000 00000002244 13035744274 023073 0 ustar root root # Stubs for werkzeug.contrib.iterio (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
greenlet = ... # type: Any
class IterIO:
def __new__(cls, obj, sentinel=''): ...
def __iter__(self): ...
def tell(self): ...
def isatty(self): ...
def seek(self, pos, mode=0): ...
def truncate(self, size=None): ...
def write(self, s): ...
def writelines(self, list): ...
def read(self, n=-1): ...
def readlines(self, sizehint=0): ...
def readline(self, length=None): ...
def flush(self): ...
def __next__(self): ...
class IterI(IterIO):
def __new__(cls, func, sentinel=''): ...
closed = ... # type: Any
def close(self): ...
def write(self, s): ...
def writelines(self, list): ...
def flush(self): ...
class IterO(IterIO):
sentinel = ... # type: Any
closed = ... # type: Any
pos = ... # type: Any
def __new__(cls, gen, sentinel=''): ...
def __iter__(self): ...
def close(self): ...
def seek(self, pos, mode=0): ...
def read(self, n=-1): ...
def readline(self, length=None): ...
def readlines(self, sizehint=0): ...
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/jsrouting.pyi 0000644 0000000 0000000 00000000674 13035744274 023631 0 ustar root root # Stubs for werkzeug.contrib.jsrouting (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def dumps(*args): ...
def render_template(name_parts, rules, converters): ...
def generate_map(map, name=''): ...
def generate_adapter(adapter, name='', map_name=''): ...
def js_to_url_function(converter): ...
def NumberConverter_js_to_url(conv): ...
js_to_url_functions = ... # type: Any
mypy-0.470/typeshed/third_party/2/werkzeug/contrib/securecookie.pyi 0000644 0000000 0000000 00000002127 13035744274 024260 0 ustar root root # Stubs for werkzeug.contrib.securecookie (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from hmac import new as hmac
from hashlib import sha1 as _default_hash
from werkzeug.contrib.sessions import ModificationTrackingDict
class UnquoteError(Exception): ...
class SecureCookie(ModificationTrackingDict):
hash_method = ... # type: Any
serialization_method = ... # type: Any
quote_base64 = ... # type: Any
secret_key = ... # type: Any
new = ... # type: Any
def __init__(self, data=None, secret_key=None, new=True): ...
@property
def should_save(self): ...
@classmethod
def quote(cls, value): ...
@classmethod
def unquote(cls, value): ...
def serialize(self, expires=None): ...
@classmethod
def unserialize(cls, string, secret_key): ...
@classmethod
def load_cookie(cls, request, key='', secret_key=None): ...
def save_cookie(self, response, key='', expires=None, session_expires=None, max_age=None, path='', domain=None, secure=None, httponly=False, force=False): ...
mypy-0.470/typeshed/third_party/2/werkzeug/filesystem.pyi 0000644 0000000 0000000 00000000461 13035744274 022323 0 ustar root root # Stubs for werkzeug.filesystem (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
has_likely_buggy_unicode_filesystem = ... # type: Any
class BrokenFilesystemWarning(RuntimeWarning, UnicodeWarning): ...
def get_filesystem_encoding(): ...
mypy-0.470/typeshed/third_party/2/werkzeug/datastructures.pyi 0000644 0000000 0000000 00000030617 13035744274 023222 0 ustar root root # Stubs for werkzeug.datastructures (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from collections import Container, Iterable, Mapping, MutableSet
def is_immutable(self): ...
def iter_multi_items(mapping): ...
def native_itermethods(names): ...
class ImmutableListMixin:
def __hash__(self): ...
def __reduce_ex__(self, protocol): ...
def __delitem__(self, key): ...
def __delslice__(self, i, j): ...
def __iadd__(self, other): ...
__imul__ = ... # type: Any
def __setitem__(self, key, value): ...
def __setslice__(self, i, j, value): ...
def append(self, item): ...
remove = ... # type: Any
def extend(self, iterable): ...
def insert(self, pos, value): ...
def pop(self, index=-1): ...
def reverse(self): ...
def sort(self, cmp=None, key=None, reverse=None): ...
class ImmutableList(ImmutableListMixin, list): ...
class ImmutableDictMixin:
@classmethod
def fromkeys(cls, *args, **kwargs): ...
def __reduce_ex__(self, protocol): ...
def __hash__(self): ...
def setdefault(self, key, default=None): ...
def update(self, *args, **kwargs): ...
def pop(self, key, default=None): ...
def popitem(self): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def clear(self): ...
class ImmutableMultiDictMixin(ImmutableDictMixin):
def __reduce_ex__(self, protocol): ...
def add(self, key, value): ...
def popitemlist(self): ...
def poplist(self, key): ...
def setlist(self, key, new_list): ...
def setlistdefault(self, key, default_list=None): ...
class UpdateDictMixin:
on_update = ... # type: Any
def calls_update(name): ...
def setdefault(self, key, default=None): ...
def pop(self, key, default=...): ...
__setitem__ = ... # type: Any
__delitem__ = ... # type: Any
clear = ... # type: Any
popitem = ... # type: Any
update = ... # type: Any
class TypeConversionDict(dict):
def get(self, key, default=None, type=None): ...
class ImmutableTypeConversionDict(ImmutableDictMixin, TypeConversionDict):
def copy(self): ...
def __copy__(self): ...
class ViewItems:
def __init__(self, multi_dict, method, repr_name, *a, **kw): ...
def __iter__(self): ...
class MultiDict(TypeConversionDict):
def __init__(self, mapping=None): ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def add(self, key, value): ...
def getlist(self, key, type=None): ...
def setlist(self, key, new_list): ...
def setdefault(self, key, default=None): ...
def setlistdefault(self, key, default_list=None): ...
def items(self, multi=False): ...
def lists(self): ...
def keys(self): ...
__iter__ = ... # type: Any
def values(self): ...
def listvalues(self): ...
def copy(self): ...
def deepcopy(self, memo=None): ...
def to_dict(self, flat=True): ...
def update(self, other_dict): ...
def pop(self, key, default=...): ...
def popitem(self): ...
def poplist(self, key): ...
def popitemlist(self): ...
def __copy__(self): ...
def __deepcopy__(self, memo): ...
class _omd_bucket:
prev = ... # type: Any
key = ... # type: Any
value = ... # type: Any
next = ... # type: Any
def __init__(self, omd, key, value): ...
def unlink(self, omd): ...
class OrderedMultiDict(MultiDict):
def __init__(self, mapping=None): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def __reduce_ex__(self, protocol): ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def keys(self): ...
__iter__ = ... # type: Any
def values(self): ...
def items(self, multi=False): ...
def lists(self): ...
def listvalues(self): ...
def add(self, key, value): ...
def getlist(self, key, type=None): ...
def setlist(self, key, new_list): ...
def setlistdefault(self, key, default_list=None): ...
def update(self, mapping): ...
def poplist(self, key): ...
def pop(self, key, default=...): ...
def popitem(self): ...
def popitemlist(self): ...
class Headers(Mapping):
def __init__(self, defaults=None): ...
def __getitem__(self, key, _get_mode=False): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def get(self, key, default=None, type=None, as_bytes=False): ...
def getlist(self, key, type=None, as_bytes=False): ...
def get_all(self, name): ...
def items(self, lower=False): ...
def keys(self, lower=False): ...
def values(self): ...
def extend(self, iterable): ...
def __delitem__(self, key, _index_operation=True): ...
def remove(self, key): ...
def pop(self, **kwargs): ...
def popitem(self): ...
def __contains__(self, key): ...
has_key = ... # type: Any
def __iter__(self): ...
def __len__(self): ...
def add(self, _key, _value, **kw): ...
def add_header(self, _key, _value, **_kw): ...
def clear(self): ...
def set(self, _key, _value, **kw): ...
def setdefault(self, key, value): ...
def __setitem__(self, key, value): ...
def to_list(self, charset=''): ...
def to_wsgi_list(self): ...
def copy(self): ...
def __copy__(self): ...
class ImmutableHeadersMixin:
def __delitem__(self, key, _index_operation=True): ... # FIXME: This is invalid but works around https://github.com/pallets/werkzeug/issues/1051
def __setitem__(self, key, value): ...
set = ... # type: Any
def add(self, *args, **kwargs): ...
remove = ... # type: Any
add_header = ... # type: Any
def extend(self, iterable): ...
def insert(self, pos, value): ...
def pop(self, **kwargs): ...
def popitem(self): ...
def setdefault(self, key, default): ...
class EnvironHeaders(ImmutableHeadersMixin, Headers):
environ = ... # type: Any
def __init__(self, environ): ...
def __eq__(self, other): ...
def __getitem__(self, key, _get_mode=False): ...
def __len__(self): ...
def __iter__(self): ...
def copy(self): ...
class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):
def __reduce_ex__(self, protocol): ...
dicts = ... # type: Any
def __init__(self, dicts=None): ...
@classmethod
def fromkeys(cls): ...
def __getitem__(self, key): ...
def get(self, key, default=None, type=None): ...
def getlist(self, key, type=None): ...
def keys(self): ...
__iter__ = ... # type: Any
def items(self, multi=False): ...
def values(self): ...
def lists(self): ...
def listvalues(self): ...
def copy(self): ...
def to_dict(self, flat=True): ...
def __len__(self): ...
def __contains__(self, key): ...
has_key = ... # type: Any
class FileMultiDict(MultiDict):
def add_file(self, name, file, filename=None, content_type=None): ...
class ImmutableDict(ImmutableDictMixin, dict):
def copy(self): ...
def __copy__(self): ...
class ImmutableMultiDict(ImmutableMultiDictMixin, MultiDict):
def copy(self): ...
def __copy__(self): ...
class ImmutableOrderedMultiDict(ImmutableMultiDictMixin, OrderedMultiDict):
def copy(self): ...
def __copy__(self): ...
class Accept(ImmutableList):
provided = ... # type: Any
def __init__(self, values=...): ...
def __getitem__(self, key): ...
def quality(self, key): ...
def __contains__(self, value): ...
def index(self, key): ...
def find(self, key): ...
def values(self): ...
def to_header(self): ...
def best_match(self, matches, default=None): ...
@property
def best(self): ...
class MIMEAccept(Accept):
@property
def accept_html(self): ...
@property
def accept_xhtml(self): ...
@property
def accept_json(self): ...
class LanguageAccept(Accept): ...
class CharsetAccept(Accept): ...
def cache_property(key, empty, type): ...
class _CacheControl(UpdateDictMixin, dict):
no_cache = ... # type: Any
no_store = ... # type: Any
max_age = ... # type: Any
no_transform = ... # type: Any
on_update = ... # type: Any
provided = ... # type: Any
def __init__(self, values=..., on_update=None): ...
def to_header(self): ...
class RequestCacheControl(ImmutableDictMixin, _CacheControl):
max_stale = ... # type: Any
min_fresh = ... # type: Any
no_transform = ... # type: Any
only_if_cached = ... # type: Any
class ResponseCacheControl(_CacheControl):
public = ... # type: Any
private = ... # type: Any
must_revalidate = ... # type: Any
proxy_revalidate = ... # type: Any
s_maxage = ... # type: Any
class CallbackDict(UpdateDictMixin, dict):
on_update = ... # type: Any
def __init__(self, initial=None, on_update=None): ...
class HeaderSet(MutableSet):
on_update = ... # type: Any
def __init__(self, headers=None, on_update=None): ...
def add(self, header): ...
def remove(self, header): ...
def update(self, iterable): ...
def discard(self, header): ...
def find(self, header): ...
def index(self, header): ...
def clear(self): ...
def as_set(self, preserve_casing=False): ...
def to_header(self): ...
def __getitem__(self, idx): ...
def __delitem__(self, idx): ...
def __setitem__(self, idx, value): ...
def __contains__(self, header): ...
def __len__(self): ...
def __iter__(self): ...
def __nonzero__(self): ...
class ETags(Container, Iterable):
star_tag = ... # type: Any
def __init__(self, strong_etags=None, weak_etags=None, star_tag=False): ...
def as_set(self, include_weak=False): ...
def is_weak(self, etag): ...
def contains_weak(self, etag): ...
def contains(self, etag): ...
def contains_raw(self, etag): ...
def to_header(self): ...
def __call__(self, etag=None, data=None, include_weak=False): ...
def __bool__(self): ...
__nonzero__ = ... # type: Any
def __iter__(self): ...
def __contains__(self, etag): ...
class IfRange:
etag = ... # type: Any
date = ... # type: Any
def __init__(self, etag=None, date=None): ...
def to_header(self): ...
class Range:
units = ... # type: Any
ranges = ... # type: Any
def __init__(self, units, ranges): ...
def range_for_length(self, length): ...
def make_content_range(self, length): ...
def to_header(self): ...
def to_content_range_header(self, length): ...
class ContentRange:
on_update = ... # type: Any
def __init__(self, units, start, stop, length=None, on_update=None): ...
units = ... # type: Any
start = ... # type: Any
stop = ... # type: Any
length = ... # type: Any
def set(self, start, stop, length=None, units=''): ...
def unset(self): ...
def to_header(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
class Authorization(ImmutableDictMixin, dict):
type = ... # type: Any
def __init__(self, auth_type, data=None): ...
username = ... # type: Any
password = ... # type: Any
realm = ... # type: Any
nonce = ... # type: Any
uri = ... # type: Any
nc = ... # type: Any
cnonce = ... # type: Any
response = ... # type: Any
opaque = ... # type: Any
@property
def qop(self): ...
class WWWAuthenticate(UpdateDictMixin, dict):
on_update = ... # type: Any
def __init__(self, auth_type=None, values=None, on_update=None): ...
def set_basic(self, realm=''): ...
def set_digest(self, realm, nonce, qop=..., opaque=None, algorithm=None, stale=False): ...
def to_header(self): ...
@staticmethod
def auth_property(name, doc=None): ...
type = ... # type: Any
realm = ... # type: Any
domain = ... # type: Any
nonce = ... # type: Any
opaque = ... # type: Any
algorithm = ... # type: Any
qop = ... # type: Any
stale = ... # type: Any
class FileStorage:
name = ... # type: Any
stream = ... # type: Any
filename = ... # type: Any
headers = ... # type: Any
def __init__(self, stream=None, filename=None, name=None, content_type=None, content_length=None, headers=None): ...
@property
def content_type(self): ...
@property
def content_length(self): ...
@property
def mimetype(self): ...
@property
def mimetype_params(self): ...
def save(self, dst, buffer_size=16384): ...
def close(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
def __getattr__(self, name): ...
def __iter__(self): ...
mypy-0.470/typeshed/third_party/2/werkzeug/useragents.pyi 0000644 0000000 0000000 00000000751 13035744274 022321 0 ustar root root # Stubs for werkzeug.useragents (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class UserAgentParser:
platforms = ... # type: Any
browsers = ... # type: Any
def __init__(self): ...
def __call__(self, user_agent): ...
class UserAgent:
string = ... # type: Any
def __init__(self, environ_or_string): ...
def to_header(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
mypy-0.470/typeshed/third_party/2/fb303/ 0000755 0000000 0000000 00000000000 13044320557 016357 5 ustar root root mypy-0.470/typeshed/third_party/2/fb303/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020626 0 ustar root root mypy-0.470/typeshed/third_party/2/fb303/FacebookService.pyi 0000644 0000000 0000000 00000022177 13035744274 022153 0 ustar root root # Stubs for fb303.FacebookService (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from thrift.Thrift import TProcessor
fastbinary = ... # type: Any
class Iface:
def getName(self): ...
def getVersion(self): ...
def getStatus(self): ...
def getStatusDetails(self): ...
def getCounters(self): ...
def getCounter(self, key): ...
def setOption(self, key, value): ...
def getOption(self, key): ...
def getOptions(self): ...
def getCpuProfile(self, profileDurationInSec): ...
def aliveSince(self): ...
def reinitialize(self): ...
def shutdown(self): ...
class Client(Iface):
def __init__(self, iprot, oprot=...) -> None: ...
def getName(self): ...
def send_getName(self): ...
def recv_getName(self): ...
def getVersion(self): ...
def send_getVersion(self): ...
def recv_getVersion(self): ...
def getStatus(self): ...
def send_getStatus(self): ...
def recv_getStatus(self): ...
def getStatusDetails(self): ...
def send_getStatusDetails(self): ...
def recv_getStatusDetails(self): ...
def getCounters(self): ...
def send_getCounters(self): ...
def recv_getCounters(self): ...
def getCounter(self, key): ...
def send_getCounter(self, key): ...
def recv_getCounter(self): ...
def setOption(self, key, value): ...
def send_setOption(self, key, value): ...
def recv_setOption(self): ...
def getOption(self, key): ...
def send_getOption(self, key): ...
def recv_getOption(self): ...
def getOptions(self): ...
def send_getOptions(self): ...
def recv_getOptions(self): ...
def getCpuProfile(self, profileDurationInSec): ...
def send_getCpuProfile(self, profileDurationInSec): ...
def recv_getCpuProfile(self): ...
def aliveSince(self): ...
def send_aliveSince(self): ...
def recv_aliveSince(self): ...
def reinitialize(self): ...
def send_reinitialize(self): ...
def shutdown(self): ...
def send_shutdown(self): ...
class Processor(Iface, TProcessor):
def __init__(self, handler) -> None: ...
def process(self, iprot, oprot): ...
def process_getName(self, seqid, iprot, oprot): ...
def process_getVersion(self, seqid, iprot, oprot): ...
def process_getStatus(self, seqid, iprot, oprot): ...
def process_getStatusDetails(self, seqid, iprot, oprot): ...
def process_getCounters(self, seqid, iprot, oprot): ...
def process_getCounter(self, seqid, iprot, oprot): ...
def process_setOption(self, seqid, iprot, oprot): ...
def process_getOption(self, seqid, iprot, oprot): ...
def process_getOptions(self, seqid, iprot, oprot): ...
def process_getCpuProfile(self, seqid, iprot, oprot): ...
def process_aliveSince(self, seqid, iprot, oprot): ...
def process_reinitialize(self, seqid, iprot, oprot): ...
def process_shutdown(self, seqid, iprot, oprot): ...
class getName_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getName_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getVersion_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getVersion_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getStatus_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getStatus_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getStatusDetails_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getStatusDetails_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCounters_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCounters_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCounter_args:
thrift_spec = ... # type: Any
key = ... # type: Any
def __init__(self, key=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCounter_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class setOption_args:
thrift_spec = ... # type: Any
key = ... # type: Any
value = ... # type: Any
def __init__(self, key=..., value=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class setOption_result:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getOption_args:
thrift_spec = ... # type: Any
key = ... # type: Any
def __init__(self, key=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getOption_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getOptions_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getOptions_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCpuProfile_args:
thrift_spec = ... # type: Any
profileDurationInSec = ... # type: Any
def __init__(self, profileDurationInSec=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class getCpuProfile_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class aliveSince_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class aliveSince_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class reinitialize_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class shutdown_args:
thrift_spec = ... # type: Any
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
mypy-0.470/typeshed/third_party/2/OpenSSL/ 0000755 0000000 0000000 00000000000 13044320557 017025 5 ustar root root mypy-0.470/typeshed/third_party/2/OpenSSL/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021274 0 ustar root root mypy-0.470/typeshed/third_party/2/OpenSSL/crypto.pyi 0000644 0000000 0000000 00000000261 13044257024 021065 0 ustar root root class X509:
...
def sign(key: str, data: str, digest: str) -> str: ...
def verify(certificate: X509, signature: str, data: str, digest: str) -> None:
raise Exception()
mypy-0.470/typeshed/third_party/2/pycurl.pyi 0000644 0000000 0000000 00000030553 13035744274 017617 0 ustar root root # TODO(MichalPokorny): more precise types
from typing import Any, Tuple, Optional
GLOBAL_SSL = ... # type: int
GLOBAL_WIN32 = ... # type: int
GLOBAL_ALL = ... # type: int
GLOBAL_NOTHING = ... # type: int
GLOBAL_DEFAULT = ... # type: int
def global_init(option: int) -> None: ...
def global_cleanup() -> None: ...
version = ... # type: str
def version_info() -> Tuple[int, str, int, str, int, str,
int, str, tuple, Any, int, Any]: ...
class error(Exception):
pass
class Curl(object):
def close(self) -> None: ...
def setopt(self, option: int, value: Any) -> None: ...
def perform(self) -> None: ...
def getinfo(self, info: Any) -> Any: ...
def reset(self) -> None: ...
def unsetopt(self, option: int) -> Any: ...
def pause(self, bitmask: Any) -> Any: ...
def errstr(self) -> str: ...
# TODO(MichalPokorny): wat?
USERPWD = ... # type: int
class CurlMulti(object):
def close(self) -> None: ...
def add_handle(self, obj: Curl) -> None: ...
def remove_handle(self, obj: Curl) -> None: ...
def perform(self) -> Tuple[Any, int]: ...
def fdset(self) -> tuple: ...
def select(self, timeout: float = ...) -> int: ...
def info_read(self, max_objects: int) -> tuple: ...
class CurlShare(object):
def close(self) -> None: ...
def setopt(self, option: int, value: Any) -> Any: ...
ADDRESS_SCOPE = ... # type: int
APPCONNECT_TIME = ... # type: int
AUTOREFERER = ... # type: int
BUFFERSIZE = ... # type: int
CAINFO = ... # type: int
CAPATH = ... # type: int
COMPILE_LIBCURL_VERSION_NUM = ... # type: int
COMPILE_PY_VERSION_HEX = ... # type: int
CONNECTTIMEOUT = ... # type: int
CONNECTTIMEOUT_MS = ... # type: int
CONNECT_ONLY = ... # type: int
CONNECT_TIME = ... # type: int
CONTENT_LENGTH_DOWNLOAD = ... # type: int
CONTENT_LENGTH_UPLOAD = ... # type: int
CONTENT_TYPE = ... # type: int
COOKIE = ... # type: int
COOKIEFILE = ... # type: int
COOKIEJAR = ... # type: int
COOKIELIST = ... # type: int
COPYPOSTFIELDS = ... # type: int
CRLF = ... # type: int
CRLFILE = ... # type: int
CSELECT_ERR = ... # type: int
CSELECT_IN = ... # type: int
CSELECT_OUT = ... # type: int
CURL_HTTP_VERSION_1_0 = ... # type: int
CURL_HTTP_VERSION_1_1 = ... # type: int
CURL_HTTP_VERSION_LAST = ... # type: int
CURL_HTTP_VERSION_NONE = ... # type: int
CUSTOMREQUEST = ... # type: int
DEBUGFUNCTION = ... # type: int
DNS_CACHE_TIMEOUT = ... # type: int
DNS_USE_GLOBAL_CACHE = ... # type: int
EFFECTIVE_URL = ... # type: int
EGDSOCKET = ... # type: int
ENCODING = ... # type: int
FAILONERROR = ... # type: int
FILE = ... # type: int
FOLLOWLOCATION = ... # type: int
FORBID_REUSE = ... # type: int
FORM_CONTENTS = ... # type: int
FORM_CONTENTTYPE = ... # type: int
FORM_FILE = ... # type: int
FORM_FILENAME = ... # type: int
FRESH_CONNECT = ... # type: int
FTPAPPEND = ... # type: int
FTPAUTH_DEFAULT = ... # type: int
FTPAUTH_SSL = ... # type: int
FTPAUTH_TLS = ... # type: int
FTPLISTONLY = ... # type: int
FTPMETHOD_DEFAULT = ... # type: int
FTPMETHOD_MULTICWD = ... # type: int
FTPMETHOD_NOCWD = ... # type: int
FTPMETHOD_SINGLECWD = ... # type: int
FTPPORT = ... # type: int
FTPSSLAUTH = ... # type: int
FTPSSL_ALL = ... # type: int
FTPSSL_CONTROL = ... # type: int
FTPSSL_NONE = ... # type: int
FTPSSL_TRY = ... # type: int
FTP_ACCOUNT = ... # type: int
FTP_ALTERNATIVE_TO_USER = ... # type: int
FTP_CREATE_MISSING_DIRS = ... # type: int
FTP_ENTRY_PATH = ... # type: int
FTP_FILEMETHOD = ... # type: int
FTP_RESPONSE_TIMEOUT = ... # type: int
FTP_SKIP_PASV_IP = ... # type: int
FTP_SSL = ... # type: int
FTP_SSL_CCC = ... # type: int
FTP_USE_EPRT = ... # type: int
FTP_USE_EPSV = ... # type: int
HEADER = ... # type: int
HEADERFUNCTION = ... # type: int
HEADER_SIZE = ... # type: int
HTTP200ALIASES = ... # type: int
HTTPAUTH = ... # type: int
HTTPAUTH_ANY = ... # type: int
HTTPAUTH_ANYSAFE = ... # type: int
HTTPAUTH_AVAIL = ... # type: int
HTTPAUTH_BASIC = ... # type: int
HTTPAUTH_DIGEST = ... # type: int
HTTPAUTH_GSSNEGOTIATE = ... # type: int
HTTPAUTH_NONE = ... # type: int
HTTPAUTH_NTLM = ... # type: int
HTTPGET = ... # type: int
HTTPHEADER = ... # type: int
HTTPPOST = ... # type: int
HTTPPROXYTUNNEL = ... # type: int
HTTP_CODE = ... # type: int
HTTP_CONNECTCODE = ... # type: int
HTTP_CONTENT_DECODING = ... # type: int
HTTP_TRANSFER_DECODING = ... # type: int
HTTP_VERSION = ... # type: int
IGNORE_CONTENT_LENGTH = ... # type: int
INFILE = ... # type: int
INFILESIZE = ... # type: int
INFILESIZE_LARGE = ... # type: int
INFOTYPE_DATA_IN = ... # type: int
INFOTYPE_DATA_OUT = ... # type: int
INFOTYPE_HEADER_IN = ... # type: int
INFOTYPE_HEADER_OUT = ... # type: int
INFOTYPE_SSL_DATA_IN = ... # type: int
INFOTYPE_SSL_DATA_OUT = ... # type: int
INFOTYPE_TEXT = ... # type: int
INFO_COOKIELIST = ... # type: int
INFO_FILETIME = ... # type: int
INTERFACE = ... # type: int
IOCMD_NOP = ... # type: int
IOCMD_RESTARTREAD = ... # type: int
IOCTLDATA = ... # type: int
IOCTLFUNCTION = ... # type: int
IOE_FAILRESTART = ... # type: int
IOE_OK = ... # type: int
IOE_UNKNOWNCMD = ... # type: int
IPRESOLVE = ... # type: int
IPRESOLVE_V4 = ... # type: int
IPRESOLVE_V6 = ... # type: int
IPRESOLVE_WHATEVER = ... # type: int
ISSUERCERT = ... # type: int
KRB4LEVEL = ... # type: int
LASTSOCKET = ... # type: int
LOCALPORT = ... # type: int
LOCALPORTRANGE = ... # type: int
LOCK_DATA_COOKIE = ... # type: int
LOCK_DATA_DNS = ... # type: int
LOW_SPEED_LIMIT = ... # type: int
LOW_SPEED_TIME = ... # type: int
MAXCONNECTS = ... # type: int
MAXFILESIZE = ... # type: int
MAXFILESIZE_LARGE = ... # type: int
MAXREDIRS = ... # type: int
MAX_RECV_SPEED_LARGE = ... # type: int
MAX_SEND_SPEED_LARGE = ... # type: int
NAMELOOKUP_TIME = ... # type: int
NETRC = ... # type: int
NETRC_FILE = ... # type: int
NETRC_IGNORED = ... # type: int
NETRC_OPTIONAL = ... # type: int
NETRC_REQUIRED = ... # type: int
NEW_DIRECTORY_PERMS = ... # type: int
NEW_FILE_PERMS = ... # type: int
NOBODY = ... # type: int
NOPROGRESS = ... # type: int
NOSIGNAL = ... # type: int
NUM_CONNECTS = ... # type: int
OPENSOCKETFUNCTION = ... # type: int
OPT_FILETIME = ... # type: int
OS_ERRNO = ... # type: int
POLL_IN = ... # type: int
POLL_INOUT = ... # type: int
POLL_NONE = ... # type: int
POLL_OUT = ... # type: int
POLL_REMOVE = ... # type: int
PORT = ... # type: int
POST = ... # type: int
POST301 = ... # type: int
POSTFIELDS = ... # type: int
POSTFIELDSIZE = ... # type: int
POSTFIELDSIZE_LARGE = ... # type: int
POSTQUOTE = ... # type: int
PREQUOTE = ... # type: int
PRETRANSFER_TIME = ... # type: int
PRIMARY_IP = ... # type: int
PROGRESSFUNCTION = ... # type: int
PROXY = ... # type: int
PROXYAUTH = ... # type: int
PROXYAUTH_AVAIL = ... # type: int
PROXYPORT = ... # type: int
PROXYTYPE = ... # type: int
PROXYTYPE_HTTP = ... # type: int
PROXYTYPE_SOCKS4 = ... # type: int
PROXYTYPE_SOCKS5 = ... # type: int
PROXYUSERPWD = ... # type: int
PROXY_TRANSFER_MODE = ... # type: int
PUT = ... # type: int
QUOTE = ... # type: int
RANDOM_FILE = ... # type: int
RANGE = ... # type: int
READDATA = ... # type: int
READFUNCTION = ... # type: int
READFUNC_ABORT = ... # type: int
REDIRECT_COUNT = ... # type: int
REDIRECT_TIME = ... # type: int
REDIRECT_URL = ... # type: int
REFERER = ... # type: int
REQUEST_SIZE = ... # type: int
RESPONSE_CODE = ... # type: int
RESUME_FROM = ... # type: int
RESUME_FROM_LARGE = ... # type: int
SHARE = ... # type: int
SH_SHARE = ... # type: int
SH_UNSHARE = ... # type: int
SIZE_DOWNLOAD = ... # type: int
SIZE_UPLOAD = ... # type: int
SOCKET_TIMEOUT = ... # type: int
SPEED_DOWNLOAD = ... # type: int
SPEED_UPLOAD = ... # type: int
SSH_AUTH_ANY = ... # type: int
SSH_AUTH_DEFAULT = ... # type: int
SSH_AUTH_HOST = ... # type: int
SSH_AUTH_KEYBOARD = ... # type: int
SSH_AUTH_NONE = ... # type: int
SSH_AUTH_PASSWORD = ... # type: int
SSH_AUTH_PUBLICKEY = ... # type: int
SSH_AUTH_TYPES = ... # type: int
SSH_HOST_PUBLIC_KEY_MD5 = ... # type: int
SSH_PRIVATE_KEYFILE = ... # type: int
SSH_PUBLIC_KEYFILE = ... # type: int
SSLCERT = ... # type: int
SSLCERTPASSWD = ... # type: int
SSLCERTTYPE = ... # type: int
SSLENGINE = ... # type: int
SSLENGINE_DEFAULT = ... # type: int
SSLKEY = ... # type: int
SSLKEYPASSWD = ... # type: int
SSLKEYTYPE = ... # type: int
SSLVERSION = ... # type: int
SSLVERSION_DEFAULT = ... # type: int
SSLVERSION_SSLv2 = ... # type: int
SSLVERSION_SSLv3 = ... # type: int
SSLVERSION_TLSv1 = ... # type: int
SSL_CIPHER_LIST = ... # type: int
SSL_ENGINES = ... # type: int
SSL_SESSIONID_CACHE = ... # type: int
SSL_VERIFYHOST = ... # type: int
SSL_VERIFYPEER = ... # type: int
SSL_VERIFYRESULT = ... # type: int
STARTTRANSFER_TIME = ... # type: int
STDERR = ... # type: int
TCP_NODELAY = ... # type: int
TIMECONDITION = ... # type: int
TIMECONDITION_IFMODSINCE = ... # type: int
TIMECONDITION_IFUNMODSINCE = ... # type: int
TIMECONDITION_LASTMOD = ... # type: int
TIMECONDITION_NONE = ... # type: int
TIMEOUT = ... # type: int
TIMEOUT_MS = ... # type: int
TIMEVALUE = ... # type: int
TOTAL_TIME = ... # type: int
TRANSFERTEXT = ... # type: int
UNRESTRICTED_AUTH = ... # type: int
UPLOAD = ... # type: int
URL = ... # type: int
USERAGENT = ... # type: int
USERPWD = ... # type: int
VERBOSE = ... # type: int
WRITEDATA = ... # type: int
WRITEFUNCTION = ... # type: int
WRITEHEADER = ... # type: int
E_ABORTED_BY_CALLBACK = ... # type: int
E_BAD_CONTENT_ENCODING = ... # type: int
E_BAD_DOWNLOAD_RESUME = ... # type: int
E_BAD_FUNCTION_ARGUMENT = ... # type: int
E_CALL_MULTI_PERFORM = ... # type: int
E_CONV_FAILED = ... # type: int
E_CONV_REQD = ... # type: int
E_COULDNT_CONNECT = ... # type: int
E_COULDNT_RESOLVE_HOST = ... # type: int
E_COULDNT_RESOLVE_PROXY = ... # type: int
E_FAILED_INIT = ... # type: int
E_FILESIZE_EXCEEDED = ... # type: int
E_FILE_COULDNT_READ_FILE = ... # type: int
E_FTP_ACCESS_DENIED = ... # type: int
E_FTP_CANT_GET_HOST = ... # type: int
E_FTP_CANT_RECONNECT = ... # type: int
E_FTP_COULDNT_GET_SIZE = ... # type: int
E_FTP_COULDNT_RETR_FILE = ... # type: int
E_FTP_COULDNT_SET_ASCII = ... # type: int
E_FTP_COULDNT_SET_BINARY = ... # type: int
E_FTP_COULDNT_STOR_FILE = ... # type: int
E_FTP_COULDNT_USE_REST = ... # type: int
E_FTP_PORT_FAILED = ... # type: int
E_FTP_QUOTE_ERROR = ... # type: int
E_FTP_SSL_FAILED = ... # type: int
E_FTP_WEIRD_227_FORMAT = ... # type: int
E_FTP_WEIRD_PASS_REPLY = ... # type: int
E_FTP_WEIRD_PASV_REPLY = ... # type: int
E_FTP_WEIRD_SERVER_REPLY = ... # type: int
E_FTP_WEIRD_USER_REPLY = ... # type: int
E_FTP_WRITE_ERROR = ... # type: int
E_FUNCTION_NOT_FOUND = ... # type: int
E_GOT_NOTHING = ... # type: int
E_HTTP_POST_ERROR = ... # type: int
E_HTTP_RANGE_ERROR = ... # type: int
E_HTTP_RETURNED_ERROR = ... # type: int
E_INTERFACE_FAILED = ... # type: int
E_LDAP_CANNOT_BIND = ... # type: int
E_LDAP_INVALID_URL = ... # type: int
E_LDAP_SEARCH_FAILED = ... # type: int
E_LIBRARY_NOT_FOUND = ... # type: int
E_LOGIN_DENIED = ... # type: int
E_MULTI_BAD_EASY_HANDLE = ... # type: int
E_MULTI_BAD_HANDLE = ... # type: int
E_MULTI_INTERNAL_ERROR = ... # type: int
E_MULTI_OK = ... # type: int
E_MULTI_OUT_OF_MEMORY = ... # type: int
E_OK = ... # type: int
E_OPERATION_TIMEOUTED = ... # type: int
E_OUT_OF_MEMORY = ... # type: int
E_PARTIAL_FILE = ... # type: int
E_READ_ERROR = ... # type: int
E_RECV_ERROR = ... # type: int
E_REMOTE_FILE_NOT_FOUND = ... # type: int
E_SEND_ERROR = ... # type: int
E_SEND_FAIL_REWIND = ... # type: int
E_SHARE_IN_USE = ... # type: int
E_SSH = ... # type: int
E_SSL_CACERT = ... # type: int
E_SSL_CACERT_BADFILE = ... # type: int
E_SSL_CERTPROBLEM = ... # type: int
E_SSL_CIPHER = ... # type: int
E_SSL_CONNECT_ERROR = ... # type: int
E_SSL_ENGINE_INITFAILED = ... # type: int
E_SSL_ENGINE_NOTFOUND = ... # type: int
E_SSL_ENGINE_SETFAILED = ... # type: int
E_SSL_PEER_CERTIFICATE = ... # type: int
E_SSL_SHUTDOWN_FAILED = ... # type: int
E_TELNET_OPTION_SYNTAX = ... # type: int
E_TFTP_DISKFULL = ... # type: int
E_TFTP_EXISTS = ... # type: int
E_TFTP_ILLEGAL = ... # type: int
E_TFTP_NOSUCHUSER = ... # type: int
E_TFTP_NOTFOUND = ... # type: int
E_TFTP_PERM = ... # type: int
E_TFTP_UNKNOWNID = ... # type: int
E_TOO_MANY_REDIRECTS = ... # type: int
E_UNKNOWN_TELNET_OPTION = ... # type: int
E_UNSUPPORTED_PROTOCOL = ... # type: int
E_URL_MALFORMAT = ... # type: int
E_WRITE_ERROR = ... # type: int
mypy-0.470/typeshed/third_party/2/kazoo/ 0000755 0000000 0000000 00000000000 13044320557 016665 5 ustar root root mypy-0.470/typeshed/third_party/2/kazoo/__init__.pyi 0000644 0000000 0000000 00000000153 13035744274 021154 0 ustar root root # Stubs for kazoo (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2/kazoo/client.pyi 0000644 0000000 0000000 00000007472 13035744274 020706 0 ustar root root # Stubs for kazoo.client (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
string_types = ... # type: Any
bytes_types = ... # type: Any
LOST_STATES = ... # type: Any
ENVI_VERSION = ... # type: Any
ENVI_VERSION_KEY = ... # type: Any
log = ... # type: Any
class KazooClient:
logger = ... # type: Any
handler = ... # type: Any
auth_data = ... # type: Any
default_acl = ... # type: Any
randomize_hosts = ... # type: Any
hosts = ... # type: Any
chroot = ... # type: Any
state = ... # type: Any
state_listeners = ... # type: Any
read_only = ... # type: Any
retry = ... # type: Any
Barrier = ... # type: Any
Counter = ... # type: Any
DoubleBarrier = ... # type: Any
ChildrenWatch = ... # type: Any
DataWatch = ... # type: Any
Election = ... # type: Any
NonBlockingLease = ... # type: Any
MultiNonBlockingLease = ... # type: Any
Lock = ... # type: Any
Party = ... # type: Any
Queue = ... # type: Any
LockingQueue = ... # type: Any
SetPartitioner = ... # type: Any
Semaphore = ... # type: Any
ShallowParty = ... # type: Any
def __init__(self, hosts=..., timeout=..., client_id=..., handler=..., default_acl=..., auth_data=..., read_only=..., randomize_hosts=..., connection_retry=..., command_retry=..., logger=..., **kwargs) -> None: ...
@property
def client_state(self): ...
@property
def client_id(self): ...
@property
def connected(self): ...
def set_hosts(self, hosts, randomize_hosts=...): ...
def add_listener(self, listener): ...
def remove_listener(self, listener): ...
def start(self, timeout=...): ...
def start_async(self): ...
def stop(self): ...
def restart(self): ...
def close(self): ...
def command(self, cmd=...): ...
def server_version(self, retries=...): ...
def add_auth(self, scheme, credential): ...
def add_auth_async(self, scheme, credential): ...
def unchroot(self, path): ...
def sync_async(self, path): ...
def sync(self, path): ...
def create(self, path, value=..., acl=..., ephemeral=..., sequence=..., makepath=...): ...
def create_async(self, path, value=..., acl=..., ephemeral=..., sequence=..., makepath=...): ...
def ensure_path(self, path, acl=...): ...
def ensure_path_async(self, path, acl=...): ...
def exists(self, path, watch=...): ...
def exists_async(self, path, watch=...): ...
def get(self, path, watch=...): ...
def get_async(self, path, watch=...): ...
def get_children(self, path, watch=..., include_data=...): ...
def get_children_async(self, path, watch=..., include_data=...): ...
def get_acls(self, path): ...
def get_acls_async(self, path): ...
def set_acls(self, path, acls, version=...): ...
def set_acls_async(self, path, acls, version=...): ...
def set(self, path, value, version=...): ...
def set_async(self, path, value, version=...): ...
def transaction(self): ...
def delete(self, path, version=..., recursive=...): ...
def delete_async(self, path, version=...): ...
def reconfig(self, joining, leaving, new_members, from_config=...): ...
def reconfig_async(self, joining, leaving, new_members, from_config): ...
class TransactionRequest:
client = ... # type: Any
operations = ... # type: Any
committed = ... # type: Any
def __init__(self, client) -> None: ...
def create(self, path, value=..., acl=..., ephemeral=..., sequence=...): ...
def delete(self, path, version=...): ...
def set_data(self, path, value, version=...): ...
def check(self, path, version): ...
def commit_async(self): ...
def commit(self): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, exc_tb): ...
class KazooState:
...
mypy-0.470/typeshed/third_party/2/kazoo/exceptions.pyi 0000644 0000000 0000000 00000004625 13035744274 021606 0 ustar root root # Stubs for kazoo.exceptions (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class KazooException(Exception): ...
class ZookeeperError(KazooException): ...
class CancelledError(KazooException): ...
class ConfigurationError(KazooException): ...
class ZookeeperStoppedError(KazooException): ...
class ConnectionDropped(KazooException): ...
class LockTimeout(KazooException): ...
class WriterNotClosedException(KazooException): ...
EXCEPTIONS = ... # type: Any
class RolledBackError(ZookeeperError): ...
class SystemZookeeperError(ZookeeperError): ...
class RuntimeInconsistency(ZookeeperError): ...
class DataInconsistency(ZookeeperError): ...
class ConnectionLoss(ZookeeperError): ...
class MarshallingError(ZookeeperError): ...
class UnimplementedError(ZookeeperError): ...
class OperationTimeoutError(ZookeeperError): ...
class BadArgumentsError(ZookeeperError): ...
class NewConfigNoQuorumError(ZookeeperError): ...
class ReconfigInProcessError(ZookeeperError): ...
class APIError(ZookeeperError): ...
class NoNodeError(ZookeeperError): ...
class NoAuthError(ZookeeperError): ...
class BadVersionError(ZookeeperError): ...
class NoChildrenForEphemeralsError(ZookeeperError): ...
class NodeExistsError(ZookeeperError): ...
class NotEmptyError(ZookeeperError): ...
class SessionExpiredError(ZookeeperError): ...
class InvalidCallbackError(ZookeeperError): ...
class InvalidACLError(ZookeeperError): ...
class AuthFailedError(ZookeeperError): ...
class SessionMovedError(ZookeeperError): ...
class NotReadOnlyCallError(ZookeeperError): ...
class ConnectionClosedError(SessionExpiredError): ...
ConnectionLossException = ... # type: Any
MarshallingErrorException = ... # type: Any
SystemErrorException = ... # type: Any
RuntimeInconsistencyException = ... # type: Any
DataInconsistencyException = ... # type: Any
UnimplementedException = ... # type: Any
OperationTimeoutException = ... # type: Any
BadArgumentsException = ... # type: Any
ApiErrorException = ... # type: Any
NoNodeException = ... # type: Any
NoAuthException = ... # type: Any
BadVersionException = ... # type: Any
NoChildrenForEphemeralsException = ... # type: Any
NodeExistsException = ... # type: Any
InvalidACLException = ... # type: Any
AuthFailedException = ... # type: Any
NotEmptyException = ... # type: Any
SessionExpiredException = ... # type: Any
InvalidCallbackException = ... # type: Any
mypy-0.470/typeshed/third_party/2/kazoo/recipe/ 0000755 0000000 0000000 00000000000 13044320557 020134 5 ustar root root mypy-0.470/typeshed/third_party/2/kazoo/recipe/__init__.pyi 0000644 0000000 0000000 00000000162 13035744274 022423 0 ustar root root # Stubs for kazoo.recipe (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2/kazoo/recipe/watchers.pyi 0000644 0000000 0000000 00000001405 13035744274 022505 0 ustar root root # Stubs for kazoo.recipe.watchers (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
log = ... # type: Any
class DataWatch:
def __init__(self, client, path, func=..., *args, **kwargs) -> None: ...
def __call__(self, func): ...
class ChildrenWatch:
def __init__(self, client, path, func=..., allow_session_lost=..., send_event=...) -> None: ...
def __call__(self, func): ...
class PatientChildrenWatch:
client = ... # type: Any
path = ... # type: Any
children = ... # type: Any
time_boundary = ... # type: Any
children_changed = ... # type: Any
def __init__(self, client, path, time_boundary=...) -> None: ...
asy = ... # type: Any
def start(self): ...
mypy-0.470/typeshed/third_party/2/scribe/ 0000755 0000000 0000000 00000000000 13044320557 017011 5 ustar root root mypy-0.470/typeshed/third_party/2/scribe/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021260 0 ustar root root mypy-0.470/typeshed/third_party/2/scribe/ttypes.pyi 0000644 0000000 0000000 00000001107 13035744274 021071 0 ustar root root # Stubs for scribe.ttypes (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
fastbinary = ... # type: Any
class ResultCode:
OK = ... # type: Any
TRY_LATER = ... # type: Any
class LogEntry:
thrift_spec = ... # type: Any
category = ... # type: Any
message = ... # type: Any
def __init__(self, category=..., message=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
mypy-0.470/typeshed/third_party/2/scribe/scribe.pyi 0000644 0000000 0000000 00000002441 13035744274 021012 0 ustar root root # Stubs for scribe.scribe (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import fb303.FacebookService
from .ttypes import * # noqa: F403
from thrift.Thrift import TProcessor
class Iface(fb303.FacebookService.Iface):
def Log(self, messages): ...
class Client(fb303.FacebookService.Client, Iface):
def __init__(self, iprot, oprot=...) -> None: ...
def Log(self, messages): ...
def send_Log(self, messages): ...
def recv_Log(self): ...
class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
def __init__(self, handler) -> None: ...
def process(self, iprot, oprot): ...
def process_Log(self, seqid, iprot, oprot): ...
class Log_args:
thrift_spec = ... # type: Any
messages = ... # type: Any
def __init__(self, messages=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class Log_result:
thrift_spec = ... # type: Any
success = ... # type: Any
def __init__(self, success=...) -> None: ...
def read(self, iprot): ...
def write(self, oprot): ...
def validate(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
mypy-0.470/typeshed/third_party/2/dateutil/ 0000755 0000000 0000000 00000000000 13044320557 017355 5 ustar root root mypy-0.470/typeshed/third_party/2/dateutil/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021624 0 ustar root root mypy-0.470/typeshed/third_party/2/dateutil/parser.pyi 0000644 0000000 0000000 00000003146 13035744274 021406 0 ustar root root from typing import List, Tuple, Optional, Callable, Union, IO, Any, Dict
from datetime import datetime, tzinfo
__all__ = ... # type: List[str]
class parserinfo(object):
JUMP = ... # type: List[str]
WEEKDAYS = ... # type: List[Tuple[str, str]]
MONTHS = ... # type: List[Tuple[str, str]]
HMS = ... # type: List[Tuple[str, str, str]]
AMPM = ... # type: List[Tuple[str, str]]
UTCZONE = ... # type: List[str]
PERTAIN = ... # type: List[str]
TZOFFSET = ... # type: Dict[str, int]
def __init__(self, dayfirst: bool=..., yearfirst: bool=...) -> None: ...
def jump(self, name: unicode) -> bool: ...
def weekday(self, name: unicode) -> Union[int, None]: ...
def month(self, name: unicode) -> Union[int, None]: ...
def hms(self, name: unicode) -> Union[int, None]: ...
def ampm(self, name: unicode) -> Union[int, None]: ...
def pertain(self, name: unicode) -> bool: ...
def utczone(self, name: unicode) -> bool: ...
def tzoffset(self, name: unicode) -> Union[int, None]: ...
def convertyear(self, year: int) -> int: ...
def validate(self, res: datetime) -> bool: ...
class parser(object):
def __init__(self, info: parserinfo = None) -> None: ...
def parse(self, timestr: Union[str, unicode, IO[unicode]],
default: datetime = None,
ignoretz: bool = ..., tzinfos: Dict[Union[str, unicode], tzinfo] = None,
**kwargs: Any) -> datetime: ...
DEFAULTPARSER = ... # type: parser
def parse(timestr: Union[str, unicode, IO[unicode]],
parserinfo: parserinfo = None,
**kwargs: Any) -> datetime: ...
mypy-0.470/typeshed/third_party/2/dateutil/relativedelta.pyi 0000644 0000000 0000000 00000004707 13035744274 022743 0 ustar root root from typing import Any, Optional, Union
from datetime import date, datetime, timedelta
__all__ = ... # type: List[str]
class weekday(object):
def __init__(self, weekday: int, n: Optional[int]=...) -> None: ...
def __call__(self, n: int) -> 'weekday': ...
def __eq__(self, other) -> bool: ...
def __repr__(self) -> str: ...
weekday = ... # type: int
n = ... # type: int
MO = ... # type: weekday
TU = ... # type: weekday
WE = ... # type: weekday
TH = ... # type: weekday
FR = ... # type: weekday
SA = ... # type: weekday
SU = ... # type: weekday
class relativedelta(object):
def __init__(self,
dt1: Optional[date]=...,
dt2: Optional[date]=...,
years: Optional[int]=..., months: Optional[int]=...,
days: Optional[int]=..., leapdays: Optional[int]=...,
weeks: Optional[int]=...,
hours: Optional[int]=..., minutes: Optional[int]=...,
seconds: Optional[int]=..., microseconds: Optional[int]=...,
year: Optional[int]=..., month: Optional[int]=...,
day: Optional[int]=...,
weekday: Optional[Union[int, weekday]]=...,
yearday: Optional[int]=...,
nlyearday: Optional[int]=...,
hour: Optional[int]=..., minute: Optional[int]=...,
second: Optional[int]=...,
microsecond: Optional[int]=...) -> None: ...
@property
def weeks(self) -> int: ...
@weeks.setter
def weeks(self, value: int) -> None: ...
def normalized(self) -> 'relativedelta': ...
def __add__(
self,
other: Union['relativedelta', timedelta, date, datetime]) -> 'relativedelta': ...
def __radd__(
self,
other: Any) -> 'relativedelta': ...
def __rsub__(
self,
other: Any) -> 'relativedelta': ...
def __sub__(self, other: 'relativedelta') -> 'relativedelta': ...
def __neg__(self) -> 'relativedelta': ...
def __bool__(self) -> bool: ...
def __nonzero__(self) -> bool: ...
def __mul__(self, other: float) -> 'relativedelta': ...
def __rmul__(self, other: float) -> 'relativedelta': ...
def __eq__(self, other) -> bool: ...
def __ne__(self, other: object) -> bool: ...
def __div__(self, other: float) -> 'relativedelta': ...
def __truediv__(self, other: float) -> 'relativedelta': ...
def __repr__(self) -> str: ...
mypy-0.470/typeshed/third_party/2/simplejson/ 0000755 0000000 0000000 00000000000 13044320557 017725 5 ustar root root mypy-0.470/typeshed/third_party/2/simplejson/__init__.pyi 0000644 0000000 0000000 00000000602 13035744274 022213 0 ustar root root from typing import Any, IO
from simplejson.scanner import JSONDecodeError
from simplejson.decoder import JSONDecoder
from simplejson.encoder import JSONEncoder, JSONEncoderForHTML
def dumps(obj: Any, *args: Any, **kwds: Any) -> str: ...
def dump(obj: Any, fp: IO[str], *args: Any, **kwds: Any) -> None: ...
def loads(s: str, **kwds: Any) -> Any: ...
def load(fp: IO[str]) -> Any: ...
mypy-0.470/typeshed/third_party/2/simplejson/decoder.pyi 0000644 0000000 0000000 00000000352 13035744274 022063 0 ustar root root from typing import Any, Match
class JSONDecoder(object):
def __init__(self, **kwargs): ...
def decode(self, s: str, _w: Match[str], _PY3: bool): ...
def raw_decode(self, s: str, idx: int, _w: Match[str], _PY3: bool): ...
mypy-0.470/typeshed/third_party/2/simplejson/scanner.pyi 0000644 0000000 0000000 00000000415 13035744274 022107 0 ustar root root from typing import Any, IO
class JSONDecodeError(ValueError):
def dumps(self, obj: Any) -> str: ...
def dump(self, obj: Any, fp: IO[str], *args: Any, **kwds: Any) -> None: ...
def loads(self, s: str) -> Any: ...
def load(self, fp: IO[str]) -> Any: ...
mypy-0.470/typeshed/third_party/2/simplejson/encoder.pyi 0000644 0000000 0000000 00000000414 13035744274 022074 0 ustar root root from typing import Any, IO
class JSONEncoder(object):
def __init__(self, *args, **kwargs): ...
def encode(self, o: Any): ...
def default(self, o: Any): ...
def iterencode(self, o: Any, _one_shot: bool): ...
class JSONEncoderForHTML(JSONEncoder): ...
mypy-0.470/typeshed/third_party/2/redis/ 0000755 0000000 0000000 00000000000 13044320557 016650 5 ustar root root mypy-0.470/typeshed/third_party/2/redis/__init__.pyi 0000644 0000000 0000000 00000001720 13035744274 021140 0 ustar root root # Stubs for redis (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import client
from . import connection
from . import utils
from . import exceptions
Redis = client.Redis
StrictRedis = client.StrictRedis
BlockingConnectionPool = connection.BlockingConnectionPool
ConnectionPool = connection.ConnectionPool
Connection = connection.Connection
SSLConnection = connection.SSLConnection
UnixDomainSocketConnection = connection.UnixDomainSocketConnection
from_url = utils.from_url
AuthenticationError = exceptions.AuthenticationError
BusyLoadingError = exceptions.BusyLoadingError
ConnectionError = exceptions.ConnectionError
DataError = exceptions.DataError
InvalidResponse = exceptions.InvalidResponse
PubSubError = exceptions.PubSubError
ReadOnlyError = exceptions.ReadOnlyError
RedisError = exceptions.RedisError
ResponseError = exceptions.ResponseError
TimeoutError = exceptions.TimeoutError
WatchError = exceptions.WatchError
mypy-0.470/typeshed/third_party/2/redis/connection.pyi 0000644 0000000 0000000 00000011542 13035744274 021543 0 ustar root root # Stubs for redis.connection (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
ssl_available = ... # type: Any
hiredis_version = ... # type: Any
HIREDIS_SUPPORTS_CALLABLE_ERRORS = ... # type: Any
HIREDIS_SUPPORTS_BYTE_BUFFER = ... # type: Any
msg = ... # type: Any
HIREDIS_USE_BYTE_BUFFER = ... # type: Any
SYM_STAR = ... # type: Any
SYM_DOLLAR = ... # type: Any
SYM_CRLF = ... # type: Any
SYM_EMPTY = ... # type: Any
SERVER_CLOSED_CONNECTION_ERROR = ... # type: Any
class Token:
value = ... # type: Any
def __init__(self, value) -> None: ...
class BaseParser:
EXCEPTION_CLASSES = ... # type: Any
def parse_error(self, response): ...
class SocketBuffer:
socket_read_size = ... # type: Any
bytes_written = ... # type: Any
bytes_read = ... # type: Any
def __init__(self, socket, socket_read_size) -> None: ...
@property
def length(self): ...
def read(self, length): ...
def readline(self): ...
def purge(self): ...
def close(self): ...
class PythonParser(BaseParser):
encoding = ... # type: Any
socket_read_size = ... # type: Any
def __init__(self, socket_read_size) -> None: ...
def __del__(self): ...
def on_connect(self, connection): ...
def on_disconnect(self): ...
def can_read(self): ...
def read_response(self): ...
class HiredisParser(BaseParser):
socket_read_size = ... # type: Any
def __init__(self, socket_read_size) -> None: ...
def __del__(self): ...
def on_connect(self, connection): ...
def on_disconnect(self): ...
def can_read(self): ...
def read_response(self): ...
DefaultParser = ... # type: Any
class Connection:
description_format = ... # type: Any
pid = ... # type: Any
host = ... # type: Any
port = ... # type: Any
db = ... # type: Any
password = ... # type: Any
socket_timeout = ... # type: Any
socket_connect_timeout = ... # type: Any
socket_keepalive = ... # type: Any
socket_keepalive_options = ... # type: Any
retry_on_timeout = ... # type: Any
encoding = ... # type: Any
encoding_errors = ... # type: Any
decode_responses = ... # type: Any
def __init__(self, host=..., port=..., db=..., password=..., socket_timeout=..., socket_connect_timeout=..., socket_keepalive=..., socket_keepalive_options=..., retry_on_timeout=..., encoding=..., encoding_errors=..., decode_responses=..., parser_class=..., socket_read_size=...) -> None: ...
def __del__(self): ...
def register_connect_callback(self, callback): ...
def clear_connect_callbacks(self): ...
def connect(self): ...
def on_connect(self): ...
def disconnect(self): ...
def send_packed_command(self, command): ...
def send_command(self, *args): ...
def can_read(self): ...
def read_response(self): ...
def encode(self, value): ...
def pack_command(self, *args): ...
def pack_commands(self, commands): ...
class SSLConnection(Connection):
description_format = ... # type: Any
keyfile = ... # type: Any
certfile = ... # type: Any
cert_reqs = ... # type: Any
ca_certs = ... # type: Any
def __init__(self, ssl_keyfile=..., ssl_certfile=..., ssl_cert_reqs=..., ssl_ca_certs=..., **kwargs) -> None: ...
class UnixDomainSocketConnection(Connection):
description_format = ... # type: Any
pid = ... # type: Any
path = ... # type: Any
db = ... # type: Any
password = ... # type: Any
socket_timeout = ... # type: Any
retry_on_timeout = ... # type: Any
encoding = ... # type: Any
encoding_errors = ... # type: Any
decode_responses = ... # type: Any
def __init__(self, path=..., db=..., password=..., socket_timeout=..., encoding=..., encoding_errors=..., decode_responses=..., retry_on_timeout=..., parser_class=..., socket_read_size=...) -> None: ...
class ConnectionPool:
@classmethod
def from_url(cls, url, db=..., **kwargs): ...
connection_class = ... # type: Any
connection_kwargs = ... # type: Any
max_connections = ... # type: Any
def __init__(self, connection_class=..., max_connections=..., **connection_kwargs) -> None: ...
pid = ... # type: Any
def reset(self): ...
def get_connection(self, command_name, *keys, **options): ...
def make_connection(self): ...
def release(self, connection): ...
def disconnect(self): ...
class BlockingConnectionPool(ConnectionPool):
queue_class = ... # type: Any
timeout = ... # type: Any
def __init__(self, max_connections=..., timeout=..., connection_class=..., queue_class=..., **connection_kwargs) -> None: ...
pid = ... # type: Any
pool = ... # type: Any
def reset(self): ...
def make_connection(self): ...
def get_connection(self, command_name, *keys, **options): ...
def release(self, connection): ...
def disconnect(self): ...
mypy-0.470/typeshed/third_party/2/redis/utils.pyi 0000644 0000000 0000000 00000000410 13035744274 020534 0 ustar root root # Stubs for redis.utils (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
HIREDIS_AVAILABLE = ... # type: Any
def from_url(url, db=..., **kwargs): ...
def pipeline(redis_obj): ...
class dummy: ...
mypy-0.470/typeshed/third_party/2/redis/client.pyi 0000644 0000000 0000000 00000030252 13035744274 020661 0 ustar root root # Stubs for redis.client (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
SYM_EMPTY = ... # type: Any
def list_or_args(keys, args): ...
def timestamp_to_datetime(response): ...
def string_keys_to_dict(key_string, callback): ...
def dict_merge(*dicts): ...
def parse_debug_object(response): ...
def parse_object(response, infotype): ...
def parse_info(response): ...
SENTINEL_STATE_TYPES = ... # type: Any
def parse_sentinel_state(item): ...
def parse_sentinel_master(response): ...
def parse_sentinel_masters(response): ...
def parse_sentinel_slaves_and_sentinels(response): ...
def parse_sentinel_get_master(response): ...
def pairs_to_dict(response): ...
def pairs_to_dict_typed(response, type_info): ...
def zset_score_pairs(response, **options): ...
def sort_return_tuples(response, **options): ...
def int_or_none(response): ...
def float_or_none(response): ...
def bool_ok(response): ...
def parse_client_list(response, **options): ...
def parse_config_get(response, **options): ...
def parse_scan(response, **options): ...
def parse_hscan(response, **options): ...
def parse_zscan(response, **options): ...
def parse_slowlog_get(response, **options): ...
class StrictRedis:
RESPONSE_CALLBACKS = ... # type: Any
@classmethod
def from_url(cls, url, db=..., **kwargs): ...
connection_pool = ... # type: Any
response_callbacks = ... # type: Any
def __init__(self, host=..., port=..., db=..., password=..., socket_timeout=..., socket_connect_timeout=..., socket_keepalive=..., socket_keepalive_options=..., connection_pool=..., unix_socket_path=..., encoding=..., encoding_errors=..., charset=..., errors=..., decode_responses=..., retry_on_timeout=..., ssl=..., ssl_keyfile=..., ssl_certfile=..., ssl_cert_reqs=..., ssl_ca_certs=...) -> None: ...
def set_response_callback(self, command, callback): ...
def pipeline(self, transaction=..., shard_hint=...): ...
def transaction(self, func, *watches, **kwargs): ...
def lock(self, name, timeout=..., sleep=..., blocking_timeout=..., lock_class=..., thread_local=...): ...
def pubsub(self, **kwargs): ...
def execute_command(self, *args, **options): ...
def parse_response(self, connection, command_name, **options): ...
def bgrewriteaof(self): ...
def bgsave(self): ...
def client_kill(self, address): ...
def client_list(self): ...
def client_getname(self): ...
def client_setname(self, name): ...
def config_get(self, pattern=...): ...
def config_set(self, name, value): ...
def config_resetstat(self): ...
def config_rewrite(self): ...
def dbsize(self): ...
def debug_object(self, key): ...
def echo(self, value): ...
def flushall(self): ...
def flushdb(self): ...
def info(self, section=...): ...
def lastsave(self): ...
def object(self, infotype, key): ...
def ping(self): ...
def save(self): ...
def sentinel(self, *args): ...
def sentinel_get_master_addr_by_name(self, service_name): ...
def sentinel_master(self, service_name): ...
def sentinel_masters(self): ...
def sentinel_monitor(self, name, ip, port, quorum): ...
def sentinel_remove(self, name): ...
def sentinel_sentinels(self, service_name): ...
def sentinel_set(self, name, option, value): ...
def sentinel_slaves(self, service_name): ...
def shutdown(self): ...
def slaveof(self, host=..., port=...): ...
def slowlog_get(self, num=...): ...
def slowlog_len(self): ...
def slowlog_reset(self): ...
def time(self): ...
def append(self, key, value): ...
def bitcount(self, key, start=..., end=...): ...
def bitop(self, operation, dest, *keys): ...
def bitpos(self, key, bit, start=..., end=...): ...
def decr(self, name, amount=...): ...
def delete(self, *names): ...
def __delitem__(self, name): ...
def dump(self, name): ...
def exists(self, name): ...
__contains__ = ... # type: Any
def expire(self, name, time): ...
def expireat(self, name, when): ...
def get(self, name): ...
def __getitem__(self, name): ...
def getbit(self, name, offset): ...
def getrange(self, key, start, end): ...
def getset(self, name, value): ...
def incr(self, name, amount=...): ...
def incrby(self, name, amount=...): ...
def incrbyfloat(self, name, amount=...): ...
def keys(self, pattern=...): ...
def mget(self, keys, *args): ...
def mset(self, *args, **kwargs): ...
def msetnx(self, *args, **kwargs): ...
def move(self, name, db): ...
def persist(self, name): ...
def pexpire(self, name, time): ...
def pexpireat(self, name, when): ...
def psetex(self, name, time_ms, value): ...
def pttl(self, name): ...
def randomkey(self): ...
def rename(self, src, dst): ...
def renamenx(self, src, dst): ...
def restore(self, name, ttl, value): ...
def set(self, name, value, ex=..., px=..., nx=..., xx=...): ...
def __setitem__(self, name, value): ...
def setbit(self, name, offset, value): ...
def setex(self, name, time, value): ...
def setnx(self, name, value): ...
def setrange(self, name, offset, value): ...
def strlen(self, name): ...
def substr(self, name, start, end=...): ...
def ttl(self, name): ...
def type(self, name): ...
def watch(self, *names): ...
def unwatch(self): ...
def blpop(self, keys, timeout=...): ...
def brpop(self, keys, timeout=...): ...
def brpoplpush(self, src, dst, timeout=...): ...
def lindex(self, name, index): ...
def linsert(self, name, where, refvalue, value): ...
def llen(self, name): ...
def lpop(self, name): ...
def lpush(self, name, *values): ...
def lpushx(self, name, value): ...
def lrange(self, name, start, end): ...
def lrem(self, name, count, value): ...
def lset(self, name, index, value): ...
def ltrim(self, name, start, end): ...
def rpop(self, name): ...
def rpoplpush(self, src, dst): ...
def rpush(self, name, *values): ...
def rpushx(self, name, value): ...
def sort(self, name, start=..., num=..., by=..., get=..., desc=..., alpha=..., store=..., groups=...): ...
def scan(self, cursor=..., match=..., count=...): ...
def scan_iter(self, match=..., count=...): ...
def sscan(self, name, cursor=..., match=..., count=...): ...
def sscan_iter(self, name, match=..., count=...): ...
def hscan(self, name, cursor=..., match=..., count=...): ...
def hscan_iter(self, name, match=..., count=...): ...
def zscan(self, name, cursor=..., match=..., count=..., score_cast_func=...): ...
def zscan_iter(self, name, match=..., count=..., score_cast_func=...): ...
def sadd(self, name, *values): ...
def scard(self, name): ...
def sdiff(self, keys, *args): ...
def sdiffstore(self, dest, keys, *args): ...
def sinter(self, keys, *args): ...
def sinterstore(self, dest, keys, *args): ...
def sismember(self, name, value): ...
def smembers(self, name): ...
def smove(self, src, dst, value): ...
def spop(self, name): ...
def srandmember(self, name, number=...): ...
def srem(self, name, *values): ...
def sunion(self, keys, *args): ...
def sunionstore(self, dest, keys, *args): ...
def zadd(self, name, *args, **kwargs): ...
def zcard(self, name): ...
def zcount(self, name, min, max): ...
def zincrby(self, name, value, amount=...): ...
def zinterstore(self, dest, keys, aggregate=...): ...
def zlexcount(self, name, min, max): ...
def zrange(self, name, start, end, desc=..., withscores=..., score_cast_func=...): ...
def zrangebylex(self, name, min, max, start=..., num=...): ...
def zrangebyscore(self, name, min, max, start=..., num=..., withscores=..., score_cast_func=...): ...
def zrank(self, name, value): ...
def zrem(self, name, *values): ...
def zremrangebylex(self, name, min, max): ...
def zremrangebyrank(self, name, min, max): ...
def zremrangebyscore(self, name, min, max): ...
def zrevrange(self, name, start, end, withscores=..., score_cast_func=...): ...
def zrevrangebyscore(self, name, max, min, start=..., num=..., withscores=..., score_cast_func=...): ...
def zrevrank(self, name, value): ...
def zscore(self, name, value): ...
def zunionstore(self, dest, keys, aggregate=...): ...
def pfadd(self, name, *values): ...
def pfcount(self, name): ...
def pfmerge(self, dest, *sources): ...
def hdel(self, name, *keys): ...
def hexists(self, name, key): ...
def hget(self, name, key): ...
def hgetall(self, name): ...
def hincrby(self, name, key, amount=...): ...
def hincrbyfloat(self, name, key, amount=...): ...
def hkeys(self, name): ...
def hlen(self, name): ...
def hset(self, name, key, value): ...
def hsetnx(self, name, key, value): ...
def hmset(self, name, mapping): ...
def hmget(self, name, keys, *args): ...
def hvals(self, name): ...
def publish(self, channel, message): ...
def eval(self, script, numkeys, *keys_and_args): ...
def evalsha(self, sha, numkeys, *keys_and_args): ...
def script_exists(self, *args): ...
def script_flush(self): ...
def script_kill(self): ...
def script_load(self, script): ...
def register_script(self, script): ...
class Redis(StrictRedis):
RESPONSE_CALLBACKS = ... # type: Any
def pipeline(self, transaction=..., shard_hint=...): ...
def setex(self, name, value, time): ...
def lrem(self, name, value, num=...): ...
def zadd(self, name, *args, **kwargs): ...
class PubSub:
PUBLISH_MESSAGE_TYPES = ... # type: Any
UNSUBSCRIBE_MESSAGE_TYPES = ... # type: Any
connection_pool = ... # type: Any
shard_hint = ... # type: Any
ignore_subscribe_messages = ... # type: Any
connection = ... # type: Any
encoding = ... # type: Any
encoding_errors = ... # type: Any
decode_responses = ... # type: Any
def __init__(self, connection_pool, shard_hint=..., ignore_subscribe_messages=...) -> None: ...
def __del__(self): ...
channels = ... # type: Any
patterns = ... # type: Any
def reset(self): ...
def close(self): ...
def on_connect(self, connection): ...
def encode(self, value): ...
@property
def subscribed(self): ...
def execute_command(self, *args, **kwargs): ...
def parse_response(self, block=...): ...
def psubscribe(self, *args, **kwargs): ...
def punsubscribe(self, *args): ...
def subscribe(self, *args, **kwargs): ...
def unsubscribe(self, *args): ...
def listen(self): ...
def get_message(self, ignore_subscribe_messages=...): ...
def handle_message(self, response, ignore_subscribe_messages=...): ...
def run_in_thread(self, sleep_time=...): ...
class BasePipeline:
UNWATCH_COMMANDS = ... # type: Any
connection_pool = ... # type: Any
connection = ... # type: Any
response_callbacks = ... # type: Any
transaction = ... # type: Any
shard_hint = ... # type: Any
watching = ... # type: Any
def __init__(self, connection_pool, response_callbacks, transaction, shard_hint) -> None: ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, traceback): ...
def __del__(self): ...
def __len__(self): ...
command_stack = ... # type: Any
scripts = ... # type: Any
explicit_transaction = ... # type: Any
def reset(self): ...
def multi(self): ...
def execute_command(self, *args, **kwargs): ...
def immediate_execute_command(self, *args, **options): ...
def pipeline_execute_command(self, *args, **options): ...
def raise_first_error(self, commands, response): ...
def annotate_exception(self, exception, number, command): ...
def parse_response(self, connection, command_name, **options): ...
def load_scripts(self): ...
def execute(self, raise_on_error=...): ...
def watch(self, *names): ...
def unwatch(self): ...
def script_load_for_pipeline(self, script): ...
class StrictPipeline(BasePipeline, StrictRedis): ...
class Pipeline(BasePipeline, Redis): ...
class Script:
registered_client = ... # type: Any
script = ... # type: Any
sha = ... # type: Any
def __init__(self, registered_client, script) -> None: ...
def __call__(self, keys=..., args=..., client=...): ...
mypy-0.470/typeshed/third_party/2/redis/exceptions.pyi 0000644 0000000 0000000 00000001260 13023631176 021552 0 ustar root root # Stubs for redis.exceptions (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class RedisError(Exception): ...
def __unicode__(self): ...
class AuthenticationError(RedisError): ...
class ConnectionError(RedisError): ...
class TimeoutError(RedisError): ...
class BusyLoadingError(ConnectionError): ...
class InvalidResponse(RedisError): ...
class ResponseError(RedisError): ...
class DataError(RedisError): ...
class PubSubError(RedisError): ...
class WatchError(RedisError): ...
class NoScriptError(ResponseError): ...
class ExecAbortError(ResponseError): ...
class ReadOnlyError(ResponseError): ...
class LockError(RedisError, ValueError): ...
mypy-0.470/typeshed/third_party/2/requests/ 0000755 0000000 0000000 00000000000 13044320557 017415 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/__init__.pyi 0000644 0000000 0000000 00000001776 13035744274 021720 0 ustar root root # Stubs for requests (based on version 2.6.0, Python 3)
from typing import Any
from requests import models
from requests import api
from requests import sessions
from requests import status_codes
from requests import exceptions
import logging
__title__ = ... # type: Any
__build__ = ... # type: Any
__license__ = ... # type: Any
__copyright__ = ... # type: Any
__version__ = ... # type: Any
Request = models.Request
Response = models.Response
PreparedRequest = models.PreparedRequest
request = api.request
get = api.get
head = api.head
post = api.post
patch = api.patch
put = api.put
delete = api.delete
options = api.options
session = sessions.session
Session = sessions.Session
codes = status_codes.codes
RequestException = exceptions.RequestException
Timeout = exceptions.Timeout
URLRequired = exceptions.URLRequired
TooManyRedirects = exceptions.TooManyRedirects
HTTPError = exceptions.HTTPError
ConnectionError = exceptions.ConnectionError
class NullHandler(logging.Handler):
def emit(self, record): ...
mypy-0.470/typeshed/third_party/2/requests/auth.pyi 0000644 0000000 0000000 00000002260 13023631176 021100 0 ustar root root # Stubs for requests.auth (Python 3)
from typing import Any
from . import compat
from . import cookies
from . import utils
from . import status_codes
extract_cookies_to_jar = cookies.extract_cookies_to_jar
parse_dict_header = utils.parse_dict_header
to_native_string = utils.to_native_string
codes = status_codes.codes
CONTENT_TYPE_FORM_URLENCODED = ... # type: Any
CONTENT_TYPE_MULTI_PART = ... # type: Any
class AuthBase:
def __call__(self, r): ...
class HTTPBasicAuth(AuthBase):
username = ... # type: Any
password = ... # type: Any
def __init__(self, username, password) -> None: ...
def __call__(self, r): ...
class HTTPProxyAuth(HTTPBasicAuth):
def __call__(self, r): ...
class HTTPDigestAuth(AuthBase):
username = ... # type: Any
password = ... # type: Any
last_nonce = ... # type: Any
nonce_count = ... # type: Any
chal = ... # type: Any
pos = ... # type: Any
num_401_calls = ... # type: Any
def __init__(self, username, password) -> None: ...
def build_digest_header(self, method, url): ...
def handle_redirect(self, r, **kwargs): ...
def handle_401(self, r, **kwargs): ...
def __call__(self, r): ...
mypy-0.470/typeshed/third_party/2/requests/cookies.pyi 0000644 0000000 0000000 00000003640 13023631176 021576 0 ustar root root # Stubs for requests.cookies (Python 3)
from typing import Any, MutableMapping
import collections
from . import compat
class MockRequest:
type = ... # type: Any
def __init__(self, request) -> None: ...
def get_type(self): ...
def get_host(self): ...
def get_origin_req_host(self): ...
def get_full_url(self): ...
def is_unverifiable(self): ...
def has_header(self, name): ...
def get_header(self, name, default=...): ...
def add_header(self, key, val): ...
def add_unredirected_header(self, name, value): ...
def get_new_headers(self): ...
@property
def unverifiable(self): ...
@property
def origin_req_host(self): ...
@property
def host(self): ...
class MockResponse:
def __init__(self, headers) -> None: ...
def info(self): ...
def getheaders(self, name): ...
def extract_cookies_to_jar(jar, request, response): ...
def get_cookie_header(jar, request): ...
def remove_cookie_by_name(cookiejar, name, domain=..., path=...): ...
class CookieConflictError(RuntimeError): ...
class RequestsCookieJar(MutableMapping):
def get(self, name, default=..., domain=..., path=...): ...
def set(self, name, value, **kwargs): ...
def iterkeys(self): ...
def keys(self): ...
def itervalues(self): ...
def values(self): ...
def iteritems(self): ...
def items(self): ...
def list_domains(self): ...
def list_paths(self): ...
def multiple_domains(self): ...
def get_dict(self, domain=..., path=...): ...
def __getitem__(self, name): ...
def __setitem__(self, name, value): ...
def __delitem__(self, name): ...
def set_cookie(self, cookie, *args, **kwargs): ...
def update(self, other): ...
def copy(self): ...
def create_cookie(name, value, **kwargs): ...
def morsel_to_cookie(morsel): ...
def cookiejar_from_dict(cookie_dict, cookiejar=..., overwrite=...): ...
def merge_cookies(cookiejar, cookies): ...
mypy-0.470/typeshed/third_party/2/requests/api.pyi 0000644 0000000 0000000 00000001514 13044257024 020710 0 ustar root root # Stubs for requests.api (Python 3)
from typing import Union, Optional, AnyStr
from .models import Response
def request(method: str, url: str, **kwargs) -> Response: ...
def get(url: Union[str, unicode],
params: Optional[Union[dict[Union[str, unicode],
Union[str, unicode]],
Union[str, unicode]]]=None,
**kwargs) -> Response: ...
def options(url: Union[str, unicode], **kwargs) -> Response: ...
def head(url: Union[str, unicode], **kwargs) -> Response: ...
def post(url: Union[str, unicode], data=..., json=...,
**kwargs) -> Response: ...
def put(url: Union[str, unicode], data=..., **kwargs) -> Response: ...
def patch(url: Union[str, unicode], data=..., **kwargs) -> Response: ...
def delete(url: Union[str, unicode], **kwargs) -> Response: ...
mypy-0.470/typeshed/third_party/2/requests/compat.pyi 0000644 0000000 0000000 00000000173 13023631176 021423 0 ustar root root # Stubs for requests.compat (Python 3.4)
from typing import Any
import collections
OrderedDict = collections.OrderedDict
mypy-0.470/typeshed/third_party/2/requests/utils.pyi 0000644 0000000 0000000 00000003155 13023631176 021303 0 ustar root root # Stubs for requests.utils (Python 3)
from typing import Any
from . import compat
from . import cookies
from . import structures
from . import exceptions
OrderedDict = compat.OrderedDict
RequestsCookieJar = cookies.RequestsCookieJar
cookiejar_from_dict = cookies.cookiejar_from_dict
CaseInsensitiveDict = structures.CaseInsensitiveDict
InvalidURL = exceptions.InvalidURL
NETRC_FILES = ... # type: Any
DEFAULT_CA_BUNDLE_PATH = ... # type: Any
def dict_to_sequence(d): ...
def super_len(o): ...
def get_netrc_auth(url): ...
def guess_filename(obj): ...
def from_key_val_list(value): ...
def to_key_val_list(value): ...
def parse_list_header(value): ...
def parse_dict_header(value): ...
def unquote_header_value(value, is_filename=...): ...
def dict_from_cookiejar(cj): ...
def add_dict_to_cookiejar(cj, cookie_dict): ...
def get_encodings_from_content(content): ...
def get_encoding_from_headers(headers): ...
def stream_decode_response_unicode(iterator, r): ...
def iter_slices(string, slice_length): ...
def get_unicode_from_response(r): ...
UNRESERVED_SET = ... # type: Any
def unquote_unreserved(uri): ...
def requote_uri(uri): ...
def address_in_network(ip, net): ...
def dotted_netmask(mask): ...
def is_ipv4_address(string_ip): ...
def is_valid_cidr(string_network): ...
def should_bypass_proxies(url): ...
def get_environ_proxies(url): ...
def default_user_agent(name=...): ...
def default_headers(): ...
def parse_header_links(value): ...
def guess_json_utf(data): ...
def prepend_scheme_if_needed(url, new_scheme): ...
def get_auth_from_url(url): ...
def to_native_string(string, encoding=...): ...
def urldefragauth(url): ...
mypy-0.470/typeshed/third_party/2/requests/sessions.pyi 0000644 0000000 0000000 00000011441 13035744274 022015 0 ustar root root # Stubs for requests.sessions (Python 2.7)
from typing import Any, Union, MutableMapping, Text, Optional, IO, Tuple, Callable
from . import adapters
from . import auth
from . import compat
from . import cookies
from . import models
from .models import Response
from . import hooks
from . import utils
from . import exceptions
from .packages.urllib3 import _collections
from . import structures
from . import adapters
from . import status_codes
BaseAdapter = adapters.BaseAdapter
OrderedDict = compat.OrderedDict
cookiejar_from_dict = cookies.cookiejar_from_dict
extract_cookies_to_jar = cookies.extract_cookies_to_jar
RequestsCookieJar = cookies.RequestsCookieJar
merge_cookies = cookies.merge_cookies
Request = models.Request
PreparedRequest = models.PreparedRequest
DEFAULT_REDIRECT_LIMIT = models.DEFAULT_REDIRECT_LIMIT
default_hooks = hooks.default_hooks
dispatch_hook = hooks.dispatch_hook
to_key_val_list = utils.to_key_val_list
default_headers = utils.default_headers
to_native_string = utils.to_native_string
TooManyRedirects = exceptions.TooManyRedirects
InvalidSchema = exceptions.InvalidSchema
ChunkedEncodingError = exceptions.ChunkedEncodingError
ContentDecodingError = exceptions.ContentDecodingError
RecentlyUsedContainer = _collections.RecentlyUsedContainer
CaseInsensitiveDict = structures.CaseInsensitiveDict
HTTPAdapter = adapters.HTTPAdapter
requote_uri = utils.requote_uri
get_environ_proxies = utils.get_environ_proxies
get_netrc_auth = utils.get_netrc_auth
should_bypass_proxies = utils.should_bypass_proxies
get_auth_from_url = utils.get_auth_from_url
codes = status_codes.codes
REDIRECT_STATI = models.REDIRECT_STATI
REDIRECT_CACHE_SIZE = ... # type: Any
def merge_setting(request_setting, session_setting, dict_class=...): ...
def merge_hooks(request_hooks, session_hooks, dict_class=...): ...
class SessionRedirectMixin:
def resolve_redirects(self, resp, req, stream=..., timeout=..., verify=..., cert=...,
proxies=...): ...
def rebuild_auth(self, prepared_request, response): ...
def rebuild_proxies(self, prepared_request, proxies): ...
class Session(SessionRedirectMixin):
__attrs__ = ... # type: Any
headers = ... # type: Optional[MutableMapping[Text, Text]]
auth = ... # type: Union[None, Tuple[Text, Text], Callable[[Request], Request]]
proxies = ... # type: Optional[MutableMapping[Text, Text]]
hooks = ... # type: Optional[MutableMapping[Text, Callable[[Request], Any]]]
params = ... # type: Union[None, bytes, MutableMapping[Text, Text]]
stream = ... # type: bool
verify = ... # type: bool
cert = ... # type: Union[None, Text, Tuple[Text, Text]]
max_redirects = ... # type: int
trust_env = ... # type: bool
cookies = ... # type: Union[None, RequestsCookieJar, MutableMapping[Text, Text]]
adapters = ... # type: MutableMapping
redirect_cache = ... # type: RecentlyUsedContainer
def __init__(self) -> None: ...
def __enter__(self) -> 'Session': ...
def __exit__(self, *args) -> None: ...
def prepare_request(self, request): ...
def request(self, method: str, url: str,
params, # type: Union[None, bytes, MutableMapping[Text, Text]]
data, # type: Union[None, bytes, MutableMapping[Text, Text], IO]
headers, # type: Optional[MutableMapping[Text, Text]]
cookies, # type: Union[None, RequestsCookieJar, MutableMapping[Text, Text]]
files, # type: Optional[MutableMapping[Text, IO]]
auth, # type: Union[None, Tuple[Text, Text], Callable[[Request], Request]]
timeout, # type: Union[None, float, Tuple[float, float]]
allow_redirects, # type: Optional[bool]
proxies, # type: Optional[MutableMapping[Text, Text]]
hooks, # type: Optional[MutableMapping[Text, Callable[[Request], Any]]]
stream, # type: Optional[bool]
verify, # type: Optional[bool]
cert, # type: Union[Text, Tuple[Text, Text], None]
json # type: Optional[MutableMapping]
) -> Response: ...
def get(self, url: str, **kwargs) -> Response: ...
def options(self, url: str, **kwargs) -> Response: ...
def head(self, url: str, **kwargs) -> Response: ...
def post(self, url: str, data=..., json=..., **kwargs) -> Response: ...
def put(self, url: str, data=..., **kwargs) -> Response: ...
def patch(self, url: str, data=..., **kwargs) -> Response: ...
def delete(self, url: str, **kwargs) -> Response: ...
def send(self, request, **kwargs): ...
def merge_environment_settings(self, url, proxies, stream, verify, cert): ...
def get_adapter(self, url): ...
def close(self) -> None: ...
def mount(self, prefix: str, adapter: BaseAdapter) -> None: ...
def session() -> Session: ...
mypy-0.470/typeshed/third_party/2/requests/structures.pyi 0000644 0000000 0000000 00000000655 13035744274 022377 0 ustar root root # Stubs for requests.structures (Python 3)
from typing import Any, Iterator, MutableMapping, Tuple, Union
class CaseInsensitiveDict(MutableMapping[str, Union[str, unicode]]):
def lower_items(self) -> Iterator[Tuple[str, Union[str, unicode]]]: ...
class LookupDict(dict):
name = ... # type: Any
def __init__(self, name=...) -> None: ...
def __getitem__(self, key): ...
def get(self, key, default=...): ...
mypy-0.470/typeshed/third_party/2/requests/adapters.pyi 0000644 0000000 0000000 00000005545 13023631176 021753 0 ustar root root # Stubs for requests.adapters (Python 3)
from typing import Any, Container, Union, Tuple
from . import models
from .packages.urllib3 import poolmanager
from .packages.urllib3 import response
from .packages.urllib3.util import retry
from . import compat
from . import utils
from . import structures
from .packages.urllib3 import exceptions as urllib3_exceptions
from . import cookies
from . import exceptions
from . import auth
PreparedRequest = models.PreparedRequest
Response = models.Response
PoolManager = poolmanager.PoolManager
proxy_from_url = poolmanager.proxy_from_url
HTTPResponse = response.HTTPResponse
Retry = retry.Retry
DEFAULT_CA_BUNDLE_PATH = utils.DEFAULT_CA_BUNDLE_PATH
get_encoding_from_headers = utils.get_encoding_from_headers
prepend_scheme_if_needed = utils.prepend_scheme_if_needed
get_auth_from_url = utils.get_auth_from_url
urldefragauth = utils.urldefragauth
CaseInsensitiveDict = structures.CaseInsensitiveDict
ConnectTimeoutError = urllib3_exceptions.ConnectTimeoutError
MaxRetryError = urllib3_exceptions.MaxRetryError
ProtocolError = urllib3_exceptions.ProtocolError
ReadTimeoutError = urllib3_exceptions.ReadTimeoutError
ResponseError = urllib3_exceptions.ResponseError
extract_cookies_to_jar = cookies.extract_cookies_to_jar
ConnectionError = exceptions.ConnectionError
ConnectTimeout = exceptions.ConnectTimeout
ReadTimeout = exceptions.ReadTimeout
SSLError = exceptions.SSLError
ProxyError = exceptions.ProxyError
RetryError = exceptions.RetryError
DEFAULT_POOLBLOCK = ... # type: Any
DEFAULT_POOLSIZE = ... # type: Any
DEFAULT_RETRIES = ... # type: Any
class BaseAdapter:
def __init__(self) -> None: ...
def send(self, request: PreparedRequest, stream=False,
timeout: Union[None, float, Tuple[float, float]]=None,
verify=False,
cert: Union[None, Union[str, unicode, bytes], Container[Union[str, unicode]]]=None) -> Response: ...
def close(self) -> None: ...
class HTTPAdapter(BaseAdapter):
__attrs__ = ... # type: Any
max_retries = ... # type: Any
config = ... # type: Any
proxy_manager = ... # type: Any
def __init__(self, pool_connections=..., pool_maxsize=..., max_retries=...,
pool_block=...): ...
poolmanager = ... # type: Any
def init_poolmanager(self, connections, maxsize, block=..., **pool_kwargs): ...
def proxy_manager_for(self, proxy, **proxy_kwargs): ...
def cert_verify(self, conn, url, verify, cert): ...
def build_response(self, req, resp): ...
def get_connection(self, url, proxies=...): ...
def close(self): ...
def request_url(self, request, proxies): ...
def add_headers(self, request, **kwargs): ...
def proxy_headers(self, proxy): ...
# TODO: "request" is not actually optional, modified to please mypy.
def send(self, request=..., stream=..., timeout=..., verify=..., cert=...,
proxies=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/ 0000755 0000000 0000000 00000000000 13044320557 021173 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/__init__.pyi 0000644 0000000 0000000 00000000430 13023631176 023451 0 ustar root root # Stubs for requests.packages (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class VendorAlias:
def __init__(self, package_names) -> None: ...
def find_module(self, fullname, path=...): ...
def load_module(self, name): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/ 0000755 0000000 0000000 00000000000 13044320557 022547 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/_collections.pyi 0000644 0000000 0000000 00000003174 13023631176 025753 0 ustar root root # Stubs for requests.packages.urllib3._collections (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from collections import MutableMapping
class RLock:
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, traceback): ...
class RecentlyUsedContainer(MutableMapping):
ContainerCls = ... # type: Any
dispose_func = ... # type: Any
lock = ... # type: Any
def __init__(self, maxsize=..., dispose_func=...) -> None: ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def __len__(self): ...
def __iter__(self): ...
def clear(self): ...
def keys(self): ...
class HTTPHeaderDict(dict):
def __init__(self, headers=..., **kwargs) -> None: ...
def __setitem__(self, key, val): ...
def __getitem__(self, key): ...
def __delitem__(self, key): ...
def __contains__(self, key): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
values = ... # type: Any
get = ... # type: Any
update = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
def pop(self, key, default=...): ...
def discard(self, key): ...
def add(self, key, val): ...
def extend(*args, **kwargs): ...
def getlist(self, key): ...
getheaders = ... # type: Any
getallmatchingheaders = ... # type: Any
iget = ... # type: Any
def copy(self): ...
def iteritems(self): ...
def itermerged(self): ...
def items(self): ...
@classmethod
def from_httplib(cls, message, duplicates=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/__init__.pyi 0000644 0000000 0000000 00000000474 13023631176 025035 0 ustar root root # Stubs for requests.packages.urllib3 (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import logging
class NullHandler(logging.Handler):
def emit(self, record): ...
def add_stderr_logger(level=...): ...
def disable_warnings(category=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/connectionpool.pyi 0000644 0000000 0000000 00000006566 13023631176 026337 0 ustar root root # Stubs for requests.packages.urllib3.connectionpool (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from ssl import SSLError as BaseSSLError
from . import exceptions
from .packages import ssl_match_hostname
from . import packages
from . import connection
from . import request
from . import response
from .util import connection as _connection
from .util import retry
from .util import timeout
from .util import url
ClosedPoolError = exceptions.ClosedPoolError
ProtocolError = exceptions.ProtocolError
EmptyPoolError = exceptions.EmptyPoolError
HostChangedError = exceptions.HostChangedError
LocationValueError = exceptions.LocationValueError
MaxRetryError = exceptions.MaxRetryError
ProxyError = exceptions.ProxyError
ReadTimeoutError = exceptions.ReadTimeoutError
SSLError = exceptions.SSLError
TimeoutError = exceptions.TimeoutError
InsecureRequestWarning = exceptions.InsecureRequestWarning
CertificateError = ssl_match_hostname.CertificateError
port_by_scheme = connection.port_by_scheme
DummyConnection = connection.DummyConnection
HTTPConnection = connection.HTTPConnection
HTTPSConnection = connection.HTTPSConnection
VerifiedHTTPSConnection = connection.VerifiedHTTPSConnection
HTTPException = connection.HTTPException
ConnectionError = connection.ConnectionError
RequestMethods = request.RequestMethods
HTTPResponse = response.HTTPResponse
is_connection_dropped = _connection.is_connection_dropped
Retry = retry.Retry
Timeout = timeout.Timeout
get_host = url.get_host
xrange = ... # type: Any
log = ... # type: Any
class ConnectionPool:
scheme = ... # type: Any
QueueCls = ... # type: Any
host = ... # type: Any
port = ... # type: Any
def __init__(self, host, port=...) -> None: ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_val, exc_tb): ...
def close(self): ...
class HTTPConnectionPool(ConnectionPool, RequestMethods):
scheme = ... # type: Any
ConnectionCls = ... # type: Any
strict = ... # type: Any
timeout = ... # type: Any
retries = ... # type: Any
pool = ... # type: Any
block = ... # type: Any
proxy = ... # type: Any
proxy_headers = ... # type: Any
num_connections = ... # type: Any
num_requests = ... # type: Any
conn_kw = ... # type: Any
def __init__(self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., **conn_kw) -> None: ...
def close(self): ...
def is_same_host(self, url): ...
def urlopen(self, method, url, body=..., headers=..., retries=..., redirect=..., assert_same_host=..., timeout=..., pool_timeout=..., release_conn=..., **response_kw): ...
class HTTPSConnectionPool(HTTPConnectionPool):
scheme = ... # type: Any
ConnectionCls = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
cert_reqs = ... # type: Any
ca_certs = ... # type: Any
ssl_version = ... # type: Any
assert_hostname = ... # type: Any
assert_fingerprint = ... # type: Any
def __init__(self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., ssl_version=..., assert_hostname=..., assert_fingerprint=..., **conn_kw) -> None: ...
def connection_from_url(url, **kw): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/ 0000755 0000000 0000000 00000000000 13044320557 023524 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/__init__.pyi 0000644 0000000 0000000 00000000266 13035744274 026020 0 ustar root root # Stubs for requests.packages.urllib3.util (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import connection
from . import request
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/connection.pyi 0000644 0000000 0000000 00000000533 13023631176 026406 0 ustar root root # Stubs for requests.packages.urllib3.util.connection (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
poll = ... # type: Any
select = ... # type: Any
def is_connection_dropped(conn): ...
def create_connection(address, timeout=..., source_address=..., socket_options=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/request.pyi 0000644 0000000 0000000 00000000571 13035744274 025750 0 ustar root root # Stubs for requests.packages.urllib3.util.request (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
# from ..packages import six
# b = six.b
ACCEPT_ENCODING = ... # type: Any
def make_headers(keep_alive=..., accept_encoding=..., user_agent=..., basic_auth=..., proxy_basic_auth=..., disable_cache=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/retry.pyi 0000644 0000000 0000000 00000002560 13023631176 025416 0 ustar root root # Stubs for requests.packages.urllib3.util.retry (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
from .. import packages
ConnectTimeoutError = exceptions.ConnectTimeoutError
MaxRetryError = exceptions.MaxRetryError
ProtocolError = exceptions.ProtocolError
ReadTimeoutError = exceptions.ReadTimeoutError
ResponseError = exceptions.ResponseError
log = ... # type: Any
class Retry:
DEFAULT_METHOD_WHITELIST = ... # type: Any
BACKOFF_MAX = ... # type: Any
total = ... # type: Any
connect = ... # type: Any
read = ... # type: Any
redirect = ... # type: Any
status_forcelist = ... # type: Any
method_whitelist = ... # type: Any
backoff_factor = ... # type: Any
raise_on_redirect = ... # type: Any
def __init__(self, total=..., connect=..., read=..., redirect=..., method_whitelist=..., status_forcelist=..., backoff_factor=..., raise_on_redirect=..., _observed_errors=...) -> None: ...
def new(self, **kw): ...
@classmethod
def from_int(cls, retries, redirect=..., default=...): ...
def get_backoff_time(self): ...
def sleep(self): ...
def is_forced_retry(self, method, status_code): ...
def is_exhausted(self): ...
def increment(self, method=..., url=..., response=..., error=..., _pool=..., _stacktrace=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/response.pyi 0000644 0000000 0000000 00000000253 13023631176 026104 0 ustar root root # Stubs for requests.packages.urllib3.util.response (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def is_fp_closed(obj): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/url.pyi 0000644 0000000 0000000 00000001222 13023631176 025045 0 ustar root root # Stubs for requests.packages.urllib3.util.url (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
LocationParseError = exceptions.LocationParseError
url_attrs = ... # type: Any
class Url:
slots = ... # type: Any
def __new__(cls, scheme=..., auth=..., host=..., port=..., path=..., query=..., fragment=...): ...
@property
def hostname(self): ...
@property
def request_uri(self): ...
@property
def netloc(self): ...
@property
def url(self): ...
def split_first(s, delims): ...
def parse_url(url): ...
def get_host(url): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/util/timeout.pyi 0000644 0000000 0000000 00000001235 13023631176 025735 0 ustar root root # Stubs for requests.packages.urllib3.util.timeout (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
TimeoutStateError = exceptions.TimeoutStateError
def current_time(): ...
class Timeout:
DEFAULT_TIMEOUT = ... # type: Any
total = ... # type: Any
def __init__(self, total=..., connect=..., read=...) -> None: ...
@classmethod
def from_float(cls, timeout): ...
def clone(self): ...
def start_connect(self): ...
def get_connect_duration(self): ...
@property
def connect_timeout(self): ...
@property
def read_timeout(self): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/connection.pyi 0000644 0000000 0000000 00000003210 13023631176 025424 0 ustar root root # Stubs for requests.packages.urllib3.connection (Python 3.4)
from typing import Any
from httplib import HTTPException
from . import packages
from . import exceptions
from . import util
class DummyConnection: ...
ConnectTimeoutError = exceptions.ConnectTimeoutError
SystemTimeWarning = exceptions.SystemTimeWarning
SecurityWarning = exceptions.SecurityWarning
port_by_scheme = ... # type: Any
RECENT_DATE = ... # type: Any
class HTTPConnection(object):
default_port = ... # type: Any
default_socket_options = ... # type: Any
is_verified = ... # type: Any
source_address = ... # type: Any
socket_options = ... # type: Any
def __init__(self, *args, **kw) -> None: ...
def connect(self): ...
class HTTPSConnection(HTTPConnection):
default_port = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
def __init__(self, host, port=..., key_file=..., cert_file=..., strict=..., timeout=..., **kw) -> None: ...
sock = ... # type: Any
def connect(self): ...
class VerifiedHTTPSConnection(HTTPSConnection):
cert_reqs = ... # type: Any
ca_certs = ... # type: Any
ssl_version = ... # type: Any
assert_fingerprint = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
assert_hostname = ... # type: Any
def set_cert(self, key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., assert_hostname=..., assert_fingerprint=...): ...
sock = ... # type: Any
auto_open = ... # type: Any
is_verified = ... # type: Any
def connect(self): ...
UnverifiedHTTPSConnection = ... # type: Any
class ConnectionError(Exception): pass
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/request.pyi 0000644 0000000 0000000 00000001240 13023631176 024756 0 ustar root root # Stubs for requests.packages.urllib3.request (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class RequestMethods:
headers = ... # type: Any
def __init__(self, headers=...) -> None: ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
def request(self, method, url, fields=..., headers=..., **urlopen_kw): ...
def request_encode_url(self, method, url, fields=..., **urlopen_kw): ...
def request_encode_body(self, method, url, fields=..., headers=..., encode_multipart=..., multipart_boundary=..., **urlopen_kw): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/poolmanager.pyi 0000644 0000000 0000000 00000002760 13023631176 025602 0 ustar root root # Stubs for requests.packages.urllib3.poolmanager (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .request import RequestMethods
class PoolManager(RequestMethods):
proxy = ... # type: Any
connection_pool_kw = ... # type: Any
pools = ... # type: Any
def __init__(self, num_pools=..., headers=..., **connection_pool_kw) -> None: ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_val, exc_tb): ...
def clear(self): ...
def connection_from_host(self, host, port=..., scheme=...): ...
def connection_from_url(self, url): ...
# TODO: This was the original signature -- copied another one from base class to fix complaint.
# def urlopen(self, method, url, redirect=True, **kw): ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
class ProxyManager(PoolManager):
proxy = ... # type: Any
proxy_headers = ... # type: Any
def __init__(self, proxy_url, num_pools=..., headers=..., proxy_headers=..., **connection_pool_kw) -> None: ...
def connection_from_host(self, host, port=..., scheme=...): ...
# TODO: This was the original signature -- copied another one from base class to fix complaint.
# def urlopen(self, method, url, redirect=True, **kw): ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
def proxy_from_url(url, **kw): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/fields.pyi 0000644 0000000 0000000 00000001050 13023631176 024533 0 ustar root root # Stubs for requests.packages.urllib3.fields (Python 3.4)
from typing import Any
from . import packages
def guess_content_type(filename, default=...): ...
def format_header_param(name, value): ...
class RequestField:
data = ... # type: Any
headers = ... # type: Any
def __init__(self, name, data, filename=..., headers=...) -> None: ...
@classmethod
def from_tuples(cls, fieldname, value): ...
def render_headers(self): ...
def make_multipart(self, content_disposition=..., content_type=..., content_location=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/filepost.pyi 0000644 0000000 0000000 00000000740 13035744274 025126 0 ustar root root # Stubs for requests.packages.urllib3.filepost (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import packages
# from .packages import six
from . import fields
# six = packages.six
# b = six.b
RequestField = fields.RequestField
writer = ... # type: Any
def choose_boundary(): ...
def iter_field_objects(fields): ...
def iter_fields(fields): ...
def encode_multipart_formdata(fields, boundary=...): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/response.pyi 0000644 0000000 0000000 00000003604 13035744274 025141 0 ustar root root # Stubs for requests.packages.urllib3.response (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, IO
import io
from . import _collections
from . import exceptions
# from .packages import six
from . import connection
from .util import response
HTTPHeaderDict = _collections.HTTPHeaderDict
ProtocolError = exceptions.ProtocolError
DecodeError = exceptions.DecodeError
ReadTimeoutError = exceptions.ReadTimeoutError
binary_type = str # six.binary_type
PY3 = True # six.PY3
is_fp_closed = response.is_fp_closed
class DeflateDecoder:
def __init__(self) -> None: ...
def __getattr__(self, name): ...
def decompress(self, data): ...
class GzipDecoder:
def __init__(self) -> None: ...
def __getattr__(self, name): ...
def decompress(self, data): ...
class HTTPResponse(IO[Any]):
CONTENT_DECODERS = ... # type: Any
REDIRECT_STATUSES = ... # type: Any
headers = ... # type: Any
status = ... # type: Any
version = ... # type: Any
reason = ... # type: Any
strict = ... # type: Any
decode_content = ... # type: Any
def __init__(self, body=..., headers=..., status=..., version=..., reason=..., strict=..., preload_content=..., decode_content=..., original_response=..., pool=..., connection=...) -> None: ...
def get_redirect_location(self): ...
def release_conn(self): ...
@property
def data(self): ...
def tell(self): ...
def read(self, amt=..., decode_content=..., cache_content=...): ...
def stream(self, amt=..., decode_content=...): ...
@classmethod
def from_httplib(ResponseCls, r, **response_kw): ...
def getheaders(self): ...
def getheader(self, name, default=...): ...
def close(self): ...
@property
def closed(self): ...
def fileno(self): ...
def flush(self): ...
def readable(self): ...
def readinto(self, b): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/ 0000755 0000000 0000000 00000000000 13044320557 024325 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/__init__.pyi 0000644 0000000 0000000 00000000212 13035744274 026610 0 ustar root root # Stubs for requests.packages.urllib3.packages (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/ssl_match_hostname/ 0000755 0000000 0000000 00000000000 13044320557 030200 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/ssl_match_hostname/__init__.pyi0000644 0000000 0000000 00000000051 13023631176 032455 0 ustar root root class CertificateError(ValueError): pass
././@LongLink 0000644 0000000 0000000 00000000154 00000000000 011603 L ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/ssl_match_hostname/_implementation.pyi mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/packages/ssl_match_hostname/_implementat0000644 0000000 0000000 00000000377 13023631176 032607 0 ustar root root # Stubs for requests.packages.urllib3.packages.ssl_match_hostname._implementation (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class CertificateError(ValueError): ...
def match_hostname(cert, hostname): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/exceptions.pyi 0000644 0000000 0000000 00000003202 13023631176 025447 0 ustar root root # Stubs for requests.packages.urllib3.exceptions (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class HTTPError(Exception): ...
class HTTPWarning(Warning): ...
class PoolError(HTTPError):
pool = ... # type: Any
def __init__(self, pool, message) -> None: ...
def __reduce__(self): ...
class RequestError(PoolError):
url = ... # type: Any
def __init__(self, pool, url, message) -> None: ...
def __reduce__(self): ...
class SSLError(HTTPError): ...
class ProxyError(HTTPError): ...
class DecodeError(HTTPError): ...
class ProtocolError(HTTPError): ...
ConnectionError = ... # type: Any
class MaxRetryError(RequestError):
reason = ... # type: Any
def __init__(self, pool, url, reason=...) -> None: ...
class HostChangedError(RequestError):
retries = ... # type: Any
def __init__(self, pool, url, retries=...) -> None: ...
class TimeoutStateError(HTTPError): ...
class TimeoutError(HTTPError): ...
class ReadTimeoutError(TimeoutError, RequestError): ...
class ConnectTimeoutError(TimeoutError): ...
class EmptyPoolError(PoolError): ...
class ClosedPoolError(PoolError): ...
class LocationValueError(ValueError, HTTPError): ...
class LocationParseError(LocationValueError):
location = ... # type: Any
def __init__(self, location) -> None: ...
class ResponseError(HTTPError):
GENERIC_ERROR = ... # type: Any
SPECIFIC_ERROR = ... # type: Any
class SecurityWarning(HTTPWarning): ...
class InsecureRequestWarning(SecurityWarning): ...
class SystemTimeWarning(SecurityWarning): ...
class InsecurePlatformWarning(SecurityWarning): ...
mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/contrib/ 0000755 0000000 0000000 00000000000 13044320557 024207 5 ustar root root mypy-0.470/typeshed/third_party/2/requests/packages/urllib3/contrib/__init__.pyi 0000644 0000000 0000000 00000000211 13035744274 026471 0 ustar root root # Stubs for requests.packages.urllib3.contrib (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2/requests/models.pyi 0000644 0000000 0000000 00000011376 13035744274 021441 0 ustar root root # Stubs for requests.models (Python 3)
from typing import Any, List, MutableMapping, Iterator, Dict
import datetime
from . import hooks
from . import structures
from . import auth
from . import cookies
from .cookies import RequestsCookieJar
from .packages.urllib3 import fields
from .packages.urllib3 import filepost
from .packages.urllib3 import util
from .packages.urllib3 import exceptions as urllib3_exceptions
from . import exceptions
from . import utils
from . import compat
from . import status_codes
from typing import Optional, Union
default_hooks = hooks.default_hooks
CaseInsensitiveDict = structures.CaseInsensitiveDict
HTTPBasicAuth = auth.HTTPBasicAuth
cookiejar_from_dict = cookies.cookiejar_from_dict
get_cookie_header = cookies.get_cookie_header
RequestField = fields.RequestField
encode_multipart_formdata = filepost.encode_multipart_formdata
DecodeError = urllib3_exceptions.DecodeError
ReadTimeoutError = urllib3_exceptions.ReadTimeoutError
ProtocolError = urllib3_exceptions.ProtocolError
LocationParseError = urllib3_exceptions.LocationParseError
HTTPError = exceptions.HTTPError
MissingSchema = exceptions.MissingSchema
InvalidURL = exceptions.InvalidURL
ChunkedEncodingError = exceptions.ChunkedEncodingError
ContentDecodingError = exceptions.ContentDecodingError
ConnectionError = exceptions.ConnectionError
StreamConsumedError = exceptions.StreamConsumedError
guess_filename = utils.guess_filename
get_auth_from_url = utils.get_auth_from_url
requote_uri = utils.requote_uri
stream_decode_response_unicode = utils.stream_decode_response_unicode
to_key_val_list = utils.to_key_val_list
parse_header_links = utils.parse_header_links
iter_slices = utils.iter_slices
guess_json_utf = utils.guess_json_utf
super_len = utils.super_len
to_native_string = utils.to_native_string
codes = status_codes.codes
REDIRECT_STATI = ... # type: Any
DEFAULT_REDIRECT_LIMIT = ... # type: Any
CONTENT_CHUNK_SIZE = ... # type: Any
ITER_CHUNK_SIZE = ... # type: Any
json_dumps = ... # type: Any
class RequestEncodingMixin:
@property
def path_url(self): ...
class RequestHooksMixin:
def register_hook(self, event, hook): ...
def deregister_hook(self, event, hook): ...
class Request(RequestHooksMixin):
hooks = ... # type: Any
method = ... # type: Any
url = ... # type: Any
headers = ... # type: Any
files = ... # type: Any
data = ... # type: Any
json = ... # type: Any
params = ... # type: Any
auth = ... # type: Any
cookies = ... # type: Any
def __init__(self, method=..., url=..., headers=..., files=..., data=..., params=...,
auth=..., cookies=..., hooks=..., json=...): ...
def prepare(self): ...
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
method = ... # type: Optional[Union[str, unicode]]
url = ... # type: Optional[Union[str, unicode]]
headers = ... # type: CaseInsensitiveDict
body = ... # type: Optional[Union[str, unicode]]
hooks = ... # type: Any
def __init__(self) -> None: ...
def prepare(self, method=..., url=..., headers=..., files=..., data=..., params=...,
auth=..., cookies=..., hooks=..., json=...): ...
def copy(self): ...
def prepare_method(self, method): ...
def prepare_url(self, url, params): ...
def prepare_headers(self, headers): ...
def prepare_body(self, data, files, json=...): ...
def prepare_content_length(self, body): ...
def prepare_auth(self, auth, url=...): ...
def prepare_cookies(self, cookies): ...
def prepare_hooks(self, hooks): ...
class Response:
__attrs__ = ... # type: Any
status_code = ... # type: int
headers = ... # type: MutableMapping[str, str]
raw = ... # type: Any
url = ... # type: str
encoding = ... # type: str
history = ... # type: List[Response]
reason = ... # type: str
cookies = ... # type: RequestsCookieJar
elapsed = ... # type: datetime.timedelta
request = ... # type: PreparedRequest
def __init__(self) -> None: ...
def __bool__(self) -> bool: ...
def __nonzero__(self) -> bool: ...
def __iter__(self) -> Iterator[str]: ...
@property
def ok(self) -> bool: ...
@property
def is_redirect(self) -> bool: ...
@property
def is_permanent_redirect(self) -> bool: ...
@property
def apparent_encoding(self) -> str: ...
def iter_content(self, chunk_size: int = ...,
decode_unicode: bool = ...) -> Iterator[Any]: ...
def iter_lines(self, chunk_size=..., decode_unicode=..., delimiter=...): ...
@property
def content(self) -> str: ...
@property
def text(self) -> str: ...
def json(self, **kwargs) -> Any: ...
@property
def links(self) -> Dict[Any, Any]: ...
def raise_for_status(self) -> None: ...
def close(self) -> None: ...
mypy-0.470/typeshed/third_party/2/requests/status_codes.pyi 0000644 0000000 0000000 00000000320 13023631176 022632 0 ustar root root # Stubs for requests.status_codes (Python 3)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .structures import LookupDict
codes = ... # type: Any
mypy-0.470/typeshed/third_party/2/requests/exceptions.pyi 0000644 0000000 0000000 00000002007 13023631176 022317 0 ustar root root # Stubs for requests.exceptions (Python 3)
from typing import Any
from .packages.urllib3.exceptions import HTTPError as BaseHTTPError
class RequestException(IOError):
response = ... # type: Any
request = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
class HTTPError(RequestException): ...
class ConnectionError(RequestException): ...
class ProxyError(ConnectionError): ...
class SSLError(ConnectionError): ...
class Timeout(RequestException): ...
class ConnectTimeout(ConnectionError, Timeout): ...
class ReadTimeout(Timeout): ...
class URLRequired(RequestException): ...
class TooManyRedirects(RequestException): ...
class MissingSchema(RequestException, ValueError): ...
class InvalidSchema(RequestException, ValueError): ...
class InvalidURL(RequestException, ValueError): ...
class ChunkedEncodingError(RequestException): ...
class ContentDecodingError(RequestException, BaseHTTPError): ...
class StreamConsumedError(RequestException, TypeError): ...
class RetryError(RequestException): ...
mypy-0.470/typeshed/third_party/2/requests/hooks.pyi 0000644 0000000 0000000 00000000252 13023631176 021261 0 ustar root root # Stubs for requests.hooks (Python 3)
from typing import Any
HOOKS = ... # type: Any
def default_hooks(): ...
def dispatch_hook(key, hooks, hook_data, **kwargs): ...
mypy-0.470/typeshed/third_party/2/six/ 0000755 0000000 0000000 00000000000 13044320557 016345 5 ustar root root mypy-0.470/typeshed/third_party/2/six/__init__.pyi 0000644 0000000 0000000 00000006472 13044257024 020636 0 ustar root root # Stubs for six (Python 2.7)
from __future__ import print_function
import types
from typing import (
Any, AnyStr, Callable, Dict, Iterable, Mapping, Optional,
Pattern, Tuple, Type, TypeVar, Union, overload, ValuesView, KeysView, ItemsView
)
import typing
import unittest
from mypy_extensions import NoReturn
# Exports
from __builtin__ import unichr as unichr
from StringIO import StringIO as StringIO, StringIO as BytesIO
from functools import wraps as wraps
_T = TypeVar('_T')
_K = TypeVar('_K')
_V = TypeVar('_V')
# TODO make constant, then move this stub to 2and3
# https://github.com/python/typeshed/issues/17
PY2 = True
PY3 = False
PY34 = False
string_types = basestring,
integer_types = (int, long)
class_types = (type, types.ClassType)
text_type = unicode
binary_type = str
MAXSIZE = ... # type: int
# def add_move
# def remove_move
def advance_iterator(it: typing.Iterator[_T]) -> _T: ...
next = advance_iterator
def callable(obj: object) -> bool: ...
def get_unbound_function(unbound: types.MethodType) -> types.FunctionType: ...
def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ...
def create_unbound_method(func: types.FunctionType, cls: Union[type, types.ClassType]) -> types.MethodType: ...
class Iterator:
def next(self) -> Any: ...
def get_method_function(meth: types.MethodType) -> types.FunctionType: ...
def get_method_self(meth: types.MethodType) -> Optional[object]: ...
def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ...
def get_function_code(fun: types.FunctionType) -> types.CodeType: ...
def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ...
def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ...
def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ...
def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ...
def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ...
# def iterlists
def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ...
def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ...
def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ...
def b(s: str) -> binary_type: ...
def u(s: str) -> text_type: ...
int2byte = chr
def byte2int(bs: binary_type) -> int: ...
def indexbytes(buf: binary_type, i: int) -> int: ...
def iterbytes(buf: binary_type) -> typing.Iterator[int]: ...
def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: str = ...) -> None: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, msg: str = ...) -> Any: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
def assertRegex(self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: str = ...) -> None: ...
def reraise(tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ...) -> NoReturn: ...
def exec_(_code_: Union[unicode, types.CodeType], _globs_: Dict[str, Any] = ..., _locs_: Dict[str, Any] = ...): ...
def raise_from(value: BaseException, from_value: BaseException) -> None: ...
print_ = print
def with_metaclass(meta: type, *bases: type) -> type: ...
def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ...
def python_2_unicode_compatible(klass: _T) -> _T: ...
mypy-0.470/typeshed/third_party/2/six/moves/ 0000755 0000000 0000000 00000000000 13044320557 017476 5 ustar root root mypy-0.470/typeshed/third_party/2/six/moves/__init__.pyi 0000644 0000000 0000000 00000002242 13035744274 021766 0 ustar root root # Provisional stubs for six.moves (Python 2.7)
import Cookie as http_cookies
from cStringIO import StringIO as cStringIO
from itertools import ifilter as filter
from itertools import ifilterfalse as filterfalse
from __builtin__ import raw_input as input
from __builtin__ import intern as intern
from itertools import imap as map
from os import getcwdu as getcwd
from os import getcwd as getcwdb
from __builtin__ import xrange as range
from __builtin__ import reload as reload_module
from __builtin__ import reduce as reduce
from pipes import quote as shlex_quote
from StringIO import StringIO as StringIO
from UserDict import UserDict as UserDict
from UserList import UserList as UserList
from UserString import UserString as UserString
from __builtin__ import xrange as xrange
from itertools import izip as zip
from itertools import izip_longest as zip_longest
import six.moves.cPickle as cPickle
import HTMLParser as html_parser
import htmlentitydefs as html_entities
import httplib as http_client
import six.moves.urllib_parse as urllib_parse
import six.moves.urllib_error as urllib_error
import six.moves.urllib as urllib
import six.moves.urllib_robotparser as urllib_robotparser
mypy-0.470/typeshed/third_party/2/six/moves/urllib_robotparser.pyi 0000644 0000000 0000000 00000000336 13023631176 024135 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_robotparser (Python 2.7)
from six.moves.urllib.robotparser import (
RobotFileParser as RobotFileParser,
)
mypy-0.470/typeshed/third_party/2/six/moves/urllib_response.pyi 0000644 0000000 0000000 00000000440 13023631176 023425 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_response (Python 2.7)
from six.moves.urllib.response import (
addbase as addbase,
addclosehook as addclosehook,
addinfo as addinfo,
addinfourl as addinfourl,
)
mypy-0.470/typeshed/third_party/2/six/moves/urllib_request.pyi 0000644 0000000 0000000 00000002734 13023631176 023267 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_request (Python 2.7)
from six.moves.urllib.request import (
urlopen as urlopen,
install_opener as install_opener,
build_opener as build_opener,
pathname2url as pathname2url,
url2pathname as url2pathname,
getproxies as getproxies,
Request as Request,
OpenerDirector as OpenerDirector,
HTTPDefaultErrorHandler as HTTPDefaultErrorHandler,
HTTPRedirectHandler as HTTPRedirectHandler,
HTTPCookieProcessor as HTTPCookieProcessor,
ProxyHandler as ProxyHandler,
BaseHandler as BaseHandler,
HTTPPasswordMgr as HTTPPasswordMgr,
HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm,
AbstractBasicAuthHandler as AbstractBasicAuthHandler,
HTTPBasicAuthHandler as HTTPBasicAuthHandler,
ProxyBasicAuthHandler as ProxyBasicAuthHandler,
AbstractDigestAuthHandler as AbstractDigestAuthHandler,
HTTPDigestAuthHandler as HTTPDigestAuthHandler,
ProxyDigestAuthHandler as ProxyDigestAuthHandler,
HTTPHandler as HTTPHandler,
HTTPSHandler as HTTPSHandler,
FileHandler as FileHandler,
FTPHandler as FTPHandler,
CacheFTPHandler as CacheFTPHandler,
UnknownHandler as UnknownHandler,
HTTPErrorProcessor as HTTPErrorProcessor,
urlretrieve as urlretrieve,
urlcleanup as urlcleanup,
URLopener as URLopener,
FancyURLopener as FancyURLopener,
proxy_bypass as proxy_bypass,
)
mypy-0.470/typeshed/third_party/2/six/moves/cPickle.pyi 0000644 0000000 0000000 00000000242 13035744274 021577 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.cPickle (Python 2.7)
from cPickle import * # noqa: F403
mypy-0.470/typeshed/third_party/2/six/moves/urllib_error.pyi 0000644 0000000 0000000 00000000422 13023631176 022720 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_error (Python 2.7)
from six.moves.urllib.error import (
URLError as URLError,
HTTPError as HTTPError,
ContentTooShortError as ContentTooShortError,
)
mypy-0.470/typeshed/third_party/2/six/moves/urllib/ 0000755 0000000 0000000 00000000000 13044320557 020767 5 ustar root root mypy-0.470/typeshed/third_party/2/six/moves/urllib/error.pyi 0000644 0000000 0000000 00000000427 13023631176 022645 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.error (Python 2.7)
from urllib2 import URLError as URLError
from urllib2 import HTTPError as HTTPError
from urllib import ContentTooShortError as ContentTooShortError
mypy-0.470/typeshed/third_party/2/six/moves/urllib/__init__.pyi 0000644 0000000 0000000 00000000526 13023631176 023253 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib (Python 2.7)
import six.moves.urllib.error as error
import six.moves.urllib.parse as parse
import six.moves.urllib.request as request
import six.moves.urllib.response as response
import six.moves.urllib.robotparser as robotparser
mypy-0.470/typeshed/third_party/2/six/moves/urllib/request.pyi 0000644 0000000 0000000 00000003632 13023631176 023205 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.request (Python 2.7)
from urllib2 import urlopen as urlopen
from urllib2 import install_opener as install_opener
from urllib2 import build_opener as build_opener
from urllib import pathname2url as pathname2url
from urllib import url2pathname as url2pathname
from urllib import getproxies as getproxies
from urllib2 import Request as Request
from urllib2 import OpenerDirector as OpenerDirector
from urllib2 import HTTPDefaultErrorHandler as HTTPDefaultErrorHandler
from urllib2 import HTTPRedirectHandler as HTTPRedirectHandler
from urllib2 import HTTPCookieProcessor as HTTPCookieProcessor
from urllib2 import ProxyHandler as ProxyHandler
from urllib2 import BaseHandler as BaseHandler
from urllib2 import HTTPPasswordMgr as HTTPPasswordMgr
from urllib2 import HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm
from urllib2 import AbstractBasicAuthHandler as AbstractBasicAuthHandler
from urllib2 import HTTPBasicAuthHandler as HTTPBasicAuthHandler
from urllib2 import ProxyBasicAuthHandler as ProxyBasicAuthHandler
from urllib2 import AbstractDigestAuthHandler as AbstractDigestAuthHandler
from urllib2 import HTTPDigestAuthHandler as HTTPDigestAuthHandler
from urllib2 import ProxyDigestAuthHandler as ProxyDigestAuthHandler
from urllib2 import HTTPHandler as HTTPHandler
from urllib2 import HTTPSHandler as HTTPSHandler
from urllib2 import FileHandler as FileHandler
from urllib2 import FTPHandler as FTPHandler
from urllib2 import CacheFTPHandler as CacheFTPHandler
from urllib2 import UnknownHandler as UnknownHandler
from urllib2 import HTTPErrorProcessor as HTTPErrorProcessor
from urllib import urlretrieve as urlretrieve
from urllib import urlcleanup as urlcleanup
from urllib import URLopener as URLopener
from urllib import FancyURLopener as FancyURLopener
from urllib import proxy_bypass as proxy_bypass
mypy-0.470/typeshed/third_party/2/six/moves/urllib/parse.pyi 0000644 0000000 0000000 00000001506 13023631176 022625 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.parse (Python 2.7)
from six.moves.urllib_parse import (
ParseResult as ParseResult,
SplitResult as SplitResult,
parse_qs as parse_qs,
parse_qsl as parse_qsl,
urldefrag as urldefrag,
urljoin as urljoin,
urlparse as urlparse,
urlsplit as urlsplit,
urlunparse as urlunparse,
urlunsplit as urlunsplit,
quote as quote,
quote_plus as quote_plus,
unquote as unquote,
unquote_plus as unquote_plus,
urlencode as urlencode,
splitquery as splitquery,
splittag as splittag,
splituser as splituser,
uses_fragment as uses_fragment,
uses_netloc as uses_netloc,
uses_params as uses_params,
uses_query as uses_query,
uses_relative as uses_relative,
)
mypy-0.470/typeshed/third_party/2/six/moves/urllib/response.pyi 0000644 0000000 0000000 00000000456 13023631176 023354 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.response (Python 2.7)
from urllib import addbase as addbase
from urllib import addclosehook as addclosehook
from urllib import addinfo as addinfo
from urllib import addinfourl as addinfourl
mypy-0.470/typeshed/third_party/2/six/moves/urllib/robotparser.pyi 0000644 0000000 0000000 00000000304 13023631176 024050 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.robotparser (Python 2.7)
from robotparser import RobotFileParser as RobotFileParser
mypy-0.470/typeshed/third_party/2/six/moves/urllib_parse.pyi 0000644 0000000 0000000 00000002177 13023631176 022712 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_parse (Python 2.7)
from urlparse import ParseResult as ParseResult
from urlparse import SplitResult as SplitResult
from urlparse import parse_qs as parse_qs
from urlparse import parse_qsl as parse_qsl
from urlparse import urldefrag as urldefrag
from urlparse import urljoin as urljoin
from urlparse import urlparse as urlparse
from urlparse import urlsplit as urlsplit
from urlparse import urlunparse as urlunparse
from urlparse import urlunsplit as urlunsplit
from urllib import quote as quote
from urllib import quote_plus as quote_plus
from urllib import unquote as unquote
from urllib import unquote_plus as unquote_plus
from urllib import urlencode as urlencode
from urllib import splitquery as splitquery
from urllib import splittag as splittag
from urllib import splituser as splituser
from urlparse import uses_fragment as uses_fragment
from urlparse import uses_netloc as uses_netloc
from urlparse import uses_params as uses_params
from urlparse import uses_query as uses_query
from urlparse import uses_relative as uses_relative
mypy-0.470/typeshed/third_party/2/google/ 0000755 0000000 0000000 00000000000 13044320557 017016 5 ustar root root mypy-0.470/typeshed/third_party/2/google/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021265 0 ustar root root mypy-0.470/typeshed/third_party/2/google/protobuf/ 0000755 0000000 0000000 00000000000 13044320557 020656 5 ustar root root mypy-0.470/typeshed/third_party/2/google/protobuf/__init__.pyi 0000644 0000000 0000000 00000000037 13023631176 023137 0 ustar root root __version__ = ... # type: str
mypy-0.470/typeshed/third_party/2/google/protobuf/internal/ 0000755 0000000 0000000 00000000000 13044320557 022472 5 ustar root root mypy-0.470/typeshed/third_party/2/google/protobuf/internal/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 024741 0 ustar root root mypy-0.470/typeshed/third_party/2/google/protobuf/internal/decoder.pyi 0000644 0000000 0000000 00000002265 13035744274 024635 0 ustar root root # Stubs for google.protobuf.internal.decoder (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def ReadTag(buffer, pos): ...
def EnumDecoder(field_number, is_repeated, is_packed, key, new_default): ...
Int32Decoder = ... # type: Any
Int64Decoder = ... # type: Any
UInt32Decoder = ... # type: Any
UInt64Decoder = ... # type: Any
SInt32Decoder = ... # type: Any
SInt64Decoder = ... # type: Any
Fixed32Decoder = ... # type: Any
Fixed64Decoder = ... # type: Any
SFixed32Decoder = ... # type: Any
SFixed64Decoder = ... # type: Any
FloatDecoder = ... # type: Any
DoubleDecoder = ... # type: Any
BoolDecoder = ... # type: Any
def StringDecoder(field_number, is_repeated, is_packed, key, new_default): ...
def BytesDecoder(field_number, is_repeated, is_packed, key, new_default): ...
def GroupDecoder(field_number, is_repeated, is_packed, key, new_default): ...
def MessageDecoder(field_number, is_repeated, is_packed, key, new_default): ...
MESSAGE_SET_ITEM_TAG = ... # type: Any
def MessageSetItemDecoder(extensions_by_number): ...
def MapDecoder(field_descriptor, new_default, is_message_map): ...
SkipField = ... # type: Any
mypy-0.470/typeshed/third_party/2/google/protobuf/internal/enum_type_wrapper.pyi 0000644 0000000 0000000 00000000536 13023631176 026765 0 ustar root root from typing import Any, List, Tuple
class EnumTypeWrapper(object):
def __init__(self, enum_type: Any) -> None: ...
def Name(self, number: int) -> str: ...
def Value(self, name: str) -> int: ...
def keys(self) -> List[str]: ...
def values(self) -> List[int]: ...
@classmethod
def items(cls) -> List[Tuple[str, int]]: ...
mypy-0.470/typeshed/third_party/2/google/protobuf/internal/encoder.pyi 0000644 0000000 0000000 00000002556 13035744274 024652 0 ustar root root # Stubs for google.protobuf.internal.encoder (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
Int32Sizer = ... # type: Any
UInt32Sizer = ... # type: Any
SInt32Sizer = ... # type: Any
Fixed32Sizer = ... # type: Any
Fixed64Sizer = ... # type: Any
BoolSizer = ... # type: Any
def StringSizer(field_number, is_repeated, is_packed): ...
def BytesSizer(field_number, is_repeated, is_packed): ...
def GroupSizer(field_number, is_repeated, is_packed): ...
def MessageSizer(field_number, is_repeated, is_packed): ...
def MessageSetItemSizer(field_number): ...
def MapSizer(field_descriptor): ...
def TagBytes(field_number, wire_type): ...
Int32Encoder = ... # type: Any
UInt32Encoder = ... # type: Any
SInt32Encoder = ... # type: Any
Fixed32Encoder = ... # type: Any
Fixed64Encoder = ... # type: Any
SFixed32Encoder = ... # type: Any
SFixed64Encoder = ... # type: Any
FloatEncoder = ... # type: Any
DoubleEncoder = ... # type: Any
def BoolEncoder(field_number, is_repeated, is_packed): ...
def StringEncoder(field_number, is_repeated, is_packed): ...
def BytesEncoder(field_number, is_repeated, is_packed): ...
def GroupEncoder(field_number, is_repeated, is_packed): ...
def MessageEncoder(field_number, is_repeated, is_packed): ...
def MessageSetItemEncoder(field_number): ...
def MapEncoder(field_descriptor): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/internal/wire_format.pyi 0000644 0000000 0000000 00000003647 13035744274 025553 0 ustar root root # Stubs for google.protobuf.internal.wire_format (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
TAG_TYPE_BITS = ... # type: Any
TAG_TYPE_MASK = ... # type: Any
WIRETYPE_VARINT = ... # type: Any
WIRETYPE_FIXED64 = ... # type: Any
WIRETYPE_LENGTH_DELIMITED = ... # type: Any
WIRETYPE_START_GROUP = ... # type: Any
WIRETYPE_END_GROUP = ... # type: Any
WIRETYPE_FIXED32 = ... # type: Any
INT32_MAX = ... # type: Any
INT32_MIN = ... # type: Any
UINT32_MAX = ... # type: Any
INT64_MAX = ... # type: Any
INT64_MIN = ... # type: Any
UINT64_MAX = ... # type: Any
FORMAT_UINT32_LITTLE_ENDIAN = ... # type: Any
FORMAT_UINT64_LITTLE_ENDIAN = ... # type: Any
FORMAT_FLOAT_LITTLE_ENDIAN = ... # type: Any
FORMAT_DOUBLE_LITTLE_ENDIAN = ... # type: Any
def PackTag(field_number, wire_type): ...
def UnpackTag(tag): ...
def ZigZagEncode(value): ...
def ZigZagDecode(value): ...
def Int32ByteSize(field_number, int32): ...
def Int32ByteSizeNoTag(int32): ...
def Int64ByteSize(field_number, int64): ...
def UInt32ByteSize(field_number, uint32): ...
def UInt64ByteSize(field_number, uint64): ...
def SInt32ByteSize(field_number, int32): ...
def SInt64ByteSize(field_number, int64): ...
def Fixed32ByteSize(field_number, fixed32): ...
def Fixed64ByteSize(field_number, fixed64): ...
def SFixed32ByteSize(field_number, sfixed32): ...
def SFixed64ByteSize(field_number, sfixed64): ...
def FloatByteSize(field_number, flt): ...
def DoubleByteSize(field_number, double): ...
def BoolByteSize(field_number, b): ...
def EnumByteSize(field_number, enum): ...
def StringByteSize(field_number, string): ...
def BytesByteSize(field_number, b): ...
def GroupByteSize(field_number, message): ...
def MessageByteSize(field_number, message): ...
def MessageSetItemByteSize(field_number, msg): ...
def TagByteSize(field_number): ...
NON_PACKABLE_TYPES = ... # type: Any
def IsTypePackable(field_type): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/descriptor_pb2.pyi 0000644 0000000 0000000 00000000077 13023631176 024325 0 ustar root root class FileOptions(object): ...
class FieldOptions(object): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/descriptor_pool.pyi 0000644 0000000 0000000 00000001560 13035744274 024620 0 ustar root root # Stubs for google.protobuf.descriptor_pool (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class DescriptorPool:
def __new__(cls, descriptor_db: Optional[Any] = ...): ...
def __init__(self, descriptor_db: Optional[Any] = ...) -> None: ...
def Add(self, file_desc_proto): ...
def AddSerializedFile(self, serialized_file_desc_proto): ...
def AddDescriptor(self, desc): ...
def AddEnumDescriptor(self, enum_desc): ...
def AddFileDescriptor(self, file_desc): ...
def FindFileByName(self, file_name): ...
def FindFileContainingSymbol(self, symbol): ...
def FindMessageTypeByName(self, full_name): ...
def FindEnumTypeByName(self, full_name): ...
def FindFieldByName(self, full_name): ...
def FindExtensionByName(self, full_name): ...
def Default(): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/symbol_database.pyi 0000644 0000000 0000000 00000001375 13035744274 024546 0 ustar root root # Stubs for google.protobuf.symbol_database
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Dict, Iterable, Type
from .descriptor import EnumDescriptor, FileDescriptor
from .message import Message
from .message_factory import MessageFactory
class SymbolDatabase(MessageFactory):
def RegisterMessage(self, message: Type[Message]) -> Type[Message]: ...
def RegisterEnumDescriptor(self, enum_descriptor: Type[EnumDescriptor]) -> EnumDescriptor: ...
def RegisterFileDescriptor(self, file_descriptor: Type[FileDescriptor]) -> FileDescriptor: ...
def GetSymbol(self, symbol: str) -> Type[Message]: ...
def GetMessages(self, files: Iterable[str]) -> Dict[str, Type[Message]]: ...
def Default(): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/message.pyi 0000644 0000000 0000000 00000002615 13035744274 023037 0 ustar root root # Stubs for google.protobuf.message (Python 2.7)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Sequence, Optional, Tuple
from .descriptor import FieldDescriptor
class Error(Exception): ...
class DecodeError(Error): ...
class EncodeError(Error): ...
class Message:
DESCRIPTOR = ... # type: Any
def __deepcopy__(self, memo=...): ...
def __eq__(self, other_msg): ...
def __ne__(self, other_msg): ...
def MergeFrom(self, other_msg: Message) -> None: ...
def CopyFrom(self, other_msg: Message) -> None: ...
def Clear(self) -> None: ...
def SetInParent(self) -> None: ...
def IsInitialized(self) -> bool: ...
def MergeFromString(self, serialized: Any) -> int: ... # TODO: we need to be able to call buffer() on serialized
def ParseFromString(self, serialized: Any) -> None: ...
def SerializeToString(self) -> str: ...
def SerializePartialToString(self) -> str: ...
def ListFields(self) -> Sequence[Tuple[FieldDescriptor, Any]]: ...
def HasField(self, field_name: str) -> bool: ...
def ClearField(self, field_name: str) -> None: ...
def WhichOneof(self, oneof_group) -> Optional[str]: ...
def HasExtension(self, extension_handle): ...
def ClearExtension(self, extension_handle): ...
def ByteSize(self) -> int: ...
# TODO: check kwargs
def __init__(self, **kwargs) -> None: ...
mypy-0.470/typeshed/third_party/2/google/protobuf/message_factory.pyi 0000644 0000000 0000000 00000001206 13035744274 024561 0 ustar root root # Stubs for google.protobuf.message_factory (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Dict, Iterable, Optional, Type
from .message import Message
from .descriptor import Descriptor
from .descriptor_pool import DescriptorPool
class MessageFactory:
pool = ... # type: Any
def __init__(self, pool: DescriptorPool=None) -> None: ...
def GetPrototype(self, descriptor: Descriptor) -> Type[Message]: ...
def GetMessages(self, files: Iterable[str]) -> Dict[str, Type[Message]]: ...
def GetMessages(file_protos: Iterable[str]) -> Dict[str, Type[Message]]: ...
mypy-0.470/typeshed/third_party/2/google/protobuf/reflection.pyi 0000644 0000000 0000000 00000000546 13023631176 023537 0 ustar root root # Stubs for google.protobuf.reflection (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class GeneratedProtocolMessageType(type):
def __new__(cls, name, bases, dictionary): ...
def __init__(cls, name, bases, dictionary) -> None: ...
def ParseMessage(descriptor, byte_str): ...
def MakeClass(descriptor): ...
mypy-0.470/typeshed/third_party/2/google/protobuf/descriptor.pyi 0000644 0000000 0000000 00000015751 13035744274 023576 0 ustar root root # Stubs for google.protobuf.descriptor (Python 2.7)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .message import Message
class Error(Exception): ...
class TypeTransformationError(Error): ...
class DescriptorMetaclass(type):
def __instancecheck__(cls, obj): ...
class DescriptorBase:
__metaclass__ = ... # type: Any
has_options = ... # type: Any
def __init__(self, options, options_class_name) -> None: ...
def GetOptions(self): ...
class _NestedDescriptorBase(DescriptorBase):
name = ... # type: Any
full_name = ... # type: Any
file = ... # type: Any
containing_type = ... # type: Any
def __init__(self, options, options_class_name, name, full_name, file, containing_type, serialized_start=..., serialized_end=...) -> None: ...
def GetTopLevelContainingType(self): ...
def CopyToProto(self, proto): ...
class Descriptor(_NestedDescriptorBase):
def __new__(cls, name, full_name, filename, containing_type, fields, nested_types, enum_types, extensions, options=..., is_extendable=..., extension_ranges=..., oneofs=..., file=..., serialized_start=..., serialized_end=..., syntax=...): ...
fields = ... # type: Any
fields_by_number = ... # type: Any
fields_by_name = ... # type: Any
nested_types = ... # type: Any
nested_types_by_name = ... # type: Any
enum_types = ... # type: Any
enum_types_by_name = ... # type: Any
enum_values_by_name = ... # type: Any
extensions = ... # type: Any
extensions_by_name = ... # type: Any
is_extendable = ... # type: Any
extension_ranges = ... # type: Any
oneofs = ... # type: Any
oneofs_by_name = ... # type: Any
syntax = ... # type: Any
def __init__(self, name, full_name, filename, containing_type, fields, nested_types, enum_types, extensions, options=..., is_extendable=..., extension_ranges=..., oneofs=..., file=..., serialized_start=..., serialized_end=..., syntax=...) -> None: ...
def EnumValueName(self, enum, value): ...
def CopyToProto(self, proto): ...
class FieldDescriptor(DescriptorBase):
TYPE_DOUBLE = ... # type: Any
TYPE_FLOAT = ... # type: Any
TYPE_INT64 = ... # type: Any
TYPE_UINT64 = ... # type: Any
TYPE_INT32 = ... # type: Any
TYPE_FIXED64 = ... # type: Any
TYPE_FIXED32 = ... # type: Any
TYPE_BOOL = ... # type: Any
TYPE_STRING = ... # type: Any
TYPE_GROUP = ... # type: Any
TYPE_MESSAGE = ... # type: Any
TYPE_BYTES = ... # type: Any
TYPE_UINT32 = ... # type: Any
TYPE_ENUM = ... # type: Any
TYPE_SFIXED32 = ... # type: Any
TYPE_SFIXED64 = ... # type: Any
TYPE_SINT32 = ... # type: Any
TYPE_SINT64 = ... # type: Any
MAX_TYPE = ... # type: Any
CPPTYPE_INT32 = ... # type: Any
CPPTYPE_INT64 = ... # type: Any
CPPTYPE_UINT32 = ... # type: Any
CPPTYPE_UINT64 = ... # type: Any
CPPTYPE_DOUBLE = ... # type: Any
CPPTYPE_FLOAT = ... # type: Any
CPPTYPE_BOOL = ... # type: Any
CPPTYPE_ENUM = ... # type: Any
CPPTYPE_STRING = ... # type: Any
CPPTYPE_MESSAGE = ... # type: Any
MAX_CPPTYPE = ... # type: Any
LABEL_OPTIONAL = ... # type: Any
LABEL_REQUIRED = ... # type: Any
LABEL_REPEATED = ... # type: Any
MAX_LABEL = ... # type: Any
MAX_FIELD_NUMBER = ... # type: Any
FIRST_RESERVED_FIELD_NUMBER = ... # type: Any
LAST_RESERVED_FIELD_NUMBER = ... # type: Any
def __new__(cls, name, full_name, index, number, type, cpp_type, label, default_value, message_type, enum_type, containing_type, is_extension, extension_scope, options=..., has_default_value=..., containing_oneof=...): ...
name = ... # type: Any
full_name = ... # type: Any
index = ... # type: Any
number = ... # type: Any
type = ... # type: Any
cpp_type = ... # type: Any
label = ... # type: Any
has_default_value = ... # type: Any
default_value = ... # type: Any
containing_type = ... # type: Any
message_type = ... # type: Any
enum_type = ... # type: Any
is_extension = ... # type: Any
extension_scope = ... # type: Any
containing_oneof = ... # type: Any
def __init__(self, name, full_name, index, number, type, cpp_type, label, default_value, message_type, enum_type, containing_type, is_extension, extension_scope, options=..., has_default_value=..., containing_oneof=...) -> None: ...
@staticmethod
def ProtoTypeToCppProtoType(proto_type): ...
class EnumDescriptor(_NestedDescriptorBase):
def __new__(cls, name, full_name, filename, values, containing_type=..., options=..., file=..., serialized_start=..., serialized_end=...): ...
values = ... # type: Any
values_by_name = ... # type: Any
values_by_number = ... # type: Any
def __init__(self, name, full_name, filename, values, containing_type=..., options=..., file=..., serialized_start=..., serialized_end=...) -> None: ...
def CopyToProto(self, proto): ...
class EnumValueDescriptor(DescriptorBase):
def __new__(cls, name, index, number, type=..., options=...): ...
name = ... # type: Any
index = ... # type: Any
number = ... # type: Any
type = ... # type: Any
def __init__(self, name, index, number, type=..., options=...) -> None: ...
class OneofDescriptor:
def __new__(cls, name, full_name, index, containing_type, fields): ...
name = ... # type: Any
full_name = ... # type: Any
index = ... # type: Any
containing_type = ... # type: Any
fields = ... # type: Any
def __init__(self, name, full_name, index, containing_type, fields) -> None: ...
class ServiceDescriptor(_NestedDescriptorBase):
index = ... # type: Any
methods = ... # type: Any
def __init__(self, name, full_name, index, methods, options=..., file=..., serialized_start=..., serialized_end=...) -> None: ...
def FindMethodByName(self, name): ...
def CopyToProto(self, proto): ...
class MethodDescriptor(DescriptorBase):
name = ... # type: Any
full_name = ... # type: Any
index = ... # type: Any
containing_service = ... # type: Any
input_type = ... # type: Any
output_type = ... # type: Any
def __init__(self, name, full_name, index, containing_service, input_type, output_type, options=...) -> None: ...
class FileDescriptor(DescriptorBase):
def __new__(cls, name, package, options=..., serialized_pb=..., dependencies=..., syntax=...): ...
_options = ... # type: Any
message_types_by_name = ... # type: Any
name = ... # type: Any
package = ... # type: Any
syntax = ... # type: Any
serialized_pb = ... # type: Any
enum_types_by_name = ... # type: Any
extensions_by_name = ... # type: Any
dependencies = ... # type: Any
def __init__(self, name, package, options=..., serialized_pb=..., dependencies=..., syntax=...) -> None: ...
def CopyToProto(self, proto): ...
def MakeDescriptor(desc_proto, package=..., build_file_if_cpp=..., syntax=...): ...
def _ParseOptions(message: Message, string: str) -> Message: ...
mypy-0.470/typeshed/third_party/2/concurrent/ 0000755 0000000 0000000 00000000000 13044320557 017724 5 ustar root root mypy-0.470/typeshed/third_party/2/concurrent/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 022173 0 ustar root root mypy-0.470/typeshed/third_party/2/concurrent/futures/ 0000755 0000000 0000000 00000000000 13044320557 021421 5 ustar root root mypy-0.470/typeshed/third_party/2/concurrent/futures/__init__.pyi 0000644 0000000 0000000 00000003001 13035744274 023703 0 ustar root root from typing import TypeVar, Generic, Any, Iterable, Iterator, Callable, Tuple, Union
_T = TypeVar('_T')
class Future(Generic[_T]):
def cancel(self) -> bool: ...
def cancelled(self) -> bool: ...
def running(self) -> bool: ...
def done(self) -> bool: ...
def result(self, timeout: float = ...) -> _T: ...
def exception(self, timeout: float = ...) -> Exception: ...
def add_done_callback(self, fn: Callable[[Future], Any]) -> None: ...
def set_running_or_notify_cancel(self) -> None: ...
def set_result(self, result: _T) -> None: ...
def set_exception(self, exception: Exception) -> None: ...
class Executor:
def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
def map(self, func: Callable[..., _T], *iterables: Any, timeout: float = ...) -> Iterable[_T]: ...
def shutdown(self, wait: bool = ...) -> None: ...
def __enter__(self) -> Executor: ...
def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool: ...
class ThreadPoolExecutor(Executor):
def __init__(self, max_workers: int) -> None: ...
class ProcessPoolExecutor(Executor):
def __init__(self, max_workers: Union[int, None] = ...) -> None: ...
def wait(fs: Iterable[Future], timeout: float = ..., return_when: str = ...) -> Tuple[Iterable[Future], Iterable[Future]]: ...
FIRST_COMPLETED = ... # type: str
FIRST_EXCEPTION = ... # type: str
ALL_COMPLETED = ... # type: str
def as_completed(fs: Iterable[Future], timeout: float = ...) -> Iterator[Future]: ...
mypy-0.470/typeshed/third_party/2/croniter.pyi 0000644 0000000 0000000 00000001564 13035744274 020126 0 ustar root root # Stubs for croniter.croniter (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class croniter:
MONTHS_IN_YEAR = ... # type: Any
RANGES = ... # type: Any
DAYS = ... # type: Any
ALPHACONV = ... # type: Any
LOWMAP = ... # type: Any
bad_length = ... # type: Any
tzinfo = ... # type: Any
cur = ... # type: Any
exprs = ... # type: Any
expanded = ... # type: Any
def __init__(self, expr_format, start_time=..., ret_type=...) -> None: ...
def get_next(self, ret_type=...): ...
def get_prev(self, ret_type=...): ...
def get_current(self, ret_type=...): ...
def __iter__(self): ...
__next__ = ... # type: Any
def all_next(self, ret_type=...): ...
def all_prev(self, ret_type=...): ...
iter = ... # type: Any
def is_leap(self, year): ...
mypy-0.470/typeshed/third_party/2/tornado/ 0000755 0000000 0000000 00000000000 13044320557 017210 5 ustar root root mypy-0.470/typeshed/third_party/2/tornado/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021457 0 ustar root root mypy-0.470/typeshed/third_party/2/tornado/locks.pyi 0000644 0000000 0000000 00000002470 13035744274 021057 0 ustar root root # Stubs for tornado.locks (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _TimeoutGarbageCollector:
def __init__(self): ...
class Condition(_TimeoutGarbageCollector):
io_loop = ... # type: Any
def __init__(self): ...
def wait(self, timeout=None): ...
def notify(self, n=1): ...
def notify_all(self): ...
class Event:
def __init__(self): ...
def is_set(self): ...
def set(self): ...
def clear(self): ...
def wait(self, timeout=None): ...
class _ReleasingContextManager:
def __init__(self, obj): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_val, exc_tb): ...
class Semaphore(_TimeoutGarbageCollector):
def __init__(self, value=1): ...
def release(self): ...
def acquire(self, timeout=None): ...
def __enter__(self): ...
__exit__ = ... # type: Any
def __aenter__(self): ...
def __aexit__(self, typ, value, tb): ...
class BoundedSemaphore(Semaphore):
def __init__(self, value=1): ...
def release(self): ...
class Lock:
def __init__(self): ...
def acquire(self, timeout=None): ...
def release(self): ...
def __enter__(self): ...
__exit__ = ... # type: Any
def __aenter__(self): ...
def __aexit__(self, typ, value, tb): ...
mypy-0.470/typeshed/third_party/2/tornado/util.pyi 0000644 0000000 0000000 00000002365 13035744274 020724 0 ustar root root # Stubs for tornado.util (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
xrange = ... # type: Any
class ObjectDict(dict):
def __getattr__(self, name): ...
def __setattr__(self, name, value): ...
class GzipDecompressor:
decompressobj = ... # type: Any
def __init__(self) -> None: ...
def decompress(self, value, max_length=...): ...
@property
def unconsumed_tail(self): ...
def flush(self): ...
unicode_type = ... # type: Any
basestring_type = ... # type: Any
def import_object(name): ...
bytes_type = ... # type: Any
def errno_from_exception(e): ...
class Configurable:
def __new__(cls, *args, **kwargs): ...
@classmethod
def configurable_base(cls): ...
@classmethod
def configurable_default(cls): ...
def initialize(self): ...
@classmethod
def configure(cls, impl, **kwargs): ...
@classmethod
def configured_class(cls): ...
class ArgReplacer:
name = ... # type: Any
arg_pos = ... # type: Any
def __init__(self, func, name) -> None: ...
def get_old_value(self, args, kwargs, default=...): ...
def replace(self, new_value, args, kwargs): ...
def timedelta_to_seconds(td): ...
def doctests(): ...
mypy-0.470/typeshed/third_party/2/tornado/web.pyi 0000644 0000000 0000000 00000022517 13035744274 020525 0 ustar root root # Stubs for tornado.web (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado import httputil
MIN_SUPPORTED_SIGNED_VALUE_VERSION = ... # type: Any
MAX_SUPPORTED_SIGNED_VALUE_VERSION = ... # type: Any
DEFAULT_SIGNED_VALUE_VERSION = ... # type: Any
DEFAULT_SIGNED_VALUE_MIN_VERSION = ... # type: Any
class RequestHandler:
SUPPORTED_METHODS = ... # type: Any
application = ... # type: Any
request = ... # type: Any
path_args = ... # type: Any
path_kwargs = ... # type: Any
ui = ... # type: Any
def __init__(self, application, request, **kwargs) -> None: ...
def initialize(self): ...
@property
def settings(self): ...
def head(self, *args, **kwargs): ...
def get(self, *args, **kwargs): ...
def post(self, *args, **kwargs): ...
def delete(self, *args, **kwargs): ...
def patch(self, *args, **kwargs): ...
def put(self, *args, **kwargs): ...
def options(self, *args, **kwargs): ...
def prepare(self): ...
def on_finish(self): ...
def on_connection_close(self): ...
def clear(self): ...
def set_default_headers(self): ...
def set_status(self, status_code, reason=...): ...
def get_status(self): ...
def set_header(self, name, value): ...
def add_header(self, name, value): ...
def clear_header(self, name): ...
def get_argument(self, name, default=..., strip=...): ...
def get_arguments(self, name, strip=...): ...
def get_body_argument(self, name, default=..., strip=...): ...
def get_body_arguments(self, name, strip=...): ...
def get_query_argument(self, name, default=..., strip=...): ...
def get_query_arguments(self, name, strip=...): ...
def decode_argument(self, value, name=...): ...
@property
def cookies(self): ...
def get_cookie(self, name, default=...): ...
def set_cookie(self, name, value, domain=..., expires=..., path=..., expires_days=..., **kwargs): ...
def clear_cookie(self, name, path=..., domain=...): ...
def clear_all_cookies(self, path=..., domain=...): ...
def set_secure_cookie(self, name, value, expires_days=..., version=..., **kwargs): ...
def create_signed_value(self, name, value, version=...): ...
def get_secure_cookie(self, name, value=..., max_age_days=..., min_version=...): ...
def get_secure_cookie_key_version(self, name, value=...): ...
def redirect(self, url, permanent=..., status=...): ...
def write(self, chunk): ...
def render(self, template_name, **kwargs): ...
def render_string(self, template_name, **kwargs): ...
def get_template_namespace(self): ...
def create_template_loader(self, template_path): ...
def flush(self, include_footers=..., callback=...): ...
def finish(self, chunk=...): ...
def send_error(self, status_code=..., **kwargs): ...
def write_error(self, status_code, **kwargs): ...
@property
def locale(self): ...
@locale.setter
def locale(self, value): ...
def get_user_locale(self): ...
def get_browser_locale(self, default=...): ...
@property
def current_user(self): ...
@current_user.setter
def current_user(self, value): ...
def get_current_user(self): ...
def get_login_url(self): ...
def get_template_path(self): ...
@property
def xsrf_token(self): ...
def check_xsrf_cookie(self): ...
def xsrf_form_html(self): ...
def static_url(self, path, include_host=..., **kwargs): ...
def require_setting(self, name, feature=...): ...
def reverse_url(self, name, *args): ...
def compute_etag(self): ...
def set_etag_header(self): ...
def check_etag_header(self): ...
def data_received(self, chunk): ...
def log_exception(self, typ, value, tb): ...
def asynchronous(method): ...
def stream_request_body(cls): ...
def removeslash(method): ...
def addslash(method): ...
class Application(httputil.HTTPServerConnectionDelegate):
transforms = ... # type: Any
handlers = ... # type: Any
named_handlers = ... # type: Any
default_host = ... # type: Any
settings = ... # type: Any
ui_modules = ... # type: Any
ui_methods = ... # type: Any
def __init__(self, handlers=..., default_host=..., transforms=..., **settings) -> None: ...
def listen(self, port, address=..., **kwargs): ...
def add_handlers(self, host_pattern, host_handlers): ...
def add_transform(self, transform_class): ...
def start_request(self, server_conn, request_conn): ...
def __call__(self, request): ...
def reverse_url(self, name, *args): ...
def log_request(self, handler): ...
class _RequestDispatcher(httputil.HTTPMessageDelegate):
application = ... # type: Any
connection = ... # type: Any
request = ... # type: Any
chunks = ... # type: Any
handler_class = ... # type: Any
handler_kwargs = ... # type: Any
path_args = ... # type: Any
path_kwargs = ... # type: Any
def __init__(self, application, connection) -> None: ...
def headers_received(self, start_line, headers): ...
stream_request_body = ... # type: Any
def set_request(self, request): ...
def data_received(self, data): ...
def finish(self): ...
def on_connection_close(self): ...
handler = ... # type: Any
def execute(self): ...
class HTTPError(Exception):
status_code = ... # type: Any
log_message = ... # type: Any
args = ... # type: Any
reason = ... # type: Any
def __init__(self, status_code, log_message=..., *args, **kwargs) -> None: ...
class Finish(Exception): ...
class MissingArgumentError(HTTPError):
arg_name = ... # type: Any
def __init__(self, arg_name) -> None: ...
class ErrorHandler(RequestHandler):
def initialize(self, status_code): ...
def prepare(self): ...
def check_xsrf_cookie(self): ...
class RedirectHandler(RequestHandler):
def initialize(self, url, permanent=...): ...
def get(self): ...
class StaticFileHandler(RequestHandler):
CACHE_MAX_AGE = ... # type: Any
root = ... # type: Any
default_filename = ... # type: Any
def initialize(self, path, default_filename=...): ...
@classmethod
def reset(cls): ...
def head(self, path): ...
path = ... # type: Any
absolute_path = ... # type: Any
modified = ... # type: Any
def get(self, path, include_body=...): ...
def compute_etag(self): ...
def set_headers(self): ...
def should_return_304(self): ...
@classmethod
def get_absolute_path(cls, root, path): ...
def validate_absolute_path(self, root, absolute_path): ...
@classmethod
def get_content(cls, abspath, start=..., end=...): ...
@classmethod
def get_content_version(cls, abspath): ...
def get_content_size(self): ...
def get_modified_time(self): ...
def get_content_type(self): ...
def set_extra_headers(self, path): ...
def get_cache_time(self, path, modified, mime_type): ...
@classmethod
def make_static_url(cls, settings, path, include_version=...): ...
def parse_url_path(self, url_path): ...
@classmethod
def get_version(cls, settings, path): ...
class FallbackHandler(RequestHandler):
fallback = ... # type: Any
def initialize(self, fallback): ...
def prepare(self): ...
class OutputTransform:
def __init__(self, request) -> None: ...
def transform_first_chunk(self, status_code, headers, chunk, finishing): ...
def transform_chunk(self, chunk, finishing): ...
class GZipContentEncoding(OutputTransform):
CONTENT_TYPES = ... # type: Any
MIN_LENGTH = ... # type: Any
def __init__(self, request) -> None: ...
def transform_first_chunk(self, status_code, headers, chunk, finishing): ...
def transform_chunk(self, chunk, finishing): ...
def authenticated(method): ...
class UIModule:
handler = ... # type: Any
request = ... # type: Any
ui = ... # type: Any
locale = ... # type: Any
def __init__(self, handler) -> None: ...
@property
def current_user(self): ...
def render(self, *args, **kwargs): ...
def embedded_javascript(self): ...
def javascript_files(self): ...
def embedded_css(self): ...
def css_files(self): ...
def html_head(self): ...
def html_body(self): ...
def render_string(self, path, **kwargs): ...
class _linkify(UIModule):
def render(self, text, **kwargs): ...
class _xsrf_form_html(UIModule):
def render(self): ...
class TemplateModule(UIModule):
def __init__(self, handler) -> None: ...
def render(self, path, **kwargs): ...
def embedded_javascript(self): ...
def javascript_files(self): ...
def embedded_css(self): ...
def css_files(self): ...
def html_head(self): ...
def html_body(self): ...
class _UIModuleNamespace:
handler = ... # type: Any
ui_modules = ... # type: Any
def __init__(self, handler, ui_modules) -> None: ...
def __getitem__(self, key): ...
def __getattr__(self, key): ...
class URLSpec:
regex = ... # type: Any
handler_class = ... # type: Any
kwargs = ... # type: Any
name = ... # type: Any
def __init__(self, pattern, handler, kwargs=..., name=...) -> None: ...
def reverse(self, *args): ...
url = ... # type: Any
def create_signed_value(secret, name, value, version=..., clock=..., key_version=...): ...
def decode_signed_value(secret, name, value, max_age_days=..., clock=..., min_version=...): ...
def get_signature_key_version(value): ...
mypy-0.470/typeshed/third_party/2/tornado/gen.pyi 0000644 0000000 0000000 00000006347 13035744274 020524 0 ustar root root # Stubs for tornado.gen (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from collections import namedtuple
singledispatch = ... # type: Any
class KeyReuseError(Exception): ...
class UnknownKeyError(Exception): ...
class LeakedCallbackError(Exception): ...
class BadYieldError(Exception): ...
class ReturnValueIgnoredError(Exception): ...
class TimeoutError(Exception): ...
def engine(func): ...
def coroutine(func, replace_callback=...): ...
class Return(Exception):
value = ... # type: Any
def __init__(self, value=...) -> None: ...
class WaitIterator:
current_index = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def done(self): ...
def next(self): ...
class YieldPoint:
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
class Callback(YieldPoint):
key = ... # type: Any
def __init__(self, key) -> None: ...
runner = ... # type: Any
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
class Wait(YieldPoint):
key = ... # type: Any
def __init__(self, key) -> None: ...
runner = ... # type: Any
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
class WaitAll(YieldPoint):
keys = ... # type: Any
def __init__(self, keys) -> None: ...
runner = ... # type: Any
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
def Task(func, *args, **kwargs): ...
class YieldFuture(YieldPoint):
future = ... # type: Any
io_loop = ... # type: Any
def __init__(self, future, io_loop=...) -> None: ...
runner = ... # type: Any
key = ... # type: Any
result_fn = ... # type: Any
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
class Multi(YieldPoint):
keys = ... # type: Any
children = ... # type: Any
unfinished_children = ... # type: Any
quiet_exceptions = ... # type: Any
def __init__(self, children, quiet_exceptions=...) -> None: ...
def start(self, runner): ...
def is_ready(self): ...
def get_result(self): ...
def multi_future(children, quiet_exceptions=...): ...
def maybe_future(x): ...
def with_timeout(timeout, future, io_loop=..., quiet_exceptions=...): ...
def sleep(duration): ...
moment = ... # type: Any
class Runner:
gen = ... # type: Any
result_future = ... # type: Any
future = ... # type: Any
yield_point = ... # type: Any
pending_callbacks = ... # type: Any
results = ... # type: Any
running = ... # type: Any
finished = ... # type: Any
had_exception = ... # type: Any
io_loop = ... # type: Any
stack_context_deactivate = ... # type: Any
def __init__(self, gen, result_future, first_yielded) -> None: ...
def register_callback(self, key): ...
def is_ready(self, key): ...
def set_result(self, key, result): ...
def pop_result(self, key): ...
def run(self): ...
def handle_yield(self, yielded): ...
def result_callback(self, key): ...
def handle_exception(self, typ, value, tb): ...
Arguments = namedtuple('Arguments', ['args', 'kwargs'])
def convert_yielded(yielded): ...
mypy-0.470/typeshed/third_party/2/tornado/ioloop.pyi 0000644 0000000 0000000 00000006012 13035744274 021241 0 ustar root root # Stubs for tornado.ioloop (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado.util import Configurable
signal = ... # type: Any
class TimeoutError(Exception): ...
class IOLoop(Configurable):
NONE = ... # type: Any
READ = ... # type: Any
WRITE = ... # type: Any
ERROR = ... # type: Any
@staticmethod
def instance(): ...
@staticmethod
def initialized(): ...
def install(self): ...
@staticmethod
def clear_instance(): ...
@staticmethod
def current(instance=...): ...
def make_current(self): ...
@staticmethod
def clear_current(): ...
@classmethod
def configurable_base(cls): ...
@classmethod
def configurable_default(cls): ...
def initialize(self, make_current=...): ...
def close(self, all_fds=...): ...
def add_handler(self, fd, handler, events): ...
def update_handler(self, fd, events): ...
def remove_handler(self, fd): ...
def set_blocking_signal_threshold(self, seconds, action): ...
def set_blocking_log_threshold(self, seconds): ...
def log_stack(self, signal, frame): ...
def start(self): ...
def stop(self): ...
def run_sync(self, func, timeout=...): ...
def time(self): ...
def add_timeout(self, deadline, callback, *args, **kwargs): ...
def call_later(self, delay, callback, *args, **kwargs): ...
def call_at(self, when, callback, *args, **kwargs): ...
def remove_timeout(self, timeout): ...
def add_callback(self, callback, *args, **kwargs): ...
def add_callback_from_signal(self, callback, *args, **kwargs): ...
def spawn_callback(self, callback, *args, **kwargs): ...
def add_future(self, future, callback): ...
def handle_callback_exception(self, callback): ...
def split_fd(self, fd): ...
def close_fd(self, fd): ...
class PollIOLoop(IOLoop):
time_func = ... # type: Any
def initialize(self, impl, time_func=..., **kwargs): ...
def close(self, all_fds=...): ...
def add_handler(self, fd, handler, events): ...
def update_handler(self, fd, events): ...
def remove_handler(self, fd): ...
def set_blocking_signal_threshold(self, seconds, action): ...
def start(self): ...
def stop(self): ...
def time(self): ...
def call_at(self, deadline, callback, *args, **kwargs): ...
def remove_timeout(self, timeout): ...
def add_callback(self, callback, *args, **kwargs): ...
def add_callback_from_signal(self, callback, *args, **kwargs): ...
class _Timeout:
deadline = ... # type: Any
callback = ... # type: Any
tiebreaker = ... # type: Any
def __init__(self, deadline, callback, io_loop) -> None: ...
def __lt__(self, other): ...
def __le__(self, other): ...
class PeriodicCallback:
callback = ... # type: Any
callback_time = ... # type: Any
io_loop = ... # type: Any
def __init__(self, callback, callback_time, io_loop=...) -> None: ...
def start(self): ...
def stop(self): ...
def is_running(self): ...
mypy-0.470/typeshed/third_party/2/tornado/httpclient.pyi 0000644 0000000 0000000 00000010216 13035744274 022117 0 ustar root root # Stubs for tornado.httpclient (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado.util import Configurable
class HTTPClient:
def __init__(self, async_client_class=..., **kwargs) -> None: ...
def __del__(self): ...
def close(self): ...
def fetch(self, request, **kwargs): ...
class AsyncHTTPClient(Configurable):
@classmethod
def configurable_base(cls): ...
@classmethod
def configurable_default(cls): ...
def __new__(cls, io_loop=..., force_instance=..., **kwargs): ...
io_loop = ... # type: Any
defaults = ... # type: Any
def initialize(self, io_loop, defaults=...): ...
def close(self): ...
def fetch(self, request, callback=..., raise_error=..., **kwargs): ...
def fetch_impl(self, request, callback): ...
@classmethod
def configure(cls, impl, **kwargs): ...
class HTTPRequest:
headers = ... # type: Any
proxy_host = ... # type: Any
proxy_port = ... # type: Any
proxy_username = ... # type: Any
proxy_password = ... # type: Any
url = ... # type: Any
method = ... # type: Any
body = ... # type: Any
body_producer = ... # type: Any
auth_username = ... # type: Any
auth_password = ... # type: Any
auth_mode = ... # type: Any
connect_timeout = ... # type: Any
request_timeout = ... # type: Any
follow_redirects = ... # type: Any
max_redirects = ... # type: Any
user_agent = ... # type: Any
decompress_response = ... # type: Any
network_interface = ... # type: Any
streaming_callback = ... # type: Any
header_callback = ... # type: Any
prepare_curl_callback = ... # type: Any
allow_nonstandard_methods = ... # type: Any
validate_cert = ... # type: Any
ca_certs = ... # type: Any
allow_ipv6 = ... # type: Any
client_key = ... # type: Any
client_cert = ... # type: Any
ssl_options = ... # type: Any
expect_100_continue = ... # type: Any
start_time = ... # type: Any
def __init__(self, url, method=..., headers=..., body=..., auth_username=..., auth_password=..., auth_mode=..., connect_timeout=..., request_timeout=..., if_modified_since=..., follow_redirects=..., max_redirects=..., user_agent=..., use_gzip=..., network_interface=..., streaming_callback=..., header_callback=..., prepare_curl_callback=..., proxy_host=..., proxy_port=..., proxy_username=..., proxy_password=..., allow_nonstandard_methods=..., validate_cert=..., ca_certs=..., allow_ipv6=..., client_key=..., client_cert=..., body_producer=..., expect_100_continue=..., decompress_response=..., ssl_options=...) -> None: ...
@property
def headers(self): ...
@headers.setter
def headers(self, value): ...
@property
def body(self): ...
@body.setter
def body(self, value): ...
@property
def body_producer(self): ...
@body_producer.setter
def body_producer(self, value): ...
@property
def streaming_callback(self): ...
@streaming_callback.setter
def streaming_callback(self, value): ...
@property
def header_callback(self): ...
@header_callback.setter
def header_callback(self, value): ...
@property
def prepare_curl_callback(self): ...
@prepare_curl_callback.setter
def prepare_curl_callback(self, value): ...
class HTTPResponse:
request = ... # type: Any
code = ... # type: Any
reason = ... # type: Any
headers = ... # type: Any
buffer = ... # type: Any
effective_url = ... # type: Any
error = ... # type: Any
request_time = ... # type: Any
time_info = ... # type: Any
def __init__(self, request, code, headers=..., buffer=..., effective_url=..., error=..., request_time=..., time_info=..., reason=...) -> None: ...
body = ... # type: Any
def rethrow(self): ...
class HTTPError(Exception):
code = ... # type: Any
response = ... # type: Any
def __init__(self, code, message=..., response=...) -> None: ...
class _RequestProxy:
request = ... # type: Any
defaults = ... # type: Any
def __init__(self, request, defaults) -> None: ...
def __getattr__(self, name): ...
def main(): ...
mypy-0.470/typeshed/third_party/2/tornado/tcpserver.pyi 0000644 0000000 0000000 00000001352 13035744274 021757 0 ustar root root # Stubs for tornado.tcpserver (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
ssl = ... # type: Any
class TCPServer:
io_loop = ... # type: Any
ssl_options = ... # type: Any
max_buffer_size = ... # type: Any
read_chunk_size = ... # type: Any
def __init__(self, io_loop=..., ssl_options=..., max_buffer_size=..., read_chunk_size=...) -> None: ...
def listen(self, port, address=...): ...
def add_sockets(self, sockets): ...
def add_socket(self, socket): ...
def bind(self, port, address=..., family=..., backlog=...): ...
def start(self, num_processes=...): ...
def stop(self): ...
def handle_stream(self, stream, address): ...
mypy-0.470/typeshed/third_party/2/tornado/httputil.pyi 0000644 0000000 0000000 00000005670 13035744274 021626 0 ustar root root # Stubs for tornado.httputil (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado.util import ObjectDict
from collections import namedtuple
class SSLError(Exception): ...
class _NormalizedHeaderCache(dict):
size = ... # type: Any
queue = ... # type: Any
def __init__(self, size) -> None: ...
def __missing__(self, key): ...
class HTTPHeaders(dict):
def __init__(self, *args, **kwargs) -> None: ...
def add(self, name, value): ...
def get_list(self, name): ...
def get_all(self): ...
def parse_line(self, line): ...
@classmethod
def parse(cls, headers): ...
def __setitem__(self, name, value): ...
def __getitem__(self, name): ...
def __delitem__(self, name): ...
def __contains__(self, name): ...
def get(self, name, default=...): ...
def update(self, *args, **kwargs): ...
def copy(self): ...
__copy__ = ... # type: Any
def __deepcopy__(self, memo_dict): ...
class HTTPServerRequest:
method = ... # type: Any
uri = ... # type: Any
version = ... # type: Any
headers = ... # type: Any
body = ... # type: Any
remote_ip = ... # type: Any
protocol = ... # type: Any
host = ... # type: Any
files = ... # type: Any
connection = ... # type: Any
arguments = ... # type: Any
query_arguments = ... # type: Any
body_arguments = ... # type: Any
def __init__(self, method=..., uri=..., version=..., headers=..., body=..., host=..., files=..., connection=..., start_line=...) -> None: ...
def supports_http_1_1(self): ...
@property
def cookies(self): ...
def write(self, chunk, callback=...): ...
def finish(self): ...
def full_url(self): ...
def request_time(self): ...
def get_ssl_certificate(self, binary_form=...): ...
class HTTPInputError(Exception): ...
class HTTPOutputError(Exception): ...
class HTTPServerConnectionDelegate:
def start_request(self, server_conn, request_conn): ...
def on_close(self, server_conn): ...
class HTTPMessageDelegate:
def headers_received(self, start_line, headers): ...
def data_received(self, chunk): ...
def finish(self): ...
def on_connection_close(self): ...
class HTTPConnection:
def write_headers(self, start_line, headers, chunk=..., callback=...): ...
def write(self, chunk, callback=...): ...
def finish(self): ...
def url_concat(url, args): ...
class HTTPFile(ObjectDict): ...
def parse_body_arguments(content_type, body, arguments, files, headers=...): ...
def parse_multipart_form_data(boundary, data, arguments, files): ...
def format_timestamp(ts): ...
RequestStartLine = namedtuple('RequestStartLine', ['method', 'path', 'version'])
def parse_request_start_line(line): ...
ResponseStartLine = namedtuple('ResponseStartLine', ['version', 'code', 'reason'])
def parse_response_start_line(line): ...
def doctests(): ...
def split_host_and_port(netloc): ...
mypy-0.470/typeshed/third_party/2/tornado/testing.pyi 0000644 0000000 0000000 00000003442 13035744274 021421 0 ustar root root # Stubs for tornado.testing (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import unittest
import logging
AsyncHTTPClient = ... # type: Any
gen = ... # type: Any
HTTPServer = ... # type: Any
IOLoop = ... # type: Any
netutil = ... # type: Any
SimpleAsyncHTTPClient = ... # type: Any
def get_unused_port(): ...
def bind_unused_port(): ...
class AsyncTestCase(unittest.TestCase):
def __init__(self, *args, **kwargs): ...
io_loop = ... # type: Any
def setUp(self): ...
def tearDown(self): ...
def get_new_ioloop(self): ...
def run(self, result=None): ...
def stop(self, _arg=None, **kwargs): ...
def wait(self, condition=None, timeout=5): ...
class AsyncHTTPTestCase(AsyncTestCase):
http_client = ... # type: Any
http_server = ... # type: Any
def setUp(self): ...
def get_http_client(self): ...
def get_http_server(self): ...
def get_app(self): ...
def fetch(self, path, **kwargs): ...
def get_httpserver_options(self): ...
def get_http_port(self): ...
def get_protocol(self): ...
def get_url(self, path): ...
def tearDown(self): ...
class AsyncHTTPSTestCase(AsyncHTTPTestCase):
def get_http_client(self): ...
def get_httpserver_options(self): ...
def get_ssl_options(self): ...
def get_protocol(self): ...
def gen_test(f): ...
class LogTrapTestCase(unittest.TestCase):
def run(self, result=None): ...
class ExpectLog(logging.Filter):
logger = ... # type: Any
regex = ... # type: Any
required = ... # type: Any
matched = ... # type: Any
def __init__(self, logger, regex, required=True): ...
def filter(self, record): ...
def __enter__(self): ...
def __exit__(self, typ, value, tb): ...
def main(**kwargs): ...
mypy-0.470/typeshed/third_party/2/tornado/httpserver.pyi 0000644 0000000 0000000 00000003426 13035744274 022154 0 ustar root root # Stubs for tornado.httpserver (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado import httputil
from tornado.tcpserver import TCPServer
from tornado.util import Configurable
class HTTPServer(TCPServer, Configurable, httputil.HTTPServerConnectionDelegate):
def __init__(self, *args, **kwargs) -> None: ...
request_callback = ... # type: Any
no_keep_alive = ... # type: Any
xheaders = ... # type: Any
protocol = ... # type: Any
conn_params = ... # type: Any
def initialize(self, request_callback, no_keep_alive=..., io_loop=..., xheaders=..., ssl_options=..., protocol=..., decompress_request=..., chunk_size=..., max_header_size=..., idle_connection_timeout=..., body_timeout=..., max_body_size=..., max_buffer_size=...): ...
@classmethod
def configurable_base(cls): ...
@classmethod
def configurable_default(cls): ...
def close_all_connections(self): ...
def handle_stream(self, stream, address): ...
def start_request(self, server_conn, request_conn): ...
def on_close(self, server_conn): ...
class _HTTPRequestContext:
address = ... # type: Any
protocol = ... # type: Any
address_family = ... # type: Any
remote_ip = ... # type: Any
def __init__(self, stream, address, protocol) -> None: ...
class _ServerRequestAdapter(httputil.HTTPMessageDelegate):
server = ... # type: Any
connection = ... # type: Any
request = ... # type: Any
delegate = ... # type: Any
def __init__(self, server, server_conn, request_conn) -> None: ...
def headers_received(self, start_line, headers): ...
def data_received(self, chunk): ...
def finish(self): ...
def on_connection_close(self): ...
HTTPRequest = ... # type: Any
mypy-0.470/typeshed/third_party/2/tornado/concurrent.pyi 0000644 0000000 0000000 00000002305 13035744274 022123 0 ustar root root # Stubs for tornado.concurrent (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
futures = ... # type: Any
class ReturnValueIgnoredError(Exception): ...
class _TracebackLogger:
exc_info = ... # type: Any
formatted_tb = ... # type: Any
def __init__(self, exc_info) -> None: ...
def activate(self): ...
def clear(self): ...
def __del__(self): ...
class Future:
def __init__(self) -> None: ...
def cancel(self): ...
def cancelled(self): ...
def running(self): ...
def done(self): ...
def result(self, timeout=...): ...
def exception(self, timeout=...): ...
def add_done_callback(self, fn): ...
def set_result(self, result): ...
def set_exception(self, exception): ...
def exc_info(self): ...
def set_exc_info(self, exc_info): ...
def __del__(self): ...
TracebackFuture = ... # type: Any
FUTURES = ... # type: Any
def is_future(x): ...
class DummyExecutor:
def submit(self, fn, *args, **kwargs): ...
def shutdown(self, wait=...): ...
dummy_executor = ... # type: Any
def run_on_executor(*args, **kwargs): ...
def return_future(f): ...
def chain_future(a, b): ...
mypy-0.470/typeshed/third_party/2/tornado/netutil.pyi 0000644 0000000 0000000 00000003107 13035744274 021426 0 ustar root root # Stubs for tornado.netutil (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from tornado.util import Configurable
ssl = ... # type: Any
certifi = ... # type: Any
xrange = ... # type: Any
ssl_match_hostname = ... # type: Any
SSLCertificateError = ... # type: Any
def bind_sockets(port, address=..., family=..., backlog=..., flags=...): ...
def bind_unix_socket(file, mode=..., backlog=...): ...
def add_accept_handler(sock, callback, io_loop=...): ...
def is_valid_ip(ip): ...
class Resolver(Configurable):
@classmethod
def configurable_base(cls): ...
@classmethod
def configurable_default(cls): ...
def resolve(self, host, port, family=..., callback=...): ...
def close(self): ...
class ExecutorResolver(Resolver):
io_loop = ... # type: Any
executor = ... # type: Any
close_executor = ... # type: Any
def initialize(self, io_loop=..., executor=..., close_executor=...): ...
def close(self): ...
def resolve(self, host, port, family=...): ...
class BlockingResolver(ExecutorResolver):
def initialize(self, io_loop=...): ...
class ThreadedResolver(ExecutorResolver):
def initialize(self, io_loop=..., num_threads=...): ...
class OverrideResolver(Resolver):
resolver = ... # type: Any
mapping = ... # type: Any
def initialize(self, resolver, mapping): ...
def close(self): ...
def resolve(self, host, port, *args, **kwargs): ...
def ssl_options_to_context(ssl_options): ...
def ssl_wrap_socket(socket, ssl_options, server_hostname=..., **kwargs): ...
mypy-0.470/typeshed/third_party/2/enum.pyi 0000644 0000000 0000000 00000000761 13023631176 017234 0 ustar root root from typing import List, Any, TypeVar
class Enum:
def __new__(cls, value: Any) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def __dir__(self) -> List[str]: ...
def __format__(self, format_spec: str) -> str: ...
def __hash__(self) -> Any: ...
def __reduce_ex__(self, proto: Any) -> Any: ...
name = ... # type: str
value = ... # type: Any
class IntEnum(int, Enum): ...
_T = TypeVar('_T')
def unique(enumeration: _T) -> _T: ...
mypy-0.470/typeshed/third_party/2/routes/ 0000755 0000000 0000000 00000000000 13044320557 017063 5 ustar root root mypy-0.470/typeshed/third_party/2/routes/__init__.pyi 0000644 0000000 0000000 00000000746 13035744274 021362 0 ustar root root # Stubs for routes (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import mapper
from . import util
class _RequestConfig:
def __getattr__(self, name): ...
def __setattr__(self, name, value): ...
def __delattr__(self, name): ...
def load_wsgi_environ(self, environ): ...
def request_config(original=...): ...
Mapper = mapper.Mapper
redirect_to = util.redirect_to
url_for = util.url_for
URLGenerator = util.URLGenerator
mypy-0.470/typeshed/third_party/2/routes/util.pyi 0000644 0000000 0000000 00000001316 13035744274 020572 0 ustar root root # Stubs for routes.util (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class RoutesException(Exception): ...
class MatchException(RoutesException): ...
class GenerationException(RoutesException): ...
def url_for(*args, **kargs): ...
class URLGenerator:
mapper = ... # type: Any
environ = ... # type: Any
def __init__(self, mapper, environ) -> None: ...
def __call__(self, *args, **kargs): ...
def current(self, *args, **kwargs): ...
def redirect_to(*args, **kargs): ...
def cache_hostinfo(environ): ...
def controller_scan(directory=...): ...
def as_unicode(value, encoding, errors=...): ...
def ascii_characters(string): ...
mypy-0.470/typeshed/third_party/2/routes/mapper.pyi 0000644 0000000 0000000 00000005373 13035744274 021110 0 ustar root root # Stubs for routes.mapper (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
COLLECTION_ACTIONS = ... # type: Any
MEMBER_ACTIONS = ... # type: Any
def strip_slashes(name): ...
class SubMapperParent:
def submapper(self, **kargs): ...
def collection(self, collection_name, resource_name, path_prefix=..., member_prefix=..., controller=..., collection_actions=..., member_actions=..., member_options=..., **kwargs): ...
class SubMapper(SubMapperParent):
kwargs = ... # type: Any
obj = ... # type: Any
collection_name = ... # type: Any
member = ... # type: Any
resource_name = ... # type: Any
formatted = ... # type: Any
def __init__(self, obj, resource_name=..., collection_name=..., actions=..., formatted=..., **kwargs) -> None: ...
def connect(self, *args, **kwargs): ...
def link(self, rel=..., name=..., action=..., method=..., formatted=..., **kwargs): ...
def new(self, **kwargs): ...
def edit(self, **kwargs): ...
def action(self, name=..., action=..., method=..., formatted=..., **kwargs): ...
def index(self, name=..., **kwargs): ...
def show(self, name=..., **kwargs): ...
def create(self, **kwargs): ...
def update(self, **kwargs): ...
def delete(self, **kwargs): ...
def add_actions(self, actions): ...
def __enter__(self): ...
def __exit__(self, type, value, tb): ...
class Mapper(SubMapperParent):
matchlist = ... # type: Any
maxkeys = ... # type: Any
minkeys = ... # type: Any
urlcache = ... # type: Any
prefix = ... # type: Any
req_data = ... # type: Any
directory = ... # type: Any
always_scan = ... # type: Any
controller_scan = ... # type: Any
debug = ... # type: Any
append_slash = ... # type: Any
sub_domains = ... # type: Any
sub_domains_ignore = ... # type: Any
domain_match = ... # type: Any
explicit = ... # type: Any
encoding = ... # type: Any
decode_errors = ... # type: Any
hardcode_names = ... # type: Any
minimization = ... # type: Any
create_regs_lock = ... # type: Any
def __init__(self, controller_scan=..., directory=..., always_scan=..., register=..., explicit=...) -> None: ...
environ = ... # type: Any
def extend(self, routes, path_prefix=...): ...
def make_route(self, *args, **kargs): ...
def connect(self, *args, **kargs): ...
def create_regs(self, *args, **kwargs): ...
def match(self, url=..., environ=...): ...
def routematch(self, url=..., environ=...): ...
obj = ... # type: Any
def generate(self, *args, **kargs): ...
def resource(self, member_name, collection_name, **kwargs): ...
def redirect(self, match_path, destination_path, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/2/itsdangerous.pyi 0000644 0000000 0000000 00000016605 13035744274 021012 0 ustar root root # Stubs for itsdangerous (Python 2.7)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from datetime import datetime
from itertools import izip
from typing import Any, Callable, IO, MutableMapping, Optional, Text, Tuple, Union
PY2 = ... # type: bool
text_type = unicode
int_to_byte = chr
number_types = (int, long, float)
bytes_like = Union[bytearray, str]
class _CompactJSON:
def loads(self, payload: Text) -> Any: ...
def dumps(self, obj: Any) -> Text: ...
compact_json = _CompactJSON
EPOCH = ... # type: int
def want_bytes(s: str, encoding='', errors='') -> str: ...
def is_text_serializer(serializer: Any) -> bool: ...
def constant_time_compare(val1: bytes_like, val2: bytes_like) -> bool: ...
class BadData(Exception):
message = ... # type: str
def __init__(self, message: str) -> None: ...
class BadPayload(BadData):
original_error = ... # type: Optional[Exception]
def __init__(self, message: str, original_error: Optional[Exception]=None) -> None: ...
class BadSignature(BadData):
payload = ... # type: Optional[Any]
def __init__(self, message: str, payload: Optional[Any]=None) -> None: ...
class BadTimeSignature(BadSignature):
date_signed = ... # type: Optional[int]
def __init__(self, message, payload: Optional[Any]=None, date_signed: Optional[int]=None) -> None: ...
class BadHeader(BadSignature):
header = ... # type: Any
original_error = ... # type: Any
def __init__(self, message, payload=None, header=None, original_error=None) -> None: ...
class SignatureExpired(BadTimeSignature): ...
def base64_encode(string: bytes_like) -> str: ...
def base64_decode(string: bytes_like) -> str: ...
def int_to_bytes(num: int) -> str: ...
def bytes_to_int(bytestr: bytes_like) -> int: ...
class SigningAlgorithm:
def get_signature(self, key: bytes_like, value: bytes_like) -> str: ...
def verify_signature(self, key: bytes_like, value: bytes_like, sig: bytes_like) -> bool: ...
class NoneAlgorithm(SigningAlgorithm):
def get_signature(self, key: bytes_like, value: bytes_like) -> str: ...
class HMACAlgorithm(SigningAlgorithm):
default_digest_method = ... # type: Callable
digest_method = ... # type: Callable
def __init__(self, digest_method: Optional[Callable]=None) -> None: ...
def get_signature(self, key: bytes_like, value: bytes_like) -> str: ...
class Signer:
default_digest_method = ... # type: Callable
default_key_derivation = ... # type: str
secret_key = ... # type: bytes_like
sep = ... # type: str
salt = ... # type: bytes_like
key_derivation = ... # type: str
digest_method = ... # type: Callable
algorithm = ... # type: SigningAlgorithm
def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like]=None, sep: Optional[str]='',
key_derivation: Optional[str]=None,
digest_method: Optional[Callable]=None,
algorithm: Optional[SigningAlgorithm]=None) -> None: ...
def derive_key(self) -> str: ...
def get_signature(self, value: bytes_like) -> str: ...
def sign(self, value: bytes_like) -> str: ...
def verify_signature(self, value: bytes_like, sig: bytes_like) -> bool: ...
def unsign(self, signed_value: str) -> str: ...
def validate(self, signed_value: str) -> bool: ...
class TimestampSigner(Signer):
def get_timestamp(self) -> int: ...
def timestamp_to_datetime(self, ts: int) -> datetime: ...
def sign(self, value: bytes_like) -> str: ...
def unsign(self, value: str, max_age: Optional[int]=None, return_timestamp=False) -> Any: ...
def validate(self, signed_value: str, max_age: Optional[int]=None) -> bool: ...
class Serializer:
default_serializer = ... # type: Any
default_signer = ... # type: Callable[..., Signer]
secret_key = ... # type: Any
salt = ... # type: bytes_like
serializer = ... # type: Any
is_text_serializer = ... # type: bool
signer = ... # type: Signer
signer_kwargs = ... # type: MutableMapping
def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like]=b'', serializer=None, signer: Optional[Callable[..., Signer]]=None, signer_kwargs: Optional[MutableMapping]=None) -> None: ...
def load_payload(self, payload: Any, serializer=None) -> Any: ...
def dump_payload(self, *args, **kwargs) -> str: ...
def make_signer(self, salt: Optional[bytes_like]=None) -> Signer: ...
def dumps(self, obj: Any, salt: Optional[bytes_like]=None) -> str: ...
def dump(self, obj: Any, f: IO[str], salt: Optional[bytes_like]=None) -> None: ...
def loads(self, s: str, salt: Optional[bytes_like]=None) -> Any: ...
def load(self, f: IO[str], salt: Optional[bytes_like]=None): ...
def loads_unsafe(self, s, salt: Optional[bytes_like]=None) -> Tuple[bool, Any]: ...
def load_unsafe(self, f: IO[str], *args, **kwargs) -> Tuple[bool, Any]: ...
class TimedSerializer(Serializer):
default_signer = ... # type: Callable[..., TimestampSigner]
def loads(self, s: str, salt: Optional[bytes_like]=None, max_age: Optional[int]=None, return_timestamp=False) -> Any: ...
def loads_unsafe(self, s: str, salt: Optional[bytes_like]=None, max_age: Optional[int]=None) -> Tuple[bool, Any]: ...
class JSONWebSignatureSerializer(Serializer):
jws_algorithms = ... # type: MutableMapping[str, SigningAlgorithm]
default_algorithm = ... # type: str
default_serializer = ... # type: Any
algorithm_name = ... # type: str
algorithm = ... # type: Any
def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like]=None, serializer=None, signer: Optional[Callable[..., Signer]]=None, signer_kwargs: Optional[MutableMapping]=None, algorithm_name: Optional[str]=None) -> None: ...
def load_payload(self, payload: Any, return_header=False) -> Any: ...
def dump_payload(self, *args, **kwargs) -> str: ...
def make_algorithm(self, algorithm_name: str) -> SigningAlgorithm: ...
def make_signer(self, salt: Optional[bytes_like]=None, algorithm_name: Optional[str]=None) -> Signer: ...
def make_header(self, header_fields=Optional[MutableMapping]) -> MutableMapping: ...
def dumps(self, obj: Any, salt: Optional[bytes_like]=None, header_fields=Optional[MutableMapping]) -> str: ...
def loads(self, s: str, salt: Optional[bytes_like]=None, return_header=False) -> Any: ...
def loads_unsafe(self, s, salt: Optional[bytes_like]=None, return_header=False) -> Tuple[bool, Any]: ...
class TimedJSONWebSignatureSerializer(JSONWebSignatureSerializer):
DEFAULT_EXPIRES_IN = ... # type: int
expires_in = ... # type: int
def __init__(self, secret_key: bytes_like, expires_in: Optional[int]=None, **kwargs) -> None: ...
def make_header(self, header_fields=Optional[MutableMapping]) -> MutableMapping: ...
def loads(self, s: str, salt: Optional[bytes_like]=None, return_header=False) -> Any: ...
def get_issue_date(self, header: MutableMapping) -> Optional[datetime]: ...
def now(self) -> int: ...
class URLSafeSerializerMixin:
def load_payload(self, payload: Any, serializer=None, return_header=False, **kwargs) -> Any: ... # FIXME: This is invalid but works around https://github.com/pallets/itsdangerous/issues/74
def dump_payload(self, *args, **kwargs) -> str: ...
class URLSafeSerializer(URLSafeSerializerMixin, Serializer):
default_serializer = ... # type: Any
class URLSafeTimedSerializer(URLSafeSerializerMixin, TimedSerializer):
default_serializer = ... # type: Any
mypy-0.470/typeshed/third_party/2/gflags.pyi 0000644 0000000 0000000 00000022124 13035744274 017537 0 ustar root root from typing import Any, Callable, Dict, Iterable, IO, List, Union
from types import ModuleType
class FlagsError(Exception): ...
class DuplicateFlag(FlagsError): ...
class CantOpenFlagFileError(FlagsError): ...
class DuplicateFlagCannotPropagateNoneToSwig(DuplicateFlag): ...
class DuplicateFlagError(DuplicateFlag):
def __init__(self, flagname: str, flag_values: FlagValues, other_flag_values: FlagValues = ...) -> None: ...
class IllegalFlagValue(FlagsError): ...
class UnrecognizedFlag(FlagsError): ...
class UnrecognizedFlagError(UnrecognizedFlag):
def __init__(self, flagname: str, flagvalue: str = ...) -> None: ...
def GetHelpWidth() -> int: ...
def CutCommonSpacePrefix(text) -> str: ...
def TextWrap(text: str, length: int = ..., indent: str = ..., firstline_indent: str = ..., tabs: str = ...) -> str: ...
def DocToHelp(doc: str) -> str: ...
class FlagValues:
def __init__(self) -> None: ...
def UseGnuGetOpt(self, use_gnu_getopt: bool = ...) -> None: ...
def IsGnuGetOpt(self) -> bool: ...
# TODO dict type
def FlagDict(self) -> dict: ...
def FlagsByModuleDict(self) -> Dict[str, List[Flag]]: ...
def FlagsByModuleIdDict(self) -> Dict[int, List[Flag]]: ...
def KeyFlagsByModuleDict(self) -> Dict[str, List[Flag]]: ...
def FindModuleDefiningFlag(self, flagname: str, default: str = ...) -> str: ...
def FindModuleIdDefiningFlag(self, flagname: str, default: int = ...) -> int: ...
def AppendFlagValues(self, flag_values: FlagValues) -> None: ...
def RemoveFlagValues(self, flag_values: FlagValues) -> None: ...
def __setitem__(self, name: str, flag: Flag) -> None: ...
def __getitem__(self, name: str) -> Flag: ...
def __getattr__(self, name: str) -> Any: ...
def __setattr__(self, name: str, value: Any): ...
def __delattr__(self, flag_name: str) -> None: ...
def SetDefault(self, name: str, value: Any) -> None: ...
def __contains__(self, name: str) -> bool: ...
has_key = __contains__
def __iter__(self) -> Iterable[str]: ...
def __call__(self, argv: List[str]) -> List[str]: ...
def Reset(self) -> None: ...
def RegisteredFlags(self) -> List[str]: ...
def FlagValuesDict(self) -> Dict[str, Any]: ...
def __str__(self) -> str: ...
def GetHelp(self, prefix: str = ...) -> str: ...
def ModuleHelp(self, module: Union[ModuleType, str]) -> str: ...
def MainModuleHelp(self) -> str: ...
def get(self, name: str, default: Any) -> Any: ...
def ShortestUniquePrefixes(self, fl: Dict[str, Flag]) -> Dict[str, str]: ...
def ExtractFilename(self, flagfile_str: str) -> str: ...
def ReadFlagsFromFiles(self, argv: List[str], force_gnu: bool = ...) -> List[str]: ...
def FlagsIntoString(self) -> str: ...
def AppendFlagsIntoFile(self, filename: str) -> None: ...
def WriteHelpInXMLFormat(self, outfile: IO[str] = ...) -> None: ...
# TODO validator: gflags_validators.Validator
def AddValidator(self, validator: Any) -> None: ...
FLAGS = ... # type: FlagValues
class Flag:
name = ... # type: str
default = ... # type: Any
default_as_str = ... # type: str
value = ... # type: Any
help = ... # type: str
short_name = ... # type: str
boolean = False
present = False
parser = ... # type: ArgumentParser
serializer = ... # type: ArgumentSerializer
allow_override = False
def __init__(self, parser: ArgumentParser, serializer: ArgumentSerializer, name: str,
default: str, help_string: str, short_name: str = ..., boolean: bool = ...,
allow_override: bool = ...) -> None: ...
def Parse(self, argument: Any) -> Any: ...
def Unparse(self) -> None: ...
def Serialize(self) -> str: ...
def SetDefault(self, value: Any) -> None: ...
def Type(self) -> str: ...
def WriteInfoInXMLFormat(self, outfile: IO[str], module_name: str, is_key: bool = ..., indent: str = ...) -> None: ...
class ArgumentParser(object):
syntactic_help = ... # type: str
# TODO what is this
def Parse(self, argument: Any) -> Any: ...
def Type(self) -> str: ...
def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ...
class ArgumentSerializer:
def Serialize(self, value: Any) -> unicode: ...
class ListSerializer(ArgumentSerializer):
def __init__(self, list_sep: str) -> None: ...
def Serialize(self, value: List[Any]) -> str: ...
def RegisterValidator(flag_name: str,
checker: Callable[[Any], bool],
message: str = ...,
flag_values: FlagValues = ...) -> None: ...
def MarkFlagAsRequired(flag_name: str, flag_values: FlagValues = ...) -> None: ...
def DEFINE(parser: ArgumentParser, name: str, default: Any, help: str,
flag_values: FlagValues = ..., serializer: ArgumentSerializer = ..., **args: Any) -> None: ...
def DEFINE_flag(flag: Flag, flag_values: FlagValues = ...) -> None: ...
def DECLARE_key_flag(flag_name: str, flag_values: FlagValues = ...) -> None: ...
def ADOPT_module_key_flags(module: ModuleType, flag_values: FlagValues = ...) -> None: ...
def DEFINE_string(name: str, default: str, help: str, flag_values: FlagValues = ..., **args: Any): ...
class BooleanParser(ArgumentParser):
def Convert(self, argument: Any) -> bool: ...
def Parse(self, argument: Any) -> bool: ...
def Type(self) -> str: ...
class BooleanFlag(Flag):
def __init__(self, name: str, default: bool, help: str, short_name=..., **args: Any) -> None: ...
def DEFINE_boolean(name: str, default: bool, help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...
DEFINE_bool = DEFINE_boolean
class HelpFlag(BooleanFlag):
def __init__(self) -> None: ...
def Parse(self, arg: Any) -> None: ...
class HelpXMLFlag(BooleanFlag):
def __init__(self) -> None: ...
def Parse(self, arg: Any) -> None: ...
class HelpshortFlag(BooleanFlag):
def __init__(self) -> None: ...
def Parse(self, arg: Any) -> None: ...
class NumericParser(ArgumentParser):
def IsOutsideBounds(self, val: float) -> bool: ...
def Parse(self, argument: Any) -> float: ...
def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ...
def Convert(self, argument: Any) -> Any: ...
class FloatParser(NumericParser):
number_article = ... # type: str
number_name = ... # type: str
syntactic_help = ... # type: str
def __init__(self, lower_bound: float = ..., upper_bound: float = ...) -> None: ...
def Convert(self, argument: Any) -> float: ...
def Type(self) -> str: ...
def DEFINE_float(name: str, default: float, help: str, lower_bound: float = ...,
upper_bound: float = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...
class IntegerParser(NumericParser):
number_article = ... # type: str
number_name = ... # type: str
syntactic_help = ... # type: str
def __init__(self, lower_bound: int = ..., upper_bound: int = ...) -> None: ...
def Convert(self, argument: Any) -> int: ...
def Type(self) -> str: ...
def DEFINE_integer(name: str, default: int, help: str, lower_bound: int = ...,
upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...
class EnumParser(ArgumentParser):
def __init__(self, enum_values: List[str]) -> None: ...
def Parse(self, argument: Any) -> Any: ...
def Type(self) -> str: ...
class EnumFlag(Flag):
def __init__(self, name: str, default: str, help: str, enum_values: List[str],
short_name: str, **args: Any) -> None: ...
def DEFINE_enum(name: str, default: str, enum_values: List[str], help: str,
flag_values: FlagValues = ..., **args: Any) -> None: ...
class BaseListParser(ArgumentParser):
def __init__(self, token: str = ..., name: str = ...) -> None: ...
def Parse(self, argument: Any) -> list: ...
def Type(self) -> str: ...
class ListParser(BaseListParser):
def __init__(self) -> None: ...
def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str): ...
class WhitespaceSeparatedListParser(BaseListParser):
def __init__(self) -> None: ...
def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str): ...
def DEFINE_list(name: str, default: List[str], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...
def DEFINE_spaceseplist(name: str, default: List[str], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...
class MultiFlag(Flag):
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
def Parse(self, arguments: Any) -> None: ...
def Serialize(self) -> str: ...
def Type(self) -> str: ...
def DEFINE_multistring(name: str, default: Union[str, List[str]], help: str,
flag_values: FlagValues = ..., **args: Any) -> None: ...
def DEFINE_multi_int(name: str, default: Union[int, List[int]], help: str, lower_bound: int = ...,
upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...
def DEFINE_multi_float(name: str, default: Union[float, List[float]], help: str,
lower_bound: float = ..., upper_bound: float = ...,
flag_values: FlagValues = ..., **args: Any) -> None: ...
mypy-0.470/typeshed/third_party/2/pymssql.pyi 0000644 0000000 0000000 00000003543 13035744274 020010 0 ustar root root from datetime import datetime, date, time
from typing import Any, Dict, Tuple, Iterable, List, Optional, Union, Sequence
Scalar = Union[int, float, str, datetime, date, time]
Result = Union[Tuple[Scalar, ...], Dict[str, Scalar]]
class Connection(object):
def __init__(self, user, password, host, database, timeout,
login_timeout, charset, as_dict) -> None: ...
def autocommit(self, status: bool) -> None: ...
def close(self) -> None: ...
def commit(self) -> None: ...
def cursor(self) -> 'Cursor': ...
def rollback(self) -> None: ...
class Cursor(object):
def __init__(self) -> None: ...
def __iter__(self): ...
def __next__(self) -> Any: ...
def callproc(self, procname: str, **kwargs) -> None: ...
def close(self) -> None: ...
def execute(self, stmt: str,
params: Optional[Union[Scalar, Tuple[Scalar, ...],
Dict[str, Scalar]]]) -> None: ...
def executemany(self, stmt: str,
params: Optional[Sequence[Tuple[Scalar, ...]]]) -> None: ...
def fetchall(self) -> List[Result]: ...
def fetchmany(self, size: Optional[Union[int, None]]) -> List[Result]: ...
def fetchone(self) -> Result: ...
def connect(server: Optional[str],
user: Optional[str],
password: Optional[str],
database: Optional[str],
timeout: Optional[int],
login_timeout: Optional[int],
charset: Optional[str],
as_dict: Optional[bool],
host: Optional[str],
appname: Optional[str],
port: Optional[str],
conn_properties: Optional[Union[str, Sequence[str]]],
autocommit: Optional[bool],
tds_version: Optional[str]) -> Connection: ...
def get_max_connections() -> int: ...
def set_max_connections(n: int) -> None: ...
mypy-0.470/typeshed/third_party/2/selenium/ 0000755 0000000 0000000 00000000000 13044320557 017363 5 ustar root root mypy-0.470/typeshed/third_party/2/selenium/webdriver/ 0000755 0000000 0000000 00000000000 13044320557 021354 5 ustar root root mypy-0.470/typeshed/third_party/2/selenium/webdriver/remote/ 0000755 0000000 0000000 00000000000 13044320557 022647 5 ustar root root mypy-0.470/typeshed/third_party/2/selenium/webdriver/remote/webelement.pyi 0000644 0000000 0000000 00000006047 13035744274 025536 0 ustar root root # Stubs for selenium.webdriver.remote.webelement (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from selenium.webdriver.remote.webdriver import WebDriver
from typing import Any, Optional, Dict, List
SizeDict = Dict[str, int] # containing "height", "width"
PointDict = Dict[str, int] # containing "x", "y"
class WebElement:
def __init__(self, parent: WebDriver, id_: Optional[basestring], w3c: bool=False) -> None: ...
@property
def tag_name(self) -> basestring: ...
@property
def text(self) -> Optional[basestring]: ...
def click(self) -> None: ...
def submit(self) -> None: ...
def clear(self) -> None: ...
def get_attribute(self, name: basestring) -> Optional[basestring]: ...
def is_selected(self) -> bool: ...
def is_enabled(self) -> bool: ...
def find_element_by_id(self, id_: basestring) -> WebElement: ...
def find_elements_by_id(self, id_: basestring) -> List[WebElement]: ...
def find_element_by_name(self, name: basestring) -> WebElement: ...
def find_elements_by_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_link_text(self, link_text: basestring) -> WebElement: ...
def find_elements_by_link_text(self, link_text: basestring) -> List[WebElement]: ...
def find_element_by_partial_link_text(self, link_text: basestring) -> WebElement: ...
def find_elements_by_partial_link_text(self, link_text: basestring) -> List[WebElement]: ...
def find_element_by_tag_name(self, name: basestring) -> WebElement: ...
def find_elements_by_tag_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_xpath(self, xpath: basestring) -> WebElement: ...
def find_elements_by_xpath(self, xpath: basestring) -> List[WebElement]: ...
def find_element_by_class_name(self, name: basestring) -> WebElement: ...
def find_elements_by_class_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_css_selector(self, css_selector: basestring) -> WebElement: ...
def find_elements_by_css_selector(self, css_selector: basestring) -> List[WebElement]: ...
def send_keys(self, *value: basestring) -> None: ...
def is_displayed(self) -> bool: ...
@property
def location_once_scrolled_into_view(self): ...
@property
def size(self) -> SizeDict: ...
def value_of_css_property(self, property_name): ...
@property
def location(self) -> PointDict: ...
@property
def rect(self): ...
@property
def screenshot_as_base64(self): ...
@property
def screenshot_as_png(self): ...
def screenshot(self, filename: basestring): ...
@property
def parent(self) -> WebDriver: ...
@property
def id(self) -> Optional[basestring]: ...
def __eq__(self, element: object) -> bool: ...
def __ne__(self, element: object) -> bool: ...
def find_element(self, by: basestring=..., value: basestring=None) -> WebElement: ...
def find_elements(self, by: basestring=..., value: basestring=None) -> List[WebElement]: ...
def __hash__(self) -> int: ...
mypy-0.470/typeshed/third_party/2/selenium/webdriver/remote/webdriver.pyi 0000644 0000000 0000000 00000011471 13035744274 025375 0 ustar root root # Stubs for selenium.webdriver.remote.webdriver (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Dict, List, Optional
from .mobile import Mobile as Mobile
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.remote.errorhandler import ErrorHandler
from selenium.webdriver.remote.file_detector import FileDetector
Capabilities = Dict[basestring, Any]
ExecuteResult = Dict[basestring, Any] # containing 'success', 'value', 'sessionId'
class WebDriver:
command_executor = ... # type: basestring
session_id = ... # type: Any
capabilities = ... # type: Capabilities
error_handler = ... # type: ErrorHandler
file_detector = ... # type: FileDetector
def __init__(self,
command_executor: basestring='',
desired_capabilities: Capabilities=None,
browser_profile=None,
proxy=None,
keep_alive: bool=False
) -> None: ...
@property
def mobile(self) -> Mobile: ...
@property
def name(self) -> basestring: ...
def start_client(self): ...
def stop_client(self): ...
w3c = ... # type: Any
def start_session(self, desired_capabilities, browser_profile=None): ...
def create_web_element(self, element_id: basestring) -> WebElement: ...
def execute(self, driver_command: basestring, params: Optional[Dict[basestring, Any]]=None) -> ExecuteResult: ...
def get(self, url: basestring) -> None: ...
@property
def title(self) -> basestring: ...
def find_element_by_id(self, id_: basestring) -> WebElement: ...
def find_elements_by_id(self, id_: basestring) -> List[WebElement]: ...
def find_element_by_xpath(self, xpath: basestring) -> WebElement: ...
def find_elements_by_xpath(self, xpath: basestring) -> List[WebElement]: ...
def find_element_by_link_text(self, link_text: basestring) -> WebElement: ...
def find_elements_by_link_text(self, text: basestring) -> List[WebElement]: ...
def find_element_by_partial_link_text(self, link_text: basestring) -> WebElement: ...
def find_elements_by_partial_link_text(self, link_text: basestring) -> List[WebElement]: ...
def find_element_by_name(self, name: basestring) -> WebElement: ...
def find_elements_by_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_tag_name(self, name: basestring) -> WebElement: ...
def find_elements_by_tag_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_class_name(self, name: basestring) -> WebElement: ...
def find_elements_by_class_name(self, name: basestring) -> List[WebElement]: ...
def find_element_by_css_selector(self, css_selector: basestring) -> WebElement: ...
def find_elements_by_css_selector(self, css_selector: basestring) -> List[WebElement]: ...
def execute_script(self, script, *args): ...
def execute_async_script(self, script, *args): ...
@property
def current_url(self) -> basestring: ...
@property
def page_source(self): ...
def close(self): ...
def quit(self): ...
@property
def current_window_handle(self): ...
@property
def window_handles(self): ...
def maximize_window(self): ...
@property
def switch_to(self): ...
def switch_to_active_element(self): ...
def switch_to_window(self, window_name): ...
def switch_to_frame(self, frame_reference): ...
def switch_to_default_content(self): ...
def switch_to_alert(self): ...
def back(self): ...
def forward(self): ...
def refresh(self): ...
def get_cookies(self): ...
def get_cookie(self, name): ...
def delete_cookie(self, name): ...
def delete_all_cookies(self): ...
def add_cookie(self, cookie_dict): ...
def implicitly_wait(self, time_to_wait): ...
def set_script_timeout(self, time_to_wait): ...
def set_page_load_timeout(self, time_to_wait): ...
def find_element(self, by=..., value=None): ...
def find_elements(self, by=..., value=None): ...
@property
def desired_capabilities(self): ...
def get_screenshot_as_file(self, filename): ...
save_screenshot = ... # type: Any
def get_screenshot_as_png(self): ...
def get_screenshot_as_base64(self): ...
def set_window_size(self, width, height, windowHandle=''): ...
def get_window_size(self, windowHandle=''): ...
def set_window_position(self, x, y, windowHandle=''): ...
def get_window_position(self, windowHandle=''): ...
@property
def file_detector(self): ...
@file_detector.setter
def file_detector(self, detector): ...
@property
def orientation(self): ...
@orientation.setter
def orientation(self, value): ...
@property
def application_cache(self): ...
@property
def log_types(self): ...
def get_log(self, log_type): ...
mypy-0.470/typeshed/third_party/2and3/ 0000755 0000000 0000000 00000000000 13044320557 016310 5 ustar root root mypy-0.470/typeshed/third_party/2and3/characteristic/ 0000755 0000000 0000000 00000000000 13044320557 021300 5 ustar root root mypy-0.470/typeshed/third_party/2and3/characteristic/__init__.pyi 0000644 0000000 0000000 00000002501 13035744274 023566 0 ustar root root from typing import Sequence, Callable, Union, Any, Optional, AnyStr, TypeVar, Type
def with_repr(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ...
def with_cmp(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ...
def with_init(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ...
def immutable(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ...
def strip_leading_underscores(attribute_name: AnyStr) -> AnyStr: ...
NOTHING = Any
T = TypeVar('T')
def attributes(
attrs: Sequence[Union[AnyStr, Attribute]],
apply_with_cmp: bool = True,
apply_with_init: bool = True,
apply_with_repr: bool = True,
apply_immutable: bool = False,
store_attributes: Optional[Callable[[type, Attribute], Any]] = None,
**kw: Optional[dict]) -> Callable[[Type[T]], Type[T]]: ...
class Attribute:
def __init__(
self,
name: AnyStr,
exclude_from_cmp: bool = False,
exclude_from_init: bool = False,
exclude_from_repr: bool = False,
exclude_from_immutable: bool = False,
default_value: Any = NOTHING,
default_factory: Optional[Callable[[None], Any]] = None,
instance_of: Optional[Any] = None,
init_aliaser: Optional[Callable[[AnyStr], AnyStr]] = strip_leading_underscores) -> None: ...
mypy-0.470/typeshed/third_party/2and3/Crypto/ 0000755 0000000 0000000 00000000000 13044320557 017570 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Signature/ 0000755 0000000 0000000 00000000000 13044320557 021531 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Signature/__init__.pyi 0000644 0000000 0000000 00000000275 13035744274 024025 0 ustar root root # Stubs for Crypto.Signature (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# PKCS1_PSS
# PKCS1_v1_5
mypy-0.470/typeshed/third_party/2and3/Crypto/Signature/PKCS1_PSS.pyi 0000644 0000000 0000000 00000000641 13035744274 023631 0 ustar root root # Stubs for Crypto.Signature.PKCS1_PSS (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class PSS_SigScheme:
def __init__(self, key, mgfunc, saltLen) -> None: ...
def can_sign(self): ...
def sign(self, mhash): ...
def verify(self, mhash, S): ...
def new(key, mgfunc: Optional[Any] = ..., saltLen: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Signature/PKCS1_v1_5.pyi 0000644 0000000 0000000 00000000471 13035744274 023737 0 ustar root root # Stubs for Crypto.Signature.PKCS1_v1_5 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class PKCS115_SigScheme:
def __init__(self, key) -> None: ...
def can_sign(self): ...
def sign(self, mhash): ...
def verify(self, mhash, S): ...
def new(key): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/__init__.pyi 0000644 0000000 0000000 00000000334 13035744274 022060 0 ustar root root # Stubs for Crypto (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# Cipher
# Hash
# Protocol
# PublicKey
# Signature
# Util
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/ 0000755 0000000 0000000 00000000000 13044320557 020505 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Util/__init__.pyi 0000644 0000000 0000000 00000000323 13035744274 022773 0 ustar root root # Stubs for Crypto.Util (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# RFC1751
# asn1
# number
# randpool
# strxor
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/randpool.pyi 0000644 0000000 0000000 00000001312 13035744274 023051 0 ustar root root # Stubs for Crypto.Util.randpool (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
__revision__ = ... # type: str
class RandomPool:
bytes = ... # type: Any
bits = ... # type: Any
entropy = ... # type: Any
def __init__(self, numbytes: int = ..., cipher: Optional[Any] = ..., hash: Optional[Any] = ..., file: Optional[Any] = ...) -> None: ...
def get_bytes(self, N): ...
def randomize(self, N: int = ...): ...
def stir(self, s: str = ...): ...
def stir_n(self, N: int = ...): ...
def add_event(self, s: str = ...): ...
def getBytes(self, N): ...
def addEvent(self, event, s: str = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/RFC1751.pyi 0000644 0000000 0000000 00000000444 13035744274 022170 0 ustar root root # Stubs for Crypto.Util.RFC1751 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
__revision__ = ... # type: str
binary = ... # type: Any
def key_to_english(key): ...
def english_to_key(s): ...
wordlist = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/strxor.pyi 0000644 0000000 0000000 00000000277 13035744274 022605 0 ustar root root # Stubs for Crypto.Util.strxor (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def strxor(*args, **kwargs): ...
def strxor_c(*args, **kwargs): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/number.pyi 0000644 0000000 0000000 00000001706 13035744274 022532 0 ustar root root # Stubs for Crypto.Util.number (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from warnings import warn as _warn
__revision__ = ... # type: str
bignum = ... # type: Any
def size(N): ...
def getRandomNumber(N, randfunc: Optional[Any] = ...): ...
def getRandomInteger(N, randfunc: Optional[Any] = ...): ...
def getRandomRange(a, b, randfunc: Optional[Any] = ...): ...
def getRandomNBitInteger(N, randfunc: Optional[Any] = ...): ...
def GCD(x, y): ...
def inverse(u, v): ...
def getPrime(N, randfunc: Optional[Any] = ...): ...
def getStrongPrime(N, e: int = ..., false_positive_prob: float = ..., randfunc: Optional[Any] = ...): ...
def isPrime(N, false_positive_prob: float = ..., randfunc: Optional[Any] = ...): ...
def long_to_bytes(n, blocksize: int = ...): ...
def bytes_to_long(s): ...
def long2str(n, blocksize: int = ...): ...
def str2long(s): ...
sieve_base = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/asn1.pyi 0000644 0000000 0000000 00000003137 13035744274 022104 0 ustar root root # Stubs for Crypto.Util.asn1 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class DerObject:
typeTags = ... # type: Any
typeTag = ... # type: Any
payload = ... # type: Any
def __init__(self, ASN1Type: Optional[Any] = ..., payload: Any = ...) -> None: ...
def isType(self, ASN1Type): ...
def encode(self): ...
def decode(self, derEle, noLeftOvers: int = ...): ...
class DerInteger(DerObject):
value = ... # type: Any
def __init__(self, value: int = ...) -> None: ...
payload = ... # type: Any
def encode(self): ...
def decode(self, derEle, noLeftOvers: int = ...): ...
class DerSequence(DerObject):
def __init__(self, startSeq: Optional[Any] = ...) -> None: ...
def __delitem__(self, n): ...
def __getitem__(self, n): ...
def __setitem__(self, key, value): ...
def __setslice__(self, i, j, sequence): ...
def __delslice__(self, i, j): ...
def __getslice__(self, i, j): ...
def __len__(self): ...
def append(self, item): ...
def hasInts(self): ...
def hasOnlyInts(self): ...
payload = ... # type: Any
def encode(self): ...
def decode(self, derEle, noLeftOvers: int = ...): ...
class DerOctetString(DerObject):
payload = ... # type: Any
def __init__(self, value: Any = ...) -> None: ...
def decode(self, derEle, noLeftOvers: int = ...): ...
class DerNull(DerObject):
def __init__(self) -> None: ...
class DerObjectId(DerObject):
def __init__(self) -> None: ...
def decode(self, derEle, noLeftOvers: int = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Util/Counter.pyi 0000644 0000000 0000000 00000000524 13035744274 022656 0 ustar root root # Stubs for Crypto.Util.Counter (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def new(nbits, prefix: Any = ..., suffix: Any = ..., initial_value: int = ..., overflow: int = ..., little_endian: bool = ..., allow_wraparound: bool = ..., disable_shortcut: bool = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Protocol/ 0000755 0000000 0000000 00000000000 13044320557 021371 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Protocol/__init__.pyi 0000644 0000000 0000000 00000000305 13035744274 023657 0 ustar root root # Stubs for Crypto.Protocol (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# AllOrNothing
# Chaffing
# KDF
mypy-0.470/typeshed/third_party/2and3/Crypto/Protocol/Chaffing.pyi 0000644 0000000 0000000 00000000437 13035744274 023633 0 ustar root root # Stubs for Crypto.Protocol.Chaffing (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
__revision__ = ... # type: str
class Chaff:
def __init__(self, factor: float = ..., blocksper: int = ...) -> None: ...
def chaff(self, blocks): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Protocol/KDF.pyi 0000644 0000000 0000000 00000000631 13035744274 022526 0 ustar root root # Stubs for Crypto.Protocol.KDF (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash import SHA as SHA1
__revision__ = ... # type: str
def PBKDF1(password, salt, dkLen, count: int = ..., hashAlgo: Optional[Any] = ...): ...
def PBKDF2(password, salt, dkLen: int = ..., count: int = ..., prf: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Protocol/AllOrNothing.pyi 0000644 0000000 0000000 00000000631 13035744274 024462 0 ustar root root # Stubs for Crypto.Protocol.AllOrNothing (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
__revision__ = ... # type: str
def isInt(x): ...
class AllOrNothing:
def __init__(self, ciphermodule, mode: Optional[Any] = ..., IV: Optional[Any] = ...) -> None: ...
def digest(self, text): ...
def undigest(self, blocks): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/ 0000755 0000000 0000000 00000000000 13044320557 020453 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/SHA.pyi 0000644 0000000 0000000 00000000770 13035744274 021623 0 ustar root root # Stubs for Crypto.Hash.SHA (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class SHA1Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/__init__.pyi 0000644 0000000 0000000 00000000373 13035744274 022746 0 ustar root root # Stubs for Crypto.Hash (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# HMAC
# MD2
# MD4
# MD5
# RIPEMD
# SHA
# SHA224
# SHA256
# SHA384
# SHA512
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/SHA256.pyi 0000644 0000000 0000000 00000000775 13035744274 022065 0 ustar root root # Stubs for Crypto.Hash.SHA256 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class SHA256Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/hashalgo.pyi 0000644 0000000 0000000 00000000741 13035744274 022774 0 ustar root root # Stubs for Crypto.Hash.hashalgo (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class HashAlgo:
digest_size = ... # type: Any
block_size = ... # type: Any
def __init__(self, hashFactory, data: Optional[Any] = ...) -> None: ...
def update(self, data): ...
def digest(self): ...
def hexdigest(self): ...
def copy(self): ...
def new(self, data: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/SHA512.pyi 0000644 0000000 0000000 00000000775 13035744274 022060 0 ustar root root # Stubs for Crypto.Hash.SHA512 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class SHA512Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/MD4.pyi 0000644 0000000 0000000 00000000767 13035744274 021602 0 ustar root root # Stubs for Crypto.Hash.MD4 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class MD4Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/HMAC.pyi 0000644 0000000 0000000 00000001143 13035744274 021713 0 ustar root root # Stubs for Crypto.Hash.HMAC (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
digest_size = ... # type: Any
class HMAC:
digest_size = ... # type: Any
digestmod = ... # type: Any
outer = ... # type: Any
inner = ... # type: Any
def __init__(self, key, msg: Optional[Any] = ..., digestmod: Optional[Any] = ...) -> None: ...
def update(self, msg): ...
def copy(self): ...
def digest(self): ...
def hexdigest(self): ...
def new(key, msg: Optional[Any] = ..., digestmod: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/SHA224.pyi 0000644 0000000 0000000 00000000775 13035744274 022060 0 ustar root root # Stubs for Crypto.Hash.SHA224 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class SHA224Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/RIPEMD.pyi 0000644 0000000 0000000 00000001000 13035744274 022153 0 ustar root root # Stubs for Crypto.Hash.RIPEMD (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class RIPEMD160Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/MD2.pyi 0000644 0000000 0000000 00000000767 13035744274 021600 0 ustar root root # Stubs for Crypto.Hash.MD2 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class MD2Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/MD5.pyi 0000644 0000000 0000000 00000000767 13035744274 021603 0 ustar root root # Stubs for Crypto.Hash.MD5 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class MD5Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Hash/SHA384.pyi 0000644 0000000 0000000 00000000775 13035744274 022067 0 ustar root root # Stubs for Crypto.Hash.SHA384 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.Hash.hashalgo import HashAlgo
class SHA384Hash(HashAlgo):
oid = ... # type: Any
digest_size = ... # type: int
block_size = ... # type: int
def __init__(self, data: Optional[Any] = ...) -> None: ...
def new(self, data: Optional[Any] = ...): ...
def new(data: Optional[Any] = ...): ...
digest_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/ 0000755 0000000 0000000 00000000000 13044320557 021010 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Random/__init__.pyi 0000644 0000000 0000000 00000000224 13035744274 023276 0 ustar root root # Stubs for Crypto.Random (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def new(*args, **kwargs): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/Fortuna/ 0000755 0000000 0000000 00000000000 13044320557 022426 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Random/Fortuna/FortunaAccumulator.pyi 0000644 0000000 0000000 00000001511 13035744274 026773 0 ustar root root # Stubs for Crypto.Random.Fortuna.FortunaAccumulator (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
__revision__ = ... # type: str
class FortunaPool:
digest_size = ... # type: Any
def __init__(self) -> None: ...
def append(self, data): ...
def digest(self): ...
def hexdigest(self): ...
length = ... # type: int
def reset(self): ...
def which_pools(r): ...
class FortunaAccumulator:
min_pool_size = ... # type: int
reseed_interval = ... # type: float
reseed_count = ... # type: int
generator = ... # type: Any
last_reseed = ... # type: Any
pools = ... # type: Any
def __init__(self) -> None: ...
def random_data(self, bytes): ...
def add_random_event(self, source_number, pool_number, data): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/Fortuna/__init__.pyi 0000644 0000000 0000000 00000000175 13035744274 024721 0 ustar root root # Stubs for Crypto.Random.Fortuna (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/Fortuna/FortunaGenerator.pyi 0000644 0000000 0000000 00000001162 13035744274 026444 0 ustar root root # Stubs for Crypto.Random.Fortuna.FortunaGenerator (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
__revision__ = ... # type: str
class AESGenerator:
block_size = ... # type: Any
key_size = ... # type: int
max_blocks_per_request = ... # type: Any
counter = ... # type: Any
key = ... # type: Any
block_size_shift = ... # type: Any
blocks_per_key = ... # type: Any
max_bytes_per_request = ... # type: Any
def __init__(self) -> None: ...
def reseed(self, seed): ...
def pseudo_random_data(self, bytes): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/Fortuna/SHAd256.pyi 0000644 0000000 0000000 00000000734 13035744274 024177 0 ustar root root # Stubs for Crypto.Random.Fortuna.SHAd256 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class _SHAd256:
digest_size = ... # type: Any
def __init__(self, internal_api_check, sha256_hash_obj) -> None: ...
def copy(self): ...
def digest(self): ...
def hexdigest(self): ...
def update(self, data): ...
digest_size = ... # type: Any
def new(data: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/OSRNG/ 0000755 0000000 0000000 00000000000 13044320557 021700 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Random/OSRNG/__init__.pyi 0000644 0000000 0000000 00000000234 13035744274 024167 0 ustar root root # Stubs for Crypto.Random.OSRNG (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
__revision__ = ... # type: str
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/OSRNG/posix.pyi 0000644 0000000 0000000 00000000476 13035744274 023602 0 ustar root root # Stubs for Crypto.Random.OSRNG.posix (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from .rng_base import BaseRNG
class DevURandomRNG(BaseRNG):
name = ... # type: str
def __init__(self, devname: Optional[Any] = ...) -> None: ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/OSRNG/fallback.pyi 0000644 0000000 0000000 00000000407 13035744274 024171 0 ustar root root # Stubs for Crypto.Random.OSRNG.fallback (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .rng_base import BaseRNG
class PythonOSURandomRNG(BaseRNG):
name = ... # type: str
def __init__(self) -> None: ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/OSRNG/rng_base.pyi 0000644 0000000 0000000 00000000644 13035744274 024215 0 ustar root root # Stubs for Crypto.Random.OSRNG.rng_base (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
__revision__ = ... # type: str
class BaseRNG:
closed = ... # type: bool
def __init__(self) -> None: ...
def __del__(self): ...
def __enter__(self): ...
def __exit__(self): ...
def close(self): ...
def flush(self): ...
def read(self, N: int = ...): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Random/random.pyi 0000644 0000000 0000000 00000001204 13035744274 023016 0 ustar root root # Stubs for Crypto.Random.random (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class StrongRandom:
def __init__(self, rng: Optional[Any] = ..., randfunc: Optional[Any] = ...) -> None: ...
def getrandbits(self, k): ...
def randrange(self, *args): ...
def randint(self, a, b): ...
def choice(self, seq): ...
def shuffle(self, x): ...
def sample(self, population, k): ...
getrandbits = ... # type: Any
randrange = ... # type: Any
randint = ... # type: Any
choice = ... # type: Any
shuffle = ... # type: Any
sample = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/ 0000755 0000000 0000000 00000000000 13044320557 021457 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/ElGamal.pyi 0000644 0000000 0000000 00000001242 13035744274 023511 0 ustar root root # Stubs for Crypto.PublicKey.ElGamal (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from Crypto.PublicKey.pubkey import pubkey
from Crypto.PublicKey.pubkey import * # noqa: F403
class error(Exception): ...
def generate(bits, randfunc, progress_func: Optional[Any] = ...): ...
def construct(tup): ...
class ElGamalobj(pubkey):
keydata = ... # type: Any
def encrypt(self, plaintext, K): ...
def decrypt(self, ciphertext): ...
def sign(self, M, K): ...
def verify(self, M, signature): ...
def size(self): ...
def has_private(self): ...
def publickey(self): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/__init__.pyi 0000644 0000000 0000000 00000000274 13035744274 023752 0 ustar root root # Stubs for Crypto.PublicKey (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# DSA
# ElGamal
# RSA
mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/pubkey.pyi 0000644 0000000 0000000 00000001361 13035744274 023510 0 ustar root root # Stubs for Crypto.PublicKey.pubkey (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from Crypto.Util.number import * # noqa: F403
__revision__ = ... # type: str
class pubkey:
def __init__(self) -> None: ...
def encrypt(self, plaintext, K): ...
def decrypt(self, ciphertext): ...
def sign(self, M, K): ...
def verify(self, M, signature): ...
def validate(self, M, signature): ...
def blind(self, M, B): ...
def unblind(self, M, B): ...
def can_sign(self): ...
def can_encrypt(self): ...
def can_blind(self): ...
def size(self): ...
def has_private(self): ...
def publickey(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/DSA.pyi 0000644 0000000 0000000 00000001704 13035744274 022621 0 ustar root root # Stubs for Crypto.PublicKey.DSA (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from .pubkey import pubkey
class _DSAobj(pubkey):
keydata = ... # type: Any
implementation = ... # type: Any
key = ... # type: Any
def __init__(self, implementation, key) -> None: ...
def __getattr__(self, attrname): ...
def sign(self, M, K): ...
def verify(self, M, signature): ...
def has_private(self): ...
def size(self): ...
def can_blind(self): ...
def can_encrypt(self): ...
def can_sign(self): ...
def publickey(self): ...
class DSAImplementation:
error = ... # type: Any
def __init__(self, **kwargs) -> None: ...
def generate(self, bits, randfunc: Optional[Any] = ..., progress_func: Optional[Any] = ...): ...
def construct(self, tup): ...
generate = ... # type: Any
construct = ... # type: Any
error = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/PublicKey/RSA.pyi 0000644 0000000 0000000 00000002461 13035744274 022640 0 ustar root root # Stubs for Crypto.PublicKey.RSA (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional, Union, Text
from .pubkey import pubkey
class _RSAobj(pubkey):
keydata = ... # type: Any
implementation = ... # type: Any
key = ... # type: Any
def __init__(self, implementation, key, randfunc: Optional[Any] = ...) -> None: ...
def __getattr__(self, attrname): ...
def encrypt(self, plaintext, K): ...
def decrypt(self, ciphertext): ...
def sign(self, M, K): ...
def verify(self, M, signature): ...
def has_private(self): ...
def size(self): ...
def can_blind(self): ...
def can_encrypt(self): ...
def can_sign(self): ...
def publickey(self): ...
def exportKey(self, format: str = ..., passphrase: Optional[Any] = ..., pkcs: int = ...): ...
class RSAImplementation:
error = ... # type: Any
def __init__(self, **kwargs) -> None: ...
def generate(self, bits, randfunc: Optional[Any] = ..., progress_func: Optional[Any] = ..., e: int = ...): ...
def construct(self, tup): ...
def importKey(self, externKey: Any, passphrase: Union[None, bytes, Text] = ...) -> _RSAobj: ...
generate = ... # type: Any
construct = ... # type: Any
importKey = ... # type: Any
error = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/pct_warnings.pyi 0000644 0000000 0000000 00000001030 13035744274 023011 0 ustar root root # Stubs for Crypto.pct_warnings (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class CryptoWarning(Warning): ...
class CryptoDeprecationWarning(DeprecationWarning, CryptoWarning): ...
class CryptoRuntimeWarning(RuntimeWarning, CryptoWarning): ...
class RandomPool_DeprecationWarning(CryptoDeprecationWarning): ...
class ClockRewindWarning(CryptoRuntimeWarning): ...
class GetRandomNumber_DeprecationWarning(CryptoDeprecationWarning): ...
class PowmInsecureWarning(CryptoRuntimeWarning): ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/ 0000755 0000000 0000000 00000000000 13044320557 021002 5 ustar root root mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/XOR.pyi 0000644 0000000 0000000 00000001134 13035744274 022202 0 ustar root root # Stubs for Crypto.Cipher.XOR (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
__revision__ = ... # type: str
class XORCipher:
block_size = ... # type: int
key_size = ... # type: int
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def encrypt(self, plaintext: Union[bytes, Text]) -> bytes: ...
def decrypt(self, ciphertext: bytes) -> bytes: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> XORCipher: ...
block_size = ... # type: int
key_size = ... # type: int
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/__init__.pyi 0000644 0000000 0000000 00000000404 13035744274 023270 0 ustar root root # Stubs for Crypto.Cipher (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
# Names in __all__ with no definition:
# AES
# ARC2
# ARC4
# Blowfish
# CAST
# DES
# DES3
# PKCS1_OAEP
# PKCS1_v1_5
# XOR
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/ARC2.pyi 0000644 0000000 0000000 00000001224 13035744274 022221 0 ustar root root # Stubs for Crypto.Cipher.ARC2 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class RC2Cipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> RC2Cipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: int
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/PKCS1_v1_5.pyi 0000644 0000000 0000000 00000001055 13035744274 023207 0 ustar root root # Stubs for Crypto.Cipher.PKCS1_v1_5 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from Crypto.PublicKey.RSA import _RSAobj
class PKCS115_Cipher:
def __init__(self, key: _RSAobj) -> None: ...
def can_encrypt(self) -> bool: ...
def can_decrypt(self) -> bool: ...
rf = ... # type: Any
def encrypt(self, message: Union[bytes, Text]) -> bytes: ...
def decrypt(self, ct: bytes, sentinel: Any) -> bytes: ...
def new(key: _RSAobj) -> PKCS115_Cipher: ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/DES3.pyi 0000644 0000000 0000000 00000001227 13035744274 022233 0 ustar root root # Stubs for Crypto.Cipher.DES3 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class DES3Cipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> DES3Cipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/PKCS1_OAEP.pyi 0000644 0000000 0000000 00000001171 13035744274 023160 0 ustar root root # Stubs for Crypto.Cipher.PKCS1_OAEP (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional, Union, Text
from Crypto.PublicKey.RSA import _RSAobj
class PKCS1OAEP_Cipher:
def __init__(self, key: _RSAobj, hashAlgo: Any, mgfunc: Any, label: Any) -> None: ...
def can_encrypt(self): ...
def can_decrypt(self): ...
def encrypt(self, message: Union[bytes, Text]) -> bytes: ...
def decrypt(self, ct: bytes) -> bytes: ...
def new(key: _RSAobj, hashAlgo: Optional[Any] = ..., mgfunc: Optional[Any] = ..., label: Any = ...) -> PKCS1OAEP_Cipher: ...
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/CAST.pyi 0000644 0000000 0000000 00000001234 13035744274 022265 0 ustar root root # Stubs for Crypto.Cipher.CAST (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class CAST128Cipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> CAST128Cipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/DES.pyi 0000644 0000000 0000000 00000001223 13035744274 022144 0 ustar root root # Stubs for Crypto.Cipher.DES (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class DESCipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> DESCipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: int
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/ARC4.pyi 0000644 0000000 0000000 00000001061 13035744274 022222 0 ustar root root # Stubs for Crypto.Cipher.ARC4 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
__revision__ = ... # type: str
class ARC4Cipher:
block_size = ... # type: int
key_size = ... # type: int
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def encrypt(self, plaintext): ...
def decrypt(self, ciphertext): ...
def new(key: Union[bytes, Text], *args, **kwargs) -> ARC4Cipher: ...
block_size = ... # type: int
key_size = ... # type: int
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/Blowfish.pyi 0000644 0000000 0000000 00000001242 13035744274 023307 0 ustar root root # Stubs for Crypto.Cipher.Blowfish (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class BlowfishCipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> BlowfishCipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/AES.pyi 0000644 0000000 0000000 00000001223 13035744274 022141 0 ustar root root # Stubs for Crypto.Cipher.AES (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
from .blockalgo import BlockAlgo
__revision__ = ... # type: str
class AESCipher(BlockAlgo):
def __init__(self, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def new(key: Union[bytes, Text], *args, **kwargs) -> AESCipher: ...
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
block_size = ... # type: int
key_size = ... # type: int
mypy-0.470/typeshed/third_party/2and3/Crypto/Cipher/blockalgo.pyi 0000644 0000000 0000000 00000001255 13035744274 023473 0 ustar root root # Stubs for Crypto.Cipher.blockalgo (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Union, Text
MODE_ECB = ... # type: int
MODE_CBC = ... # type: int
MODE_CFB = ... # type: int
MODE_PGP = ... # type: int
MODE_OFB = ... # type: int
MODE_CTR = ... # type: int
MODE_OPENPGP = ... # type: int
class BlockAlgo:
mode = ... # type: int
block_size = ... # type: int
IV = ... # type: Any
def __init__(self, factory: Any, key: Union[bytes, Text], *args, **kwargs) -> None: ...
def encrypt(self, plaintext: Union[bytes, Text]) -> bytes: ...
def decrypt(self, ciphertext: bytes) -> bytes: ...
mypy-0.470/typeshed/third_party/2and3/certifi.pyi 0000644 0000000 0000000 00000000064 13023631176 020457 0 ustar root root def where() -> str: ...
def old_where() -> str: ...
mypy-0.470/typeshed/third_party/2and3/jinja2/ 0000755 0000000 0000000 00000000000 13044320557 017465 5 ustar root root mypy-0.470/typeshed/third_party/2and3/jinja2/defaults.pyi 0000644 0000000 0000000 00000001461 13035744274 022027 0 ustar root root # Stubs for jinja2.defaults (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from jinja2.filters import FILTERS as DEFAULT_FILTERS
from jinja2.tests import TESTS as DEFAULT_TESTS
BLOCK_START_STRING = ... # type: str
BLOCK_END_STRING = ... # type: str
VARIABLE_START_STRING = ... # type: str
VARIABLE_END_STRING = ... # type: str
COMMENT_START_STRING = ... # type: str
COMMENT_END_STRING = ... # type: str
LINE_STATEMENT_PREFIX = ... # type: Any
LINE_COMMENT_PREFIX = ... # type: Any
TRIM_BLOCKS = ... # type: bool
LSTRIP_BLOCKS = ... # type: bool
NEWLINE_SEQUENCE = ... # type: str
KEEP_TRAILING_NEWLINE = ... # type: bool
DEFAULT_NAMESPACE = ... # type: Any
# Names in __all__ with no definition:
# DEFAULT_FILTERS
# DEFAULT_TESTS
mypy-0.470/typeshed/third_party/2and3/jinja2/__init__.pyi 0000644 0000000 0000000 00000002642 13035744274 021761 0 ustar root root # Stubs for jinja2 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from jinja2.environment import Environment as Environment, Template as Template
from jinja2.loaders import BaseLoader as BaseLoader, FileSystemLoader as FileSystemLoader, PackageLoader as PackageLoader, DictLoader as DictLoader, FunctionLoader as FunctionLoader, PrefixLoader as PrefixLoader, ChoiceLoader as ChoiceLoader, ModuleLoader as ModuleLoader
from jinja2.bccache import BytecodeCache as BytecodeCache, FileSystemBytecodeCache as FileSystemBytecodeCache, MemcachedBytecodeCache as MemcachedBytecodeCache
from jinja2.runtime import Undefined as Undefined, DebugUndefined as DebugUndefined, StrictUndefined as StrictUndefined, make_logging_undefined as make_logging_undefined
from jinja2.exceptions import TemplateError as TemplateError, UndefinedError as UndefinedError, TemplateNotFound as TemplateNotFound, TemplatesNotFound as TemplatesNotFound, TemplateSyntaxError as TemplateSyntaxError, TemplateAssertionError as TemplateAssertionError
from jinja2.filters import environmentfilter as environmentfilter, contextfilter as contextfilter, evalcontextfilter as evalcontextfilter
from jinja2.utils import Markup as Markup, escape as escape, clear_caches as clear_caches, environmentfunction as environmentfunction, evalcontextfunction as evalcontextfunction, contextfunction as contextfunction, is_undefined as is_undefined
mypy-0.470/typeshed/third_party/2and3/jinja2/lexer.pyi 0000644 0000000 0000000 00000007505 13035744274 021344 0 ustar root root # Stubs for jinja2.lexer (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
whitespace_re = ... # type: Any
string_re = ... # type: Any
integer_re = ... # type: Any
name_re = ... # type: Any
float_re = ... # type: Any
newline_re = ... # type: Any
TOKEN_ADD = ... # type: Any
TOKEN_ASSIGN = ... # type: Any
TOKEN_COLON = ... # type: Any
TOKEN_COMMA = ... # type: Any
TOKEN_DIV = ... # type: Any
TOKEN_DOT = ... # type: Any
TOKEN_EQ = ... # type: Any
TOKEN_FLOORDIV = ... # type: Any
TOKEN_GT = ... # type: Any
TOKEN_GTEQ = ... # type: Any
TOKEN_LBRACE = ... # type: Any
TOKEN_LBRACKET = ... # type: Any
TOKEN_LPAREN = ... # type: Any
TOKEN_LT = ... # type: Any
TOKEN_LTEQ = ... # type: Any
TOKEN_MOD = ... # type: Any
TOKEN_MUL = ... # type: Any
TOKEN_NE = ... # type: Any
TOKEN_PIPE = ... # type: Any
TOKEN_POW = ... # type: Any
TOKEN_RBRACE = ... # type: Any
TOKEN_RBRACKET = ... # type: Any
TOKEN_RPAREN = ... # type: Any
TOKEN_SEMICOLON = ... # type: Any
TOKEN_SUB = ... # type: Any
TOKEN_TILDE = ... # type: Any
TOKEN_WHITESPACE = ... # type: Any
TOKEN_FLOAT = ... # type: Any
TOKEN_INTEGER = ... # type: Any
TOKEN_NAME = ... # type: Any
TOKEN_STRING = ... # type: Any
TOKEN_OPERATOR = ... # type: Any
TOKEN_BLOCK_BEGIN = ... # type: Any
TOKEN_BLOCK_END = ... # type: Any
TOKEN_VARIABLE_BEGIN = ... # type: Any
TOKEN_VARIABLE_END = ... # type: Any
TOKEN_RAW_BEGIN = ... # type: Any
TOKEN_RAW_END = ... # type: Any
TOKEN_COMMENT_BEGIN = ... # type: Any
TOKEN_COMMENT_END = ... # type: Any
TOKEN_COMMENT = ... # type: Any
TOKEN_LINESTATEMENT_BEGIN = ... # type: Any
TOKEN_LINESTATEMENT_END = ... # type: Any
TOKEN_LINECOMMENT_BEGIN = ... # type: Any
TOKEN_LINECOMMENT_END = ... # type: Any
TOKEN_LINECOMMENT = ... # type: Any
TOKEN_DATA = ... # type: Any
TOKEN_INITIAL = ... # type: Any
TOKEN_EOF = ... # type: Any
operators = ... # type: Any
reverse_operators = ... # type: Any
operator_re = ... # type: Any
ignored_tokens = ... # type: Any
ignore_if_empty = ... # type: Any
def describe_token(token): ...
def describe_token_expr(expr): ...
def count_newlines(value): ...
def compile_rules(environment): ...
class Failure:
message = ... # type: Any
error_class = ... # type: Any
def __init__(self, message, cls: Any = ...) -> None: ...
def __call__(self, lineno, filename): ...
class Token(tuple):
lineno = ... # type: Any
type = ... # type: Any
value = ... # type: Any
def __new__(cls, lineno, type, value): ...
def test(self, expr): ...
def test_any(self, *iterable): ...
class TokenStreamIterator:
stream = ... # type: Any
def __init__(self, stream) -> None: ...
def __iter__(self): ...
def __next__(self): ...
class TokenStream:
name = ... # type: Any
filename = ... # type: Any
closed = ... # type: bool
current = ... # type: Any
def __init__(self, generator, name, filename) -> None: ...
def __iter__(self): ...
def __bool__(self): ...
__nonzero__ = ... # type: Any
eos = ... # type: Any
def push(self, token): ...
def look(self): ...
def skip(self, n: int = ...): ...
def next_if(self, expr): ...
def skip_if(self, expr): ...
def __next__(self): ...
def close(self): ...
def expect(self, expr): ...
def get_lexer(environment): ...
class Lexer:
newline_sequence = ... # type: Any
keep_trailing_newline = ... # type: Any
rules = ... # type: Any
def __init__(self, environment) -> None: ...
def tokenize(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., state: Optional[Any] = ...): ...
def wrap(self, stream, name: Optional[Any] = ..., filename: Optional[Any] = ...): ...
def tokeniter(self, source, name, filename: Optional[Any] = ..., state: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/optimizer.pyi 0000644 0000000 0000000 00000002045 13035744274 022241 0 ustar root root # Stubs for jinja2.optimizer (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from jinja2.visitor import NodeTransformer
def optimize(node, environment): ...
class Optimizer(NodeTransformer):
environment = ... # type: Any
def __init__(self, environment) -> None: ...
def visit_If(self, node): ...
def fold(self, node): ...
visit_Add = ... # type: Any
visit_Sub = ... # type: Any
visit_Mul = ... # type: Any
visit_Div = ... # type: Any
visit_FloorDiv = ... # type: Any
visit_Pow = ... # type: Any
visit_Mod = ... # type: Any
visit_And = ... # type: Any
visit_Or = ... # type: Any
visit_Pos = ... # type: Any
visit_Neg = ... # type: Any
visit_Not = ... # type: Any
visit_Compare = ... # type: Any
visit_Getitem = ... # type: Any
visit_Getattr = ... # type: Any
visit_Call = ... # type: Any
visit_Filter = ... # type: Any
visit_Test = ... # type: Any
visit_CondExpr = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/filters.pyi 0000644 0000000 0000000 00000005066 13035744274 021675 0 ustar root root # Stubs for jinja2.filters (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
def contextfilter(f): ...
def evalcontextfilter(f): ...
def environmentfilter(f): ...
def make_attrgetter(environment, attribute): ...
def do_forceescape(value): ...
def do_urlencode(value): ...
def do_replace(eval_ctx, s, old, new, count: Optional[Any] = ...): ...
def do_upper(s): ...
def do_lower(s): ...
def do_xmlattr(_eval_ctx, d, autospace: bool = ...): ...
def do_capitalize(s): ...
def do_title(s): ...
def do_dictsort(value, case_sensitive: bool = ..., by: str = ...): ...
def do_sort(environment, value, reverse: bool = ..., case_sensitive: bool = ..., attribute: Optional[Any] = ...): ...
def do_default(value, default_value: str = ..., boolean: bool = ...): ...
def do_join(eval_ctx, value, d: str = ..., attribute: Optional[Any] = ...): ...
def do_center(value, width: int = ...): ...
def do_first(environment, seq): ...
def do_last(environment, seq): ...
def do_random(environment, seq): ...
def do_filesizeformat(value, binary: bool = ...): ...
def do_pprint(value, verbose: bool = ...): ...
def do_urlize(eval_ctx, value, trim_url_limit: Optional[Any] = ..., nofollow: bool = ..., target: Optional[Any] = ...): ...
def do_indent(s, width: int = ..., indentfirst: bool = ...): ...
def do_truncate(s, length: int = ..., killwords: bool = ..., end: str = ...): ...
def do_wordwrap(environment, s, width: int = ..., break_long_words: bool = ..., wrapstring: Optional[Any] = ...): ...
def do_wordcount(s): ...
def do_int(value, default: int = ..., base: int = ...): ...
def do_float(value, default: float = ...): ...
def do_format(value, *args, **kwargs): ...
def do_trim(value): ...
def do_striptags(value): ...
def do_slice(value, slices, fill_with: Optional[Any] = ...): ...
def do_batch(value, linecount, fill_with: Optional[Any] = ...): ...
def do_round(value, precision: int = ..., method: str = ...): ...
def do_groupby(environment, value, attribute): ...
class _GroupTuple(tuple):
grouper = ... # type: Any
list = ... # type: Any
def __new__(cls, xxx_todo_changeme): ...
def do_sum(environment, iterable, attribute: Optional[Any] = ..., start: int = ...): ...
def do_list(value): ...
def do_mark_safe(value): ...
def do_mark_unsafe(value): ...
def do_reverse(value): ...
def do_attr(environment, obj, name): ...
def do_map(*args, **kwargs): ...
def do_select(*args, **kwargs): ...
def do_reject(*args, **kwargs): ...
def do_selectattr(*args, **kwargs): ...
def do_rejectattr(*args, **kwargs): ...
FILTERS = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/bccache.pyi 0000644 0000000 0000000 00000003257 13035744274 021575 0 ustar root root # Stubs for jinja2.bccache (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
marshal_dump = ... # type: Any
marshal_load = ... # type: Any
bc_version = ... # type: int
bc_magic = ... # type: Any
class Bucket:
environment = ... # type: Any
key = ... # type: Any
checksum = ... # type: Any
def __init__(self, environment, key, checksum) -> None: ...
code = ... # type: Any
def reset(self): ...
def load_bytecode(self, f): ...
def write_bytecode(self, f): ...
def bytecode_from_string(self, string): ...
def bytecode_to_string(self): ...
class BytecodeCache:
def load_bytecode(self, bucket): ...
def dump_bytecode(self, bucket): ...
def clear(self): ...
def get_cache_key(self, name, filename: Optional[Any] = ...): ...
def get_source_checksum(self, source): ...
def get_bucket(self, environment, name, filename, source): ...
def set_bucket(self, bucket): ...
class FileSystemBytecodeCache(BytecodeCache):
directory = ... # type: Any
pattern = ... # type: Any
def __init__(self, directory: Optional[Any] = ..., pattern: str = ...) -> None: ...
def load_bytecode(self, bucket): ...
def dump_bytecode(self, bucket): ...
def clear(self): ...
class MemcachedBytecodeCache(BytecodeCache):
client = ... # type: Any
prefix = ... # type: Any
timeout = ... # type: Any
ignore_memcache_errors = ... # type: Any
def __init__(self, client, prefix: str = ..., timeout: Optional[Any] = ..., ignore_memcache_errors: bool = ...) -> None: ...
def load_bytecode(self, bucket): ...
def dump_bytecode(self, bucket): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/meta.pyi 0000644 0000000 0000000 00000000724 13035744274 021147 0 ustar root root # Stubs for jinja2.meta (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from jinja2.compiler import CodeGenerator
class TrackingCodeGenerator(CodeGenerator):
undeclared_identifiers = ... # type: Any
def __init__(self, environment) -> None: ...
def write(self, x): ...
def pull_locals(self, frame): ...
def find_undeclared_variables(ast): ...
def find_referenced_templates(ast): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/parser.pyi 0000644 0000000 0000000 00000005235 13035744274 021517 0 ustar root root # Stubs for jinja2.parser (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Parser:
environment = ... # type: Any
stream = ... # type: Any
name = ... # type: Any
filename = ... # type: Any
closed = ... # type: bool
extensions = ... # type: Any
def __init__(self, environment, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., state: Optional[Any] = ...) -> None: ...
def fail(self, msg, lineno: Optional[Any] = ..., exc: Any = ...): ...
def fail_unknown_tag(self, name, lineno: Optional[Any] = ...): ...
def fail_eof(self, end_tokens: Optional[Any] = ..., lineno: Optional[Any] = ...): ...
def is_tuple_end(self, extra_end_rules: Optional[Any] = ...): ...
def free_identifier(self, lineno: Optional[Any] = ...): ...
def parse_statement(self): ...
def parse_statements(self, end_tokens, drop_needle: bool = ...): ...
def parse_set(self): ...
def parse_for(self): ...
def parse_if(self): ...
def parse_block(self): ...
def parse_extends(self): ...
def parse_import_context(self, node, default): ...
def parse_include(self): ...
def parse_import(self): ...
def parse_from(self): ...
def parse_signature(self, node): ...
def parse_call_block(self): ...
def parse_filter_block(self): ...
def parse_macro(self): ...
def parse_print(self): ...
def parse_assign_target(self, with_tuple: bool = ..., name_only: bool = ..., extra_end_rules: Optional[Any] = ...): ...
def parse_expression(self, with_condexpr: bool = ...): ...
def parse_condexpr(self): ...
def parse_or(self): ...
def parse_and(self): ...
def parse_not(self): ...
def parse_compare(self): ...
def parse_add(self): ...
def parse_sub(self): ...
def parse_concat(self): ...
def parse_mul(self): ...
def parse_div(self): ...
def parse_floordiv(self): ...
def parse_mod(self): ...
def parse_pow(self): ...
def parse_unary(self, with_filter: bool = ...): ...
def parse_primary(self): ...
def parse_tuple(self, simplified: bool = ..., with_condexpr: bool = ..., extra_end_rules: Optional[Any] = ..., explicit_parentheses: bool = ...): ...
def parse_list(self): ...
def parse_dict(self): ...
def parse_postfix(self, node): ...
def parse_filter_expr(self, node): ...
def parse_subscript(self, node): ...
def parse_subscribed(self): ...
def parse_call(self, node): ...
def parse_filter(self, node, start_inline: bool = ...): ...
def parse_test(self, node): ...
def subparse(self, end_tokens: Optional[Any] = ...): ...
def parse(self): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/environment.pyi 0000644 0000000 0000000 00000016130 13035744274 022563 0 ustar root root # Stubs for jinja2.environment (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Callable, Dict, Iterator, List, Optional, Text, Type, Union
from .bccache import BytecodeCache
from .loaders import BaseLoader
from .runtime import Context, Undefined
def get_spontaneous_environment(*args): ...
def create_cache(size): ...
def copy_cache(cache): ...
def load_extensions(environment, extensions): ...
class Environment:
sandboxed = ... # type: bool
overlayed = ... # type: bool
linked_to = ... # type: Any
shared = ... # type: bool
exception_handler = ... # type: Any
exception_formatter = ... # type: Any
code_generator_class = ... # type: Any
context_class = ... # type: Any
block_start_string = ... # type: Text
block_end_string = ... # type: Text
variable_start_string = ... # type: Text
variable_end_string = ... # type: Text
comment_start_string = ... # type: Text
comment_end_string = ... # type: Text
line_statement_prefix = ... # type: Text
line_comment_prefix = ... # type: Text
trim_blocks = ... # type: bool
lstrip_blocks = ... # type: Any
newline_sequence = ... # type: Text
keep_trailing_newline = ... # type: bool
undefined = ... # type: Type[Undefined]
optimized = ... # type: bool
finalize = ... # type: Callable
autoescape = ... # type: Any
filters = ... # type: Any
tests = ... # type: Any
globals = ... # type: Dict[str, Any]
loader = ... # type: BaseLoader
cache = ... # type: Any
bytecode_cache = ... # type: BytecodeCache
auto_reload = ... # type: bool
extensions = ... # type: List
def __init__(self, block_start_string: Text = ..., block_end_string: Text = ..., variable_start_string: Text = ..., variable_end_string: Text = ..., comment_start_string: Any = ..., comment_end_string: Text = ..., line_statement_prefix: Text = ..., line_comment_prefix: Text = ..., trim_blocks: bool = ..., lstrip_blocks: bool = ..., newline_sequence: Text = ..., keep_trailing_newline: bool = ..., extensions: List = ..., optimized: bool = ..., undefined: Type[Undefined] = ..., finalize: Optional[Callable] = ..., autoescape: bool = ..., loader: Optional[BaseLoader] = ..., cache_size: int = ..., auto_reload: bool = ..., bytecode_cache: Optional[BytecodeCache] = ...) -> None: ...
def add_extension(self, extension): ...
def extend(self, **attributes): ...
def overlay(self, block_start_string: Text = ..., block_end_string: Text = ..., variable_start_string: Text = ..., variable_end_string: Text = ..., comment_start_string: Any = ..., comment_end_string: Text = ..., line_statement_prefix: Text = ..., line_comment_prefix: Text = ..., trim_blocks: bool = ..., lstrip_blocks: bool = ..., extensions: List = ..., optimized: bool = ..., undefined: Type[Undefined] = ..., finalize: Callable = ..., autoescape: bool = ..., loader: Optional[BaseLoader] = ..., cache_size: int = ..., auto_reload: bool = ..., bytecode_cache: Optional[BytecodeCache] = ...): ...
lexer = ... # type: Any
def iter_extensions(self): ...
def getitem(self, obj, argument): ...
def getattr(self, obj, attribute): ...
def call_filter(self, name, value, args: Optional[Any] = ..., kwargs: Optional[Any] = ..., context: Optional[Any] = ..., eval_ctx: Optional[Any] = ...): ...
def call_test(self, name, value, args: Optional[Any] = ..., kwargs: Optional[Any] = ...): ...
def parse(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ...): ...
def lex(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ...): ...
def preprocess(self, source: Text, name: Optional[Any] = ..., filename: Optional[Any] = ...): ...
def compile(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., raw: bool = ..., defer_init: bool = ...): ...
def compile_expression(self, source: Text, undefined_to_none: bool = ...): ...
def compile_templates(self, target, extensions: Optional[Any] = ..., filter_func: Optional[Any] = ..., zip: str = ..., log_function: Optional[Any] = ..., ignore_errors: bool = ..., py_compile: bool = ...): ...
def list_templates(self, extensions: Optional[Any] = ..., filter_func: Optional[Any] = ...): ...
def handle_exception(self, exc_info: Optional[Any] = ..., rendered: bool = ..., source_hint: Optional[Any] = ...): ...
def join_path(self, template: Union[Template, Text], parent: Text) -> Text: ...
def get_template(self, name: Union[Template, Text], parent: Optional[Text] = ..., globals: Optional[Any] = ...) -> Template: ...
def select_template(self, names: List[Union[Template, Text]], parent: Optional[Text] = ..., globals: Optional[Dict[str, Any]] = ...) -> Template: ...
def get_or_select_template(self, template_name_or_list: Union[Union[Template, Text], List[Union[Template, Text]]], parent: Optional[Text] = ..., globals: Optional[Dict[str, Any]] = ...) -> Template: ...
def from_string(self, source: Text, globals: Optional[Dict[str, Any]] = ..., template_class: Optional[Type[Template]] = ...) -> Template: ...
def make_globals(self, d: Optional[Dict[str, Any]]) -> Dict[str, Any]: ...
class Template:
def __new__(cls, source, block_start_string: Any = ..., block_end_string: Any = ..., variable_start_string: Any = ..., variable_end_string: Any = ..., comment_start_string: Any = ..., comment_end_string: Any = ..., line_statement_prefix: Any = ..., line_comment_prefix: Any = ..., trim_blocks: Any = ..., lstrip_blocks: Any = ..., newline_sequence: Any = ..., keep_trailing_newline: Any = ..., extensions: Any = ..., optimized: bool = ..., undefined: Any = ..., finalize: Optional[Any] = ..., autoescape: bool = ...): ...
@classmethod
def from_code(cls, environment, code, globals, uptodate: Optional[Any] = ...): ...
@classmethod
def from_module_dict(cls, environment, module_dict, globals): ...
def render(self, *args, **kwargs) -> Text: ...
def stream(self, *args, **kwargs) -> TemplateStream: ...
def generate(self, *args, **kwargs) -> Iterator[Text]: ...
def new_context(self, vars: Optional[Dict[str, Any]] = ..., shared: bool = ..., locals: Optional[Dict[str, Any]] = ...) -> Context: ...
def make_module(self, vars: Optional[Dict[str, Any]] = ..., shared: bool = ..., locals: Optional[Dict[str, Any]] = ...) -> Context: ...
@property
def module(self) -> Any: ...
def get_corresponding_lineno(self, lineno): ...
@property
def is_up_to_date(self) -> bool: ...
@property
def debug_info(self): ...
class TemplateModule:
__name__ = ... # type: Any
def __init__(self, template, context) -> None: ...
def __html__(self): ...
class TemplateExpression:
def __init__(self, template, undefined_to_none) -> None: ...
def __call__(self, *args, **kwargs): ...
class TemplateStream:
def __init__(self, gen) -> None: ...
def dump(self, fp, encoding: Optional[Text] = ..., errors: Text = ...): ...
buffered = ... # type: bool
def disable_buffering(self) -> None: ...
def enable_buffering(self, size: int = ...) -> None: ...
def __iter__(self): ...
def __next__(self): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/constants.pyi 0000644 0000000 0000000 00000000236 13035744274 022233 0 ustar root root # Stubs for jinja2.constants (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
LOREM_IPSUM_WORDS = ... # type: str
mypy-0.470/typeshed/third_party/2and3/jinja2/loaders.pyi 0000644 0000000 0000000 00000005613 13035744274 021654 0 ustar root root # Stubs for jinja2.loaders (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Callable, List, Optional, Text, Tuple
from types import ModuleType
from .environment import Environment
def split_template_path(template: Text) -> List[Text]: ...
class BaseLoader:
has_source_access = ... # type: bool
def get_source(self, environment, template): ...
def list_templates(self): ...
def load(self, environment, name, globals: Optional[Any] = ...): ...
class FileSystemLoader(BaseLoader):
searchpath = ... # type: Text
encoding = ... # type: Any
followlinks = ... # type: Any
def __init__(self, searchpath: Text, encoding: Text = ..., followlinks: bool = ...) -> None: ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
def list_templates(self): ...
class PackageLoader(BaseLoader):
encoding = ... # type: Text
manager = ... # type: Any
filesystem_bound = ... # type: Any
provider = ... # type: Any
package_path = ... # type: Any
def __init__(self, package_name: Text, package_path: Text = ..., encoding: Text = ...) -> None: ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
def list_templates(self): ...
class DictLoader(BaseLoader):
mapping = ... # type: Any
def __init__(self, mapping) -> None: ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
def list_templates(self): ...
class FunctionLoader(BaseLoader):
load_func = ... # type: Any
def __init__(self, load_func) -> None: ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
class PrefixLoader(BaseLoader):
mapping = ... # type: Any
delimiter = ... # type: Any
def __init__(self, mapping, delimiter: str = ...) -> None: ...
def get_loader(self, template): ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
def load(self, environment, name, globals: Optional[Any] = ...): ...
def list_templates(self): ...
class ChoiceLoader(BaseLoader):
loaders = ... # type: Any
def __init__(self, loaders) -> None: ...
def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable]: ...
def load(self, environment, name, globals: Optional[Any] = ...): ...
def list_templates(self): ...
class _TemplateModule(ModuleType): ...
class ModuleLoader(BaseLoader):
has_source_access = ... # type: bool
module = ... # type: Any
package_name = ... # type: Any
def __init__(self, path) -> None: ...
@staticmethod
def get_template_key(name): ...
@staticmethod
def get_module_filename(name): ...
def load(self, environment, name, globals: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/nodes.pyi 0000644 0000000 0000000 00000014175 13035744274 021336 0 ustar root root # Stubs for jinja2.nodes (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Impossible(Exception): ...
class NodeType(type):
def __new__(cls, name, bases, d): ...
class EvalContext:
environment = ... # type: Any
autoescape = ... # type: Any
volatile = ... # type: bool
def __init__(self, environment, template_name: Optional[Any] = ...) -> None: ...
def save(self): ...
def revert(self, old): ...
def get_eval_context(node, ctx): ...
class Node:
fields = ... # type: Any
attributes = ... # type: Any
abstract = ... # type: bool
def __init__(self, *fields, **attributes) -> None: ...
def iter_fields(self, exclude: Optional[Any] = ..., only: Optional[Any] = ...): ...
def iter_child_nodes(self, exclude: Optional[Any] = ..., only: Optional[Any] = ...): ...
def find(self, node_type): ...
def find_all(self, node_type): ...
def set_ctx(self, ctx): ...
def set_lineno(self, lineno, override: bool = ...): ...
def set_environment(self, environment): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
__hash__ = ... # type: Any
class Stmt(Node):
abstract = ... # type: bool
class Helper(Node):
abstract = ... # type: bool
class Template(Node):
fields = ... # type: Any
class Output(Stmt):
fields = ... # type: Any
class Extends(Stmt):
fields = ... # type: Any
class For(Stmt):
fields = ... # type: Any
class If(Stmt):
fields = ... # type: Any
class Macro(Stmt):
fields = ... # type: Any
class CallBlock(Stmt):
fields = ... # type: Any
class FilterBlock(Stmt):
fields = ... # type: Any
class Block(Stmt):
fields = ... # type: Any
class Include(Stmt):
fields = ... # type: Any
class Import(Stmt):
fields = ... # type: Any
class FromImport(Stmt):
fields = ... # type: Any
class ExprStmt(Stmt):
fields = ... # type: Any
class Assign(Stmt):
fields = ... # type: Any
class AssignBlock(Stmt):
fields = ... # type: Any
class Expr(Node):
abstract = ... # type: bool
def as_const(self, eval_ctx: Optional[Any] = ...): ...
def can_assign(self): ...
class BinExpr(Expr):
fields = ... # type: Any
operator = ... # type: Any
abstract = ... # type: bool
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class UnaryExpr(Expr):
fields = ... # type: Any
operator = ... # type: Any
abstract = ... # type: bool
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Name(Expr):
fields = ... # type: Any
def can_assign(self): ...
class Literal(Expr):
abstract = ... # type: bool
class Const(Literal):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
@classmethod
def from_untrusted(cls, value, lineno: Optional[Any] = ..., environment: Optional[Any] = ...): ...
class TemplateData(Literal):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Tuple(Literal):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
def can_assign(self): ...
class List(Literal):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Dict(Literal):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Pair(Helper):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Keyword(Helper):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class CondExpr(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Filter(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Test(Expr):
fields = ... # type: Any
class Call(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Getitem(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
def can_assign(self): ...
class Getattr(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
def can_assign(self): ...
class Slice(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Concat(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Compare(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Operand(Helper):
fields = ... # type: Any
class Mul(BinExpr):
operator = ... # type: str
class Div(BinExpr):
operator = ... # type: str
class FloorDiv(BinExpr):
operator = ... # type: str
class Add(BinExpr):
operator = ... # type: str
class Sub(BinExpr):
operator = ... # type: str
class Mod(BinExpr):
operator = ... # type: str
class Pow(BinExpr):
operator = ... # type: str
class And(BinExpr):
operator = ... # type: str
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Or(BinExpr):
operator = ... # type: str
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class Not(UnaryExpr):
operator = ... # type: str
class Neg(UnaryExpr):
operator = ... # type: str
class Pos(UnaryExpr):
operator = ... # type: str
class EnvironmentAttribute(Expr):
fields = ... # type: Any
class ExtensionAttribute(Expr):
fields = ... # type: Any
class ImportedName(Expr):
fields = ... # type: Any
class InternalName(Expr):
fields = ... # type: Any
def __init__(self) -> None: ...
class MarkSafe(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class MarkSafeIfAutoescape(Expr):
fields = ... # type: Any
def as_const(self, eval_ctx: Optional[Any] = ...): ...
class ContextReference(Expr): ...
class Continue(Stmt): ...
class Break(Stmt): ...
class Scope(Stmt):
fields = ... # type: Any
class EvalContextModifier(Stmt):
fields = ... # type: Any
class ScopedEvalContextModifier(EvalContextModifier):
fields = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/utils.pyi 0000644 0000000 0000000 00000003770 13035744274 021365 0 ustar root root # Stubs for jinja2.utils (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from markupsafe import Markup, escape, soft_unicode
missing = ... # type: Any
internal_code = ... # type: Any
concat = ... # type: Any
def contextfunction(f): ...
def evalcontextfunction(f): ...
def environmentfunction(f): ...
def internalcode(f): ...
def is_undefined(obj): ...
def consume(iterable): ...
def clear_caches(): ...
def import_string(import_name, silent: bool = ...): ...
def open_if_exists(filename, mode: str = ...): ...
def object_type_repr(obj): ...
def pformat(obj, verbose: bool = ...): ...
def urlize(text, trim_url_limit: Optional[Any] = ..., nofollow: bool = ..., target: Optional[Any] = ...): ...
def generate_lorem_ipsum(n: int = ..., html: bool = ..., min: int = ..., max: int = ...): ...
def unicode_urlencode(obj, charset: str = ..., for_qs: bool = ...): ...
class LRUCache:
capacity = ... # type: Any
def __init__(self, capacity) -> None: ...
def __getnewargs__(self): ...
def copy(self): ...
def get(self, key, default: Optional[Any] = ...): ...
def setdefault(self, key, default: Optional[Any] = ...): ...
def clear(self): ...
def __contains__(self, key): ...
def __len__(self): ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def items(self): ...
def iteritems(self): ...
def values(self): ...
def itervalue(self): ...
def keys(self): ...
def iterkeys(self): ...
__iter__ = ... # type: Any
def __reversed__(self): ...
__copy__ = ... # type: Any
class Cycler:
items = ... # type: Any
def __init__(self, *items) -> None: ...
pos = ... # type: int
def reset(self): ...
@property
def current(self): ...
def __next__(self): ...
class Joiner:
sep = ... # type: Any
used = ... # type: bool
def __init__(self, sep: str = ...) -> None: ...
def __call__(self): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/_stringdefs.pyi 0000644 0000000 0000000 00000001661 13035744274 022531 0 ustar root root # Stubs for jinja2._stringdefs (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
Cc = ... # type: str
Cf = ... # type: str
Cn = ... # type: str
Co = ... # type: str
Cs = ... # type: Any
Ll = ... # type: str
Lm = ... # type: str
Lo = ... # type: str
Lt = ... # type: str
Lu = ... # type: str
Mc = ... # type: str
Me = ... # type: str
Mn = ... # type: str
Nd = ... # type: str
Nl = ... # type: str
No = ... # type: str
Pc = ... # type: str
Pd = ... # type: str
Pe = ... # type: str
Pf = ... # type: str
Pi = ... # type: str
Po = ... # type: str
Ps = ... # type: str
Sc = ... # type: str
Sk = ... # type: str
Sm = ... # type: str
So = ... # type: str
Zl = ... # type: str
Zp = ... # type: str
Zs = ... # type: str
cats = ... # type: Any
def combine(*args): ...
xid_start = ... # type: str
xid_continue = ... # type: str
def allexcept(*args): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/tests.pyi 0000644 0000000 0000000 00000001336 13035744274 021363 0 ustar root root # Stubs for jinja2.tests (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
number_re = ... # type: Any
regex_type = ... # type: Any
test_callable = ... # type: Any
def test_odd(value): ...
def test_even(value): ...
def test_divisibleby(value, num): ...
def test_defined(value): ...
def test_undefined(value): ...
def test_none(value): ...
def test_lower(value): ...
def test_upper(value): ...
def test_string(value): ...
def test_mapping(value): ...
def test_number(value): ...
def test_sequence(value): ...
def test_equalto(value, other): ...
def test_sameas(value, other): ...
def test_iterable(value): ...
def test_escaped(value): ...
TESTS = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/sandbox.pyi 0000644 0000000 0000000 00000002612 13035744274 021655 0 ustar root root # Stubs for jinja2.sandbox (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from jinja2.environment import Environment
MAX_RANGE = ... # type: int
UNSAFE_FUNCTION_ATTRIBUTES = ... # type: Any
UNSAFE_METHOD_ATTRIBUTES = ... # type: Any
UNSAFE_GENERATOR_ATTRIBUTES = ... # type: Any
def safe_range(*args): ...
def unsafe(f): ...
def is_internal_attribute(obj, attr): ...
def modifies_known_mutable(obj, attr): ...
class SandboxedEnvironment(Environment):
sandboxed = ... # type: bool
default_binop_table = ... # type: Any
default_unop_table = ... # type: Any
intercepted_binops = ... # type: Any
intercepted_unops = ... # type: Any
def intercept_unop(self, operator): ...
binop_table = ... # type: Any
unop_table = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def is_safe_attribute(self, obj, attr, value): ...
def is_safe_callable(self, obj): ...
def call_binop(self, context, operator, left, right): ...
def call_unop(self, context, operator, arg): ...
def getitem(self, obj, argument): ...
def getattr(self, obj, attribute): ...
def unsafe_undefined(self, obj, attribute): ...
def call(__self, __context, __obj, *args, **kwargs): ...
class ImmutableSandboxedEnvironment(SandboxedEnvironment):
def is_safe_attribute(self, obj, attr, value): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/runtime.pyi 0000644 0000000 0000000 00000010576 13035744274 021712 0 ustar root root # Stubs for jinja2.runtime (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Dict, Optional, Text, Union
from jinja2.utils import Markup as Markup, escape as escape, missing as missing, concat as concat
from jinja2.exceptions import TemplateRuntimeError as TemplateRuntimeError, TemplateNotFound as TemplateNotFound
from jinja2.environment import Environment
to_string = ... # type: Any
identity = ... # type: Any
def markup_join(seq): ...
def unicode_join(seq): ...
class TemplateReference:
def __init__(self, context) -> None: ...
def __getitem__(self, name): ...
class Context:
parent = ... # type: Union[Context, Dict[str, Any]]
vars = ... # type: Dict[str, Any]
environment = ... # type: Environment
eval_ctx = ... # type: Any
exported_vars = ... # type: Any
name = ... # type: Text
blocks = ... # type: Dict[str, Any]
def __init__(self, environment: Environment, parent: Union[Context, Dict[str, Any]], name: Text, blocks: Dict[str, Any]) -> None: ...
def super(self, name, current): ...
def get(self, key, default: Optional[Any] = ...): ...
def resolve(self, key): ...
def get_exported(self): ...
def get_all(self): ...
def call(__self, __obj, *args, **kwargs): ...
def derived(self, locals: Optional[Any] = ...): ...
keys = ... # type: Any
values = ... # type: Any
items = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
iteritems = ... # type: Any
def __contains__(self, name): ...
def __getitem__(self, key): ...
class BlockReference:
name = ... # type: Any
def __init__(self, name, context, stack, depth) -> None: ...
@property
def super(self): ...
def __call__(self): ...
class LoopContext:
index0 = ... # type: int
depth0 = ... # type: Any
def __init__(self, iterable, recurse: Optional[Any] = ..., depth0: int = ...) -> None: ...
def cycle(self, *args): ...
first = ... # type: Any
last = ... # type: Any
index = ... # type: Any
revindex = ... # type: Any
revindex0 = ... # type: Any
depth = ... # type: Any
def __len__(self): ...
def __iter__(self): ...
def loop(self, iterable): ...
__call__ = ... # type: Any
@property
def length(self): ...
class LoopContextIterator:
context = ... # type: Any
def __init__(self, context) -> None: ...
def __iter__(self): ...
def __next__(self): ...
class Macro:
name = ... # type: Any
arguments = ... # type: Any
defaults = ... # type: Any
catch_kwargs = ... # type: Any
catch_varargs = ... # type: Any
caller = ... # type: Any
def __init__(self, environment, func, name, arguments, defaults, catch_kwargs, catch_varargs, caller) -> None: ...
def __call__(self, *args, **kwargs): ...
class Undefined:
def __init__(self, hint: Optional[Any] = ..., obj: Any = ..., name: Optional[Any] = ..., exc: Any = ...) -> None: ...
def __getattr__(self, name): ...
__add__ = ... # type: Any
__radd__ = ... # type: Any
__mul__ = ... # type: Any
__rmul__ = ... # type: Any
__div__ = ... # type: Any
__rdiv__ = ... # type: Any
__truediv__ = ... # type: Any
__rtruediv__ = ... # type: Any
__floordiv__ = ... # type: Any
__rfloordiv__ = ... # type: Any
__mod__ = ... # type: Any
__rmod__ = ... # type: Any
__pos__ = ... # type: Any
__neg__ = ... # type: Any
__call__ = ... # type: Any
__getitem__ = ... # type: Any
__lt__ = ... # type: Any
__le__ = ... # type: Any
__gt__ = ... # type: Any
__ge__ = ... # type: Any
__int__ = ... # type: Any
__float__ = ... # type: Any
__complex__ = ... # type: Any
__pow__ = ... # type: Any
__rpow__ = ... # type: Any
def __eq__(self, other): ...
def __ne__(self, other): ...
def __hash__(self): ...
def __len__(self): ...
def __iter__(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
def make_logging_undefined(logger: Optional[Any] = ..., base: Optional[Any] = ...): ...
class DebugUndefined(Undefined): ...
class StrictUndefined(Undefined):
__iter__ = ... # type: Any
__len__ = ... # type: Any
__nonzero__ = ... # type: Any
__eq__ = ... # type: Any
__ne__ = ... # type: Any
__bool__ = ... # type: Any
__hash__ = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/_compat.pyi 0000644 0000000 0000000 00000002005 13035744274 021635 0 ustar root root # Stubs for jinja2._compat (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
import sys
if sys.version_info[0] >= 3:
from io import BytesIO
from urllib.parse import quote_from_bytes as url_quote
else:
from cStringIO import StringIO as BytesIO
from urllib import quote as url_quote
PY2 = ... # type: Any
PYPY = ... # type: Any
unichr = ... # type: Any
range_type = ... # type: Any
text_type = ... # type: Any
string_types = ... # type: Any
integer_types = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
iteritems = ... # type: Any
NativeStringIO = ... # type: Any
def reraise(tp, value, tb: Optional[Any] = ...): ...
ifilter = ... # type: Any
imap = ... # type: Any
izip = ... # type: Any
intern = ... # type: Any
implements_iterator = ... # type: Any
implements_to_string = ... # type: Any
encode_filename = ... # type: Any
get_next = ... # type: Any
def with_metaclass(meta, *bases): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/debug.pyi 0000644 0000000 0000000 00000002321 13035744274 021302 0 ustar root root # Stubs for jinja2.debug (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
tproxy = ... # type: Any
raise_helper = ... # type: str
class TracebackFrameProxy:
tb = ... # type: Any
def __init__(self, tb) -> None: ...
@property
def tb_next(self): ...
def set_next(self, next): ...
@property
def is_jinja_frame(self): ...
def __getattr__(self, name): ...
def make_frame_proxy(frame): ...
class ProcessedTraceback:
exc_type = ... # type: Any
exc_value = ... # type: Any
frames = ... # type: Any
def __init__(self, exc_type, exc_value, frames) -> None: ...
def render_as_text(self, limit: Optional[Any] = ...): ...
def render_as_html(self, full: bool = ...): ...
@property
def is_template_syntax_error(self): ...
@property
def exc_info(self): ...
@property
def standard_exc_info(self): ...
def make_traceback(exc_info, source_hint: Optional[Any] = ...): ...
def translate_syntax_error(error, source: Optional[Any] = ...): ...
def translate_exception(exc_info, initial_skip: int = ...): ...
def fake_exc_info(exc_info, filename, lineno): ...
tb_set_next = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/jinja2/compiler.pyi 0000644 0000000 0000000 00000016010 13035744274 022026 0 ustar root root # Stubs for jinja2.compiler (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from keyword import iskeyword as is_python_keyword
from jinja2.visitor import NodeVisitor
operators = ... # type: Any
dict_item_iter = ... # type: str
unoptimize_before_dead_code = ... # type: bool
def generate(node, environment, name, filename, stream: Optional[Any] = ..., defer_init: bool = ...): ...
def has_safe_repr(value): ...
def find_undeclared(nodes, names): ...
class Identifiers:
declared = ... # type: Any
outer_undeclared = ... # type: Any
undeclared = ... # type: Any
declared_locally = ... # type: Any
declared_parameter = ... # type: Any
def __init__(self) -> None: ...
def add_special(self, name): ...
def is_declared(self, name): ...
def copy(self): ...
class Frame:
eval_ctx = ... # type: Any
identifiers = ... # type: Any
toplevel = ... # type: bool
rootlevel = ... # type: bool
require_output_check = ... # type: Any
buffer = ... # type: Any
block = ... # type: Any
assigned_names = ... # type: Any
parent = ... # type: Any
def __init__(self, eval_ctx, parent: Optional[Any] = ...) -> None: ...
def copy(self): ...
def inspect(self, nodes): ...
def find_shadowed(self, extra: Any = ...): ...
def inner(self): ...
def soft(self): ...
__copy__ = ... # type: Any
class VisitorExit(RuntimeError): ...
class DependencyFinderVisitor(NodeVisitor):
filters = ... # type: Any
tests = ... # type: Any
def __init__(self) -> None: ...
def visit_Filter(self, node): ...
def visit_Test(self, node): ...
def visit_Block(self, node): ...
class UndeclaredNameVisitor(NodeVisitor):
names = ... # type: Any
undeclared = ... # type: Any
def __init__(self, names) -> None: ...
def visit_Name(self, node): ...
def visit_Block(self, node): ...
class FrameIdentifierVisitor(NodeVisitor):
identifiers = ... # type: Any
def __init__(self, identifiers) -> None: ...
def visit_Name(self, node): ...
def visit_If(self, node): ...
def visit_Macro(self, node): ...
def visit_Import(self, node): ...
def visit_FromImport(self, node): ...
def visit_Assign(self, node): ...
def visit_For(self, node): ...
def visit_CallBlock(self, node): ...
def visit_FilterBlock(self, node): ...
def visit_AssignBlock(self, node): ...
def visit_Scope(self, node): ...
def visit_Block(self, node): ...
class CompilerExit(Exception): ...
class CodeGenerator(NodeVisitor):
environment = ... # type: Any
name = ... # type: Any
filename = ... # type: Any
stream = ... # type: Any
created_block_context = ... # type: bool
defer_init = ... # type: Any
import_aliases = ... # type: Any
blocks = ... # type: Any
extends_so_far = ... # type: int
has_known_extends = ... # type: bool
code_lineno = ... # type: int
tests = ... # type: Any
filters = ... # type: Any
debug_info = ... # type: Any
def __init__(self, environment, name, filename, stream: Optional[Any] = ..., defer_init: bool = ...) -> None: ...
def fail(self, msg, lineno): ...
def temporary_identifier(self): ...
def buffer(self, frame): ...
def return_buffer_contents(self, frame): ...
def indent(self): ...
def outdent(self, step: int = ...): ...
def start_write(self, frame, node: Optional[Any] = ...): ...
def end_write(self, frame): ...
def simple_write(self, s, frame, node: Optional[Any] = ...): ...
def blockvisit(self, nodes, frame): ...
def write(self, x): ...
def writeline(self, x, node: Optional[Any] = ..., extra: int = ...): ...
def newline(self, node: Optional[Any] = ..., extra: int = ...): ...
def signature(self, node, frame, extra_kwargs: Optional[Any] = ...): ...
def pull_locals(self, frame): ...
def pull_dependencies(self, nodes): ...
def unoptimize_scope(self, frame): ...
def push_scope(self, frame, extra_vars: Any = ...): ...
def pop_scope(self, aliases, frame): ...
def function_scoping(self, node, frame, children: Optional[Any] = ..., find_special: bool = ...): ...
def macro_body(self, node, frame, children: Optional[Any] = ...): ...
def macro_def(self, node, frame): ...
def position(self, node): ...
def visit_Template(self, node, frame: Optional[Any] = ...): ...
def visit_Block(self, node, frame): ...
def visit_Extends(self, node, frame): ...
def visit_Include(self, node, frame): ...
def visit_Import(self, node, frame): ...
def visit_FromImport(self, node, frame): ...
def visit_For(self, node, frame): ...
def visit_If(self, node, frame): ...
def visit_Macro(self, node, frame): ...
def visit_CallBlock(self, node, frame): ...
def visit_FilterBlock(self, node, frame): ...
def visit_ExprStmt(self, node, frame): ...
def visit_Output(self, node, frame): ...
def make_assignment_frame(self, frame): ...
def export_assigned_vars(self, frame, assignment_frame): ...
def visit_Assign(self, node, frame): ...
def visit_AssignBlock(self, node, frame): ...
def visit_Name(self, node, frame): ...
def visit_Const(self, node, frame): ...
def visit_TemplateData(self, node, frame): ...
def visit_Tuple(self, node, frame): ...
def visit_List(self, node, frame): ...
def visit_Dict(self, node, frame): ...
def binop(operator, interceptable: bool = ...): ...
def uaop(operator, interceptable: bool = ...): ...
visit_Add = ... # type: Any
visit_Sub = ... # type: Any
visit_Mul = ... # type: Any
visit_Div = ... # type: Any
visit_FloorDiv = ... # type: Any
visit_Pow = ... # type: Any
visit_Mod = ... # type: Any
visit_And = ... # type: Any
visit_Or = ... # type: Any
visit_Pos = ... # type: Any
visit_Neg = ... # type: Any
visit_Not = ... # type: Any
def visit_Concat(self, node, frame): ...
def visit_Compare(self, node, frame): ...
def visit_Operand(self, node, frame): ...
def visit_Getattr(self, node, frame): ...
def visit_Getitem(self, node, frame): ...
def visit_Slice(self, node, frame): ...
def visit_Filter(self, node, frame): ...
def visit_Test(self, node, frame): ...
def visit_CondExpr(self, node, frame): ...
def visit_Call(self, node, frame, forward_caller: bool = ...): ...
def visit_Keyword(self, node, frame): ...
def visit_MarkSafe(self, node, frame): ...
def visit_MarkSafeIfAutoescape(self, node, frame): ...
def visit_EnvironmentAttribute(self, node, frame): ...
def visit_ExtensionAttribute(self, node, frame): ...
def visit_ImportedName(self, node, frame): ...
def visit_InternalName(self, node, frame): ...
def visit_ContextReference(self, node, frame): ...
def visit_Continue(self, node, frame): ...
def visit_Break(self, node, frame): ...
def visit_Scope(self, node, frame): ...
def visit_EvalContextModifier(self, node, frame): ...
def visit_ScopedEvalContextModifier(self, node, frame): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/visitor.pyi 0000644 0000000 0000000 00000000651 13035744274 021717 0 ustar root root # Stubs for jinja2.visitor (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class NodeVisitor:
def get_visitor(self, node): ...
def visit(self, node, *args, **kwargs): ...
def generic_visit(self, node, *args, **kwargs): ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node, *args, **kwargs): ...
def visit_list(self, node, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/exceptions.pyi 0000644 0000000 0000000 00000002473 13035744274 022405 0 ustar root root # Stubs for jinja2.exceptions (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional, Text
class TemplateError(Exception):
def __init__(self, message: Optional[Text] = ...) -> None: ...
@property
def message(self): ...
def __unicode__(self): ...
@property
def message(self): ...
class TemplateNotFound(IOError, LookupError, TemplateError):
message = ... # type: Any
name = ... # type: Any
templates = ... # type: Any
def __init__(self, name, message: Optional[Text] = ...) -> None: ...
class TemplatesNotFound(TemplateNotFound):
templates = ... # type: Any
def __init__(self, names: Any = ..., message: Optional[Text] = ...) -> None: ...
class TemplateSyntaxError(TemplateError):
lineno = ... # type: int
name = ... # type: Text
filename = ... # type: Text
source = ... # type: Text
translated = ... # type: bool
def __init__(self, message: Text, lineno: int, name: Optional[Text] = ..., filename: Optional[Text] = ...) -> None: ...
class TemplateAssertionError(TemplateSyntaxError): ...
class TemplateRuntimeError(TemplateError): ...
class UndefinedError(TemplateRuntimeError): ...
class SecurityError(TemplateRuntimeError): ...
class FilterArgumentError(TemplateRuntimeError): ...
mypy-0.470/typeshed/third_party/2and3/jinja2/ext.pyi 0000644 0000000 0000000 00000003704 13035744274 021022 0 ustar root root # Stubs for jinja2.ext (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
GETTEXT_FUNCTIONS = ... # type: Any
class ExtensionRegistry(type):
def __new__(cls, name, bases, d): ...
class Extension:
tags = ... # type: Any
priority = ... # type: int
environment = ... # type: Any
def __init__(self, environment) -> None: ...
def bind(self, environment): ...
def preprocess(self, source, name, filename: Optional[Any] = ...): ...
def filter_stream(self, stream): ...
def parse(self, parser): ...
def attr(self, name, lineno: Optional[Any] = ...): ...
def call_method(self, name, args: Optional[Any] = ..., kwargs: Optional[Any] = ..., dyn_args: Optional[Any] = ..., dyn_kwargs: Optional[Any] = ..., lineno: Optional[Any] = ...): ...
class InternationalizationExtension(Extension):
tags = ... # type: Any
def __init__(self, environment) -> None: ...
def parse(self, parser): ...
class ExprStmtExtension(Extension):
tags = ... # type: Any
def parse(self, parser): ...
class LoopControlExtension(Extension):
tags = ... # type: Any
def parse(self, parser): ...
class WithExtension(Extension):
tags = ... # type: Any
def parse(self, parser): ...
class AutoEscapeExtension(Extension):
tags = ... # type: Any
def parse(self, parser): ...
def extract_from_ast(node, gettext_functions: Any = ..., babel_style: bool = ...): ...
class _CommentFinder:
tokens = ... # type: Any
comment_tags = ... # type: Any
offset = ... # type: int
last_lineno = ... # type: int
def __init__(self, tokens, comment_tags) -> None: ...
def find_backwards(self, offset): ...
def find_comments(self, lineno): ...
def babel_extract(fileobj, keywords, comment_tags, options): ...
i18n = ... # type: Any
do = ... # type: Any
loopcontrols = ... # type: Any
with_ = ... # type: Any
autoescape = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/backports_abc.pyi 0000644 0000000 0000000 00000000603 13035744274 021635 0 ustar root root # Stubs for backports_abc (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def mk_gen(): ...
def mk_awaitable(): ...
def mk_coroutine(): ...
Generator = ... # type: Any
Awaitable = ... # type: Any
Coroutine = ... # type: Any
def isawaitable(obj): ...
PATCHED = ... # type: Any
def patch(patch_inspect=True): ...
mypy-0.470/typeshed/third_party/2and3/atomicwrites/ 0000755 0000000 0000000 00000000000 13044320557 021022 5 ustar root root mypy-0.470/typeshed/third_party/2and3/atomicwrites/__init__.pyi 0000644 0000000 0000000 00000001430 13035744274 023310 0 ustar root root import contextlib
import os
import sys
import tempfile
from typing import Any, AnyStr, Callable, IO, Iterator, Text
def replace_atomic(src: AnyStr, dst: AnyStr) -> None: ...
def move_atomic(src: AnyStr, dst: AnyStr) -> None: ...
class AtomicWriter(object):
def __init__(self, path: AnyStr, mode: Text='w', overwrite: bool=False) -> None: ...
def open(self) -> contextlib.ContextManager[IO]: ...
def _open(self, get_fileobject: Callable) -> contextlib.ContextManager[IO]: ...
def get_fileobject(self, dir: AnyStr=None, **kwargs) -> IO: ...
def sync(self, f: IO) -> None: ...
def commit(self, f: IO) -> None: ...
def rollback(self, f: IO) -> None: ...
def atomic_write(path: AnyStr, writer_cls: type=AtomicWriter, **cls_kwargs) -> contextlib.ContextManager[IO]: ...
mypy-0.470/typeshed/third_party/2and3/ujson.pyi 0000644 0000000 0000000 00000002047 13035744274 020202 0 ustar root root # Stubs for ujson
# See: https://pypi.python.org/pypi/ujson
from typing import Any, AnyStr, IO, Optional
__version__ = ... # type: str
def encode(
obj: Any,
ensure_ascii: bool = ...,
double_precision: bool = ...,
encode_html_chars: bool = ...,
escape_forward_slashes: bool = ...,
sort_keys: bool = ...,
indent: int = ...,
) -> str: ...
def dumps(
obj: Any,
ensure_ascii: bool = ...,
double_precision: bool = ...,
encode_html_chars: bool = ...,
escape_forward_slashes: bool = ...,
sort_keys: bool = ...,
indent: int = ...,
) -> str: ...
def dump(
obj: Any,
fp: IO[str],
ensure_ascii: bool = ...,
double_precision: bool = ...,
encode_html_chars: bool = ...,
escape_forward_slashes: bool = ...,
sort_keys: bool = ...,
indent: int = ...,
) -> None: ...
def decode(
s: AnyStr,
precise_float: bool = ...,
) -> Any: ...
def loads(
s: AnyStr,
precise_float: bool = ...,
) -> Any: ...
def load(
fp: IO[AnyStr],
precise_float: bool = ...,
) -> Any: ...
mypy-0.470/typeshed/third_party/2and3/boto/ 0000755 0000000 0000000 00000000000 13044320557 017253 5 ustar root root mypy-0.470/typeshed/third_party/2and3/boto/__init__.pyi 0000644 0000000 0000000 00000016103 13035744274 021544 0 ustar root root # Stubs for boto (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional, Text
import logging
from .s3.connection import S3Connection
Version = ... # type: Any
UserAgent = ... # type: Any
config = ... # type: Any
BUCKET_NAME_RE = ... # type: Any
TOO_LONG_DNS_NAME_COMP = ... # type: Any
GENERATION_RE = ... # type: Any
VERSION_RE = ... # type: Any
ENDPOINTS_PATH = ... # type: Any
def init_logging(): ...
class NullHandler(logging.Handler):
def emit(self, record): ...
log = ... # type: Any
perflog = ... # type: Any
def set_file_logger(name, filepath, level: Any = ..., format_string: Optional[Any] = ...): ...
def set_stream_logger(name, level: Any = ..., format_string: Optional[Any] = ...): ...
def connect_sqs(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_s3(aws_access_key_id: Optional[Text] = ..., aws_secret_access_key: Optional[Text] = ..., **kwargs) -> S3Connection: ...
def connect_gs(gs_access_key_id: Optional[Any] = ..., gs_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_ec2(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_elb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_autoscale(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudwatch(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_sdb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_fps(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_mturk(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudfront(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_vpc(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_rds(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_rds2(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_emr(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_sns(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_iam(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_route53(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudformation(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_euca(host: Optional[Any] = ..., aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., port: int = ..., path: str = ..., is_secure: bool = ..., **kwargs): ...
def connect_glacier(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_ec2_endpoint(url, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_walrus(host: Optional[Any] = ..., aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., port: int = ..., path: str = ..., is_secure: bool = ..., **kwargs): ...
def connect_ses(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_sts(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_ia(ia_access_key_id: Optional[Any] = ..., ia_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., **kwargs): ...
def connect_dynamodb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_swf(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudsearch(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudsearch2(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., sign_request: bool = ..., **kwargs): ...
def connect_cloudsearchdomain(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_beanstalk(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_elastictranscoder(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_opsworks(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_redshift(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_support(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudtrail(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_directconnect(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_kinesis(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_logs(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_route53domains(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cognito_identity(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cognito_sync(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_kms(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_awslambda(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_codedeploy(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_configservice(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_cloudhsm(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_ec2containerservice(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def connect_machinelearning(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ...
def storage_uri(uri_str, default_scheme: str = ..., debug: int = ..., validate: bool = ..., bucket_storage_uri_class: Any = ..., suppress_consec_slashes: bool = ..., is_latest: bool = ...): ...
def storage_uri_for_key(key): ...
mypy-0.470/typeshed/third_party/2and3/boto/auth.pyi 0000644 0000000 0000000 00000010666 13035744274 020756 0 ustar root root # Stubs for boto.auth (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from boto.auth_handler import AuthHandler
SIGV4_DETECT = ... # type: Any
class HmacKeys:
host = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def update_provider(self, provider): ...
def algorithm(self): ...
def sign_string(self, string_to_sign): ...
class AnonAuthHandler(AuthHandler, HmacKeys):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def add_auth(self, http_request, **kwargs): ...
class HmacAuthV1Handler(AuthHandler, HmacKeys):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def update_provider(self, provider): ...
def add_auth(self, http_request, **kwargs): ...
class HmacAuthV2Handler(AuthHandler, HmacKeys):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def update_provider(self, provider): ...
def add_auth(self, http_request, **kwargs): ...
class HmacAuthV3Handler(AuthHandler, HmacKeys):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def add_auth(self, http_request, **kwargs): ...
class HmacAuthV3HTTPHandler(AuthHandler, HmacKeys):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def headers_to_sign(self, http_request): ...
def canonical_headers(self, headers_to_sign): ...
def string_to_sign(self, http_request): ...
def add_auth(self, req, **kwargs): ...
class HmacAuthV4Handler(AuthHandler, HmacKeys):
capability = ... # type: Any
service_name = ... # type: Any
region_name = ... # type: Any
def __init__(self, host, config, provider, service_name: Optional[Any] = ..., region_name: Optional[Any] = ...) -> None: ...
def headers_to_sign(self, http_request): ...
def host_header(self, host, http_request): ...
def query_string(self, http_request): ...
def canonical_query_string(self, http_request): ...
def canonical_headers(self, headers_to_sign): ...
def signed_headers(self, headers_to_sign): ...
def canonical_uri(self, http_request): ...
def payload(self, http_request): ...
def canonical_request(self, http_request): ...
def scope(self, http_request): ...
def split_host_parts(self, host): ...
def determine_region_name(self, host): ...
def determine_service_name(self, host): ...
def credential_scope(self, http_request): ...
def string_to_sign(self, http_request, canonical_request): ...
def signature(self, http_request, string_to_sign): ...
def add_auth(self, req, **kwargs): ...
class S3HmacAuthV4Handler(HmacAuthV4Handler, AuthHandler):
capability = ... # type: Any
region_name = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
def clean_region_name(self, region_name): ...
def canonical_uri(self, http_request): ...
def canonical_query_string(self, http_request): ...
def host_header(self, host, http_request): ...
def headers_to_sign(self, http_request): ...
def determine_region_name(self, host): ...
def determine_service_name(self, host): ...
def mangle_path_and_params(self, req): ...
def payload(self, http_request): ...
def add_auth(self, req, **kwargs): ...
def presign(self, req, expires, iso_date: Optional[Any] = ...): ...
class STSAnonHandler(AuthHandler):
capability = ... # type: Any
def add_auth(self, http_request, **kwargs): ...
class QuerySignatureHelper(HmacKeys):
def add_auth(self, http_request, **kwargs): ...
class QuerySignatureV0AuthHandler(QuerySignatureHelper, AuthHandler):
SignatureVersion = ... # type: int
capability = ... # type: Any
class QuerySignatureV1AuthHandler(QuerySignatureHelper, AuthHandler):
SignatureVersion = ... # type: int
capability = ... # type: Any
def __init__(self, *args, **kw) -> None: ...
class QuerySignatureV2AuthHandler(QuerySignatureHelper, AuthHandler):
SignatureVersion = ... # type: int
capability = ... # type: Any
class POSTPathQSV2AuthHandler(QuerySignatureV2AuthHandler, AuthHandler):
capability = ... # type: Any
def add_auth(self, req, **kwargs): ...
def get_auth_handler(host, config, provider, requested_capability: Optional[Any] = ...): ...
def detect_potential_sigv4(func): ...
def detect_potential_s3sigv4(func): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/ 0000755 0000000 0000000 00000000000 13044320557 017600 5 ustar root root mypy-0.470/typeshed/third_party/2and3/boto/s3/prefix.pyi 0000644 0000000 0000000 00000000727 13035744274 021634 0 ustar root root # Stubs for boto.s3.prefix (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Prefix:
bucket = ... # type: Any
name = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
@property
def provider(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/deletemarker.pyi 0000644 0000000 0000000 00000001077 13035744274 023002 0 ustar root root # Stubs for boto.s3.deletemarker (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class DeleteMarker:
bucket = ... # type: Any
name = ... # type: Any
version_id = ... # type: Any
is_latest = ... # type: bool
last_modified = ... # type: Any
owner = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/keyfile.pyi 0000644 0000000 0000000 00000001642 13035744274 021764 0 ustar root root # Stubs for boto.s3.keyfile (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class KeyFile:
key = ... # type: Any
location = ... # type: int
closed = ... # type: bool
softspace = ... # type: int
mode = ... # type: str
encoding = ... # type: str
errors = ... # type: str
newlines = ... # type: str
name = ... # type: Any
def __init__(self, key) -> None: ...
def tell(self): ...
def seek(self, pos, whence: Any = ...): ...
def read(self, size): ...
def close(self): ...
def isatty(self): ...
def getkey(self): ...
def write(self, buf): ...
def fileno(self): ...
def flush(self): ...
def next(self): ...
def readinto(self): ...
def readline(self): ...
def readlines(self): ...
def truncate(self): ...
def writelines(self): ...
def xreadlines(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/__init__.pyi 0000644 0000000 0000000 00000001041 13035744274 022064 0 ustar root root # Stubs for boto.s3 (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .connection import S3Connection
from boto.connection import AWSAuthConnection
from boto.regioninfo import RegionInfo
from typing import List, Type, Text
class S3RegionInfo(RegionInfo):
def connect(self, name: Text=None, endpoint: str=None, connection_cls: Type[AWSAuthConnection]=None, **kw_params) -> S3Connection: ...
def regions() -> List[S3RegionInfo]: ...
def connect_to_region(region_name: Text, **kw_params): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/multidelete.pyi 0000644 0000000 0000000 00000002414 13035744274 022647 0 ustar root root # Stubs for boto.s3.multidelete (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Deleted:
key = ... # type: Any
version_id = ... # type: Any
delete_marker = ... # type: Any
delete_marker_version_id = ... # type: Any
def __init__(self, key: Optional[Any] = ..., version_id: Optional[Any] = ..., delete_marker: bool = ..., delete_marker_version_id: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class Error:
key = ... # type: Any
version_id = ... # type: Any
code = ... # type: Any
message = ... # type: Any
def __init__(self, key: Optional[Any] = ..., version_id: Optional[Any] = ..., code: Optional[Any] = ..., message: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class MultiDeleteResult:
bucket = ... # type: Any
deleted = ... # type: Any
errors = ... # type: Any
def __init__(self, bucket: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/connection.pyi 0000644 0000000 0000000 00000011135 13035744274 022471 0 ustar root root # Stubs for boto.s3.connection (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .bucket import Bucket
from typing import Any, Dict, Optional, Text, Type
from boto.connection import AWSAuthConnection
from boto.exception import BotoClientError
def check_lowercase_bucketname(n): ...
def assert_case_insensitive(f): ...
class _CallingFormat:
def get_bucket_server(self, server, bucket): ...
def build_url_base(self, connection, protocol, server, bucket, key: str = ...): ...
def build_host(self, server, bucket): ...
def build_auth_path(self, bucket, key: str = ...): ...
def build_path_base(self, bucket, key: str = ...): ...
class SubdomainCallingFormat(_CallingFormat):
def get_bucket_server(self, server, bucket): ...
class VHostCallingFormat(_CallingFormat):
def get_bucket_server(self, server, bucket): ...
class OrdinaryCallingFormat(_CallingFormat):
def get_bucket_server(self, server, bucket): ...
def build_path_base(self, bucket, key: str = ...): ...
class ProtocolIndependentOrdinaryCallingFormat(OrdinaryCallingFormat):
def build_url_base(self, connection, protocol, server, bucket, key: str = ...): ...
class Location:
DEFAULT = ... # type: str
EU = ... # type: str
EUCentral1 = ... # type: str
USWest = ... # type: str
USWest2 = ... # type: str
SAEast = ... # type: str
APNortheast = ... # type: str
APSoutheast = ... # type: str
APSoutheast2 = ... # type: str
CNNorth1 = ... # type: str
class NoHostProvided: ...
class HostRequiredError(BotoClientError): ...
class S3Connection(AWSAuthConnection):
DefaultHost = ... # type: Any
DefaultCallingFormat = ... # type: Any
QueryString = ... # type: str
calling_format = ... # type: Any
bucket_class = ... # type: Type[Bucket]
anon = ... # type: Any
def __init__(self, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., host: Any = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., calling_format: Any = ..., path: str = ..., provider: str = ..., bucket_class: Type[Bucket] = ..., security_token: Optional[Any] = ..., suppress_consec_slashes: bool = ..., anon: bool = ..., validate_certs: Optional[Any] = ..., profile_name: Optional[Any] = ...) -> None: ...
def __iter__(self): ...
def __contains__(self, bucket_name): ...
def set_bucket_class(self, bucket_class: Type[Bucket]) -> None: ...
def build_post_policy(self, expiration_time, conditions): ...
def build_post_form_args(self, bucket_name, key, expires_in: int = ..., acl: Optional[Any] = ..., success_action_redirect: Optional[Any] = ..., max_content_length: Optional[Any] = ..., http_method: str = ..., fields: Optional[Any] = ..., conditions: Optional[Any] = ..., storage_class: str = ..., server_side_encryption: Optional[Any] = ...): ...
def generate_url_sigv4(self, expires_in, method, bucket: str = ..., key: str = ..., headers: Optional[Dict[Text, Text]] = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., iso_date: Optional[Any] = ...): ...
def generate_url(self, expires_in, method, bucket: str = ..., key: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_auth: bool = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ..., version_id: Optional[Any] = ...): ...
def get_all_buckets(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_canonical_user_id(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_bucket(self, bucket_name: Text, validate: bool = ..., headers: Optional[Dict[Text, Text]] = ...) -> Bucket: ...
def head_bucket(self, bucket_name, headers: Optional[Dict[Text, Text]] = ...): ...
def lookup(self, bucket_name, validate: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def create_bucket(self, bucket_name, headers: Optional[Dict[Text, Text]] = ..., location: Any = ..., policy: Optional[Any] = ...): ...
def delete_bucket(self, bucket, headers: Optional[Dict[Text, Text]] = ...): ...
def make_request(self, method, bucket: str = ..., key: str = ..., headers: Optional[Any] = ..., data: str = ..., query_args: Optional[Any] = ..., sender: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., retry_handler: Optional[Any] = ..., *args, **kwargs): ... # type: ignore # https://github.com/python/mypy/issues/1237
mypy-0.470/typeshed/third_party/2and3/boto/s3/cors.pyi 0000644 0000000 0000000 00000002173 13035744274 021302 0 ustar root root # Stubs for boto.s3.cors (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class CORSRule:
allowed_method = ... # type: Any
allowed_origin = ... # type: Any
id = ... # type: Any
allowed_header = ... # type: Any
max_age_seconds = ... # type: Any
expose_header = ... # type: Any
def __init__(self, allowed_method: Optional[Any] = ..., allowed_origin: Optional[Any] = ..., id: Optional[Any] = ..., allowed_header: Optional[Any] = ..., max_age_seconds: Optional[Any] = ..., expose_header: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self) -> str: ...
class CORSConfiguration(list):
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self) -> str: ...
def add_rule(self, allowed_method, allowed_origin, id: Optional[Any] = ..., allowed_header: Optional[Any] = ..., max_age_seconds: Optional[Any] = ..., expose_header: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/key.pyi 0000644 0000000 0000000 00000016445 13035744274 021133 0 ustar root root # Stubs for boto.s3.key (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Callable, Dict, Optional, Text
class Key:
DefaultContentType = ... # type: str
RestoreBody = ... # type: str
BufferSize = ... # type: Any
base_user_settable_fields = ... # type: Any
base_fields = ... # type: Any
bucket = ... # type: Any
name = ... # type: str
metadata = ... # type: Any
cache_control = ... # type: Any
content_type = ... # type: Any
content_encoding = ... # type: Any
content_disposition = ... # type: Any
content_language = ... # type: Any
filename = ... # type: Any
etag = ... # type: Any
is_latest = ... # type: bool
last_modified = ... # type: Any
owner = ... # type: Any
path = ... # type: Any
resp = ... # type: Any
mode = ... # type: Any
size = ... # type: Any
version_id = ... # type: Any
source_version_id = ... # type: Any
delete_marker = ... # type: bool
encrypted = ... # type: Any
ongoing_restore = ... # type: Any
expiry_date = ... # type: Any
local_hashes = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ...
def __iter__(self): ...
@property
def provider(self): ...
key = ... # type: Any
md5 = ... # type: Any
base64md5 = ... # type: Any
storage_class = ... # type: Any
def get_md5_from_hexdigest(self, md5_hexdigest): ...
def handle_encryption_headers(self, resp): ...
def handle_version_headers(self, resp, force: bool = ...): ...
def handle_restore_headers(self, response): ...
def handle_addl_headers(self, headers): ...
def open_read(self, headers: Optional[Dict[Text, Text]] = ..., query_args: str = ..., override_num_retries: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ...): ...
def open_write(self, headers: Optional[Dict[Text, Text]] = ..., override_num_retries: Optional[Any] = ...): ...
def open(self, mode: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_args: Optional[Any] = ..., override_num_retries: Optional[Any] = ...): ...
closed = ... # type: bool
def close(self, fast: bool = ...): ...
def next(self): ...
__next__ = ... # type: Any
def read(self, size: int = ...): ...
def change_storage_class(self, new_storage_class, dst_bucket: Optional[Any] = ..., validate_dst_bucket: bool = ...): ...
def copy(self, dst_bucket, dst_key, metadata: Optional[Any] = ..., reduced_redundancy: bool = ..., preserve_acl: bool = ..., encrypt_key: bool = ..., validate_dst_bucket: bool = ...): ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def exists(self, headers: Optional[Dict[Text, Text]] = ...): ...
def delete(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_metadata(self, name): ...
def set_metadata(self, name, value): ...
def update_metadata(self, d): ...
def set_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ...
def get_acl(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_xml_acl(self, headers: Optional[Dict[Text, Text]] = ...): ...
def set_xml_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ...
def set_canned_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ...
def get_redirect(self): ...
def set_redirect(self, redirect_location, headers: Optional[Dict[Text, Text]] = ...): ...
def make_public(self, headers: Optional[Dict[Text, Text]] = ...): ...
def generate_url(self, expires_in, method: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_auth: bool = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ..., version_id: Optional[Any] = ..., policy: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ...): ...
def send_file(self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., query_args: Optional[Any] = ..., chunked_transfer: bool = ..., size: Optional[Any] = ...): ...
def should_retry(self, response, chunked_transfer: bool = ...): ...
def compute_md5(self, fp, size: Optional[Any] = ...): ...
def set_contents_from_stream(self, fp, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., reduced_redundancy: bool = ..., query_args: Optional[Any] = ..., size: Optional[Any] = ...): ...
def set_contents_from_file(self, fp, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., query_args: Optional[Any] = ..., encrypt_key: bool = ..., size: Optional[Any] = ..., rewind: bool = ...): ...
def set_contents_from_filename(self, filename, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ...): ...
def set_contents_from_string(self, string_data: Text, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ...) -> None: ...
def get_file(self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ...): ...
def get_torrent_file(self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ...): ...
def get_contents_to_file(self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., res_download_handler: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ...): ...
def get_contents_to_filename(self, filename, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., res_download_handler: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ...): ...
def get_contents_as_string(self, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., encoding: Optional[Any] = ...) -> str: ...
def add_email_grant(self, permission, email_address, headers: Optional[Dict[Text, Text]] = ...): ...
def add_user_grant(self, permission, user_id, headers: Optional[Dict[Text, Text]] = ..., display_name: Optional[Any] = ...): ...
def set_remote_metadata(self, metadata_plus, metadata_minus, preserve_acl, headers: Optional[Dict[Text, Text]] = ...): ...
def restore(self, days, headers: Optional[Dict[Text, Text]] = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/tagging.pyi 0000644 0000000 0000000 00000001555 13035744274 021757 0 ustar root root # Stubs for boto.s3.tagging (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Tag:
key = ... # type: Any
value = ... # type: Any
def __init__(self, key: Optional[Any] = ..., value: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
def __eq__(self, other): ...
class TagSet(list):
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def add_tag(self, key, value): ...
def to_xml(self): ...
class Tags(list):
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
def add_tag_set(self, tag_set): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/multipart.pyi 0000644 0000000 0000000 00000004363 13035744274 022360 0 ustar root root # Stubs for boto.s3.multipart (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class CompleteMultiPartUpload:
bucket = ... # type: Any
location = ... # type: Any
bucket_name = ... # type: Any
key_name = ... # type: Any
etag = ... # type: Any
version_id = ... # type: Any
encrypted = ... # type: Any
def __init__(self, bucket: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class Part:
bucket = ... # type: Any
part_number = ... # type: Any
last_modified = ... # type: Any
etag = ... # type: Any
size = ... # type: Any
def __init__(self, bucket: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def part_lister(mpupload, part_number_marker: Optional[Any] = ...): ...
class MultiPartUpload:
bucket = ... # type: Any
bucket_name = ... # type: Any
key_name = ... # type: Any
id = ... # type: Any
initiator = ... # type: Any
owner = ... # type: Any
storage_class = ... # type: Any
initiated = ... # type: Any
part_number_marker = ... # type: Any
next_part_number_marker = ... # type: Any
max_parts = ... # type: Any
is_truncated = ... # type: bool
def __init__(self, bucket: Optional[Any] = ...) -> None: ...
def __iter__(self): ...
def to_xml(self): ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def get_all_parts(self, max_parts: Optional[Any] = ..., part_number_marker: Optional[Any] = ..., encoding_type: Optional[Any] = ...): ...
def upload_part_from_file(self, fp, part_num, headers: Optional[Any] = ..., replace: bool = ..., cb: Optional[Any] = ..., num_cb: int = ..., md5: Optional[Any] = ..., size: Optional[Any] = ...): ...
def copy_part_from_key(self, src_bucket_name, src_key_name, part_num, start: Optional[Any] = ..., end: Optional[Any] = ..., src_version_id: Optional[Any] = ..., headers: Optional[Any] = ...): ...
def complete_upload(self): ...
def cancel_upload(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/bucket.pyi 0000644 0000000 0000000 00000020151 13035744274 021605 0 ustar root root # Stubs for boto.s3.bucket (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .bucketlistresultset import BucketListResultSet
from .connection import S3Connection
from .key import Key
from typing import Any, Dict, Optional, Text, Type
class S3WebsiteEndpointTranslate:
trans_region = ... # type: Dict[str, str]
@classmethod
def translate_region(self, reg: Text) -> str: ...
S3Permissions = ... # type: List[str]
class Bucket:
LoggingGroup = ... # type: str
BucketPaymentBody = ... # type: str
VersioningBody = ... # type: str
VersionRE = ... # type: str
MFADeleteRE = ... # type: str
name = ... # type: Text
connection = ... # type: S3Connection
key_class = ... # type: Type[Key]
def __init__(self, connection: Optional[S3Connection] = ..., name: Optional[Text] = ..., key_class: Type[Key] = ...) -> None: ...
def __iter__(self): ...
def __contains__(self, key_name) -> bool: ...
def startElement(self, name, attrs, connection): ...
creation_date = ... # type: Any
def endElement(self, name, value, connection): ...
def set_key_class(self, key_class): ...
def lookup(self, key_name, headers: Optional[Dict[Text, Text]] = ...): ...
def get_key(self, key_name, headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., validate: bool = ...) -> Key: ...
def list(self, prefix: Text = ..., delimiter: Text = ..., marker: Text = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Any] = ...) -> BucketListResultSet: ...
def list_versions(self, prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Text] = ...) -> BucketListResultSet: ...
def list_multipart_uploads(self, key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Any] = ...): ...
def validate_kwarg_names(self, kwargs, names): ...
def get_all_keys(self, headers: Optional[Dict[Text, Text]] = ..., **params): ...
def get_all_versions(self, headers: Optional[Dict[Text, Text]] = ..., **params): ...
def validate_get_all_versions_params(self, params): ...
def get_all_multipart_uploads(self, headers: Optional[Dict[Text, Text]] = ..., **params): ...
def new_key(self, key_name: Optional[Any] = ...): ...
def generate_url(self, expires_in, method: str = ..., headers: Optional[Dict[Text, Text]] = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ...): ...
def delete_keys(self, keys, quiet: bool = ..., mfa_token: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def delete_key(self, key_name, headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., mfa_token: Optional[Any] = ...): ...
def copy_key(self, new_key_name, src_bucket_name, src_key_name, metadata: Optional[Any] = ..., src_version_id: Optional[Any] = ..., storage_class: str = ..., preserve_acl: bool = ..., encrypt_key: bool = ..., headers: Optional[Dict[Text, Text]] = ..., query_args: Optional[Any] = ...): ...
def set_canned_acl(self, acl_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def get_xml_acl(self, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def set_xml_acl(self, acl_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., query_args: str = ...): ...
def set_acl(self, acl_or_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def get_acl(self, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def set_subresource(self, subresource, value, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def get_subresource(self, subresource, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ...
def make_public(self, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def add_email_grant(self, permission, email_address, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def add_user_grant(self, permission, user_id, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ..., display_name: Optional[Any] = ...): ...
def list_grants(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_location(self): ...
def set_xml_logging(self, logging_str, headers: Optional[Dict[Text, Text]] = ...): ...
def enable_logging(self, target_bucket, target_prefix: str = ..., grants: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def disable_logging(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_logging_status(self, headers: Optional[Dict[Text, Text]] = ...): ...
def set_as_logging_target(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_request_payment(self, headers: Optional[Dict[Text, Text]] = ...): ...
def set_request_payment(self, payer: str = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def configure_versioning(self, versioning, mfa_delete: bool = ..., mfa_token: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def get_versioning_status(self, headers: Optional[Dict[Text, Text]] = ...): ...
def configure_lifecycle(self, lifecycle_config, headers: Optional[Dict[Text, Text]] = ...): ...
def get_lifecycle_config(self, headers: Optional[Dict[Text, Text]] = ...): ...
def delete_lifecycle_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ...
def configure_website(self, suffix: Optional[Any] = ..., error_key: Optional[Any] = ..., redirect_all_requests_to: Optional[Any] = ..., routing_rules: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ...): ...
def set_website_configuration(self, config, headers: Optional[Dict[Text, Text]] = ...): ...
def set_website_configuration_xml(self, xml, headers: Optional[Dict[Text, Text]] = ...): ...
def get_website_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_website_configuration_obj(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_website_configuration_with_xml(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_website_configuration_xml(self, headers: Optional[Dict[Text, Text]] = ...): ...
def delete_website_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_website_endpoint(self): ...
def get_policy(self, headers: Optional[Dict[Text, Text]] = ...): ...
def set_policy(self, policy, headers: Optional[Dict[Text, Text]] = ...): ...
def delete_policy(self, headers: Optional[Dict[Text, Text]] = ...): ...
def set_cors_xml(self, cors_xml, headers: Optional[Dict[Text, Text]] = ...): ...
def set_cors(self, cors_config, headers: Optional[Dict[Text, Text]] = ...): ...
def get_cors_xml(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_cors(self, headers: Optional[Dict[Text, Text]] = ...): ...
def delete_cors(self, headers: Optional[Dict[Text, Text]] = ...): ...
def initiate_multipart_upload(self, key_name, headers: Optional[Dict[Text, Text]] = ..., reduced_redundancy: bool = ..., metadata: Optional[Any] = ..., encrypt_key: bool = ..., policy: Optional[Any] = ...): ...
def complete_multipart_upload(self, key_name, upload_id, xml_body, headers: Optional[Dict[Text, Text]] = ...): ...
def cancel_multipart_upload(self, key_name, upload_id, headers: Optional[Dict[Text, Text]] = ...): ...
def delete(self, headers: Optional[Dict[Text, Text]] = ...): ...
def get_tags(self): ...
def get_xml_tags(self): ...
def set_xml_tags(self, tag_str, headers: Optional[Dict[Text, Text]] = ..., query_args: str = ...): ...
def set_tags(self, tags, headers: Optional[Dict[Text, Text]] = ...): ...
def delete_tags(self, headers: Optional[Dict[Text, Text]] = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/user.pyi 0000644 0000000 0000000 00000001011 13035744274 021300 0 ustar root root # Stubs for boto.s3.user (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class User:
type = ... # type: Any
id = ... # type: Any
display_name = ... # type: Any
def __init__(self, parent: Optional[Any] = ..., id: str = ..., display_name: str = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self, element_name: str = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/bucketlistresultset.pyi 0000644 0000000 0000000 00000004213 13035744274 024455 0 ustar root root # Stubs for boto.s3.bucketlistresultset (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .bucket import Bucket
from .key import Key
from typing import Any, Iterable, Iterator, Optional
def bucket_lister(bucket, prefix: str = ..., delimiter: str = ..., marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...): ...
class BucketListResultSet(Iterable[Key]):
bucket = ... # type: Any
prefix = ... # type: Any
delimiter = ... # type: Any
marker = ... # type: Any
headers = ... # type: Any
encoding_type = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., prefix: str = ..., delimiter: str = ..., marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...) -> None: ...
def __iter__(self) -> Iterator[Key]: ...
def versioned_bucket_lister(bucket, prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...): ...
class VersionedBucketListResultSet:
bucket = ... # type: Any
prefix = ... # type: Any
delimiter = ... # type: Any
key_marker = ... # type: Any
version_id_marker = ... # type: Any
headers = ... # type: Any
encoding_type = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...) -> None: ...
def __iter__(self) -> Iterator[Key]: ...
def multipart_upload_lister(bucket, key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...): ...
class MultiPartUploadListResultSet:
bucket = ... # type: Any
key_marker = ... # type: Any
upload_id_marker = ... # type: Any
headers = ... # type: Any
encoding_type = ... # type: Any
def __init__(self, bucket: Optional[Any] = ..., key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ...) -> None: ...
def __iter__(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/acl.pyi 0000644 0000000 0000000 00000003616 13035744274 021076 0 ustar root root # Stubs for boto.s3.acl (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from .connection import S3Connection
from .user import User
from typing import Any, Dict, Optional, List, Text, Union
CannedACLStrings = ... # type: List[str]
class Policy:
parent = ... # type: Any
namespace = ... # type: Any
acl = ... # type: ACL
def __init__(self, parent: Optional[Any] = ...) -> None: ...
owner = ... # type: User
def startElement(self, name: Text, attrs: Dict[str, Any], connection: S3Connection) -> Union[None, User, ACL]: ...
def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ...
def to_xml(self) -> str: ...
class ACL:
policy = ... # type: Policy
grants = ... # type: List[Grant]
def __init__(self, policy: Optional[Policy] = ...) -> None: ...
def add_grant(self, grant: Grant) -> None: ...
def add_email_grant(self, permission: Text, email_address: Text) -> None: ...
def add_user_grant(self, permission: Text, user_id: Text, display_name: Optional[Text] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ...
def to_xml(self) -> str: ...
class Grant:
NameSpace = ... # type: Text
permission = ... # type: Text
id = ... # type: Text
display_name = ... # type: Text
uri = ... # type: Text
email_address = ... # type: Text
type = ... # type: Text
def __init__(self, permission: Optional[Text] = ..., type: Optional[Text] = ..., id: Optional[Text] = ..., display_name: Optional[Text] = ..., uri: Optional[Text] = ..., email_address: Optional[Text] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ...
def to_xml(self) -> str: ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/bucketlogging.pyi 0000644 0000000 0000000 00000001070 13035744274 023153 0 ustar root root # Stubs for boto.s3.bucketlogging (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class BucketLogging:
target = ... # type: Any
prefix = ... # type: Any
grants = ... # type: Any
def __init__(self, target: Optional[Any] = ..., prefix: Optional[Any] = ..., grants: Optional[Any] = ...) -> None: ...
def add_grant(self, grant): ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/website.pyi 0000644 0000000 0000000 00000005434 13035744274 022001 0 ustar root root # Stubs for boto.s3.website (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
def tag(key, value): ...
class WebsiteConfiguration:
suffix = ... # type: Any
error_key = ... # type: Any
redirect_all_requests_to = ... # type: Any
routing_rules = ... # type: Any
def __init__(self, suffix: Optional[Any] = ..., error_key: Optional[Any] = ..., redirect_all_requests_to: Optional[Any] = ..., routing_rules: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
class _XMLKeyValue:
translator = ... # type: Any
container = ... # type: Any
def __init__(self, translator, container: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
class RedirectLocation(_XMLKeyValue):
TRANSLATOR = ... # type: Any
hostname = ... # type: Any
protocol = ... # type: Any
def __init__(self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ...) -> None: ...
def to_xml(self): ...
class RoutingRules(list):
def add_rule(self, rule): ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
class RoutingRule:
condition = ... # type: Any
redirect = ... # type: Any
def __init__(self, condition: Optional[Any] = ..., redirect: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
@classmethod
def when(cls, key_prefix: Optional[Any] = ..., http_error_code: Optional[Any] = ...): ...
def then_redirect(self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ..., replace_key: Optional[Any] = ..., replace_key_prefix: Optional[Any] = ..., http_redirect_code: Optional[Any] = ...): ...
class Condition(_XMLKeyValue):
TRANSLATOR = ... # type: Any
key_prefix = ... # type: Any
http_error_code = ... # type: Any
def __init__(self, key_prefix: Optional[Any] = ..., http_error_code: Optional[Any] = ...) -> None: ...
def to_xml(self): ...
class Redirect(_XMLKeyValue):
TRANSLATOR = ... # type: Any
hostname = ... # type: Any
protocol = ... # type: Any
replace_key = ... # type: Any
replace_key_prefix = ... # type: Any
http_redirect_code = ... # type: Any
def __init__(self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ..., replace_key: Optional[Any] = ..., replace_key_prefix: Optional[Any] = ..., http_redirect_code: Optional[Any] = ...) -> None: ...
def to_xml(self): ...
mypy-0.470/typeshed/third_party/2and3/boto/s3/lifecycle.pyi 0000644 0000000 0000000 00000004206 13035744274 022272 0 ustar root root # Stubs for boto.s3.lifecycle (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Rule:
id = ... # type: Any
prefix = ... # type: Any
status = ... # type: Any
expiration = ... # type: Any
transition = ... # type: Any
def __init__(self, id: Optional[Any] = ..., prefix: Optional[Any] = ..., status: Optional[Any] = ..., expiration: Optional[Any] = ..., transition: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
class Expiration:
days = ... # type: Any
date = ... # type: Any
def __init__(self, days: Optional[Any] = ..., date: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
class Transition:
days = ... # type: Any
date = ... # type: Any
storage_class = ... # type: Any
def __init__(self, days: Optional[Any] = ..., date: Optional[Any] = ..., storage_class: Optional[Any] = ...) -> None: ...
def to_xml(self): ...
class Transitions(list):
transition_properties = ... # type: int
current_transition_property = ... # type: int
temp_days = ... # type: Any
temp_date = ... # type: Any
temp_storage_class = ... # type: Any
def __init__(self) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
def add_transition(self, days: Optional[Any] = ..., date: Optional[Any] = ..., storage_class: Optional[Any] = ...): ...
@property
def days(self): ...
@property
def date(self): ...
@property
def storage_class(self): ...
class Lifecycle(list):
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def to_xml(self): ...
def add_rule(self, id: Optional[Any] = ..., prefix: str = ..., status: str = ..., expiration: Optional[Any] = ..., transition: Optional[Any] = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/plugin.pyi 0000644 0000000 0000000 00000000555 13035744274 021307 0 ustar root root # Stubs for boto.plugin (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
class Plugin:
capability = ... # type: Any
@classmethod
def is_capable(cls, requested_capability): ...
def get_plugin(cls, requested_capability: Optional[Any] = ...): ...
def load_plugins(config): ...
mypy-0.470/typeshed/third_party/2and3/boto/regioninfo.pyi 0000644 0000000 0000000 00000001476 13035744274 022153 0 ustar root root # Stubs for boto.regioninfo (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
def load_endpoint_json(path): ...
def merge_endpoints(defaults, additions): ...
def load_regions(): ...
def get_regions(service_name, region_cls: Optional[Any] = ..., connection_cls: Optional[Any] = ...): ...
class RegionInfo:
connection = ... # type: Any
name = ... # type: Any
endpoint = ... # type: Any
connection_cls = ... # type: Any
def __init__(self, connection: Optional[Any] = ..., name: Optional[Any] = ..., endpoint: Optional[Any] = ..., connection_cls: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
def connect(self, **kw_params): ...
mypy-0.470/typeshed/third_party/2and3/boto/connection.pyi 0000644 0000000 0000000 00000013632 13035744274 022150 0 ustar root root # Stubs for boto.connection (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Dict, Optional, Text
from six.moves import http_client
HAVE_HTTPS_CONNECTION = ... # type: bool
ON_APP_ENGINE = ... # type: Any
PORTS_BY_SECURITY = ... # type: Any
DEFAULT_CA_CERTS_FILE = ... # type: Any
class HostConnectionPool:
queue = ... # type: Any
def __init__(self) -> None: ...
def size(self): ...
def put(self, conn): ...
def get(self): ...
def clean(self): ...
class ConnectionPool:
CLEAN_INTERVAL = ... # type: float
STALE_DURATION = ... # type: float
host_to_pool = ... # type: Any
last_clean_time = ... # type: float
mutex = ... # type: Any
def __init__(self) -> None: ...
def size(self): ...
def get_http_connection(self, host, port, is_secure): ...
def put_http_connection(self, host, port, is_secure, conn): ...
def clean(self): ...
class HTTPRequest:
method = ... # type: Any
protocol = ... # type: Any
host = ... # type: Any
port = ... # type: Any
path = ... # type: Any
auth_path = ... # type: Any
params = ... # type: Any
headers = ... # type: Any
body = ... # type: Any
def __init__(self, method, protocol, host, port, path, auth_path, params, headers, body) -> None: ...
def authorize(self, connection, **kwargs): ...
class HTTPResponse(http_client.HTTPResponse):
def __init__(self, *args, **kwargs) -> None: ...
def read(self, amt: Optional[Any] = ...): ...
class AWSAuthConnection:
suppress_consec_slashes = ... # type: Any
num_retries = ... # type: int
is_secure = ... # type: Any
https_validate_certificates = ... # type: Any
ca_certificates_file = ... # type: Any
port = ... # type: Any
http_exceptions = ... # type: Any
http_unretryable_exceptions = ... # type: Any
socket_exception_values = ... # type: Any
https_connection_factory = ... # type: Any
protocol = ... # type: str
host = ... # type: Any
path = ... # type: Any
debug = ... # type: Any
host_header = ... # type: Any
http_connection_kwargs = ... # type: Any
provider = ... # type: Any
auth_service_name = ... # type: Any
request_hook = ... # type: Any
def __init__(self, host, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., path: str = ..., provider: str = ..., security_token: Optional[Any] = ..., suppress_consec_slashes: bool = ..., validate_certs: bool = ..., profile_name: Optional[Any] = ...) -> None: ...
auth_region_name = ... # type: Any
@property
def connection(self): ...
@property
def aws_access_key_id(self): ...
@property
def gs_access_key_id(self): ... # type: Any
access_key = ... # type: Any
@property
def aws_secret_access_key(self): ...
@property
def gs_secret_access_key(self): ...
secret_key = ... # type: Any
@property
def profile_name(self): ...
def get_path(self, path: str = ...): ...
def server_name(self, port: Optional[Any] = ...): ...
proxy = ... # type: Any
proxy_port = ... # type: Any
proxy_user = ... # type: Any
proxy_pass = ... # type: Any
no_proxy = ... # type: Any
use_proxy = ... # type: Any
def handle_proxy(self, proxy, proxy_port, proxy_user, proxy_pass): ...
def get_http_connection(self, host, port, is_secure): ...
def skip_proxy(self, host): ...
def new_http_connection(self, host, port, is_secure): ...
def put_http_connection(self, host, port, is_secure, connection): ...
def proxy_ssl(self, host: Optional[Any] = ..., port: Optional[Any] = ...): ...
def prefix_proxy_to_path(self, path, host: Optional[Any] = ...): ...
def get_proxy_auth_header(self): ...
def get_proxy_url_with_auth(self): ...
def set_host_header(self, request): ...
def set_request_hook(self, hook): ...
def build_base_http_request(self, method, path, auth_path, params: Optional[Any] = ..., headers: Optional[Any] = ..., data: str = ..., host: Optional[Any] = ...): ...
def make_request(self, method, path, headers: Optional[Any] = ..., data: str = ..., host: Optional[Any] = ..., auth_path: Optional[Any] = ..., sender: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., params: Optional[Any] = ..., retry_handler: Optional[Any] = ...): ...
def close(self): ...
class AWSQueryConnection(AWSAuthConnection):
APIVersion = ... # type: str
ResponseError = ... # type: Any
def __init__(self, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., host: Optional[Any] = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., path: str = ..., security_token: Optional[Any] = ..., validate_certs: bool = ..., profile_name: Optional[Any] = ..., provider: str = ...) -> None: ...
def get_utf8_value(self, value): ...
def make_request(self, action, params: Optional[Any] = ..., path: str = ..., verb: str = ..., *args, **kwargs): ... # type: ignore # https://github.com/python/mypy/issues/1237
def build_list_params(self, params, items, label): ...
def build_complex_list_params(self, params, items, label, names): ...
def get_list(self, action, params, markers, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ...
def get_object(self, action, params, cls, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ...
def get_status(self, action, params, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ...
mypy-0.470/typeshed/third_party/2and3/boto/exception.pyi 0000644 0000000 0000000 00000012267 13035744274 022012 0 ustar root root # Stubs for boto.exception (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Optional
from boto.compat import StandardError
class BotoClientError(StandardError):
reason = ... # type: Any
def __init__(self, reason, *args) -> None: ...
class SDBPersistenceError(StandardError): ...
class StoragePermissionsError(BotoClientError): ...
class S3PermissionsError(StoragePermissionsError): ...
class GSPermissionsError(StoragePermissionsError): ...
class BotoServerError(StandardError):
status = ... # type: Any
reason = ... # type: Any
body = ... # type: Any
request_id = ... # type: Any
error_code = ... # type: Any
message = ... # type: str
box_usage = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ..., *args) -> None: ...
def __getattr__(self, name): ...
def __setattr__(self, name, value): ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class ConsoleOutput:
parent = ... # type: Any
instance_id = ... # type: Any
timestamp = ... # type: Any
comment = ... # type: Any
output = ... # type: Any
def __init__(self, parent: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class StorageCreateError(BotoServerError):
bucket = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ...
def endElement(self, name, value, connection): ...
class S3CreateError(StorageCreateError): ...
class GSCreateError(StorageCreateError): ...
class StorageCopyError(BotoServerError): ...
class S3CopyError(StorageCopyError): ...
class GSCopyError(StorageCopyError): ...
class SQSError(BotoServerError):
detail = ... # type: Any
type = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class SQSDecodeError(BotoClientError):
message = ... # type: Any
def __init__(self, reason, message) -> None: ...
class StorageResponseError(BotoServerError):
resource = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class S3ResponseError(StorageResponseError): ...
class GSResponseError(StorageResponseError): ...
class EC2ResponseError(BotoServerError):
errors = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
request_id = ... # type: Any
def endElement(self, name, value, connection): ...
class JSONResponseError(BotoServerError):
status = ... # type: Any
reason = ... # type: Any
body = ... # type: Any
error_message = ... # type: Any
error_code = ... # type: Any
def __init__(self, status, reason, body: Optional[Any] = ..., *args) -> None: ...
class DynamoDBResponseError(JSONResponseError): ...
class SWFResponseError(JSONResponseError): ...
class EmrResponseError(BotoServerError): ...
class _EC2Error:
connection = ... # type: Any
error_code = ... # type: Any
error_message = ... # type: Any
def __init__(self, connection: Optional[Any] = ...) -> None: ...
def startElement(self, name, attrs, connection): ...
def endElement(self, name, value, connection): ...
class SDBResponseError(BotoServerError): ...
class AWSConnectionError(BotoClientError): ...
class StorageDataError(BotoClientError): ...
class S3DataError(StorageDataError): ...
class GSDataError(StorageDataError): ...
class InvalidUriError(Exception):
message = ... # type: Any
def __init__(self, message) -> None: ...
class InvalidAclError(Exception):
message = ... # type: Any
def __init__(self, message) -> None: ...
class InvalidCorsError(Exception):
message = ... # type: Any
def __init__(self, message) -> None: ...
class NoAuthHandlerFound(Exception): ...
class InvalidLifecycleConfigError(Exception):
message = ... # type: Any
def __init__(self, message) -> None: ...
class ResumableTransferDisposition:
START_OVER = ... # type: str
WAIT_BEFORE_RETRY = ... # type: str
ABORT_CUR_PROCESS = ... # type: str
ABORT = ... # type: str
class ResumableUploadException(Exception):
message = ... # type: Any
disposition = ... # type: Any
def __init__(self, message, disposition) -> None: ...
class ResumableDownloadException(Exception):
message = ... # type: Any
disposition = ... # type: Any
def __init__(self, message, disposition) -> None: ...
class TooManyRecordsException(Exception):
message = ... # type: Any
def __init__(self, message) -> None: ...
class PleaseRetryException(Exception):
message = ... # type: Any
response = ... # type: Any
def __init__(self, message, response: Optional[Any] = ...) -> None: ...
class InvalidInstanceMetadataError(Exception):
MSG = ... # type: str
def __init__(self, msg) -> None: ...
mypy-0.470/typeshed/third_party/2and3/boto/ec2/ 0000755 0000000 0000000 00000000000 13044320557 017724 5 ustar root root mypy-0.470/typeshed/third_party/2and3/boto/ec2/__init__.pyi 0000644 0000000 0000000 00000000447 13035744274 022221 0 ustar root root # Stubs for boto.ec2 (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
RegionData = ... # type: Any
def regions(**kw_params): ...
def connect_to_region(region_name, **kw_params): ...
def get_region(region_name, **kw_params): ...
mypy-0.470/typeshed/third_party/2and3/boto/compat.pyi 0000644 0000000 0000000 00000000572 13035744274 021273 0 ustar root root # Stubs for boto.compat (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from base64 import encodestring as encodebytes
from six.moves import http_client
expanduser = ... # type: Any
StandardError = ... # type: Any
long_type = ... # type: Any
unquote_str = ... # type: Any
parse_qs_safe = ... # type: Any
mypy-0.470/typeshed/third_party/2and3/boto/auth_handler.pyi 0000644 0000000 0000000 00000000602 13035744274 022440 0 ustar root root # Stubs for boto.auth_handler (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from boto.plugin import Plugin
class NotReadyToAuthenticate(Exception): ...
class AuthHandler(Plugin):
capability = ... # type: Any
def __init__(self, host, config, provider) -> None: ...
def add_auth(self, http_request): ...
mypy-0.470/typeshed/third_party/2and3/boto/elb/ 0000755 0000000 0000000 00000000000 13044320557 020015 5 ustar root root mypy-0.470/typeshed/third_party/2and3/boto/elb/__init__.pyi 0000644 0000000 0000000 00000005150 13035744274 022306 0 ustar root root # Stubs for boto.ec2.elb (Python 2)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from boto.connection import AWSQueryConnection
RegionData = ... # type: Any
def regions(): ...
def connect_to_region(region_name, **kw_params): ...
class ELBConnection(AWSQueryConnection):
APIVersion = ... # type: Any
DefaultRegionName = ... # type: Any
DefaultRegionEndpoint = ... # type: Any
region = ... # type: Any
def __init__(self, aws_access_key_id=..., aws_secret_access_key=..., is_secure=..., port=..., proxy=..., proxy_port=..., proxy_user=..., proxy_pass=..., debug=..., https_connection_factory=..., region=..., path=..., security_token=..., validate_certs=..., profile_name=...) -> None: ...
def build_list_params(self, params, items, label): ...
def get_all_load_balancers(self, load_balancer_names=..., marker=...): ...
def create_load_balancer(self, name, zones, listeners=..., subnets=..., security_groups=..., scheme=..., complex_listeners=...): ...
def create_load_balancer_listeners(self, name, listeners=..., complex_listeners=...): ...
def delete_load_balancer(self, name): ...
def delete_load_balancer_listeners(self, name, ports): ...
def enable_availability_zones(self, load_balancer_name, zones_to_add): ...
def disable_availability_zones(self, load_balancer_name, zones_to_remove): ...
def modify_lb_attribute(self, load_balancer_name, attribute, value): ...
def get_all_lb_attributes(self, load_balancer_name): ...
def get_lb_attribute(self, load_balancer_name, attribute): ...
def register_instances(self, load_balancer_name, instances): ...
def deregister_instances(self, load_balancer_name, instances): ...
def describe_instance_health(self, load_balancer_name, instances=...): ...
def configure_health_check(self, name, health_check): ...
def set_lb_listener_SSL_certificate(self, lb_name, lb_port, ssl_certificate_id): ...
def create_app_cookie_stickiness_policy(self, name, lb_name, policy_name): ...
def create_lb_cookie_stickiness_policy(self, cookie_expiration_period, lb_name, policy_name): ...
def create_lb_policy(self, lb_name, policy_name, policy_type, policy_attributes): ...
def delete_lb_policy(self, lb_name, policy_name): ...
def set_lb_policies_of_listener(self, lb_name, lb_port, policies): ...
def set_lb_policies_of_backend_server(self, lb_name, instance_port, policies): ...
def apply_security_groups_to_lb(self, name, security_groups): ...
def attach_lb_to_subnets(self, name, subnets): ...
def detach_lb_from_subnets(self, name, subnets): ...
mypy-0.470/typeshed/third_party/2and3/singledispatch.pyi 0000644 0000000 0000000 00000001212 13035744274 022036 0 ustar root root from typing import Any, Callable, Generic, Mapping, Optional, TypeVar, overload
_T = TypeVar("_T")
class _SingleDispatchCallable(Generic[_T]):
registry = ... # type: Mapping[Any, Callable[..., _T]]
def dispatch(self, cls: Any) -> Callable[..., _T]: ...
@overload
def register(self, cls: Any) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
@overload
def register(self, cls: Any, func: Callable[..., _T]) -> Callable[..., _T]: ...
def _clear_cache(self) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
mypy-0.470/typeshed/third_party/2and3/mypy_extensions.pyi 0000644 0000000 0000000 00000000540 13035744274 022315 0 ustar root root from typing import Dict, Type, TypeVar, Union
T = TypeVar('T')
def TypedDict(typename: str, fields: Dict[str, Type[T]]) -> Type[dict]: ...
# Return type that indicates a function does not return.
# This type is equivalent to the None type, but the no-op Union is necessary to
# distinguish the None type from the None value.
NoReturn = Union[None]
mypy-0.470/typeshed/third_party/2and3/markupsafe/ 0000755 0000000 0000000 00000000000 13044320557 020446 5 ustar root root mypy-0.470/typeshed/third_party/2and3/markupsafe/_constants.pyi 0000644 0000000 0000000 00000000317 13035744274 023353 0 ustar root root # Stubs for markupsafe._constants (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any, Dict, Text
HTML_ENTITIES = ... # type: Dict[Text, int]
mypy-0.470/typeshed/third_party/2and3/markupsafe/__init__.pyi 0000644 0000000 0000000 00000005601 13035744274 022740 0 ustar root root # Stubs for markupsafe (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
import sys
from typing import Any, Callable, Dict, Iterable, List, Optional, Text, Tuple, Union
from collections import Mapping
from markupsafe._compat import text_type
import string
from markupsafe._speedups import escape as escape, escape_silent as escape_silent, soft_unicode as soft_unicode
from markupsafe._native import escape as escape, escape_silent as escape_silent, soft_unicode as soft_unicode
class Markup(text_type):
def __new__(cls, base: Text = ..., encoding: Optional[Text] = ..., errors: Text = ...) -> Markup: ...
def __html__(self) -> Markup: ...
def __add__(self, other: text_type) -> Markup: ...
def __radd__(self, other: text_type) -> Markup: ...
def __mul__(self, num: int) -> Markup: ...
def __rmul__(self, num: int) -> Markup: ...
def __mod__(self, *args: Any) -> Markup: ...
def join(self, seq: Iterable[text_type]): ...
def split(self, sep: text_type = None, maxsplit: int = -1) -> List[text_type]: ...
def rsplit(self, sep: text_type = None, maxsplit: int = -1) -> List[text_type]: ...
def splitlines(self, keepends: bool = ...) -> List[text_type]: ...
def unescape(self) -> Text: ...
def striptags(self) -> Text: ...
@classmethod
def escape(cls, s: text_type) -> Markup: ...
def partition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ...
def rpartition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ...
def format(*args, **kwargs) -> Markup: ...
def __html_format__(self, format_spec) -> Markup: ...
def __getslice__(self, start: int, stop: int) -> Markup: ...
def __getitem__(self, i: Union[int, slice]) -> Markup: ...
def capitalize(self) -> Markup: ...
def title(self) -> Markup: ...
def lower(self) -> Markup: ...
def upper(self) -> Markup: ...
def swapcase(self) -> Markup: ...
def replace(self, old: text_type, new: text_type, count: int = -1) -> Markup: ...
def ljust(self, width: int, fillchar: text_type = ...) -> Markup: ...
def rjust(self, width: int, fillchar: text_type = ...) -> Markup: ...
def lstrip(self, chars: text_type = None) -> Markup: ...
def rstrip(self, chars: text_type = None) -> Markup: ...
def strip(self, chars: text_type = None) -> Markup: ...
def center(self, width: int, fillchar: text_type = ...) -> Markup: ...
def zfill(self, width: int) -> Markup: ...
def translate(self, table: Union[Dict[int, Any], text_type]) -> Markup: ...
def expandtabs(self, tabsize: int = 8) -> Markup: ...
class EscapeFormatter(string.Formatter):
escape = ... # type: Callable[[text_type], Markup]
def __init__(self, escape: Callable[[text_type], Markup]) -> None: ...
def format_field(self, value: text_type, format_spec: text_type) -> Markup: ...
if sys.version_info[0] >= 3:
soft_str = soft_unicode
mypy-0.470/typeshed/third_party/2and3/markupsafe/_speedups.pyi 0000644 0000000 0000000 00000000574 13035744274 023174 0 ustar root root # Stubs for markupsafe._speedups (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import Markup
from ._compat import text_type, string_types
from typing import Union, Text
def escape(s: Union[Markup, Text]) -> Markup: ...
def escape_silent(s: Union[None, Markup, Text]) -> Markup: ...
def soft_unicode(s: Text) -> text_type: ...
mypy-0.470/typeshed/third_party/2and3/markupsafe/_compat.pyi 0000644 0000000 0000000 00000001065 13035744274 022623 0 ustar root root # Stubs for markupsafe._compat (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
import sys
from typing import Any, Iterator, Mapping, Text, Tuple, TypeVar
_K = TypeVar('_K')
_V = TypeVar('_V')
PY2 = ... # type: bool
def iteritems(d: Mapping[_K, _V]) -> Iterator[Tuple[_K, _V]]: ...
if sys.version_info[0] >= 3:
text_type = str
string_types = str,
unichr = chr
int_types = int,
else:
text_type = unicode
string_types = (str, unicode)
unichr = __builtins__.unichr
int_types = (int, long)
mypy-0.470/typeshed/third_party/2and3/markupsafe/_native.pyi 0000644 0000000 0000000 00000000572 13035744274 022630 0 ustar root root # Stubs for markupsafe._native (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import Markup
from ._compat import text_type, string_types
from typing import Union, Text
def escape(s: Union[Markup, Text]) -> Markup: ...
def escape_silent(s: Union[None, Markup, Text]) -> Markup: ...
def soft_unicode(s: Text) -> text_type: ...
mypy-0.470/typeshed/third_party/2and3/pytz/ 0000755 0000000 0000000 00000000000 13044320557 017316 5 ustar root root mypy-0.470/typeshed/third_party/2and3/pytz/__init__.pyi 0000644 0000000 0000000 00000001645 13035744274 021614 0 ustar root root # Stubs for pytz (Python 3.5)
import datetime as dt
from typing import Optional, List, Set, Dict # NOQA
all_timezones = ... # type: List
all_timezones_set = ... # type: Set
common_timezones = ... # type: List
common_timezones_set = ... # type: Set
country_timezones = ... # type: Dict
country_names = ... # type: Dict
class _UTCclass(dt.tzinfo):
zone = ... # type: str
def fromutc(self, dt: dt.datetime) -> dt.datetime: ...
def utcoffset(self, dt: Optional[dt.datetime]) -> dt.timedelta: ... # type: ignore
def tzname(self, dt: Optional[dt.datetime]) -> str: ...
def dst(self, dt: Optional[dt.datetime]) -> dt.timedelta: ... # type: ignore
def localize(self, dt: dt.datetime, is_dst: bool=...) -> dt.datetime: ...
def normalize(self, dt: dt.datetime, is_dst: bool=...) -> dt.datetime: ...
utc = ... # type: _UTCclass
UTC = ... # type: _UTCclass
def timezone(zone: str) -> dt.tzinfo: ...
mypy-0.470/typeshed/third_party/2and3/pytz/lazy.pyi 0000644 0000000 0000000 00000000337 13023631176 021022 0 ustar root root # Stubs for pytz.lazy (Python 3.5)
from typing import Any, Iterable, List, Set, Dict # NOQA
from collections import Mapping
class LazyDict(Mapping):
pass
class LazyList(List):
pass
class LazySet(Set):
pass
mypy-0.470/typeshed/third_party/2and3/backports/ 0000755 0000000 0000000 00000000000 13044320557 020300 5 ustar root root mypy-0.470/typeshed/third_party/2and3/backports/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 022547 0 ustar root root mypy-0.470/typeshed/third_party/2and3/backports/ssl_match_hostname.pyi 0000644 0000000 0000000 00000000121 13023631176 024667 0 ustar root root class CertificateError(ValueError): ...
def match_hostname(cert, hostname): ...
mypy-0.470/typeshed/third_party/3/ 0000755 0000000 0000000 00000000000 13044320557 015543 5 ustar root root mypy-0.470/typeshed/third_party/3/werkzeug/ 0000755 0000000 0000000 00000000000 13044320557 017406 5 ustar root root mypy-0.470/typeshed/third_party/3/werkzeug/routing.pyi 0000644 0000000 0000000 00000014574 13035744274 021641 0 ustar root root # Stubs for werkzeug.routing (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.exceptions import HTTPException
def parse_converter_args(argstr): ...
def parse_rule(rule): ...
class RoutingException(Exception): ...
class RequestRedirect(HTTPException, RoutingException):
code = ... # type: Any
new_url = ... # type: Any
def __init__(self, new_url): ...
def get_response(self, environ): ...
class RequestSlash(RoutingException): ...
class RequestAliasRedirect(RoutingException):
matched_values = ... # type: Any
def __init__(self, matched_values): ...
class BuildError(RoutingException, LookupError):
endpoint = ... # type: Any
values = ... # type: Any
method = ... # type: Any
adapter = ... # type: Any
def __init__(self, endpoint, values, method, adapter=None): ...
def suggested(self): ...
def closest_rule(self, adapter): ...
class ValidationError(ValueError): ...
class RuleFactory:
def get_rules(self, map): ...
class Subdomain(RuleFactory):
subdomain = ... # type: Any
rules = ... # type: Any
def __init__(self, subdomain, rules): ...
def get_rules(self, map): ...
class Submount(RuleFactory):
path = ... # type: Any
rules = ... # type: Any
def __init__(self, path, rules): ...
def get_rules(self, map): ...
class EndpointPrefix(RuleFactory):
prefix = ... # type: Any
rules = ... # type: Any
def __init__(self, prefix, rules): ...
def get_rules(self, map): ...
class RuleTemplate:
rules = ... # type: Any
def __init__(self, rules): ...
def __call__(self, *args, **kwargs): ...
class RuleTemplateFactory(RuleFactory):
rules = ... # type: Any
context = ... # type: Any
def __init__(self, rules, context): ...
def get_rules(self, map): ...
class Rule(RuleFactory):
rule = ... # type: Any
is_leaf = ... # type: Any
map = ... # type: Any
strict_slashes = ... # type: Any
subdomain = ... # type: Any
host = ... # type: Any
defaults = ... # type: Any
build_only = ... # type: Any
alias = ... # type: Any
methods = ... # type: Any
endpoint = ... # type: Any
redirect_to = ... # type: Any
arguments = ... # type: Any
def __init__(self, string, defaults=None, subdomain=None, methods=None, build_only=False, endpoint=None, strict_slashes=None, redirect_to=None, alias=False, host=None): ...
def empty(self): ...
def get_empty_kwargs(self): ...
def get_rules(self, map): ...
def refresh(self): ...
def bind(self, map, rebind=False): ...
def get_converter(self, variable_name, converter_name, args, kwargs): ...
def compile(self): ...
def match(self, path, method=None): ...
def build(self, values, append_unknown=True): ...
def provides_defaults_for(self, rule): ...
def suitable_for(self, values, method=None): ...
def match_compare_key(self): ...
def build_compare_key(self): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
class BaseConverter:
regex = ... # type: Any
weight = ... # type: Any
map = ... # type: Any
def __init__(self, map): ...
def to_python(self, value): ...
def to_url(self, value): ...
class UnicodeConverter(BaseConverter):
regex = ... # type: Any
def __init__(self, map, minlength=1, maxlength=None, length=None): ...
class AnyConverter(BaseConverter):
regex = ... # type: Any
def __init__(self, map, *items): ...
class PathConverter(BaseConverter):
regex = ... # type: Any
weight = ... # type: Any
class NumberConverter(BaseConverter):
weight = ... # type: Any
fixed_digits = ... # type: Any
min = ... # type: Any
max = ... # type: Any
def __init__(self, map, fixed_digits=0, min=None, max=None): ...
def to_python(self, value): ...
def to_url(self, value): ...
class IntegerConverter(NumberConverter):
regex = ... # type: Any
num_convert = ... # type: Any
class FloatConverter(NumberConverter):
regex = ... # type: Any
num_convert = ... # type: Any
def __init__(self, map, min=None, max=None): ...
class UUIDConverter(BaseConverter):
regex = ... # type: Any
def to_python(self, value): ...
def to_url(self, value): ...
DEFAULT_CONVERTERS = ... # type: Any
class Map:
default_converters = ... # type: Any
default_subdomain = ... # type: Any
charset = ... # type: Any
encoding_errors = ... # type: Any
strict_slashes = ... # type: Any
redirect_defaults = ... # type: Any
host_matching = ... # type: Any
converters = ... # type: Any
sort_parameters = ... # type: Any
sort_key = ... # type: Any
def __init__(self, rules=None, default_subdomain='', charset='', strict_slashes=True, redirect_defaults=True, converters=None, sort_parameters=False, sort_key=None, encoding_errors='', host_matching=False): ...
def is_endpoint_expecting(self, endpoint, *arguments): ...
def iter_rules(self, endpoint=None): ...
def add(self, rulefactory): ...
def bind(self, server_name, script_name=None, subdomain=None, url_scheme='', default_method='', path_info=None, query_args=None): ...
def bind_to_environ(self, environ, server_name=None, subdomain=None): ...
def update(self): ...
class MapAdapter:
map = ... # type: Any
server_name = ... # type: Any
script_name = ... # type: Any
subdomain = ... # type: Any
url_scheme = ... # type: Any
path_info = ... # type: Any
default_method = ... # type: Any
query_args = ... # type: Any
def __init__(self, map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args=None): ...
def dispatch(self, view_func, path_info=None, method=None, catch_http_exceptions=False): ...
def match(self, path_info=None, method=None, return_rule=False, query_args=None): ...
def test(self, path_info=None, method=None): ...
def allowed_methods(self, path_info=None): ...
def get_host(self, domain_part): ...
def get_default_redirect(self, rule, method, values, query_args): ...
def encode_query_args(self, query_args): ...
def make_redirect_url(self, path_info, query_args=None, domain_part=None): ...
def make_alias_redirect_url(self, path, endpoint, values, method, query_args): ...
def build(self, endpoint, values=None, method=None, force_external=False, append_unknown=True): ...
mypy-0.470/typeshed/third_party/3/werkzeug/__init__.pyi 0000644 0000000 0000000 00000013042 13035744274 021676 0 ustar root root # Stubs for werkzeug (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from types import ModuleType
from typing import Any
from werkzeug import _internal
from werkzeug import datastructures
from werkzeug import debug
from werkzeug import exceptions
from werkzeug import formparser
from werkzeug import http
from werkzeug import local
from werkzeug import security
from werkzeug import serving
from werkzeug import test
from werkzeug import testapp
from werkzeug import urls
from werkzeug import useragents
from werkzeug import utils
from werkzeug import wrappers
from werkzeug import wsgi
class module(ModuleType):
def __getattr__(self, name): ...
def __dir__(self): ...
__version__ = ... # type: Any
run_simple = serving.run_simple
test_app = testapp.test_app
UserAgent = useragents.UserAgent
_easteregg = _internal._easteregg
DebuggedApplication = debug.DebuggedApplication
MultiDict = datastructures.MultiDict
CombinedMultiDict = datastructures.CombinedMultiDict
Headers = datastructures.Headers
EnvironHeaders = datastructures.EnvironHeaders
ImmutableList = datastructures.ImmutableList
ImmutableDict = datastructures.ImmutableDict
ImmutableMultiDict = datastructures.ImmutableMultiDict
TypeConversionDict = datastructures.TypeConversionDict
ImmutableTypeConversionDict = datastructures.ImmutableTypeConversionDict
Accept = datastructures.Accept
MIMEAccept = datastructures.MIMEAccept
CharsetAccept = datastructures.CharsetAccept
LanguageAccept = datastructures.LanguageAccept
RequestCacheControl = datastructures.RequestCacheControl
ResponseCacheControl = datastructures.ResponseCacheControl
ETags = datastructures.ETags
HeaderSet = datastructures.HeaderSet
WWWAuthenticate = datastructures.WWWAuthenticate
Authorization = datastructures.Authorization
FileMultiDict = datastructures.FileMultiDict
CallbackDict = datastructures.CallbackDict
FileStorage = datastructures.FileStorage
OrderedMultiDict = datastructures.OrderedMultiDict
ImmutableOrderedMultiDict = datastructures.ImmutableOrderedMultiDict
escape = utils.escape
environ_property = utils.environ_property
append_slash_redirect = utils.append_slash_redirect
redirect = utils.redirect
cached_property = utils.cached_property
import_string = utils.import_string
dump_cookie = http.dump_cookie
parse_cookie = http.parse_cookie
unescape = utils.unescape
format_string = utils.format_string
find_modules = utils.find_modules
header_property = utils.header_property
html = utils.html
xhtml = utils.xhtml
HTMLBuilder = utils.HTMLBuilder
validate_arguments = utils.validate_arguments
ArgumentValidationError = utils.ArgumentValidationError
bind_arguments = utils.bind_arguments
secure_filename = utils.secure_filename
BaseResponse = wrappers.BaseResponse
BaseRequest = wrappers.BaseRequest
Request = wrappers.Request
Response = wrappers.Response
AcceptMixin = wrappers.AcceptMixin
ETagRequestMixin = wrappers.ETagRequestMixin
ETagResponseMixin = wrappers.ETagResponseMixin
ResponseStreamMixin = wrappers.ResponseStreamMixin
CommonResponseDescriptorsMixin = wrappers.CommonResponseDescriptorsMixin
UserAgentMixin = wrappers.UserAgentMixin
AuthorizationMixin = wrappers.AuthorizationMixin
WWWAuthenticateMixin = wrappers.WWWAuthenticateMixin
CommonRequestDescriptorsMixin = wrappers.CommonRequestDescriptorsMixin
Local = local.Local
LocalManager = local.LocalManager
LocalProxy = local.LocalProxy
LocalStack = local.LocalStack
release_local = local.release_local
generate_password_hash = security.generate_password_hash
check_password_hash = security.check_password_hash
Client = test.Client
EnvironBuilder = test.EnvironBuilder
create_environ = test.create_environ
run_wsgi_app = test.run_wsgi_app
get_current_url = wsgi.get_current_url
get_host = wsgi.get_host
pop_path_info = wsgi.pop_path_info
peek_path_info = wsgi.peek_path_info
SharedDataMiddleware = wsgi.SharedDataMiddleware
DispatcherMiddleware = wsgi.DispatcherMiddleware
ClosingIterator = wsgi.ClosingIterator
FileWrapper = wsgi.FileWrapper
make_line_iter = wsgi.make_line_iter
LimitedStream = wsgi.LimitedStream
responder = wsgi.responder
wrap_file = wsgi.wrap_file
extract_path_info = wsgi.extract_path_info
parse_etags = http.parse_etags
parse_date = http.parse_date
http_date = http.http_date
cookie_date = http.cookie_date
parse_cache_control_header = http.parse_cache_control_header
is_resource_modified = http.is_resource_modified
parse_accept_header = http.parse_accept_header
parse_set_header = http.parse_set_header
quote_etag = http.quote_etag
unquote_etag = http.unquote_etag
generate_etag = http.generate_etag
dump_header = http.dump_header
parse_list_header = http.parse_list_header
parse_dict_header = http.parse_dict_header
parse_authorization_header = http.parse_authorization_header
parse_www_authenticate_header = http.parse_www_authenticate_header
remove_entity_headers = http.remove_entity_headers
is_entity_header = http.is_entity_header
remove_hop_by_hop_headers = http.remove_hop_by_hop_headers
parse_options_header = http.parse_options_header
dump_options_header = http.dump_options_header
is_hop_by_hop_header = http.is_hop_by_hop_header
unquote_header_value = http.unquote_header_value
quote_header_value = http.quote_header_value
HTTP_STATUS_CODES = http.HTTP_STATUS_CODES
url_decode = urls.url_decode
url_encode = urls.url_encode
url_quote = urls.url_quote
url_quote_plus = urls.url_quote_plus
url_unquote = urls.url_unquote
url_unquote_plus = urls.url_unquote_plus
url_fix = urls.url_fix
Href = urls.Href
iri_to_uri = urls.iri_to_uri
uri_to_iri = urls.uri_to_iri
parse_form_data = formparser.parse_form_data
abort = exceptions.Aborter
Aborter = exceptions.Aborter
mypy-0.470/typeshed/third_party/3/werkzeug/script.pyi 0000644 0000000 0000000 00000001244 13035744274 021444 0 ustar root root # Stubs for werkzeug.script (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
argument_types = ... # type: Any
converters = ... # type: Any
def run(namespace=None, action_prefix='', args=None): ...
def fail(message, code=-1): ...
def find_actions(namespace, action_prefix): ...
def print_usage(actions): ...
def analyse_action(func): ...
def make_shell(init_func=None, banner=None, use_ipython=True): ...
def make_runserver(app_factory, hostname='', port=5000, use_reloader=False, use_debugger=False, use_evalex=True, threaded=False, processes=1, static_files=None, extra_files=None, ssl_context=None): ...
mypy-0.470/typeshed/third_party/3/werkzeug/posixemulation.pyi 0000644 0000000 0000000 00000000524 13035744274 023220 0 ustar root root # Stubs for werkzeug.posixemulation (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from ._compat import to_unicode as to_unicode
from .filesystem import get_filesystem_encoding as get_filesystem_encoding
can_rename_open_file = ... # type: Any
def rename(src, dst): ...
mypy-0.470/typeshed/third_party/3/werkzeug/urls.pyi 0000644 0000000 0000000 00000004616 13035744274 021133 0 ustar root root # Stubs for werkzeug.urls (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from collections import namedtuple
from typing import Any
_URLTuple = namedtuple(
'_URLTuple',
['scheme', 'netloc', 'path', 'query', 'fragment']
)
class BaseURL(_URLTuple):
def replace(self, **kwargs): ...
@property
def host(self): ...
@property
def ascii_host(self): ...
@property
def port(self): ...
@property
def auth(self): ...
@property
def username(self): ...
@property
def raw_username(self): ...
@property
def password(self): ...
@property
def raw_password(self): ...
def decode_query(self, *args, **kwargs): ...
def join(self, *args, **kwargs): ...
def to_url(self): ...
def decode_netloc(self): ...
def to_uri_tuple(self): ...
def to_iri_tuple(self): ...
def get_file_location(self, pathformat=None): ...
class URL(BaseURL):
def encode_netloc(self): ...
def encode(self, charset='', errors=''): ...
class BytesURL(BaseURL):
def encode_netloc(self): ...
def decode(self, charset='', errors=''): ...
def url_parse(url, scheme=None, allow_fragments=True): ...
def url_quote(string, charset='', errors='', safe='', unsafe=''): ...
def url_quote_plus(string, charset='', errors='', safe=''): ...
def url_unparse(components): ...
def url_unquote(string, charset='', errors='', unsafe=''): ...
def url_unquote_plus(s, charset='', errors=''): ...
def url_fix(s, charset=''): ...
def uri_to_iri(uri, charset='', errors=''): ...
def iri_to_uri(iri, charset='', errors='', safe_conversion=False): ...
def url_decode(s, charset='', decode_keys=False, include_empty=True, errors='', separator='', cls=None): ...
def url_decode_stream(stream, charset='', decode_keys=False, include_empty=True, errors='', separator='', cls=None, limit=None, return_iterator=False): ...
def url_encode(obj, charset='', encode_keys=False, sort=False, key=None, separator=b''): ...
def url_encode_stream(obj, stream=None, charset='', encode_keys=False, sort=False, key=None, separator=b''): ...
def url_join(base, url, allow_fragments=True): ...
class Href:
base = ... # type: Any
charset = ... # type: Any
sort = ... # type: Any
key = ... # type: Any
def __init__(self, base='', charset='', sort=False, key=None): ...
def __getattr__(self, name): ...
def __call__(self, *path, **query): ...
mypy-0.470/typeshed/third_party/3/werkzeug/formparser.pyi 0000644 0000000 0000000 00000003726 13035744274 022327 0 ustar root root # Stubs for werkzeug.formparser (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def default_stream_factory(total_content_length, filename, content_type, content_length=None): ...
def parse_form_data(environ, stream_factory=None, charset='', errors='', max_form_memory_size=None, max_content_length=None, cls=None, silent=True): ...
def exhaust_stream(f): ...
class FormDataParser:
stream_factory = ... # type: Any
charset = ... # type: Any
errors = ... # type: Any
max_form_memory_size = ... # type: Any
max_content_length = ... # type: Any
cls = ... # type: Any
silent = ... # type: Any
def __init__(self, stream_factory=None, charset='', errors='', max_form_memory_size=None, max_content_length=None, cls=None, silent=True): ...
def get_parse_func(self, mimetype, options): ...
def parse_from_environ(self, environ): ...
def parse(self, stream, mimetype, content_length, options=None): ...
parse_functions = ... # type: Any
def is_valid_multipart_boundary(boundary): ...
def parse_multipart_headers(iterable): ...
class MultiPartParser:
charset = ... # type: Any
errors = ... # type: Any
max_form_memory_size = ... # type: Any
stream_factory = ... # type: Any
cls = ... # type: Any
buffer_size = ... # type: Any
def __init__(self, stream_factory=None, charset='', errors='', max_form_memory_size=None, cls=None, buffer_size=...): ...
def fail(self, message): ...
def get_part_encoding(self, headers): ...
def get_part_charset(self, headers): ...
def start_file_streaming(self, filename, headers, total_content_length): ...
def in_memory_threshold_reached(self, bytes): ...
def validate_boundary(self, boundary): ...
def parse_lines(self, file, boundary, content_length, cap_at_buffer=True): ...
def parse_parts(self, file, boundary, content_length): ...
def parse(self, file, boundary, content_length): ...
mypy-0.470/typeshed/third_party/3/werkzeug/wsgi.pyi 0000644 0000000 0000000 00000006147 13035744274 021120 0 ustar root root # Stubs for werkzeug.wsgi (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def responder(f): ...
def get_current_url(environ, root_only=False, strip_querystring=False, host_only=False, trusted_hosts=None): ...
def host_is_trusted(hostname, trusted_list): ...
def get_host(environ, trusted_hosts=None): ...
def get_content_length(environ): ...
def get_input_stream(environ, safe_fallback=True): ...
def get_query_string(environ): ...
def get_path_info(environ, charset='', errors=''): ...
def get_script_name(environ, charset='', errors=''): ...
def pop_path_info(environ, charset='', errors=''): ...
def peek_path_info(environ, charset='', errors=''): ...
def extract_path_info(environ_or_baseurl, path_or_url, charset='', errors='', collapse_http_schemes=True): ...
class SharedDataMiddleware:
app = ... # type: Any
exports = ... # type: Any
cache = ... # type: Any
cache_timeout = ... # type: Any
fallback_mimetype = ... # type: Any
def __init__(self, app, exports, disallow=None, cache=True, cache_timeout=..., fallback_mimetype=''): ...
def is_allowed(self, filename): ...
def get_file_loader(self, filename): ...
def get_package_loader(self, package, package_path): ...
def get_directory_loader(self, directory): ...
def generate_etag(self, mtime, file_size, real_filename): ...
def __call__(self, environ, start_response): ...
class DispatcherMiddleware:
app = ... # type: Any
mounts = ... # type: Any
def __init__(self, app, mounts=None): ...
def __call__(self, environ, start_response): ...
class ClosingIterator:
def __init__(self, iterable, callbacks=None): ...
def __iter__(self): ...
def __next__(self): ...
def close(self): ...
def wrap_file(environ, file, buffer_size=8192): ...
class FileWrapper:
file = ... # type: Any
buffer_size = ... # type: Any
def __init__(self, file, buffer_size=8192): ...
def close(self): ...
def seekable(self): ...
def seek(self, *args): ...
def tell(self): ...
def __iter__(self): ...
def __next__(self): ...
class _RangeWrapper:
iterable = ... # type: Any
byte_range = ... # type: Any
start_byte = ... # type: Any
end_byte = ... # type: Any
read_length = ... # type: Any
seekable = ... # type: Any
end_reached = ... # type: Any
def __init__(self, iterable, start_byte=0, byte_range=None): ...
def __iter__(self): ...
def __next__(self): ...
def close(self): ...
def make_line_iter(stream, limit=None, buffer_size=..., cap_at_buffer=False): ...
def make_chunk_iter(stream, separator, limit=None, buffer_size=..., cap_at_buffer=False): ...
class LimitedStream:
limit = ... # type: Any
def __init__(self, stream, limit): ...
def __iter__(self): ...
@property
def is_exhausted(self): ...
def on_exhausted(self): ...
def on_disconnect(self): ...
def exhaust(self, chunk_size=...): ...
def read(self, size=None): ...
def readline(self, size=None): ...
def readlines(self, size=None): ...
def tell(self): ...
def __next__(self): ...
mypy-0.470/typeshed/third_party/3/werkzeug/security.pyi 0000644 0000000 0000000 00000001107 13035744274 022005 0 ustar root root # Stubs for werkzeug.security (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
SALT_CHARS = ... # type: Any
DEFAULT_PBKDF2_ITERATIONS = ... # type: Any
def pbkdf2_hex(data, salt, iterations=..., keylen=None, hashfunc=None): ...
def pbkdf2_bin(data, salt, iterations=..., keylen=None, hashfunc=None): ...
def safe_str_cmp(a, b): ...
def gen_salt(length): ...
def generate_password_hash(password, method='', salt_length=8): ...
def check_password_hash(pwhash, password): ...
def safe_join(directory, filename): ...
mypy-0.470/typeshed/third_party/3/werkzeug/debug/ 0000755 0000000 0000000 00000000000 13044320557 020474 5 ustar root root mypy-0.470/typeshed/third_party/3/werkzeug/debug/__init__.pyi 0000644 0000000 0000000 00000002767 13035744274 023000 0 ustar root root # Stubs for werkzeug.debug (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
PIN_TIME = ... # type: Any
def hash_pin(pin): ...
def get_machine_id(): ...
class _ConsoleFrame:
console = ... # type: Any
id = ... # type: Any
def __init__(self, namespace): ...
def get_pin_and_cookie_name(app): ...
class DebuggedApplication:
app = ... # type: Any
evalex = ... # type: Any
frames = ... # type: Any
tracebacks = ... # type: Any
request_key = ... # type: Any
console_path = ... # type: Any
console_init_func = ... # type: Any
show_hidden_frames = ... # type: Any
secret = ... # type: Any
pin_logging = ... # type: Any
pin = ... # type: Any
def __init__(self, app, evalex=False, request_key='', console_path='', console_init_func=None, show_hidden_frames=False, lodgeit_url=None, pin_security=True, pin_logging=True): ...
@property
def pin_cookie_name(self): ...
def debug_application(self, environ, start_response): ...
def execute_command(self, request, command, frame): ...
def display_console(self, request): ...
def paste_traceback(self, request, traceback): ...
def get_resource(self, request, filename): ...
def check_pin_trust(self, environ): ...
def pin_auth(self, request): ...
def log_pin_request(self): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/3/werkzeug/debug/console.pyi 0000644 0000000 0000000 00000002435 13035744274 022673 0 ustar root root # Stubs for werkzeug.debug.console (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import code
class HTMLStringO:
def __init__(self): ...
def isatty(self): ...
def close(self): ...
def flush(self): ...
def seek(self, n, mode=0): ...
def readline(self): ...
def reset(self): ...
def write(self, x): ...
def writelines(self, x): ...
class ThreadedStream:
@staticmethod
def push(): ...
@staticmethod
def fetch(): ...
@staticmethod
def displayhook(obj): ...
def __setattr__(self, name, value): ...
def __dir__(self): ...
def __getattribute__(self, name): ...
class _ConsoleLoader:
def __init__(self): ...
def register(self, code, source): ...
def get_source_by_code(self, code): ...
class _InteractiveConsole(code.InteractiveInterpreter):
globals = ... # type: Any
more = ... # type: Any
buffer = ... # type: Any
def __init__(self, globals, locals): ...
def runsource(self, source): ...
def runcode(self, code): ...
def showtraceback(self): ...
def showsyntaxerror(self, filename=None): ...
def write(self, data): ...
class Console:
def __init__(self, globals=None, locals=None): ...
def eval(self, code): ...
mypy-0.470/typeshed/third_party/3/werkzeug/debug/tbtools.pyi 0000644 0000000 0000000 00000004101 13035744274 022707 0 ustar root root # Stubs for werkzeug.debug.tbtools (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
UTF8_COOKIE = ... # type: Any
system_exceptions = ... # type: Any
HEADER = ... # type: Any
FOOTER = ... # type: Any
PAGE_HTML = ... # type: Any
CONSOLE_HTML = ... # type: Any
SUMMARY_HTML = ... # type: Any
FRAME_HTML = ... # type: Any
SOURCE_LINE_HTML = ... # type: Any
def render_console_html(secret, evalex_trusted=True): ...
def get_current_traceback(ignore_system_exceptions=False, show_hidden_frames=False, skip=0): ...
class Line:
lineno = ... # type: Any
code = ... # type: Any
in_frame = ... # type: Any
current = ... # type: Any
def __init__(self, lineno, code): ...
def classes(self): ...
def render(self): ...
class Traceback:
exc_type = ... # type: Any
exc_value = ... # type: Any
exception_type = ... # type: Any
frames = ... # type: Any
def __init__(self, exc_type, exc_value, tb): ...
def filter_hidden_frames(self): ...
def is_syntax_error(self): ...
def exception(self): ...
def log(self, logfile=None): ...
def paste(self): ...
def render_summary(self, include_title=True): ...
def render_full(self, evalex=False, secret=None, evalex_trusted=True): ...
def generate_plaintext_traceback(self): ...
def plaintext(self): ...
id = ... # type: Any
class Frame:
lineno = ... # type: Any
function_name = ... # type: Any
locals = ... # type: Any
globals = ... # type: Any
filename = ... # type: Any
module = ... # type: Any
loader = ... # type: Any
code = ... # type: Any
hide = ... # type: Any
info = ... # type: Any
def __init__(self, exc_type, exc_value, tb): ...
def render(self): ...
def render_line_context(self): ...
def get_annotated_lines(self): ...
def eval(self, code, mode=''): ...
def sourcelines(self): ...
def get_context_lines(self, context=5): ...
@property
def current_line(self): ...
def console(self): ...
id = ... # type: Any
mypy-0.470/typeshed/third_party/3/werkzeug/debug/repr.pyi 0000644 0000000 0000000 00000002051 13035744274 022173 0 ustar root root # Stubs for werkzeug.debug.repr (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
deque = ... # type: Any
missing = ... # type: Any
RegexType = ... # type: Any
HELP_HTML = ... # type: Any
OBJECT_DUMP_HTML = ... # type: Any
def debug_repr(obj): ...
def dump(obj=...): ...
class _Helper:
def __call__(self, topic=None): ...
helper = ... # type: Any
class DebugReprGenerator:
def __init__(self): ...
list_repr = ... # type: Any
tuple_repr = ... # type: Any
set_repr = ... # type: Any
frozenset_repr = ... # type: Any
deque_repr = ... # type: Any
def regex_repr(self, obj): ...
def string_repr(self, obj, limit=70): ...
def dict_repr(self, d, recursive, limit=5): ...
def object_repr(self, obj): ...
def dispatch_repr(self, obj, recursive): ...
def fallback_repr(self): ...
def repr(self, obj): ...
def dump_object(self, obj): ...
def dump_locals(self, d): ...
def render_object_dump(self, items, title, repr=None): ...
mypy-0.470/typeshed/third_party/3/werkzeug/testapp.pyi 0000644 0000000 0000000 00000000566 13035744274 021626 0 ustar root root # Stubs for werkzeug.testapp (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
logo = ... # type: Any
TEMPLATE = ... # type: Any
def iter_sys_path(): ...
def render_testapp(req): ...
def test_app(environ, start_response): ...
mypy-0.470/typeshed/third_party/3/werkzeug/_internal.pyi 0000644 0000000 0000000 00000001232 13035744274 022110 0 ustar root root # Stubs for werkzeug._internal (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class _Missing:
def __reduce__(self): ...
class _DictAccessorProperty:
read_only = ... # type: Any
name = ... # type: Any
default = ... # type: Any
load_func = ... # type: Any
dump_func = ... # type: Any
__doc__ = ... # type: Any
def __init__(self, name, default=None, load_func=None, dump_func=None, read_only=None, doc=None): ...
def __get__(self, obj, type=None): ...
def __set__(self, obj, value): ...
def __delete__(self, obj): ...
def _easteregg(app=None): ...
mypy-0.470/typeshed/third_party/3/werkzeug/local.pyi 0000644 0000000 0000000 00000006146 13035744274 021240 0 ustar root root # Stubs for werkzeug.local (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def release_local(local): ...
class Local:
def __init__(self): ...
def __iter__(self): ...
def __call__(self, proxy): ...
def __release_local__(self): ...
def __getattr__(self, name): ...
def __setattr__(self, name, value): ...
def __delattr__(self, name): ...
class LocalStack:
def __init__(self): ...
def __release_local__(self): ...
def _get__ident_func__(self): ...
def _set__ident_func__(self, value): ...
__ident_func__ = ... # type: Any
def __call__(self): ...
def push(self, obj): ...
def pop(self): ...
@property
def top(self): ...
class LocalManager:
locals = ... # type: Any
ident_func = ... # type: Any
def __init__(self, locals=None, ident_func=None): ...
def get_ident(self): ...
def cleanup(self): ...
def make_middleware(self, app): ...
def middleware(self, func): ...
class LocalProxy:
def __init__(self, local, name=None): ...
@property
def __dict__(self): ...
def __bool__(self): ...
def __unicode__(self): ...
def __dir__(self): ...
def __getattr__(self, name): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
__getslice__ = ... # type: Any
def __setslice__(self, i, j, seq): ...
def __delslice__(self, i, j): ...
__setattr__ = ... # type: Any
__delattr__ = ... # type: Any
__lt__ = ... # type: Any
__le__ = ... # type: Any
__eq__ = ... # type: Any
__ne__ = ... # type: Any
__gt__ = ... # type: Any
__ge__ = ... # type: Any
__cmp__ = ... # type: Any
__hash__ = ... # type: Any
__call__ = ... # type: Any
__len__ = ... # type: Any
__getitem__ = ... # type: Any
__iter__ = ... # type: Any
__contains__ = ... # type: Any
__add__ = ... # type: Any
__sub__ = ... # type: Any
__mul__ = ... # type: Any
__floordiv__ = ... # type: Any
__mod__ = ... # type: Any
__divmod__ = ... # type: Any
__pow__ = ... # type: Any
__lshift__ = ... # type: Any
__rshift__ = ... # type: Any
__and__ = ... # type: Any
__xor__ = ... # type: Any
__or__ = ... # type: Any
__div__ = ... # type: Any
__truediv__ = ... # type: Any
__neg__ = ... # type: Any
__pos__ = ... # type: Any
__abs__ = ... # type: Any
__invert__ = ... # type: Any
__complex__ = ... # type: Any
__int__ = ... # type: Any
__long__ = ... # type: Any
__float__ = ... # type: Any
__oct__ = ... # type: Any
__hex__ = ... # type: Any
__index__ = ... # type: Any
__coerce__ = ... # type: Any
__enter__ = ... # type: Any
__exit__ = ... # type: Any
__radd__ = ... # type: Any
__rsub__ = ... # type: Any
__rmul__ = ... # type: Any
__rdiv__ = ... # type: Any
__rtruediv__ = ... # type: Any
__rfloordiv__ = ... # type: Any
__rmod__ = ... # type: Any
__rdivmod__ = ... # type: Any
__copy__ = ... # type: Any
__deepcopy__ = ... # type: Any
mypy-0.470/typeshed/third_party/3/werkzeug/utils.pyi 0000644 0000000 0000000 00000003322 13035744274 021277 0 ustar root root # Stubs for werkzeug.utils (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug._internal import _DictAccessorProperty
class cached_property(property):
__name__ = ... # type: Any
__module__ = ... # type: Any
__doc__ = ... # type: Any
func = ... # type: Any
def __init__(self, func, name=None, doc=None): ...
def __set__(self, obj, value): ...
def __get__(self, obj, type=None): ...
class environ_property(_DictAccessorProperty):
read_only = ... # type: Any
def lookup(self, obj): ...
class header_property(_DictAccessorProperty):
def lookup(self, obj): ...
class HTMLBuilder:
def __init__(self, dialect): ...
def __call__(self, s): ...
def __getattr__(self, tag): ...
html = ... # type: Any
xhtml = ... # type: Any
def get_content_type(mimetype, charset): ...
def format_string(string, context): ...
def secure_filename(filename): ...
def escape(s, quote=None): ...
def unescape(s): ...
def redirect(location, code=302, Response=None): ...
def append_slash_redirect(environ, code=301): ...
def import_string(import_name, silent=False): ...
def find_modules(import_path, include_packages=False, recursive=False): ...
def validate_arguments(func, args, kwargs, drop_extra=True): ...
def bind_arguments(func, args, kwargs): ...
class ArgumentValidationError(ValueError):
missing = ... # type: Any
extra = ... # type: Any
extra_positional = ... # type: Any
def __init__(self, missing=None, extra=None, extra_positional=None): ...
class ImportStringError(ImportError):
import_name = ... # type: Any
exception = ... # type: Any
def __init__(self, import_name, exception): ...
mypy-0.470/typeshed/third_party/3/werkzeug/wrappers.pyi 0000644 0000000 0000000 00000014452 13035744274 022010 0 ustar root root # Stubs for werkzeug.wrappers (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class BaseRequest:
charset = ... # type: Any
encoding_errors = ... # type: Any
max_content_length = ... # type: Any
max_form_memory_size = ... # type: Any
parameter_storage_class = ... # type: Any
list_storage_class = ... # type: Any
dict_storage_class = ... # type: Any
form_data_parser_class = ... # type: Any
trusted_hosts = ... # type: Any
disable_data_descriptor = ... # type: Any
environ = ... # type: Any
shallow = ... # type: Any
def __init__(self, environ, populate_request=True, shallow=False): ...
@property
def url_charset(self): ...
@classmethod
def from_values(cls, *args, **kwargs): ...
@classmethod
def application(cls, f): ...
@property
def want_form_data_parsed(self): ...
def make_form_data_parser(self): ...
def close(self): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, tb): ...
def stream(self): ...
input_stream = ... # type: Any
def args(self): ...
def data(self): ...
def get_data(self, cache=True, as_text=False, parse_form_data=False): ...
def form(self): ...
def values(self): ...
def files(self): ...
def cookies(self): ...
def headers(self): ...
def path(self): ...
def full_path(self): ...
def script_root(self): ...
def url(self): ...
def base_url(self): ...
def url_root(self): ...
def host_url(self): ...
def host(self): ...
query_string = ... # type: Any
method = ... # type: Any
def access_route(self): ...
@property
def remote_addr(self): ...
remote_user = ... # type: Any
scheme = ... # type: Any
is_xhr = ... # type: Any
is_secure = ... # type: Any
is_multithread = ... # type: Any
is_multiprocess = ... # type: Any
is_run_once = ... # type: Any
class BaseResponse:
charset = ... # type: Any
default_status = ... # type: Any
default_mimetype = ... # type: Any
implicit_sequence_conversion = ... # type: Any
autocorrect_location_header = ... # type: Any
automatically_set_content_length = ... # type: Any
headers = ... # type: Any
status_code = ... # type: Any
status = ... # type: Any
direct_passthrough = ... # type: Any
response = ... # type: Any
def __init__(self, response=None, status=None, headers=None, mimetype=None, content_type=None, direct_passthrough=False): ...
def call_on_close(self, func): ...
@classmethod
def force_type(cls, response, environ=None): ...
@classmethod
def from_app(cls, app, environ, buffered=False): ...
def get_data(self, as_text=False): ...
def set_data(self, value): ...
data = ... # type: Any
def calculate_content_length(self): ...
def make_sequence(self): ...
def iter_encoded(self): ...
def set_cookie(self, key, value='', max_age=None, expires=None, path='', domain=None, secure=False, httponly=False): ...
def delete_cookie(self, key, path='', domain=None): ...
@property
def is_streamed(self): ...
@property
def is_sequence(self): ...
def close(self): ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, tb): ...
def freeze(self, **kwargs): ...
def get_wsgi_headers(self, environ): ...
def get_app_iter(self, environ): ...
def get_wsgi_response(self, environ): ...
def __call__(self, environ, start_response): ...
class AcceptMixin:
def accept_mimetypes(self): ...
def accept_charsets(self): ...
def accept_encodings(self): ...
def accept_languages(self): ...
class ETagRequestMixin:
def cache_control(self): ...
def if_match(self): ...
def if_none_match(self): ...
def if_modified_since(self): ...
def if_unmodified_since(self): ...
def if_range(self): ...
def range(self): ...
class UserAgentMixin:
def user_agent(self): ...
class AuthorizationMixin:
def authorization(self): ...
class StreamOnlyMixin:
disable_data_descriptor = ... # type: Any
want_form_data_parsed = ... # type: Any
class ETagResponseMixin:
@property
def cache_control(self): ...
status_code = ... # type: Any
def make_conditional(self, request_or_environ, accept_ranges=False, complete_length=None): ...
def add_etag(self, overwrite=False, weak=False): ...
def set_etag(self, etag, weak=False): ...
def get_etag(self): ...
def freeze(self, *, no_etag=False): ...
accept_ranges = ... # type: Any
content_range = ... # type: Any
class ResponseStream:
mode = ... # type: Any
response = ... # type: Any
closed = ... # type: Any
def __init__(self, response): ...
def write(self, value): ...
def writelines(self, seq): ...
def close(self): ...
def flush(self): ...
def isatty(self): ...
@property
def encoding(self): ...
class ResponseStreamMixin:
def stream(self): ...
class CommonRequestDescriptorsMixin:
content_type = ... # type: Any
def content_length(self): ...
content_encoding = ... # type: Any
content_md5 = ... # type: Any
referrer = ... # type: Any
date = ... # type: Any
max_forwards = ... # type: Any
@property
def mimetype(self): ...
@property
def mimetype_params(self): ...
def pragma(self): ...
class CommonResponseDescriptorsMixin:
mimetype = ... # type: Any
mimetype_params = ... # type: Any
location = ... # type: Any
age = ... # type: Any
content_type = ... # type: Any
content_length = ... # type: Any
content_location = ... # type: Any
content_encoding = ... # type: Any
content_md5 = ... # type: Any
date = ... # type: Any
expires = ... # type: Any
last_modified = ... # type: Any
retry_after = ... # type: Any
vary = ... # type: Any
content_language = ... # type: Any
allow = ... # type: Any
class WWWAuthenticateMixin:
@property
def www_authenticate(self): ...
class Request(BaseRequest, AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthorizationMixin, CommonRequestDescriptorsMixin): ...
class PlainRequest(StreamOnlyMixin, Request): ...
class Response(BaseResponse, ETagResponseMixin, ResponseStreamMixin, CommonResponseDescriptorsMixin, WWWAuthenticateMixin): ...
mypy-0.470/typeshed/third_party/3/werkzeug/http.pyi 0000644 0000000 0000000 00000003531 13035744274 021120 0 ustar root root # Stubs for werkzeug.http (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from urllib.request import parse_http_list as _parse_list_header
from urllib.parse import unquote_to_bytes as _unquote
HTTP_STATUS_CODES = ... # type: Any
def wsgi_to_bytes(data): ...
def bytes_to_wsgi(data): ...
def quote_header_value(value, extra_chars='', allow_token=True): ...
def unquote_header_value(value, is_filename=False): ...
def dump_options_header(header, options): ...
def dump_header(iterable, allow_token=True): ...
def parse_list_header(value): ...
def parse_dict_header(value, cls=...): ...
def parse_options_header(value, multiple=False): ...
def parse_accept_header(value, cls=None): ...
def parse_cache_control_header(value, on_update=None, cls=None): ...
def parse_set_header(value, on_update=None): ...
def parse_authorization_header(value): ...
def parse_www_authenticate_header(value, on_update=None): ...
def parse_if_range_header(value): ...
def parse_range_header(value, make_inclusive=True): ...
def parse_content_range_header(value, on_update=None): ...
def quote_etag(etag, weak=False): ...
def unquote_etag(etag): ...
def parse_etags(value): ...
def generate_etag(data): ...
def parse_date(value): ...
def cookie_date(expires=None): ...
def http_date(timestamp=None): ...
def is_resource_modified(environ, etag=None, data=None, last_modified=None, ignore_if_range=True): ...
def remove_entity_headers(headers, allowed=...): ...
def remove_hop_by_hop_headers(headers): ...
def is_entity_header(header): ...
def is_hop_by_hop_header(header): ...
def parse_cookie(header, charset='', errors='', cls=None): ...
def dump_cookie(key, value='', max_age=None, expires=None, path='', domain=None, secure=False, httponly=False, charset='', sync_expires=True): ...
def is_byte_range_valid(start, stop, length): ...
mypy-0.470/typeshed/third_party/3/werkzeug/test.pyi 0000644 0000000 0000000 00000006361 13035744274 021124 0 ustar root root # Stubs for werkzeug.test (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from urllib.request import Request as U2Request
from http.cookiejar import CookieJar
def stream_encode_multipart(values, use_tempfile=True, threshold=..., boundary=None, charset=''): ...
def encode_multipart(values, boundary=None, charset=''): ...
def File(fd, filename=None, mimetype=None): ...
class _TestCookieHeaders:
headers = ... # type: Any
def __init__(self, headers): ...
def getheaders(self, name): ...
def get_all(self, name, default=None): ...
class _TestCookieResponse:
headers = ... # type: Any
def __init__(self, headers): ...
def info(self): ...
class _TestCookieJar(CookieJar):
def inject_wsgi(self, environ): ...
def extract_wsgi(self, environ, headers): ...
class EnvironBuilder:
server_protocol = ... # type: Any
wsgi_version = ... # type: Any
request_class = ... # type: Any
charset = ... # type: Any
path = ... # type: Any
base_url = ... # type: Any
query_string = ... # type: Any
args = ... # type: Any
method = ... # type: Any
headers = ... # type: Any
content_type = ... # type: Any
errors_stream = ... # type: Any
multithread = ... # type: Any
multiprocess = ... # type: Any
run_once = ... # type: Any
environ_base = ... # type: Any
environ_overrides = ... # type: Any
input_stream = ... # type: Any
content_length = ... # type: Any
closed = ... # type: Any
def __init__(self, path='', base_url=None, query_string=None, method='', input_stream=None, content_type=None, content_length=None, errors_stream=None, multithread=False, multiprocess=False, run_once=False, headers=None, data=None, environ_base=None, environ_overrides=None, charset=''): ...
def form_property(name, storage, doc): ...
form = ... # type: Any
files = ... # type: Any
@property
def server_name(self): ...
@property
def server_port(self): ...
def __del__(self): ...
def close(self): ...
def get_environ(self): ...
def get_request(self, cls=None): ...
class ClientRedirectError(Exception): ...
class Client:
application = ... # type: Any
response_wrapper = ... # type: Any
cookie_jar = ... # type: Any
allow_subdomain_redirects = ... # type: Any
def __init__(self, application, response_wrapper=None, use_cookies=True, allow_subdomain_redirects=False): ...
def set_cookie(self, server_name, key, value='', max_age=None, expires=None, path='', domain=None, secure=None, httponly=False, charset=''): ...
def delete_cookie(self, server_name, key, path='', domain=None): ...
def run_wsgi_app(self, environ, buffered=False): ...
def resolve_redirect(self, response, new_location, environ, buffered=False): ...
def open(self, *args, **kwargs): ...
def get(self, *args, **kw): ...
def patch(self, *args, **kw): ...
def post(self, *args, **kw): ...
def head(self, *args, **kw): ...
def put(self, *args, **kw): ...
def delete(self, *args, **kw): ...
def options(self, *args, **kw): ...
def trace(self, *args, **kw): ...
def create_environ(*args, **kwargs): ...
def run_wsgi_app(app, environ, buffered=False): ...
mypy-0.470/typeshed/third_party/3/werkzeug/_compat.pyi 0000644 0000000 0000000 00000002450 13035744274 021562 0 ustar root root # Stubs for werkzeug._compat (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from io import StringIO as BytesIO
PY2 = ... # type: Any
WIN = ... # type: Any
unichr = ... # type: Any
text_type = ... # type: Any
string_types = ... # type: Any
integer_types = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
iteritems = ... # type: Any
iterlists = ... # type: Any
iterlistvalues = ... # type: Any
int_to_byte = ... # type: Any
iter_bytes = ... # type: Any
def fix_tuple_repr(obj): ...
def implements_iterator(cls): ...
def implements_to_string(cls): ...
def native_string_result(func): ...
def implements_bool(cls): ...
range_type = ... # type: Any
NativeStringIO = ... # type: Any
def make_literal_wrapper(reference): ...
def normalize_string_tuple(tup): ...
def try_coerce_native(s): ...
wsgi_get_bytes = ... # type: Any
def wsgi_decoding_dance(s, charset='', errors=''): ...
def wsgi_encoding_dance(s, charset='', errors=''): ...
def to_bytes(x, charset=..., errors=''): ...
def to_native(x, charset=..., errors=''): ...
def reraise(tp, value, tb=None): ...
imap = ... # type: Any
izip = ... # type: Any
ifilter = ... # type: Any
def to_unicode(x, charset=..., errors='', allow_none_charset=False): ...
mypy-0.470/typeshed/third_party/3/werkzeug/exceptions.pyi 0000644 0000000 0000000 00000010172 13035744274 022321 0 ustar root root # Stubs for werkzeug.exceptions (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class HTTPException(Exception):
code = ... # type: Any
description = ... # type: Any
response = ... # type: Any
def __init__(self, description=None, response=None): ...
@classmethod
def wrap(cls, exception, name=None): ...
@property
def name(self): ...
def get_description(self, environ=None): ...
def get_body(self, environ=None): ...
def get_headers(self, environ=None): ...
def get_response(self, environ=None): ...
def __call__(self, environ, start_response): ...
class BadRequest(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ClientDisconnected(BadRequest): ...
class SecurityError(BadRequest): ...
class BadHost(BadRequest): ...
class Unauthorized(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Forbidden(HTTPException):
code = ... # type: Any
description = ... # type: Any
class NotFound(HTTPException):
code = ... # type: Any
description = ... # type: Any
class MethodNotAllowed(HTTPException):
code = ... # type: Any
description = ... # type: Any
valid_methods = ... # type: Any
def __init__(self, valid_methods=None, description=None): ...
def get_headers(self, environ): ...
class NotAcceptable(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestTimeout(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Conflict(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Gone(HTTPException):
code = ... # type: Any
description = ... # type: Any
class LengthRequired(HTTPException):
code = ... # type: Any
description = ... # type: Any
class PreconditionFailed(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestEntityTooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestURITooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class UnsupportedMediaType(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestedRangeNotSatisfiable(HTTPException):
code = ... # type: Any
description = ... # type: Any
length = ... # type: Any
units = ... # type: Any
def __init__(self, length=None, units='', description=None): ...
def get_headers(self, environ): ...
class ExpectationFailed(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ImATeapot(HTTPException):
code = ... # type: Any
description = ... # type: Any
class UnprocessableEntity(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Locked(HTTPException):
code = ... # type: Any
description = ... # type: Any
class PreconditionRequired(HTTPException):
code = ... # type: Any
description = ... # type: Any
class TooManyRequests(HTTPException):
code = ... # type: Any
description = ... # type: Any
class RequestHeaderFieldsTooLarge(HTTPException):
code = ... # type: Any
description = ... # type: Any
class UnavailableForLegalReasons(HTTPException):
code = ... # type: Any
description = ... # type: Any
class InternalServerError(HTTPException):
code = ... # type: Any
description = ... # type: Any
class NotImplemented(HTTPException):
code = ... # type: Any
description = ... # type: Any
class BadGateway(HTTPException):
code = ... # type: Any
description = ... # type: Any
class ServiceUnavailable(HTTPException):
code = ... # type: Any
description = ... # type: Any
class GatewayTimeout(HTTPException):
code = ... # type: Any
description = ... # type: Any
class HTTPVersionNotSupported(HTTPException):
code = ... # type: Any
description = ... # type: Any
class Aborter:
mapping = ... # type: Any
def __init__(self, mapping=None, extra=None): ...
def __call__(self, code, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/3/werkzeug/serving.pyi 0000644 0000000 0000000 00000006352 13035744274 021622 0 ustar root root # Stubs for werkzeug.serving (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from socketserver import ThreadingMixIn, ForkingMixIn
from http.server import HTTPServer, BaseHTTPRequestHandler
class _SslDummy:
def __getattr__(self, name): ...
ssl = ... # type: Any
LISTEN_QUEUE = ... # type: Any
can_open_by_fd = ... # type: Any
class WSGIRequestHandler(BaseHTTPRequestHandler):
@property
def server_version(self): ...
def make_environ(self): ...
environ = ... # type: Any
close_connection = ... # type: Any
def run_wsgi(self): ...
def handle(self): ...
def initiate_shutdown(self): ...
def connection_dropped(self, error, environ=None): ...
raw_requestline = ... # type: Any
def handle_one_request(self): ...
def send_response(self, code, message=None): ...
def version_string(self): ...
def address_string(self): ...
def port_integer(self): ...
def log_request(self, code='', size=''): ...
def log_error(self, *args): ...
def log_message(self, format, *args): ...
def log(self, type, message, *args): ...
BaseRequestHandler = ... # type: Any
def generate_adhoc_ssl_pair(cn=None): ...
def make_ssl_devcert(base_path, host=None, cn=None): ...
def generate_adhoc_ssl_context(): ...
def load_ssl_context(cert_file, pkey_file=None, protocol=None): ...
class _SSLContext:
def __init__(self, protocol): ...
def load_cert_chain(self, certfile, keyfile=None, password=None): ...
def wrap_socket(self, sock, **kwargs): ...
def is_ssl_error(error=None): ...
def select_ip_version(host, port): ...
class BaseWSGIServer(HTTPServer):
multithread = ... # type: Any
multiprocess = ... # type: Any
request_queue_size = ... # type: Any
address_family = ... # type: Any
app = ... # type: Any
passthrough_errors = ... # type: Any
shutdown_signal = ... # type: Any
host = ... # type: Any
port = ... # type: Any
socket = ... # type: Any
server_address = ... # type: Any
ssl_context = ... # type: Any
def __init__(self, host, port, app, handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def log(self, type, message, *args): ...
def serve_forever(self): ...
def handle_error(self, request, client_address): ...
def get_request(self): ...
class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer):
multithread = ... # type: Any
daemon_threads = ... # type: Any
class ForkingWSGIServer(ForkingMixIn, BaseWSGIServer):
multiprocess = ... # type: Any
max_children = ... # type: Any
def __init__(self, host, port, app, processes=40, handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def make_server(host=None, port=None, app=None, threaded=False, processes=1, request_handler=None, passthrough_errors=False, ssl_context=None, fd=None): ...
def is_running_from_reloader(): ...
def run_simple(hostname, port, application, use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='', threaded=False, processes=1, request_handler=None, static_files=None, passthrough_errors=False, ssl_context=None): ...
def run_with_reloader(*args, **kwargs): ...
def main(): ...
mypy-0.470/typeshed/third_party/3/werkzeug/_reloader.pyi 0000644 0000000 0000000 00000001767 13035744274 022106 0 ustar root root # Stubs for werkzeug._reloader (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class ReloaderLoop:
name = ... # type: Any
extra_files = ... # type: Any
interval = ... # type: Any
def __init__(self, extra_files=None, interval=1): ...
def run(self): ...
def restart_with_reloader(self): ...
def trigger_reload(self, filename): ...
def log_reload(self, filename): ...
class StatReloaderLoop(ReloaderLoop):
name = ... # type: Any
def run(self): ...
class WatchdogReloaderLoop(ReloaderLoop):
observable_paths = ... # type: Any
name = ... # type: Any
observer_class = ... # type: Any
event_handler = ... # type: Any
should_reload = ... # type: Any
def __init__(self, *args, **kwargs): ...
def trigger_reload(self, filename): ...
def run(self): ...
reloader_loops = ... # type: Any
def run_with_reloader(main_func, extra_files=None, interval=1, reloader_type=''): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/ 0000755 0000000 0000000 00000000000 13044320557 021046 5 ustar root root mypy-0.470/typeshed/third_party/3/werkzeug/contrib/fixers.pyi 0000644 0000000 0000000 00000002506 13035744274 023102 0 ustar root root # Stubs for werkzeug.contrib.fixers (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class CGIRootFix:
app = ... # type: Any
app_root = ... # type: Any
def __init__(self, app, app_root=''): ...
def __call__(self, environ, start_response): ...
LighttpdCGIRootFix = ... # type: Any
class PathInfoFromRequestUriFix:
app = ... # type: Any
def __init__(self, app): ...
def __call__(self, environ, start_response): ...
class ProxyFix:
app = ... # type: Any
num_proxies = ... # type: Any
def __init__(self, app, num_proxies=1): ...
def get_remote_addr(self, forwarded_for): ...
def __call__(self, environ, start_response): ...
class HeaderRewriterFix:
app = ... # type: Any
remove_headers = ... # type: Any
add_headers = ... # type: Any
def __init__(self, app, remove_headers=None, add_headers=None): ...
def __call__(self, environ, start_response): ...
class InternetExplorerFix:
app = ... # type: Any
fix_vary = ... # type: Any
fix_attach = ... # type: Any
def __init__(self, app, fix_vary=True, fix_attach=True): ...
def fix_headers(self, environ, headers, status=None): ...
def run_fixed(self, environ, start_response): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/testtools.pyi 0000644 0000000 0000000 00000000526 13035744274 023642 0 ustar root root # Stubs for werkzeug.contrib.testtools (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.wrappers import Response
class ContentAccessors:
def xml(self): ...
def lxml(self): ...
def json(self): ...
class TestResponse(Response, ContentAccessors): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/__init__.pyi 0000644 0000000 0000000 00000000170 13035744274 023334 0 ustar root root # Stubs for werkzeug.contrib (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/profiler.pyi 0000644 0000000 0000000 00000001142 13035744274 023417 0 ustar root root # Stubs for werkzeug.contrib.profiler (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
available = ... # type: Any
class MergeStream:
streams = ... # type: Any
def __init__(self, *streams): ...
def write(self, data): ...
class ProfilerMiddleware:
def __init__(self, app, stream=None, sort_by=..., restrictions=..., profile_dir=None): ...
def __call__(self, environ, start_response): ...
def make_action(app_factory, hostname='', port=5000, threaded=False, processes=1, stream=None, sort_by=..., restrictions=...): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/lint.pyi 0000644 0000000 0000000 00000002433 13035744274 022547 0 ustar root root # Stubs for werkzeug.contrib.lint (Python 3)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class WSGIWarning(Warning): ...
class HTTPWarning(Warning): ...
def check_string(context, obj, stacklevel=3): ...
class InputStream:
def __init__(self, stream): ...
def read(self, *args): ...
def readline(self, *args): ...
def __iter__(self): ...
def close(self): ...
class ErrorStream:
def __init__(self, stream): ...
def write(self, s): ...
def flush(self): ...
def writelines(self, seq): ...
def close(self): ...
class GuardedWrite:
def __init__(self, write, chunks): ...
def __call__(self, s): ...
class GuardedIterator:
closed = ... # type: Any
headers_set = ... # type: Any
chunks = ... # type: Any
def __init__(self, iterator, headers_set, chunks): ...
def __iter__(self): ...
def next(self): ...
def close(self): ...
def __del__(self): ...
class LintMiddleware:
app = ... # type: Any
def __init__(self, app): ...
def check_environ(self, environ): ...
def check_start_response(self, status, headers, exc_info): ...
def check_headers(self, headers): ...
def check_iterator(self, app_iter): ...
def __call__(self, *args, **kwargs): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/atom.pyi 0000644 0000000 0000000 00000003142 13035744274 022537 0 ustar root root # Stubs for werkzeug.contrib.atom (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
XHTML_NAMESPACE = ... # type: Any
def format_iso8601(obj): ...
class AtomFeed:
default_generator = ... # type: Any
title = ... # type: Any
title_type = ... # type: Any
url = ... # type: Any
feed_url = ... # type: Any
id = ... # type: Any
updated = ... # type: Any
author = ... # type: Any
icon = ... # type: Any
logo = ... # type: Any
rights = ... # type: Any
rights_type = ... # type: Any
subtitle = ... # type: Any
subtitle_type = ... # type: Any
generator = ... # type: Any
links = ... # type: Any
entries = ... # type: Any
def __init__(self, title=None, entries=None, **kwargs): ...
def add(self, *args, **kwargs): ...
def generate(self): ...
def to_string(self): ...
def get_response(self): ...
def __call__(self, environ, start_response): ...
class FeedEntry:
title = ... # type: Any
title_type = ... # type: Any
content = ... # type: Any
content_type = ... # type: Any
url = ... # type: Any
id = ... # type: Any
updated = ... # type: Any
summary = ... # type: Any
summary_type = ... # type: Any
author = ... # type: Any
published = ... # type: Any
rights = ... # type: Any
links = ... # type: Any
categories = ... # type: Any
xml_base = ... # type: Any
def __init__(self, title=None, content=None, feed_url=None, **kwargs): ...
def generate(self): ...
def to_string(self): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/limiter.pyi 0000644 0000000 0000000 00000000535 13035744274 023247 0 ustar root root # Stubs for werkzeug.contrib.limiter (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class StreamLimitMiddleware:
app = ... # type: Any
maximum_size = ... # type: Any
def __init__(self, app, maximum_size=...): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/cache.pyi 0000644 0000000 0000000 00000005753 13035744274 022654 0 ustar root root # Stubs for werkzeug.contrib.cache (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class BaseCache:
default_timeout = ... # type: Any
def __init__(self, default_timeout=300): ...
def get(self, key): ...
def delete(self, key): ...
def get_many(self, *keys): ...
def get_dict(self, *keys): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def set_many(self, mapping, timeout=None): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
class NullCache(BaseCache): ...
class SimpleCache(BaseCache):
clear = ... # type: Any
def __init__(self, threshold=500, default_timeout=300): ...
def get(self, key): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def delete(self, key): ...
def has(self, key): ...
class MemcachedCache(BaseCache):
key_prefix = ... # type: Any
def __init__(self, servers=None, default_timeout=300, key_prefix=None): ...
def get(self, key): ...
def get_dict(self, *keys): ...
def add(self, key, value, timeout=None): ...
def set(self, key, value, timeout=None): ...
def get_many(self, *keys): ...
def set_many(self, mapping, timeout=None): ...
def delete(self, key): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
def import_preferred_memcache_lib(self, servers): ...
GAEMemcachedCache = ... # type: Any
class RedisCache(BaseCache):
key_prefix = ... # type: Any
def __init__(self, host='', port=6379, password=None, db=0, default_timeout=300, key_prefix=None, **kwargs): ...
def dump_object(self, value): ...
def load_object(self, value): ...
def get(self, key): ...
def get_many(self, *keys): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def set_many(self, mapping, timeout=None): ...
def delete(self, key): ...
def delete_many(self, *keys): ...
def has(self, key): ...
def clear(self): ...
def inc(self, key, delta=1): ...
def dec(self, key, delta=1): ...
class FileSystemCache(BaseCache):
def __init__(self, cache_dir, threshold=500, default_timeout=300, mode=384): ...
def clear(self): ...
def get(self, key): ...
def add(self, key, value, timeout=None): ...
def set(self, key, value, timeout=None): ...
def delete(self, key): ...
def has(self, key): ...
class UWSGICache(BaseCache):
cache = ... # type: Any
def __init__(self, default_timeout=300, cache=''): ...
def get(self, key): ...
def delete(self, key): ...
def set(self, key, value, timeout=None): ...
def add(self, key, value, timeout=None): ...
def clear(self): ...
def has(self, key): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/wrappers.pyi 0000644 0000000 0000000 00000001461 13035744274 023444 0 ustar root root # Stubs for werkzeug.contrib.wrappers (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def is_known_charset(charset): ...
class JSONRequestMixin:
def json(self): ...
class ProtobufRequestMixin:
protobuf_check_initialization = ... # type: Any
def parse_protobuf(self, proto_type): ...
class RoutingArgsRequestMixin:
routing_args = ... # type: Any
routing_vars = ... # type: Any
class ReverseSlashBehaviorRequestMixin:
def path(self): ...
def script_root(self): ...
class DynamicCharsetRequestMixin:
default_charset = ... # type: Any
def unknown_charset(self, charset): ...
def charset(self): ...
class DynamicCharsetResponseMixin:
default_charset = ... # type: Any
charset = ... # type: Any
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/sessions.pyi 0000644 0000000 0000000 00000003747 13035744274 023460 0 ustar root root # Stubs for werkzeug.contrib.sessions (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from werkzeug.datastructures import CallbackDict
def generate_key(salt=None): ...
class ModificationTrackingDict(CallbackDict):
modified = ... # type: Any
def __init__(self, *args, **kwargs): ...
def copy(self): ...
def __copy__(self): ...
class Session(ModificationTrackingDict):
sid = ... # type: Any
new = ... # type: Any
def __init__(self, data, sid, new=False): ...
@property
def should_save(self): ...
class SessionStore:
session_class = ... # type: Any
def __init__(self, session_class=None): ...
def is_valid_key(self, key): ...
def generate_key(self, salt=None): ...
def new(self): ...
def save(self, session): ...
def save_if_modified(self, session): ...
def delete(self, session): ...
def get(self, sid): ...
class FilesystemSessionStore(SessionStore):
path = ... # type: Any
filename_template = ... # type: Any
renew_missing = ... # type: Any
mode = ... # type: Any
def __init__(self, path=None, filename_template='', session_class=None, renew_missing=False, mode=420): ...
def get_session_filename(self, sid): ...
def save(self, session): ...
def delete(self, session): ...
def get(self, sid): ...
def list(self): ...
class SessionMiddleware:
app = ... # type: Any
store = ... # type: Any
cookie_name = ... # type: Any
cookie_age = ... # type: Any
cookie_expires = ... # type: Any
cookie_path = ... # type: Any
cookie_domain = ... # type: Any
cookie_secure = ... # type: Any
cookie_httponly = ... # type: Any
environ_key = ... # type: Any
def __init__(self, app, store, cookie_name='', cookie_age=None, cookie_expires=None, cookie_path='', cookie_domain=None, cookie_secure=None, cookie_httponly=False, environ_key=''): ...
def __call__(self, environ, start_response): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/iterio.pyi 0000644 0000000 0000000 00000002246 13035744274 023076 0 ustar root root # Stubs for werkzeug.contrib.iterio (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
greenlet = ... # type: Any
class IterIO:
def __new__(cls, obj, sentinel=''): ...
def __iter__(self): ...
def tell(self): ...
def isatty(self): ...
def seek(self, pos, mode=0): ...
def truncate(self, size=None): ...
def write(self, s): ...
def writelines(self, list): ...
def read(self, n=-1): ...
def readlines(self, sizehint=0): ...
def readline(self, length=None): ...
def flush(self): ...
def __next__(self): ...
class IterI(IterIO):
def __new__(cls, func, sentinel=''): ...
closed = ... # type: Any
def close(self): ...
def write(self, s): ...
def writelines(self, list): ...
def flush(self): ...
class IterO(IterIO):
sentinel = ... # type: Any
closed = ... # type: Any
pos = ... # type: Any
def __new__(cls, gen, sentinel=''): ...
def __iter__(self): ...
def close(self): ...
def seek(self, pos, mode=0): ...
def read(self, n=-1): ...
def readline(self, length=None): ...
def readlines(self, sizehint=0): ...
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/jsrouting.pyi 0000644 0000000 0000000 00000000676 13035744274 023634 0 ustar root root # Stubs for werkzeug.contrib.jsrouting (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
def dumps(*args): ...
def render_template(name_parts, rules, converters): ...
def generate_map(map, name=''): ...
def generate_adapter(adapter, name='', map_name=''): ...
def js_to_url_function(converter): ...
def NumberConverter_js_to_url(conv): ...
js_to_url_functions = ... # type: Any
mypy-0.470/typeshed/third_party/3/werkzeug/contrib/securecookie.pyi 0000644 0000000 0000000 00000002131 13035744274 024254 0 ustar root root # Stubs for werkzeug.contrib.securecookie (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from hmac import new as hmac
from hashlib import sha1 as _default_hash
from werkzeug.contrib.sessions import ModificationTrackingDict
class UnquoteError(Exception): ...
class SecureCookie(ModificationTrackingDict):
hash_method = ... # type: Any
serialization_method = ... # type: Any
quote_base64 = ... # type: Any
secret_key = ... # type: Any
new = ... # type: Any
def __init__(self, data=None, secret_key=None, new=True): ...
@property
def should_save(self): ...
@classmethod
def quote(cls, value): ...
@classmethod
def unquote(cls, value): ...
def serialize(self, expires=None): ...
@classmethod
def unserialize(cls, string, secret_key): ...
@classmethod
def load_cookie(cls, request, key='', secret_key=None): ...
def save_cookie(self, response, key='', expires=None, session_expires=None, max_age=None, path='', domain=None, secure=None, httponly=False, force=False): ...
mypy-0.470/typeshed/third_party/3/werkzeug/filesystem.pyi 0000644 0000000 0000000 00000000463 13035744274 022326 0 ustar root root # Stubs for werkzeug.filesystem (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
has_likely_buggy_unicode_filesystem = ... # type: Any
class BrokenFilesystemWarning(RuntimeWarning, UnicodeWarning): ...
def get_filesystem_encoding(): ...
mypy-0.470/typeshed/third_party/3/werkzeug/datastructures.pyi 0000644 0000000 0000000 00000030410 13035744274 023212 0 ustar root root # Stubs for werkzeug.datastructures (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from collections import Container, Iterable, Mapping, MutableSet
def is_immutable(self): ...
def iter_multi_items(mapping): ...
def native_itermethods(names): ...
class ImmutableListMixin:
def __hash__(self): ...
def __reduce_ex__(self, protocol): ...
def __delitem__(self, key): ...
def __delslice__(self, i, j): ...
def __iadd__(self, other): ...
__imul__ = ... # type: Any
def __setitem__(self, key, value): ...
def __setslice__(self, i, j, value): ...
def append(self, item): ...
remove = ... # type: Any
def extend(self, iterable): ...
def insert(self, pos, value): ...
def pop(self, index=-1): ...
def reverse(self): ...
def sort(self, cmp=None, key=None, reverse=None): ...
class ImmutableList(ImmutableListMixin, list): ...
class ImmutableDictMixin:
@classmethod
def fromkeys(cls, *args, **kwargs): ...
def __reduce_ex__(self, protocol): ...
def __hash__(self): ...
def setdefault(self, key, default=None): ...
def update(self, *args, **kwargs): ...
def pop(self, key, default=None): ...
def popitem(self): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def clear(self): ...
class ImmutableMultiDictMixin(ImmutableDictMixin):
def __reduce_ex__(self, protocol): ...
def add(self, key, value): ...
def popitemlist(self): ...
def poplist(self, key): ...
def setlist(self, key, new_list): ...
def setlistdefault(self, key, default_list=None): ...
class UpdateDictMixin:
on_update = ... # type: Any
def calls_update(name): ...
def setdefault(self, key, default=None): ...
def pop(self, key, default=...): ...
__setitem__ = ... # type: Any
__delitem__ = ... # type: Any
clear = ... # type: Any
popitem = ... # type: Any
update = ... # type: Any
class TypeConversionDict(dict):
def get(self, key, default=None, type=None): ...
class ImmutableTypeConversionDict(ImmutableDictMixin, TypeConversionDict):
def copy(self): ...
def __copy__(self): ...
class ViewItems:
def __init__(self, multi_dict, method, repr_name, *a, **kw): ...
def __iter__(self): ...
class MultiDict(TypeConversionDict):
def __init__(self, mapping=None): ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def add(self, key, value): ...
def getlist(self, key, type=None): ...
def setlist(self, key, new_list): ...
def setdefault(self, key, default=None): ...
def setlistdefault(self, key, default_list=None): ...
def items(self, multi=False): ...
def lists(self): ...
def keys(self): ...
__iter__ = ... # type: Any
def values(self): ...
def listvalues(self): ...
def copy(self): ...
def deepcopy(self, memo=None): ...
def to_dict(self, flat=True): ...
def update(self, other_dict): ...
def pop(self, key, default=...): ...
def popitem(self): ...
def poplist(self, key): ...
def popitemlist(self): ...
def __copy__(self): ...
def __deepcopy__(self, memo): ...
class _omd_bucket:
prev = ... # type: Any
key = ... # type: Any
value = ... # type: Any
next = ... # type: Any
def __init__(self, omd, key, value): ...
def unlink(self, omd): ...
class OrderedMultiDict(MultiDict):
def __init__(self, mapping=None): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def __reduce_ex__(self, protocol): ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def keys(self): ...
__iter__ = ... # type: Any
def values(self): ...
def items(self, multi=False): ...
def lists(self): ...
def listvalues(self): ...
def add(self, key, value): ...
def getlist(self, key, type=None): ...
def setlist(self, key, new_list): ...
def setlistdefault(self, key, default_list=None): ...
def update(self, mapping): ...
def poplist(self, key): ...
def pop(self, key, default=...): ...
def popitem(self): ...
def popitemlist(self): ...
class Headers(Mapping):
def __init__(self, defaults=None): ...
def __getitem__(self, key, _get_mode=False): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
def get(self, key, default=None, type=None, as_bytes=False): ...
def getlist(self, key, type=None, as_bytes=False): ...
def get_all(self, name): ...
def items(self, lower=False): ...
def keys(self, lower=False): ...
def values(self): ...
def extend(self, iterable): ...
def __delitem__(self, key): ...
def remove(self, key): ...
def pop(self, **kwargs): ...
def popitem(self): ...
def __contains__(self, key): ...
has_key = ... # type: Any
def __iter__(self): ...
def __len__(self): ...
def add(self, _key, _value, **kw): ...
def add_header(self, _key, _value, **_kw): ...
def clear(self): ...
def set(self, _key, _value, **kw): ...
def setdefault(self, key, value): ...
def __setitem__(self, key, value): ...
def to_list(self, charset=''): ...
def to_wsgi_list(self): ...
def copy(self): ...
def __copy__(self): ...
class ImmutableHeadersMixin:
def __delitem__(self, key): ...
def __setitem__(self, key, value): ...
set = ... # type: Any
def add(self, *args, **kwargs): ...
remove = ... # type: Any
add_header = ... # type: Any
def extend(self, iterable): ...
def insert(self, pos, value): ...
def pop(self, **kwargs): ...
def popitem(self): ...
def setdefault(self, key, default): ...
class EnvironHeaders(ImmutableHeadersMixin, Headers):
environ = ... # type: Any
def __init__(self, environ): ...
def __eq__(self, other): ...
def __getitem__(self, key, _get_mode=False): ...
def __len__(self): ...
def __iter__(self): ...
def copy(self): ...
class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):
def __reduce_ex__(self, protocol): ...
dicts = ... # type: Any
def __init__(self, dicts=None): ...
@classmethod
def fromkeys(cls): ...
def __getitem__(self, key): ...
def get(self, key, default=None, type=None): ...
def getlist(self, key, type=None): ...
def keys(self): ...
__iter__ = ... # type: Any
def items(self, multi=False): ...
def values(self): ...
def lists(self): ...
def listvalues(self): ...
def copy(self): ...
def to_dict(self, flat=True): ...
def __len__(self): ...
def __contains__(self, key): ...
has_key = ... # type: Any
class FileMultiDict(MultiDict):
def add_file(self, name, file, filename=None, content_type=None): ...
class ImmutableDict(ImmutableDictMixin, dict):
def copy(self): ...
def __copy__(self): ...
class ImmutableMultiDict(ImmutableMultiDictMixin, MultiDict):
def copy(self): ...
def __copy__(self): ...
class ImmutableOrderedMultiDict(ImmutableMultiDictMixin, OrderedMultiDict):
def copy(self): ...
def __copy__(self): ...
class Accept(ImmutableList):
provided = ... # type: Any
def __init__(self, values=...): ...
def __getitem__(self, key): ...
def quality(self, key): ...
def __contains__(self, value): ...
def index(self, key): ...
def find(self, key): ...
def values(self): ...
def to_header(self): ...
def best_match(self, matches, default=None): ...
@property
def best(self): ...
class MIMEAccept(Accept):
@property
def accept_html(self): ...
@property
def accept_xhtml(self): ...
@property
def accept_json(self): ...
class LanguageAccept(Accept): ...
class CharsetAccept(Accept): ...
def cache_property(key, empty, type): ...
class _CacheControl(UpdateDictMixin, dict):
no_cache = ... # type: Any
no_store = ... # type: Any
max_age = ... # type: Any
no_transform = ... # type: Any
on_update = ... # type: Any
provided = ... # type: Any
def __init__(self, values=..., on_update=None): ...
def to_header(self): ...
class RequestCacheControl(ImmutableDictMixin, _CacheControl):
max_stale = ... # type: Any
min_fresh = ... # type: Any
no_transform = ... # type: Any
only_if_cached = ... # type: Any
class ResponseCacheControl(_CacheControl):
public = ... # type: Any
private = ... # type: Any
must_revalidate = ... # type: Any
proxy_revalidate = ... # type: Any
s_maxage = ... # type: Any
class CallbackDict(UpdateDictMixin, dict):
on_update = ... # type: Any
def __init__(self, initial=None, on_update=None): ...
class HeaderSet(MutableSet):
on_update = ... # type: Any
def __init__(self, headers=None, on_update=None): ...
def add(self, header): ...
def remove(self, header): ...
def update(self, iterable): ...
def discard(self, header): ...
def find(self, header): ...
def index(self, header): ...
def clear(self): ...
def as_set(self, preserve_casing=False): ...
def to_header(self): ...
def __getitem__(self, idx): ...
def __delitem__(self, idx): ...
def __setitem__(self, idx, value): ...
def __contains__(self, header): ...
def __len__(self): ...
def __iter__(self): ...
def __nonzero__(self): ...
class ETags(Container, Iterable):
star_tag = ... # type: Any
def __init__(self, strong_etags=None, weak_etags=None, star_tag=False): ...
def as_set(self, include_weak=False): ...
def is_weak(self, etag): ...
def contains_weak(self, etag): ...
def contains(self, etag): ...
def contains_raw(self, etag): ...
def to_header(self): ...
def __call__(self, etag=None, data=None, include_weak=False): ...
def __bool__(self): ...
__nonzero__ = ... # type: Any
def __iter__(self): ...
def __contains__(self, etag): ...
class IfRange:
etag = ... # type: Any
date = ... # type: Any
def __init__(self, etag=None, date=None): ...
def to_header(self): ...
class Range:
units = ... # type: Any
ranges = ... # type: Any
def __init__(self, units, ranges): ...
def range_for_length(self, length): ...
def make_content_range(self, length): ...
def to_header(self): ...
def to_content_range_header(self, length): ...
class ContentRange:
on_update = ... # type: Any
def __init__(self, units, start, stop, length=None, on_update=None): ...
units = ... # type: Any
start = ... # type: Any
stop = ... # type: Any
length = ... # type: Any
def set(self, start, stop, length=None, units=''): ...
def unset(self): ...
def to_header(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
class Authorization(ImmutableDictMixin, dict):
type = ... # type: Any
def __init__(self, auth_type, data=None): ...
username = ... # type: Any
password = ... # type: Any
realm = ... # type: Any
nonce = ... # type: Any
uri = ... # type: Any
nc = ... # type: Any
cnonce = ... # type: Any
response = ... # type: Any
opaque = ... # type: Any
@property
def qop(self): ...
class WWWAuthenticate(UpdateDictMixin, dict):
on_update = ... # type: Any
def __init__(self, auth_type=None, values=None, on_update=None): ...
def set_basic(self, realm=''): ...
def set_digest(self, realm, nonce, qop=..., opaque=None, algorithm=None, stale=False): ...
def to_header(self): ...
@staticmethod
def auth_property(name, doc=None): ...
type = ... # type: Any
realm = ... # type: Any
domain = ... # type: Any
nonce = ... # type: Any
opaque = ... # type: Any
algorithm = ... # type: Any
qop = ... # type: Any
stale = ... # type: Any
class FileStorage:
name = ... # type: Any
stream = ... # type: Any
filename = ... # type: Any
headers = ... # type: Any
def __init__(self, stream=None, filename=None, name=None, content_type=None, content_length=None, headers=None): ...
@property
def content_type(self): ...
@property
def content_length(self): ...
@property
def mimetype(self): ...
@property
def mimetype_params(self): ...
def save(self, dst, buffer_size=16384): ...
def close(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
def __getattr__(self, name): ...
def __iter__(self): ...
mypy-0.470/typeshed/third_party/3/werkzeug/useragents.pyi 0000644 0000000 0000000 00000000753 13035744274 022324 0 ustar root root # Stubs for werkzeug.useragents (Python 3.5)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class UserAgentParser:
platforms = ... # type: Any
browsers = ... # type: Any
def __init__(self): ...
def __call__(self, user_agent): ...
class UserAgent:
string = ... # type: Any
def __init__(self, environ_or_string): ...
def to_header(self): ...
def __nonzero__(self): ...
__bool__ = ... # type: Any
mypy-0.470/typeshed/third_party/3/docutils/ 0000755 0000000 0000000 00000000000 13044320557 017371 5 ustar root root mypy-0.470/typeshed/third_party/3/docutils/__init__.pyi 0000644 0000000 0000000 00000000004 13023631176 021644 0 ustar root root ...
mypy-0.470/typeshed/third_party/3/docutils/parsers/ 0000755 0000000 0000000 00000000000 13044320557 021050 5 ustar root root mypy-0.470/typeshed/third_party/3/docutils/parsers/__init__.pyi 0000644 0000000 0000000 00000000004 13023631176 023323 0 ustar root root ...
mypy-0.470/typeshed/third_party/3/docutils/parsers/rst/ 0000755 0000000 0000000 00000000000 13044320557 021660 5 ustar root root mypy-0.470/typeshed/third_party/3/docutils/parsers/rst/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 024127 0 ustar root root mypy-0.470/typeshed/third_party/3/docutils/parsers/rst/states.pyi 0000644 0000000 0000000 00000000112 13023631176 023677 0 ustar root root import typing
class Inliner:
def __init__(self) -> None:
...
mypy-0.470/typeshed/third_party/3/docutils/parsers/rst/roles.pyi 0000644 0000000 0000000 00000000637 13023631176 023534 0 ustar root root import docutils.nodes
import docutils.parsers.rst.states
from typing import Callable, Any, List, Dict, Tuple
def register_local_role(name: str,
role_fn: Callable[[str, str, str, int, docutils.parsers.rst.states.Inliner, Dict, List],
Tuple[List[docutils.nodes.reference], List[docutils.nodes.reference]]]
) -> None:
...
mypy-0.470/typeshed/third_party/3/docutils/parsers/rst/nodes.pyi 0000644 0000000 0000000 00000000004 13023631176 023504 0 ustar root root ...
mypy-0.470/typeshed/third_party/3/docutils/examples.pyi 0000644 0000000 0000000 00000000066 13023631176 021733 0 ustar root root from typing import Any
html_parts = ... # type: Any
mypy-0.470/typeshed/third_party/3/docutils/nodes.pyi 0000644 0000000 0000000 00000000342 13023631176 021222 0 ustar root root from typing import Any, List
class reference:
def __init__(self,
rawsource: str = ...,
text: str = ...,
*children: List[Any],
**attributes) -> None: ...
mypy-0.470/typeshed/third_party/3/dateutil/ 0000755 0000000 0000000 00000000000 13044320557 017356 5 ustar root root mypy-0.470/typeshed/third_party/3/dateutil/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 021625 0 ustar root root mypy-0.470/typeshed/third_party/3/dateutil/parser.pyi 0000644 0000000 0000000 00000002743 13035744274 021411 0 ustar root root from typing import List, Tuple, Optional, Callable, Union, IO, Any
from datetime import datetime
__all__ = ... # type: List[str]
class parserinfo(object):
JUMP = ... # type: List[str]
WEEKDAYS = ... # type: List[Tuple[str, str]]
MONTHS = ... # type: List[Tuple[str, str]]
HMS = ... # type: List[Tuple[str, str, str]]
AMPM = ... # type: List[Tuple[str, str, str]]
UTCZONE = ... # type: List[str]
PERTAIN = ... # type: List[str]
TZOFFSET = ... # type: Dict[str, int]
def __init__(self, dayfirst: bool=..., yearfirst: bool=...) -> None: ...
def jump(self, name: str) -> bool: ...
def weekday(self, name: str) -> str: ...
def month(self, name: str) -> str: ...
def hms(self, name: str) -> str: ...
def ampm(self, name: str) -> str: ...
def pertain(self, name: str) -> bool: ...
def utczone(self, name: str) -> bool: ...
def tzoffset(self, name: str) -> int: ...
def convertyear(self, year: int) -> int: ...
def validate(self, year: datetime) -> bool: ...
class parser(object):
def __init__(self, info: parserinfo=...) -> None: ...
def parse(
self,
timestr: Union[str, bytes, IO[Any]],
default: Optional[datetime],
ignoretz: bool=...,
tzinfos: Any =...,
) -> datetime: ...
DEFAULTPARSER = ... # type: parser
def parse(timestr, parserinfo: parserinfo=..., **kwargs) -> datetime:
...
class _tzparser(object):
...
DEFAULTTZPARSER = ... # type: _tzparser
mypy-0.470/typeshed/third_party/3/dateutil/relativedelta.pyi 0000644 0000000 0000000 00000006271 13035744274 022742 0 ustar root root from typing import Optional, overload, Union
from datetime import date, datetime, timedelta
__all__ = ... # type: List[str]
class weekday(object):
def __init__(self, weekday: int, n: Optional[int]=...) -> None: ...
def __call__(self, n: int) -> 'weekday': ...
def __eq__(self, other) -> bool: ...
def __repr__(self) -> str: ...
weekday = ... # type: int
n = ... # type: int
MO = ... # type: weekday
TU = ... # type: weekday
WE = ... # type: weekday
TH = ... # type: weekday
FR = ... # type: weekday
SA = ... # type: weekday
SU = ... # type: weekday
class relativedelta(object):
def __init__(self,
dt1: Optional[date]=...,
dt2: Optional[date]=...,
years: Optional[int]=..., months: Optional[int]=...,
days: Optional[int]=..., leapdays: Optional[int]=...,
weeks: Optional[int]=...,
hours: Optional[int]=..., minutes: Optional[int]=...,
seconds: Optional[int]=..., microseconds: Optional[int]=...,
year: Optional[int]=..., month: Optional[int]=...,
day: Optional[int]=...,
weekday: Optional[Union[int, weekday]]=...,
yearday: Optional[int]=...,
nlyearday: Optional[int]=...,
hour: Optional[int]=..., minute: Optional[int]=...,
second: Optional[int]=...,
microsecond: Optional[int]=...) -> None: ...
@property
def weeks(self) -> int: ...
@weeks.setter
def weeks(self, value: int) -> None: ...
def normalized(self) -> 'relativedelta': ...
# TODO: use Union when mypy will handle it properly in overloaded operator
# methods (#2129, #1442, #1264 in mypy)
@overload
def __add__(self, other: 'relativedelta') -> 'relativedelta': ...
@overload
def __add__(self, other: timedelta) -> 'relativedelta': ...
@overload
def __add__(self, other: date) -> date: ...
@overload
def __add__(self, other: datetime) -> datetime: ...
@overload
def __radd__(self, other: 'relativedelta') -> 'relativedelta': ...
@overload
def __radd__(self, other: timedelta) -> 'relativedelta': ...
@overload
def __radd__(self, other: date) -> date: ...
@overload
def __radd__(self, other: datetime) -> datetime: ...
@overload
def __rsub__(self, other: 'relativedelta') -> 'relativedelta': ...
@overload
def __rsub__(self, other: timedelta) -> 'relativedelta': ...
@overload
def __rsub__(self, other: date) -> date: ...
@overload
def __rsub__(self, other: datetime) -> datetime: ...
def __sub__(self, other: 'relativedelta') -> 'relativedelta': ...
def __neg__(self) -> 'relativedelta': ...
def __bool__(self) -> bool: ...
def __nonzero__(self) -> bool: ...
def __mul__(self, other: float) -> 'relativedelta': ...
def __rmul__(self, other: float) -> 'relativedelta': ...
def __eq__(self, other) -> bool: ...
def __ne__(self, other: object) -> bool: ...
def __div__(self, other: float) -> 'relativedelta': ...
def __truediv__(self, other: float) -> 'relativedelta': ...
def __repr__(self) -> str: ...
mypy-0.470/typeshed/third_party/3/typed_ast/ 0000755 0000000 0000000 00000000000 13044320557 017537 5 ustar root root mypy-0.470/typeshed/third_party/3/typed_ast/ast27.pyi 0000644 0000000 0000000 00000021302 13035744274 021226 0 ustar root root import typing
from typing import Any, Optional, Union, Generic, Iterator
class NodeVisitor():
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> Optional[bytes]: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
PyCF_ONLY_AST = ... # type: int
# ast classes
identifier = str
class AST:
_attributes = ... # type: typing.Tuple[str, ...]
_fields = ... # type: typing.Tuple[str, ...]
def __init__(self, *args, **kwargs) -> None: ...
class mod(AST):
...
class Module(mod):
body = ... # type: typing.List[stmt]
type_ignores = ... # type: typing.List[TypeIgnore]
class Interactive(mod):
body = ... # type: typing.List[stmt]
class Expression(mod):
body = ... # type: expr
class FunctionType(mod):
argtypes = ... # type: typing.List[expr]
returns = ... # type: expr
class Suite(mod):
body = ... # type: typing.List[stmt]
class stmt(AST):
lineno = ... # type: int
col_offset = ... # type: int
class FunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
type_comment = ... # type: Optional[str]
class ClassDef(stmt):
name = ... # type: identifier
bases = ... # type: typing.List[expr]
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
class Return(stmt):
value = ... # type: Optional[expr]
class Delete(stmt):
targets = ... # type: typing.List[expr]
class Assign(stmt):
targets = ... # type: typing.List[expr]
value = ... # type: expr
type_comment = ... # type: Optional[str]
class AugAssign(stmt):
target = ... # type: expr
op = ... # type: operator
value = ... # type: expr
class Print(stmt):
dest = ... # type: Optional[expr]
values = ... # type: typing.List[expr]
nl = ... # type: bool
class For(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
type_comment = ... # type: Optional[str]
class While(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class If(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class With(stmt):
context_expr = ... # type: expr
optional_vars = ... # type: Optional[expr]
body = ... # type: typing.List[stmt]
type_comment = ... # type: Optional[str]
class Raise(stmt):
type = ... # type: Optional[expr]
inst = ... # type: Optional[expr]
tback = ... # type: Optional[expr]
class TryExcept(stmt):
body = ... # type: typing.List[stmt]
handlers = ... # type: typing.List[ExceptHandler]
orelse = ... # type: typing.List[stmt]
class TryFinally(stmt):
body = ... # type: typing.List[stmt]
finalbody = ... # type: typing.List[stmt]
class Assert(stmt):
test = ... # type: expr
msg = ... # type: Optional[expr]
class Import(stmt):
names = ... # type: typing.List[alias]
class ImportFrom(stmt):
module = ... # type: Optional[identifier]
names = ... # type: typing.List[alias]
level = ... # type: Optional[int]
class Exec(stmt):
body = ... # type: expr
globals = ... # type: Optional[expr]
locals = ... # type: Optional[expr]
class Global(stmt):
names = ... # type: typing.List[identifier]
class Expr(stmt):
value = ... # type: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class slice(AST):
...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower = ... # type: Optional[expr]
upper = ... # type: Optional[expr]
step = ... # type: Optional[expr]
class ExtSlice(slice):
dims = ... # type: typing.List[slice]
class Index(slice):
value = ... # type: expr
class Ellipsis(slice): ...
class expr(AST):
lineno = ... # type: int
col_offset = ... # type: int
class BoolOp(expr):
op = ... # type: boolop
values = ... # type: typing.List[expr]
class BinOp(expr):
left = ... # type: expr
op = ... # type: operator
right = ... # type: expr
class UnaryOp(expr):
op = ... # type: unaryop
operand = ... # type: expr
class Lambda(expr):
args = ... # type: arguments
body = ... # type: expr
class IfExp(expr):
test = ... # type: expr
body = ... # type: expr
orelse = ... # type: expr
class Dict(expr):
keys = ... # type: typing.List[expr]
values = ... # type: typing.List[expr]
class Set(expr):
elts = ... # type: typing.List[expr]
class ListComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class SetComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class DictComp(expr):
key = ... # type: expr
value = ... # type: expr
generators = ... # type: typing.List[comprehension]
class GeneratorExp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class Yield(expr):
value = ... # type: Optional[expr]
class Compare(expr):
left = ... # type: expr
ops = ... # type: typing.List[cmpop]
comparators = ... # type: typing.List[expr]
class Call(expr):
func = ... # type: expr
args = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
starargs = ... # type: Optional[expr]
kwargs = ... # type: Optional[expr]
class Repr(expr):
value = ... # type: expr
class Num(expr):
n = ... # type: Union[int, float]
class Str(expr):
s = ... # type: bytes
class Attribute(expr):
value = ... # type: expr
attr = ... # type: identifier
ctx = ... # type: expr_context
class Subscript(expr):
value = ... # type: expr
slice = ... # type: _slice
ctx = ... # type: expr_context
class Name(expr):
id = ... # type: identifier
ctx = ... # type: expr_context
class List(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class Tuple(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class expr_context(AST):
...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(expr_context): ...
class Store(expr_context): ...
class boolop(AST):
...
class And(boolop): ...
class Or(boolop): ...
class operator(AST):
...
class Add(operator): ...
class BitAnd(operator): ...
class BitOr(operator): ...
class BitXor(operator): ...
class Div(operator): ...
class FloorDiv(operator): ...
class LShift(operator): ...
class Mod(operator): ...
class Mult(operator): ...
class Pow(operator): ...
class RShift(operator): ...
class Sub(operator): ...
class unaryop(AST):
...
class Invert(unaryop): ...
class Not(unaryop): ...
class UAdd(unaryop): ...
class USub(unaryop): ...
class cmpop(AST):
...
class Eq(cmpop): ...
class Gt(cmpop): ...
class GtE(cmpop): ...
class In(cmpop): ...
class Is(cmpop): ...
class IsNot(cmpop): ...
class Lt(cmpop): ...
class LtE(cmpop): ...
class NotEq(cmpop): ...
class NotIn(cmpop): ...
class comprehension(AST):
target = ... # type: expr
iter = ... # type: expr
ifs = ... # type: typing.List[expr]
class ExceptHandler(AST):
type = ... # type: Optional[expr]
name = ... # type: Optional[expr]
body = ... # type: typing.List[stmt]
lineno = ... # type: int
col_offset = ... # type: int
class arguments(AST):
args = ... # type: typing.List[expr]
vararg = ... # type: Optional[identifier]
kwarg = ... # type: Optional[identifier]
defaults = ... # type: typing.List[expr]
type_comments = ... # type: typing.List[str]
class keyword(AST):
arg = ... # type: identifier
value = ... # type: expr
class alias(AST):
name = ... # type: identifier
asname = ... # type: Optional[identifier]
class TypeIgnore(AST):
lineno = ... # type: int
mypy-0.470/typeshed/third_party/3/typed_ast/__init__.pyi 0000644 0000000 0000000 00000000202 13023631176 022012 0 ustar root root # This module is a fork of the CPython 2.7 and 3.5 ast modules with PEP 484 support.
# See: https://github.com/dropbox/typed_ast
mypy-0.470/typeshed/third_party/3/typed_ast/conversions.pyi 0000644 0000000 0000000 00000000126 13023631176 022630 0 ustar root root from . import ast27
from . import ast35
def py2to3(ast: ast27.AST) -> ast35.AST: ...
mypy-0.470/typeshed/third_party/3/typed_ast/ast35.pyi 0000644 0000000 0000000 00000023036 13035744274 021233 0 ustar root root import typing
from typing import Any, Optional, Union, Generic, Iterator
class NodeVisitor():
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> str: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
PyCF_ONLY_AST = ... # type: int
# ast classes
identifier = str
class AST:
_attributes = ... # type: typing.Tuple[str, ...]
_fields = ... # type: typing.Tuple[str, ...]
def __init__(self, *args, **kwargs) -> None: ...
class mod(AST):
...
class Module(mod):
body = ... # type: typing.List[stmt]
type_ignores = ... # type: typing.List[TypeIgnore]
class Interactive(mod):
body = ... # type: typing.List[stmt]
class Expression(mod):
body = ... # type: expr
class FunctionType(mod):
argtypes = ... # type: typing.List[expr]
returns = ... # type: expr
class Suite(mod):
body = ... # type: typing.List[stmt]
class stmt(AST):
lineno = ... # type: int
col_offset = ... # type: int
class FunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
returns = ... # type: Optional[expr]
type_comment = ... # type: Optional[str]
class AsyncFunctionDef(stmt):
name = ... # type: identifier
args = ... # type: arguments
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
returns = ... # type: Optional[expr]
type_comment = ... # type: Optional[str]
class ClassDef(stmt):
name = ... # type: identifier
bases = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
body = ... # type: typing.List[stmt]
decorator_list = ... # type: typing.List[expr]
class Return(stmt):
value = ... # type: Optional[expr]
class Delete(stmt):
targets = ... # type: typing.List[expr]
class Assign(stmt):
targets = ... # type: typing.List[expr]
value = ... # type: Optional[expr]
type_comment = ... # type: Optional[str]
annotation = ... # type: Optional[expr]
class AugAssign(stmt):
target = ... # type: expr
op = ... # type: operator
value = ... # type: expr
class For(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
type_comment = ... # type: Optional[str]
class AsyncFor(stmt):
target = ... # type: expr
iter = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class While(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class If(stmt):
test = ... # type: expr
body = ... # type: typing.List[stmt]
orelse = ... # type: typing.List[stmt]
class With(stmt):
items = ... # type: typing.List[withitem]
body = ... # type: typing.List[stmt]
type_comment = ... # type: Optional[str]
class AsyncWith(stmt):
items = ... # type: typing.List[withitem]
body = ... # type: typing.List[stmt]
class Raise(stmt):
exc = ... # type: Optional[expr]
cause = ... # type: Optional[expr]
class Try(stmt):
body = ... # type: typing.List[stmt]
handlers = ... # type: typing.List[ExceptHandler]
orelse = ... # type: typing.List[stmt]
finalbody = ... # type: typing.List[stmt]
class Assert(stmt):
test = ... # type: expr
msg = ... # type: Optional[expr]
class Import(stmt):
names = ... # type: typing.List[alias]
class ImportFrom(stmt):
module = ... # type: Optional[identifier]
names = ... # type: typing.List[alias]
level = ... # type: Optional[int]
class Global(stmt):
names = ... # type: typing.List[identifier]
class Nonlocal(stmt):
names = ... # type: typing.List[identifier]
class Expr(stmt):
value = ... # type: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class slice(AST):
...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower = ... # type: Optional[expr]
upper = ... # type: Optional[expr]
step = ... # type: Optional[expr]
class ExtSlice(slice):
dims = ... # type: typing.List[slice]
class Index(slice):
value = ... # type: expr
class expr(AST):
lineno = ... # type: int
col_offset = ... # type: int
class BoolOp(expr):
op = ... # type: boolop
values = ... # type: typing.List[expr]
class BinOp(expr):
left = ... # type: expr
op = ... # type: operator
right = ... # type: expr
class UnaryOp(expr):
op = ... # type: unaryop
operand = ... # type: expr
class Lambda(expr):
args = ... # type: arguments
body = ... # type: expr
class IfExp(expr):
test = ... # type: expr
body = ... # type: expr
orelse = ... # type: expr
class Dict(expr):
keys = ... # type: typing.List[expr]
values = ... # type: typing.List[expr]
class Set(expr):
elts = ... # type: typing.List[expr]
class ListComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class SetComp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class DictComp(expr):
key = ... # type: expr
value = ... # type: expr
generators = ... # type: typing.List[comprehension]
class GeneratorExp(expr):
elt = ... # type: expr
generators = ... # type: typing.List[comprehension]
class Await(expr):
value = ... # type: expr
class Yield(expr):
value = ... # type: Optional[expr]
class YieldFrom(expr):
value = ... # type: expr
class Compare(expr):
left = ... # type: expr
ops = ... # type: typing.List[cmpop]
comparators = ... # type: typing.List[expr]
class Call(expr):
func = ... # type: expr
args = ... # type: typing.List[expr]
keywords = ... # type: typing.List[keyword]
class Num(expr):
n = ... # type: Union[int, float]
class Str(expr):
s = ... # type: str
class Bytes(expr):
s = ... # type: bytes
class NameConstant(expr):
value = ... # type: Any
class Ellipsis(expr): ...
class Attribute(expr):
value = ... # type: expr
attr = ... # type: identifier
ctx = ... # type: expr_context
class Subscript(expr):
value = ... # type: expr
slice = ... # type: _slice
ctx = ... # type: expr_context
class Starred(expr):
value = ... # type: expr
ctx = ... # type: expr_context
class Name(expr):
id = ... # type: identifier
ctx = ... # type: expr_context
class List(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class Tuple(expr):
elts = ... # type: typing.List[expr]
ctx = ... # type: expr_context
class expr_context(AST):
...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(expr_context): ...
class Store(expr_context): ...
class boolop(AST):
...
class And(boolop): ...
class Or(boolop): ...
class operator(AST):
...
class Add(operator): ...
class BitAnd(operator): ...
class BitOr(operator): ...
class BitXor(operator): ...
class Div(operator): ...
class FloorDiv(operator): ...
class LShift(operator): ...
class Mod(operator): ...
class Mult(operator): ...
class MatMult(operator): ...
class Pow(operator): ...
class RShift(operator): ...
class Sub(operator): ...
class unaryop(AST):
...
class Invert(unaryop): ...
class Not(unaryop): ...
class UAdd(unaryop): ...
class USub(unaryop): ...
class cmpop(AST):
...
class Eq(cmpop): ...
class Gt(cmpop): ...
class GtE(cmpop): ...
class In(cmpop): ...
class Is(cmpop): ...
class IsNot(cmpop): ...
class Lt(cmpop): ...
class LtE(cmpop): ...
class NotEq(cmpop): ...
class NotIn(cmpop): ...
class comprehension(AST):
target = ... # type: expr
iter = ... # type: expr
ifs = ... # type: typing.List[expr]
class ExceptHandler(AST):
type = ... # type: Optional[expr]
name = ... # type: Optional[identifier]
body = ... # type: typing.List[stmt]
lineno = ... # type: int
col_offset = ... # type: int
class arguments(AST):
args = ... # type: typing.List[arg]
vararg = ... # type: Optional[arg]
kwonlyargs = ... # type: typing.List[arg]
kw_defaults = ... # type: typing.List[expr]
kwarg = ... # type: Optional[arg]
defaults = ... # type: typing.List[expr]
class arg(AST):
arg = ... # type: identifier
annotation = ... # type: Optional[expr]
lineno = ... # type: int
col_offset = ... # type: int
class keyword(AST):
arg = ... # type: Optional[identifier]
value = ... # type: expr
class alias(AST):
name = ... # type: identifier
asname = ... # type: Optional[identifier]
class withitem(AST):
context_expr = ... # type: expr
optional_vars = ... # type: Optional[expr]
class TypeIgnore(AST):
lineno = ... # type: int
mypy-0.470/typeshed/third_party/3/requests/ 0000755 0000000 0000000 00000000000 13044320557 017416 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/__init__.pyi 0000644 0000000 0000000 00000001733 13023631176 021703 0 ustar root root # Stubs for requests (based on version 2.6.0, Python 3)
from typing import Any
from . import models
from . import api
from . import sessions
from . import status_codes
from . import exceptions
import logging
__title__ = ... # type: Any
__build__ = ... # type: Any
__license__ = ... # type: Any
__copyright__ = ... # type: Any
__version__ = ... # type: Any
Request = models.Request
Response = models.Response
PreparedRequest = models.PreparedRequest
request = api.request
get = api.get
head = api.head
post = api.post
patch = api.patch
put = api.put
delete = api.delete
options = api.options
session = sessions.session
Session = sessions.Session
codes = status_codes.codes
RequestException = exceptions.RequestException
Timeout = exceptions.Timeout
URLRequired = exceptions.URLRequired
TooManyRedirects = exceptions.TooManyRedirects
HTTPError = exceptions.HTTPError
ConnectionError = exceptions.ConnectionError
class NullHandler(logging.Handler):
def emit(self, record): ...
mypy-0.470/typeshed/third_party/3/requests/auth.pyi 0000644 0000000 0000000 00000002260 13023631176 021101 0 ustar root root # Stubs for requests.auth (Python 3)
from typing import Any
from . import compat
from . import cookies
from . import utils
from . import status_codes
extract_cookies_to_jar = cookies.extract_cookies_to_jar
parse_dict_header = utils.parse_dict_header
to_native_string = utils.to_native_string
codes = status_codes.codes
CONTENT_TYPE_FORM_URLENCODED = ... # type: Any
CONTENT_TYPE_MULTI_PART = ... # type: Any
class AuthBase:
def __call__(self, r): ...
class HTTPBasicAuth(AuthBase):
username = ... # type: Any
password = ... # type: Any
def __init__(self, username, password) -> None: ...
def __call__(self, r): ...
class HTTPProxyAuth(HTTPBasicAuth):
def __call__(self, r): ...
class HTTPDigestAuth(AuthBase):
username = ... # type: Any
password = ... # type: Any
last_nonce = ... # type: Any
nonce_count = ... # type: Any
chal = ... # type: Any
pos = ... # type: Any
num_401_calls = ... # type: Any
def __init__(self, username, password) -> None: ...
def build_digest_header(self, method, url): ...
def handle_redirect(self, r, **kwargs): ...
def handle_401(self, r, **kwargs): ...
def __call__(self, r): ...
mypy-0.470/typeshed/third_party/3/requests/cookies.pyi 0000644 0000000 0000000 00000004020 13035744274 021577 0 ustar root root # Stubs for requests.cookies (Python 3)
from typing import Any, MutableMapping
# import cookielib
from http import cookiejar as cookielib
import collections
from . import compat
# cookielib = compat.cookielib
class MockRequest:
type = ... # type: Any
def __init__(self, request) -> None: ...
def get_type(self): ...
def get_host(self): ...
def get_origin_req_host(self): ...
def get_full_url(self): ...
def is_unverifiable(self): ...
def has_header(self, name): ...
def get_header(self, name, default=...): ...
def add_header(self, key, val): ...
def add_unredirected_header(self, name, value): ...
def get_new_headers(self): ...
@property
def unverifiable(self): ...
@property
def origin_req_host(self): ...
@property
def host(self): ...
class MockResponse:
def __init__(self, headers) -> None: ...
def info(self): ...
def getheaders(self, name): ...
def extract_cookies_to_jar(jar, request, response): ...
def get_cookie_header(jar, request): ...
def remove_cookie_by_name(cookiejar, name, domain=..., path=...): ...
class CookieConflictError(RuntimeError): ...
class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
def get(self, name, default=..., domain=..., path=...): ...
def set(self, name, value, **kwargs): ...
def iterkeys(self): ...
def keys(self): ...
def itervalues(self): ...
def values(self): ...
def iteritems(self): ...
def items(self): ...
def list_domains(self): ...
def list_paths(self): ...
def multiple_domains(self): ...
def get_dict(self, domain=..., path=...): ...
def __getitem__(self, name): ...
def __setitem__(self, name, value): ...
def __delitem__(self, name): ...
def set_cookie(self, cookie, *args, **kwargs): ...
def update(self, other): ...
def copy(self): ...
def create_cookie(name, value, **kwargs): ...
def morsel_to_cookie(morsel): ...
def cookiejar_from_dict(cookie_dict, cookiejar=..., overwrite=...): ...
def merge_cookies(cookiejar, cookies): ...
mypy-0.470/typeshed/third_party/3/requests/api.pyi 0000644 0000000 0000000 00000001312 13044257024 020705 0 ustar root root # Stubs for requests.api (Python 3)
from typing import Optional, Union, Any
from .models import Response
def request(method: str, url: str, **kwargs) -> Response: ...
def get(url: Union[str, bytes],
params: Optional[Union[str,
bytes,
dict[Union[str, bytes], Union[str, bytes]]]]=None,
**kwargs) -> Response: ...
def options(url: str, **kwargs) -> Response: ...
def head(url: str, **kwargs) -> Response: ...
def post(url: str, data=..., json=..., **kwargs) -> Response: ...
def put(url: str, data=..., **kwargs) -> Response: ...
def patch(url: str, data=..., **kwargs) -> Response: ...
def delete(url: str, **kwargs) -> Response: ...
mypy-0.470/typeshed/third_party/3/requests/compat.pyi 0000644 0000000 0000000 00000000173 13023631176 021424 0 ustar root root # Stubs for requests.compat (Python 3.4)
from typing import Any
import collections
OrderedDict = collections.OrderedDict
mypy-0.470/typeshed/third_party/3/requests/utils.pyi 0000644 0000000 0000000 00000003155 13023631176 021304 0 ustar root root # Stubs for requests.utils (Python 3)
from typing import Any
from . import compat
from . import cookies
from . import structures
from . import exceptions
OrderedDict = compat.OrderedDict
RequestsCookieJar = cookies.RequestsCookieJar
cookiejar_from_dict = cookies.cookiejar_from_dict
CaseInsensitiveDict = structures.CaseInsensitiveDict
InvalidURL = exceptions.InvalidURL
NETRC_FILES = ... # type: Any
DEFAULT_CA_BUNDLE_PATH = ... # type: Any
def dict_to_sequence(d): ...
def super_len(o): ...
def get_netrc_auth(url): ...
def guess_filename(obj): ...
def from_key_val_list(value): ...
def to_key_val_list(value): ...
def parse_list_header(value): ...
def parse_dict_header(value): ...
def unquote_header_value(value, is_filename=...): ...
def dict_from_cookiejar(cj): ...
def add_dict_to_cookiejar(cj, cookie_dict): ...
def get_encodings_from_content(content): ...
def get_encoding_from_headers(headers): ...
def stream_decode_response_unicode(iterator, r): ...
def iter_slices(string, slice_length): ...
def get_unicode_from_response(r): ...
UNRESERVED_SET = ... # type: Any
def unquote_unreserved(uri): ...
def requote_uri(uri): ...
def address_in_network(ip, net): ...
def dotted_netmask(mask): ...
def is_ipv4_address(string_ip): ...
def is_valid_cidr(string_network): ...
def should_bypass_proxies(url): ...
def get_environ_proxies(url): ...
def default_user_agent(name=...): ...
def default_headers(): ...
def parse_header_links(value): ...
def guess_json_utf(data): ...
def prepend_scheme_if_needed(url, new_scheme): ...
def get_auth_from_url(url): ...
def to_native_string(string, encoding=...): ...
def urldefragauth(url): ...
mypy-0.470/typeshed/third_party/3/requests/sessions.pyi 0000644 0000000 0000000 00000011653 13035744274 022023 0 ustar root root # Stubs for requests.sessions (Python 3)
from typing import Any, Union, MutableMapping, Text, Optional, IO, Tuple, Callable
from . import adapters
from . import auth
from . import compat
from . import cookies
from . import models
from .models import Response
from . import hooks
from . import utils
from . import exceptions
from .packages.urllib3 import _collections
from . import structures
from . import adapters
from . import status_codes
BaseAdapter = adapters.BaseAdapter
OrderedDict = compat.OrderedDict
cookiejar_from_dict = cookies.cookiejar_from_dict
extract_cookies_to_jar = cookies.extract_cookies_to_jar
RequestsCookieJar = cookies.RequestsCookieJar
merge_cookies = cookies.merge_cookies
Request = models.Request
PreparedRequest = models.PreparedRequest
DEFAULT_REDIRECT_LIMIT = models.DEFAULT_REDIRECT_LIMIT
default_hooks = hooks.default_hooks
dispatch_hook = hooks.dispatch_hook
to_key_val_list = utils.to_key_val_list
default_headers = utils.default_headers
to_native_string = utils.to_native_string
TooManyRedirects = exceptions.TooManyRedirects
InvalidSchema = exceptions.InvalidSchema
ChunkedEncodingError = exceptions.ChunkedEncodingError
ContentDecodingError = exceptions.ContentDecodingError
RecentlyUsedContainer = _collections.RecentlyUsedContainer
CaseInsensitiveDict = structures.CaseInsensitiveDict
HTTPAdapter = adapters.HTTPAdapter
requote_uri = utils.requote_uri
get_environ_proxies = utils.get_environ_proxies
get_netrc_auth = utils.get_netrc_auth
should_bypass_proxies = utils.should_bypass_proxies
get_auth_from_url = utils.get_auth_from_url
codes = status_codes.codes
REDIRECT_STATI = models.REDIRECT_STATI
REDIRECT_CACHE_SIZE = ... # type: Any
def merge_setting(request_setting, session_setting, dict_class=...): ...
def merge_hooks(request_hooks, session_hooks, dict_class=...): ...
class SessionRedirectMixin:
def resolve_redirects(self, resp, req, stream=..., timeout=..., verify=..., cert=...,
proxies=...): ...
def rebuild_auth(self, prepared_request, response): ...
def rebuild_proxies(self, prepared_request, proxies): ...
class Session(SessionRedirectMixin):
__attrs__ = ... # type: Any
headers = ... # type: Optional[MutableMapping[Text, Text]]
auth = ... # type: Union[None, Tuple[Text, Text], Callable[[Request], Request]]
proxies = ... # type: Optional[MutableMapping[Text, Text]]
hooks = ... # type: Optional[MutableMapping[Text, Callable[[Request], Any]]]
params = ... # type: Union[None, bytes, MutableMapping[Text, Text]]
stream = ... # type: bool
verify = ... # type: bool
cert = ... # type: Union[None, Text, Tuple[Text, Text]]
max_redirects = ... # type: int
trust_env = ... # type: bool
cookies = ... # type: Union[None, RequestsCookieJar, MutableMapping[Text, Text]]
adapters = ... # type: MutableMapping
redirect_cache = ... # type: RecentlyUsedContainer
def __init__(self) -> None: ...
def __enter__(self) -> 'Session': ...
def __exit__(self, *args) -> None: ...
def prepare_request(self, request): ...
def request(self, method: str, url: str,
params, # type: Union[None, bytes, MutableMapping[Text, Text]]
data, # type: Union[None, bytes, MutableMapping[Text, Text], IO]
headers, # type: Optional[MutableMapping[Text, Text]]
cookies, # type: Union[None, RequestsCookieJar, MutableMapping[Text, Text]]
files, # type: Optional[MutableMapping[Text, IO]]
auth, # type: Union[None, Tuple[Text, Text], Callable[[Request], Request]]
timeout, # type: Union[None, float, Tuple[float, float]]
allow_redirects, # type: Optional[bool]
proxies, # type: Optional[MutableMapping[Text, Text]]
hooks, # type: Optional[MutableMapping[Text, Callable[[Request], Any]]]
stream, # type: Optional[bool]
verify, # type: Optional[bool]
cert, # type: Union[Text, Tuple[Text, Text], None]
json # type: Optional[MutableMapping]
) -> Response: ...
def get(self, url: Union[str, bytes], **kwargs) -> Response: ...
def options(self, url: Union[str, bytes], **kwargs) -> Response: ...
def head(self, url: Union[str, bytes], **kwargs) -> Response: ...
def post(self, url: Union[str, bytes], data=..., json=..., **kwargs) -> Response: ...
def put(self, url: Union[str, bytes], data=..., **kwargs) -> Response: ...
def patch(self, url: Union[str, bytes], data=..., **kwargs) -> Response: ...
def delete(self, url: Union[str, bytes], **kwargs) -> Response: ...
def send(self, request, **kwargs): ...
def merge_environment_settings(self, url, proxies, stream, verify, cert): ...
def get_adapter(self, url): ...
def close(self) -> None: ...
def mount(self, prefix:
Union[str, bytes],
adapter: BaseAdapter) -> None: ...
def session() -> Session: ...
mypy-0.470/typeshed/third_party/3/requests/structures.pyi 0000644 0000000 0000000 00000000651 13035744274 022374 0 ustar root root # Stubs for requests.structures (Python 3)
from typing import Any, Iterator, MutableMapping, Tuple, Union
class CaseInsensitiveDict(MutableMapping[str, Union[str, bytes]]):
def lower_items(self) -> Iterator[Tuple[str, Union[str, bytes]]]: ...
class LookupDict(dict):
name = ... # type: Any
def __init__(self, name=...) -> None: ...
def __getitem__(self, key): ...
def get(self, key, default=...): ...
mypy-0.470/typeshed/third_party/3/requests/adapters.pyi 0000644 0000000 0000000 00000005547 13023631176 021756 0 ustar root root # Stubs for requests.adapters (Python 3)
from typing import Any, Container, Union, Tuple
from . import models
from .packages.urllib3 import poolmanager
from .packages.urllib3 import response
from .packages.urllib3.util import retry
from . import compat
from . import utils
from . import structures
from .packages.urllib3 import exceptions as urllib3_exceptions
from . import cookies
from . import exceptions
from . import auth
PreparedRequest = models.PreparedRequest
Response = models.Response
PoolManager = poolmanager.PoolManager
proxy_from_url = poolmanager.proxy_from_url
HTTPResponse = response.HTTPResponse
Retry = retry.Retry
DEFAULT_CA_BUNDLE_PATH = utils.DEFAULT_CA_BUNDLE_PATH
get_encoding_from_headers = utils.get_encoding_from_headers
prepend_scheme_if_needed = utils.prepend_scheme_if_needed
get_auth_from_url = utils.get_auth_from_url
urldefragauth = utils.urldefragauth
CaseInsensitiveDict = structures.CaseInsensitiveDict
ConnectTimeoutError = urllib3_exceptions.ConnectTimeoutError
MaxRetryError = urllib3_exceptions.MaxRetryError
ProtocolError = urllib3_exceptions.ProtocolError
ReadTimeoutError = urllib3_exceptions.ReadTimeoutError
ResponseError = urllib3_exceptions.ResponseError
extract_cookies_to_jar = cookies.extract_cookies_to_jar
ConnectionError = exceptions.ConnectionError
ConnectTimeout = exceptions.ConnectTimeout
ReadTimeout = exceptions.ReadTimeout
SSLError = exceptions.SSLError
ProxyError = exceptions.ProxyError
RetryError = exceptions.RetryError
DEFAULT_POOLBLOCK = ... # type: Any
DEFAULT_POOLSIZE = ... # type: Any
DEFAULT_RETRIES = ... # type: Any
class BaseAdapter:
def __init__(self) -> None: ...
def send(self, request: PreparedRequest, stream=False,
timeout: Union[None, float, Tuple[float, float]]=None,
verify=False,
cert: Union[None, Union[str, bytes], Container[Union[str, bytes]]]=None
) -> Response: ...
def close(self) -> None: ...
class HTTPAdapter(BaseAdapter):
__attrs__ = ... # type: Any
max_retries = ... # type: Any
config = ... # type: Any
proxy_manager = ... # type: Any
def __init__(self, pool_connections=..., pool_maxsize=..., max_retries=...,
pool_block=...): ...
poolmanager = ... # type: Any
def init_poolmanager(self, connections, maxsize, block=..., **pool_kwargs): ...
def proxy_manager_for(self, proxy, **proxy_kwargs): ...
def cert_verify(self, conn, url, verify, cert): ...
def build_response(self, req, resp): ...
def get_connection(self, url, proxies=...): ...
def close(self): ...
def request_url(self, request, proxies): ...
def add_headers(self, request, **kwargs): ...
def proxy_headers(self, proxy): ...
# TODO: "request" is not actually optional, modified to please mypy.
def send(self, request=..., stream=..., timeout=..., verify=..., cert=...,
proxies=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/ 0000755 0000000 0000000 00000000000 13044320557 021174 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/__init__.pyi 0000644 0000000 0000000 00000000430 13023631176 023452 0 ustar root root # Stubs for requests.packages (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class VendorAlias:
def __init__(self, package_names) -> None: ...
def find_module(self, fullname, path=...): ...
def load_module(self, name): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/ 0000755 0000000 0000000 00000000000 13044320557 022550 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/_collections.pyi 0000644 0000000 0000000 00000003174 13023631176 025754 0 ustar root root # Stubs for requests.packages.urllib3._collections (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from collections import MutableMapping
class RLock:
def __enter__(self): ...
def __exit__(self, exc_type, exc_value, traceback): ...
class RecentlyUsedContainer(MutableMapping):
ContainerCls = ... # type: Any
dispose_func = ... # type: Any
lock = ... # type: Any
def __init__(self, maxsize=..., dispose_func=...) -> None: ...
def __getitem__(self, key): ...
def __setitem__(self, key, value): ...
def __delitem__(self, key): ...
def __len__(self): ...
def __iter__(self): ...
def clear(self): ...
def keys(self): ...
class HTTPHeaderDict(dict):
def __init__(self, headers=..., **kwargs) -> None: ...
def __setitem__(self, key, val): ...
def __getitem__(self, key): ...
def __delitem__(self, key): ...
def __contains__(self, key): ...
def __eq__(self, other): ...
def __ne__(self, other): ...
values = ... # type: Any
get = ... # type: Any
update = ... # type: Any
iterkeys = ... # type: Any
itervalues = ... # type: Any
def pop(self, key, default=...): ...
def discard(self, key): ...
def add(self, key, val): ...
def extend(*args, **kwargs): ...
def getlist(self, key): ...
getheaders = ... # type: Any
getallmatchingheaders = ... # type: Any
iget = ... # type: Any
def copy(self): ...
def iteritems(self): ...
def itermerged(self): ...
def items(self): ...
@classmethod
def from_httplib(cls, message, duplicates=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/__init__.pyi 0000644 0000000 0000000 00000002042 13023631176 025027 0 ustar root root # Stubs for requests.packages.urllib3 (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import connectionpool
from . import filepost
from . import poolmanager
from . import response
from .util import request as _request
from .util import url
from .util import timeout
from .util import retry
import logging
__license__ = ... # type: Any
HTTPConnectionPool = connectionpool.HTTPConnectionPool
HTTPSConnectionPool = connectionpool.HTTPSConnectionPool
connection_from_url = connectionpool.connection_from_url
encode_multipart_formdata = filepost.encode_multipart_formdata
PoolManager = poolmanager.PoolManager
ProxyManager = poolmanager.ProxyManager
proxy_from_url = poolmanager.proxy_from_url
HTTPResponse = response.HTTPResponse
make_headers = _request.make_headers
get_host = url.get_host
Timeout = timeout.Timeout
Retry = retry.Retry
class NullHandler(logging.Handler):
def emit(self, record): ...
def add_stderr_logger(level=...): ...
def disable_warnings(category=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/connectionpool.pyi 0000644 0000000 0000000 00000006601 13023631176 026326 0 ustar root root # Stubs for requests.packages.urllib3.connectionpool (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import exceptions
from .packages import ssl_match_hostname
from . import packages
from .connection import (
HTTPException as HTTPException,
BaseSSLError as BaseSSLError,
ConnectionError as ConnectionError,
)
from . import request
from . import response
from . import connection
from .util import connection as _connection
from .util import retry
from .util import timeout
from .util import url
ClosedPoolError = exceptions.ClosedPoolError
ProtocolError = exceptions.ProtocolError
EmptyPoolError = exceptions.EmptyPoolError
HostChangedError = exceptions.HostChangedError
LocationValueError = exceptions.LocationValueError
MaxRetryError = exceptions.MaxRetryError
ProxyError = exceptions.ProxyError
ReadTimeoutError = exceptions.ReadTimeoutError
SSLError = exceptions.SSLError
TimeoutError = exceptions.TimeoutError
InsecureRequestWarning = exceptions.InsecureRequestWarning
CertificateError = ssl_match_hostname.CertificateError
port_by_scheme = connection.port_by_scheme
DummyConnection = connection.DummyConnection
HTTPConnection = connection.HTTPConnection
HTTPSConnection = connection.HTTPSConnection
VerifiedHTTPSConnection = connection.VerifiedHTTPSConnection
RequestMethods = request.RequestMethods
HTTPResponse = response.HTTPResponse
is_connection_dropped = _connection.is_connection_dropped
Retry = retry.Retry
Timeout = timeout.Timeout
get_host = url.get_host
xrange = ... # type: Any
log = ... # type: Any
class ConnectionPool:
scheme = ... # type: Any
QueueCls = ... # type: Any
host = ... # type: Any
port = ... # type: Any
def __init__(self, host, port=...) -> None: ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_val, exc_tb): ...
def close(self): ...
class HTTPConnectionPool(ConnectionPool, RequestMethods):
scheme = ... # type: Any
ConnectionCls = ... # type: Any
strict = ... # type: Any
timeout = ... # type: Any
retries = ... # type: Any
pool = ... # type: Any
block = ... # type: Any
proxy = ... # type: Any
proxy_headers = ... # type: Any
num_connections = ... # type: Any
num_requests = ... # type: Any
conn_kw = ... # type: Any
def __init__(self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., **conn_kw) -> None: ...
def close(self): ...
def is_same_host(self, url): ...
def urlopen(self, method, url, body=..., headers=..., retries=..., redirect=..., assert_same_host=..., timeout=..., pool_timeout=..., release_conn=..., **response_kw): ...
class HTTPSConnectionPool(HTTPConnectionPool):
scheme = ... # type: Any
ConnectionCls = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
cert_reqs = ... # type: Any
ca_certs = ... # type: Any
ssl_version = ... # type: Any
assert_hostname = ... # type: Any
assert_fingerprint = ... # type: Any
def __init__(self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., ssl_version=..., assert_hostname=..., assert_fingerprint=..., **conn_kw) -> None: ...
def connection_from_url(url, **kw): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/ 0000755 0000000 0000000 00000000000 13044320557 023525 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/__init__.pyi 0000644 0000000 0000000 00000001473 13023631176 026013 0 ustar root root # Stubs for requests.packages.urllib3.util (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from . import connection
from . import request
from . import response
from . import ssl_
from . import timeout
from . import retry
from . import url
import ssl
is_connection_dropped = connection.is_connection_dropped
make_headers = request.make_headers
is_fp_closed = response.is_fp_closed
SSLContext = ssl.SSLContext
HAS_SNI = ssl_.HAS_SNI
assert_fingerprint = ssl_.assert_fingerprint
resolve_cert_reqs = ssl_.resolve_cert_reqs
resolve_ssl_version = ssl_.resolve_ssl_version
ssl_wrap_socket = ssl_.ssl_wrap_socket
current_time = timeout.current_time
Timeout = timeout.Timeout
Retry = retry.Retry
get_host = url.get_host
parse_url = url.parse_url
split_first = url.split_first
Url = url.Url
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/connection.pyi 0000644 0000000 0000000 00000000533 13023631176 026407 0 ustar root root # Stubs for requests.packages.urllib3.util.connection (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
poll = ... # type: Any
select = ... # type: Any
def is_connection_dropped(conn): ...
def create_connection(address, timeout=..., source_address=..., socket_options=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/request.pyi 0000644 0000000 0000000 00000000571 13035744274 025751 0 ustar root root # Stubs for requests.packages.urllib3.util.request (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
# from ..packages import six
# b = six.b
ACCEPT_ENCODING = ... # type: Any
def make_headers(keep_alive=..., accept_encoding=..., user_agent=..., basic_auth=..., proxy_basic_auth=..., disable_cache=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/retry.pyi 0000644 0000000 0000000 00000002560 13023631176 025417 0 ustar root root # Stubs for requests.packages.urllib3.util.retry (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
from .. import packages
ConnectTimeoutError = exceptions.ConnectTimeoutError
MaxRetryError = exceptions.MaxRetryError
ProtocolError = exceptions.ProtocolError
ReadTimeoutError = exceptions.ReadTimeoutError
ResponseError = exceptions.ResponseError
log = ... # type: Any
class Retry:
DEFAULT_METHOD_WHITELIST = ... # type: Any
BACKOFF_MAX = ... # type: Any
total = ... # type: Any
connect = ... # type: Any
read = ... # type: Any
redirect = ... # type: Any
status_forcelist = ... # type: Any
method_whitelist = ... # type: Any
backoff_factor = ... # type: Any
raise_on_redirect = ... # type: Any
def __init__(self, total=..., connect=..., read=..., redirect=..., method_whitelist=..., status_forcelist=..., backoff_factor=..., raise_on_redirect=..., _observed_errors=...) -> None: ...
def new(self, **kw): ...
@classmethod
def from_int(cls, retries, redirect=..., default=...): ...
def get_backoff_time(self): ...
def sleep(self): ...
def is_forced_retry(self, method, status_code): ...
def is_exhausted(self): ...
def increment(self, method=..., url=..., response=..., error=..., _pool=..., _stacktrace=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/response.pyi 0000644 0000000 0000000 00000000253 13023631176 026105 0 ustar root root # Stubs for requests.packages.urllib3.util.response (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
def is_fp_closed(obj): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/url.pyi 0000644 0000000 0000000 00000001222 13023631176 025046 0 ustar root root # Stubs for requests.packages.urllib3.util.url (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
LocationParseError = exceptions.LocationParseError
url_attrs = ... # type: Any
class Url:
slots = ... # type: Any
def __new__(cls, scheme=..., auth=..., host=..., port=..., path=..., query=..., fragment=...): ...
@property
def hostname(self): ...
@property
def request_uri(self): ...
@property
def netloc(self): ...
@property
def url(self): ...
def split_first(s, delims): ...
def parse_url(url): ...
def get_host(url): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/timeout.pyi 0000644 0000000 0000000 00000001235 13023631176 025736 0 ustar root root # Stubs for requests.packages.urllib3.util.timeout (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
TimeoutStateError = exceptions.TimeoutStateError
def current_time(): ...
class Timeout:
DEFAULT_TIMEOUT = ... # type: Any
total = ... # type: Any
def __init__(self, total=..., connect=..., read=...) -> None: ...
@classmethod
def from_float(cls, timeout): ...
def clone(self): ...
def start_connect(self): ...
def get_connect_duration(self): ...
@property
def connect_timeout(self): ...
@property
def read_timeout(self): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/util/ssl_.pyi 0000644 0000000 0000000 00000001561 13023631176 025212 0 ustar root root # Stubs for requests.packages.urllib3.util.ssl_ (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .. import exceptions
import ssl
SSLError = exceptions.SSLError
InsecurePlatformWarning = exceptions.InsecurePlatformWarning
SSLContext = ssl.SSLContext
HAS_SNI = ... # type: Any
create_default_context = ... # type: Any
OP_NO_SSLv2 = ... # type: Any
OP_NO_SSLv3 = ... # type: Any
OP_NO_COMPRESSION = ... # type: Any
def assert_fingerprint(cert, fingerprint): ...
def resolve_cert_reqs(candidate): ...
def resolve_ssl_version(candidate): ...
def create_urllib3_context(ssl_version=..., cert_reqs=..., options=..., ciphers=...): ...
def ssl_wrap_socket(sock, keyfile=..., certfile=..., cert_reqs=..., ca_certs=...,
server_hostname=..., ssl_version=..., ciphers=..., ssl_context=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/connection.pyi 0000644 0000000 0000000 00000004226 13035744274 025444 0 ustar root root # Stubs for requests.packages.urllib3.connection (Python 3.4)
from typing import Any
from . import packages
from http.client import HTTPConnection as _HTTPConnection
import ssl
# from httplib import HTTPConnection as _HTTPConnection # python 2
from . import exceptions
from .packages import ssl_match_hostname
from .util import ssl_
from . import util
import http.client
class DummyConnection: ...
BaseSSLError = ssl.SSLError
ConnectionError = __builtins__.ConnectionError
HTTPException = http.client.HTTPException
ConnectTimeoutError = exceptions.ConnectTimeoutError
SystemTimeWarning = exceptions.SystemTimeWarning
SecurityWarning = exceptions.SecurityWarning
match_hostname = ssl_match_hostname.match_hostname
resolve_cert_reqs = ssl_.resolve_cert_reqs
resolve_ssl_version = ssl_.resolve_ssl_version
ssl_wrap_socket = ssl_.ssl_wrap_socket
assert_fingerprint = ssl_.assert_fingerprint
connection = util.connection
port_by_scheme = ... # type: Any
RECENT_DATE = ... # type: Any
class HTTPConnection(_HTTPConnection):
default_port = ... # type: Any
default_socket_options = ... # type: Any
is_verified = ... # type: Any
source_address = ... # type: Any
socket_options = ... # type: Any
def __init__(self, *args, **kw) -> None: ...
def connect(self): ...
class HTTPSConnection(HTTPConnection):
default_port = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
def __init__(self, host, port=..., key_file=..., cert_file=..., strict=..., timeout=..., **kw) -> None: ...
sock = ... # type: Any
def connect(self): ...
class VerifiedHTTPSConnection(HTTPSConnection):
cert_reqs = ... # type: Any
ca_certs = ... # type: Any
ssl_version = ... # type: Any
assert_fingerprint = ... # type: Any
key_file = ... # type: Any
cert_file = ... # type: Any
assert_hostname = ... # type: Any
def set_cert(self, key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., assert_hostname=..., assert_fingerprint=...): ...
sock = ... # type: Any
auto_open = ... # type: Any
is_verified = ... # type: Any
def connect(self): ...
UnverifiedHTTPSConnection = ... # type: Any
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/request.pyi 0000644 0000000 0000000 00000001240 13023631176 024757 0 ustar root root # Stubs for requests.packages.urllib3.request (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class RequestMethods:
headers = ... # type: Any
def __init__(self, headers=...) -> None: ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
def request(self, method, url, fields=..., headers=..., **urlopen_kw): ...
def request_encode_url(self, method, url, fields=..., **urlopen_kw): ...
def request_encode_body(self, method, url, fields=..., headers=..., encode_multipart=..., multipart_boundary=..., **urlopen_kw): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/poolmanager.pyi 0000644 0000000 0000000 00000002760 13023631176 025603 0 ustar root root # Stubs for requests.packages.urllib3.poolmanager (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .request import RequestMethods
class PoolManager(RequestMethods):
proxy = ... # type: Any
connection_pool_kw = ... # type: Any
pools = ... # type: Any
def __init__(self, num_pools=..., headers=..., **connection_pool_kw) -> None: ...
def __enter__(self): ...
def __exit__(self, exc_type, exc_val, exc_tb): ...
def clear(self): ...
def connection_from_host(self, host, port=..., scheme=...): ...
def connection_from_url(self, url): ...
# TODO: This was the original signature -- copied another one from base class to fix complaint.
# def urlopen(self, method, url, redirect=True, **kw): ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
class ProxyManager(PoolManager):
proxy = ... # type: Any
proxy_headers = ... # type: Any
def __init__(self, proxy_url, num_pools=..., headers=..., proxy_headers=..., **connection_pool_kw) -> None: ...
def connection_from_host(self, host, port=..., scheme=...): ...
# TODO: This was the original signature -- copied another one from base class to fix complaint.
# def urlopen(self, method, url, redirect=True, **kw): ...
def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ...
def proxy_from_url(url, **kw): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/fields.pyi 0000644 0000000 0000000 00000001050 13023631176 024534 0 ustar root root # Stubs for requests.packages.urllib3.fields (Python 3.4)
from typing import Any
from . import packages
def guess_content_type(filename, default=...): ...
def format_header_param(name, value): ...
class RequestField:
data = ... # type: Any
headers = ... # type: Any
def __init__(self, name, data, filename=..., headers=...) -> None: ...
@classmethod
def from_tuples(cls, fieldname, value): ...
def render_headers(self): ...
def make_multipart(self, content_disposition=..., content_type=..., content_location=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/filepost.pyi 0000644 0000000 0000000 00000000740 13035744274 025127 0 ustar root root # Stubs for requests.packages.urllib3.filepost (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from . import packages
# from .packages import six
from . import fields
# six = packages.six
# b = six.b
RequestField = fields.RequestField
writer = ... # type: Any
def choose_boundary(): ...
def iter_field_objects(fields): ...
def iter_fields(fields): ...
def encode_multipart_formdata(fields, boundary=...): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/response.pyi 0000644 0000000 0000000 00000003700 13035744274 025137 0 ustar root root # Stubs for requests.packages.urllib3.response (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
import io
from . import _collections
from . import exceptions
# from .packages import six
from .connection import HTTPException as HTTPException, BaseSSLError as BaseSSLError
from .util import response
HTTPHeaderDict = _collections.HTTPHeaderDict
ProtocolError = exceptions.ProtocolError
DecodeError = exceptions.DecodeError
ReadTimeoutError = exceptions.ReadTimeoutError
binary_type = bytes # six.binary_type
PY3 = True # six.PY3
is_fp_closed = response.is_fp_closed
class DeflateDecoder:
def __init__(self) -> None: ...
def __getattr__(self, name): ...
def decompress(self, data): ...
class GzipDecoder:
def __init__(self) -> None: ...
def __getattr__(self, name): ...
def decompress(self, data): ...
class HTTPResponse(io.IOBase):
CONTENT_DECODERS = ... # type: Any
REDIRECT_STATUSES = ... # type: Any
headers = ... # type: Any
status = ... # type: Any
version = ... # type: Any
reason = ... # type: Any
strict = ... # type: Any
decode_content = ... # type: Any
def __init__(self, body=..., headers=..., status=..., version=..., reason=..., strict=..., preload_content=..., decode_content=..., original_response=..., pool=..., connection=...) -> None: ...
def get_redirect_location(self): ...
def release_conn(self): ...
@property
def data(self): ...
def tell(self): ...
def read(self, amt=..., decode_content=..., cache_content=...): ...
def stream(self, amt=..., decode_content=...): ...
@classmethod
def from_httplib(ResponseCls, r, **response_kw): ...
def getheaders(self): ...
def getheader(self, name, default=...): ...
def close(self): ...
@property
def closed(self): ...
def fileno(self): ...
def flush(self): ...
def readable(self): ...
def readinto(self, b): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/ 0000755 0000000 0000000 00000000000 13044320557 024326 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/__init__.pyi 0000644 0000000 0000000 00000000212 13035744274 026611 0 ustar root root # Stubs for requests.packages.urllib3.packages (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/ssl_match_hostname/ 0000755 0000000 0000000 00000000000 13044320557 030201 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/ssl_match_hostname/__init__.pyi0000644 0000000 0000000 00000000366 13023631176 032467 0 ustar root root # Stubs for requests.packages.urllib3.packages.ssl_match_hostname (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
import ssl
CertificateError = ssl.CertificateError
match_hostname = ssl.match_hostname
././@LongLink 0000644 0000000 0000000 00000000154 00000000000 011603 L ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/ssl_match_hostname/_implementation.pyi mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/packages/ssl_match_hostname/_implementat0000644 0000000 0000000 00000000377 13023631176 032610 0 ustar root root # Stubs for requests.packages.urllib3.packages.ssl_match_hostname._implementation (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
class CertificateError(ValueError): ...
def match_hostname(cert, hostname): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/exceptions.pyi 0000644 0000000 0000000 00000003202 13023631176 025450 0 ustar root root # Stubs for requests.packages.urllib3.exceptions (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
class HTTPError(Exception): ...
class HTTPWarning(Warning): ...
class PoolError(HTTPError):
pool = ... # type: Any
def __init__(self, pool, message) -> None: ...
def __reduce__(self): ...
class RequestError(PoolError):
url = ... # type: Any
def __init__(self, pool, url, message) -> None: ...
def __reduce__(self): ...
class SSLError(HTTPError): ...
class ProxyError(HTTPError): ...
class DecodeError(HTTPError): ...
class ProtocolError(HTTPError): ...
ConnectionError = ... # type: Any
class MaxRetryError(RequestError):
reason = ... # type: Any
def __init__(self, pool, url, reason=...) -> None: ...
class HostChangedError(RequestError):
retries = ... # type: Any
def __init__(self, pool, url, retries=...) -> None: ...
class TimeoutStateError(HTTPError): ...
class TimeoutError(HTTPError): ...
class ReadTimeoutError(TimeoutError, RequestError): ...
class ConnectTimeoutError(TimeoutError): ...
class EmptyPoolError(PoolError): ...
class ClosedPoolError(PoolError): ...
class LocationValueError(ValueError, HTTPError): ...
class LocationParseError(LocationValueError):
location = ... # type: Any
def __init__(self, location) -> None: ...
class ResponseError(HTTPError):
GENERIC_ERROR = ... # type: Any
SPECIFIC_ERROR = ... # type: Any
class SecurityWarning(HTTPWarning): ...
class InsecureRequestWarning(SecurityWarning): ...
class SystemTimeWarning(SecurityWarning): ...
class InsecurePlatformWarning(SecurityWarning): ...
mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/contrib/ 0000755 0000000 0000000 00000000000 13044320557 024210 5 ustar root root mypy-0.470/typeshed/third_party/3/requests/packages/urllib3/contrib/__init__.pyi 0000644 0000000 0000000 00000000211 13035744274 026472 0 ustar root root # Stubs for requests.packages.urllib3.contrib (Python 3.4)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
mypy-0.470/typeshed/third_party/3/requests/models.pyi 0000644 0000000 0000000 00000011373 13035744274 021437 0 ustar root root # Stubs for requests.models (Python 3)
from typing import Any, List, MutableMapping, Iterator, Dict
import datetime
from . import hooks
from . import structures
from . import auth
from . import cookies
from .cookies import RequestsCookieJar
from .packages.urllib3 import fields
from .packages.urllib3 import filepost
from .packages.urllib3 import util
from .packages.urllib3 import exceptions as urllib3_exceptions
from . import exceptions
from . import utils
from . import compat
from . import status_codes
from typing import Optional, Union
default_hooks = hooks.default_hooks
CaseInsensitiveDict = structures.CaseInsensitiveDict
HTTPBasicAuth = auth.HTTPBasicAuth
cookiejar_from_dict = cookies.cookiejar_from_dict
get_cookie_header = cookies.get_cookie_header
RequestField = fields.RequestField
encode_multipart_formdata = filepost.encode_multipart_formdata
parse_url = util.parse_url
DecodeError = urllib3_exceptions.DecodeError
ReadTimeoutError = urllib3_exceptions.ReadTimeoutError
ProtocolError = urllib3_exceptions.ProtocolError
LocationParseError = urllib3_exceptions.LocationParseError
HTTPError = exceptions.HTTPError
MissingSchema = exceptions.MissingSchema
InvalidURL = exceptions.InvalidURL
ChunkedEncodingError = exceptions.ChunkedEncodingError
ContentDecodingError = exceptions.ContentDecodingError
ConnectionError = exceptions.ConnectionError
StreamConsumedError = exceptions.StreamConsumedError
guess_filename = utils.guess_filename
get_auth_from_url = utils.get_auth_from_url
requote_uri = utils.requote_uri
stream_decode_response_unicode = utils.stream_decode_response_unicode
to_key_val_list = utils.to_key_val_list
parse_header_links = utils.parse_header_links
iter_slices = utils.iter_slices
guess_json_utf = utils.guess_json_utf
super_len = utils.super_len
to_native_string = utils.to_native_string
codes = status_codes.codes
REDIRECT_STATI = ... # type: Any
DEFAULT_REDIRECT_LIMIT = ... # type: Any
CONTENT_CHUNK_SIZE = ... # type: Any
ITER_CHUNK_SIZE = ... # type: Any
json_dumps = ... # type: Any
class RequestEncodingMixin:
@property
def path_url(self): ...
class RequestHooksMixin:
def register_hook(self, event, hook): ...
def deregister_hook(self, event, hook): ...
class Request(RequestHooksMixin):
hooks = ... # type: Any
method = ... # type: Any
url = ... # type: Any
headers = ... # type: Any
files = ... # type: Any
data = ... # type: Any
json = ... # type: Any
params = ... # type: Any
auth = ... # type: Any
cookies = ... # type: Any
def __init__(self, method=..., url=..., headers=..., files=..., data=..., params=...,
auth=..., cookies=..., hooks=..., json=...): ...
def prepare(self): ...
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
method = ... # type: Optional[str]
url = ... # type: Optional[str]
headers = ... # type: CaseInsensitiveDict
body = ... # type: Optional[Union[str, bytes]]
hooks = ... # type: Any
def __init__(self) -> None: ...
def prepare(self, method=..., url=..., headers=..., files=..., data=..., params=...,
auth=..., cookies=..., hooks=..., json=...): ...
def copy(self): ...
def prepare_method(self, method): ...
def prepare_url(self, url, params): ...
def prepare_headers(self, headers): ...
def prepare_body(self, data, files, json=...): ...
def prepare_content_length(self, body): ...
def prepare_auth(self, auth, url=...): ...
def prepare_cookies(self, cookies): ...
def prepare_hooks(self, hooks): ...
class Response:
__attrs__ = ... # type: Any
status_code = ... # type: int
headers = ... # type: MutableMapping[str, str]
raw = ... # type: Any
url = ... # type: str
encoding = ... # type: str
history = ... # type: List[Response]
reason = ... # type: str
cookies = ... # type: RequestsCookieJar
elapsed = ... # type: datetime.timedelta
request = ... # type: PreparedRequest
def __init__(self) -> None: ...
def __bool__(self) -> bool: ...
def __nonzero__(self) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
@property
def ok(self) -> bool: ...
@property
def is_redirect(self) -> bool: ...
@property
def is_permanent_redirect(self) -> bool: ...
@property
def apparent_encoding(self) -> str: ...
def iter_content(self, chunk_size: int = ...,
decode_unicode: bool = ...) -> Iterator[Any]: ...
def iter_lines(self, chunk_size=..., decode_unicode=..., delimiter=...): ...
@property
def content(self) -> bytes: ...
@property
def text(self) -> str: ...
def json(self, **kwargs) -> Any: ...
@property
def links(self) -> Dict[Any, Any]: ...
def raise_for_status(self) -> None: ...
def close(self) -> None: ...
mypy-0.470/typeshed/third_party/3/requests/status_codes.pyi 0000644 0000000 0000000 00000000320 13023631176 022633 0 ustar root root # Stubs for requests.status_codes (Python 3)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from typing import Any
from .structures import LookupDict
codes = ... # type: Any
mypy-0.470/typeshed/third_party/3/requests/exceptions.pyi 0000644 0000000 0000000 00000002007 13023631176 022320 0 ustar root root # Stubs for requests.exceptions (Python 3)
from typing import Any
from .packages.urllib3.exceptions import HTTPError as BaseHTTPError
class RequestException(IOError):
response = ... # type: Any
request = ... # type: Any
def __init__(self, *args, **kwargs) -> None: ...
class HTTPError(RequestException): ...
class ConnectionError(RequestException): ...
class ProxyError(ConnectionError): ...
class SSLError(ConnectionError): ...
class Timeout(RequestException): ...
class ConnectTimeout(ConnectionError, Timeout): ...
class ReadTimeout(Timeout): ...
class URLRequired(RequestException): ...
class TooManyRedirects(RequestException): ...
class MissingSchema(RequestException, ValueError): ...
class InvalidSchema(RequestException, ValueError): ...
class InvalidURL(RequestException, ValueError): ...
class ChunkedEncodingError(RequestException): ...
class ContentDecodingError(RequestException, BaseHTTPError): ...
class StreamConsumedError(RequestException, TypeError): ...
class RetryError(RequestException): ...
mypy-0.470/typeshed/third_party/3/requests/hooks.pyi 0000644 0000000 0000000 00000000252 13023631176 021262 0 ustar root root # Stubs for requests.hooks (Python 3)
from typing import Any
HOOKS = ... # type: Any
def default_hooks(): ...
def dispatch_hook(key, hooks, hook_data, **kwargs): ...
mypy-0.470/typeshed/third_party/3/pkg_resources.pyi 0000644 0000000 0000000 00000031172 13035744274 021153 0 ustar root root # Stubs for pkg_resources (Python 3.4)
from typing import (
Any, Callable, Dict, IO, Iterable, Generator, Optional, Sequence, Tuple,
List, Union,
TypeVar, overload,
)
import importlib.abc
import sys
import types
import zipimport
_T = TypeVar('_T')
_NestedStr = Union[str, Iterable[Union[str, Iterable[Any]]]]
_InstallerType = Callable[[Requirement], Optional[Distribution]]
_EPDistType = Union[Distribution, Requirement, str]
_MetadataType = Optional[IResourceProvider]
_PkgReqType = Union[str, Requirement]
_DistFinderType = Callable[[str, _Importer, bool],
Generator[Distribution, None, None]]
_NSHandlerType = Callable[[_Importer, str, str, types.ModuleType], str]
def declare_namespace(name: str) -> None: ...
def fixup_namespace_packages(path_item: str) -> None: ...
class WorkingSet:
entries = ... # type: List[str]
def __init__(self, entries: Optional[Iterable[str]] = ...) -> None: ...
def require(self, *requirements: _NestedStr) -> Sequence[Distribution]: ...
def run_script(self, requires: str, script_name: str) -> None: ...
def iter_entry_points(self, group: str, name: Optional[str] = ...) \
-> Generator[EntryPoint, None, None]: ...
def add_entry(self, entry: str) -> None: ...
def __contains__(self, dist: Distribution) -> bool: ...
def __iter__(self) -> Generator[Distribution, None, None]: ...
def find(self, req: Requirement) -> Optional[Distribution]: ...
def resolve(self, requirements: Sequence[Requirement],
env: Optional[Environment] = ...,
installer: Optional[_InstallerType] = ...) \
-> List[Distribution]: ...
def add(self, dist: Distribution, entry: Optional[str] = ...,
insert: bool = ..., replace: bool = ...) -> None: ...
def subscribe(self, callback: Callable[[Distribution], None]) -> None: ...
def find_plugins(self, plugin_env: Environment,
full_env: Optional[Environment] = ...,
fallback: bool = ...) \
-> Tuple[List[Distribution],
Dict[Distribution, Exception]]: ...
working_set = ... # type: WorkingSet
def require(
*requirements: Union[str, Sequence[str]]
) -> Sequence[Distribution]: ...
def run_script(requires: str, script_name: str) -> None: ...
def iter_entry_points(
group: str, name: Optional[str] = ...
) -> Generator[EntryPoint, None, None]: ...
def add_activation_listener(
callback: Callable[[Distribution], None]
) -> None: ...
class Environment:
def __init__(self, search_path: Optional[Sequence[str]] = ...,
platform: Optional[str] = ...,
python: Optional[str] = ...) -> None: ...
def __getitem__(self, project_name: str) -> List[Distribution]: ...
def __iter__(self) -> Generator[str, None, None]: ...
def add(self, dist: Distribution) -> None: ...
def remove(self, dist: Distribution) -> None: ...
def can_add(self, dist: Distribution) -> bool: ...
def __add__(self,
other: Union[Distribution, Environment]) -> Environment: ...
def __iadd__(self,
other: Union[Distribution, Environment]) -> Environment: ...
@overload
def best_match(self, req: Requirement, working_set: WorkingSet) -> Distribution: ...
@overload
def best_match(self, req: Requirement, working_set: WorkingSet,
installer: Callable[[Requirement], _T] = ...) -> _T: ...
@overload
def obtain(self, requirement: Requirement) -> None: ...
@overload
def obtain(self, requirement: Requirement,
installer: Callable[[Requirement], _T] = ...) -> _T: ...
def scan(self, search_path: Optional[Sequence[str]] = ...) -> None: ...
def parse_requirements(strs: Union[str, Iterable[str]]) -> Generator[Requirement, None, None]: ...
class Requirement:
project_name = ... # type: str
key = ... # type: str
extras = ... # type: Tuple[str, ...]
specs = ... # type: List[Tuple[str, str]]
@staticmethod
def parse(s: Union[str, Iterable[str]]) -> Requirement: ...
def __contains__(self,
item: Union[Distribution, str, Tuple[str, ...]]) \
-> bool: ...
def __eq__(self, other_requirement: Any) -> bool: ...
def load_entry_point(dist: _EPDistType, group: str, name: str) -> None: ...
def get_entry_info(dist: _EPDistType, group: str,
name: str) -> Optional[EntryPoint]: ...
@overload
def get_entry_map(dist: _EPDistType) -> Dict[str, Dict[str, EntryPoint]]: ...
@overload
def get_entry_map(dist: _EPDistType, group: str = ...) -> Dict[str, EntryPoint]: ...
class EntryPoint:
name = ... # type: str
module_name = ... # type: str
attrs = ... # type: Tuple[str, ...]
extras = ... # type: Tuple[str, ...]
dist = ... # type: Optional[Distribution]
def __init__(self, name: str, module_name: str,
attrs: Tuple[str, ...] = ..., extras: Tuple[str, ...] = ...,
dist: Optional[Distribution] = ...) -> None: ...
@classmethod
def parse(cls, src: str, dist: Optional[Distribution] = ...) -> EntryPoint: ...
@classmethod
def parse_group(cls, group: str, lines: Union[str, Sequence[str]],
dist: Optional[Distribution] = ...) -> Dict[str, EntryPoint]: ...
@classmethod
def parse_map(cls, data: Union[Dict[str, Union[str, Sequence[str]]],
str, Sequence[str]],
dist: Optional[Distribution] = ...) -> Dict[str, EntryPoint]: ...
def load(self, require: bool = ..., env: Optional[Environment] = ...,
installer: Optional[_InstallerType] = ...) -> Any: ...
def require(self, env: Optional[Environment] = ...,
installer: Optional[_InstallerType] = ...) -> None: ...
def find_distributions(
path_item: str, only: bool = ...
) -> Generator[Distribution, None, None]: ...
def get_distribution(dist: Union[Requirement, str, Distribution]) -> Distribution: ...
class Distribution(IResourceProvider, IMetadataProvider):
location = ... # type: str
project_name = ... # type: str
key = ... # type: str
extras = ... # type: List[str]
version = ... # type: str
parsed_version = ... # type: Tuple[str, ...]
py_version = ... # type: str
platform = ... # type: Optional[str]
precedence = ... # type: int
def __init__(self, location: Optional[str] = ...,
metadata: Optional[str] = ...,
project_name: Optional[str] = ...,
version: Optional[str] = ..., py_version: str = ...,
platform: Optional[str] = ...,
precedence: int = ...) -> None: ...
@classmethod
def from_location(cls, location: str, basename: str,
metadata: Optional[str] = ...,
**kw: Union[str, None, int]) -> Distribution: ...
@classmethod
def from_filename(cls, filename: str, metadata: Optional[str] = ...,
**kw: Union[str, None, int]) -> Distribution: ...
def activate(self, path: Optional[List[str]] = ...) -> None: ...
def as_requirement(self) -> Requirement: ...
def requires(self, extras: Tuple[str, ...] = ...) -> List[Requirement]: ...
def clone(self, **kw: Union[str, int, None]) -> Requirement: ...
def egg_name(self) -> str: ...
def __cmp__(self, other: Any) -> bool: ...
def get_entry_info(dist: _EPDistType, group: str,
name: str) -> Optional[EntryPoint]: ...
@overload
def get_entry_map(dist: _EPDistType) \
-> Dict[str, Dict[str, EntryPoint]]: ...
@overload
def get_entry_map(dist: _EPDistType, group: str = ...) \
-> Dict[str, EntryPoint]: ...
def load_entry_point(dist: _EPDistType, group: str, name: str) -> None: ...
EGG_DIST = ... # type: int
BINARY_DIST = ... # type: int
SOURCE_DIST = ... # type: int
CHECKOUT_DIST = ... # type: int
DEVELOP_DIST = ... # type: int
def resource_exists(package_or_requirement: _PkgReqType,
resource_name: str) -> bool: ...
def resource_stream(package_or_requirement: _PkgReqType,
resource_name: str) -> IO[bytes]: ...
def resource_string(package_or_requirement: _PkgReqType,
resource_name: str) -> bytes: ...
def resource_isdir(package_or_requirement: _PkgReqType,
resource_name: str) -> bool: ...
def resource_listdir(package_or_requirement: _PkgReqType,
resource_name: str) -> List[str]: ...
def resource_filename(package_or_requirement: _PkgReqType,
resource_name: str) -> str: ...
def set_extraction_path(path: str) -> None: ...
def cleanup_resources(force: bool = ...) -> List[str]: ...
class IResourceManager:
def resource_exists(self, package_or_requirement: _PkgReqType,
resource_name: str) -> bool: ...
def resource_stream(self, package_or_requirement: _PkgReqType,
resource_name: str) -> IO[bytes]: ...
def resource_string(self, package_or_requirement: _PkgReqType,
resource_name: str) -> bytes: ...
def resource_isdir(self, package_or_requirement: _PkgReqType,
resource_name: str) -> bool: ...
def resource_listdir(self, package_or_requirement: _PkgReqType,
resource_name: str) -> List[str]: ...
def resource_filename(self, package_or_requirement: _PkgReqType,
resource_name: str) -> str: ...
def set_extraction_path(self, path: str) -> None: ...
def cleanup_resources(self, force: bool = ...) -> List[str]: ...
def get_cache_path(self, archive_name: str,
names: Tuple[str, ...] = ...) -> str: ...
def extraction_error(self) -> None: ...
def postprocess(self, tempname: str, filename: str) -> None: ...
@overload
def get_provider(package_or_requirement: str) -> IResourceProvider: ...
@overload
def get_provider(package_or_requirement: Requirement) -> Distribution: ...
class IMetadataProvider:
def has_metadata(self, name: str) -> bool: ...
def metadata_isdir(self, name: str) -> bool: ...
def metadata_listdir(self, name: str) -> List[str]: ...
def get_metadata(self, name: str) -> str: ...
def get_metadata_lines(self, name: str) -> Generator[List[str], None, None]: ...
def run_script(self, script_name: str, namespace: Dict[str, Any]) -> None: ...
class ResolutionError(Exception): ...
class DistributionNotFound(ResolutionError): ...
class VersionConflict(ResolutionError): ...
class UnknownExtra(ResolutionError): ...
class ExtractionError(Exception):
manager = ... # type: IResourceManager
cache_path = ... # type: str
original_error = ... # type: Exception
if sys.version_info >= (3, 3):
class _Importer(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader): ...
else:
class _Importer(importlib.abc.InspectLoader): ...
def register_finder(importer_type: type,
distribution_finder: _DistFinderType) -> None: ...
def register_loader_type(
loader_type: type,
provider_factory: Callable[[types.ModuleType], IResourceProvider]
) -> None: ...
def register_namespace_handler(importer_type: type,
namespace_handler: _NSHandlerType) -> None: ...
class IResourceProvider(IMetadataProvider): ...
class NullProvider: ...
class EggProvider(NullProvider): ...
class DefaultProvider(EggProvider): ...
class PathMetadata(DefaultProvider, IResourceProvider):
def __init__(self, path: str, egg_info: str) -> None: ...
class ZipProvider(EggProvider): ...
class EggMetadata(ZipProvider, IResourceProvider):
def __init__(self, zipimporter: zipimport.zipimporter) -> None: ...
class EmptyProvider(NullProvider): ...
empty_provider = ... # type: EmptyProvider
class FileMetadata(EmptyProvider, IResourceProvider):
def __init__(self, path_to_pkg_info: str) -> None: ...
def parse_version(v: str) -> Tuple[str, ...]: ...
def yield_lines(strs: _NestedStr) -> Generator[str, None, None]: ...
def split_sections(
strs: _NestedStr
) -> Generator[Tuple[Optional[str], str], None, None]: ...
def safe_name(name: str) -> str: ...
def safe_version(version: str) -> str: ...
def safe_extra(extra: str) -> str: ...
def to_filename(name_or_version: str) -> str: ...
def get_build_platform() -> str: ...
def get_platform() -> str: ...
def get_supported_platform() -> str: ...
def compatible_platforms(provided: Optional[str],
required: Optional[str]) -> bool: ...
def get_default_cache() -> str: ...
def get_importer(path_item: str) -> _Importer: ...
def ensure_directory(path: str) -> None: ...
def normalize_path(filename: str) -> str: ...
mypy-0.470/typeshed/third_party/3/six/ 0000755 0000000 0000000 00000000000 13044320557 016346 5 ustar root root mypy-0.470/typeshed/third_party/3/six/__init__.pyi 0000644 0000000 0000000 00000006213 13035744274 020640 0 ustar root root # Stubs for six (Python 3.5)
from __future__ import print_function
from typing import (
Any,
AnyStr,
Callable,
Dict,
ItemsView,
Iterable,
KeysView,
Mapping,
Optional,
Pattern,
Tuple,
Type,
TypeVar,
Union,
ValuesView,
overload,
)
import types
import typing
import unittest
from mypy_extensions import NoReturn
# Exports
from io import StringIO as StringIO, BytesIO as BytesIO
from builtins import next as next
from functools import wraps as wraps
_T = TypeVar('_T')
_K = TypeVar('_K')
_V = TypeVar('_V')
# TODO make constant, then move this stub to 2and3
# https://github.com/python/typeshed/issues/17
PY2 = False
PY3 = True
PY34 = ... # type: bool
string_types = str,
integer_types = int,
class_types = type,
text_type = str
binary_type = bytes
MAXSIZE = ... # type: int
# def add_move
# def remove_move
def callable(obj: object) -> bool: ...
def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ...
def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ...
def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ...
Iterator = object
def get_method_function(meth: types.MethodType) -> types.FunctionType: ...
def get_method_self(meth: types.MethodType) -> Optional[object]: ...
def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ...
def get_function_code(fun: types.FunctionType) -> types.CodeType: ...
def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ...
def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ...
def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ...
def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ...
def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ...
# def iterlists
def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ...
def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ...
def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ...
def b(s: str) -> binary_type: ...
def u(s: str) -> text_type: ...
unichr = chr
def int2byte(i: int) -> bytes: ...
def byte2int(bs: binary_type) -> int: ...
def indexbytes(buf: binary_type, i: int) -> int: ...
def iterbytes(buf: binary_type) -> typing.Iterator[int]: ...
def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: str = None) -> None: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, msg: str = None) -> Any: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
def assertRegex(self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: str = None) -> None: ...
exec_ = exec
def reraise(tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = None) -> NoReturn: ...
def raise_from(value: BaseException, from_value: BaseException) -> None: ...
print_ = print
def with_metaclass(meta: type, *bases: type) -> type: ...
def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ...
def python_2_unicode_compatible(klass: _T) -> _T: ...
mypy-0.470/typeshed/third_party/3/six/moves/ 0000755 0000000 0000000 00000000000 13044320557 017477 5 ustar root root mypy-0.470/typeshed/third_party/3/six/moves/__init__.pyi 0000644 0000000 0000000 00000002310 13023631176 021754 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves (Python 3.2)
from http import cookies as http_cookies
from io import StringIO as cStringIO
from builtins import filter as filter
from itertools import filterfalse as filterfalse
from builtins import input as input
from sys import intern as intern
from builtins import map as map
from os import getcwd as getcwd
from os import getcwdb as getcwdb
from builtins import range as range
from imp import reload as reload_module
from functools import reduce as reduce
from shlex import quote as shlex_quote
from io import StringIO as StringIO
from collections import UserDict as UserDict
from collections import UserList as UserList
from collections import UserString as UserString
from builtins import range as xrange
from builtins import zip as zip
from itertools import zip_longest as zip_longest
import six.moves.cPickle as cPickle
import html.parser as html_parser
import html.entities as html_entities
import http.client as http_client
import six.moves.urllib_parse as urllib_parse
import six.moves.urllib_error as urllib_error
import six.moves.urllib as urllib
import six.moves.urllib_robotparser as urllib_robotparser
mypy-0.470/typeshed/third_party/3/six/moves/urllib_robotparser.pyi 0000644 0000000 0000000 00000000336 13023631176 024136 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_robotparser (Python 3.2)
from six.moves.urllib.robotparser import (
RobotFileParser as RobotFileParser,
)
mypy-0.470/typeshed/third_party/3/six/moves/urllib_response.pyi 0000644 0000000 0000000 00000000077 13023631176 023434 0 ustar root root from six.moves.urllib.response import addinfourl as addinfourl
mypy-0.470/typeshed/third_party/3/six/moves/urllib_request.pyi 0000644 0000000 0000000 00000003025 13023631176 023262 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_request (Python 3.2)
from six.moves.urllib.request import (
install_opener as install_opener,
build_opener as build_opener,
BaseHandler as BaseHandler,
OpenerDirector as OpenerDirector,
HTTPRedirectHandler as HTTPRedirectHandler,
# urlopen as urlopen,
# pathname2url as pathname2url,
# url2pathname as url2pathname,
# getproxies as getproxies,
# Request as Request,
# HTTPDefaultErrorHandler as HTTPDefaultErrorHandler,
# HTTPCookieProcessor as HTTPCookieProcessor,
# ProxyHandler as ProxyHandler,
# HTTPPasswordMgr as HTTPPasswordMgr,
# HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm,
# AbstractBasicAuthHandler as AbstractBasicAuthHandler,
# HTTPBasicAuthHandler as HTTPBasicAuthHandler,
# ProxyBasicAuthHandler as ProxyBasicAuthHandler,
# AbstractDigestAuthHandler as AbstractDigestAuthHandler,
# HTTPDigestAuthHandler as HTTPDigestAuthHandler,
# ProxyDigestAuthHandler as ProxyDigestAuthHandler,
# HTTPHandler as HTTPHandler,
# HTTPSHandler as HTTPSHandler,
# FileHandler as FileHandler,
# FTPHandler as FTPHandler,
# CacheFTPHandler as CacheFTPHandler,
# UnknownHandler as UnknownHandler,
# HTTPErrorProcessor as HTTPErrorProcessor,
# urlretrieve as urlretrieve,
# urlcleanup as urlcleanup,
# URLopener as URLopener,
# FancyURLopener as FancyURLopener,
# proxy_bypass as proxy_bypass,
)
mypy-0.470/typeshed/third_party/3/six/moves/cPickle.pyi 0000644 0000000 0000000 00000000241 13035744274 021577 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.cPickle (Python 3.2)
from pickle import * # noqa: F403
mypy-0.470/typeshed/third_party/3/six/moves/urllib_error.pyi 0000644 0000000 0000000 00000000422 13023631176 022721 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_error (Python 3.2)
from six.moves.urllib.error import (
URLError as URLError,
HTTPError as HTTPError,
ContentTooShortError as ContentTooShortError,
)
mypy-0.470/typeshed/third_party/3/six/moves/urllib/ 0000755 0000000 0000000 00000000000 13044320557 020770 5 ustar root root mypy-0.470/typeshed/third_party/3/six/moves/urllib/error.pyi 0000644 0000000 0000000 00000000447 13023631176 022650 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.error (Python 3.2)
from urllib.error import URLError as URLError
from urllib.error import HTTPError as HTTPError
from urllib.error import ContentTooShortError as ContentTooShortError
mypy-0.470/typeshed/third_party/3/six/moves/urllib/__init__.pyi 0000644 0000000 0000000 00000000526 13023631176 023254 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib (Python 3.2)
import six.moves.urllib.error as error
import six.moves.urllib.parse as parse
import six.moves.urllib.request as request
import six.moves.urllib.response as response
import six.moves.urllib.robotparser as robotparser
mypy-0.470/typeshed/third_party/3/six/moves/urllib/request.pyi 0000644 0000000 0000000 00000004303 13023631176 023202 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.request (Python 3.2)
from urllib.request import BaseHandler as BaseHandler
from urllib.request import HTTPRedirectHandler as HTTPRedirectHandler
from urllib.request import OpenerDirector as OpenerDirector
from urllib.request import install_opener as install_opener
from urllib.request import build_opener as build_opener
# from urllib.request import urlopen as urlopen
# from urllib.request import pathname2url as pathname2url
# from urllib.request import url2pathname as url2pathname
# from urllib.request import getproxies as getproxies
# from urllib.request import Request as Request
# from urllib.request import HTTPDefaultErrorHandler as HTTPDefaultErrorHandler
# from urllib.request import HTTPCookieProcessor as HTTPCookieProcessor
# from urllib.request import ProxyHandler as ProxyHandler
# from urllib.request import HTTPPasswordMgr as HTTPPasswordMgr
# from urllib.request import HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm
# from urllib.request import AbstractBasicAuthHandler as AbstractBasicAuthHandler
# from urllib.request import HTTPBasicAuthHandler as HTTPBasicAuthHandler
# from urllib.request import ProxyBasicAuthHandler as ProxyBasicAuthHandler
# from urllib.request import AbstractDigestAuthHandler as AbstractDigestAuthHandler
# from urllib.request import HTTPDigestAuthHandler as HTTPDigestAuthHandler
# from urllib.request import ProxyDigestAuthHandler as ProxyDigestAuthHandler
# from urllib.request import HTTPHandler as HTTPHandler
# from urllib.request import HTTPSHandler as HTTPSHandler
# from urllib.request import FileHandler as FileHandler
# from urllib.request import FTPHandler as FTPHandler
# from urllib.request import CacheFTPHandler as CacheFTPHandler
# from urllib.request import UnknownHandler as UnknownHandler
# from urllib.request import HTTPErrorProcessor as HTTPErrorProcessor
# from urllib.request import urlretrieve as urlretrieve
# from urllib.request import urlcleanup as urlcleanup
# from urllib.request import URLopener as URLopener
# from urllib.request import FancyURLopener as FancyURLopener
# from urllib.request import proxy_bypass as proxy_bypass
mypy-0.470/typeshed/third_party/3/six/moves/urllib/parse.pyi 0000644 0000000 0000000 00000001114 13023631176 022621 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.parse (Python 3.2)
from six.moves.urllib_parse import (
ParseResult as ParseResult,
SplitResult as SplitResult,
parse_qs as parse_qs,
parse_qsl as parse_qsl,
urldefrag as urldefrag,
urljoin as urljoin,
urlparse as urlparse,
urlsplit as urlsplit,
urlunparse as urlunparse,
urlunsplit as urlunsplit,
quote as quote,
quote_plus as quote_plus,
unquote as unquote,
unquote_plus as unquote_plus,
urlencode as urlencode,
)
mypy-0.470/typeshed/third_party/3/six/moves/urllib/response.pyi 0000644 0000000 0000000 00000000065 13023631176 023351 0 ustar root root from urllib.response import addinfourl as addinfourl
mypy-0.470/typeshed/third_party/3/six/moves/urllib/robotparser.pyi 0000644 0000000 0000000 00000000313 13023631176 024051 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib.robotparser (Python 3.2)
from urllib.robotparser import RobotFileParser as RobotFileParser
mypy-0.470/typeshed/third_party/3/six/moves/urllib_parse.pyi 0000644 0000000 0000000 00000001521 13023631176 022703 0 ustar root root # Generated by stubtool 0.1, DO NOT EDIT
# See https://github.com/o11c/stubtool
#
# Stubs for six.moves.urllib_parse (Python 3.2)
from urllib.parse import ParseResult as ParseResult
from urllib.parse import SplitResult as SplitResult
from urllib.parse import parse_qs as parse_qs
from urllib.parse import parse_qsl as parse_qsl
from urllib.parse import urldefrag as urldefrag
from urllib.parse import urljoin as urljoin
from urllib.parse import urlparse as urlparse
from urllib.parse import urlsplit as urlsplit
from urllib.parse import urlunparse as urlunparse
from urllib.parse import urlunsplit as urlunsplit
from urllib.parse import quote as quote
from urllib.parse import quote_plus as quote_plus
from urllib.parse import unquote as unquote
from urllib.parse import unquote_plus as unquote_plus
from urllib.parse import urlencode as urlencode
mypy-0.470/typeshed/third_party/3/enum.pyi 0000644 0000000 0000000 00000003143 13035744274 017241 0 ustar root root # FIXME: Stub incomplete, ommissions include:
# * the metaclass
# * _sunder_ methods with their transformations
import sys
from typing import List, Any, TypeVar, Union
class Enum:
def __new__(cls, value: Any) -> None: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def __dir__(self) -> List[str]: ...
def __format__(self, format_spec: str) -> str: ...
def __hash__(self) -> Any: ...
def __reduce_ex__(self, proto: Any) -> Any: ...
name = ... # type: str
value = ... # type: Any
class IntEnum(int, Enum):
value = ... # type: int
_T = TypeVar('_T')
def unique(enumeration: _T) -> _T: ...
if sys.version_info >= (3, 6):
_auto_null = ... # type: Any
class auto:
value = ... # type: Any
class Flag(Enum):
def __contains__(self: _T, other: _T) -> bool: ...
def __repr__(self) -> str: ...
def __str__(self) -> str: ...
def __bool__(self) -> bool: ...
def __or__(self: _T, other: _T) -> _T: ...
def __and__(self: _T, other: _T) -> _T: ...
def __xor__(self: _T, other: _T) -> _T: ...
def __invert__(self: _T) -> _T: ...
# All `type: ignore` comments below due to IntFlag making the function signatures more permissive.
class IntFlag(int, Flag): # type: ignore
def __or__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
def __and__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
def __xor__(self: _T, other: Union[int, _T]) -> _T: ... # type: ignore
__ror__ = __or__
__rand__ = __and__
__rxor__ = __xor__
mypy-0.470/typeshed/third_party/3/lxml/ 0000755 0000000 0000000 00000000000 13044320557 016517 5 ustar root root mypy-0.470/typeshed/third_party/3/lxml/__init__.pyi 0000644 0000000 0000000 00000000000 13023631176 020766 0 ustar root root mypy-0.470/typeshed/third_party/3/lxml/etree.pyi 0000644 0000000 0000000 00000011332 13035744274 020354 0 ustar root root # Hand-written stub for lxml.etree as used by mypy.report.
# This is *far* from complete, and the stubgen-generated ones crash mypy.
# Any use of `Any` below means I couldn't figure out the type.
import typing
from typing import Any, Dict, List, MutableMapping, Tuple, Union
from typing import Iterable, Iterator, SupportsBytes
# We do *not* want `typing.AnyStr` because it is a `TypeVar`, which is an
# unnecessary constraint. It seems reasonable to constrain each
# List/Dict argument to use one type consistently, though, and it is
# necessary in order to keep these brief.
AnyStr = Union[str, bytes]
ListAnyStr = Union[List[str], List[bytes]]
DictAnyStr = Union[Dict[str, str], Dict[bytes, bytes]]
Dict_Tuple2AnyStr_Any = Union[Dict[Tuple[str, str], Any], Tuple[bytes, bytes], Any]
class ElementChildIterator(Iterator['_Element;']):
def __iter__(self) -> 'ElementChildIterator': ...
def __next__(self) -> '_Element': ...
class _Element(Iterable['_Element']):
def addprevious(self, element: '_Element') -> None:
pass
attrib = ... # type: MutableMapping[str, str]
text = ... # type: AnyStr
tag = ... # type: str
def append(self, element: '_Element') -> '_Element': ...
def __iter__(self) -> ElementChildIterator: ...
class ElementBase(_Element):
pass
class _ElementTree:
def write(self,
file: Union[AnyStr, typing.IO],
encoding: AnyStr = ...,
method: AnyStr = ...,
pretty_print: bool = ...,
xml_declaration: Any = ...,
with_tail: Any = ...,
standalone: bool = ...,
compression: int = ...,
exclusive: bool = ...,
with_comments: bool = ...,
inclusive_ns_prefixes: ListAnyStr = ...) -> None:
pass
class _XSLTResultTree(SupportsBytes):
pass
class _XSLTQuotedStringParam:
pass
class XMLParser:
pass
class XMLSchema:
def __init__(self,
etree: Union[_Element, _ElementTree] = ...,
file: Union[AnyStr, typing.IO] = ...) -> None:
pass
def assertValid(self,
etree: Union[_Element, _ElementTree]) -> None:
pass
class XSLTAccessControl:
pass
class XSLT:
def __init__(self,
xslt_input: Union[_Element, _ElementTree],
extensions: Dict_Tuple2AnyStr_Any = ...,
regexp: bool = ...,
access_control: XSLTAccessControl = ...) -> None:
pass
def __call__(self,
_input: Union[_Element, _ElementTree],
profile_run: bool = ...,
**kwargs: Union[AnyStr, _XSLTQuotedStringParam]) -> _XSLTResultTree:
pass
@staticmethod
def strparam(s: AnyStr) -> _XSLTQuotedStringParam:
pass
def Element(_tag: AnyStr,
attrib: DictAnyStr = ...,
nsmap: DictAnyStr = ...,
**extra: AnyStr) -> _Element:
pass
def SubElement(_parent: _Element, _tag: AnyStr,
attrib: DictAnyStr = ...,
nsmap: DictAnyStr = ...,
**extra: AnyStr) -> _Element:
pass
def ElementTree(element: _Element = ...,
file: Union[AnyStr, typing.IO] = ...,
parser: XMLParser = ...) -> _ElementTree:
pass
def ProcessingInstruction(target: AnyStr, text: AnyStr = ...) -> _Element:
pass
def parse(source: Union[AnyStr, typing.IO],
parser: XMLParser = ...,
base_url: AnyStr = ...) -> _ElementTree:
pass
def fromstring(text: AnyStr,
parser: XMLParser = ...,
*,
base_url: AnyStr = ...) -> _Element: ...
def tostring(element_or_tree: Union[_Element, _ElementTree],
encoding: Union[str, type] = ...,
method: str = ...,
xml_declaration: bool = ...,
pretty_print: bool = ...,
with_tail: bool = ...,
standalone: bool = ...,
doctype: str = ...,
exclusive: bool = ...,
with_comments: bool = ...,
inclusive_ns_prefixes: Any = ...) -> AnyStr: ...
class _ErrorLog:
pass
class Error(Exception):
pass
class LxmlError(Error):
def __init__(self, message: Any, error_log: _ErrorLog = ...) -> None: ...
error_log = ... # type: _ErrorLog
class DocumentInvalid(LxmlError):
pass
class LxmlSyntaxError(LxmlError, SyntaxError):
pass
class ParseError(LxmlSyntaxError):
pass
class XMLSyntaxError(ParseError):
pass
class _Validator:
pass
class DTD(_Validator):
def __init__(self,
file: Union[AnyStr, typing.IO] = ...,
*,
external_id: Any = ...) -> None: ...
def assertValid(self, etree: _Element) -> None: ...
mypy-0.470/typeshed/third_party/3/lxml/objectify.pyi 0000644 0000000 0000000 00000000512 13023631176 021215 0 ustar root root # Hand-written stub, incomplete
from typing import Union
from lxml.etree import ElementBase, XMLParser
class ObjectifiedElement(ElementBase):
pass
def fromstring(text: Union[bytes, str],
parser: XMLParser = ...,
*,
base_url: Union[bytes, str] = ...) -> ObjectifiedElement: ...
mypy-0.470/typeshed/third_party/3/itsdangerous.pyi 0000644 0000000 0000000 00000017475 13035744274 021021 0 ustar root root # Stubs for itsdangerous (Python 3)
#
# NOTE: This dynamically typed stub was automatically generated by stubgen.
from datetime import datetime
from typing import Any, Callable, IO, MutableMapping, Optional, Text, Tuple, TypeVar, Union
PY2 = ... # type: bool
text_type = str
int_to_byte = Callable[[int], bytes]
number_types = (int, float)
izip = zip
bytes_like = Union[bytearray, bytes]
str_like = Union[str, bytes]
can_become_bytes = Union[str, bytes, bytearray]
comparable_bytes = TypeVar('comparable_bytes', str, Union[bytes, bytearray])
class _CompactJSON:
def loads(self, payload: Text) -> Any: ...
def dumps(self, obj: Any) -> Text: ...
compact_json = _CompactJSON
EPOCH = ... # type: int
def want_bytes(s: can_become_bytes, encoding='', errors='') -> bytes: ...
def is_text_serializer(serializer: Any) -> bool: ...
def constant_time_compare(val1: comparable_bytes, val2: comparable_bytes) -> bool: ...
class BadData(Exception):
message = ... # type: str
def __init__(self, message: str) -> None: ...
class BadPayload(BadData):
original_error = ... # type: Optional[Exception]
def __init__(self, message: str, original_error: Optional[Exception]=None) -> None: ...
class BadSignature(BadData):
payload = ... # type: Optional[Any]
def __init__(self, message: str, payload: Optional[Any]=None) -> None: ...
class BadTimeSignature(BadSignature):
date_signed = ... # type: Optional[int]
def __init__(self, message, payload: Optional[Any]=None, date_signed: Optional[int]=None) -> None: ...
class BadHeader(BadSignature):
header = ... # type: Any
original_error = ... # type: Any
def __init__(self, message, payload=None, header=None, original_error=None) -> None: ...
class SignatureExpired(BadTimeSignature): ...
def base64_encode(string: can_become_bytes) -> bytes: ...
def base64_decode(string: can_become_bytes) -> bytes: ...
def int_to_bytes(num: int) -> bytes: ...
def bytes_to_int(bytestr: can_become_bytes) -> bytes: ...
class SigningAlgorithm:
def get_signature(self, key: bytes_like, value: bytes_like) -> bytes: ...
def verify_signature(self, key: bytes_like, value: bytes_like, sig: can_become_bytes) -> bool: ...
class NoneAlgorithm(SigningAlgorithm):
def get_signature(self, key: bytes_like, value: bytes_like) -> bytes: ...
class HMACAlgorithm(SigningAlgorithm):
default_digest_method = ... # type: Callable
digest_method = ... # type: Callable
def __init__(self, digest_method: Optional[Callable]=None) -> None: ...
def get_signature(self, key: bytes_like, value: bytes_like) -> bytes: ...
class Signer:
default_digest_method = ... # type: Callable
default_key_derivation = ... # type: str
secret_key = ... # type: can_become_bytes
sep = ... # type: can_become_bytes
salt = ... # type: can_become_bytes
key_derivation = ... # type: str
digest_method = ... # type: Callable
algorithm = ... # type: SigningAlgorithm
def __init__(self, secret_key: can_become_bytes, salt: Optional[can_become_bytes]=None, sep: Optional[can_become_bytes]='',
key_derivation: Optional[str]=None,
digest_method: Optional[Callable]=None,
algorithm: Optional[SigningAlgorithm]=None) -> None: ...
def derive_key(self) -> bytes: ...
def get_signature(self, value: bytes_like) -> bytes: ...
def sign(self, value: bytes_like) -> bytes: ...
def verify_signature(self, value: bytes_like, sig: can_become_bytes) -> bool: ...
def unsign(self, signed_value: can_become_bytes) -> str: ...
def validate(self, signed_value: can_become_bytes) -> bool: ...
class TimestampSigner(Signer):
def get_timestamp(self) -> int: ...
def timestamp_to_datetime(self, ts: int) -> datetime: ...
def sign(self, value: bytes_like) -> bytes: ...
def unsign(self, value: can_become_bytes, max_age: Optional[int]=None, return_timestamp=False) -> Any: ...
def validate(self, signed_value: can_become_bytes, max_age: Optional[int]=None) -> bool: ...
class Serializer:
default_serializer = ... # type: Any
default_signer = ... # type: Callable[..., Signer]
secret_key = ... # type: Any
salt = ... # type: can_become_bytes
serializer = ... # type: Any
is_text_serializer = ... # type: bool
signer = ... # type: Signer
signer_kwargs = ... # type: MutableMapping
def __init__(self, secret_key: can_become_bytes, salt: Optional[can_become_bytes]=b'', serializer=None, signer: Optional[Callable[..., Signer]]=None, signer_kwargs: Optional[MutableMapping]=None) -> None: ...
def load_payload(self, payload: Any, serializer=None) -> Any: ...
def dump_payload(self, *args, **kwargs) -> bytes: ...
def make_signer(self, salt: Optional[can_become_bytes]=None) -> Signer: ...
def dumps(self, obj: Any, salt: Optional[can_become_bytes]=None) -> str_like: ...
def dump(self, obj: Any, f: IO, salt: Optional[can_become_bytes]=None) -> None: ...
def loads(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None) -> Any: ...
def load(self, f: IO, salt: Optional[can_become_bytes]=None): ...
def loads_unsafe(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None) -> Tuple[bool, Any]: ...
def load_unsafe(self, f: IO, *args, **kwargs) -> Tuple[bool, Any]: ...
class TimedSerializer(Serializer):
default_signer = ... # type: Callable[..., TimestampSigner]
def loads(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None, max_age: Optional[int]=None, return_timestamp=False) -> Any: ...
def loads_unsafe(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None, max_age: Optional[int]=None) -> Tuple[bool, Any]: ...
class JSONWebSignatureSerializer(Serializer):
jws_algorithms = ... # type: MutableMapping[str, SigningAlgorithm]
default_algorithm = ... # type: str
default_serializer = ... # type: Any
algorithm_name = ... # type: str
algorithm = ... # type: Any
def __init__(self, secret_key: can_become_bytes, salt: Optional[can_become_bytes]=None, serializer=None, signer: Optional[Callable[..., Signer]]=None, signer_kwargs: Optional[MutableMapping]=None, algorithm_name: Optional[str]=None) -> None: ...
def load_payload(self, payload: Any, return_header=False) -> Any: ...
def dump_payload(self, *args, **kwargs) -> bytes: ...
def make_algorithm(self, algorithm_name: str) -> SigningAlgorithm: ...
def make_signer(self, salt: Optional[can_become_bytes]=None, algorithm_name: Optional[str]=None) -> Signer: ...
def make_header(self, header_fields=Optional[MutableMapping]) -> MutableMapping: ...
def dumps(self, obj: Any, salt: Optional[can_become_bytes]=None, header_fields=Optional[MutableMapping]) -> str: ...
def loads(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None, return_header=False) -> Any: ...
def loads_unsafe(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None, return_header=False) -> Tuple[bool, Any]: ...
class TimedJSONWebSignatureSerializer(JSONWebSignatureSerializer):
DEFAULT_EXPIRES_IN = ... # type: int
expires_in = ... # type: int
def __init__(self, secret_key: can_become_bytes, expires_in: Optional[int]=None, **kwargs) -> None: ...
def make_header(self, header_fields=Optional[MutableMapping]) -> MutableMapping: ...
def loads(self, s: can_become_bytes, salt: Optional[can_become_bytes]=None, return_header=False) -> Any: ...
def get_issue_date(self, header: MutableMapping) -> Optional[datetime]: ...
def now(self) -> int: ...
class URLSafeSerializerMixin:
def load_payload(self, payload: Any, serializer: Any = ..., **kwargs) -> Any: ...
def dump_payload(self, *args, **kwargs) -> bytes: ...
class URLSafeSerializer(URLSafeSerializerMixin, Serializer):
default_serializer = ... # type: Any
class URLSafeTimedSerializer(URLSafeSerializerMixin, TimedSerializer):
default_serializer = ... # type: Any
mypy-0.470/scripts/ 0000755 0000000 0000000 00000000000 13044320557 012712 5 ustar root root mypy-0.470/scripts/stubgen 0000755 0000000 0000000 00000000732 13012205774 014307 0 ustar root root #!/usr/bin/env python3
"""Generator of dynamically typed draft stubs for arbitrary modules.
This is just a wrapper script. Look at mypy/stubgen.py for the actual
implementation.
"""
import os
import os.path
import sys
file_dir = os.path.dirname(__file__)
parent_dir = os.path.join(file_dir, os.pardir)
if os.path.exists(os.path.join(parent_dir, '.git')):
# We are running from a git clone.
sys.path.insert(0, parent_dir)
import mypy.stubgen
mypy.stubgen.main()
mypy-0.470/scripts/find_type.py 0000755 0000000 0000000 00000006637 13012205774 015262 0 ustar root root #!/usr/bin/env python3
# Usage: find_type.py FILENAME START_LINE START_COL END_LINE END_COL MYPY_AND_ARGS
# Prints out the type of the expression in the given location if the mypy run
# succeeds cleanly. Otherwise, prints out the errors encountered.
# Note: this only works on expressions, and not assignment targets.
# Note: MYPY_AND_ARGS is should be the remainder of argv, not a single
# spaces-included argument.
# NOTE: Line numbers are 1-based; column numbers are 0-based.
#
#
# Example vim usage:
# function RevealType()
# " Set this to the command you use to run mypy on your project. Include the mypy invocation.
# let mypycmd = 'python3 -m mypy mypy --incremental'
# let [startline, startcol] = getpos("'<")[1:2]
# let [endline, endcol] = getpos("'>")[1:2]
# " Convert to 0-based column offsets
# let startcol = startcol - 1
# " Change this line to point to the find_type.py script.
# execute '!python3 /path/to/mypy/scripts/find_type.py % ' . startline . ' ' . startcol . ' ' . endline . ' ' . endcol . ' ' . mypycmd
# endfunction
# vnoremap t :call RevealType()
#
# For an Emacs example, see misc/macs.el.
from typing import List, Tuple, Optional
import subprocess
import sys
import tempfile
import os.path
import re
REVEAL_TYPE_START = 'reveal_type('
REVEAL_TYPE_END = ')'
def update_line(line: str, s: str, pos: int) -> str:
return line[:pos] + s + line[pos:]
def run_mypy(mypy_and_args: List[str], filename: str, tmp_name: str) -> str:
proc = subprocess.run(mypy_and_args + ['--shadow-file', filename, tmp_name], stdout=subprocess.PIPE)
assert(isinstance(proc.stdout, bytes)) # Guaranteed to be true because we called run with universal_newlines=False
return proc.stdout.decode(encoding="utf-8")
def get_revealed_type(line: str, relevant_file: str, relevant_line: int) -> Optional[str]:
m = re.match("(.+?):(\d+): error: Revealed type is '(.*)'$", line)
if (m and
int(m.group(2)) == relevant_line and
os.path.samefile(relevant_file, m.group(1))):
return m.group(3)
else:
return None
def process_output(output: str, filename: str, start_line: int) -> Tuple[Optional[str], bool]:
error_found = False
for line in output.splitlines():
t = get_revealed_type(line, filename, start_line)
if t:
return t, error_found
elif 'error:' in line:
error_found = True
return None, True # finding no reveal_type is an error
def main():
filename, start_line_str, start_col_str, end_line_str, end_col_str, *mypy_and_args = sys.argv[1:]
start_line = int(start_line_str)
start_col = int(start_col_str)
end_line = int(end_line_str)
end_col = int(end_col_str)
with open(filename, 'r') as f:
lines = f.readlines()
lines[end_line - 1] = update_line(lines[end_line - 1], REVEAL_TYPE_END, end_col) # insert after end_col
lines[start_line - 1] = update_line(lines[start_line - 1], REVEAL_TYPE_START, start_col)
with tempfile.NamedTemporaryFile(mode='w', prefix='mypy') as tmp_f:
tmp_f.writelines(lines)
tmp_f.flush()
output = run_mypy(mypy_and_args, filename, tmp_f.name)
revealed_type, error = process_output(output, filename, start_line)
if revealed_type:
print(revealed_type)
if error:
print(output)
exit(int(error))
if __name__ == "__main__":
main()
mypy-0.470/scripts/mypy 0000755 0000000 0000000 00000000156 13012205774 013636 0 ustar root root #!/usr/bin/env python3
"""Mypy type checker command line tool."""
from mypy.main import main
main(__file__)
mypy-0.470/scripts/mypy.bat 0000644 0000000 0000000 00000000214 13012205774 014373 0 ustar root root @echo off
setlocal
if exist "%~dp0\python.exe" (
"%~dp0\python" "%~dp0mypy" %*
) else (
"%~dp0..\python" "%~dp0mypy" %*
)
endlocal
mypy-0.470/setup.py 0000644 0000000 0000000 00000007136 13037731162 012744 0 ustar root root #!/usr/bin/env python
import glob
import os
import os.path
import sys
if sys.version_info < (3, 2, 0):
sys.stderr.write("ERROR: You need Python 3.2 or later to use mypy.\n")
exit(1)
# This requires setuptools when building; setuptools is not needed
# when installing from a wheel file (though it is still neeeded for
# alternative forms of installing, as suggested by README.md).
from setuptools import setup
from setuptools.command.build_py import build_py
from mypy.version import base_version
from mypy import git
git.verify_git_integrity_or_abort(".")
version = base_version
description = 'Optional static typing for Python'
long_description = '''
Mypy -- Optional Static Typing for Python
=========================================
Add type annotations to your Python programs, and use mypy to type
check them. Mypy is essentially a Python linter on steroids, and it
can catch many programming errors by analyzing your program, without
actually having to run it. Mypy has a powerful type system with
features such as type inference, gradual typing, generics and union
types.
'''.lstrip()
def find_data_files(base, globs):
"""Find all interesting data files, for setup(data_files=)
Arguments:
root: The directory to search in.
globs: A list of glob patterns to accept files.
"""
rv_dirs = [root for root, dirs, files in os.walk(base)]
rv = []
for rv_dir in rv_dirs:
files = []
for pat in globs:
files += glob.glob(os.path.join(rv_dir, pat))
if not files:
continue
target = os.path.join('lib', 'mypy', rv_dir)
rv.append((target, files))
return rv
class CustomPythonBuild(build_py):
def pin_version(self):
path = os.path.join(self.build_lib, 'mypy')
self.mkpath(path)
with open(os.path.join(path, 'version.py'), 'w') as stream:
stream.write('__version__ = "{}"\n'.format(version))
def run(self):
self.execute(self.pin_version, ())
build_py.run(self)
data_files = []
data_files += find_data_files('typeshed', ['*.py', '*.pyi'])
data_files += find_data_files('xml', ['*.xsd', '*.xslt', '*.css'])
classifiers = [
'Development Status :: 2 - Pre-Alpha',
'Environment :: Console',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: POSIX',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Topic :: Software Development',
]
package_dir = {'mypy': 'mypy'}
scripts = ['scripts/mypy', 'scripts/stubgen']
if os.name == 'nt':
scripts.append('scripts/mypy.bat')
# These requirements are used when installing by other means than bdist_wheel.
# E.g. "pip3 install ." or
# "pip3 install git+git://github.com/python/mypy.git"
# (as suggested by README.md).
install_requires = []
install_requires.append('typed-ast >= 0.6.3')
if sys.version_info < (3, 5):
install_requires.append('typing >= 3.5.3')
setup(name='mypy',
version=version,
description=description,
long_description=long_description,
author='Jukka Lehtosalo',
author_email='jukka.lehtosalo@iki.fi',
url='http://www.mypy-lang.org/',
license='MIT License',
platforms=['POSIX'],
package_dir=package_dir,
py_modules=[],
packages=['mypy'],
scripts=scripts,
data_files=data_files,
classifiers=classifiers,
cmdclass={'build_py': CustomPythonBuild},
install_requires=install_requires,
)