d8s-python 0.10.0__py3-none-any.whl

d8s_python/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.10.0"
+__author__ = """Floyd Hightower"""
+__email__ = "floyd.hightower27@gmail.com"
+
+from .ast_data import *
+from .python_data import *

d8s_python/ast_data.py

@@ -0,0 +1,284 @@
+import ast
+from typing import Iterable, List, Optional, Tuple, Union
+
+import more_itertools
+from d8s_lists import iterable_replace, truthy_items
+
+# TODO: all of these functions where code_text is given should also be able to read a file at a given path (?)
+
+
+def _python_ast_exception_name(node: Union[ast.Raise, ast.ExceptHandler]) -> Optional[str]:
+    """."""
+    if hasattr(node, "exc") and node.exc:  # this handles ast.Raise nodes
+        if hasattr(
+            node.exc, "id"
+        ):  # this handles ast.Raise nodes where the exception being raised is an ast.Name (e.g. "e" or "ValueError")
+            return node.exc.id
+        elif hasattr(
+            node.exc.func,  # type: ignore[union-attr]
+            "id",
+        ):  # handles ast.Raise nodes where the exception being raised is an ast.Call (e.g. "ValueError('Foo Bar')")
+            return node.exc.func.id  # type: ignore[union-attr]
+        elif hasattr(
+            node.exc.func,  # type: ignore[union-attr]
+            "attr",
+        ):  # this handles ast.Raise nodes raising a non-built-in error (e.g. "pint.UndefinedUnitError")
+            return f"{node.exc.func.value.id}.{node.exc.func.attr}"  # type: ignore[union-attr]
+    elif hasattr(node, "type") and node.type:  # this handles ast.ExceptHandler nodes
+        if hasattr(
+            node.type, "id"
+        ):  # this handles ast.ExceptHandler nodes raising a built-in error (e.g. "RuntimeError")
+            return node.type.id
+        elif hasattr(
+            node.type, "attr"
+        ):  # this handles ast.ExceptHandler nodes raising a non-built-in error (e.g. "pint.UndefinedUnitError")
+            return f"{node.type.value.id}.{node.type.attr}"  # type: ignore[union-attr]
+    elif hasattr(
+        node, "attr"
+    ):  # this handles situations where the exception being raised is an ast.Attribute (e.g. "pint.UndefinedUnitError")
+        return f"{node.value.id}.{node.attr}"  # type: ignore[union-attr]
+    elif hasattr(node, "id"):  # this handles situations where the exception being raised is an ast.Name (e.g. "e")
+        return node.id
+
+    return None
+
+
+def python_ast_raise_name(node: ast.Raise) -> Optional[str]:
+    """Get the name of the exception raise by the given ast.Raise object."""
+    return _python_ast_exception_name(node)
+
+
+def python_ast_exception_handler_exceptions_handled(handler: ast.ExceptHandler) -> Optional[Iterable[str]]:  # type: ignore[return]
+    """Return all of the exceptions handled by the given exception handler."""
+    handler_has_multiple_exceptions = handler.type and hasattr(handler.type, "elts")
+    if handler_has_multiple_exceptions:
+        yield from (_python_ast_exception_name(i) for i in handler.type.elts)  # type: ignore[union-attr]
+    else:
+        exception_name = _python_ast_exception_name(handler)
+        if exception_name:
+            yield exception_name
+
+
+def python_ast_exception_handler_exceptions_raised(handler: ast.ExceptHandler) -> Optional[Iterable[str]]:  # type: ignore[return]
+    """Return the exception raised by the given exception handler."""
+    raise_nodes = python_ast_objects_of_type(handler, ast.Raise)
+    exceptions_names = list(map(python_ast_raise_name, raise_nodes))  # type: ignore[arg-type]
+    for name in exceptions_names:
+        if name and name == handler.name:
+            exceptions_names = iterable_replace(
+                exceptions_names, name, python_ast_exception_handler_exceptions_handled(handler)
+            )
+        elif name is None:
+            exceptions_names = iterable_replace(
+                exceptions_names, name, python_ast_exception_handler_exceptions_handled(handler)
+            )
+    yield from more_itertools.collapse(exceptions_names, base_type=str)
+
+
+def python_exceptions_handled(code_text: str) -> Iterable[str]:
+    """Return a list of all exceptions handled in the given code."""
+    ast_except_handlers = python_ast_objects_of_type(code_text, ast.ExceptHandler)
+    yield from more_itertools.collapse(
+        list(map(python_ast_exception_handler_exceptions_handled, ast_except_handlers)),  # type: ignore[arg-type]
+        base_type=str,
+    )
+
+
+def python_exceptions_raised(code_text: str) -> Iterable[str]:
+    """Return a list of all exceptions raised in the given code."""
+    parsed_code = python_ast_parse(code_text)
+
+    ast_except_handlers = python_ast_objects_of_type(parsed_code, ast.ExceptHandler)
+    exceptions = list(map(python_ast_exception_handler_exceptions_raised, ast_except_handlers))  # type: ignore[arg-type]
+
+    # remove all of the ast.ExceptHandlers so exceptions are not parsed twice...
+    # (once from the code above and once in the code below)
+    nodes = python_ast_objects_not_of_type(parsed_code, ast.ExceptHandler)
+    exceptions.extend(list(map(python_ast_raise_name, (node for node in nodes if isinstance(node, ast.Raise)))))
+
+    yield from more_itertools.collapse(exceptions, base_type=str)
+
+
+def python_functions_as_import_string(code_text: str, module_name: str) -> str:
+    """."""
+    import jinja2
+
+    function_names = python_function_names(code_text)
+    template = """from {{ module_name }} import (
+{%- for name in function_names %}
+    {{ name }},
+{%- endfor %}
+)"""
+    template = jinja2.Template(template)  # type: ignore[assignment]
+    result = template.render(module_name=module_name, function_names=function_names)  # type: ignore[attr-defined]
+    return result
+
+
+def python_ast_object_line_number(ast_object: object) -> Optional[int]:
+    """."""
+    if hasattr(ast_object, "lineno"):
+        return ast_object.lineno
+    else:
+        return None
+
+
+def python_ast_object_line_numbers(ast_object: object) -> Tuple[int, int]:
+    """."""
+    from d8s_algorithms import depth_first_traverse
+
+    line_numbers = tuple(
+        truthy_items(
+            list(
+                depth_first_traverse(
+                    ast_object, ast.iter_child_nodes, collect_items_function=python_ast_object_line_number
+                )
+            )
+        )
+    )
+    return min(line_numbers), max(line_numbers)
+
+
+def _python_ast_clean(code_text: str) -> str:
+    """."""
+    import re
+
+    return re.sub("\n", "\\\\n", code_text)
+
+
+# TODO: have a decorator to parse a first argument that is a string
+def python_ast_objects_of_type(  # noqa: CCR001
+    code_text_or_ast_object: Union[str, object], ast_type: type, *, recursive_search: bool = True
+) -> Iterable[object]:
+    """Return all of the ast objects of the given ast_type in the code_text_or_ast_object."""
+    if isinstance(code_text_or_ast_object, str):
+        parsed_code = python_ast_parse(code_text_or_ast_object)
+    else:
+        parsed_code = code_text_or_ast_object  # type: ignore[assignment]
+
+    if recursive_search:
+        yield from (node for node in ast.walk(parsed_code) if isinstance(node, ast_type))
+    else:
+        if isinstance(parsed_code, ast_type):
+            yield parsed_code
+
+        if hasattr(parsed_code, "body"):
+            yield from (node for node in parsed_code.body if isinstance(node, ast_type))
+
+
+def python_ast_objects_not_of_type(code_text_or_ast_object: Union[str, object], ast_type: type) -> Iterable[object]:
+    """Return all of the ast objects which are not of the given ast_type in the code_text_or_ast_object."""
+    from d8s_algorithms import depth_first_traverse
+
+    if isinstance(code_text_or_ast_object, str):
+        parsed_code = python_ast_parse(code_text_or_ast_object)
+    else:
+        parsed_code = code_text_or_ast_object  # type: ignore[assignment]
+
+    ast_objects_not_of_type = truthy_items(
+        list(
+            depth_first_traverse(
+                parsed_code,
+                lambda x: ast.iter_child_nodes(x) if not isinstance(x, ast_type) else [],
+                collect_items_function=lambda x: x,
+            )
+        )
+    )
+    return ast_objects_not_of_type
+
+    # ast_objects_not_of_type = (node for node in ast.walk(parsed_code) if not isinstance(node, ast_type))
+    # for node in ast.walk(parsed_code):
+    #     if not isinstance(node, ast_type):
+    #         yield node
+    #     else:
+    #         break
+
+    # return ast_objects_not_of_type
+
+
+def python_ast_parse(code_text: str) -> ast.Module:
+    """."""
+    try:
+        parsed_code = ast.parse(code_text)
+    except Exception:  # pylint: disable=W0703
+        code_text = _python_ast_clean(code_text)
+        parsed_code = ast.parse(code_text)
+    return parsed_code
+
+
+def python_ast_function_defs(code_text: str, recursive_search: bool = True) -> Iterable[ast.FunctionDef]:
+    """."""
+    yield from python_ast_objects_of_type(code_text, ast.FunctionDef, recursive_search=recursive_search)  # type: ignore[misc]
+    yield from python_ast_objects_of_type(code_text, ast.AsyncFunctionDef, recursive_search=recursive_search)  # type: ignore[misc]
+
+
+def python_function_arguments(function_text: str) -> List[ast.arg]:
+    """."""
+    parsed_code = python_ast_parse(function_text)
+    args = parsed_code.body[0].args.args  # type: ignore[attr-defined]
+    return args
+
+
+def python_function_argument_names(function_text: str) -> Iterable[str]:
+    """."""
+    argument_names = (arg.arg for arg in python_function_arguments(function_text))
+    return argument_names
+
+
+def python_function_argument_defaults(function_text: str) -> List[str]:
+    """."""
+    # TODO: this function does not return defaults for keyword args
+    parsed_code = python_ast_parse(function_text)
+    return parsed_code.body[0].args.defaults  # type: ignore[attr-defined]
+
+
+def python_function_argument_annotations(function_text: str) -> List[str]:
+    """."""
+    annotations = []
+    args = python_function_arguments(function_text)
+    for arg in args:
+        if arg.annotation:
+            annotations.append(arg.annotation.id)  # type: ignore[attr-defined]
+        else:
+            annotations.append(None)
+    return annotations
+
+
+def python_function_names(
+    code_text: str, *, ignore_private_functions: bool = False, ignore_nested_functions: bool = False
+) -> List[str]:
+    """."""
+    function_objects = python_ast_function_defs(code_text, recursive_search=not ignore_nested_functions)
+    function_names = [f.name for f in function_objects]
+    if ignore_private_functions:
+        function_names = [name for name in function_names if not name.startswith("_")]
+    return function_names
+
+
+def python_function_docstrings(
+    code_text: str, *, ignore_private_functions: bool = False, ignore_nested_functions: bool = False
+) -> List[str]:
+    """Get docstrings for all of the functions in the given text."""
+    function_objects = python_ast_function_defs(code_text, recursive_search=not ignore_nested_functions)
+    docstrings = [
+        ast.get_docstring(f) for f in function_objects if not (ignore_private_functions and f.name.startswith("_"))
+    ]
+    return docstrings  # type: ignore[return-value]
+
+
+def python_variable_names(code_text: str) -> List[str]:
+    """Get all of the variables names in the code_text."""
+    # TODO: add a caveat that this function will only find *stored* variables and not those which are referenced or...
+    # loaded. E.g., given "x = y + 1", this function will return ["x"]; note that "y" is not included
+    parsed_code = python_ast_parse(code_text)
+    variable_names = [
+        node.id for node in ast.walk(parsed_code) if isinstance(node, ast.Name) and (isinstance(node.ctx, ast.Store))
+    ]
+    return variable_names
+
+
+def python_constants(code_text: str) -> List[str]:
+    """Get all constants in the code_text."""
+    # TODO: add a caveat that this function will only find *stored* variables which are uppercased
+    variables = python_variable_names(code_text)
+    constants = [var for var in variables if var.isupper()]
+    return constants

