File size: 5,195 Bytes
712b117 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | import functools
from importlib.metadata import entry_points
from functools import cache
import os
import warnings
def dispatching_disabled():
"""Determine if dispatching has been disabled by the user."""
no_dispatching = os.environ.get("SKIMAGE_NO_DISPATCHING", False)
if no_dispatching == "1":
return True
else:
return False
def public_api_module(func):
"""Get the name of the public module for a scikit-image function.
This computes the name of the public submodule in which the function can
be found.
"""
full_name = func.__module__
# This relies on the fact that scikit-image does not use
# sub-submodules in its public API, except in one case.
# This means that public name can be atmost `skimage.foobar`
# for everything else
sub_submodules = ["skimage.filters.rank"]
candidates = [name for name in sub_submodules if full_name.startswith(name)]
if len(candidates) == 0:
# Assume first two parts of the name are where the function is in our public API
parts = full_name.split(".")
if len(parts) <= 2:
msg = f"expected {func.__module__=} with more than 2 dot-delimited parts"
raise ValueError(msg)
public_name = ".".join(parts[:2])
elif len(candidates) == 1:
public_name = candidates[0]
else:
msg = f"{func!r} matches more than one sub-submodule: {candidates!r}"
raise ValueError(msg)
# It would be nice to sanity check things by doing something like the
# following. However we can't because this code is executed while the
# module is being imported, which means this would create a circular
# import
# mod = importlib.import_module(public_name)
# assert getattr(mod, func.__name__) is func
return public_name
@cache
def all_backends():
"""List all installed backends and information about them."""
backends = {}
backends_ = entry_points(group="skimage_backends")
backend_infos = entry_points(group="skimage_backend_infos")
for backend in backends_:
backends[backend.name] = {"implementation": backend}
try:
info = backend_infos[backend.name]
# Double () to load and then call the backend information function
backends[backend.name]["info"] = info.load()()
except KeyError:
pass
return backends
def dispatchable(func):
"""Mark a function as dispatchable.
When a decorated function is called, the installed backends are
searched for an implementation. If no backend implements the function
then the scikit-image implementation is used.
"""
func_name = func.__name__
func_module = public_api_module(func)
# If no backends are installed at all or dispatching is disabled,
# return the original function. This way people who don't care about it
# don't see anything related to dispatching
if dispatching_disabled() or not all_backends():
return func
@functools.wraps(func)
def wrapper(*args, **kwargs):
# Backends are tried in alphabetical order, this makes things
# predictable and stable across runs. Might need a better solution
# when it becomes common that users have more than one backend
# that would accept a call.
for name in sorted(all_backends()):
backend = all_backends()[name]
# Check if the function we are looking for is implemented in
# the backend
if f"{func_module}:{func_name}" not in backend["info"].supported_functions:
continue
backend_impl = backend["implementation"].load()
# Allow the backend to accept/reject a call based on the function
# name and the arguments
wants_it = backend_impl.can_has(
f"{func_module}:{func_name}", *args, **kwargs
)
if not wants_it:
continue
func_impl = backend_impl.get_implementation(f"{func_module}:{func_name}")
warnings.warn(
f"Call to '{func_module}:{func_name}' was dispatched to"
f" the '{name}' backend. Set SKIMAGE_NO_DISPATCHING=1 to"
" disable this.",
DispatchNotification,
# XXX from where should this warning originate?
# XXX from where the function that was dispatched was called?
# XXX or from where the user called a function that called
# XXX a function that was dispatched?
stacklevel=2,
)
return func_impl(*args, **kwargs)
else:
return func(*args, **kwargs)
return wrapper
class BackendInformation:
"""Information about a backend
A backend that wants to provide additional information about itself
should return an instance of this from its information entry point.
"""
def __init__(self, supported_functions):
self.supported_functions = supported_functions
class DispatchNotification(RuntimeWarning):
"""Notification issued when a function is dispatched to a backend."""
pass
|