/python/helpers/pycharm_generator_utils/constants.py
Python | 794 lines | 732 code | 38 blank | 24 comment | 16 complexity | a3f4cfc8dd298ee11c4ef2d61cd0dcc4 MD5 | raw file
Possible License(s): BSD-3-Clause, Apache-2.0, MPL-2.0-no-copyleft-exception, MIT, EPL-1.0, AGPL-1.0
- import os
- import re
- import types
- import sys
- import string
- import time
- # !!! Don't forget to update VERSION and required_gen_version if necessary !!!
- VERSION = "1.143"
- OUT_ENCODING = 'utf-8'
- version = (
- (sys.hexversion & (0xff << 24)) >> 24,
- (sys.hexversion & (0xff << 16)) >> 16
- )
- if version[0] >= 3:
- #noinspection PyUnresolvedReferences
- import builtins as the_builtins
- string = "".__class__
- STR_TYPES = (getattr(the_builtins, "bytes"), str)
- NUM_TYPES = (int, float)
- SIMPLEST_TYPES = NUM_TYPES + STR_TYPES + (None.__class__,)
- EASY_TYPES = NUM_TYPES + STR_TYPES + (None.__class__, dict, tuple, list)
- def the_exec(source, context):
- exec (source, context)
- else: # < 3.0
- import __builtin__ as the_builtins
- STR_TYPES = (getattr(the_builtins, "unicode"), str)
- NUM_TYPES = (int, long, float)
- SIMPLEST_TYPES = NUM_TYPES + STR_TYPES + (types.NoneType,)
- EASY_TYPES = NUM_TYPES + STR_TYPES + (types.NoneType, dict, tuple, list)
- def the_exec(source, context):
- #noinspection PyRedundantParentheses
- exec (source) in context
- if version[0] == 2 and version[1] < 4:
- HAS_DECORATORS = False
- def lstrip(s, prefix):
- i = 0
- while s[i] == prefix:
- i += 1
- return s[i:]
- else:
- HAS_DECORATORS = True
- lstrip = string.lstrip
- # return type inference helper table
- INT_LIT = '0'
- FLOAT_LIT = '0.0'
- DICT_LIT = '{}'
- LIST_LIT = '[]'
- TUPLE_LIT = '()'
- BOOL_LIT = 'False'
- RET_TYPE = {# {'type_name': 'value_string'} lookup table
- # chaining
- "self": "self",
- "self.": "self",
- # int
- "int": INT_LIT,
- "Int": INT_LIT,
- "integer": INT_LIT,
- "Integer": INT_LIT,
- "short": INT_LIT,
- "long": INT_LIT,
- "number": INT_LIT,
- "Number": INT_LIT,
- # float
- "float": FLOAT_LIT,
- "Float": FLOAT_LIT,
- "double": FLOAT_LIT,
- "Double": FLOAT_LIT,
- "floating": FLOAT_LIT,
- # boolean
- "bool": BOOL_LIT,
- "boolean": BOOL_LIT,
- "Bool": BOOL_LIT,
- "Boolean": BOOL_LIT,
- "True": BOOL_LIT,
- "true": BOOL_LIT,
- "False": BOOL_LIT,
- "false": BOOL_LIT,
- # list
- 'list': LIST_LIT,
- 'List': LIST_LIT,
- '[]': LIST_LIT,
- # tuple
- "tuple": TUPLE_LIT,
- "sequence": TUPLE_LIT,
- "Sequence": TUPLE_LIT,
- # dict
- "dict": DICT_LIT,
- "Dict": DICT_LIT,
- "dictionary": DICT_LIT,
- "Dictionary": DICT_LIT,
- "map": DICT_LIT,
- "Map": DICT_LIT,
- "hashtable": DICT_LIT,
- "Hashtable": DICT_LIT,
- "{}": DICT_LIT,
- # "objects"
- "object": "object()",
- }
- if version[0] < 3:
- UNICODE_LIT = 'u""'
- BYTES_LIT = '""'
- RET_TYPE.update({
- 'string': BYTES_LIT,
- 'String': BYTES_LIT,
- 'str': BYTES_LIT,
- 'Str': BYTES_LIT,
- 'character': BYTES_LIT,
- 'char': BYTES_LIT,
- 'unicode': UNICODE_LIT,
- 'Unicode': UNICODE_LIT,
- 'bytes': BYTES_LIT,
- 'byte': BYTES_LIT,
- 'Bytes': BYTES_LIT,
- 'Byte': BYTES_LIT,
- })
- DEFAULT_STR_LIT = BYTES_LIT
- # also, files:
- RET_TYPE.update({
- 'file': "file('/dev/null')",
- })
- def ensureUnicode(data):
- if type(data) == str:
- return data.decode(OUT_ENCODING, 'replace')
- return unicode(data)
- else:
- UNICODE_LIT = '""'
- BYTES_LIT = 'b""'
- RET_TYPE.update({
- 'string': UNICODE_LIT,
- 'String': UNICODE_LIT,
- 'str': UNICODE_LIT,
- 'Str': UNICODE_LIT,
- 'character': UNICODE_LIT,
- 'char': UNICODE_LIT,
- 'unicode': UNICODE_LIT,
- 'Unicode': UNICODE_LIT,
- 'bytes': BYTES_LIT,
- 'byte': BYTES_LIT,
- 'Bytes': BYTES_LIT,
- 'Byte': BYTES_LIT,
- })
- DEFAULT_STR_LIT = UNICODE_LIT
- # also, files: we can't provide an easy expression on py3k
- RET_TYPE.update({
- 'file': None,
- })
- def ensureUnicode(data):
- if type(data) == bytes:
- return data.decode(OUT_ENCODING, 'replace')
- return str(data)
- if version[0] > 2:
- import io # in 3.0
- #noinspection PyArgumentList
- fopen = lambda name, mode: io.open(name, mode, encoding=OUT_ENCODING)
- else:
- fopen = open
- if sys.platform == 'cli':
- #noinspection PyUnresolvedReferences
- from System import DateTime
- class Timer(object):
- def __init__(self):
- self.started = DateTime.Now
- def elapsed(self):
- return (DateTime.Now - self.started).TotalMilliseconds
- else:
- class Timer(object):
- def __init__(self):
- self.started = time.time()
- def elapsed(self):
- return int((time.time() - self.started) * 1000)
- IS_JAVA = hasattr(os, "java")
- BUILTIN_MOD_NAME = the_builtins.__name__
- IDENT_PATTERN = "[A-Za-z_][0-9A-Za-z_]*" # re pattern for identifier
- NUM_IDENT_PATTERN = re.compile("([A-Za-z_]+)[0-9]?[A-Za-z_]*") # 'foo_123' -> $1 = 'foo_'
- STR_CHAR_PATTERN = "[0-9A-Za-z_.,\+\-&\*% ]"
- DOC_FUNC_RE = re.compile("(?:.*\.)?(\w+)\(([^\)]*)\).*") # $1 = function name, $2 = arglist
- SANE_REPR_RE = re.compile(IDENT_PATTERN + "(?:\(.*\))?") # identifier with possible (...), go catches
- IDENT_RE = re.compile("(" + IDENT_PATTERN + ")") # $1 = identifier
- STARS_IDENT_RE = re.compile("(\*?\*?" + IDENT_PATTERN + ")") # $1 = identifier, maybe with a * or **
- IDENT_EQ_RE = re.compile("(" + IDENT_PATTERN + "\s*=)") # $1 = identifier with a following '='
- SIMPLE_VALUE_RE = re.compile(
- "(\([+-]?[0-9](?:\s*,\s*[+-]?[0-9])*\))|" + # a numeric tuple, e.g. in pygame
- "([+-]?[0-9]+\.?[0-9]*(?:[Ee]?[+-]?[0-9]+\.?[0-9]*)?)|" + # number
- "('" + STR_CHAR_PATTERN + "*')|" + # single-quoted string
- '("' + STR_CHAR_PATTERN + '*")|' + # double-quoted string
- "(\[\])|" +
- "(\{\})|" +
- "(\(\))|" +
- "(True|False|None)"
- ) # $? = sane default value
- ########################### parsing ###########################################################
- if version[0] < 3:
- from pycharm_generator_utils.pyparsing import *
- else:
- #noinspection PyUnresolvedReferences
- from pycharm_generator_utils.pyparsing_py3 import *
- # grammar to parse parameter lists
- # // snatched from parsePythonValue.py, from pyparsing samples, copyright 2006 by Paul McGuire but under BSD license.
- # we don't suppress lots of punctuation because we want it back when we reconstruct the lists
- lparen, rparen, lbrack, rbrack, lbrace, rbrace, colon = map(Literal, "()[]{}:")
- integer = Combine(Optional(oneOf("+ -")) + Word(nums)).setName("integer")
- real = Combine(Optional(oneOf("+ -")) + Word(nums) + "." +
- Optional(Word(nums)) +
- Optional(oneOf("e E") + Optional(oneOf("+ -")) + Word(nums))).setName("real")
- tupleStr = Forward()
- listStr = Forward()
- dictStr = Forward()
- boolLiteral = oneOf("True False")
- noneLiteral = Literal("None")
- listItem = real | integer | quotedString | unicodeString | boolLiteral | noneLiteral | \
- Group(listStr) | tupleStr | dictStr
- tupleStr << ( Suppress("(") + Optional(delimitedList(listItem)) +
- Optional(Literal(",")) + Suppress(")") ).setResultsName("tuple")
- listStr << (lbrack + Optional(delimitedList(listItem) +
- Optional(Literal(","))) + rbrack).setResultsName("list")
- dictEntry = Group(listItem + colon + listItem)
- dictStr << (lbrace + Optional(delimitedList(dictEntry) + Optional(Literal(","))) + rbrace).setResultsName("dict")
- # \\ end of the snatched part
- # our output format is s-expressions:
- # (simple name optional_value) is name or name=value
- # (nested (simple ...) (simple ...)) is (name, name,...)
- # (opt ...) is [, ...] or suchlike.
- T_SIMPLE = 'Simple'
- T_NESTED = 'Nested'
- T_OPTIONAL = 'Opt'
- T_RETURN = "Ret"
- TRIPLE_DOT = '...'
- COMMA = Suppress(",")
- APOS = Suppress("'")
- QUOTE = Suppress('"')
- SP = Suppress(Optional(White()))
- ident = Word(alphas + "_", alphanums + "_-.").setName("ident") # we accept things like "foo-or-bar"
- decorated_ident = ident + Optional(Suppress(SP + Literal(":") + SP + ident)) # accept "foo: bar", ignore "bar"
- spaced_ident = Combine(decorated_ident + ZeroOrMore(Literal(' ') + decorated_ident)) # we accept 'list or tuple' or 'C struct'
- # allow quoted names, because __setattr__, etc docs use it
- paramname = spaced_ident | \
- APOS + spaced_ident + APOS | \
- QUOTE + spaced_ident + QUOTE
- parenthesized_tuple = ( Literal("(") + Optional(delimitedList(listItem, combine=True)) +
- Optional(Literal(",")) + Literal(")") ).setResultsName("(tuple)")
- initializer = (SP + Suppress("=") + SP + Combine(parenthesized_tuple | listItem | ident)).setName("=init") # accept foo=defaultfoo
- param = Group(Empty().setParseAction(replaceWith(T_SIMPLE)) + Combine(Optional(oneOf("* **")) + paramname) + Optional(initializer))
- ellipsis = Group(
- Empty().setParseAction(replaceWith(T_SIMPLE)) + \
- (Literal("..") +
- ZeroOrMore(Literal('.'))).setParseAction(replaceWith(TRIPLE_DOT)) # we want to accept both 'foo,..' and 'foo, ...'
- )
- paramSlot = Forward()
- simpleParamSeq = ZeroOrMore(paramSlot + COMMA) + Optional(paramSlot + Optional(COMMA))
- nestedParamSeq = Group(
- Suppress('(').setParseAction(replaceWith(T_NESTED)) + \
- simpleParamSeq + Optional(ellipsis + Optional(COMMA) + Optional(simpleParamSeq)) + \
- Suppress(')')
- ) # we accept "(a1, ... an)"
- paramSlot << (param | nestedParamSeq)
- optionalPart = Forward()
- paramSeq = simpleParamSeq + Optional(optionalPart) # this is our approximate target
- optionalPart << (
- Group(
- Suppress('[').setParseAction(replaceWith(T_OPTIONAL)) + Optional(COMMA) +
- paramSeq + Optional(ellipsis) +
- Suppress(']')
- )
- | ellipsis
- )
- return_type = Group(
- Empty().setParseAction(replaceWith(T_RETURN)) +
- Suppress(SP + (Literal("->") | (Literal(":") + SP + Literal("return"))) + SP) +
- ident
- )
- # this is our ideal target, with balancing paren and a multiline rest of doc.
- paramSeqAndRest = paramSeq + Suppress(')') + Optional(return_type) + Suppress(Optional(Regex(".*(?s)")))
- ############################################################################################
- # Some values are known to be of no use in source and needs to be suppressed.
- # Dict is keyed by module names, with "*" meaning "any module";
- # values are lists of names of members whose value must be pruned.
- SKIP_VALUE_IN_MODULE = {
- "sys": (
- "modules", "path_importer_cache", "argv", "builtins",
- "last_traceback", "last_type", "last_value", "builtin_module_names",
- ),
- "posix": (
- "environ",
- ),
- "zipimport": (
- "_zip_directory_cache",
- ),
- "*": (BUILTIN_MOD_NAME,)
- }
- # {"module": ("name",..)}: omit the names from the skeleton at all.
- OMIT_NAME_IN_MODULE = {}
- if version[0] >= 3:
- v = OMIT_NAME_IN_MODULE.get(BUILTIN_MOD_NAME, []) + ["True", "False", "None", "__debug__"]
- OMIT_NAME_IN_MODULE[BUILTIN_MOD_NAME] = v
- if IS_JAVA and version > (2, 4): # in 2.5.1 things are way weird!
- OMIT_NAME_IN_MODULE['_codecs'] = ['EncodingMap']
- OMIT_NAME_IN_MODULE['_hashlib'] = ['Hash']
- ADD_VALUE_IN_MODULE = {
- "sys": ("exc_value = Exception()", "exc_traceback=None"), # only present after an exception in current thread
- }
- # Some values are special and are better represented by hand-crafted constructs.
- # Dict is keyed by (module name, member name) and value is the replacement.
- REPLACE_MODULE_VALUES = {
- ("numpy.core.multiarray", "typeinfo"): "{}",
- ("psycopg2._psycopg", "string_types"): "{}", # badly mangled __eq__ breaks fmtValue
- ("PyQt5.QtWidgets", "qApp") : "QApplication()", # instead of None
- }
- if version[0] <= 2:
- REPLACE_MODULE_VALUES[(BUILTIN_MOD_NAME, "None")] = "object()"
- for std_file in ("stdin", "stdout", "stderr"):
- REPLACE_MODULE_VALUES[("sys", std_file)] = "open('')" #
- # Some functions and methods of some builtin classes have special signatures.
- # {("class", "method"): ("signature_string")}
- PREDEFINED_BUILTIN_SIGS = { #TODO: user-skeleton
- ("type", "__init__"): "(cls, what, bases=None, dict=None)", # two sigs squeezed into one
- ("object", "__init__"): "(self)",
- ("object", "__new__"): "(cls, *more)", # only for the sake of parameter names readability
- ("object", "__subclasshook__"): "(cls, subclass)", # trusting PY-1818 on sig
- ("int", "__init__"): "(self, x, base=10)", # overrides a fake
- ("list", "__init__"): "(self, seq=())",
- ("tuple", "__init__"): "(self, seq=())", # overrides a fake
- ("set", "__init__"): "(self, seq=())",
- ("dict", "__init__"): "(self, seq=None, **kwargs)",
- ("property", "__init__"): "(self, fget=None, fset=None, fdel=None, doc=None)",
- # TODO: infer, doc comments have it
- ("dict", "update"): "(self, E=None, **F)", # docstring nearly lies
- (None, "zip"): "(seq1, seq2, *more_seqs)",
- (None, "range"): "(start=None, stop=None, step=None)", # suboptimal: allows empty arglist
- (None, "filter"): "(function_or_none, sequence)",
- (None, "iter"): "(source, sentinel=None)",
- (None, "getattr"): "(object, name, default=None)",
- ('frozenset', "__init__"): "(self, seq=())",
- ("bytearray", "__init__"): "(self, source=None, encoding=None, errors='strict')",
- }
- if version[0] < 3:
- PREDEFINED_BUILTIN_SIGS[
- ("unicode", "__init__")] = "(self, string=u'', encoding=None, errors='strict')" # overrides a fake
- PREDEFINED_BUILTIN_SIGS[("super", "__init__")] = "(self, type1, type2=None)"
- PREDEFINED_BUILTIN_SIGS[
- (None, "min")] = "(*args, **kwargs)" # too permissive, but py2.x won't allow a better sig
- PREDEFINED_BUILTIN_SIGS[(None, "max")] = "(*args, **kwargs)"
- PREDEFINED_BUILTIN_SIGS[("str", "__init__")] = "(self, string='')" # overrides a fake
- PREDEFINED_BUILTIN_SIGS[(None, "print")] = "(*args, **kwargs)" # can't do better in 2.x
- else:
- PREDEFINED_BUILTIN_SIGS[("super", "__init__")] = "(self, type1=None, type2=None)"
- PREDEFINED_BUILTIN_SIGS[(None, "min")] = "(*args, key=None)"
- PREDEFINED_BUILTIN_SIGS[(None, "max")] = "(*args, key=None)"
- PREDEFINED_BUILTIN_SIGS[
- (None, "open")] = "(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)"
- PREDEFINED_BUILTIN_SIGS[
- ("str", "__init__")] = "(self, value='', encoding=None, errors='strict')" # overrides a fake
- PREDEFINED_BUILTIN_SIGS[("str", "format")] = "(self, *args, **kwargs)"
- PREDEFINED_BUILTIN_SIGS[
- ("bytes", "__init__")] = "(self, value=b'', encoding=None, errors='strict')" # overrides a fake
- PREDEFINED_BUILTIN_SIGS[("bytes", "format")] = "(self, *args, **kwargs)"
- PREDEFINED_BUILTIN_SIGS[(None, "print")] = "(self, *args, sep=' ', end='\\n', file=None)" # proper signature
- if (2, 6) <= version < (3, 0):
- PREDEFINED_BUILTIN_SIGS[("unicode", "format")] = "(self, *args, **kwargs)"
- PREDEFINED_BUILTIN_SIGS[("str", "format")] = "(self, *args, **kwargs)"
- if version == (2, 5):
- PREDEFINED_BUILTIN_SIGS[("unicode", "splitlines")] = "(keepends=None)" # a typo in docstring there
- if version >= (2, 7):
- PREDEFINED_BUILTIN_SIGS[
- ("enumerate", "__init__")] = "(self, iterable, start=0)" # dosctring omits this completely.
- if version < (3, 3):
- datetime_mod = "datetime"
- else:
- datetime_mod = "_datetime"
- # NOTE: per-module signature data may be lazily imported
- # keyed by (module_name, class_name, method_name). PREDEFINED_BUILTIN_SIGS might be a layer of it.
- # value is ("signature", "return_literal")
- PREDEFINED_MOD_CLASS_SIGS = { #TODO: user-skeleton
- (BUILTIN_MOD_NAME, None, 'divmod'): ("(x, y)", "(0, 0)"),
- ("binascii", None, "hexlify"): ("(data)", BYTES_LIT),
- ("binascii", None, "unhexlify"): ("(hexstr)", BYTES_LIT),
- ("time", None, "ctime"): ("(seconds=None)", DEFAULT_STR_LIT),
- ("_struct", None, "pack"): ("(fmt, *args)", BYTES_LIT),
- ("_struct", None, "pack_into"): ("(fmt, buffer, offset, *args)", None),
- ("_struct", None, "unpack"): ("(fmt, string)", None),
- ("_struct", None, "unpack_from"): ("(fmt, buffer, offset=0)", None),
- ("_struct", None, "calcsize"): ("(fmt)", INT_LIT),
- ("_struct", "Struct", "__init__"): ("(self, fmt)", None),
- ("_struct", "Struct", "pack"): ("(self, *args)", BYTES_LIT),
- ("_struct", "Struct", "pack_into"): ("(self, buffer, offset, *args)", None),
- ("_struct", "Struct", "unpack"): ("(self, string)", None),
- ("_struct", "Struct", "unpack_from"): ("(self, buffer, offset=0)", None),
- (datetime_mod, "date", "__new__"): ("(cls, year=None, month=None, day=None)", None),
- (datetime_mod, "date", "fromordinal"): ("(cls, ordinal)", "date(1,1,1)"),
- (datetime_mod, "date", "fromtimestamp"): ("(cls, timestamp)", "date(1,1,1)"),
- (datetime_mod, "date", "isocalendar"): ("(self)", "(1, 1, 1)"),
- (datetime_mod, "date", "isoformat"): ("(self)", DEFAULT_STR_LIT),
- (datetime_mod, "date", "isoweekday"): ("(self)", INT_LIT),
- (datetime_mod, "date", "replace"): ("(self, year=None, month=None, day=None)", "date(1,1,1)"),
- (datetime_mod, "date", "strftime"): ("(self, format)", DEFAULT_STR_LIT),
- (datetime_mod, "date", "timetuple"): ("(self)", "(0, 0, 0, 0, 0, 0, 0, 0, 0)"),
- (datetime_mod, "date", "today"): ("(self)", "date(1, 1, 1)"),
- (datetime_mod, "date", "toordinal"): ("(self)", INT_LIT),
- (datetime_mod, "date", "weekday"): ("(self)", INT_LIT),
- (datetime_mod, "timedelta", "__new__"
- ): (
- "(cls, days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None, hours=None, weeks=None)",
- None),
- (datetime_mod, "datetime", "__new__"
- ): (
- "(cls, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, tzinfo=None)",
- None),
- (datetime_mod, "datetime", "astimezone"): ("(self, tz)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "combine"): ("(cls, date, time)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "date"): ("(self)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "fromtimestamp"): ("(cls, timestamp, tz=None)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "isoformat"): ("(self, sep='T')", DEFAULT_STR_LIT),
- (datetime_mod, "datetime", "now"): ("(cls, tz=None)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "strptime"): ("(cls, date_string, format)", DEFAULT_STR_LIT),
- (datetime_mod, "datetime", "replace" ):
- (
- "(self, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, tzinfo=None)",
- "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "time"): ("(self)", "time(0, 0)"),
- (datetime_mod, "datetime", "timetuple"): ("(self)", "(0, 0, 0, 0, 0, 0, 0, 0, 0)"),
- (datetime_mod, "datetime", "timetz"): ("(self)", "time(0, 0)"),
- (datetime_mod, "datetime", "utcfromtimestamp"): ("(self, timestamp)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "utcnow"): ("(cls)", "datetime(1, 1, 1)"),
- (datetime_mod, "datetime", "utctimetuple"): ("(self)", "(0, 0, 0, 0, 0, 0, 0, 0, 0)"),
- (datetime_mod, "time", "__new__"): (
- "(cls, hour=None, minute=None, second=None, microsecond=None, tzinfo=None)", None),
- (datetime_mod, "time", "isoformat"): ("(self)", DEFAULT_STR_LIT),
- (datetime_mod, "time", "replace"): (
- "(self, hour=None, minute=None, second=None, microsecond=None, tzinfo=None)", "time(0, 0)"),
- (datetime_mod, "time", "strftime"): ("(self, format)", DEFAULT_STR_LIT),
- (datetime_mod, "tzinfo", "dst"): ("(self, date_time)", INT_LIT),
- (datetime_mod, "tzinfo", "fromutc"): ("(self, date_time)", "datetime(1, 1, 1)"),
- (datetime_mod, "tzinfo", "tzname"): ("(self, date_time)", DEFAULT_STR_LIT),
- (datetime_mod, "tzinfo", "utcoffset"): ("(self, date_time)", INT_LIT),
- ("_io", None, "open"): ("(name, mode=None, buffering=None)", "file('/dev/null')"),
- ("_io", "FileIO", "read"): ("(self, size=-1)", DEFAULT_STR_LIT),
- ("_fileio", "_FileIO", "read"): ("(self, size=-1)", DEFAULT_STR_LIT),
- ("thread", None, "start_new"): ("(function, args, kwargs=None)", INT_LIT),
- ("_thread", None, "start_new"): ("(function, args, kwargs=None)", INT_LIT),
- ("itertools", "groupby", "__init__"): ("(self, iterable, key=None)", None),
- ("itertools", None, "groupby"): ("(iterable, key=None)", LIST_LIT),
- ("cStringIO", "OutputType", "seek"): ("(self, position, mode=0)", None),
- ("cStringIO", "InputType", "seek"): ("(self, position, mode=0)", None),
- # NOTE: here we stand on shaky ground providing sigs for 3rd-party modules, though well-known
- ("numpy.core.multiarray", "ndarray", "__array__"): ("(self, dtype=None)", None),
- ("numpy.core.multiarray", None, "arange"): ("(start=None, stop=None, step=None, dtype=None)", None),
- # same as range()
- ("numpy.core.multiarray", None, "set_numeric_ops"): ("(**ops)", None),
- ("numpy.random.mtrand", None, "rand"): ("(*dn)", None),
- ("numpy.random.mtrand", None, "randn"): ("(*dn)", None),
- ("numpy.core.multiarray", "ndarray", "reshape"): ("(self, shape, *shapes, order='C')", None),
- ("numpy.core.multiarray", "ndarray", "resize"): ("(self, *new_shape, refcheck=True)", None),
- }
- bin_collections_names = ['collections', '_collections']
- for name in bin_collections_names:
- PREDEFINED_MOD_CLASS_SIGS[(name, "deque", "__init__")] = ("(self, iterable=(), maxlen=None)", None)
- PREDEFINED_MOD_CLASS_SIGS[(name, "defaultdict", "__init__")] = ("(self, default_factory=None, **kwargs)", None)
- if version[0] < 3:
- PREDEFINED_MOD_CLASS_SIGS[("exceptions", "BaseException", "__unicode__")] = ("(self)", UNICODE_LIT)
- PREDEFINED_MOD_CLASS_SIGS[("itertools", "product", "__init__")] = ("(self, *iterables, **kwargs)", LIST_LIT)
- else:
- PREDEFINED_MOD_CLASS_SIGS[("itertools", "product", "__init__")] = ("(self, *iterables, repeat=1)", LIST_LIT)
- if version[0] < 3:
- PREDEFINED_MOD_CLASS_SIGS[("PyQt4.QtCore", None, "pyqtSlot")] = (
- "(*types, **keywords)", None) # doc assumes py3k syntax
- # known properties of modules
- # {{"module": {"class", "property" : ("letters", ("getter", "type"))}},
- # where letters is any set of r,w,d (read, write, del) and "getter" is a source of typed getter.
- # if value is None, the property should be omitted.
- # read-only properties that return an object are not listed.
- G_OBJECT = ("lambda self: object()", None)
- G_TYPE = ("lambda self: type(object)", "type")
- G_DICT = ("lambda self: {}", "dict")
- G_STR = ("lambda self: ''", "string")
- G_TUPLE = ("lambda self: tuple()", "tuple")
- G_FLOAT = ("lambda self: 0.0", "float")
- G_INT = ("lambda self: 0", "int")
- G_BOOL = ("lambda self: True", "bool")
- KNOWN_PROPS = {
- BUILTIN_MOD_NAME: {
- ("object", '__class__'): ('r', G_TYPE),
- ('complex', 'real'): ('r', G_FLOAT),
- ('complex', 'imag'): ('r', G_FLOAT),
- ("file", 'softspace'): ('r', G_BOOL),
- ("file", 'name'): ('r', G_STR),
- ("file", 'encoding'): ('r', G_STR),
- ("file", 'mode'): ('r', G_STR),
- ("file", 'closed'): ('r', G_BOOL),
- ("file", 'newlines'): ('r', G_STR),
- ("slice", 'start'): ('r', G_INT),
- ("slice", 'step'): ('r', G_INT),
- ("slice", 'stop'): ('r', G_INT),
- ("super", '__thisclass__'): ('r', G_TYPE),
- ("super", '__self__'): ('r', G_TYPE),
- ("super", '__self_class__'): ('r', G_TYPE),
- ("type", '__basicsize__'): ('r', G_INT),
- ("type", '__itemsize__'): ('r', G_INT),
- ("type", '__base__'): ('r', G_TYPE),
- ("type", '__flags__'): ('r', G_INT),
- ("type", '__mro__'): ('r', G_TUPLE),
- ("type", '__bases__'): ('r', G_TUPLE),
- ("type", '__dictoffset__'): ('r', G_INT),
- ("type", '__dict__'): ('r', G_DICT),
- ("type", '__name__'): ('r', G_STR),
- ("type", '__weakrefoffset__'): ('r', G_INT),
- },
- "exceptions": {
- ("BaseException", '__dict__'): ('r', G_DICT),
- ("BaseException", 'message'): ('rwd', G_STR),
- ("BaseException", 'args'): ('r', G_TUPLE),
- ("EnvironmentError", 'errno'): ('rwd', G_INT),
- ("EnvironmentError", 'message'): ('rwd', G_STR),
- ("EnvironmentError", 'strerror'): ('rwd', G_INT),
- ("EnvironmentError", 'filename'): ('rwd', G_STR),
- ("SyntaxError", 'text'): ('rwd', G_STR),
- ("SyntaxError", 'print_file_and_line'): ('rwd', G_BOOL),
- ("SyntaxError", 'filename'): ('rwd', G_STR),
- ("SyntaxError", 'lineno'): ('rwd', G_INT),
- ("SyntaxError", 'offset'): ('rwd', G_INT),
- ("SyntaxError", 'msg'): ('rwd', G_STR),
- ("SyntaxError", 'message'): ('rwd', G_STR),
- ("SystemExit", 'message'): ('rwd', G_STR),
- ("SystemExit", 'code'): ('rwd', G_OBJECT),
- ("UnicodeDecodeError", '__basicsize__'): None,
- ("UnicodeDecodeError", '__itemsize__'): None,
- ("UnicodeDecodeError", '__base__'): None,
- ("UnicodeDecodeError", '__flags__'): ('rwd', G_INT),
- ("UnicodeDecodeError", '__mro__'): None,
- ("UnicodeDecodeError", '__bases__'): None,
- ("UnicodeDecodeError", '__dictoffset__'): None,
- ("UnicodeDecodeError", '__dict__'): None,
- ("UnicodeDecodeError", '__name__'): None,
- ("UnicodeDecodeError", '__weakrefoffset__'): None,
- ("UnicodeEncodeError", 'end'): ('rwd', G_INT),
- ("UnicodeEncodeError", 'encoding'): ('rwd', G_STR),
- ("UnicodeEncodeError", 'object'): ('rwd', G_OBJECT),
- ("UnicodeEncodeError", 'start'): ('rwd', G_INT),
- ("UnicodeEncodeError", 'reason'): ('rwd', G_STR),
- ("UnicodeEncodeError", 'message'): ('rwd', G_STR),
- ("UnicodeTranslateError", 'end'): ('rwd', G_INT),
- ("UnicodeTranslateError", 'encoding'): ('rwd', G_STR),
- ("UnicodeTranslateError", 'object'): ('rwd', G_OBJECT),
- ("UnicodeTranslateError", 'start'): ('rwd', G_INT),
- ("UnicodeTranslateError", 'reason'): ('rwd', G_STR),
- ("UnicodeTranslateError", 'message'): ('rwd', G_STR),
- },
- '_ast': {
- ("AST", '__dict__'): ('rd', G_DICT),
- },
- 'posix': {
- ("statvfs_result", 'f_flag'): ('r', G_INT),
- ("statvfs_result", 'f_bavail'): ('r', G_INT),
- ("statvfs_result", 'f_favail'): ('r', G_INT),
- ("statvfs_result", 'f_files'): ('r', G_INT),
- ("statvfs_result", 'f_frsize'): ('r', G_INT),
- ("statvfs_result", 'f_blocks'): ('r', G_INT),
- ("statvfs_result", 'f_ffree'): ('r', G_INT),
- ("statvfs_result", 'f_bfree'): ('r', G_INT),
- ("statvfs_result", 'f_namemax'): ('r', G_INT),
- ("statvfs_result", 'f_bsize'): ('r', G_INT),
- ("stat_result", 'st_ctime'): ('r', G_INT),
- ("stat_result", 'st_rdev'): ('r', G_INT),
- ("stat_result", 'st_mtime'): ('r', G_INT),
- ("stat_result", 'st_blocks'): ('r', G_INT),
- ("stat_result", 'st_gid'): ('r', G_INT),
- ("stat_result", 'st_nlink'): ('r', G_INT),
- ("stat_result", 'st_ino'): ('r', G_INT),
- ("stat_result", 'st_blksize'): ('r', G_INT),
- ("stat_result", 'st_dev'): ('r', G_INT),
- ("stat_result", 'st_size'): ('r', G_INT),
- ("stat_result", 'st_mode'): ('r', G_INT),
- ("stat_result", 'st_uid'): ('r', G_INT),
- ("stat_result", 'st_atime'): ('r', G_INT),
- },
- "pwd": {
- ("struct_pwent", 'pw_dir'): ('r', G_STR),
- ("struct_pwent", 'pw_gid'): ('r', G_INT),
- ("struct_pwent", 'pw_passwd'): ('r', G_STR),
- ("struct_pwent", 'pw_gecos'): ('r', G_STR),
- ("struct_pwent", 'pw_shell'): ('r', G_STR),
- ("struct_pwent", 'pw_name'): ('r', G_STR),
- ("struct_pwent", 'pw_uid'): ('r', G_INT),
- ("struct_passwd", 'pw_dir'): ('r', G_STR),
- ("struct_passwd", 'pw_gid'): ('r', G_INT),
- ("struct_passwd", 'pw_passwd'): ('r', G_STR),
- ("struct_passwd", 'pw_gecos'): ('r', G_STR),
- ("struct_passwd", 'pw_shell'): ('r', G_STR),
- ("struct_passwd", 'pw_name'): ('r', G_STR),
- ("struct_passwd", 'pw_uid'): ('r', G_INT),
- },
- "thread": {
- ("_local", '__dict__'): None
- },
- "xxsubtype": {
- ("spamdict", 'state'): ('r', G_INT),
- ("spamlist", 'state'): ('r', G_INT),
- },
- "zipimport": {
- ("zipimporter", 'prefix'): ('r', G_STR),
- ("zipimporter", 'archive'): ('r', G_STR),
- ("zipimporter", '_files'): ('r', G_DICT),
- },
- "_struct": {
- ("Struct", "size"): ('r', G_INT),
- ("Struct", "format"): ('r', G_STR),
- },
- datetime_mod: {
- ("datetime", "hour"): ('r', G_INT),
- ("datetime", "minute"): ('r', G_INT),
- ("datetime", "second"): ('r', G_INT),
- ("datetime", "microsecond"): ('r', G_INT),
- ("date", "day"): ('r', G_INT),
- ("date", "month"): ('r', G_INT),
- ("date", "year"): ('r', G_INT),
- ("time", "hour"): ('r', G_INT),
- ("time", "minute"): ('r', G_INT),
- ("time", "second"): ('r', G_INT),
- ("time", "microsecond"): ('r', G_INT),
- ("timedelta", "days"): ('r', G_INT),
- ("timedelta", "seconds"): ('r', G_INT),
- ("timedelta", "microseconds"): ('r', G_INT),
- },
- }
- # Sometimes module X defines item foo but foo.__module__ == 'Y' instead of 'X';
- # module Y just re-exports foo, and foo fakes being defined in Y.
- # We list all such Ys keyed by X, all fully-qualified names:
- # {"real_definer_module": ("fake_reexporter_module",..)}
- KNOWN_FAKE_REEXPORTERS = {
- "_collections": ('collections',),
- "_functools": ('functools',),
- "_socket": ('socket',), # .error, etc
- "pyexpat": ('xml.parsers.expat',),
- "_bsddb": ('bsddb.db',),
- "pysqlite2._sqlite": ('pysqlite2.dbapi2',), # errors
- "numpy.core.multiarray": ('numpy', 'numpy.core'),
- "numpy.core._dotblas": ('numpy', 'numpy.core'),
- "numpy.core.umath": ('numpy', 'numpy.core'),
- "gtk._gtk": ('gtk', 'gtk.gdk',),
- "gobject._gobject": ('gobject',),
- "gnomecanvas": ("gnome.canvas",),
- }
- KNOWN_FAKE_BASES = []
- # list of classes that pretend to be base classes but are mere wrappers, and their defining modules
- # [(class, module),...] -- real objects, not names
- #noinspection PyBroadException
- try:
- #noinspection PyUnresolvedReferences
- import sip as sip_module # Qt specifically likes it
- if hasattr(sip_module, 'wrapper'):
- KNOWN_FAKE_BASES.append((sip_module.wrapper, sip_module))
- if hasattr(sip_module, 'simplewrapper'):
- KNOWN_FAKE_BASES.append((sip_module.simplewrapper, sip_module))
- del sip_module
- except:
- pass
- # This is a list of builtin classes to use fake init
- FAKE_BUILTIN_INITS = (tuple, type, int, str)
- if version[0] < 3:
- FAKE_BUILTIN_INITS = FAKE_BUILTIN_INITS + (getattr(the_builtins, "unicode"),)
- else:
- FAKE_BUILTIN_INITS = FAKE_BUILTIN_INITS + (getattr(the_builtins, "str"), getattr(the_builtins, "bytes"))
- # Some builtin methods are decorated, but this is hard to detect.
- # {("class_name", "method_name"): "decorator"}
- KNOWN_DECORATORS = {
- ("dict", "fromkeys"): "staticmethod",
- ("object", "__subclasshook__"): "classmethod",
- ("bytearray", "fromhex"): "classmethod",
- ("bytes", "fromhex"): "classmethod",
- ("bytearray", "maketrans"): "staticmethod",
- ("bytes", "maketrans"): "staticmethod",
- ("int", "from_bytes"): "classmethod",
- }
- classobj_txt = ( #TODO: user-skeleton
- "class ___Classobj:" "\n"
- " '''A mock class representing the old style class base.'''" "\n"
- " __module__ = ''" "\n"
- " __class__ = None" "\n"
- "\n"
- " def __init__(self):" "\n"
- " pass" "\n"
- " __dict__ = {}" "\n"
- " __doc__ = ''" "\n"
- )
- MAC_STDLIB_PATTERN = re.compile("/System/Library/Frameworks/Python\\.framework/Versions/(.+)/lib/python\\1/(.+)")
- MAC_SKIP_MODULES = ["test", "ctypes/test", "distutils/tests", "email/test",
- "importlib/test", "json/tests", "lib2to3/tests",
- "bsddb/test",
- "sqlite3/test", "tkinter/test", "idlelib", "antigravity"]
- POSIX_SKIP_MODULES = ["vtemodule", "PAMmodule", "_snackmodule", "/quodlibet/_mmkeys"]
- BIN_MODULE_FNAME_PAT = re.compile(r'([a-zA-Z_][0-9a-zA-Z_]*)\.(?:pyc|pyo|(?:(?:[a-zA-Z_0-9\-]+\.)?(?:so|pyd)))$')
- # possible binary module filename: letter, alphanum architecture per PEP-3149
- TYPELIB_MODULE_FNAME_PAT = re.compile("([a-zA-Z_]+[0-9a-zA-Z]*)[0-9a-zA-Z-.]*\\.typelib")
- MODULES_INSPECT_DIR = ['gi.repository']