# Constant Field Values

## Contents

- com.ziclix.*
- org.python.*

## com.ziclix.*

com.ziclix.python.sql.PyStatement
`public static final int` `STATEMENT_CALLABLE` `8`
`public static final int` `STATEMENT_PREPARED` `4`
`public static final int` `STATEMENT_STATIC` `2`

## org.python.*

org.python.core.BuiltinDocs
`public static final java.lang.String` `BaseException___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `BaseException___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `BaseException___dict___doc` `""`
`public static final java.lang.String` `BaseException___format___doc` `"default object formatter"`
`public static final java.lang.String` `BaseException___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `BaseException___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `BaseException___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `BaseException___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `BaseException___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `BaseException___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `BaseException___reduce___doc` `""`
`public static final java.lang.String` `BaseException___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `BaseException___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `BaseException___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `BaseException___setstate___doc` `""`
`public static final java.lang.String` `BaseException___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `BaseException___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `BaseException___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `BaseException___unicode___doc` `""`
`public static final java.lang.String` `BaseException_args_doc` `""`
`public static final java.lang.String` `BaseException_doc` `"Common base class for all exceptions"`
`public static final java.lang.String` `BaseException_message_doc` `""`
`public static final java.lang.String` `basestring___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `basestring___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `basestring___format___doc` `"default object formatter"`
`public static final java.lang.String` `basestring___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `basestring___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `basestring___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `basestring___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `basestring___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `basestring___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `basestring___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `basestring___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `basestring___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `basestring___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `basestring___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `basestring_doc` `"Type basestring cannot be instantiated; it is the base for str and unicode."`
`public static final java.lang.String` `bool___abs___doc` `"x.__abs__() <==> abs(x)"`
`public static final java.lang.String` `bool___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `bool___and___doc` `"x.__and__(y) <==> x&y"`
`public static final java.lang.String` `bool___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `bool___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `bool___coerce___doc` `"x.__coerce__(y) <==> coerce(x, y)"`
`public static final java.lang.String` `bool___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `bool___div___doc` `"x.__div__(y) <==> x/y"`
`public static final java.lang.String` `bool___divmod___doc` `"x.__divmod__(y) <==> divmod(x, y)"`
`public static final java.lang.String` `bool___float___doc` `"x.__float__() <==> float(x)"`
`public static final java.lang.String` `bool___floordiv___doc` `"x.__floordiv__(y) <==> x//y"`
`public static final java.lang.String` `bool___format___doc` `""`
`public static final java.lang.String` `bool___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `bool___getnewargs___doc` `""`
`public static final java.lang.String` `bool___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `bool___hex___doc` `"x.__hex__() <==> hex(x)"`
`public static final java.lang.String` `bool___index___doc` `"x[y:z] <==> x[y.__index__():z.__index__()]"`
`public static final java.lang.String` `bool___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `bool___int___doc` `"x.__int__() <==> int(x)"`
`public static final java.lang.String` `bool___invert___doc` `"x.__invert__() <==> ~x"`
`public static final java.lang.String` `bool___long___doc` `"x.__long__() <==> long(x)"`
`public static final java.lang.String` `bool___lshift___doc` `"x.__lshift__(y) <==> x<<y"`
`public static final java.lang.String` `bool___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `bool___mul___doc` `"x.__mul__(y) <==> x*y"`
`public static final java.lang.String` `bool___neg___doc` `"x.__neg__() <==> -x"`
`public static final java.lang.String` `bool___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `bool___nonzero___doc` `"x.__nonzero__() <==> x != 0"`
`public static final java.lang.String` `bool___oct___doc` `"x.__oct__() <==> oct(x)"`
`public static final java.lang.String` `bool___or___doc` `"x.__or__(y) <==> x|y"`
`public static final java.lang.String` `bool___pos___doc` `"x.__pos__() <==> +x"`
`public static final java.lang.String` `bool___pow___doc` `"x.__pow__(y[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `bool___radd___doc` `"x.__radd__(y) <==> y+x"`
`public static final java.lang.String` `bool___rand___doc` `"x.__rand__(y) <==> y&x"`
`public static final java.lang.String` `bool___rdiv___doc` `"x.__rdiv__(y) <==> y/x"`
`public static final java.lang.String` `bool___rdivmod___doc` `"x.__rdivmod__(y) <==> divmod(y, x)"`
`public static final java.lang.String` `bool___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `bool___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `bool___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `bool___rfloordiv___doc` `"x.__rfloordiv__(y) <==> y//x"`
`public static final java.lang.String` `bool___rlshift___doc` `"x.__rlshift__(y) <==> y<<x"`
`public static final java.lang.String` `bool___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `bool___rmul___doc` `"x.__rmul__(y) <==> y*x"`
`public static final java.lang.String` `bool___ror___doc` `"x.__ror__(y) <==> y|x"`
`public static final java.lang.String` `bool___rpow___doc` `"y.__rpow__(x[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `bool___rrshift___doc` `"x.__rrshift__(y) <==> y>>x"`
`public static final java.lang.String` `bool___rshift___doc` `"x.__rshift__(y) <==> x>>y"`
`public static final java.lang.String` `bool___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `bool___rtruediv___doc` `"x.__rtruediv__(y) <==> y/x"`
`public static final java.lang.String` `bool___rxor___doc` `"x.__rxor__(y) <==> y^x"`
`public static final java.lang.String` `bool___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `bool___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `bool___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `bool___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `bool___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `bool___truediv___doc` `"x.__truediv__(y) <==> x/y"`
`public static final java.lang.String` `bool___trunc___doc` `"Truncating an Integral returns itself."`
`public static final java.lang.String` `bool___xor___doc` `"x.__xor__(y) <==> x^y"`
`public static final java.lang.String` `bool_bit_length_doc` `"int.bit_length() -> int\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37)\n\'0b100101\'\n>>> (37).bit_length()\n6"`
`public static final java.lang.String` `bool_conjugate_doc` `"Returns self, the complex conjugate of any int."`
`public static final java.lang.String` `bool_denominator_doc` `"the denominator of a rational number in lowest terms"`
`public static final java.lang.String` `bool_doc` `"bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed."`
`public static final java.lang.String` `bool_imag_doc` `"the imaginary part of a complex number"`
`public static final java.lang.String` `bool_numerator_doc` `"the numerator of a rational number in lowest terms"`
`public static final java.lang.String` `bool_real_doc` `"the real part of a complex number"`
`public static final java.lang.String` `buffer___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `buffer___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `buffer___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `buffer___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `buffer___delitem___doc` `"x.__delitem__(y) <==> del x[y]"`
`public static final java.lang.String` `buffer___delslice___doc` `"x.__delslice__(i, j) <==> del x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `buffer___format___doc` `"default object formatter"`
`public static final java.lang.String` `buffer___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `buffer___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `buffer___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `buffer___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `buffer___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `buffer___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `buffer___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `buffer___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `buffer___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `buffer___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `buffer___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `buffer___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `buffer___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `buffer___setitem___doc` `"x.__setitem__(i, y) <==> x[i]=y"`
`public static final java.lang.String` `buffer___setslice___doc` `"x.__setslice__(i, j, y) <==> x[i:j]=y\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `buffer___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `buffer___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `buffer___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `buffer_doc` `"buffer(object [, offset[, size]])\n\nCreate a new buffer object which references the given object.\nThe buffer will reference a slice of the target object from the\nstart of the object (or at the specified offset). The slice will\nextend to the end of the target object (or with the specified size)."`
`public static final java.lang.String` `bytearray___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `bytearray___alloc___doc` `"B.__alloc__() -> int\n\nReturns the number of bytes actually allocated."`
`public static final java.lang.String` `bytearray___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `bytearray___contains___doc` `"x.__contains__(y) <==> y in x"`
`public static final java.lang.String` `bytearray___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `bytearray___delitem___doc` `"x.__delitem__(y) <==> del x[y]"`
`public static final java.lang.String` `bytearray___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `bytearray___format___doc` `"default object formatter"`
`public static final java.lang.String` `bytearray___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `bytearray___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `bytearray___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `bytearray___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `bytearray___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `bytearray___iadd___doc` `"x.__iadd__(y) <==> x+=y"`
`public static final java.lang.String` `bytearray___imul___doc` `"x.__imul__(y) <==> x*=y"`
`public static final java.lang.String` `bytearray___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `bytearray___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `bytearray___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `bytearray___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `bytearray___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `bytearray___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `bytearray___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `bytearray___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `bytearray___reduce___doc` `"Return state information for pickling."`
`public static final java.lang.String` `bytearray___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `bytearray___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `bytearray___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `bytearray___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `bytearray___setitem___doc` `"x.__setitem__(i, y) <==> x[i]=y"`
`public static final java.lang.String` `bytearray___sizeof___doc` `"B.__sizeof__() -> int\n \nReturns the size of B in memory, in bytes"`
`public static final java.lang.String` `bytearray___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `bytearray___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `bytearray_append_doc` `"B.append(int) -> None\n\nAppend a single item to the end of B."`
`public static final java.lang.String` `bytearray_capitalize_doc` `"B.capitalize() -> copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased."`
`public static final java.lang.String` `bytearray_center_doc` `"B.center(width[, fillchar]) -> copy of B\n\nReturn B centered in a string of length width. Padding is\ndone using the specified fill character (default is a space)."`
`public static final java.lang.String` `bytearray_count_doc` `"B.count(sub [,start [,end]]) -> int\n\nReturn the number of non-overlapping occurrences of subsection sub in\nbytes B[start:end]. Optional arguments start and end are interpreted\nas in slice notation."`

`public static final java.lang.String`

`bytearray_decode_doc`

`"B.decode([encoding[, errors]]) -> unicode object.\n\nDecodes B using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registered with codecs.register_error that is\nable to handle UnicodeDecodeErrors."`

`public static final java.lang.String`

`bytearray_doc`

`"bytearray(iterable_of_ints) -> bytearray.\nbytearray(string, encoding[, errors]) -> bytearray.\nbytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.\nbytearray(memory_view) -> bytearray.\n\nConstruct an mutable bytearray object from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - a bytes or a bytearray object\n - any object implementing the buffer API.\n\nbytearray(int) -> bytearray.\n\nConstruct a zero-initialized bytearray of the given length."`

`public static final java.lang.String` `bytearray_endswith_doc` `"B.endswith(suffix [,start [,end]]) -> bool\n\nReturn True if B ends with the specified suffix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nsuffix can also be a tuple of strings to try."`
`public static final java.lang.String` `bytearray_expandtabs_doc` `"B.expandtabs([tabsize]) -> copy of B\n\nReturn a copy of B where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."`
`public static final java.lang.String` `bytearray_extend_doc` `"B.extend(iterable int) -> None\n\nAppend all the elements from the iterator or sequence to the\nend of B."`
`public static final java.lang.String` `bytearray_find_doc` `"B.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within s[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `bytearray_fromhex_doc` `"bytearray.fromhex(string) -> bytearray\n\nCreate a bytearray object from a string of hexadecimal numbers.\nSpaces between two numbers are accepted.\nExample: bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\xb9\\x01\\xef\')."`
`public static final java.lang.String` `bytearray_index_doc` `"B.index(sub [,start [,end]]) -> int\n\nLike B.find() but raise ValueError when the subsection is not found."`
`public static final java.lang.String` `bytearray_insert_doc` `"B.insert(index, int) -> None\n\nInsert a single item into the bytearray before the given index."`
`public static final java.lang.String` `bytearray_isalnum_doc` `"B.isalnum() -> bool\n\nReturn True if all characters in B are alphanumeric\nand there is at least one character in B, False otherwise."`
`public static final java.lang.String` `bytearray_isalpha_doc` `"B.isalpha() -> bool\n\nReturn True if all characters in B are alphabetic\nand there is at least one character in B, False otherwise."`
`public static final java.lang.String` `bytearray_isdigit_doc` `"B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise."`
`public static final java.lang.String` `bytearray_islower_doc` `"B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise."`
`public static final java.lang.String` `bytearray_isspace_doc` `"B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise."`
`public static final java.lang.String` `bytearray_istitle_doc` `"B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise."`
`public static final java.lang.String` `bytearray_isupper_doc` `"B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise."`
`public static final java.lang.String` `bytearray_join_doc` `"B.join(iterable_of_bytes) -> bytes\n\nConcatenates any number of bytearray objects, with B in between each pair."`
`public static final java.lang.String` `bytearray_ljust_doc` `"B.ljust(width[, fillchar]) -> copy of B\n\nReturn B left justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)."`
`public static final java.lang.String` `bytearray_lower_doc` `"B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase."`
`public static final java.lang.String` `bytearray_lstrip_doc` `"B.lstrip([bytes]) -> bytearray\n\nStrip leading bytes contained in the argument.\nIf the argument is omitted, strip leading ASCII whitespace."`
`public static final java.lang.String` `bytearray_partition_doc` `"B.partition(sep) -> (head, sep, tail)\n\nSearches for the separator sep in B, and returns the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, returns B and two empty bytearray objects."`
`public static final java.lang.String` `bytearray_pop_doc` `"B.pop([index]) -> int\n\nRemove and return a single item from B. If no index\nargument is given, will pop the last value."`
`public static final java.lang.String` `bytearray_remove_doc` `"B.remove(int) -> None\n\nRemove the first occurance of a value in B."`
`public static final java.lang.String` `bytearray_replace_doc` `"B.replace(old, new[, count]) -> bytes\n\nReturn a copy of B with all occurrences of subsection\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."`
`public static final java.lang.String` `bytearray_reverse_doc` `"B.reverse() -> None\n\nReverse the order of the values in B in place."`
`public static final java.lang.String` `bytearray_rfind_doc` `"B.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within s[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `bytearray_rindex_doc` `"B.rindex(sub [,start [,end]]) -> int\n\nLike B.rfind() but raise ValueError when the subsection is not found."`
`public static final java.lang.String` `bytearray_rjust_doc` `"B.rjust(width[, fillchar]) -> copy of B\n\nReturn B right justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)"`
`public static final java.lang.String` `bytearray_rpartition_doc` `"B.rpartition(sep) -> (head, sep, tail)\n\nSearches for the separator sep in B, starting at the end of B,\nand returns the part before it, the separator itself, and the\npart after it. If the separator is not found, returns two empty\nbytearray objects and B."`

`public static final java.lang.String`

`bytearray_rsplit_doc`

`"B.rsplit(sep[, maxsplit]) -> list of bytearray\n\nReturn a list of the sections in B, using sep as the delimiter,\nstarting at the end of B and working to the front.\nIf sep is not given, B is split on ASCII whitespace characters\n(space, tab, return, newline, formfeed, vertical tab).\nIf maxsplit is given, at most maxsplit splits are done."`

`public static final java.lang.String` `bytearray_rstrip_doc` `"B.rstrip([bytes]) -> bytearray\n\nStrip trailing bytes contained in the argument.\nIf the argument is omitted, strip trailing ASCII whitespace."`
`public static final java.lang.String` `bytearray_split_doc` `"B.split([sep[, maxsplit]]) -> list of bytearray\n\nReturn a list of the sections in B, using sep as the delimiter.\nIf sep is not given, B is split on ASCII whitespace characters\n(space, tab, return, newline, formfeed, vertical tab).\nIf maxsplit is given, at most maxsplit splits are done."`
`public static final java.lang.String` `bytearray_splitlines_doc` `"B.splitlines([keepends]) -> list of lines\n\nReturn a list of the lines in B, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."`
`public static final java.lang.String` `bytearray_startswith_doc` `"B.startswith(prefix [,start [,end]]) -> bool\n\nReturn True if B starts with the specified prefix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nprefix can also be a tuple of strings to try."`
`public static final java.lang.String` `bytearray_strip_doc` `"B.strip([bytes]) -> bytearray\n\nStrip leading and trailing bytes contained in the argument.\nIf the argument is omitted, strip ASCII whitespace."`
`public static final java.lang.String` `bytearray_swapcase_doc` `"B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa."`
`public static final java.lang.String` `bytearray_title_doc` `"B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase."`
`public static final java.lang.String` `bytearray_translate_doc` `"B.translate(table[, deletechars]) -> bytearray\n\nReturn a copy of B, where all characters occurring in the\noptional argument deletechars are removed, and the remaining\ncharacters have been mapped through the given translation\ntable, which must be a bytes object of length 256."`
`public static final java.lang.String` `bytearray_upper_doc` `"B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase."`
`public static final java.lang.String` `bytearray_zfill_doc` `"B.zfill(width) -> copy of B\n\nPad a numeric string B with zeros on the left, to fill a field\nof the specified width. B is never truncated."`
`public static final java.lang.String` `classmethod___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `classmethod___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `classmethod___format___doc` `"default object formatter"`
`public static final java.lang.String` `classmethod___func___doc` `""`
`public static final java.lang.String` `classmethod___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `classmethod___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `classmethod___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `classmethod___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `classmethod___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `classmethod___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `classmethod___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `classmethod___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `classmethod___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `classmethod___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `classmethod___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `classmethod___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`

