importall is a lightweight and robust library to import every available names from standard libraries to the current namespace, i.e., a Python equivalent to C++'s <bits/stdc++.h>.
It's definitely not intended for serious software engineering situations. It's useful and convenient for interactive consoles, and some niche scenarios, such as competitive programming contests, under which situation saving some typing strokes and hence precious time is highly desirable. Also convenient when just prototyping, testing back-of-envelop thoughts, or tinkering with ideas on playground. Save the time and tedious chores spent on typing all the necessary modules, which could be annoying, boring and typo-prone.
Call the importall() function, with the globals() passed in as argument, then all names are imported to the current namespace.
from importall import importall
importall(globals())
list(combinations("ABCD", 2))
# [("A", "B"), ("A", "C"), ("A", "D"), ("B", "C"), ("B", "D"), ("C", "D")]
nlargest(4, [48, 5, 21, 38, 65, 12, 27, 18])
# [65, 48, 38, 27]Note that local() should not be passed to importall(), as locals() is intended as readonly per doc.
The importall() function also provides several parameters for finer-grained configuration, enabling more flexible and customizable options.
More than likely, names imported from different standard libraries might collides. The name collision is resolvable by tuning the prioritized and ignore parameters.
Say, a user finds that he wants to use compress from the lzma module instead of that from the zlib module. He could either set higher priority for the lzma module through the prioritized parameter, or ignore the zlib module altogether through the ignore parameter.
importall(globals())
compress.__module__
# "zlib"
importall(globals(), prioritized=["lzma"])
# Alternatives:
# importall(globals(), prioritized={"lzma": 1, "zlib": -1})
# importall(globals(), ignore=["zlib"])
compress.__module__
# "lzma"If one prefers getting all importable names stored as a variable instead of importing them into the current namespace, so as to avoid cluttering the globals() namespace, there is also a programmatic interface for doing so:
from importall import get_all_symbols
symbol_table = get_all_symbols()
symbol_table["python_implementation"]()
# "CPython"
symbol_table["getrecursionlimit"]()
# 1000
symbol_table["log2"](2)
# 1.0To recover the globals() and de-import all imported names, use the deimportall() function:
from importall import deimportall, importall
importall(globals())
log2(2)
# 1.0
deimportall(globals())
log2(2)
# NameErrorThe doc and API of the importall() function:
def importall(
globals: SymbolTable,
*,
protect_builtins: bool = True,
include_deprecated: bool = False,
prioritized: Union[Iterable[str], Mapping[str, int]] = (),
ignore: Iterable[str] = (),
) -> None:
"""
Import every available names from standard libraries to the current namespace.
Python equivalent to C++'s <bits/stdc++.h>.
Name collision is likely. One can resolve name collisions by tuning the `prioritized`
and/or the `ignore` parameter. Names from the module with higher priority value will
override names from the module with lower priority value.
The `globals` parameter accepts a symbol table to populate. Usually the caller passes
in `globals()`.
By default, built-in names are protected from overriding. The protection can be switched
off by setting the `protect_builtins` parameter to `False`.
By default, deprecated modules and deprecated names are not imported. It is designed
so because deprecated modules and names hopefully should not be used anymore,
their presence only for easing the steepness of API changes and providing a progressive
cross-version migration experience. If you are sure you know what you are doing, override
the default behavior by setting the `include_deprecated` parameter to `True` (**not recommended**).
The `prioritized` parameter accepts either an iterable of strings specifying modules
whose priorities are set to 1, or a mapping object with string keys and integer values,
specifying respective priority values for corresponding modules. Valid priority value
is always integer. All modules default to 0 priority values. It's possible to specify
negative priority value.
The `ignore` parameter accepts an iterable of strings specifying modules that should
be skipped and not imported.
Despite imported, features in the `__future__` module are not enabled, as they are
not imported in the form of future statements (See the production rule for the
nonterminal `future_stmt` in https://docs.python.org/3/reference/simple_stmts.html#future-statements).
"""
...$ git clone https://github.com/MapleCCC/importall.git
$ cd importall
# Optionally create a virtual environment for isolation purpose
$ python3 -m virtualenv .venv
$ source .venv/bin/activate
# Install dependenies
$ python3 -m pip install -r requirements.txt
# Install dev dependenies
$ python3 -m pip install -r requirements-dev.txt
# Deploy pre-commit hooks
$ pre-commit install
$ python3 -m pip install -e .The importall project uses pytest for unit testing.
# Install test dependenies
$ python3 -m pip install -r requirements-test.txt
$ make testWe use the lists maintained by the stdlib-list library instead of that by the isort library or that of sys.stdlib_module_names, for they don't include sub-packages and sub-modules, such as concurrent.futures.
One can compare the two lists:
Contributions are welcome. Open issues or pull requests.
- no-one-left-behind, by Zalastax.
- ...
The source code of the importall library is currently licensed under the terms of the MIT license. Feel free to contribute, fork, modify, or redistribute.