示例#1
0
def get_module_members(module):
    """returns an iterable which gives the names of the module which should be exposed"""
    module_all = safe_getattr(module, "__all__", None)
    if module_all:
        return frozenset(module_all)

    return BuiltinScraper.safe_dir(module)
示例#2
0
def get_module_members(module):
    """returns an iterable which gives the names of the module which should be exposed"""
    module_all = safe_getattr(module, '__all__', None)
    if module_all:
        return frozenset(module_all)

    return BuiltinScraper.safe_dir(module)
示例#3
0
def generate_type_new(type_obj, obj):
    if safe_isinstance(
            obj, (types.BuiltinFunctionType, class_method_descriptor_type)):
        function_info = generate_builtin_function(obj)

        new_overloads = BuiltinScraper.get_new_overloads(type_obj, obj)
        if new_overloads is not None:
            # replace overloads with better version if available
            function_info['overloads'] = new_overloads
            return 'function', function_info

    if safe_getattr(
            obj, '__doc__', ''
    ) == 'T.__new__(S, ...) -> a new object with type S, a subtype of T':
        doc_str = safe_getattr(type_obj, '__doc__', None)
        if not safe_isinstance(doc_str, str_types):
            doc_str = ''
        return ('function', {
            'doc':
            doc_str,
            'overloads': [{
                'doc': doc_str,
                'args': [{
                    'arg_format': '*',
                    'name': 'args'
                }]
            }]
        })

    return generate_member(obj)
示例#4
0
def generate_builtin_function(function):
    function_table = {}

    if isinstance(function.__doc__, str):
        function_table['doc'] = function.__doc__

    function_table['overloads'] = BuiltinScraper.get_overloads(function)

    return function_table
示例#5
0
def generate_builtin_function(function, is_method=False):
    function_table = {}

    func_doc = safe_getattr(function, "__doc__", None)
    if safe_isinstance(func_doc, str):
        function_table["doc"] = func_doc

    function_table["overloads"] = BuiltinScraper.get_overloads(function, is_method)

    return function_table
示例#6
0
def generate_builtin_function(function, is_method=False):
    function_table = {}
    
    func_doc = safe_getattr(function, '__doc__', None)
    if safe_isinstance(func_doc, str):
        function_table['doc'] = func_doc

    function_table['overloads'] = BuiltinScraper.get_overloads(function, is_method)
    
    return function_table
示例#7
0
def generate_getset_descriptor(descriptor):
    descriptor_table = {}

    if isinstance(descriptor.__doc__, str):
        descriptor_table['doc'] = descriptor.__doc__

    desc_type = BuiltinScraper.get_descriptor_type(descriptor)
    descriptor_table['type'] = type_to_name(desc_type)

    return descriptor_table
示例#8
0
def generate_getset_descriptor(descriptor):
    descriptor_table = {}

    desc_doc = safe_getattr(descriptor, "__doc__", None)
    if safe_isinstance(desc_doc, str):
        descriptor_table["doc"] = desc_doc

    desc_type = BuiltinScraper.get_descriptor_type(descriptor)
    descriptor_table["type"] = type_to_typelist(desc_type)

    return descriptor_table
示例#9
0
def generate_getset_descriptor(descriptor):
    descriptor_table = {}

    desc_doc = safe_getattr(descriptor, '__doc__', None)
    if safe_isinstance(desc_doc, str):
        descriptor_table['doc'] = desc_doc

    desc_type = BuiltinScraper.get_descriptor_type(descriptor)
    descriptor_table['type'] = type_to_typelist(desc_type)

    return descriptor_table
示例#10
0
def generate_type_new(type_obj, obj):
    if safe_isinstance(obj, (types.BuiltinFunctionType, class_method_descriptor_type)):
        function_info = generate_builtin_function(obj)

        new_overloads = BuiltinScraper.get_new_overloads(type_obj, obj)
        if new_overloads is not None:
            # replace overloads with better version if available
            function_info["overloads"] = new_overloads
            return "function", function_info

    if safe_getattr(obj, "__doc__", "") == "T.__new__(S, ...) -> a new object with type S, a subtype of T":
        doc_str = safe_getattr(type_obj, "__doc__", None)
        if not safe_isinstance(doc_str, str_types):
            doc_str = ""
        return (
            "function",
            {"doc": doc_str, "overloads": [{"doc": doc_str, "args": [{"arg_format": "*", "name": "args"}]}]},
        )

    return generate_member(obj)