`public static final java.lang.String`

`classmethod_doc`

`"classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n class C:\n def f(cls, arg1, arg2, ...): ...\n f = classmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin."`

`public static final java.lang.String` `code___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `code___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `code___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `code___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `code___format___doc` `"default object formatter"`
`public static final java.lang.String` `code___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `code___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `code___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `code___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `code___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `code___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `code___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `code___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `code___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `code___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `code___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `code___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `code___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `code___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `code___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `code___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `code_co_argcount_doc` `""`
`public static final java.lang.String` `code_co_cellvars_doc` `""`
`public static final java.lang.String` `code_co_code_doc` `""`
`public static final java.lang.String` `code_co_consts_doc` `""`
`public static final java.lang.String` `code_co_filename_doc` `""`
`public static final java.lang.String` `code_co_firstlineno_doc` `""`
`public static final java.lang.String` `code_co_flags_doc` `""`
`public static final java.lang.String` `code_co_freevars_doc` `""`
`public static final java.lang.String` `code_co_lnotab_doc` `""`
`public static final java.lang.String` `code_co_name_doc` `""`
`public static final java.lang.String` `code_co_names_doc` `""`
`public static final java.lang.String` `code_co_nlocals_doc` `""`
`public static final java.lang.String` `code_co_stacksize_doc` `""`
`public static final java.lang.String` `code_co_varnames_doc` `""`
`public static final java.lang.String` `code_doc` `"code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart."`
`public static final java.lang.String` `complex___abs___doc` `"x.__abs__() <==> abs(x)"`
`public static final java.lang.String` `complex___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `complex___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `complex___coerce___doc` `"x.__coerce__(y) <==> coerce(x, y)"`
`public static final java.lang.String` `complex___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `complex___div___doc` `"x.__div__(y) <==> x/y"`
`public static final java.lang.String` `complex___divmod___doc` `"x.__divmod__(y) <==> divmod(x, y)"`
`public static final java.lang.String` `complex___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `complex___float___doc` `"x.__float__() <==> float(x)"`
`public static final java.lang.String` `complex___floordiv___doc` `"x.__floordiv__(y) <==> x//y"`
`public static final java.lang.String` `complex___format___doc` `"complex.__format__() -> str\n\nConverts to a string according to format_spec."`
`public static final java.lang.String` `complex___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `complex___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `complex___getnewargs___doc` `""`
`public static final java.lang.String` `complex___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `complex___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `complex___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `complex___int___doc` `"x.__int__() <==> int(x)"`
`public static final java.lang.String` `complex___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `complex___long___doc` `"x.__long__() <==> long(x)"`
`public static final java.lang.String` `complex___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `complex___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `complex___mul___doc` `"x.__mul__(y) <==> x*y"`
`public static final java.lang.String` `complex___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `complex___neg___doc` `"x.__neg__() <==> -x"`
`public static final java.lang.String` `complex___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `complex___nonzero___doc` `"x.__nonzero__() <==> x != 0"`
`public static final java.lang.String` `complex___pos___doc` `"x.__pos__() <==> +x"`
`public static final java.lang.String` `complex___pow___doc` `"x.__pow__(y[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `complex___radd___doc` `"x.__radd__(y) <==> y+x"`
`public static final java.lang.String` `complex___rdiv___doc` `"x.__rdiv__(y) <==> y/x"`
`public static final java.lang.String` `complex___rdivmod___doc` `"x.__rdivmod__(y) <==> divmod(y, x)"`
`public static final java.lang.String` `complex___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `complex___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `complex___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `complex___rfloordiv___doc` `"x.__rfloordiv__(y) <==> y//x"`
`public static final java.lang.String` `complex___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `complex___rmul___doc` `"x.__rmul__(y) <==> y*x"`
`public static final java.lang.String` `complex___rpow___doc` `"y.__rpow__(x[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `complex___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `complex___rtruediv___doc` `"x.__rtruediv__(y) <==> y/x"`
`public static final java.lang.String` `complex___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `complex___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `complex___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `complex___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `complex___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `complex___truediv___doc` `"x.__truediv__(y) <==> x/y"`
`public static final java.lang.String` `complex_conjugate_doc` `"complex.conjugate() -> complex\n\nReturns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j."`
`public static final java.lang.String` `complex_doc` `"complex(real[, imag]) -> complex number\n\nCreate a complex number from a real part and an optional imaginary part.\nThis is equivalent to (real + imag*1j) where imag defaults to 0."`
`public static final java.lang.String` `complex_imag_doc` `"the imaginary part of a complex number"`
`public static final java.lang.String` `complex_real_doc` `"the real part of a complex number"`
`public static final java.lang.String` `dict___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `dict___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `dict___contains___doc` `"D.__contains__(k) -> True if D has a key k, else False"`
`public static final java.lang.String` `dict___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `dict___delitem___doc` `"x.__delitem__(y) <==> del x[y]"`
`public static final java.lang.String` `dict___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `dict___format___doc` `"default object formatter"`
`public static final java.lang.String` `dict___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `dict___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `dict___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `dict___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `dict___hash___doc` `""`
`public static final java.lang.String` `dict___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `dict___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `dict___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `dict___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `dict___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `dict___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `dict___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `dict___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `dict___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `dict___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `dict___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `dict___setitem___doc` `"x.__setitem__(i, y) <==> x[i]=y"`
`public static final java.lang.String` `dict___sizeof___doc` `"D.__sizeof__() -> size of D in memory, in bytes"`
`public static final java.lang.String` `dict___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `dict___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `dict_clear_doc` `"D.clear() -> None. Remove all items from D."`
`public static final java.lang.String` `dict_copy_doc` `"D.copy() -> a shallow copy of D"`

`public static final java.lang.String`

`dict_doc`

`"dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object\'s\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)"`

`public static final java.lang.String` `dict_fromkeys_doc` `"dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None."`
`public static final java.lang.String` `dict_get_doc` `"D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None."`
`public static final java.lang.String` `dict_has_key_doc` `"D.has_key(k) -> True if D has a key k, else False"`
`public static final java.lang.String` `dict_items_doc` `"D.items() -> list of D\'s (key, value) pairs, as 2-tuples"`
`public static final java.lang.String` `dict_iteritems_doc` `"D.iteritems() -> an iterator over the (key, value) items of D"`
`public static final java.lang.String` `dict_iterkeys_doc` `"D.iterkeys() -> an iterator over the keys of D"`
`public static final java.lang.String` `dict_itervalues_doc` `"D.itervalues() -> an iterator over the values of D"`
`public static final java.lang.String` `dict_keys_doc` `"D.keys() -> list of D\'s keys"`
`public static final java.lang.String` `dict_pop_doc` `"D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised"`
`public static final java.lang.String` `dict_popitem_doc` `"D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty."`
`public static final java.lang.String` `dict_setdefault_doc` `"D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D"`
`public static final java.lang.String` `dict_update_doc` `"D.update(E, **F) -> None. Update D from dict/iterable E and F.\nIf E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"`
`public static final java.lang.String` `dict_values_doc` `"D.values() -> list of D\'s values"`
`public static final java.lang.String` `dict_viewitems_doc` `"D.viewitems() -> a set-like object providing a view on D\'s items"`
`public static final java.lang.String` `dict_viewkeys_doc` `"D.viewkeys() -> a set-like object providing a view on D\'s keys"`
`public static final java.lang.String` `dict_viewvalues_doc` `"D.viewvalues() -> an object providing a view on D\'s values"`
`public static final java.lang.String` `enumerate___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `enumerate___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `enumerate___format___doc` `"default object formatter"`
`public static final java.lang.String` `enumerate___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `enumerate___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `enumerate___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `enumerate___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `enumerate___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `enumerate___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `enumerate___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `enumerate___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `enumerate___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `enumerate___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `enumerate___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `enumerate___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`

`public static final java.lang.String`

`enumerate_doc`

`"enumerate(iterable[, start]) -> iterator for index, value of iterable\n\nReturn an enumerate object. iterable must be another object that supports\niteration. The enumerate object yields pairs containing a count (from\nstart, which defaults to zero) and a value yielded by the iterable argument.\nenumerate is useful for obtaining an indexed list:\n (0, seq[0]), (1, seq[1]), (2, seq[2]), ..."`

`public static final java.lang.String` `enumerate_next_doc` `"x.next() -> the next value, or raise StopIteration"`
`public static final java.lang.String` `file___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `file___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `file___enter___doc` `"__enter__() -> self."`
`public static final java.lang.String` `file___exit___doc` `"__exit__(*excinfo) -> None. Closes the file."`
`public static final java.lang.String` `file___format___doc` `"default object formatter"`
`public static final java.lang.String` `file___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `file___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `file___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `file___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `file___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `file___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `file___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `file___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `file___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `file___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `file___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `file___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `file_close_doc` `"close() -> None or (perhaps) an integer. Close the file.\n\nSets data attribute .closed to True. A closed file cannot be used for\nfurther I/O operations. close() may be called more than once without\nerror. Some kinds of file objects (for example, opened by popen())\nmay return an exit status upon closing."`
`public static final java.lang.String` `file_closed_doc` `"True if the file is closed"`

`public static final java.lang.String`

`file_doc`

`"file(name[, mode[, buffering]]) -> file object\n\nOpen a file. The mode can be \'r\', \'w\' or \'a\' for reading (default),\nwriting or appending. The file will be created if it doesn\'t exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing. Add a \'b\' to the mode for binary files.\nAdd a \'+\' to the mode to allow simultaneous reading and writing.\nIf the buffering argument is given, 0 means unbuffered, 1 means line\nbuffered, and larger numbers specify the buffer size. The preferred way\nto open a file is with the builtin open() function.\nAdd a \'U\' to mode to open the file for input with universal newline\nsupport. Any line ending in the input file will be seen as a \'\\n\'\nin Python. Also, a file so opened gains the attribute \'newlines\';\nthe value for this attribute is one of None (no newline read yet),\n\'\\r\', \'\\n\', \'\\r\\n\' or a tuple containing all the newline types seen.\n\n\'U\' cannot be combined with \'w\' or \'+\' mode.\n"`

`public static final java.lang.String` `file_encoding_doc` `"file encoding"`
`public static final java.lang.String` `file_errors_doc` `"Unicode error handler"`
`public static final java.lang.String` `file_fileno_doc` `"fileno() -> integer \"file descriptor\".\n\nThis is needed for lower-level file interfaces, such os.read()."`
`public static final java.lang.String` `file_flush_doc` `"flush() -> None. Flush the internal I/O buffer."`
`public static final java.lang.String` `file_isatty_doc` `"isatty() -> true or false. True if the file is connected to a tty device."`
`public static final java.lang.String` `file_mode_doc` `"file mode (\'r\', \'U\', \'w\', \'a\', possibly with \'b\' or \'+\' added)"`
`public static final java.lang.String` `file_name_doc` `"file name"`
`public static final java.lang.String` `file_newlines_doc` `"end-of-line convention used in this file"`
`public static final java.lang.String` `file_next_doc` `"x.next() -> the next value, or raise StopIteration"`
`public static final java.lang.String` `file_read_doc` `"read([size]) -> read at most size bytes, returned as a string.\n\nIf the size argument is negative or omitted, read until EOF is reached.\nNotice that when in non-blocking mode, less data than what was requested\nmay be returned, even if no size parameter was given."`
`public static final java.lang.String` `file_readinto_doc` `"readinto() -> Undocumented. Don\'t use this; it may go away."`
`public static final java.lang.String` `file_readline_doc` `"readline([size]) -> next line from the file, as a string.\n\nRetain newline. A non-negative size argument limits the maximum\nnumber of bytes to return (an incomplete line may be returned then).\nReturn an empty string at EOF."`
`public static final java.lang.String` `file_readlines_doc` `"readlines([size]) -> list of strings, each a line from the file.\n\nCall readline() repeatedly and return a list of the lines so read.\nThe optional size argument, if given, is an approximate bound on the\ntotal number of bytes in the lines returned."`

`public static final java.lang.String`

`file_seek_doc`

`"seek(offset[, whence]) -> None. Move to new file position.\n\nArgument offset is a byte count. Optional argument whence defaults to\n0 (offset from start of file, offset should be >= 0); other values are 1\n(move relative to current position, positive or negative), and 2 (move\nrelative to end of file, usually negative, although many platforms allow\nseeking beyond the end of a file). If the file is opened in text mode,\nonly offsets returned by tell() are legal. Use of other offsets causes\nundefined behavior.\nNote that not all file objects are seekable."`

`public static final java.lang.String` `file_softspace_doc` `"flag indicating that a space needs to be printed; used by print"`
`public static final java.lang.String` `file_tell_doc` `"tell() -> current file position, an integer (may be a long integer)."`
`public static final java.lang.String` `file_truncate_doc` `"truncate([size]) -> None. Truncate the file to at most size bytes.\n\nSize defaults to the current file position, as returned by tell()."`
`public static final java.lang.String` `file_write_doc` `"write(str) -> None. Write string str to file.\n\nNote that due to buffering, flush() or close() may be needed before\nthe file on disk reflects the data written."`
`public static final java.lang.String` `file_writelines_doc` `"writelines(sequence_of_strings) -> None. Write the strings to the file.\n\nNote that newlines are not added. The sequence can be any iterable object\nproducing strings. This is equivalent to calling write() for each string."`
`public static final java.lang.String` `file_xreadlines_doc` `"xreadlines() -> returns self.\n\nFor backward compatibility. File objects now include the performance\noptimizations previously implemented in the xreadlines module."`
`public static final java.lang.String` `float___abs___doc` `"x.__abs__() <==> abs(x)"`
`public static final java.lang.String` `float___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `float___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `float___coerce___doc` `"x.__coerce__(y) <==> coerce(x, y)"`
`public static final java.lang.String` `float___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `float___div___doc` `"x.__div__(y) <==> x/y"`
`public static final java.lang.String` `float___divmod___doc` `"x.__divmod__(y) <==> divmod(x, y)"`
`public static final java.lang.String` `float___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `float___float___doc` `"x.__float__() <==> float(x)"`
`public static final java.lang.String` `float___floordiv___doc` `"x.__floordiv__(y) <==> x//y"`
`public static final java.lang.String` `float___format___doc` `"float.__format__(format_spec) -> string\n\nFormats the float according to format_spec."`
`public static final java.lang.String` `float___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `float___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`

`public static final java.lang.String`

`float___getformat___doc`

`"float.__getformat__(typestr) -> string\n\nYou probably don\'t want to use this function. It exists mainly to be\nused in Python\'s test suite.\n\ntypestr must be \'double\' or \'float\'. This function returns whichever of\n\'unknown\', \'IEEE, big-endian\' or \'IEEE, little-endian\' best describes the\nformat of floating point numbers used by the C type named by typestr."`

