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 notintendedforserioussoftwareengineeringsituations. 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.
fromimportallimportimportallimportall(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:
fromimportallimportget_all_symbolssymbol_table=get_all_symbols() symbol_table["python_implementation"]() # "CPython"symbol_table["getrecursionlimit"]() # 1000symbol_table["log2"](2) # 1.0To recover the globals() and de-import all imported names, use the deimportall() function:
fromimportallimportdeimportall, importallimportall(globals()) log2(2) # 1.0deimportall(globals()) log2(2) # NameErrorThe doc and API of the importall() function:
defimportall( 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.