Dynamic Import 2024.5.2 | GitLocker.com Product

Description:

dynamicimport 2024.5.2

Dynamic Import
Let Dynamic Import handle your projects(package) import needs. Enables you to dynamically(lazily)
import module as needed within the project and for external usage on run-time.

Place importer() into top __init__.py file and forget about where
variable, function, class, … are located.
Just call from <package> import <variable> while coding and when end-user calls from your
project. All names are accessible at top level, easy to remember.
Move/rename file within your project? No problem, auto updates.
Supports .py and .so (experimental)
Saves memory(for medium to large projects).

Ultimate worry free management comfort as your project grows from small to large.

Requires

Python 3.8+
Linux, MacOS

Install, update & uninstall
Use pip to:
python3 -m pip install dynamic-import # install

python3 -m pip install --upgrade dynamic-import # update

python3 -m pip uninstall dynamic-import # uninstall

Install directly from GitHub
python3 -m pip install --upgrade git+https://github.com/YoSTEALTH/Dynamic-Import

Usage
# ./<package>/__init__.py
from dynamic_import import importer

importer()

importer() options
importer(cache=False) # disable & remove cache file (for temporary use only!)

importer(recursive=False) # do not scan sub-directories

# exclude `.py, .so` file
importer(exclude_file='file.py') # single
importer(exclude_file=('one.py', 'sub-dir/two.py', ...)) # multiple

# exclude sub-directory
importer(exclude_dir='sub-dir') # single
importer(exclude_dir=('sub-dir', 'sub/sub-dir', ...)) # multiple

Example
# ./example/pkg/__init__.py
from dynamic_import import importer

__version__ = '1.2.3' # if need to use special name place it above `importer()`

importer() # only need to call `importer()` once inside main `__init__.py` file.

# note: `importer()` will scan all package directory and sub-directories for `.py, .so`
# files and cache import names for dynamic use.
# ./example/pkg/var.py
import sys

# just like normal import if `__all__` is not defined, `my_var` will be included.
# Also `sys` will not be included.

my_var = sys.version_info.major
# ./example/pkg/functions/myfunction.py
from pkg import my_var
# all import names are available at higher level,
# no need for `from ..example.var import my_var`

__all__ = 'my_function' # using just string for single name is ok

def my_function():
return my_var + 1
# ./example/classes/__init__.py

__all__ = ['MyClass']

class MyClass:
pass

Calling
# ./example/calling.py
# import all 3 names regardless of where module is located
from pkg import my_var, my_function, MyClass

# or
import pkg

MyClass()
print(my_var, pkg.my_var is my_var) # 3 True
print(my_function()) # 4
print(dir(pkg)) # ['my_var', 'my_function', 'MyClass', ...]

Note

Only need to call importer() once inside __init__.py file.
All sub-directories will be scanned for .py, .so file as recursive=True by default.
Use exclude_dir to list sub-directories you would like to avoid scanning.
You can still use normal static/relative import.
For one word import name you can use string
e.g. __all__ = 'function' vs __all__ = ('function',)
All import names must be unique.
Cache can be disabled & removed by using importer(cache=False)
Cached temporary files are stored in ./__pycache__/__init__.importer-<python-version>.pyc
You can move or rename any .py file within project directory or sub-directory and
import will not break.
Special name e.g: __something__ are ignored. If need to use special name place it
above importer() e.g.``__version__ = ‘1.2.3’; importer()``
Using from <package> import * is not recommended unless you want to load all the modules.
No need to have empty __init__.py inside sub-directories. Its “like” Namespace + Package
combined into one! but not technically.
Calling dir(<package>) enables you to show all importable names without loading modules.

Experimental

Having module name and function name the same is ok! e.g. from pkg import my_fun while
./pkg/my_fun.py and calling my_fun() will not conflict with module name. Module will
still load in the background.
importer() also works with certain .cpython-<...>.so .abi3.so file
(only tested with cython created *.so).
.so should not contain any function/class that auto-run on import e.g.``run_something()``
Visit Liburing to see project using Dynamic Import with .so files in action.

License
Free, Public Domain (CC0). Read more