`public static final java.lang.String` `float___getnewargs___doc` `""`
`public static final java.lang.String` `float___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `float___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `float___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `float___int___doc` `"x.__int__() <==> int(x)"`
`public static final java.lang.String` `float___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `float___long___doc` `"x.__long__() <==> long(x)"`
`public static final java.lang.String` `float___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `float___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `float___mul___doc` `"x.__mul__(y) <==> x*y"`
`public static final java.lang.String` `float___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `float___neg___doc` `"x.__neg__() <==> -x"`
`public static final java.lang.String` `float___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `float___nonzero___doc` `"x.__nonzero__() <==> x != 0"`
`public static final java.lang.String` `float___pos___doc` `"x.__pos__() <==> +x"`
`public static final java.lang.String` `float___pow___doc` `"x.__pow__(y[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `float___radd___doc` `"x.__radd__(y) <==> y+x"`
`public static final java.lang.String` `float___rdiv___doc` `"x.__rdiv__(y) <==> y/x"`
`public static final java.lang.String` `float___rdivmod___doc` `"x.__rdivmod__(y) <==> divmod(y, x)"`
`public static final java.lang.String` `float___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `float___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `float___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `float___rfloordiv___doc` `"x.__rfloordiv__(y) <==> y//x"`
`public static final java.lang.String` `float___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `float___rmul___doc` `"x.__rmul__(y) <==> y*x"`
`public static final java.lang.String` `float___rpow___doc` `"y.__rpow__(x[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `float___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `float___rtruediv___doc` `"x.__rtruediv__(y) <==> y/x"`
`public static final java.lang.String` `float___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`

`public static final java.lang.String`

`float___setformat___doc`

`"float.__setformat__(typestr, fmt) -> None\n\nYou probably don\'t want to use this function. It exists mainly to be\nused in Python\'s test suite.\n\ntypestr must be \'double\' or \'float\'. fmt must be one of \'unknown\',\n\'IEEE, big-endian\' or \'IEEE, little-endian\', and in addition can only be\none of the latter two if it appears to match the underlying C reality.\n\nOverrides the automatic determination of C-level floating point type.\nThis affects how floats are converted to and from binary strings."`

`public static final java.lang.String` `float___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `float___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `float___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `float___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `float___truediv___doc` `"x.__truediv__(y) <==> x/y"`
`public static final java.lang.String` `float___trunc___doc` `"Returns the Integral closest to x between 0 and x."`

`public static final java.lang.String`

`float_as_integer_ratio_doc`

`"float.as_integer_ratio() -> (int, int)\n\nReturns a pair of integers, whose ratio is exactly equal to the original\nfloat and with a positive denominator.\nRaises OverflowError on infinities and a ValueError on NaNs.\n\n>>> (10.0).as_integer_ratio()\n(10, 1)\n>>> (0.0).as_integer_ratio()\n(0, 1)\n>>> (-.25).as_integer_ratio()\n(-1, 4)"`

`public static final java.lang.String` `float_conjugate_doc` `"Returns self, the complex conjugate of any float."`
`public static final java.lang.String` `float_doc` `"float(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible."`
`public static final java.lang.String` `float_fromhex_doc` `"float.fromhex(string) -> float\n\nCreate a floating-point number from a hexadecimal string.\n>>> float.fromhex(\'0x1.ffffp10\')\n2047.984375\n>>> float.fromhex(\'-0x1p-1074\')\n-4.9406564584124654e-324"`
`public static final java.lang.String` `float_hex_doc` `"float.hex() -> string\n\nReturn a hexadecimal representation of a floating-point number.\n>>> (-0.1).hex()\n\'-0x1.999999999999ap-4\'\n>>> 3.14159.hex()\n\'0x1.921f9f01b866ep+1\'"`
`public static final java.lang.String` `float_imag_doc` `"the imaginary part of a complex number"`
`public static final java.lang.String` `float_is_integer_doc` `"Returns True if the float is an integer."`
`public static final java.lang.String` `float_real_doc` `"the real part of a complex number"`
`public static final java.lang.String` `frame___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `frame___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `frame___format___doc` `"default object formatter"`
`public static final java.lang.String` `frame___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `frame___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `frame___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `frame___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `frame___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `frame___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `frame___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `frame___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `frame___sizeof___doc` `"F.__sizeof__() -> size of F in memory, in bytes"`
`public static final java.lang.String` `frame___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `frame___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `frame_doc` `""`
`public static final java.lang.String` `frame_f_back_doc` `""`
`public static final java.lang.String` `frame_f_builtins_doc` `""`
`public static final java.lang.String` `frame_f_code_doc` `""`
`public static final java.lang.String` `frame_f_exc_traceback_doc` `""`
`public static final java.lang.String` `frame_f_exc_type_doc` `""`
`public static final java.lang.String` `frame_f_exc_value_doc` `""`
`public static final java.lang.String` `frame_f_globals_doc` `""`
`public static final java.lang.String` `frame_f_lasti_doc` `""`
`public static final java.lang.String` `frame_f_lineno_doc` `""`
`public static final java.lang.String` `frame_f_locals_doc` `""`
`public static final java.lang.String` `frame_f_restricted_doc` `""`
`public static final java.lang.String` `frame_f_trace_doc` `""`
`public static final java.lang.String` `frozenset___and___doc` `"x.__and__(y) <==> x&y"`
`public static final java.lang.String` `frozenset___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `frozenset___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `frozenset___contains___doc` `"x.__contains__(y) <==> y in x."`
`public static final java.lang.String` `frozenset___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `frozenset___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `frozenset___format___doc` `"default object formatter"`
`public static final java.lang.String` `frozenset___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `frozenset___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `frozenset___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `frozenset___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `frozenset___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `frozenset___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `frozenset___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `frozenset___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `frozenset___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `frozenset___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `frozenset___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `frozenset___or___doc` `"x.__or__(y) <==> x|y"`
`public static final java.lang.String` `frozenset___rand___doc` `"x.__rand__(y) <==> y&x"`
`public static final java.lang.String` `frozenset___reduce___doc` `"Return state information for pickling."`
`public static final java.lang.String` `frozenset___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `frozenset___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `frozenset___ror___doc` `"x.__ror__(y) <==> y|x"`
`public static final java.lang.String` `frozenset___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `frozenset___rxor___doc` `"x.__rxor__(y) <==> y^x"`
`public static final java.lang.String` `frozenset___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `frozenset___sizeof___doc` `"S.__sizeof__() -> size of S in memory, in bytes"`
`public static final java.lang.String` `frozenset___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `frozenset___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `frozenset___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `frozenset___xor___doc` `"x.__xor__(y) <==> x^y"`
`public static final java.lang.String` `frozenset_copy_doc` `"Return a shallow copy of a set."`
`public static final java.lang.String` `frozenset_difference_doc` `"Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)"`
`public static final java.lang.String` `frozenset_doc` `"frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements."`
`public static final java.lang.String` `frozenset_intersection_doc` `"Return the intersection of two or more sets as a new set.\n\n(i.e. elements that are common to all of the sets.)"`
`public static final java.lang.String` `frozenset_isdisjoint_doc` `"Return True if two sets have a null intersection."`
`public static final java.lang.String` `frozenset_issubset_doc` `"Report whether another set contains this set."`
`public static final java.lang.String` `frozenset_issuperset_doc` `"Report whether this set contains another set."`
`public static final java.lang.String` `frozenset_symmetric_difference_doc` `"Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)"`
`public static final java.lang.String` `frozenset_union_doc` `"Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)"`
`public static final java.lang.String` `function___call___doc` `"x.__call__(...) <==> x(...)"`
`public static final java.lang.String` `function___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `function___closure___doc` `""`
`public static final java.lang.String` `function___code___doc` `""`
`public static final java.lang.String` `function___defaults___doc` `""`
`public static final java.lang.String` `function___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `function___dict___doc` `""`
`public static final java.lang.String` `function___format___doc` `"default object formatter"`
`public static final java.lang.String` `function___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `function___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `function___globals___doc` `""`
`public static final java.lang.String` `function___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `function___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `function___module___doc` `"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."`
`public static final java.lang.String` `function___name___doc` `"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."`
`public static final java.lang.String` `function___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `function___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `function___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `function___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `function___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `function___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `function___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `function___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `function_doc` `"function(code, globals[, name[, argdefs[, closure]]])\n\nCreate a function object from a code object and a dictionary.\nThe optional name string overrides the name from the code object.\nThe optional argdefs tuple specifies the default argument values.\nThe optional closure tuple supplies the bindings for free variables."`
`public static final java.lang.String` `function_func_closure_doc` `""`
`public static final java.lang.String` `function_func_code_doc` `""`
`public static final java.lang.String` `function_func_defaults_doc` `""`
`public static final java.lang.String` `function_func_dict_doc` `""`
`public static final java.lang.String` `function_func_doc_doc` `""`
`public static final java.lang.String` `function_func_globals_doc` `""`
`public static final java.lang.String` `function_func_name_doc` `""`
`public static final java.lang.String` `instancemethod___call___doc` `"x.__call__(...) <==> x(...)"`
`public static final java.lang.String` `instancemethod___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `instancemethod___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `instancemethod___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `instancemethod___format___doc` `"default object formatter"`
`public static final java.lang.String` `instancemethod___func___doc` `"the function (or other callable) implementing a method"`
`public static final java.lang.String` `instancemethod___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `instancemethod___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `instancemethod___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `instancemethod___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `instancemethod___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `instancemethod___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `instancemethod___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `instancemethod___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `instancemethod___self___doc` `"the instance to which a method is bound; None for unbound methods"`
`public static final java.lang.String` `instancemethod___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `instancemethod___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `instancemethod___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `instancemethod___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `instancemethod_doc` `"instancemethod(function, instance, class)\n\nCreate an instance method object."`
`public static final java.lang.String` `instancemethod_im_class_doc` `"the class associated with a method"`
`public static final java.lang.String` `instancemethod_im_func_doc` `"the function (or other callable) implementing a method"`
`public static final java.lang.String` `instancemethod_im_self_doc` `"the instance to which a method is bound; None for unbound methods"`
`public static final java.lang.String` `int___abs___doc` `"x.__abs__() <==> abs(x)"`
`public static final java.lang.String` `int___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `int___and___doc` `"x.__and__(y) <==> x&y"`
`public static final java.lang.String` `int___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `int___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `int___coerce___doc` `"x.__coerce__(y) <==> coerce(x, y)"`
`public static final java.lang.String` `int___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `int___div___doc` `"x.__div__(y) <==> x/y"`
`public static final java.lang.String` `int___divmod___doc` `"x.__divmod__(y) <==> divmod(x, y)"`
`public static final java.lang.String` `int___float___doc` `"x.__float__() <==> float(x)"`
`public static final java.lang.String` `int___floordiv___doc` `"x.__floordiv__(y) <==> x//y"`
`public static final java.lang.String` `int___format___doc` `""`
`public static final java.lang.String` `int___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `int___getnewargs___doc` `""`
`public static final java.lang.String` `int___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `int___hex___doc` `"x.__hex__() <==> hex(x)"`
`public static final java.lang.String` `int___index___doc` `"x[y:z] <==> x[y.__index__():z.__index__()]"`
`public static final java.lang.String` `int___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `int___int___doc` `"x.__int__() <==> int(x)"`
`public static final java.lang.String` `int___invert___doc` `"x.__invert__() <==> ~x"`
`public static final java.lang.String` `int___long___doc` `"x.__long__() <==> long(x)"`
`public static final java.lang.String` `int___lshift___doc` `"x.__lshift__(y) <==> x<<y"`
`public static final java.lang.String` `int___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `int___mul___doc` `"x.__mul__(y) <==> x*y"`
`public static final java.lang.String` `int___neg___doc` `"x.__neg__() <==> -x"`
`public static final java.lang.String` `int___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `int___nonzero___doc` `"x.__nonzero__() <==> x != 0"`
`public static final java.lang.String` `int___oct___doc` `"x.__oct__() <==> oct(x)"`
`public static final java.lang.String` `int___or___doc` `"x.__or__(y) <==> x|y"`
`public static final java.lang.String` `int___pos___doc` `"x.__pos__() <==> +x"`
`public static final java.lang.String` `int___pow___doc` `"x.__pow__(y[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `int___radd___doc` `"x.__radd__(y) <==> y+x"`
`public static final java.lang.String` `int___rand___doc` `"x.__rand__(y) <==> y&x"`
`public static final java.lang.String` `int___rdiv___doc` `"x.__rdiv__(y) <==> y/x"`
`public static final java.lang.String` `int___rdivmod___doc` `"x.__rdivmod__(y) <==> divmod(y, x)"`
`public static final java.lang.String` `int___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `int___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `int___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `int___rfloordiv___doc` `"x.__rfloordiv__(y) <==> y//x"`
`public static final java.lang.String` `int___rlshift___doc` `"x.__rlshift__(y) <==> y<<x"`
`public static final java.lang.String` `int___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `int___rmul___doc` `"x.__rmul__(y) <==> y*x"`
`public static final java.lang.String` `int___ror___doc` `"x.__ror__(y) <==> y|x"`
`public static final java.lang.String` `int___rpow___doc` `"y.__rpow__(x[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `int___rrshift___doc` `"x.__rrshift__(y) <==> y>>x"`
`public static final java.lang.String` `int___rshift___doc` `"x.__rshift__(y) <==> x>>y"`
`public static final java.lang.String` `int___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `int___rtruediv___doc` `"x.__rtruediv__(y) <==> y/x"`
`public static final java.lang.String` `int___rxor___doc` `"x.__rxor__(y) <==> y^x"`
`public static final java.lang.String` `int___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `int___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `int___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `int___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `int___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `int___truediv___doc` `"x.__truediv__(y) <==> x/y"`
`public static final java.lang.String` `int___trunc___doc` `"Truncating an Integral returns itself."`
`public static final java.lang.String` `int___xor___doc` `"x.__xor__(y) <==> x^y"`
`public static final java.lang.String` `int_bit_length_doc` `"int.bit_length() -> int\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37)\n\'0b100101\'\n>>> (37).bit_length()\n6"`
`public static final java.lang.String` `int_conjugate_doc` `"Returns self, the complex conjugate of any int."`
`public static final java.lang.String` `int_denominator_doc` `"the denominator of a rational number in lowest terms"`

`public static final java.lang.String`