示例#11
0
def generate_type_new(type_obj, obj):
    if safe_isinstance(obj, (types.BuiltinFunctionType, class_method_descriptor_type)):
        function_info = generate_builtin_function(obj)

        new_overloads = BuiltinScraper.get_new_overloads(type_obj, obj)
        if new_overloads is not None:
            # replace overloads with better version if available
            function_info['overloads'] = new_overloads
            return 'function', function_info

    if safe_getattr(obj, '__doc__', '') == 'T.__new__(S, ...) -> a new object with type S, a subtype of T':
        doc_str = safe_getattr(type_obj, '__doc__', None)
        if not safe_isinstance(doc_str, str_types):
            doc_str = ''
        return (
            'function',
            {
                'doc': doc_str,
                'overloads' : [{'doc': doc_str, 'args': [{'arg_format': '*', 'name': 'args'}] }]
            }
        )

    return generate_member(obj)
示例#12
0
def generate_member_table(obj, is_hidden=False, from_type=False, extra_types=None):
    """Generates a table of members of `obj`.

    `is_hidden` determines whether all the members are hidden from IntelliSense.

    `from_type` determines whether method descriptors are retained (True) or
    ignored (False).

    `extra_types` is a sequence of ``(type_name, object)`` pairs to add as types
    to this table. These types are always hidden.
    """

    sentinel = object()
    members = []
    for name in BuiltinScraper.safe_dir(obj):
        member = safe_getattr(obj, name, sentinel)
        if member is not sentinel:
            members.append((name, member))

    dependencies = {}
    table = {}
    if extra_types:
        for name, member in extra_types:
            member_kind, member_value = generate_member(member, is_hidden=True, from_type=from_type)
            if member_kind == "typeref":
                actual_name = type_to_typeref(member)
                if actual_name not in dependencies:
                    dependencies[actual_name] = member
            table[name] = {"kind": member_kind, "value": member_value}

    for name, member in members:
        member_kind, member_value = generate_member(member, is_hidden, from_type)
        if member_kind == "typeref":
            actual_name = type_to_typeref(member)
            if actual_name not in dependencies:
                dependencies[actual_name] = member
        table[name] = {"kind": member_kind, "value": member_value}

    if dependencies:
        obj_mod, obj_name = type_to_typeref(obj)

        def needs_type_info(other_mod, other_name):
            if obj_mod != other_mod:
                if other_mod == builtin_name:
                    # Never embed builtins (unless obj_mod is builtins, in
                    # which case the first comparison failed)
                    return False

                # Always embed external types
                return True

            # We know obj_mod == other_mod at this point

            if not obj_name:
                # Writing ourselves in the expected place
                return True
            elif obj_name.startswith(other_name + "."):
                # Always write references to outer types
                return False
            elif other_name and other_name.startswith(obj_name + "."):
                # Always write type info for inner types
                return True

            # Otherwise, use a typeref
            return False

        for (dep_mod, dep_name), dep_obj in dependencies.items():
            if needs_type_info(dep_mod, dep_name):
                table[dep_name] = {"kind": "type", "value": generate_type(dep_obj, is_hidden=dep_name not in table)}

    return table
示例#13
0
def write_module(mod_name, outpath, analysis):
    write_analysis(os.path.join(outpath, mod_name), analysis)


if __name__ == "__main__":
    outpath = sys.argv[1]
    if len(sys.argv) > 2:
        baselinepath = sys.argv[2]
    else:
        baselinepath = None

    res = generate_builtin_module()
    if not res:
        raise RuntimeError("Unable to scrape builtins")
    res = merge_with_baseline(builtin_name, baselinepath, res)

    write_module(builtin_name, outpath, res)

    for mod_name in sys.builtin_module_names:
        if mod_name == builtin_name or mod_name == "__main__" or not BuiltinScraper.should_include_module(mod_name):
            continue

        res = generate_module(lookup_module(mod_name))
        if res is not None:
            try:
                res = merge_with_baseline(mod_name, baselinepath, res)

                write_module(mod_name, outpath, res)
            except ValueError:
                pass