d8s_python/python_data.py

@@ -0,0 +1,406 @@
+import argparse
+import re
+import sys
+from ast import Import, ImportFrom
+from typing import Any, Dict, Iterator, List, Union
+
+from .ast_data import python_ast_objects_of_type
+
+
+# @decorators.map_firstp_arg
+def python_functions_signatures(
+    code_text: str,
+    *,
+    ignore_private_functions: bool = False,
+    ignore_nested_functions: bool = False,
+    keep_function_name: bool = False,
+) -> List[str]:
+    """Return the function signatures for all of the functions in the given code_text."""
+    from d8s_strings import string_remove_from_start
+
+    from .ast_data import python_function_names
+
+    signatures = []
+
+    function_names = python_function_names(
+        code_text, ignore_private_functions=ignore_private_functions, ignore_nested_functions=ignore_nested_functions
+    )
+
+    for name in function_names:
+        regex_for_signature = rf"(def {name}\((?:.|\s)*?\).*?):"
+        sig = re.findall(regex_for_signature, code_text)
+        if any(sig):
+            new_sig = string_remove_from_start(sig[0], "def ")
+            if not keep_function_name:
+                new_sig = string_remove_from_start(new_sig, name)
+            signatures.append(new_sig)
+        else:
+            message = f"Unable to find signature for the {name} function"
+            print(message)
+            signatures.append(None)
+
+    return signatures
+
+
+def python_todos(code_text: str, todo_regex: str = "TODO:.*") -> List[str]:
+    """Return all todos in the given code_text that match the given todo_regex."""
+    todos = re.findall(todo_regex, code_text)
+    return todos
+
+
+# @decorators.map_first_arg
+def python_make_pythonic(name: str) -> str:
+    """Make the name pythonic.
+
+    (e.g. 'fooBar' => 'foo_bar', 'foo-bar' => 'foo_bar', 'foo bar' => 'foo_bar', 'Foo Bar' => 'foo_bar').
+    """
+    from d8s_strings import lowercase, snake_case, string_split_on_uppercase
+
+    split_string = "_".join(
+        [
+            string.strip()
+            for string in string_split_on_uppercase(name, include_uppercase_characters=True, split_acronyms=False)
+        ]
+    )
+    split_string = lowercase(split_string)
+    result = snake_case(split_string)
+    return result
+
+
+# @decorators.map_first_arg
+def python_namespace_has_argument(namespace: argparse.Namespace, argument_name: str) -> bool:
+    """."""
+    result = argument_name in namespace
+    return result
+
+
+# @decorators.map_first_arg
+def python_traceback_prettify(traceback: str) -> str:
+    """Return a string with the given traceback pretty-printed."""
+    pretty_traceback = re.sub(" File ", "\nFile ", traceback)
+
+    return pretty_traceback
+
+
+# @decorators.map_first_arg
+def python_traceback_pretty_print(traceback: str) -> None:
+    """Return a string with the given traceback pretty-printed."""
+    prettified_string = python_traceback_prettify(traceback)
+    print(prettified_string)
+
+
+# @decorators.map_first_arg
+def python_clean(code_text: str) -> str:
+    """Clean python code as it is often found in documentation and snippets."""
+    code_text = code_text.replace(">>> ", "")
+    code_text = code_text.replace("... ", "")
+    return code_text
+
+
+def python_function_blocks(  # noqa: CCR001
+    code_text: str, *, ignore_private_functions: bool = False, ignore_nested_functions: bool = False
+) -> List[str]:
+    """Find the code (as a string) for every function in the given code_text."""
+    from d8s_lists import has_index
+    from d8s_strings import string_chars_at_start_len
+
+    from .ast_data import python_ast_function_defs, python_ast_object_line_numbers
+
+    function_block_strings = []
+    code_text_as_lines = code_text.splitlines()
+    ast_function_defs = python_ast_function_defs(code_text, recursive_search=not ignore_nested_functions)
+    function_block_line_numbers = [(f.name, python_ast_object_line_numbers(f)) for f in ast_function_defs]
+
+    for function_name, (start, end) in function_block_line_numbers:
+        function_block_lines = code_text_as_lines[start - 1 : end]  # noqa=E203
+        function_block_string = "\n".join(function_block_lines)
+
+        if ignore_private_functions:
+            if function_name.startswith("_"):
+                continue
+
+        # the code below checks to see if the line after what was determined to be the last line of the function...
+        # should also be included in the function block (which is the case when the closing parenthesis of a...
+        # function call in another function is on a newline (see the...
+        # python_data_tests.py::test_python_function_blocks_edge_cases_1 for an example))
+        if has_index(code_text_as_lines, end):
+            # find the indentation level of the function definition (the first line of the function)
+            function_indentation = string_chars_at_start_len(function_block_lines[0], " ")
+            # TODO: the check below assumes that spaces are used instead of tabs
+            next_line_is_indented = (
+                code_text_as_lines[end].startswith(" ")
+                and string_chars_at_start_len(code_text_as_lines[end], " ") > function_indentation
+            )
+            next_line_has_only_parenthesis = code_text_as_lines[end].strip(" ") == ")"
+            if next_line_is_indented and next_line_has_only_parenthesis:
+                function_block_string += f"\n{code_text_as_lines[end]}"
+        function_block_strings.append(function_block_string)
+    return function_block_strings
+
+
+def python_line_count(python_code: str, *, ignore_empty_lines: bool = True) -> int:
+    """Return the number of lines in the given function_text."""
+    from d8s_lists import truthy_items
+
+    lines = python_code.splitlines()
+    if ignore_empty_lines:
+        return len(tuple(truthy_items(lines)))
+    else:
+        return len(lines)
+
+
+def python_function_lengths(code_text: str) -> List[int]:
+    """Find the lengths of each function in the given code_text."""
+    function_blocks = python_function_blocks(code_text)
+    return [python_line_count(function_block) for function_block in function_blocks]
+
+
+def python_version() -> str:
+    """Return the python version of the current environment."""
+    return "{}.{}.{}".format(sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
+
+
+def python_is_version_2() -> bool:
+    """Return whether or not the python version of the current environment is v2.x."""
+    return python_version().startswith("2.")
+
+
+def python_is_version_3() -> bool:
+    """Return whether or not the python version of the current environment is v3.x."""
+    return not python_is_version_2()
+
+
+# TODO: need to standardize the order of arguments between functions like this an the directorySearch function
+# @decorators.map_first_arg
+def python_files_using_function(function_name: str, search_path: str) -> List[str]:
+    """Find where the given function is used in the given search path."""
+    from d8s_file_system import directory_read_files_with_path_matching
+
+    files_using_function = []
+
+    function_pattern = f"{function_name}("
+    python_files = directory_read_files_with_path_matching(search_path, "*.py")
+    for file_path, file_contents in python_files:
+        if function_pattern in file_contents:
+            files_using_function.append(file_path)
+
+    return files_using_function
+
+
+def python_keywords() -> List[str]:
+    """Get a list of the python keywords."""
+    import keyword
+
+    return keyword.kwlist  # type: ignore[return-value]
+
+    # if code_text is None:
+    #     return python_keywords
+    # else:
+    #     from d8s_strings import string_words
+
+    #     words_in_code_text = string_words(code_text)
+    #     keywords_used = []
+
+    #     for palabra in words_in_code_text:
+    #         if palabra in python_keywords:
+    #             keywords_used.append(palabra)
+
+    # return keywords_used
+
+
+# @decorators.map_first_arg
+def python_object_properties_enumerate(  # noqa: CCR001
+    python_object: Any, *, run_methods: bool = True, internal_properties: bool = True
+) -> None:
+    """Enumerate and print out the properties of the given object."""
+    for i in python_object.__dir__():
+        if not internal_properties:
+            if i.startswith("_"):
+                continue
+
+        string_to_eval_as_property = "python_object.{}".format(i)
+        try:
+            if run_methods:
+                eval_result = eval(string_to_eval_as_property)  # pylint: disable=W0123
+                if callable(eval_result):
+                    string_to_eval_as_function = "python_object.{}()".format(i)
+                    try:
+                        print(f"{i}: {eval(string_to_eval_as_function)}")  # pylint: disable=W0123
+                    except TypeError:
+                        print(f"{i}: {eval(string_to_eval_as_property)}")  # pylint: disable=W0123
+                else:
+                    print(f"{i}: {eval_result}")
+            else:
+                print(f"{i}: {eval(string_to_eval_as_property)}")  # pylint: disable=W0123
+        except AttributeError:
+            print(f"! Unable to get the {i} attribute for the item.")
+
+
+def python_copy_deep(python_object: Any) -> Any:
+    """Return a deep (complete, recursive) copy of the given python object."""
+    import copy
+
+    return copy.deepcopy(python_object)
+
+
+def python_copy_shallow(python_object: Any) -> Any:
+    """Return shallow copy of the given python object."""
+    import copy
+
+    return copy.copy(python_object)
+
+
+# @decorators.map_first_arg
+def python_file_names(path: str, *, exclude_tests: bool = False) -> List[str]:  # noqa: CCR001
+    """Find all python files in the given directory."""
+    from d8s_file_system import directory_file_names_matching
+
+    files = directory_file_names_matching(path, "*.py")
+
+    if not exclude_tests:
+        return files
+    else:
+        non_test_files = []
+
+        for file in files:
+            if "_test" not in file and "test_" not in file:
+                non_test_files.append(file)
+
+        return non_test_files
+
+
+# @decorators.map_first_arg
+def python_fstrings(code_text: str, *, include_braces: bool = False) -> Iterator[str]:
+    """Find all of the python formatted string literals in the given text.
+
+    See https://realpython.com/python-f-strings/ for more details about f-strings.
+    """
+    from d8s_grammars import python_formatted_string_literal
+    from d8s_lists import flatten
+
+    python_f_strings = flatten(python_formatted_string_literal.searchString(code_text).asList())
+
+    if not include_braces:
+        python_f_strings = (f_string.strip("{").strip("}") for f_string in python_f_strings)
+
+    return python_f_strings
+
+
+# @decorators.map_first_arg
+def python_code_details(code_text: str):
+    """Get details about the given code_text. This is a wrapper for `dis.code_info`"""
+    import dis
+
+    return dis.code_info(code_text)
+
+
+# @decorators.map_first_arg
+def python_disassemble(code_text: str):
+    """Disassemble the python code_text. This is a wrapper for `dis.dis`"""
+    import dis
+
+    return dis.Bytecode(code_text).dis()
+
+
+def python_stack_local_data():
+    """Get local data in the current python environment."""
+    import inspect
+
+    # in Python 3.13+ frame.f_locals returns a write-through proxy (PEP 667) rather than a dict, so coerce to a dict
+    return dict(inspect.currentframe().f_locals)
+
+
+# @decorators.map_first_arg
+def python_object_doc_string(python_object: Any) -> Union[str, None]:
+    """Get the doc string for the given python object (e.g. module, function, or class)."""
+    import inspect
+
+    return inspect.getdoc(python_object)
+
+
+# @decorators.map_first_arg
+def python_object_source_file(python_object: Any) -> str:
+    """Get the source file for the given python object (e.g. module, function, or class)."""
+    import inspect
+
+    return inspect.getsourcefile(python_object)  # type: ignore[return-value]
+
+
+# @decorators.map_first_arg
+def python_object_module(python_object: Any) -> str:
+    """Get the module for the given python object (e.g. function or class)."""
+    return python_object.__module__
+
+
+# @decorators.map_first_arg
+def python_object_source_code(python_object: Any) -> str:
+    """Get the source code for the given python object (e.g. module, function, or class)."""
+    import inspect
+
+    return inspect.getsource(python_object)
+
+
+# @decorators.map_first_arg
+def python_object_signature(python_object: Any) -> str:
+    """Get the argument signature for the given python object (e.g. module, function, or class)."""
+    import inspect
+
+    return inspect.signature(python_object)  # type: ignore[return-value]
+
+
+# TODO: improve the type annotations to be lists of types
+def python_sort_type_list_by_name(python_type_list: List[type], **kwargs) -> List[type]:
+    """."""
+    return sorted(python_type_list, key=lambda x: python_type_name(x), **kwargs)  # pylint: disable=W0108
+
+
+# @decorators.map_first_arg
+def python_type_name(python_type: type) -> str:
+    """Return the common name of the given type."""
+    return python_type.__name__
+
+
+def python_object_type_to_word(python_object: Any) -> str:
+    """Convert the given python type to a string."""
+    return python_type_name(type(python_object))
+
+
+def _get_importfrom_module_name(node: ImportFrom) -> str:
+    """Extract the module name from an ast.ImportFrom node.
+
+    The module name on the ast.ImportFrom node can be None for relative imports
+    In this case, this function will return the name as the dots from the import statement.
+    A few examples:
+    "from requests import get" -> "requests"
+    "from . import *" -> "."
+    "from .. import *" -> ".."
+    "from .foo import bar" -> "foo"
+    """
+    if node.module is None:
+        module_name = "." * node.level
+    else:
+        module_name = node.module
+
+    return module_name
+
+
+def python_package_imports(code: str) -> Dict[str, List[str]]:
+    """Return a dictionary containing the names of all imported modules."""
+    # Start with the Import nodes.
+    # These will always have an empty list of submodules
+    # so we can just overwrite them without losing any data
+    modules = dict()  # type: ignore[var-annotated]
+    nodes = python_ast_objects_of_type(code, Import)
+    for node in nodes:
+        for alias in node.names:  # type: ignore[attr-defined]
+            modules[alias.name] = []
+
+    # Now for the ImportFrom nodes
+    importfrom_nodes = python_ast_objects_of_type(code, ImportFrom)
+    for node in importfrom_nodes:
+        module_name = _get_importfrom_module_name(node)  # type: ignore[arg-type]
+
+        for alias in node.names:  # type: ignore[attr-defined]
+            modules.setdefault(module_name, []).append(alias.name)
+
+    return modules