`int_doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `int_imag_doc` `"the imaginary part of a complex number"`
`public static final java.lang.String` `int_numerator_doc` `"the numerator of a rational number in lowest terms"`
`public static final java.lang.String` `int_real_doc` `"the real part of a complex number"`
`public static final java.lang.String` `list___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `list___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `list___contains___doc` `"x.__contains__(y) <==> y in x"`
`public static final java.lang.String` `list___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `list___delitem___doc` `"x.__delitem__(y) <==> del x[y]"`
`public static final java.lang.String` `list___delslice___doc` `"x.__delslice__(i, j) <==> del x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `list___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `list___format___doc` `"default object formatter"`
`public static final java.lang.String` `list___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `list___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `list___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `list___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `list___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `list___hash___doc` `""`
`public static final java.lang.String` `list___iadd___doc` `"x.__iadd__(y) <==> x+=y"`
`public static final java.lang.String` `list___imul___doc` `"x.__imul__(y) <==> x*=y"`
`public static final java.lang.String` `list___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `list___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `list___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `list___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `list___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `list___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `list___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `list___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `list___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `list___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `list___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `list___reversed___doc` `"L.__reversed__() -- return a reverse iterator over the list"`
`public static final java.lang.String` `list___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `list___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `list___setitem___doc` `"x.__setitem__(i, y) <==> x[i]=y"`
`public static final java.lang.String` `list___setslice___doc` `"x.__setslice__(i, j, y) <==> x[i:j]=y\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `list___sizeof___doc` `"L.__sizeof__() -- size of L in memory, in bytes"`
`public static final java.lang.String` `list___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `list___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `list_append_doc` `"L.append(object) -- append object to end"`
`public static final java.lang.String` `list_count_doc` `"L.count(value) -> integer -- return number of occurrences of value"`
`public static final java.lang.String` `list_doc` `"list() -> new empty list\nlist(iterable) -> new list initialized from iterable\'s items"`
`public static final java.lang.String` `list_extend_doc` `"L.extend(iterable) -- extend list by appending elements from the iterable"`
`public static final java.lang.String` `list_index_doc` `"L.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present."`
`public static final java.lang.String` `list_insert_doc` `"L.insert(index, object) -- insert object before index"`
`public static final java.lang.String` `list_pop_doc` `"L.pop([index]) -> item -- remove and return item at index (default last).\nRaises IndexError if list is empty or index is out of range."`
`public static final java.lang.String` `list_remove_doc` `"L.remove(value) -- remove first occurrence of value.\nRaises ValueError if the value is not present."`
`public static final java.lang.String` `list_reverse_doc` `"L.reverse() -- reverse *IN PLACE*"`
`public static final java.lang.String` `list_sort_doc` `"L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;\ncmp(x, y) -> -1, 0, 1"`
`public static final java.lang.String` `long___abs___doc` `"x.__abs__() <==> abs(x)"`
`public static final java.lang.String` `long___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `long___and___doc` `"x.__and__(y) <==> x&y"`
`public static final java.lang.String` `long___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `long___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `long___coerce___doc` `"x.__coerce__(y) <==> coerce(x, y)"`
`public static final java.lang.String` `long___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `long___div___doc` `"x.__div__(y) <==> x/y"`
`public static final java.lang.String` `long___divmod___doc` `"x.__divmod__(y) <==> divmod(x, y)"`
`public static final java.lang.String` `long___float___doc` `"x.__float__() <==> float(x)"`
`public static final java.lang.String` `long___floordiv___doc` `"x.__floordiv__(y) <==> x//y"`
`public static final java.lang.String` `long___format___doc` `""`
`public static final java.lang.String` `long___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `long___getnewargs___doc` `""`
`public static final java.lang.String` `long___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `long___hex___doc` `"x.__hex__() <==> hex(x)"`
`public static final java.lang.String` `long___index___doc` `"x[y:z] <==> x[y.__index__():z.__index__()]"`
`public static final java.lang.String` `long___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `long___int___doc` `"x.__int__() <==> int(x)"`
`public static final java.lang.String` `long___invert___doc` `"x.__invert__() <==> ~x"`
`public static final java.lang.String` `long___long___doc` `"x.__long__() <==> long(x)"`
`public static final java.lang.String` `long___lshift___doc` `"x.__lshift__(y) <==> x<<y"`
`public static final java.lang.String` `long___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `long___mul___doc` `"x.__mul__(y) <==> x*y"`
`public static final java.lang.String` `long___neg___doc` `"x.__neg__() <==> -x"`
`public static final java.lang.String` `long___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `long___nonzero___doc` `"x.__nonzero__() <==> x != 0"`
`public static final java.lang.String` `long___oct___doc` `"x.__oct__() <==> oct(x)"`
`public static final java.lang.String` `long___or___doc` `"x.__or__(y) <==> x|y"`
`public static final java.lang.String` `long___pos___doc` `"x.__pos__() <==> +x"`
`public static final java.lang.String` `long___pow___doc` `"x.__pow__(y[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `long___radd___doc` `"x.__radd__(y) <==> y+x"`
`public static final java.lang.String` `long___rand___doc` `"x.__rand__(y) <==> y&x"`
`public static final java.lang.String` `long___rdiv___doc` `"x.__rdiv__(y) <==> y/x"`
`public static final java.lang.String` `long___rdivmod___doc` `"x.__rdivmod__(y) <==> divmod(y, x)"`
`public static final java.lang.String` `long___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `long___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `long___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `long___rfloordiv___doc` `"x.__rfloordiv__(y) <==> y//x"`
`public static final java.lang.String` `long___rlshift___doc` `"x.__rlshift__(y) <==> y<<x"`
`public static final java.lang.String` `long___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `long___rmul___doc` `"x.__rmul__(y) <==> y*x"`
`public static final java.lang.String` `long___ror___doc` `"x.__ror__(y) <==> y|x"`
`public static final java.lang.String` `long___rpow___doc` `"y.__rpow__(x[, z]) <==> pow(x, y[, z])"`
`public static final java.lang.String` `long___rrshift___doc` `"x.__rrshift__(y) <==> y>>x"`
`public static final java.lang.String` `long___rshift___doc` `"x.__rshift__(y) <==> x>>y"`
`public static final java.lang.String` `long___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `long___rtruediv___doc` `"x.__rtruediv__(y) <==> y/x"`
`public static final java.lang.String` `long___rxor___doc` `"x.__rxor__(y) <==> y^x"`
`public static final java.lang.String` `long___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `long___sizeof___doc` `"Returns size in memory, in bytes"`
`public static final java.lang.String` `long___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `long___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `long___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `long___truediv___doc` `"x.__truediv__(y) <==> x/y"`
`public static final java.lang.String` `long___trunc___doc` `"Truncating an Integral returns itself."`
`public static final java.lang.String` `long___xor___doc` `"x.__xor__(y) <==> x^y"`
`public static final java.lang.String` `long_bit_length_doc` `"long.bit_length() -> int or long\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37L)\n\'0b100101\'\n>>> (37L).bit_length()\n6"`
`public static final java.lang.String` `long_conjugate_doc` `"Returns self, the complex conjugate of any long."`
`public static final java.lang.String` `long_denominator_doc` `"the denominator of a rational number in lowest terms"`
`public static final java.lang.String` `long_doc` `"long(x[, base]) -> integer\n\nConvert a string or number to a long integer, if possible. A floating\npoint argument will be truncated towards zero (this does not include a\nstring representation of a floating point number!) When converting a\nstring, use the optional base. It is an error to supply a base when\nconverting a non-string."`
`public static final java.lang.String` `long_imag_doc` `"the imaginary part of a complex number"`
`public static final java.lang.String` `long_numerator_doc` `"the numerator of a rational number in lowest terms"`
`public static final java.lang.String` `long_real_doc` `"the real part of a complex number"`
`public static final java.lang.String` `memoryview___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `memoryview___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `memoryview___delitem___doc` `"x.__delitem__(y) <==> del x[y]"`
`public static final java.lang.String` `memoryview___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `memoryview___format___doc` `"default object formatter"`
`public static final java.lang.String` `memoryview___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `memoryview___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `memoryview___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `memoryview___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `memoryview___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `memoryview___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `memoryview___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `memoryview___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `memoryview___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `memoryview___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `memoryview___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `memoryview___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `memoryview___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `memoryview___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `memoryview___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `memoryview___setitem___doc` `"x.__setitem__(i, y) <==> x[i]=y"`
`public static final java.lang.String` `memoryview___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `memoryview___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `memoryview___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `memoryview_doc` `"memoryview(object)\n\nCreate a new memoryview object which references the given object."`
`public static final java.lang.String` `memoryview_format_doc` `""`
`public static final java.lang.String` `memoryview_itemsize_doc` `""`
`public static final java.lang.String` `memoryview_ndim_doc` `""`
`public static final java.lang.String` `memoryview_readonly_doc` `""`
`public static final java.lang.String` `memoryview_shape_doc` `""`
`public static final java.lang.String` `memoryview_strides_doc` `""`
`public static final java.lang.String` `memoryview_suboffsets_doc` `""`
`public static final java.lang.String` `memoryview_tobytes_doc` `""`
`public static final java.lang.String` `memoryview_tolist_doc` `""`
`public static final java.lang.String` `object___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `object___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `object___format___doc` `"default object formatter"`
`public static final java.lang.String` `object___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `object___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `object___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `object___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `object___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `object___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `object___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `object___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `object___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `object___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `object___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `object_doc` `"The most base type"`
`public static final java.lang.String` `property___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `property___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `property___delete___doc` `"descr.__delete__(obj)"`
`public static final java.lang.String` `property___format___doc` `"default object formatter"`
`public static final java.lang.String` `property___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `property___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `property___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `property___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `property___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `property___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `property___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `property___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `property___set___doc` `"descr.__set__(obj, value)"`
`public static final java.lang.String` `property___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `property___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `property___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `property___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `property_deleter_doc` `"Descriptor to change the deleter on a property."`

`public static final java.lang.String`

`property_doc`

`"property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n\nfget is a function to be used for getting an attribute value, and likewise\nfset is a function for setting, and fdel a function for del\'ing, an\nattribute. Typical use is to define a managed attribute x:\nclass C(object):\n def getx(self): return self._x\n def setx(self, value): self._x = value\n def delx(self): del self._x\n x = property(getx, setx, delx, \"I\'m the \'x\' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\nclass C(object):\n @property\n def x(self): return self._x\n @x.setter\n def x(self, value): self._x = value\n @x.deleter\n def x(self): del self._x\n"`

`public static final java.lang.String` `property_fdel_doc` `""`
`public static final java.lang.String` `property_fget_doc` `""`
`public static final java.lang.String` `property_fset_doc` `""`
`public static final java.lang.String` `property_getter_doc` `"Descriptor to change the getter on a property."`
`public static final java.lang.String` `property_setter_doc` `"Descriptor to change the setter on a property."`
`public static final java.lang.String` `set___and___doc` `"x.__and__(y) <==> x&y"`
`public static final java.lang.String` `set___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `set___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `set___contains___doc` `"x.__contains__(y) <==> y in x."`
`public static final java.lang.String` `set___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `set___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `set___format___doc` `"default object formatter"`
`public static final java.lang.String` `set___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `set___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `set___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `set___hash___doc` `""`
`public static final java.lang.String` `set___iand___doc` `"x.__iand__(y) <==> x&y"`
`public static final java.lang.String` `set___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `set___ior___doc` `"x.__ior__(y) <==> x|y"`
`public static final java.lang.String` `set___isub___doc` `"x.__isub__(y) <==> x-y"`
`public static final java.lang.String` `set___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `set___ixor___doc` `"x.__ixor__(y) <==> x^y"`
`public static final java.lang.String` `set___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `set___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `set___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `set___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `set___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `set___or___doc` `"x.__or__(y) <==> x|y"`
`public static final java.lang.String` `set___rand___doc` `"x.__rand__(y) <==> y&x"`
`public static final java.lang.String` `set___reduce___doc` `"Return state information for pickling."`
`public static final java.lang.String` `set___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `set___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `set___ror___doc` `"x.__ror__(y) <==> y|x"`
`public static final java.lang.String` `set___rsub___doc` `"x.__rsub__(y) <==> y-x"`
`public static final java.lang.String` `set___rxor___doc` `"x.__rxor__(y) <==> y^x"`
`public static final java.lang.String` `set___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `set___sizeof___doc` `"S.__sizeof__() -> size of S in memory, in bytes"`
`public static final java.lang.String` `set___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `set___sub___doc` `"x.__sub__(y) <==> x-y"`
`public static final java.lang.String` `set___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `set___xor___doc` `"x.__xor__(y) <==> x^y"`
`public static final java.lang.String` `set_add_doc` `"Add an element to a set.\n\nThis has no effect if the element is already present."`
`public static final java.lang.String` `set_clear_doc` `"Remove all elements from this set."`
`public static final java.lang.String` `set_copy_doc` `"Return a shallow copy of a set."`
`public static final java.lang.String` `set_difference_doc` `"Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)"`
`public static final java.lang.String` `set_difference_update_doc` `"Remove all elements of another set from this set."`
`public static final java.lang.String` `set_discard_doc` `"Remove an element from a set if it is a member.\n\nIf the element is not a member, do nothing."`
`public static final java.lang.String` `set_doc` `"set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements."`
`public static final java.lang.String` `set_intersection_doc` `"Return the intersection of two or more sets as a new set.\n\n(i.e. elements that are common to all of the sets.)"`
`public static final java.lang.String` `set_intersection_update_doc` `"Update a set with the intersection of itself and another."`
`public static final java.lang.String` `set_isdisjoint_doc` `"Return True if two sets have a null intersection."`
`public static final java.lang.String` `set_issubset_doc` `"Report whether another set contains this set."`
`public static final java.lang.String` `set_issuperset_doc` `"Report whether this set contains another set."`
`public static final java.lang.String` `set_pop_doc` `"Remove and return an arbitrary set element.\nRaises KeyError if the set is empty."`
`public static final java.lang.String` `set_remove_doc` `"Remove an element from a set; it must be a member.\n\nIf the element is not a member, raise a KeyError."`
`public static final java.lang.String` `set_symmetric_difference_doc` `"Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)"`
`public static final java.lang.String` `set_symmetric_difference_update_doc` `"Update a set with the symmetric difference of itself and another."`
`public static final java.lang.String` `set_union_doc` `"Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)"`
`public static final java.lang.String` `set_update_doc` `"Update a set with the union of itself and others."`
`public static final java.lang.String` `slice___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `slice___cmp___doc` `"x.__cmp__(y) <==> cmp(x,y)"`
`public static final java.lang.String` `slice___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `slice___format___doc` `"default object formatter"`
`public static final java.lang.String` `slice___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `slice___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `slice___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `slice___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `slice___reduce___doc` `"Return state information for pickling."`
`public static final java.lang.String` `slice___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `slice___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `slice___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `slice___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `slice___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `slice___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `slice_doc` `"slice([start,] stop[, step])\n\nCreate a slice object. This is used for extended slicing (e.g. a[0:10:2])."`
`public static final java.lang.String` `slice_indices_doc` `"S.indices(len) -> (start, stop, stride)\n\nAssuming a sequence of length len, calculate the start and stop\nindices, and the stride length of the extended slice described by\nS. Out of bounds indices are clipped in a manner consistent with the\nhandling of normal slices."`
`public static final java.lang.String` `slice_start_doc` `""`
`public static final java.lang.String` `slice_step_doc` `""`
`public static final java.lang.String` `slice_stop_doc` `""`
`public static final java.lang.String` `sre_pattern_doc` `"Compiled regular expression objects"`
`public static final java.lang.String` `sre_pattern_findall_doc` `"findall(string[, pos[, endpos]]) --> list.\n Return a list of all non-overlapping matches of pattern in string."`
`public static final java.lang.String` `sre_pattern_finditer_doc` `"finditer(string[, pos[, endpos]]) --> iterator.\n Return an iterator over all non-overlapping matches for the \n RE pattern in string. For each match, the iterator returns a\n match object."`
`public static final java.lang.String` `sre_pattern_match_doc` `"match(string[, pos[, endpos]]) --> match object or None.\n Matches zero or more characters at the beginning of the string"`
`public static final java.lang.String` `sre_pattern_search_doc` `"search(string[, pos[, endpos]]) --> match object or None.\n Scan through string looking for a match, and return a corresponding\n match object instance. Return None if no position in the string matches."`
`public static final java.lang.String` `sre_pattern_split_doc` `"split(string[, maxsplit = 0]) --> list.\n Split string by the occurrences of pattern."`
`public static final java.lang.String` `sre_pattern_sub_doc` `"sub(repl, string[, count = 0]) --> newstring\n Return the string obtained by replacing the leftmost non-overlapping\n occurrences of pattern in string by the replacement repl."`
`public static final java.lang.String` `sre_pattern_subn_doc` `"subn(repl, string[, count = 0]) --> (newstring, number of subs)\n Return the tuple (new_string, number_of_subs_made) found by replacing\n the leftmost non-overlapping occurrences of pattern with the\n replacement repl."`
`public static final java.lang.String` `staticmethod___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `staticmethod___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `staticmethod___format___doc` `"default object formatter"`
`public static final java.lang.String` `staticmethod___func___doc` `""`
`public static final java.lang.String` `staticmethod___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `staticmethod___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `staticmethod___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `staticmethod___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `staticmethod___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `staticmethod___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `staticmethod___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `staticmethod___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `staticmethod___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `staticmethod___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `staticmethod___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `staticmethod___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`

