# coding: utf-8 # AUTO-GENERATED FILE -- DO NOT EDIT # OVERRIDES FILE: static-pi-files/3.0/builtinsoverride.py """ Built-in functions, exceptions, and other objects. Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices. """ class ArithmeticError(Exception): """ Base class for arithmetic errors. """ def __init__(self, *args, **kwargs): pass class AssertionError(Exception): """ Assertion failed. """ def __init__(self, *args, **kwargs): pass class AttributeError(Exception): """ Attribute not found. """ def __init__(self, *args, **kwargs): pass class BaseException(object): """ Common base class for all exceptions """ def __init__(self, *args, **kwargs): pass args = property(None, None, None, ) def with_traceback(self, tb): """ Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self. """ pass class BlockingIOError(OSError): """ I/O operation would block. """ def __init__(self, *args, **kwargs): pass class BrokenPipeError(ConnectionError): """ Broken pipe. """ def __init__(self, *args, **kwargs): pass class BufferError(Exception): """ Buffer error. """ def __init__(self, *args, **kwargs): pass class BytesWarning(Warning): """ Base class for warnings about bytes and buffer related problems, mostly related to conversion from str or comparing to str. """ def __init__(self, *args, **kwargs): pass class ChildProcessError(OSError): """ Child process error. """ def __init__(self, *args, **kwargs): pass class ConnectionAbortedError(ConnectionError): """ Connection aborted. """ def __init__(self, *args, **kwargs): pass class ConnectionError(OSError): """ Connection error. """ def __init__(self, *args, **kwargs): pass class ConnectionRefusedError(ConnectionError): """ Connection refused. """ def __init__(self, *args, **kwargs): pass class ConnectionResetError(ConnectionError): """ Connection reset. """ def __init__(self, *args, **kwargs): pass class DeprecationWarning(Warning): """ Base class for warnings about deprecated features. """ def __init__(self, *args, **kwargs): pass class EOFError(Exception): """ Read beyond end of file. """ def __init__(self, *args, **kwargs): pass Ellipsis = None EnvironmentError = OSError class Exception(BaseException): """ Common base class for all non-exit exceptions. """ def __init__(self, *args, **kwargs): pass class FileExistsError(OSError): """ File already exists. """ def __init__(self, *args, **kwargs): pass class FileNotFoundError(OSError): """ File not found. """ def __init__(self, *args, **kwargs): pass class FloatingPointError(ArithmeticError): """ Floating point operation failed. """ def __init__(self, *args, **kwargs): pass class FutureWarning(Warning): """ Base class for warnings about constructs that will change semantically in the future. """ def __init__(self, *args, **kwargs): pass class GeneratorExit(BaseException): """ Request that a generator exit. """ def __init__(self, *args, **kwargs): pass IOError = OSError class ImportError(Exception): """ Import can't find module, or can't find name in module. """ def __init__(self, *args, **kwargs): pass msg = None name = None path = None class ImportWarning(Warning): """ Base class for warnings about probable mistakes in module imports """ def __init__(self, *args, **kwargs): pass class IndentationError(SyntaxError): """ Improper indentation. """ def __init__(self, *args, **kwargs): pass class IndexError(LookupError): """ Sequence index out of range. """ def __init__(self, *args, **kwargs): pass class InterruptedError(OSError): """ Interrupted by signal. """ def __init__(self, *args, **kwargs): pass class IsADirectoryError(OSError): """ Operation doesn't work on directories. """ def __init__(self, *args, **kwargs): pass class KeyError(LookupError): """ Mapping key not found. """ def __init__(self, *args, **kwargs): pass class KeyboardInterrupt(BaseException): """ Program interrupted by user. """ def __init__(self, *args, **kwargs): pass class LookupError(Exception): """ Base class for lookup errors. """ def __init__(self, *args, **kwargs): pass class MemoryError(Exception): """ Out of memory. """ def __init__(self, *args, **kwargs): pass class NameError(Exception): """ Name not found globally. """ def __init__(self, *args, **kwargs): pass class NotADirectoryError(OSError): """ Operation only works on directories. """ def __init__(self, *args, **kwargs): pass NotImplemented = None class NotImplementedError(RuntimeError): """ Method or function hasn't been implemented yet. """ def __init__(self, *args, **kwargs): pass class OSError(Exception): """ Base class for I/O related errors. """ def __init__(self, *args, **kwargs): pass characters_written = property(None, None, None, ) errno = None filename = None filename2 = None strerror = None class OverflowError(ArithmeticError): """ Result too large to be represented. """ def __init__(self, *args, **kwargs): pass class PendingDeprecationWarning(Warning): """ Base class for warnings about features which will be deprecated in the future. """ def __init__(self, *args, **kwargs): pass class PermissionError(OSError): """ Not enough permissions. """ def __init__(self, *args, **kwargs): pass class ProcessLookupError(OSError): """ Process not found. """ def __init__(self, *args, **kwargs): pass class ReferenceError(Exception): """ Weak ref proxy used after referent went away. """ def __init__(self, *args, **kwargs): pass class ResourceWarning(Warning): """ Base class for warnings about resource usage. """ def __init__(self, *args, **kwargs): pass class RuntimeError(Exception): """ Unspecified run-time error. """ def __init__(self, *args, **kwargs): pass class RuntimeWarning(Warning): """ Base class for warnings about dubious runtime behavior. """ def __init__(self, *args, **kwargs): pass class StopIteration(Exception): """ Signal the end from iterator.__next__(). """ def __init__(self, *args, **kwargs): pass value = None class SyntaxError(Exception): """ Invalid syntax. """ def __init__(self, *args, **kwargs): pass filename = None lineno = None msg = None offset = None print_file_and_line = None text = None class SyntaxWarning(Warning): """ Base class for warnings about dubious syntax. """ def __init__(self, *args, **kwargs): pass class SystemError(Exception): """ Internal error in the Python interpreter. Please report this to the Python maintainer, along with the traceback, the Python version, and the hardware/OS platform and version. """ def __init__(self, *args, **kwargs): pass class SystemExit(BaseException): """ Request to exit from the interpreter. """ def __init__(self, *args, **kwargs): pass code = None class TabError(IndentationError): """ Improper mixture of spaces and tabs. """ def __init__(self, *args, **kwargs): pass class TimeoutError(OSError): """ Timeout expired. """ def __init__(self, *args, **kwargs): pass class TypeError(Exception): """ Inappropriate argument type. """ def __init__(self, *args, **kwargs): pass class UnboundLocalError(NameError): """ Local name referenced but not bound to a value. """ def __init__(self, *args, **kwargs): pass class UnicodeDecodeError(UnicodeError): """ Unicode decoding error. """ def __init__(self, *args, **kwargs): pass encoding = None end = None object = None reason = None start = None class UnicodeEncodeError(UnicodeError): """ Unicode encoding error. """ def __init__(self, *args, **kwargs): pass encoding = None end = None object = None reason = None start = None class UnicodeError(ValueError): """ Unicode related error. """ def __init__(self, *args, **kwargs): pass class UnicodeTranslateError(UnicodeError): """ Unicode translation error. """ def __init__(self, *args, **kwargs): pass encoding = None end = None object = None reason = None start = None class UnicodeWarning(Warning): """ Base class for warnings about Unicode related problems, mostly related to conversion problems. """ def __init__(self, *args, **kwargs): pass class UserWarning(Warning): """ Base class for warnings generated by user code. """ def __init__(self, *args, **kwargs): pass class ValueError(Exception): """ Inappropriate argument value (of correct type). """ def __init__(self, *args, **kwargs): pass class Warning(Exception): """ Base class for warning categories. """ def __init__(self, *args, **kwargs): pass class ZeroDivisionError(ArithmeticError): """ Second argument to a division or modulo operation was zero. """ def __init__(self, *args, **kwargs): pass def __build_class__(func, name, arg0, metaclass=None, **kwds): """ __build_class__(func, name, *bases, metaclass=None, **kwds) -> class Internal helper function used by the class statement. """ return None __debug__ = True def __import__(name, globals=None, locals=None, fromlist=(), level=0): """ __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module Import a module. Because this function is meant for use by the Python interpreter and not for general use it is better to use importlib.import_module() to programmatically import a module. The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate ``from name import ...'', or an empty list to emulate ``import name''. When importing a module from a package, note that __import__('A.B', ...) returns package A when fromlist is empty, but its submodule B when fromlist is not empty. Level is used to determine whether to perform absolute or relative imports. 0 is absolute while a positive number is the number of parent directories to search relative to the current module. """ return None def abs(number): """ abs(number) -> number Return the absolute value of the argument. """ return None def all(iterable): """ all(iterable) -> bool Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True. """ return None def any(iterable): """ any(iterable) -> bool Return True if bool(x) is True for any x in the iterable. If the iterable is empty, return False. """ return None def ascii(object): """ ascii(object) -> string As repr(), return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr() using \\x, \\u or \\U escapes. This generates a string similar to that returned by repr() in Python 2. """ return "" def bin(number): """ bin(number) -> string Return the binary representation of an integer. >>> bin(2796202) '0b1010101010101010101010' """ return "" class bool(int): """ bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed. """ def from_bytes(self, bytes, byteorder, arg0, signed=False): """ int.from_bytes(bytes, byteorder, *, signed=False) -> int Return the integer represented by the given array of bytes. The bytes argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol. The byteorder argument determines the byte order used to represent the integer. If byteorder is 'big', the most significant byte is at the beginning of the byte array. If byteorder is 'little', the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder' as the byte order value. The signed keyword-only argument indicates whether two's complement is used to represent the integer. """ return 1 class bytearray(object): """ bytearray(iterable_of_ints) -> bytearray bytearray(string, encoding[, errors]) -> bytearray bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer bytearray(int) -> bytes array of size given by the parameter initialized with null bytes bytearray() -> empty bytes array Construct an mutable bytearray object from: - an iterable yielding integers in range(256) - a text string encoded using the specified encoding - a bytes or a buffer object - any object implementing the buffer API. - an integer """ def __init__(self, *args, **kwargs): return None def append(self, int): """ B.append(int) -> None Append a single item to the end of B. """ return None def capitalize(self): """ B.capitalize() -> copy of B Return a copy of B with only its first character capitalized (ASCII) and the rest lower-cased. """ return None def center(self, width, fillchar=None): """ B.center(width[, fillchar]) -> copy of B Return B centered in a string of length width. Padding is done using the specified fill character (default is a space). """ return None def clear(self): """ B.clear() -> None Remove all items from B. """ return None def copy(self): """ B.copy() -> bytearray Return a copy of B. """ return None def count(self, sub, start=None, end=None): """ B.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of subsection sub in bytes B[start:end]. Optional arguments start and end are interpreted as in slice notation. """ return 1 def decode(self, encoding='utf_8', errors='strict'): """ B.decode(encoding='utf-8', errors='strict') -> str Decode B using the codec registered for encoding. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registered with codecs.register_error that is able to handle UnicodeDecodeErrors. """ return "" def endswith(self, suffix, start=None, end=None): """ B.endswith(suffix[, start[, end]]) -> bool Return True if B ends with the specified suffix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. suffix can also be a tuple of bytes to try. """ return None def expandtabs(self, tabsize=8): """ B.expandtabs(tabsize=8) -> copy of B Return a copy of B where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. """ return None def extend(self, iterable_of_ints): """ B.extend(iterable_of_ints) -> None Append all the elements from the iterator or sequence to the end of B. """ return None def find(self, sub, start=None, end=None): """ B.find(sub[, start[, end]]) -> int Return the lowest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def fromhex(self, string): """ bytearray.fromhex(string) -> bytearray (static method) Create a bytearray object from a string of hexadecimal numbers. Spaces between two numbers are accepted. Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef'). """ return None def index(self, sub, start=None, end=None): """ B.index(sub[, start[, end]]) -> int Like B.find() but raise ValueError when the subsection is not found. """ return 1 def insert(self, index, int): """ B.insert(index, int) -> None Insert a single item into the bytearray before the given index. """ return None def isalnum(self): """ B.isalnum() -> bool Return True if all characters in B are alphanumeric and there is at least one character in B, False otherwise. """ return None def isalpha(self): """ B.isalpha() -> bool Return True if all characters in B are alphabetic and there is at least one character in B, False otherwise. """ return None def isdigit(self): """ B.isdigit() -> bool Return True if all characters in B are digits and there is at least one character in B, False otherwise. """ return None def islower(self): """ B.islower() -> bool Return True if all cased characters in B are lowercase and there is at least one cased character in B, False otherwise. """ return None def isspace(self): """ B.isspace() -> bool Return True if all characters in B are whitespace and there is at least one character in B, False otherwise. """ return None def istitle(self): """ B.istitle() -> bool Return True if B is a titlecased string and there is at least one character in B, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ return None def isupper(self): """ B.isupper() -> bool Return True if all cased characters in B are uppercase and there is at least one cased character in B, False otherwise. """ return None def join(self, iterable_of_bytes): """ B.join(iterable_of_bytes) -> bytearray Concatenate any number of bytes/bytearray objects, with B in between each pair, and return the result as a new bytearray. """ return None def ljust(self, width, fillchar=None): """ B.ljust(width[, fillchar]) -> copy of B Return B left justified in a string of length width. Padding is done using the specified fill character (default is a space). """ return None def lower(self): """ B.lower() -> copy of B Return a copy of B with all ASCII characters converted to lowercase. """ return None def lstrip(self, bytes=None): """ B.lstrip([bytes]) -> bytearray Strip leading bytes contained in the argument and return the result as a new bytearray. If the argument is omitted, strip leading ASCII whitespace. """ return None def maketrans(self, frm, to): """ B.maketrans(frm, to) -> translation table Return a translation table (a bytes object of length 256) suitable for use in the bytes or bytearray translate method where each byte in frm is mapped to the byte at the same position in to. The bytes objects frm and to must be of the same length. """ return None def partition(self, sep): """ B.partition(sep) -> (head, sep, tail) Search for the separator sep in B, and return the part before it, the separator itself, and the part after it. If the separator is not found, returns B and two empty bytearray objects. """ return (None, None, None) def pop(self, index=None): """ B.pop([index]) -> int Remove and return a single item from B. If no index argument is given, will pop the last value. """ return 1 def remove(self, int): """ B.remove(int) -> None Remove the first occurrence of a value in B. """ return None def replace(self, old, new, count=None): """ B.replace(old, new[, count]) -> bytearray Return a copy of B with all occurrences of subsection old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. """ return None def reverse(self): """ B.reverse() -> None Reverse the order of the values in B in place. """ return None def rfind(self, sub, start=None, end=None): """ B.rfind(sub[, start[, end]]) -> int Return the highest index in B where subsection sub is found, such that sub is contained within B[start,end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def rindex(self, sub, start=None, end=None): """ B.rindex(sub[, start[, end]]) -> int Like B.rfind() but raise ValueError when the subsection is not found. """ return 1 def rjust(self, width, fillchar=None): """ B.rjust(width[, fillchar]) -> copy of B Return B right justified in a string of length width. Padding is done using the specified fill character (default is a space) """ return None def rpartition(self, sep): """ B.rpartition(sep) -> (head, sep, tail) Search for the separator sep in B, starting at the end of B, and return the part before it, the separator itself, and the part after it. If the separator is not found, returns two empty bytearray objects and B. """ return (None, None, None) def rsplit(self, sep=None, maxsplit=_1): """ B.rsplit(sep=None, maxsplit=-1) -> list of bytearrays Return a list of the sections in B, using sep as the delimiter, starting at the end of B and working to the front. If sep is not given, B is split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab). If maxsplit is given, at most maxsplit splits are done. """ return [] def rstrip(self, bytes=None): """ B.rstrip([bytes]) -> bytearray Strip trailing bytes contained in the argument and return the result as a new bytearray. If the argument is omitted, strip trailing ASCII whitespace. """ return None def split(self, sep=None, maxsplit=_1): """ B.split(sep=None, maxsplit=-1) -> list of bytearrays Return a list of the sections in B, using sep as the delimiter. If sep is not given, B is split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab). If maxsplit is given, at most maxsplit splits are done. """ return [] def splitlines(self, keepends=None): """ B.splitlines([keepends]) -> list of lines Return a list of the lines in B, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. """ return [] def startswith(self, prefix, start=None, end=None): """ B.startswith(prefix[, start[, end]]) -> bool Return True if B starts with the specified prefix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. prefix can also be a tuple of bytes to try. """ return None def strip(self, bytes=None): """ B.strip([bytes]) -> bytearray Strip leading and trailing bytes contained in the argument and return the result as a new bytearray. If the argument is omitted, strip ASCII whitespace. """ return None def swapcase(self): """ B.swapcase() -> copy of B Return a copy of B with uppercase ASCII characters converted to lowercase ASCII and vice versa. """ return None def title(self): """ B.title() -> copy of B Return a titlecased version of B, i.e. ASCII words start with uppercase characters, all remaining cased characters have lowercase. """ return None def translate(self, table, deletechars=None): """ B.translate(table[, deletechars]) -> bytearray Return a copy of B, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a bytes object of length 256. """ return None def upper(self): """ B.upper() -> copy of B Return a copy of B with all ASCII characters converted to uppercase. """ return None def zfill(self, width): """ B.zfill(width) -> copy of B Pad a numeric string B with zeros on the left, to fill a field of the specified width. B is never truncated. """ return None class bytes(object): """ bytes(iterable_of_ints) -> bytes bytes(string, encoding[, errors]) -> bytes bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer bytes(int) -> bytes object of size given by the parameter initialized with null bytes bytes() -> empty bytes object Construct an immutable array of bytes from: - an iterable yielding integers in range(256) - a text string encoded using the specified encoding - any object implementing the buffer API. - an integer """ def capitalize(self): """ B.capitalize() -> copy of B Return a copy of B with only its first character capitalized (ASCII) and the rest lower-cased. """ return None def center(self, width, fillchar=None): """ B.center(width[, fillchar]) -> copy of B Return B centered in a string of length width. Padding is done using the specified fill character (default is a space). """ return None def count(self, sub, start=None, end=None): """ B.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string B[start:end]. Optional arguments start and end are interpreted as in slice notation. """ return 1 def decode(self, encoding='utf_8', errors='strict'): """ B.decode(encoding='utf-8', errors='strict') -> str Decode B using the codec registered for encoding. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' as well as any other name registerd with codecs.register_error that is able to handle UnicodeDecodeErrors. """ return "" def endswith(self, suffix, start=None, end=None): """ B.endswith(suffix[, start[, end]]) -> bool Return True if B ends with the specified suffix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. suffix can also be a tuple of bytes to try. """ return None def expandtabs(self, tabsize=8): """ B.expandtabs(tabsize=8) -> copy of B Return a copy of B where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. """ return None def find(self, sub, start=None, end=None): """ B.find(sub[, start[, end]]) -> int Return the lowest index in B where substring sub is found, such that sub is contained within B[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def fromhex(self, string): """ bytes.fromhex(string) -> bytes Create a bytes object from a string of hexadecimal numbers. Spaces between two numbers are accepted. Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'. """ return None def index(self, sub, start=None, end=None): """ B.index(sub[, start[, end]]) -> int Like B.find() but raise ValueError when the substring is not found. """ return 1 def isalnum(self): """ B.isalnum() -> bool Return True if all characters in B are alphanumeric and there is at least one character in B, False otherwise. """ return None def isalpha(self): """ B.isalpha() -> bool Return True if all characters in B are alphabetic and there is at least one character in B, False otherwise. """ return None def isdigit(self): """ B.isdigit() -> bool Return True if all characters in B are digits and there is at least one character in B, False otherwise. """ return None def islower(self): """ B.islower() -> bool Return True if all cased characters in B are lowercase and there is at least one cased character in B, False otherwise. """ return None def isspace(self): """ B.isspace() -> bool Return True if all characters in B are whitespace and there is at least one character in B, False otherwise. """ return None def istitle(self): """ B.istitle() -> bool Return True if B is a titlecased string and there is at least one character in B, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ return None def isupper(self): """ B.isupper() -> bool Return True if all cased characters in B are uppercase and there is at least one cased character in B, False otherwise. """ return None def join(self, iterable_of_bytes): """ B.join(iterable_of_bytes) -> bytes Concatenate any number of bytes objects, with B in between each pair. Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'. """ return None def ljust(self, width, fillchar=None): """ B.ljust(width[, fillchar]) -> copy of B Return B left justified in a string of length width. Padding is done using the specified fill character (default is a space). """ return None def lower(self): """ B.lower() -> copy of B Return a copy of B with all ASCII characters converted to lowercase. """ return None def lstrip(self, bytes=None): """ B.lstrip([bytes]) -> bytes Strip leading bytes contained in the argument. If the argument is omitted, strip leading ASCII whitespace. """ return None def maketrans(self, frm, to): """ B.maketrans(frm, to) -> translation table Return a translation table (a bytes object of length 256) suitable for use in the bytes or bytearray translate method where each byte in frm is mapped to the byte at the same position in to. The bytes objects frm and to must be of the same length. """ return None def partition(self, sep): """ B.partition(sep) -> (head, sep, tail) Search for the separator sep in B, and return the part before it, the separator itself, and the part after it. If the separator is not found, returns B and two empty bytes objects. """ return (None, None, None) def replace(self, old, new, count=None): """ B.replace(old, new[, count]) -> bytes Return a copy of B with all occurrences of subsection old replaced by new. If the optional argument count is given, only first count occurances are replaced. """ return None def rfind(self, sub, start=None, end=None): """ B.rfind(sub[, start[, end]]) -> int Return the highest index in B where substring sub is found, such that sub is contained within B[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def rindex(self, sub, start=None, end=None): """ B.rindex(sub[, start[, end]]) -> int Like B.rfind() but raise ValueError when the substring is not found. """ return 1 def rjust(self, width, fillchar=None): """ B.rjust(width[, fillchar]) -> copy of B Return B right justified in a string of length width. Padding is done using the specified fill character (default is a space) """ return None def rpartition(self, sep): """ B.rpartition(sep) -> (head, sep, tail) Search for the separator sep in B, starting at the end of B, and return the part before it, the separator itself, and the part after it. If the separator is not found, returns two empty bytes objects and B. """ return (None, None, None) def rsplit(self, sep=None, maxsplit=_1): """ B.rsplit(sep=None, maxsplit=-1) -> list of bytes Return a list of the sections in B, using sep as the delimiter, starting at the end of B and working to the front. If sep is not given, B is split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab). If maxsplit is given, at most maxsplit splits are done. """ return [] def rstrip(self, bytes=None): """ B.rstrip([bytes]) -> bytes Strip trailing bytes contained in the argument. If the argument is omitted, strip trailing ASCII whitespace. """ return None def split(self, sep=None, maxsplit=_1): """ B.split(sep=None, maxsplit=-1) -> list of bytes Return a list of the sections in B, using sep as the delimiter. If sep is not specified or is None, B is split on ASCII whitespace characters (space, tab, return, newline, formfeed, vertical tab). If maxsplit is given, at most maxsplit splits are done. """ return [] def splitlines(self, keepends=None): """ B.splitlines([keepends]) -> list of lines Return a list of the lines in B, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. """ return [] def startswith(self, prefix, start=None, end=None): """ B.startswith(prefix[, start[, end]]) -> bool Return True if B starts with the specified prefix, False otherwise. With optional start, test B beginning at that position. With optional end, stop comparing B at that position. prefix can also be a tuple of bytes to try. """ return None def strip(self, bytes=None): """ B.strip([bytes]) -> bytes Strip leading and trailing bytes contained in the argument. If the argument is omitted, strip leading and trailing ASCII whitespace. """ return None def swapcase(self): """ B.swapcase() -> copy of B Return a copy of B with uppercase ASCII characters converted to lowercase ASCII and vice versa. """ return None def title(self): """ B.title() -> copy of B Return a titlecased version of B, i.e. ASCII words start with uppercase characters, all remaining cased characters have lowercase. """ return None def translate(self, table, deletechars=None): """ B.translate(table[, deletechars]) -> bytes Return a copy of B, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a bytes object of length 256. """ return None def upper(self): """ B.upper() -> copy of B Return a copy of B with all ASCII characters converted to uppercase. """ return None def zfill(self, width): """ B.zfill(width) -> copy of B Pad a numeric string B with zeros on the left, to fill a field of the specified width. B is never truncated. """ return None def callable(object): """ callable(object) -> bool Return whether the object is callable (i.e., some kind of function). Note that classes are callable, as are instances of classes with a __call__() method. """ return None def chr(i): """ chr(i) -> Unicode character Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """ return None class classmethod(object): """ classmethod(function) -> method Convert a function to be a class method. A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom: class C: def f(cls, arg1, arg2, ...): ... f = classmethod(f) It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument. Class methods are different than C++ or Java static methods. If you want those, see the staticmethod builtin. """ def __init__(self, *args, **kwargs): return None def compile(source, filename, mode, flags=None, dont_inherit=None): """ compile(source, filename, mode[, flags[, dont_inherit]]) -> code object Compile the source (a Python module, statement or expression) into a code object that can be executed by exec() or eval(). The filename will be used for run-time error messages. The mode must be 'exec' to compile a module, 'single' to compile a single (interactive) statement, or 'eval' to compile an expression. The flags argument, if present, controls which future statements influence the compilation of the code. The dont_inherit argument, if non-zero, stops the compilation inheriting the effects of any future statements in effect in the code calling compile; if absent or zero these statements do influence the compilation, in addition to any features explicitly specified. """ return None class complex(object): """ complex(real[, imag]) -> complex number Create a complex number from a real part and an optional imaginary part. This is equivalent to (real + imag*1j) where imag defaults to 0. """ def conjugate(self): """ complex.conjugate() -> complex Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j. """ return None imag = None real = None def copyright(self): """ interactive prompt objects for printing the license text, a list of contributors and the copyright notice. """ pass def credits(self): """ interactive prompt objects for printing the license text, a list of contributors and the copyright notice. """ pass def delattr(object, name): """ delattr(object, name) Delete a named attribute on an object; delattr(x, 'y') is equivalent to ``del x.y''. """ pass class dict(object): """ dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) """ def __init__(self, *args, **kwargs): return {} def clear(self): """ D.clear() -> None. Remove all items from D. """ return None def copy(self): """ D.copy() -> a shallow copy of D """ return None def fromkeys(self, iterable, value=None): """ Returns a new dict with keys from iterable and values equal to value. """ pass def get(self, k, d=None): """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ return None def items(self): """ D.items() -> a set-like object providing a view on D's items """ return None def keys(self): """ D.keys() -> a set-like object providing a view on D's keys """ return None def pop(self, k, d=None): """ D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised """ return None def popitem(self): """ D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty. """ return None def setdefault(self, k, d=None): """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ return None def update(self, E=None, **F): """ D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k] """ return {} def values(self): """ D.values() -> an object providing a view on D's values """ return None def dir(object=None): """ dir([object]) -> list of strings If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named __dir__, it will be used; otherwise the default dir() logic is used and returns: for a module object: the module's attributes. for a class object: its attributes, and recursively the attributes of its bases. for any other object: its attributes, its class's attributes, and recursively the attributes of its class's base classes. """ return [] def divmod(x, y): """ divmod(x, y) -> (div, mod) Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x. """ return (None, None) class enumerate(object): """ enumerate(iterable[, start]) -> iterator for index, value of iterable Return an enumerate object. iterable must be another object that supports iteration. The enumerate object yields pairs containing a count (from start, which defaults to zero) and a value yielded by the iterable argument. enumerate is useful for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ... """ pass def eval(source, globals=None, locals=None): """ eval(source[, globals[, locals]]) -> value Evaluate the source in the context of globals and locals. The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it. """ return None def exec(object, globals=None, locals=None): """ exec(object[, globals[, locals]]) Read and execute code from an object, which can be a string or a code object. The globals and locals are dictionaries, defaulting to the current globals and locals. If only globals is given, locals defaults to it. """ pass def exit(code=None): pass class filter(object): """ filter(function or None, iterable) --> filter object Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true. """ pass class float(object): """ float(x) -> floating point number Convert a string or number to a floating point number, if possible. """ def as_integer_ratio(self): """ float.as_integer_ratio() -> (int, int) Return a pair of integers, whose ratio is exactly equal to the original float and with a positive denominator. Raise OverflowError on infinities and a ValueError on NaNs. >>> (10.0).as_integer_ratio() (10, 1) >>> (0.0).as_integer_ratio() (0, 1) >>> (-.25).as_integer_ratio() (-1, 4) """ return (1, 1) def conjugate(self): """ Return self, the complex conjugate of any float. """ pass def fromhex(self, string): """ float.fromhex(string) -> float Create a floating-point number from a hexadecimal string. >>> float.fromhex('0x1.ffffp10') 2047.984375 >>> float.fromhex('-0x1p-1074') -5e-324 """ return 1.0 def hex(self): """ float.hex() -> string Return a hexadecimal representation of a floating-point number. >>> (-0.1).hex() '-0x1.999999999999ap-4' >>> 3.14159.hex() '0x1.921f9f01b866ep+1' """ return "" imag = property(None, None, None, """ the imaginary part of a complex number """ ) def is_integer(self): """ Return True if the float is an integer. """ pass real = property(None, None, None, """ the real part of a complex number """ ) def format(value, format_spec=None): """ format(value[, format_spec]) -> string Returns value.__format__(format_spec) format_spec defaults to "" """ return "" class frozenset(object): """ frozenset() -> empty frozenset object frozenset(iterable) -> frozenset object Build an immutable unordered collection of unique elements. """ def copy(self): """ Return a shallow copy of a set. """ pass def difference(self, arg0): """ Return the difference of two or more sets as a new set. (i.e. all elements that are in this set but not the others.) """ pass def intersection(self, arg0): """ Return the intersection of two sets as a new set. (i.e. all elements that are in both sets.) """ pass def isdisjoint(self): """ Return True if two sets have a null intersection. """ pass def issubset(self): """ Report whether another set contains this set. """ pass def issuperset(self): """ Report whether this set contains another set. """ pass def symmetric_difference(self, arg0): """ Return the symmetric difference of two sets as a new set. (i.e. all elements that are in exactly one of the sets.) """ pass def union(self, arg0): """ Return the union of sets as a new set. (i.e. all elements that are in either set.) """ pass def getattr(object, name, default=None): """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case. """ return None def globals(): """ globals() -> dictionary Return the dictionary containing the current scope's global variables. """ return {} def hasattr(object, name): """ hasattr(object, name) -> bool Return whether the object has an attribute with the given name. (This is done by calling getattr(object, name) and catching AttributeError.) """ return None def hash(object): """ hash(object) -> integer Return a hash value for the object. Two objects with the same value have the same hash value. The reverse is not necessarily true, but likely. """ return 1 def help(*args, **kwds): """ Define the builtin 'help'. This is a wrapper around pydoc.help (with a twist). """ pass def hex(number): """ hex(number) -> string Return the hexadecimal representation of an integer. >>> hex(3735928559) '0xdeadbeef' """ return "" def id(object): """ id(object) -> integer Return the identity of an object. This is guaranteed to be unique among simultaneously existing objects. (Hint: it's the object's memory address.) """ return 1 def input(prompt=None): """ input([prompt]) -> string Read a string from standard input. The trailing newline is stripped. If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError. On Unix, GNU readline is used if enabled. The prompt string, if given, is printed without a trailing newline before reading. """ return "" class int(object): """ int(x=0) -> integer int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4 """ def bit_length(self): """ int.bit_length() -> int Number of bits necessary to represent self in binary. >>> bin(37) '0b100101' >>> (37).bit_length() 6 """ return 1 def conjugate(self): """ Returns self, the complex conjugate of any int. """ pass denominator = property(None, None, None, """ the denominator of a rational number in lowest terms """ ) def from_bytes(self, bytes, byteorder, arg0, signed=False): """ int.from_bytes(bytes, byteorder, *, signed=False) -> int Return the integer represented by the given array of bytes. The bytes argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol. The byteorder argument determines the byte order used to represent the integer. If byteorder is 'big', the most significant byte is at the beginning of the byte array. If byteorder is 'little', the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder' as the byte order value. The signed keyword-only argument indicates whether two's complement is used to represent the integer. """ return 1 imag = property(None, None, None, """ the imaginary part of a complex number """ ) numerator = property(None, None, None, """ the numerator of a rational number in lowest terms """ ) real = property(None, None, None, """ the real part of a complex number """ ) def to_bytes(self, length, byteorder, arg0, signed=False): """ int.to_bytes(length, byteorder, *, signed=False) -> bytes Return an array of bytes representing an integer. The integer is represented using length bytes. An OverflowError is raised if the integer is not representable with the given number of bytes. The byteorder argument determines the byte order used to represent the integer. If byteorder is 'big', the most significant byte is at the beginning of the byte array. If byteorder is 'little', the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder' as the byte order value. The signed keyword-only argument determines whether two's complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised. """ return None def isinstance(object, class_or_type_or_tuple): """ isinstance(object, class-or-type-or-tuple) -> bool Return whether an object is an instance of a class or of a subclass thereof. With a type as second argument, return whether that is the object's type. The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for isinstance(x, A) or isinstance(x, B) or ... (etc.). """ return None def issubclass(C, B): """ issubclass(C, B) -> bool Return whether class C is a subclass (i.e., a derived class) of class B. When using a tuple as the second argument issubclass(X, (A, B, ...)), is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.). """ return None def iter(iterable): """ iter(iterable) -> iterator iter(callable, sentinel) -> iterator Get an iterator from an object. In the first form, the argument must supply its own iterator, or be a sequence. In the second form, the callable is called until it returns the sentinel. """ return None def len(module, object): """ len(module, object) Return the number of items of a sequence or mapping. """ pass def license(self): """ interactive prompt objects for printing the license text, a list of contributors and the copyright notice. """ pass class list(object): """ list() -> new empty list list(iterable) -> new list initialized from iterable's items """ def __init__(self, *args, **kwargs): return [] def append(self, object): """ L.append(object) -> None -- append object to end """ return None def clear(self): """ L.clear() -> None -- remove all items from L """ return None def copy(self): """ L.copy() -> list -- a shallow copy of L """ return [] def count(self, value): """ L.count(value) -> integer -- return number of occurrences of value """ return 1 def extend(self, iterable): """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """ return None def index(self, value, start=None, stop=None): """ L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 1 def insert(self, index, object): """ L.insert(index, object) -- insert object before index """ return None def pop(self, index=None): """ L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """ return None def remove(self, value): """ L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present. """ return None def reverse(self): """ L.reverse() -- reverse *IN PLACE* """ return None def sort(self, key=None, reverse=False): """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """ return None def locals(): """ locals() -> dictionary Update and return a dictionary containing the current scope's local variables. """ return {} class map(object): """ map(func, *iterables) --> map object Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted. """ pass def max(iterable, key=func): """ max(iterable[, key=func]) -> value max(a, b, c, ...[, key=func]) -> value With a single iterable argument, return its largest item. With two or more arguments, return the largest argument. """ return None class memoryview(object): """ memoryview(object) Create a new memoryview object which references the given object. """ c_contiguous = property(None, None, None, """ A bool indicating whether the memory is C contiguous. """ ) def cast(self, format, shape=None): """ M.cast(format[, shape]) -> memoryview Cast a memoryview to a new format or shape. """ return None contiguous = property(None, None, None, """ A bool indicating whether the memory is contiguous. """ ) f_contiguous = property(None, None, None, """ A bool indicating whether the memory is Fortran contiguous. """ ) format = property(None, None, None, """ A string containing the format (in struct module style) for each element in the view. """ ) itemsize = property(None, None, None, """ The size in bytes of each element of the memoryview. """ ) nbytes = property(None, None, None, """ The amount of space in bytes that the array would use in a contiguous representation. """ ) ndim = property(None, None, None, """ An integer indicating how many dimensions of a multi-dimensional array the memory represents. """ ) obj = property(None, None, None, """ The underlying object of the memoryview. """ ) readonly = property(None, None, None, """ A bool indicating whether the memory is read only. """ ) def release(self): """ M.release() -> None Release the underlying buffer exposed by the memoryview object. """ return None shape = property(None, None, None, """ A tuple of ndim integers giving the shape of the memory as an N-dimensional array. """ ) strides = property(None, None, None, """ A tuple of ndim integers giving the size in bytes to access each element for each dimension of the array. """ ) suboffsets = property(None, None, None, """ A tuple of integers used internally for PIL-style arrays. """ ) def tobytes(self): """ M.tobytes() -> bytes Return the data in the buffer as a byte string. """ return None def tolist(self): """ M.tolist() -> list Return the data in the buffer as a list of elements. """ return [] def min(iterable, key=func): """ min(iterable[, key=func]) -> value min(a, b, c, ...[, key=func]) -> value With a single iterable argument, return its smallest item. With two or more arguments, return the smallest argument. """ return None def next(iterator, default=None): """ next(iterator[, default]) Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration. """ pass class object: """ The most base type """ def __init__(self, *args, **kwargs): """ Initialize self. See help(type(self)) for accurate signature. """ pass def oct(number): """ oct(number) -> string Return the octal representation of an integer. >>> oct(342391) '0o1234567' """ return "" def open(file, mode='r', buffering=_1, encoding=None, errors=None, newline=None, closefd=True, opener=None): """ open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) -> file object Open file and return a stream. Raise IOError upon failure. file is either a text or byte string giving the name (and the path if the file isn't in the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.) mode is an optional string that specifies the mode in which the file is opened. It defaults to 'r' which means open for reading in text mode. Other common values are 'w' for writing (truncating the file if it already exists), 'x' for creating and writing to a new file, and 'a' for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform dependent: locale.getpreferredencoding(False) is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are: ========= =============================================================== Character Meaning --------- --------------------------------------------------------------- 'r' open for reading (default) 'w' open for writing, truncating the file first 'x' create a new file and open it for writing 'a' open for writing, appending to the end of the file if it exists 'b' binary mode 't' text mode (default) '+' open a disk file for updating (reading and writing) 'U' universal newline mode (deprecated) ========= =============================================================== The default mode is 'rt' (open for reading text). For binary random access, the mode 'w+b' opens and truncates the file to 0 bytes, while 'r+b' opens the file without truncation. The 'x' mode implies 'w' and raises an `FileExistsError` if the file already exists. Python distinguishes between files opened in binary and text modes, even when the underlying operating system doesn't. Files opened in binary mode (appending 'b' to the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when 't' is appended to the mode argument), the contents of the file are returned as strings, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given. 'U' mode is deprecated and will raise an exception in future versions of Python. It has no effect in Python 3. Use newline to control universal newlines mode. buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer > 1 to indicate the size of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows: * Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device's "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`. On many systems, the buffer will typically be 4096 or 8192 bytes long. * "Interactive" text files (files for which isatty() returns True) use line buffering. Other text files use the policy described above for binary files. encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent, but any encoding supported by Python can be passed. See the codecs module for the list of supported encodings. errors is an optional string that specifies how encoding errors are to be handled---this argument should not be used in binary mode. Pass 'strict' to raise a ValueError exception if there is an encoding error (the default of None has the same effect), or pass 'ignore' to ignore errors. (Note that ignoring encoding errors can lead to data loss.) See the documentation for codecs.register or run 'help(codecs.Codec)' for a list of the permitted encoding error strings. newline controls how universal newlines works (it only applies to text mode). It can be None, '', '\\n', '\\r', and '\\r\\n'. It works as follows: * On input, if newline is None, universal newlines mode is enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and these are translated into '\\n' before being returned to the caller. If it is '', universal newline mode is enabled, but line endings are returned to the caller untranslated. If it has any of the other legal values, input lines are only terminated by the given string, and the line ending is returned to the caller untranslated. * On output, if newline is None, any '\\n' characters written are translated to the system default line separator, os.linesep. If newline is '' or '\\n', no translation takes place. If newline is any of the other legal values, any '\\n' characters written are translated to the given string. If closefd is False, the underlying file descriptor will be kept open when the file is closed. This does not work when a file name is given and must be True in that case. A custom opener can be used by passing a callable as *opener*. The underlying file descriptor for the file object is then obtained by calling *opener* with (*file*, *flags*). *opener* must return an open file descriptor (passing os.open as *opener* results in functionality similar to passing None). open() returns a file object whose type depends on the mode, and through which the standard file operations such as reading and writing are performed. When open() is used to open a file in a text mode ('w', 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open a file in a binary mode, the returned class varies: in read binary mode, it returns a BufferedReader; in write binary and append binary modes, it returns a BufferedWriter, and in read/write mode, it returns a BufferedRandom. It is also possible to use a string or bytearray as a file for both reading and writing. For strings StringIO can be used like a file opened in a text mode, and for bytes a BytesIO can be used like a file opened in a binary mode. """ import io return io.TextIOWrapper() def ord(c): """ ord(c) -> integer Return the integer ordinal of a one-character string. """ return 1 def pow(x, y, z=None): """ pow(x, y[, z]) -> number With two arguments, equivalent to x**y. With three arguments, equivalent to (x**y) % z, but may be more efficient (e.g. for ints). """ return None class property(object): """ property(fget=None, fset=None, fdel=None, doc=None) -> property attribute fget is a function to be used for getting an attribute value, and likewise fset is a function for setting, and fdel a function for del'ing, an attribute. Typical use is to define a managed attribute x: class C(object): def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.") Decorators make defining new properties or modifying existing ones easy: class C(object): @property def x(self): "I am the 'x' property." return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x """ def __init__(self, *args, **kwargs): return None def deleter(self): """ Descriptor to change the deleter on a property. """ pass fdel = None fget = None fset = None def getter(self): """ Descriptor to change the getter on a property. """ pass def setter(self): """ Descriptor to change the setter on a property. """ pass def quit(code=None): pass class range(object): """ range(stop) -> range object range(start, stop[, step]) -> range object Return a virtual sequence of numbers from start to stop by step. """ def count(self, value): """ rangeobject.count(value) -> integer -- return number of occurrences of value """ return 1 def index(self, value, start=None, stop=None): """ rangeobject.index(value, [start, [stop]]) -> integer -- return index of value. Raise ValueError if the value is not present. """ return 1 start = None step = None stop = None def repr(object): """ repr(object) -> string Return the canonical string representation of the object. For most object types, eval(repr(object)) == object. """ return "" class reversed(object): """ reversed(sequence) -> reverse iterator over values of the sequence Return a reverse iterator """ pass def round(number, ndigits=None): """ round(number[, ndigits]) -> number Round a number to a given precision in decimal digits (default 0 digits). This returns an int when called with one argument, otherwise the same type as the number. ndigits may be negative. """ return None class set(object): """ set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements. """ def __init__(self, *args, **kwargs): return None def add(self): """ Add an element to a set. This has no effect if the element is already present. """ pass def clear(self): """ Remove all elements from this set. """ pass def copy(self): """ Return a shallow copy of a set. """ pass def difference(self, arg0): """ Return the difference of two or more sets as a new set. (i.e. all elements that are in this set but not the others.) """ pass def difference_update(self): """ Remove all elements of another set from this set. """ pass def discard(self): """ Remove an element from a set if it is a member. If the element is not a member, do nothing. """ pass def intersection(self, arg0): """ Return the intersection of two sets as a new set. (i.e. all elements that are in both sets.) """ pass def intersection_update(self): """ Update a set with the intersection of itself and another. """ pass def isdisjoint(self): """ Return True if two sets have a null intersection. """ pass def issubset(self): """ Report whether another set contains this set. """ pass def issuperset(self): """ Report whether this set contains another set. """ pass def pop(self): """ Remove and return an arbitrary set element. Raises KeyError if the set is empty. """ pass def remove(self): """ Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError. """ pass def symmetric_difference(self, arg0): """ Return the symmetric difference of two sets as a new set. (i.e. all elements that are in exactly one of the sets.) """ pass def symmetric_difference_update(self): """ Update a set with the symmetric difference of itself and another. """ pass def union(self, arg0): """ Return the union of sets as a new set. (i.e. all elements that are in either set.) """ pass def update(self): """ Update a set with the union of itself and others. """ pass def setattr(object, name, value): """ setattr(object, name, value) Set a named attribute on an object; setattr(x, 'y', v) is equivalent to ``x.y = v''. """ pass class slice(object): """ slice(stop) slice(start, stop[, step]) Create a slice object. This is used for extended slicing (e.g. a[0:10:2]). """ def indices(self, len): """ S.indices(len) -> (start, stop, stride) Assuming a sequence of length len, calculate the start and stop indices, and the stride length of the extended slice described by S. Out of bounds indices are clipped in a manner consistent with the handling of normal slices. """ return (None, None, "") start = None step = None stop = None def sorted(iterable, key=None, reverse=False): """ sorted(iterable, key=None, reverse=False) --> new sorted list """ return [] class staticmethod(object): """ staticmethod(function) -> method Convert a function to be a static method. A static method does not receive an implicit first argument. To declare a static method, use this idiom: class C: def f(arg1, arg2, ...): ... f = staticmethod(f) It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see the classmethod builtin. """ def __init__(self, *args, **kwargs): return None class str(object): """ str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to 'strict'. """ def capitalize(self): """ S.capitalize() -> str Return a capitalized version of S, i.e. make the first character have upper case and the rest lower case. """ return "" def casefold(self): """ S.casefold() -> str Return a version of S suitable for caseless comparisons. """ return "" def center(self, width, fillchar=None): """ S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is done using the specified fill character (default is a space) """ return "" def count(self, sub, start=None, end=None): """ S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation. """ return 1 def encode(self, encoding='utf_8', errors='strict'): """ S.encode(encoding='utf-8', errors='strict') -> bytes Encode S using the codec registered for encoding. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors. """ return None def endswith(self, suffix, start=None, end=None): """ S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try. """ return None def expandtabs(self, tabsize=8): """ S.expandtabs(tabsize=8) -> str Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed. """ return "" def find(self, sub, start=None, end=None): """ S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def format(self, arg0, arg1): """ S.format(*args, **kwargs) -> str Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}'). """ return "" def format_map(self, mapping): """ S.format_map(mapping) -> str Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces ('{' and '}'). """ return "" def index(self, sub, start=None, end=None): """ S.index(sub[, start[, end]]) -> int Like S.find() but raise ValueError when the substring is not found. """ return 1 def isalnum(self): """ S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise. """ return None def isalpha(self): """ S.isalpha() -> bool Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise. """ return None def isdecimal(self): """ S.isdecimal() -> bool Return True if there are only decimal characters in S, False otherwise. """ return None def isdigit(self): """ S.isdigit() -> bool Return True if all characters in S are digits and there is at least one character in S, False otherwise. """ return None def isidentifier(self): """ S.isidentifier() -> bool Return True if S is a valid identifier according to the language definition. Use keyword.iskeyword() to test for reserved identifiers such as "def" and "class". """ return None def islower(self): """ S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise. """ return None def isnumeric(self): """ S.isnumeric() -> bool Return True if there are only numeric characters in S, False otherwise. """ return None def isprintable(self): """ S.isprintable() -> bool Return True if all characters in S are considered printable in repr() or S is empty, False otherwise. """ return None def isspace(self): """ S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise. """ return None def istitle(self): """ S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. upper- and titlecase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ return None def isupper(self): """ S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise. """ return None def join(self, iterable): """ S.join(iterable) -> str Return a string which is the concatenation of the strings in the iterable. The separator between elements is S. """ return "" def ljust(self, width, fillchar=None): """ S.ljust(width[, fillchar]) -> str Return S left-justified in a Unicode string of length width. Padding is done using the specified fill character (default is a space). """ return "" def lower(self): """ S.lower() -> str Return a copy of the string S converted to lowercase. """ return "" def lstrip(self, chars=None): """ S.lstrip([chars]) -> str Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead. """ return "" def maketrans(self, x, y=None, z=None): """ Return a translation table usable for str.translate(). If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result. """ pass def partition(self, sep): """ S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return S and two empty strings. """ return (None, None, None) def replace(self, old, new, count=None): """ S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. """ return "" def rfind(self, sub, start=None, end=None): """ S.rfind(sub[, start[, end]]) -> int Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. """ return 1 def rindex(self, sub, start=None, end=None): """ S.rindex(sub[, start[, end]]) -> int Like S.rfind() but raise ValueError when the substring is not found. """ return 1 def rjust(self, width, fillchar=None): """ S.rjust(width[, fillchar]) -> str Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space). """ return "" def rpartition(self, sep): """ S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return two empty strings and S. """ return (None, None, None) def rsplit(self, sep=None, maxsplit=_1): """ S.rsplit(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified, any whitespace string is a separator. """ return [] def rstrip(self, chars=None): """ S.rstrip([chars]) -> str Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead. """ return "" def split(self, sep=None, maxsplit=_1): """ S.split(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result. """ return [] def splitlines(self, keepends=None): """ S.splitlines([keepends]) -> list of strings Return a list of the lines in S, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true. """ return [] def startswith(self, prefix, start=None, end=None): """ S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try. """ return None def strip(self, chars=None): """ S.strip([chars]) -> str Return a copy of the string S with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead. """ return "" def swapcase(self): """ S.swapcase() -> str Return a copy of S with uppercase characters converted to lowercase and vice versa. """ return "" def title(self): """ S.title() -> str Return a titlecased version of S, i.e. words start with title case characters, all remaining cased characters have lower case. """ return "" def translate(self, table): """ S.translate(table) -> str Return a copy of the string S, where all characters have been mapped through the given translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None. Unmapped characters are left untouched. Characters mapped to None are deleted. """ return "" def upper(self): """ S.upper() -> str Return a copy of S converted to uppercase. """ return "" def zfill(self, width): """ S.zfill(width) -> str Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated. """ return "" def sum(iterable, start=None): """ sum(iterable[, start]) -> value Return the sum of an iterable of numbers (NOT strings) plus the value of parameter 'start' (which defaults to 0). When the iterable is empty, return start. """ return None class super(object): """ super() -> same as super(__class__, ) super(type) -> unbound super object super(type, obj) -> bound super object; requires isinstance(obj, type) super(type, type2) -> bound super object; requires issubclass(type2, type) Typical use to call a cooperative superclass method: class C(B): def meth(self, arg): super().meth(arg) This works for class methods too: class C(B): @classmethod def cmeth(cls, arg): super().cmeth(arg) """ def __init__(self, *args, **kwargs): return None class tuple(object): """ tuple() -> empty tuple tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object. """ def count(self, value): """ T.count(value) -> integer -- return number of occurrences of value """ return 1 def index(self, value, start=None, stop=None): """ T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 1 class type(object): """ type(object_or_name, bases, dict) type(object) -> the object's type type(name, bases, dict) -> a new type """ def __init__(self, *args, **kwargs): pass def mro(self): """ mro() -> list return a type's method resolution order """ return [] def vars(object=None): """ vars([object]) -> dictionary Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__. """ return {} class zip(object): """ zip(iter1 [,iter2 [...]]) --> zip object Return a zip object whose .__next__() method returns a tuple where the i-th element comes from the i-th iterable argument. The .__next__() method continues until the shortest iterable in the argument sequence is exhausted and then it raises StopIteration. """ pass # BEGIN MANUAL OVERRIDES FROM static-pi-files/3.0/builtinsoverride.py __builtins__ = {} __cached__ = '/home/shared/src/ide/build-files/static-pi-files/3.0/__pycache__/builtinsoverride.cpython-34.pyc' __doc__ = None __file__ = '/home/shared/src/ide/build-files/static-pi-files/3.0/builtinsoverride.py' __loader__ = None __name__ = 'builtinsoverride' __package__ = '' def print(value='', sep=' ', end='\n', file=sys.stdout, flush=False): """print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.""" pass # END MANUAL OVERRIDES