示例#14
0

if __name__ == "__main__":
    outpath = sys.argv[1]
    if len(sys.argv) > 2:
        baselinepath = sys.argv[2]
    else:
        baselinepath = None
    
    res = generate_builtin_module()
    if not res:
        raise RuntimeError("Unable to scrape builtins")
    res = merge_with_baseline(builtin_name, baselinepath, res)
    
    write_module(builtin_name, outpath, res)
    
    for mod_name in sys.builtin_module_names:
        if (mod_name == builtin_name or
            mod_name == '__main__' or
            not BuiltinScraper.should_include_module(mod_name)):
            continue
        
        res = generate_module(lookup_module(mod_name))
        if res is not None:
            try:
                res = merge_with_baseline(mod_name, baselinepath, res)

                write_module(mod_name, outpath, res)
            except ValueError:
                pass
示例#15
0
def generate_member_table(obj,
                          is_hidden=False,
                          from_type=False,
                          extra_types=None):
    '''Generates a table of members of `obj`.

    `is_hidden` determines whether all the members are hidden from IntelliSense.

    `from_type` determines whether method descriptors are retained (True) or
    ignored (False).

    `extra_types` is a sequence of ``(type_name, object)`` pairs to add as types
    to this table. These types are always hidden.
    '''

    sentinel = object()
    members = []
    for name in BuiltinScraper.safe_dir(obj):
        member = safe_getattr(obj, name, sentinel)
        if member is not sentinel:
            members.append((name, member))

    dependencies = {}
    table = {}
    if extra_types:
        for name, member in extra_types:
            member_kind, member_value = generate_member(member,
                                                        is_hidden=True,
                                                        from_type=from_type)
            if member_kind == 'typeref':
                actual_name = type_to_typeref(member)
                if actual_name not in dependencies:
                    dependencies[actual_name] = member
            table[name] = {'kind': member_kind, 'value': member_value}

    for name, member in members:
        member_kind, member_value = generate_member(member, is_hidden,
                                                    from_type)
        if member_kind == 'typeref':
            actual_name = type_to_typeref(member)
            if actual_name not in dependencies:
                dependencies[actual_name] = member
        table[name] = {'kind': member_kind, 'value': member_value}

    if dependencies:
        obj_mod, obj_name = type_to_typeref(obj)

        def needs_type_info(other_mod, other_name):
            if obj_mod != other_mod:
                if other_mod == builtin_name:
                    # Never embed builtins (unless obj_mod is builtins, in
                    # which case the first comparison failed)
                    return False

                # Always embed external types
                return True

            # We know obj_mod == other_mod at this point

            if not obj_name:
                # Writing ourselves in the expected place
                return True
            elif obj_name.startswith(other_name + '.'):
                # Always write references to outer types
                return False
            elif other_name and other_name.startswith(obj_name + '.'):
                # Always write type info for inner types
                return True

            # Otherwise, use a typeref
            return False

        for (dep_mod, dep_name), dep_obj in list(dependencies.items()):
            if needs_type_info(dep_mod, dep_name):
                table[dep_name] = {
                    'kind':
                    'type',
                    'value':
                    generate_type(dep_obj, is_hidden=dep_name not in table),
                }

    return table
示例#16
0
    write_analysis(os.path.join(outpath, mod_name), analysis)


if __name__ == "__main__":
    outpath = sys.argv[1]
    if len(sys.argv) > 2:
        baselinepath = sys.argv[2]
    else:
        baselinepath = None

    res = generate_builtin_module()
    if not res:
        raise RuntimeError("Unable to scrape builtins")
    res = merge_with_baseline(builtin_name, baselinepath, res)

    write_module(builtin_name, outpath, res)

    for mod_name in sys.builtin_module_names:
        if (mod_name == builtin_name or mod_name == '__main__'
                or not BuiltinScraper.should_include_module(mod_name)):
            continue

        res = generate_module(lookup_module(mod_name))
        if res is not None:
            try:
                res = merge_with_baseline(mod_name, baselinepath, res)

                write_module(mod_name, outpath, res)
            except ValueError:
                pass