`public static final java.lang.String`

`staticmethod_doc`

`"staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n class C:\n def f(arg1, arg2, ...): ...\n f = staticmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin."`

`public static final java.lang.String` `str___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `str___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `str___contains___doc` `"x.__contains__(y) <==> y in x"`
`public static final java.lang.String` `str___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `str___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `str___format___doc` `"S.__format__(format_spec) -> string\n\nReturn a formatted version of S as described by format_spec."`
`public static final java.lang.String` `str___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `str___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `str___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `str___getnewargs___doc` `""`
`public static final java.lang.String` `str___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `str___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `str___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `str___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `str___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `str___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `str___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `str___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `str___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `str___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `str___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `str___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `str___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `str___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `str___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `str___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `str___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `str___sizeof___doc` `"S.__sizeof__() -> size of S in memory, in bytes"`
`public static final java.lang.String` `str___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `str___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `str__formatter_field_name_split_doc` `""`
`public static final java.lang.String` `str__formatter_parser_doc` `""`
`public static final java.lang.String` `str_capitalize_doc` `"S.capitalize() -> string\n\nReturn a copy of the string S with only its first character\ncapitalized."`
`public static final java.lang.String` `str_center_doc` `"S.center(width[, fillchar]) -> string\n\nReturn S centered in a string of length width. Padding is\ndone using the specified fill character (default is a space)"`
`public static final java.lang.String` `str_count_doc` `"S.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of substring sub in\nstring S[start:end]. Optional arguments start and end are interpreted\nas in slice notation."`

`public static final java.lang.String`

`str_decode_doc`

`"S.decode([encoding[,errors]]) -> object\n\nDecodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registered with codecs.register_error that is\nable to handle UnicodeDecodeErrors."`

`public static final java.lang.String` `str_doc` `"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."`

`public static final java.lang.String`

`str_encode_doc`

`"S.encode([encoding[,errors]]) -> object\n\nEncodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n\'xmlcharrefreplace\' as well as any other name registered with\ncodecs.register_error that is able to handle UnicodeEncodeErrors."`

`public static final java.lang.String` `str_endswith_doc` `"S.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try."`
`public static final java.lang.String` `str_expandtabs_doc` `"S.expandtabs([tabsize]) -> string\n\nReturn a copy of S where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."`
`public static final java.lang.String` `str_find_doc` `"S.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `str_format_doc` `"S.format(*args, **kwargs) -> string\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces (\'{\' and \'}\')."`
`public static final java.lang.String` `str_index_doc` `"S.index(sub [,start [,end]]) -> int\n\nLike S.find() but raise ValueError when the substring is not found."`
`public static final java.lang.String` `str_isalnum_doc` `"S.isalnum() -> bool\n\nReturn True if all characters in S are alphanumeric\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `str_isalpha_doc` `"S.isalpha() -> bool\n\nReturn True if all characters in S are alphabetic\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `str_isdigit_doc` `"S.isdigit() -> bool\n\nReturn True if all characters in S are digits\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `str_islower_doc` `"S.islower() -> bool\n\nReturn True if all cased characters in S are lowercase and there is\nat least one cased character in S, False otherwise."`
`public static final java.lang.String` `str_isspace_doc` `"S.isspace() -> bool\n\nReturn True if all characters in S are whitespace\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `str_istitle_doc` `"S.istitle() -> bool\n\nReturn True if S is a titlecased string and there is at least one\ncharacter in S, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise."`
`public static final java.lang.String` `str_isupper_doc` `"S.isupper() -> bool\n\nReturn True if all cased characters in S are uppercase and there is\nat least one cased character in S, False otherwise."`
`public static final java.lang.String` `str_join_doc` `"S.join(iterable) -> string\n\nReturn a string which is the concatenation of the strings in the\niterable. The separator between elements is S."`
`public static final java.lang.String` `str_ljust_doc` `"S.ljust(width[, fillchar]) -> string\n\nReturn S left-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)."`
`public static final java.lang.String` `str_lower_doc` `"S.lower() -> string\n\nReturn a copy of the string S converted to lowercase."`
`public static final java.lang.String` `str_lstrip_doc` `"S.lstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"`
`public static final java.lang.String` `str_partition_doc` `"S.partition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, and return the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, return S and two empty strings."`
`public static final java.lang.String` `str_replace_doc` `"S.replace(old, new[, count]) -> string\n\nReturn a copy of string S with all occurrences of substring\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."`
`public static final java.lang.String` `str_rfind_doc` `"S.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `str_rindex_doc` `"S.rindex(sub [,start [,end]]) -> int\n\nLike S.rfind() but raise ValueError when the substring is not found."`
`public static final java.lang.String` `str_rjust_doc` `"S.rjust(width[, fillchar]) -> string\n\nReturn S right-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)"`
`public static final java.lang.String` `str_rpartition_doc` `"S.rpartition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, starting at the end of S, and return\nthe part before it, the separator itself, and the part after it. If the\nseparator is not found, return two empty strings and S."`
`public static final java.lang.String` `str_rsplit_doc` `"S.rsplit([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string, starting at the end of the string and working\nto the front. If maxsplit is given, at most maxsplit splits are\ndone. If sep is not specified or is None, any whitespace string\nis a separator."`
`public static final java.lang.String` `str_rstrip_doc` `"S.rstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with trailing whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"`
`public static final java.lang.String` `str_split_doc` `"S.split([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified or is None, any\nwhitespace string is a separator and empty strings are removed\nfrom the result."`
`public static final java.lang.String` `str_splitlines_doc` `"S.splitlines([keepends]) -> list of strings\n\nReturn a list of the lines in S, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."`
`public static final java.lang.String` `str_startswith_doc` `"S.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try."`
`public static final java.lang.String` `str_strip_doc` `"S.strip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading and trailing\nwhitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"`
`public static final java.lang.String` `str_swapcase_doc` `"S.swapcase() -> string\n\nReturn a copy of the string S with uppercase characters\nconverted to lowercase and vice versa."`
`public static final java.lang.String` `str_title_doc` `"S.title() -> string\n\nReturn a titlecased version of S, i.e. words start with uppercase\ncharacters, all remaining cased characters have lowercase."`
`public static final java.lang.String` `str_translate_doc` `"S.translate(table [,deletechars]) -> string\n\nReturn a copy of the string S, where all characters occurring\nin the optional argument deletechars are removed, and the\nremaining characters have been mapped through the given\ntranslation table, which must be a string of length 256."`
`public static final java.lang.String` `str_upper_doc` `"S.upper() -> string\n\nReturn a copy of the string S converted to uppercase."`
`public static final java.lang.String` `str_zfill_doc` `"S.zfill(width) -> string\n\nPad a numeric string S with zeros on the left, to fill a field\nof the specified width. The string S is never truncated."`
`public static final java.lang.String` `super___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `super___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `super___format___doc` `"default object formatter"`
`public static final java.lang.String` `super___get___doc` `"descr.__get__(obj[, type]) -> value"`
`public static final java.lang.String` `super___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `super___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `super___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `super___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `super___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `super___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `super___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `super___self___doc` `"the instance invoking super(); may be None"`
`public static final java.lang.String` `super___self_class___doc` `"the type of the instance invoking super(); may be None"`
`public static final java.lang.String` `super___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `super___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `super___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `super___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `super___thisclass___doc` `"the class invoking super()"`
`public static final java.lang.String` `super_doc` `"super(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n def meth(self, arg):\n super(C, self).meth(arg)"`
`public static final java.lang.String` `traceback___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `traceback___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `traceback___format___doc` `"default object formatter"`
`public static final java.lang.String` `traceback___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `traceback___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `traceback___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `traceback___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `traceback___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `traceback___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `traceback___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `traceback___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `traceback___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `traceback___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `traceback___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `traceback_doc` `""`
`public static final java.lang.String` `traceback_tb_frame_doc` `""`
`public static final java.lang.String` `traceback_tb_lasti_doc` `""`
`public static final java.lang.String` `traceback_tb_lineno_doc` `""`
`public static final java.lang.String` `traceback_tb_next_doc` `""`
`public static final java.lang.String` `tuple___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `tuple___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `tuple___contains___doc` `"x.__contains__(y) <==> y in x"`
`public static final java.lang.String` `tuple___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `tuple___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `tuple___format___doc` `"default object formatter"`
`public static final java.lang.String` `tuple___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `tuple___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `tuple___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `tuple___getnewargs___doc` `""`
`public static final java.lang.String` `tuple___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `tuple___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `tuple___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `tuple___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `tuple___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `tuple___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `tuple___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `tuple___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `tuple___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `tuple___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `tuple___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `tuple___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `tuple___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `tuple___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `tuple___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `tuple___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `tuple___sizeof___doc` `"T.__sizeof__() -- size of T in memory, in bytes"`
`public static final java.lang.String` `tuple___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `tuple___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `tuple_count_doc` `"T.count(value) -> integer -- return number of occurrences of value"`
`public static final java.lang.String` `tuple_doc` `"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."`
`public static final java.lang.String` `tuple_index_doc` `"T.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present."`
`public static final java.lang.String` `type___abstractmethods___doc` `""`
`public static final java.lang.String` `type___base___doc` `"The most base type"`
`public static final java.lang.String` `type___bases___doc` `"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."`

`public static final java.lang.String`

`type___basicsize___doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `type___call___doc` `"x.__call__(...) <==> x(...)"`
`public static final java.lang.String` `type___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `type___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `type___dict___doc` `""`

`public static final java.lang.String`

`type___dictoffset___doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `type___eq___doc` `"x.__eq__(y) <==> x==y"`

`public static final java.lang.String`

`type___flags___doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `type___format___doc` `"default object formatter"`
`public static final java.lang.String` `type___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `type___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `type___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `type___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `type___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `type___instancecheck___doc` `"__instancecheck__() -> bool\ncheck if an object is an instance"`

`public static final java.lang.String`

