@@ -28,10 +28,10 @@ def get_python_path(filepath: str) -> str:
             return os.getcwd()
 
 
-def _basename_in_ignore_list_re(base_name, ignore_list_re):
-    """Determines if the basename is matched in a regex ignorelist
+def _is_in_ignore_list_re(element, ignore_list_re):
+    """Determines if the element is matched in a regex ignore-list
 
-    :param str base_name: The basename of the file
+    :param str element: The element to be checked.
     :param list ignore_list_re: A collection of regex patterns to match against.
         Successful matches are ignored.
 
import os
import sys

from astroid import modutils


def _modpath_from_file(filename, is_namespace, path=None):
    def _is_package_cb(path, parts):
        return modutils.check_modpath_has_init(path, parts) or is_namespace

    return modutils.modpath_from_file_with_callback(
        filename, path=path, is_package_cb=_is_package_cb
    )


def get_python_path(filepath: str) -> str:
    """TODO This get the python path with the (bad) assumption that there is always
    an __init__.py. This is not true since python 3.3 and is causing problem."""
    dirname = os.path.realpath(os.path.expanduser(filepath))
    if not os.path.isdir(dirname):
        dirname = os.path.dirname(dirname)
    while True:
        if not os.path.exists(os.path.join(dirname, "__init__.py")):
            return dirname
        old_dirname = dirname
        dirname = os.path.dirname(dirname)
        if old_dirname == dirname:
            return os.getcwd()


def _basename_in_ignore_list_re(base_name, ignore_list_re):
    """Determines if the basename is matched in a regex ignorelist

    :param str base_name: The basename of the file
    :param list ignore_list_re: A collection of regex patterns to match against.
        Successful matches are ignored.

    :returns: `True` if the basename is ignored, `False` otherwise.
    :rtype: bool
    """
    for file_pattern in ignore_list_re:
        if file_pattern.match(base_name):
            return True
    return False


def expand_modules(files_or_modules, ignore_list, ignore_list_re):
    """Take a list of files/modules/packages and return the list of tuple
    (file, module name) which have to be actually checked."""
    result = []
    errors = []
    path = sys.path.copy()
    for something in files_or_modules:
        basename = os.path.basename(something)
        if basename in ignore_list or _basename_in_ignore_list_re(
            basename, ignore_list_re
        ):
            continue
        module_path = get_python_path(something)
        additional_search_path = [".", module_path] + path
        if os.path.exists(something):
            # this is a file or a directory
            try:
                modname = ".".join(
                    modutils.modpath_from_file(something, path=additional_search_path)
                )
            except ImportError:
                modname = os.path.splitext(basename)[0]
            if os.path.isdir(something):
                filepath = os.path.join(something, "__init__.py")
            else:
                filepath = something
        else:
            # suppose it's a module or package
            modname = something
            try:
                filepath = modutils.file_from_modpath(
                    modname.split("."), path=additional_search_path
                )
                if filepath is None:
                    continue
            except (ImportError, SyntaxError) as ex:
                # The SyntaxError is a Python bug and should be
                # removed once we move away from imp.find_module: https://bugs.python.org/issue10588
                errors.append({"key": "fatal", "mod": modname, "ex": ex})
                continue
        filepath = os.path.normpath(filepath)
        modparts = (modname or something).split(".")
        try:
            spec = modutils.file_info_from_modpath(
                modparts, path=additional_search_path
            )
        except ImportError:
            # Might not be acceptable, don't crash.
            is_namespace = False
            is_directory = os.path.isdir(something)
        else:
            is_namespace = modutils.is_namespace(spec)
            is_directory = modutils.is_directory(spec)
        if not is_namespace:
            result.append(
                {
                    "path": filepath,
                    "name": modname,
                    "isarg": True,
                    "basepath": filepath,
                    "basename": modname,
                }
            )
        has_init = (
            not (modname.endswith(".__init__") or modname == "__init__")
            and os.path.basename(filepath) == "__init__.py"
        )
        if has_init or is_namespace or is_directory:
            for subfilepath in modutils.get_module_files(
                os.path.dirname(filepath), ignore_list, list_all=is_namespace
            ):
                if filepath == subfilepath:
                    continue
                if _basename_in_ignore_list_re(
                    os.path.basename(subfilepath), ignore_list_re
                ):
                    continue
                modpath = _modpath_from_file(
                    subfilepath, is_namespace, path=additional_search_path
                )
                submodname = ".".join(modpath)
                result.append(
                    {
                        "path": subfilepath,
                        "name": submodname,
                        "isarg": False,
                        "basepath": filepath,
                        "basename": modname,
                    }
                )
    return result, errors

Could you add the typing and remove the docstring that became useless, please. Since this MR we've removed python 3.5 and trying to add typing on modified functions :)