`type___itemsize___doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `type___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `type___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `type___module___doc` `"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."`
`public static final java.lang.String` `type___mro___doc` `"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."`
`public static final java.lang.String` `type___name___doc` `"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."`
`public static final java.lang.String` `type___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `type___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `type___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `type___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `type___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `type___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `type___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `type___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `type___subclasscheck___doc` `"__subclasscheck__() -> bool\ncheck if a class is a subclass"`
`public static final java.lang.String` `type___subclasses___doc` `"__subclasses__() -> list of immediate subclasses"`
`public static final java.lang.String` `type___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`

`public static final java.lang.String`

`type___weakrefoffset___doc`

`"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."`

`public static final java.lang.String` `type_doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `type_mro_doc` `"mro() -> list\nreturn a type\'s method resolution order"`
`public static final java.lang.String` `unicode___add___doc` `"x.__add__(y) <==> x+y"`
`public static final java.lang.String` `unicode___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `unicode___contains___doc` `"x.__contains__(y) <==> y in x"`
`public static final java.lang.String` `unicode___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `unicode___eq___doc` `"x.__eq__(y) <==> x==y"`
`public static final java.lang.String` `unicode___format___doc` `"S.__format__(format_spec) -> unicode\n\nReturn a formatted version of S as described by format_spec."`
`public static final java.lang.String` `unicode___ge___doc` `"x.__ge__(y) <==> x>=y"`
`public static final java.lang.String` `unicode___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `unicode___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `unicode___getnewargs___doc` `""`
`public static final java.lang.String` `unicode___getslice___doc` `"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."`
`public static final java.lang.String` `unicode___gt___doc` `"x.__gt__(y) <==> x>y"`
`public static final java.lang.String` `unicode___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `unicode___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `unicode___le___doc` `"x.__le__(y) <==> x<=y"`
`public static final java.lang.String` `unicode___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `unicode___lt___doc` `"x.__lt__(y) <==> x<y"`
`public static final java.lang.String` `unicode___mod___doc` `"x.__mod__(y) <==> x%y"`
`public static final java.lang.String` `unicode___mul___doc` `"x.__mul__(n) <==> x*n"`
`public static final java.lang.String` `unicode___ne___doc` `"x.__ne__(y) <==> x!=y"`
`public static final java.lang.String` `unicode___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `unicode___reduce___doc` `"helper for pickle"`
`public static final java.lang.String` `unicode___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `unicode___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `unicode___rmod___doc` `"x.__rmod__(y) <==> y%x"`
`public static final java.lang.String` `unicode___rmul___doc` `"x.__rmul__(n) <==> n*x"`
`public static final java.lang.String` `unicode___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `unicode___sizeof___doc` `"S.__sizeof__() -> size of S in memory, in bytes\n\n"`
`public static final java.lang.String` `unicode___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `unicode___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `unicode__formatter_field_name_split_doc` `""`
`public static final java.lang.String` `unicode__formatter_parser_doc` `""`
`public static final java.lang.String` `unicode_capitalize_doc` `"S.capitalize() -> unicode\n\nReturn a capitalized version of S, i.e. make the first character\nhave upper case and the rest lower case."`
`public static final java.lang.String` `unicode_center_doc` `"S.center(width[, fillchar]) -> unicode\n\nReturn S centered in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)"`
`public static final java.lang.String` `unicode_count_doc` `"S.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of substring sub in\nUnicode string S[start:end]. Optional arguments start and end are\ninterpreted as in slice notation."`

`public static final java.lang.String`

`unicode_decode_doc`

`"S.decode([encoding[,errors]]) -> string or unicode\n\nDecodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registerd with codecs.register_error that is\nable to handle UnicodeDecodeErrors."`

`public static final java.lang.String` `unicode_doc` `"unicode(object=\'\') -> unicode object\nunicode(string[, encoding[, errors]]) -> unicode object\n\nCreate a new Unicode object from the given encoded string.\nencoding defaults to the current default string encoding.\nerrors can be \'strict\', \'replace\' or \'ignore\' and defaults to \'strict\'."`

`public static final java.lang.String`

`unicode_encode_doc`

`"S.encode([encoding[,errors]]) -> string or unicode\n\nEncodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n\'xmlcharrefreplace\' as well as any other name registered with\ncodecs.register_error that can handle UnicodeEncodeErrors."`

`public static final java.lang.String` `unicode_endswith_doc` `"S.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try."`
`public static final java.lang.String` `unicode_expandtabs_doc` `"S.expandtabs([tabsize]) -> unicode\n\nReturn a copy of S where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."`
`public static final java.lang.String` `unicode_find_doc` `"S.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `unicode_format_doc` `"S.format(*args, **kwargs) -> unicode\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces (\'{\' and \'}\')."`
`public static final java.lang.String` `unicode_index_doc` `"S.index(sub [,start [,end]]) -> int\n\nLike S.find() but raise ValueError when the substring is not found."`
`public static final java.lang.String` `unicode_isalnum_doc` `"S.isalnum() -> bool\n\nReturn True if all characters in S are alphanumeric\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `unicode_isalpha_doc` `"S.isalpha() -> bool\n\nReturn True if all characters in S are alphabetic\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `unicode_isdecimal_doc` `"S.isdecimal() -> bool\n\nReturn True if there are only decimal characters in S,\nFalse otherwise."`
`public static final java.lang.String` `unicode_isdigit_doc` `"S.isdigit() -> bool\n\nReturn True if all characters in S are digits\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `unicode_islower_doc` `"S.islower() -> bool\n\nReturn True if all cased characters in S are lowercase and there is\nat least one cased character in S, False otherwise."`
`public static final java.lang.String` `unicode_isnumeric_doc` `"S.isnumeric() -> bool\n\nReturn True if there are only numeric characters in S,\nFalse otherwise."`
`public static final java.lang.String` `unicode_isspace_doc` `"S.isspace() -> bool\n\nReturn True if all characters in S are whitespace\nand there is at least one character in S, False otherwise."`
`public static final java.lang.String` `unicode_istitle_doc` `"S.istitle() -> bool\n\nReturn True if S is a titlecased string and there is at least one\ncharacter in S, i.e. upper- and titlecase characters may only\nfollow uncased characters and lowercase characters only cased ones.\nReturn False otherwise."`
`public static final java.lang.String` `unicode_isupper_doc` `"S.isupper() -> bool\n\nReturn True if all cased characters in S are uppercase and there is\nat least one cased character in S, False otherwise."`
`public static final java.lang.String` `unicode_join_doc` `"S.join(iterable) -> unicode\n\nReturn a string which is the concatenation of the strings in the\niterable. The separator between elements is S."`
`public static final java.lang.String` `unicode_ljust_doc` `"S.ljust(width[, fillchar]) -> int\n\nReturn S left-justified in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)."`
`public static final java.lang.String` `unicode_lower_doc` `"S.lower() -> unicode\n\nReturn a copy of the string S converted to lowercase."`
`public static final java.lang.String` `unicode_lstrip_doc` `"S.lstrip([chars]) -> unicode\n\nReturn a copy of the string S with leading whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"`
`public static final java.lang.String` `unicode_partition_doc` `"S.partition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, and return the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, return S and two empty strings."`
`public static final java.lang.String` `unicode_replace_doc` `"S.replace(old, new[, count]) -> unicode\n\nReturn a copy of S with all occurrences of substring\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."`
`public static final java.lang.String` `unicode_rfind_doc` `"S.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."`
`public static final java.lang.String` `unicode_rindex_doc` `"S.rindex(sub [,start [,end]]) -> int\n\nLike S.rfind() but raise ValueError when the substring is not found."`
`public static final java.lang.String` `unicode_rjust_doc` `"S.rjust(width[, fillchar]) -> unicode\n\nReturn S right-justified in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)."`
`public static final java.lang.String` `unicode_rpartition_doc` `"S.rpartition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, starting at the end of S, and return\nthe part before it, the separator itself, and the part after it. If the\nseparator is not found, return two empty strings and S."`
`public static final java.lang.String` `unicode_rsplit_doc` `"S.rsplit([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in S, using sep as the\ndelimiter string, starting at the end of the string and\nworking to the front. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified, any whitespace string\nis a separator."`
`public static final java.lang.String` `unicode_rstrip_doc` `"S.rstrip([chars]) -> unicode\n\nReturn a copy of the string S with trailing whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"`
`public static final java.lang.String` `unicode_split_doc` `"S.split([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in S, using sep as the\ndelimiter string. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified or is None, any\nwhitespace string is a separator and empty strings are\nremoved from the result."`
`public static final java.lang.String` `unicode_splitlines_doc` `"S.splitlines([keepends]) -> list of strings\n\nReturn a list of the lines in S, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."`
`public static final java.lang.String` `unicode_startswith_doc` `"S.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try."`
`public static final java.lang.String` `unicode_strip_doc` `"S.strip([chars]) -> unicode\n\nReturn a copy of the string S with leading and trailing\nwhitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"`
`public static final java.lang.String` `unicode_swapcase_doc` `"S.swapcase() -> unicode\n\nReturn a copy of S with uppercase characters converted to lowercase\nand vice versa."`
`public static final java.lang.String` `unicode_title_doc` `"S.title() -> unicode\n\nReturn a titlecased version of S, i.e. words start with title case\ncharacters, all remaining cased characters have lower case."`
`public static final java.lang.String` `unicode_translate_doc` `"S.translate(table) -> unicode\n\nReturn a copy of the string S, where all characters have been mapped\nthrough the given translation table, which must be a mapping of\nUnicode ordinals to Unicode ordinals, Unicode strings or None.\nUnmapped characters are left untouched. Characters mapped to None\nare deleted."`
`public static final java.lang.String` `unicode_upper_doc` `"S.upper() -> unicode\n\nReturn a copy of S converted to uppercase."`
`public static final java.lang.String` `unicode_zfill_doc` `"S.zfill(width) -> unicode\n\nPad a numeric string S with zeros on the left, to fill a field\nof the specified width. The string S is never truncated."`
`public static final java.lang.String` `xrange___class___doc` `"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"`
`public static final java.lang.String` `xrange___delattr___doc` `"x.__delattr__(\'name\') <==> del x.name"`
`public static final java.lang.String` `xrange___format___doc` `"default object formatter"`
`public static final java.lang.String` `xrange___getattribute___doc` `"x.__getattribute__(\'name\') <==> x.name"`
`public static final java.lang.String` `xrange___getitem___doc` `"x.__getitem__(y) <==> x[y]"`
`public static final java.lang.String` `xrange___hash___doc` `"x.__hash__() <==> hash(x)"`
`public static final java.lang.String` `xrange___init___doc` `"x.__init__(...) initializes x; see help(type(x)) for signature"`
`public static final java.lang.String` `xrange___iter___doc` `"x.__iter__() <==> iter(x)"`
`public static final java.lang.String` `xrange___len___doc` `"x.__len__() <==> len(x)"`
`public static final java.lang.String` `xrange___new___doc` `"T.__new__(S, ...) -> a new object with type S, a subtype of T"`
`public static final java.lang.String` `xrange___reduce___doc` `""`
`public static final java.lang.String` `xrange___reduce_ex___doc` `"helper for pickle"`
`public static final java.lang.String` `xrange___repr___doc` `"x.__repr__() <==> repr(x)"`
`public static final java.lang.String` `xrange___reversed___doc` `"Returns a reverse iterator."`
`public static final java.lang.String` `xrange___setattr___doc` `"x.__setattr__(\'name\', value) <==> x.name = value"`
`public static final java.lang.String` `xrange___sizeof___doc` `"__sizeof__() -> int\nsize of object in memory, in bytes"`
`public static final java.lang.String` `xrange___str___doc` `"x.__str__() <==> str(x)"`
`public static final java.lang.String` `xrange___subclasshook___doc` `"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"`
`public static final java.lang.String` `xrange_doc` `"xrange([start,] stop[, step]) -> xrange object\n\nLike range(), but instead of returning a list, returns an object that\ngenerates the numbers in the range on demand. For looping, this is \nslightly faster than range() and more memory efficient."`

org.python.core.ClasspathPyImporter
`public static final java.lang.String` `PYCLASSPATH_PREFIX` `"__pyclasspath__/"`

org.python.core.codecs
`public static final java.lang.String` `BACKSLASHREPLACE` `"backslashreplace"`
`public static final java.lang.String` `IGNORE` `"ignore"`
`public static final java.lang.String` `REPLACE` `"replace"`
`public static final java.lang.String` `XMLCHARREFREPLACE` `"xmlcharrefreplace"`

org.python.core.CodeLoader
`public static final java.lang.String` `GET_BOOTSTRAP_METHOD_NAME` `"getCodeBootstrap"`
`public static final java.lang.String` `SIMPLE_FACTORY_METHOD_NAME` `"createSimpleBootstrap"`

org.python.core.CompilerFlags
`public static final int` `PyCF_DONT_IMPLY_DEDENT` `512`
`public static final int` `PyCF_ONLY_AST` `1024`
`public static final int` `PyCF_SOURCE_IS_UTF8` `256`

org.python.core.FutureFeature
`public static final java.lang.String` `MODULE_NAME` `"__future__"`

org.python.core.imp
`public static final int` `DEFAULT_LEVEL` `-1`
`public static final int` `NO_MTIME` `-1`

org.python.core.JavaImporter
`public static final java.lang.String` `JAVA_IMPORT_PATH_ENTRY` `"__classpath__"`

org.python.core.JyAttribute
`public static final byte` `FINALIZE_TRIGGER_ATTR` `127`
`public static final byte` `GC_CYCLE_MARK_ATTR` `5`
`public static final byte` `GC_DELAYED_FINALIZE_CRITICAL_MARK_ATTR` `6`
`public static final byte` `JAVA_PROXY_ATTR` `-128`
`public static final byte` `JYNI_HANDLE_ATTR` `1`
`public static final byte` `PY_ID_ATTR` `2`
`public static final byte` `PYCLASS_PY2JY_CACHE_ATTR` `4`
`public static final byte` `WEAK_REF_ATTR` `0`
`public static final byte` `WEAKREF_PENDING_GET_ATTR` `3`

org.python.core.Opcode
`public static final int` `BINARY_ADD` `23`
`public static final int` `BINARY_AND` `64`
`public static final int` `BINARY_DIVIDE` `21`
`public static final int` `BINARY_FLOOR_DIVIDE` `26`
`public static final int` `BINARY_LSHIFT` `62`
`public static final int` `BINARY_MODULO` `22`
`public static final int` `BINARY_MULTIPLY` `20`
`public static final int` `BINARY_OR` `66`
`public static final int` `BINARY_POWER` `19`
`public static final int` `BINARY_RSHIFT` `63`
`public static final int` `BINARY_SUBSCR` `25`
`public static final int` `BINARY_SUBTRACT` `24`
`public static final int` `BINARY_TRUE_DIVIDE` `27`
`public static final int` `BINARY_XOR` `65`
`public static final int` `BREAK_LOOP` `80`
`public static final int` `BUILD_CLASS` `89`
`public static final int` `BUILD_LIST` `103`
`public static final int` `BUILD_MAP` `105`
`public static final int` `BUILD_SET` `104`
`public static final int` `BUILD_SLICE` `133`
`public static final int` `BUILD_TUPLE` `102`
`public static final int` `CALL_FUNCTION` `131`
`public static final int` `CALL_FUNCTION_KW` `141`
`public static final int` `CALL_FUNCTION_VAR` `140`
`public static final int` `CALL_FUNCTION_VAR_KW` `142`
`public static final int` `COMPARE_OP` `107`
`public static final int` `CONTINUE_LOOP` `119`
`public static final int` `DELETE_ATTR` `96`
`public static final int` `DELETE_FAST` `126`
`public static final int` `DELETE_GLOBAL` `98`
`public static final int` `DELETE_NAME` `91`
`public static final int` `DELETE_SLICE` `50`
`public static final int` `DELETE_SLICE_1` `51`
`public static final int` `DELETE_SLICE_2` `52`
`public static final int` `DELETE_SLICE_3` `53`
`public static final int` `DELETE_SUBSCR` `61`
`public static final int` `DUP_TOP` `4`
`public static final int` `DUP_TOPX` `99`
`public static final int` `END_FINALLY` `88`
`public static final int` `EXEC_STMT` `85`
`public static final int` `EXTENDED_ARG` `145`
`public static final int` `FOR_ITER` `93`
`public static final int` `GET_ITER` `68`
`public static final int` `HAVE_ARGUMENT` `90`
`public static final int` `IMPORT_FROM` `109`
`public static final int` `IMPORT_NAME` `108`
`public static final int` `IMPORT_STAR` `84`
`public static final int` `INPLACE_ADD` `55`
`public static final int` `INPLACE_AND` `77`
`public static final int` `INPLACE_DIVIDE` `58`
`public static final int` `INPLACE_FLOOR_DIVIDE` `28`
`public static final int` `INPLACE_LSHIFT` `75`
`public static final int` `INPLACE_MODULO` `59`
`public static final int` `INPLACE_MULTIPLY` `57`
`public static final int` `INPLACE_OR` `79`
`public static final int` `INPLACE_POWER` `67`
`public static final int` `INPLACE_RSHIFT` `76`
`public static final int` `INPLACE_SUBTRACT` `56`
`public static final int` `INPLACE_TRUE_DIVIDE` `29`
`public static final int` `INPLACE_XOR` `78`
`public static final int` `JUMP_ABSOLUTE` `113`
`public static final int` `JUMP_FORWARD` `110`
`public static final int` `JUMP_IF_FALSE_OR_POP` `111`
`public static final int` `JUMP_IF_TRUE_OR_POP` `112`
`public static final int` `LIST_APPEND` `94`
`public static final int` `LOAD_ATTR` `106`
`public static final int` `LOAD_CLOSURE` `135`
`public static final int` `LOAD_CONST` `100`
`public static final int` `LOAD_DEREF` `136`
`public static final int` `LOAD_FAST` `124`
`public static final int` `LOAD_GLOBAL` `116`
`public static final int` `LOAD_LOCALS` `82`
`public static final int` `LOAD_NAME` `101`
`public static final int` `MAKE_CLOSURE` `134`
`public static final int` `MAKE_FUNCTION` `132`
`public static final int` `MAP_ADD` `147`
`public static final int` `NOP` `9`
`public static final int` `POP_BLOCK` `87`
`public static final int` `POP_JUMP_IF_FALSE` `114`
`public static final int` `POP_JUMP_IF_TRUE` `115`
`public static final int` `POP_TOP` `1`
`public static final int` `PRINT_EXPR` `70`
`public static final int` `PRINT_ITEM` `71`
`public static final int` `PRINT_ITEM_TO` `73`
`public static final int` `PRINT_NEWLINE` `72`
`public static final int` `PRINT_NEWLINE_TO` `74`
`public static final int` `PyCmp_BAD` `11`
`public static final int` `PyCmp_EQ` `2`
`public static final int` `PyCmp_EXC_MATCH` `10`
`public static final int` `PyCmp_GE` `5`
`public static final int` `PyCmp_GT` `4`
`public static final int` `PyCmp_IN` `6`
`public static final int` `PyCmp_IS` `8`
`public static final int` `PyCmp_IS_NOT` `9`
`public static final int` `PyCmp_LE` `1`
`public static final int` `PyCmp_LT` `0`
`public static final int` `PyCmp_NE` `3`
`public static final int` `PyCmp_NOT_IN` `7`
`public static final int` `RAISE_VARARGS` `130`
`public static final int` `RETURN_VALUE` `83`
`public static final int` `ROT_FOUR` `5`
`public static final int` `ROT_THREE` `3`
`public static final int` `ROT_TWO` `2`
`public static final int` `SET_ADD` `146`
`public static final int` `SETUP_EXCEPT` `121`
`public static final int` `SETUP_FINALLY` `122`
`public static final int` `SETUP_LOOP` `120`
`public static final int` `SETUP_WITH` `143`
`public static final int` `SLICE` `30`
`public static final int` `SLICE_1` `31`
`public static final int` `SLICE_2` `32`
`public static final int` `SLICE_3` `33`
`public static final int` `STOP_CODE` `0`
`public static final int` `STORE_ATTR` `95`
`public static final int` `STORE_DEREF` `137`
`public static final int` `STORE_FAST` `125`
`public static final int` `STORE_GLOBAL` `97`
`public static final int` `STORE_MAP` `54`
`public static final int` `STORE_NAME` `90`
`public static final int` `STORE_SLICE` `40`
`public static final int` `STORE_SLICE_1` `41`
`public static final int` `STORE_SLICE_2` `42`
`public static final int` `STORE_SLICE_3` `43`
`public static final int` `STORE_SUBSCR` `60`
`public static final int` `UNARY_CONVERT` `13`
`public static final int` `UNARY_INVERT` `15`
`public static final int` `UNARY_NEGATIVE` `11`
`public static final int` `UNARY_NOT` `12`
`public static final int` `UNARY_POSITIVE` `10`
`public static final int` `UNPACK_SEQUENCE` `92`
`public static final int` `WITH_CLEANUP` `81`
`public static final int` `YIELD_VALUE` `86`

org.python.core.Options
`public static final java.lang.String` `sreCacheSpecDefault` `"weakKeys,concurrencyLevel=4,maximumWeight=2621440,expireAfterAccess=30s"`

org.python.core.PrePy
`public static final int` `COMMENT` `2`
`public static final int` `DEBUG` `3`
`public static final int` `ERROR` `-1`
`public static final int` `MESSAGE` `1`
`public static final int` `WARNING` `0`

org.python.core.Py
`public static final long` `TPFLAGS_BASETYPE` `1024L`
`public static final long` `TPFLAGS_HEAPTYPE` `512L`
`public static final long` `TPFLAGS_IS_ABSTRACT` `1048576L`

org.python.core.PyBUF
`public static final int` `ANY_CONTIGUOUS` `152`
`public static final int` `AS_ARRAY` `268435456`
`public static final int` `C_CONTIGUOUS` `56`
`public static final int` `CONTIG` `9`
`public static final int` `CONTIG_RO` `8`
`public static final int` `CONTIGUITY` `224`
`public static final int` `F_CONTIGUOUS` `88`
`public static final int` `FORMAT` `4`
`public static final int` `FULL` `285`
`public static final int` `FULL_RO` `284`
`public static final int` `INDIRECT` `280`
`public static final int` `IS_C_CONTIGUOUS` `32`
`public static final int` `IS_F_CONTIGUOUS` `64`
`public static final int` `MAX_NDIM` `64`
`public static final int` `NAVIGATION` `280`
`public static final int` `ND` `8`
`public static final int` `RECORDS` `29`
`public static final int` `RECORDS_RO` `28`
`public static final int` `SIMPLE` `0`
`public static final int` `STRIDED` `25`
`public static final int` `STRIDED_RO` `24`
`public static final int` `STRIDES` `24`
`public static final int` `WRITABLE` `1`

org.python.core.PyBytecode
`public static final int` `CO_MAXBLOCKS` `20`

org.python.core.PyRunnableBootstrap
`public static final java.lang.String` `REFLECTION_METHOD_NAME` `"getFilenameConstructorReflectionBootstrap"`

org.python.core.PySystemState
`public static final java.lang.String` `JYTHON_DEV_JAR` `"jython-dev.jar"`
`public static final java.lang.String` `JYTHON_JAR` `"jython.jar"`
`public static final int` `maxint` `2147483647`
`public static final int` `maxsize` `2147483647`
`public static final int` `maxunicode` `1114111`
`public static final int` `minint` `-2147483648`

org.python.core.PyVersionInfo
`public static final int` `n_fields` `5`
`public static final int` `n_sequence_fields` `5`
`public static final int` `n_unnamed_fields` `5`

org.python.core.ReflectedArgs
`public static final int` `PyArgsCall` `1`
`public static final int` `PyArgsKeywordsCall` `2`
`public static final int` `REPLACE` `1998`
`public static final int` `StandardCall` `0`

org.python.core.RegistryKey
`public static final java.lang.String` `PYTHON_CACHEDIR` `"python.cachedir"`
`public static final java.lang.String` `PYTHON_CACHEDIR_SKIP` `"python.cachedir.skip"`
`public static final java.lang.String` `PYTHON_CONSOLE` `"python.console"`
`public static final java.lang.String` `PYTHON_CONSOLE_ENCODING` `"python.console.encoding"`
`public static final java.lang.String` `PYTHON_CPYTHON` `"python.cpython2"`
`public static final java.lang.String` `PYTHON_DIVISION_WARNING` `"python.division.warning"`
`public static final java.lang.String` `PYTHON_IMPORT_SITE` `"python.import.site"`
`public static final java.lang.String` `PYTHON_INSPECT` `"python.inspect"`
`public static final java.lang.String` `PYTHON_IO_ENCODING` `"python.io.encoding"`
`public static final java.lang.String` `PYTHON_IO_ERRORS` `"python.io.errors"`
`public static final java.lang.String` `PYTHON_LOCALE_CONTROL` `"python.locale.control"`
`public static final java.lang.String` `PYTHON_MODULES_BUILTIN` `"python.modules.builtin"`
`public static final java.lang.String` `PYTHON_OPTIONS_CASE_OK` `"python.options.caseok"`
`public static final java.lang.String` `PYTHON_OPTIONS_INCLUDE_JAVA_STACK_IN_EXCEPTIONS` `"python.options.includeJavaStackInExceptions"`
`public static final java.lang.String` `PYTHON_OPTIONS_PROXY_DEBUG_DIRECTORY` `"python.options.proxyDebugDirectory"`
`public static final java.lang.String` `PYTHON_OPTIONS_Q_NEW` `"python.options.Qnew"`
`public static final java.lang.String` `PYTHON_OPTIONS_SHOW_JAVA_EXCEPTIONS` `"python.options.showJavaExceptions"`
`public static final java.lang.String` `PYTHON_OPTIONS_SHOW_PYTHON_PROXY_EXCEPTIONS` `"python.options.showPythonProxyExceptions"`
`public static final java.lang.String` `PYTHON_OS` `"python.os"`
`public static final java.lang.String` `PYTHON_PACKAGES_DIRECTORIES` `"python.packages.directories"`
`public static final java.lang.String` `PYTHON_PACKAGES_FAKEPATH` `"python.packages.fakepath"`
`public static final java.lang.String` `PYTHON_PACKAGES_PATHS` `"python.packages.paths"`
`public static final java.lang.String` `PYTHON_PATH` `"python.path"`
`public static final java.lang.String` `PYTHON_SECURITY_RESPECT_JAVA_ACCESSIBILITY` `"python.security.respectJavaAccessibility"`
`public static final java.lang.String` `PYTHON_SRE_CACHESPEC` `"python.sre.cachespec"`
`public static final java.lang.String` `PYTHON_STARTUP` `"python.startup"`
`public static final java.lang.String` `PYTHON_VERBOSE` `"python.verbose"`
`public static final java.lang.String` `USER_HOME` `"user.home"`

org.python.core.finalization.FinalizeTrigger
`public static final byte` `FINALIZED_FLAG` `32`
`public static final byte` `NOT_FINALIZABLE_FLAG` `8`
`public static final byte` `NOTIFY_GC_FLAG` `1`
`public static final byte` `ONLY_BUILTIN_FLAG` `16`

org.python.core.io.IOBase
`public static final int` `DEFAULT_BUFFER_SIZE` `8192`

org.python.core.io.TextIOBase
`public static final int` `CHUNK_SIZE` `300`

org.python.core.stringlib.InternalFormat.Spec
`public static final char` `NONE` `65535`
`public static final int` `UNSPECIFIED` `-1`

org.python.modules._bytecodetools
`public static final java.lang.String` `__doc__` `"Provides utilities for generated bytecode.\n"`
`public static final java.lang.String` `__name__` `"BytecodeTools"`

org.python.modules._imp
`public static final int` `C_BUILTIN` `6`
`public static final int` `C_EXTENSION` `3`
`public static final int` `IMP_HOOK` `9`
`public static final int` `PKG_DIRECTORY` `5`
`public static final int` `PY_COMPILED` `2`
`public static final int` `PY_FROZEN` `7`
`public static final int` `PY_SOURCE` `1`

org.python.modules.cPickle
`public static final java.lang.String` `format_version` `"2.0"`
`public static final int` `HIGHEST_PROTOCOL` `2`

org.python.modules.cStringIO

`public static final java.lang.String`

`__doc__`

`"A simple fast partial StringIO replacement.\n\nThis module provides a simple useful replacement for\nthe StringIO module that is written in Java. It does not provide the\nfull generality of StringIO, but it provides enough for most\napplications and is especially useful in conjunction with the\npickle module.\n\nUsage:\n\n from cStringIO import StringIO\n\n an_output_stream=StringIO()\n an_output_stream.write(some_stuff)\n ...\n value=an_output_stream.getvalue()\n\n an_input_stream=StringIO(a_string)\n spam=an_input_stream.readline()\n spam=an_input_stream.read(5)\n an_input_stream.seek(0) # OK, start over\n spam=an_input_stream.read() # and read it all\n \nIf someone else wants to provide a more complete implementation,\ngo for it. :-) \n\ncStringIO.java,v 1.10 1999/05/20 18:03:20 fb Exp\nPython-level doc was inserted on 2017/02/01, copied from\ncStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp\n"`

`public static final java.lang.String` `__doc__StringIO` `"StringIO([s]) -- Return a StringIO-like stream for reading or writing"`

org.python.modules.cStringIO.StringIO
`public static final java.lang.String` `__doc__close` `"close(): explicitly release resources held."`
`public static final java.lang.String` `__doc__flush` `"flush(): does nothing."`
`public static final java.lang.String` `__doc__getvalue` `"getvalue([use_pos]) -- Get the string value.\nIf use_pos is specified and is a true value, then the string returned\nwill include only the text up to the current file position.\n"`
`public static final java.lang.String` `__doc__isatty` `"isatty(): always returns 0"`
`public static final java.lang.String` `__doc__read` `"read([s]) -- Read s characters, or the rest of the string"`
`public static final java.lang.String` `__doc__readline` `"readline() -- Read one line"`
`public static final java.lang.String` `__doc__readlines` `"readlines() -- Read all lines"`
`public static final java.lang.String` `__doc__reset` `"reset() -- Reset the file position to the beginning"`
`public static final java.lang.String` `__doc__seek` `"seek(position) -- set the current position\nseek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF"`
`public static final java.lang.String` `__doc__tell` `"tell() -- get the current position."`
`public static final java.lang.String` `__doc__truncate` `"truncate(): truncate the file at the current position."`
`public static final java.lang.String` `__doc__write` `"write(s) -- Write a string to the file\n\nNote (hack:) writing None resets the buffer"`
`public static final java.lang.String` `__doc__writelines` `"writelines(sequence_of_strings) -> None. Write the strings to the file.\n\nNote that newlines are not added. The sequence can be any iterable object\nproducing strings. This is equivalent to calling write() for each string."`

org.python.modules.gc

`public static final java.lang.String`

`__doc__`

`"This module provides access to the garbage collector for reference cycles.\n\nenable() -- Enable automatic garbage collection (does nothing in Jython).\ndisable() -- Disable automatic garbage collection (raises NotImplementedError in Jython).\nisenabled() -- Returns True because Java garbage collection cannot be disabled.\ncollect() -- Do a full collection right now (potentially expensive).\nget_count() -- Return the current collection counts (raises NotImplementedError in Jython).\nset_debug() -- Set debugging flags.\nget_debug() -- Get debugging flags.\nset_threshold() -- Set the collection thresholds (raise NotImplementedError in Jython).\nget_threshold() -- Return the current the collection thresholds (raise NotImplementedError in Jython).\nget_objects() -- Return a list of all objects tracked by the collector (raises NotImplementedError in Jython).\nis_tracked() -- Returns true if a given object is tracked (i.e. monitored in Jython).\nget_referrers() -- Return the list of objects that refer to an object (only finds monitored referrers in Jython).\nget_referents() -- Return the list of objects that an object refers to.\n"`

`public static final java.lang.String` `__name__` `"gc"`
`public static final int` `DEBUG_COLLECTABLE` `2`
`public static final int` `DEBUG_INSTANCES` `8`
`public static final int` `DEBUG_LEAK` `62`
`public static final int` `DEBUG_OBJECTS` `16`
`public static final int` `DEBUG_SAVEALL` `32`
`public static final int` `DEBUG_STATS` `1`
`public static final int` `DEBUG_UNCOLLECTABLE` `4`
`public static final short` `DONT_FINALIZE_CYCLIC_GARBAGE` `2`
`public static final short` `DONT_FINALIZE_RESURRECTED_OBJECTS` `8`
`public static final short` `DONT_TRAVERSE_BY_REFLECTION` `64`
`public static final short` `FORCE_DELAYED_FINALIZATION` `16`
`public static final short` `FORCE_DELAYED_WEAKREF_CALLBACKS` `32`
`public static final short` `INSTANCE_TRAVERSE_BY_REFLECTION_WARNING` `256`
`public static final short` `MONITOR_GLOBAL` `1`
`public static final short` `PRESERVE_WEAKREFS_ON_RESURRECTION` `4`
`public static final short` `SUPPRESS_TRAVERSE_BY_REFLECTION_WARNING` `128`
`public static final int` `UNKNOWN_COUNT` `-2`
`public static final short` `USE_PY_WRITE_DEBUG` `512`
`public static final short` `VERBOSE` `15360`
`public static final short` `VERBOSE_COLLECT` `1024`
`public static final short` `VERBOSE_DELAYED` `4096`
`public static final short` `VERBOSE_FINALIZE` `8192`
`public static final short` `VERBOSE_WEAKREF` `2048`

org.python.modules._csv.PyDialect
`public static final java.lang.String` `Dialect_doc` `"CSV dialect\n\nThe Dialect type records CSV parsing and generation options.\n"`

org.python.modules._csv.PyReader
`public static final java.lang.String` `reader_doc` `"CSV reader\n\nReader objects are responsible for reading and parsing tabular data\nin CSV format.\n"`

org.python.modules._csv.PyWriter
`public static final java.lang.String` `writer_doc` `"CSV writer\n\nWriter objects are responsible for generating tabular data\nin CSV format from sequence input.\n"`

org.python.modules._io._jyio

`public static final java.lang.String`

`__doc__`

`"The io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseperation between reading and writing to streams; implementations are\nallowed to throw an IOError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis a in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n"`

`public static final java.lang.String`

`__doc__open`

`"Open file and return a stream. Raise IOError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn\'t in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to \'r\' which means open for reading in text\nmode. Other common values are \'w\' for writing (truncating the file if\nit already exists), and \'a\' for appending (which on some Unix systems,\nmeans that all writes append to the end of the file regardless of the\ncurrent seek position). In text mode, if encoding is not specified the\nencoding used is platform dependent. (For reading and writing raw\nbytes use binary mode and leave encoding unspecified.) The available\nmodes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n\'r\' open for reading (default)\n\'w\' open for writing, truncating the file first\n\'a\' open for writing, appending to the end of the file if it exists\n\'b\' binary mode\n\'t\' text mode (default)\n\'+\' open a disk file for updating (reading and writing)\n\'U\' universal newline mode (for backwards compatibility; unneeded\n for new code)\n========= ===============================================================\n\nThe default mode is \'rt\' (open for reading text). For binary random\naccess, the mode \'w+b\' opens and truncates the file to 0 bytes, while\n\'r+b\' opens the file without truncation.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn\'t. Files opened in\nbinary mode (appending \'b\' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n\'t\' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer. When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n is chosen using a heuristic trying to determine the underlying device\'s\n \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n On many systems, the buffer will typically be 4096 or 8192 bytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n use line buffering. Other text files use the policy described above\n for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed. See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n\'strict\' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass \'ignore\' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register for a list of the permitted\nencoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, \'\', \'\\n\', \'\\r\', and \'\\r\\n\'. It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n enabled. Lines in the input can end in \'\\n\', \'\\r\', or \'\\r\\n\', and\n these are translated into \'\\n\' before being returned to the\n caller. If it is \'\', universal newline mode is enabled, but line\n endings are returned to the caller untranslated. If it has any of\n the other legal values, input lines are only terminated by the given\n string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any \'\\n\' characters written are\n translated to the system default line separator, os.linesep. If\n newline is \'\', no translation takes place. If newline is any of the\n other legal values, any \'\\n\' characters written are translated to\n the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode (\'w\',\n\'r\', \'wt\', \'rt\', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.\n"`

org.python.modules._io.PyIOBase
`public static final java.lang.String` `close_doc` `"Flush and close the IO object.\n\nThis method has no effect if the file is already closed."`
`public static final java.lang.String` `closed_doc` `"True if the stream is closed.\n"`
`public static final java.lang.String` `fileno_doc` `"Returns underlying file descriptor if one exists.\n\nAn IOError is raised if the IO object does not use a file descriptor.\n"`
`public static final java.lang.String` `flush_doc` `"Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams."`
`public static final java.lang.String` `isatty_doc` `"Return whether this is an \'interactive\' stream.\n\nReturn False if it can\'t be determined.\n"`
`public static final java.lang.String` `readable_doc` `"Return whether object was opened for reading.\n\nIf False, read() will raise IOError."`
`public static final java.lang.String` `readline_doc` `"Read and return a line from the stream.\n\nIf limit is specified, at most limit bytes will be read.\n\nThe line terminator is always b\'\n\' for binary files; for text\nfiles, the newlines argument to open can be used to select the line\nterminator(s) recognized.\n"`
`public static final java.lang.String` `readlines_doc` `"Return a list of lines from the stream.\n\nhint can be specified to control the number of lines read: no more\nlines will be read if the total size (in bytes/characters) of all\nlines so far exceeds hint."`

`public static final java.lang.String`

`seek_doc`

`"Change stream position.\n\nChange the stream position to byte offset offset. offset is\ninterpreted relative to the position indicated by whence. Values\nfor whence are:\n\n* 0 -- start of stream (the default); offset should be zero or positive\n* 1 -- current stream position; offset may be negative\n* 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position."`

`public static final java.lang.String` `seekable_doc` `"Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise IOError.\nThis method may need to do a test seek()."`
`public static final java.lang.String` `tell_doc` `"Return current stream position."`
`public static final java.lang.String` `truncate_doc` `"Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO\nposition as reported by tell(). Returns the new size."`
`public static final java.lang.String` `writable_doc` `"Return whether object was opened for writing.\n\nIf False, read() will raise IOError."`
`public static final java.lang.String` `writelines_doc` `"Write a list of lines to the stream. Line separators are not added,\nso it is usual for each of the lines provided to have a line separator\nat the end."`

org.python.modules._io.PyRawIOBase
`public static final java.lang.String` `read_doc` `"Read up to n bytes from the object and return them.\nAs a convenience, if n is unspecified or -1, readall() is called."`
`public static final java.lang.String` `readall_doc` `"Read and return all the bytes from the stream until EOF, using multiple\ncalls to the stream if necessary."`
`public static final java.lang.String` `readinto_doc` `"Read up to len(b) bytes into bytearray b and return the number of bytes read.\nIf the object is in non-blocking mode and no bytes are available,\nNone is returned."`
`public static final java.lang.String` `write_doc` `"Write the given bytes or bytearray object, b, to the underlying raw\nstream and return the number of bytes written."`

org.python.modules._json.Encoder
`public final java.lang.String` `__module__` `"_json"`

org.python.modules._json.Scanner
`public final java.lang.String` `__module__` `"_json"`

org.python.modules._locale._locale
`public static final int` `CHAR_MAX` `127`
`public static final java.lang.String` `LOCALE_CONTROL_JYTHON2_LEGACY` `"jython2_legacy"`
`public static final java.lang.String` `LOCALE_CONTROL_SETTABLE` `"settable"`

org.python.modules.itertools.chain
`public static final java.lang.String` `chain_doc` `"chain(*iterables) --> chain object\n\nReturn a chain object whose .next() method returns elements from the\nfirst iterable until it is exhausted, then elements from the next\niterable, until all of the iterables are exhausted."`

org.python.modules.itertools.combinations
`public static final java.lang.String` `combinations_doc` `"combinations(iterable, r) --> combinations object\n\nReturn successive r-length combinations of elements in the iterable.\n\ncombinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)"`

org.python.modules.itertools.combinationsWithReplacement
`public static final java.lang.String` `combinations_with_replacement_doc` `"combinations_with_replacement(iterable, r) --> combinations_with_replacement object\n\nReturn successive r-length combinations of elements in the iterable\nallowing individual elements to have successive repeats.\ncombinations_with_replacement(\'ABC\', 2) --> AA AB AC BB BC CC"`

org.python.modules.itertools.compress
`public static final java.lang.String` `compress_doc` `"compress(data, selectors) --> iterator over selected data\n\nReturn data elements corresponding to true selector elements.\nForms a shorter iterator from selected data elements using the\nselectors to choose the data elements."`

org.python.modules.itertools.count
`public static final java.lang.String` `count_doc` `"count(start=0, step=1) --> count object\n\nReturn a count object whose .next() method returns consecutive values.\n Equivalent to:\n\n def count(firstval=0, step=1):\n x = firstval\n while 1:\n yield x\n x += step\n"`

org.python.modules.itertools.cycle
`public static final java.lang.String` `cycle_doc` `"cycle(iterable) --> cycle object\n\nReturn elements from the iterable until it is exhausted.\nThen repeat the sequence indefinitely."`

org.python.modules.itertools.dropwhile
`public static final java.lang.String` `dropwhile_doc` `"dropwhile(predicate, iterable) --> dropwhile object\n\nDrop items from the iterable while predicate(item) is true.\nAfterwards, return every element until the iterable is exhausted."`

org.python.modules.itertools.groupby
`public static final java.lang.String` `groupby_doc` `"groupby(iterable[, keyfunc]) -> create an iterator which returns\n(key, sub-iterator) grouped by each value of key(value)."`

org.python.modules.itertools.ifilter
`public static final java.lang.String` `ifilter_doc` `"ifilter(function or None, sequence) --> ifilter object\n\nReturn those items of sequence for which function(item) is true.\nIf function is None, return the items that are true."`

org.python.modules.itertools.ifilterfalse
`public static final java.lang.String` `ifilterfalse_doc` `"\'ifilterfalse(function or None, sequence) --> ifilterfalse object\n\nReturn those items of sequence for which function(item) is false.\nIf function is None, return the items that are false.\'"`

org.python.modules.itertools.imap
`public static final java.lang.String` `imap_doc` `"\'map(func, *iterables) --> imap object\n\nMake an iterator that computes the function using arguments from\neach of the iterables.\tLike map() except that it returns\nan iterator instead of a list and that it stops when the shortest\niterable is exhausted instead of filling in None for shorter\niterables."`

org.python.modules.itertools.islice

`public static final java.lang.String`

`islice_doc`

`"islice(iterable, [start,] stop [, step]) --> islice object\n\nReturn an iterator whose next() method returns selected values from an\niterable. If start is specified, will skip all preceding elements;\notherwise, start defaults to zero. Step defaults to one. If\nspecified as another value, step determines how many values are \nskipped between successive calls. Works like a slice() on a list\nbut returns an iterator."`

org.python.modules.itertools.izip

`public static final java.lang.String`

`izip_doc`

`"izip(iter1 [,iter2 [...]]) --> izip object\n\nReturn an izip object whose .next() method returns a tuple where\nthe i-th element comes from the i-th iterable argument. The .next()\nmethod continues until the shortest iterable in the argument sequence\nis exhausted and then it raises StopIteration. Works like the zip()\nfunction but consumes less memory by returning an iterator instead of\na list."`

org.python.modules.itertools.izipLongest

`public static final java.lang.String`

`izip_longest_doc`

`"izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object\n\nReturn an izip_longest object whose .next() method returns a tuple where\nthe i-th element comes from the i-th iterable argument. The .next()\nmethod continues until the longest iterable in the argument sequence\nis exhausted and then it raises StopIteration. When the shorter iterables\nare exhausted, the fillvalue is substituted in their place. The fillvalue\ndefaults to None or can be specified by a keyword argument."`

org.python.modules.itertools.permutations
`public static final java.lang.String` `permutations_doc` `"permutations(iterable[, r]) --> permutations object\n\nReturn successive r-length permutations of elements in the iterable.\n\npermutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)"`

org.python.modules.itertools.product

`public static final java.lang.String`

`product_doc`

`"product(*iterables) --> product object\n\nCartesian product of input iterables. Equivalent to nested for-loops.\n\nFor example, product(A, B) returns the same as: ((x,y) for x in A for y in B).\nThe leftmost iterators are in the outermost for-loop, so the output tuples\ncycle in a manner similar to an odometer (with the rightmost element changing\non every iteration).\n\nTo compute the product of an iterable with itself, specify the number\nof repetitions with the optional repeat keyword argument. For example,\nproduct(A, repeat=4) means the same as product(A, A, A, A).\n\nproduct(\'ab\', range(3)) --> (\'a\',0) (\'a\',1) (\'a\',2) (\'b\',0) (\'b\',1) (\'b\',2)\nproduct((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ..."`

org.python.modules.itertools.PyTeeIterator
`public static final java.lang.String` `tee_doc` `"Iterator wrapped to make it copyable"`

org.python.modules.itertools.repeat
`public static final java.lang.String` `repeat_doc` `"\'repeat(element [,times]) -> create an iterator which returns the element\nfor the specified number of times. If not specified, returns the element\nendlessly."`

org.python.modules.itertools.starmap
`public static final java.lang.String` `starmap_doc` `"starmap(function, sequence) --> starmap object\n\nReturn an iterator whose values are returned from the function evaluated\nwith an argument tuple taken from the given sequence."`

org.python.modules.itertools.takewhile
`public static final java.lang.String` `takewhile_doc` `"takewhile(predicate, iterable) --> takewhile object\n\nReturn successive entries from an iterable as long as the\npredicate evaluates to true for each entry."`

org.python.modules.jffi.jffi
`public static final int` `FUNCFLAG_CDECL` `1`
`public static final int` `FUNCFLAG_HRESULT` `2`
`public static final int` `FUNCFLAG_PYTHONAPI` `4`
`public static final int` `FUNCFLAG_STDCALL` `0`
`public static final int` `FUNCFLAG_USE_ERRNO` `8`
`public static final int` `FUNCFLAG_USE_LASTERROR` `16`

org.python.modules.posix.PyStatResult
`public static final int` `n_fields` `10`
`public static final int` `n_sequence_fields` `10`
`public static final int` `n_unnamed_fields` `10`

org.python.modules.sre.SRE_STATE
`public static final int` `SRE_AT_BEGINNING` `0`
`public static final int` `SRE_AT_BEGINNING_LINE` `1`
`public static final int` `SRE_AT_BEGINNING_STRING` `2`
`public static final int` `SRE_AT_BOUNDARY` `3`
`public static final int` `SRE_AT_END` `5`
`public static final int` `SRE_AT_END_LINE` `6`
`public static final int` `SRE_AT_END_STRING` `7`
`public static final int` `SRE_AT_LOC_BOUNDARY` `8`
`public static final int` `SRE_AT_LOC_NON_BOUNDARY` `9`
`public static final int` `SRE_AT_NON_BOUNDARY` `4`
`public static final int` `SRE_AT_UNI_BOUNDARY` `10`
`public static final int` `SRE_AT_UNI_NON_BOUNDARY` `11`
`public static final int` `SRE_CATEGORY_DIGIT` `0`
`public static final int` `SRE_CATEGORY_LINEBREAK` `6`
`public static final int` `SRE_CATEGORY_LOC_NOT_WORD` `9`
`public static final int` `SRE_CATEGORY_LOC_WORD` `8`
`public static final int` `SRE_CATEGORY_NOT_DIGIT` `1`
`public static final int` `SRE_CATEGORY_NOT_LINEBREAK` `7`
`public static final int` `SRE_CATEGORY_NOT_SPACE` `3`
`public static final int` `SRE_CATEGORY_NOT_WORD` `5`
`public static final int` `SRE_CATEGORY_SPACE` `2`
`public static final int` `SRE_CATEGORY_UNI_DIGIT` `10`
`public static final int` `SRE_CATEGORY_UNI_LINEBREAK` `16`
`public static final int` `SRE_CATEGORY_UNI_NOT_DIGIT` `11`
`public static final int` `SRE_CATEGORY_UNI_NOT_LINEBREAK` `17`
`public static final int` `SRE_CATEGORY_UNI_NOT_SPACE` `13`
`public static final int` `SRE_CATEGORY_UNI_NOT_WORD` `15`
`public static final int` `SRE_CATEGORY_UNI_SPACE` `12`
`public static final int` `SRE_CATEGORY_UNI_WORD` `14`
`public static final int` `SRE_CATEGORY_WORD` `4`
`public static final int` `SRE_ERROR_ILLEGAL` `-1`
`public static final int` `SRE_ERROR_RECURSION_LIMIT` `-3`
`public static final int` `SRE_ERROR_STATE` `-2`
`public static final int` `SRE_FLAG_DOTALL` `16`
`public static final int` `SRE_FLAG_IGNORECASE` `2`
`public static final int` `SRE_FLAG_LOCALE` `4`
`public static final int` `SRE_FLAG_MULTILINE` `8`
`public static final int` `SRE_FLAG_TEMPLATE` `1`
`public static final int` `SRE_FLAG_UNICODE` `32`
`public static final int` `SRE_FLAG_VERBOSE` `64`
`public static final int` `SRE_INFO_CHARSET` `4`
`public static final int` `SRE_INFO_LITERAL` `2`
`public static final int` `SRE_INFO_PREFIX` `1`
`public static final int` `SRE_MAGIC` `20031017`
`public static final int` `SRE_OP_ANY` `2`
`public static final int` `SRE_OP_ANY_ALL` `3`
`public static final int` `SRE_OP_ASSERT` `4`
`public static final int` `SRE_OP_ASSERT_NOT` `5`
`public static final int` `SRE_OP_AT` `6`
`public static final int` `SRE_OP_BIGCHARSET` `11`
`public static final int` `SRE_OP_BRANCH` `7`
`public static final int` `SRE_OP_CALL` `8`
`public static final int` `SRE_OP_CATEGORY` `9`
`public static final int` `SRE_OP_CHARSET` `10`
`public static final int` `SRE_OP_FAILURE` `0`
`public static final int` `SRE_OP_GROUPREF` `12`
`public static final int` `SRE_OP_GROUPREF_EXISTS` `13`
`public static final int` `SRE_OP_GROUPREF_IGNORE` `14`
`public static final int` `SRE_OP_IN` `15`
`public static final int` `SRE_OP_IN_IGNORE` `16`
`public static final int` `SRE_OP_INFO` `17`
`public static final int` `SRE_OP_JUMP` `18`
`public static final int` `SRE_OP_LITERAL` `19`
`public static final int` `SRE_OP_LITERAL_IGNORE` `20`
`public static final int` `SRE_OP_MARK` `21`
`public static final int` `SRE_OP_MAX_UNTIL` `22`
`public static final int` `SRE_OP_MIN_REPEAT_ONE` `31`
`public static final int` `SRE_OP_MIN_UNTIL` `23`
`public static final int` `SRE_OP_NEGATE` `26`
`public static final int` `SRE_OP_NOT_LITERAL` `24`
`public static final int` `SRE_OP_NOT_LITERAL_IGNORE` `25`
`public static final int` `SRE_OP_RANGE` `27`
`public static final int` `SRE_OP_REPEAT` `28`
`public static final int` `SRE_OP_REPEAT_ONE` `29`
`public static final int` `SRE_OP_SUBPATTERN` `30`
`public static final int` `SRE_OP_SUCCESS` `1`
`public static final int` `USE_RECURSION_LIMIT` `5000`

org.python.modules.time.PyTimeTuple
`public final int` `n_fields` `9`
`public final int` `n_sequence_fields` `9`
`public final int` `n_unnamed_fields` `0`

org.python.modules.time.Time
`public static final int` `accept2dyear` `0`

org.python.util.Generic
`public static final int` `CHM_CONCURRENCY_LEVEL` `2`
`public static final int` `CHM_INITIAL_CAPACITY` `16`
`public static final float` `CHM_LOAD_FACTOR` `0.75f`

org.python.util.jython
`public static final java.lang.String` `CONSOLE_LOG_FORMAT` `"%3$s %4$s %5$s%n"`

org.python.util.PyFilter
`public static final java.lang.String` `FILTER_PATH_PARAM` `"__filter__"`

org.python.util.PyServlet
`public static final java.lang.String` `SKIP_INIT_NAME` `"skip_jython_initialization"`