def register_test_entry_point():
test_resource_file = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'resources/entry_points.py'))
distribution = pkg_resources.Distribution.from_filename(test_resource_file)
entry_point = pkg_resources.EntryPoint(
'foo', 'ospurge.tests.resources.entry_points', dist=distribution)
distribution._ep_map = {utils.ENTRY_POINTS_NAME: {'foo': entry_point}}
pkg_resources.working_set.add(distribution, 'foo')
return entry_point
def setUp(self):
self.plugin_ep = mock.MagicMock()
self.plugin_ep.name = "mock"
self.plugin_ep.__hash__.side_effect = TypeError
self.plugins = {self.plugin_ep.name: self.plugin_ep}
self.reg = self._create_new_registry(self.plugins)
self.ep1 = pkg_resources.EntryPoint("ep1",
"p1.ep1",
dist=mock.MagicMock(key="p1"))
def setUp(self):
self.ep1 = pkg_resources.EntryPoint("ep1",
"p1.ep1",
dist=mock.MagicMock(key="p1"))
self.ep1prim = pkg_resources.EntryPoint("ep1",
"p2.ep2",
dist=mock.MagicMock(key="p2"))
# nested
self.ep2 = pkg_resources.EntryPoint("ep2",
"p2.foo.ep2",
dist=mock.MagicMock(key="p2"))
# project name != top-level package name
self.ep3 = pkg_resources.EntryPoint("ep3",
"a.ep3",
dist=mock.MagicMock(key="p3"))
from certbot.plugins.disco import PluginEntryPoint
self.plugin_ep = PluginEntryPoint(EP_SA)
def test_generate_script_validates_expectations(self):
group = 'console_scripts'
entry_point = pkg_resources.EntryPoint(
name='test-ep',
module_name='pbr.packaging')
header = '#!/usr/bin/env fake-header\n'
template = ('%(group)s %(module_name)s %(import_target)s '
'%(invoke_target)s')
self.assertRaises(
ValueError, packaging.generate_script, group, entry_point, header,
template)
entry_point = pkg_resources.EntryPoint(
name='test-ep',
module_name='pbr.packaging',
attrs=('attr1', 'attr2', 'attr3'))
self.assertRaises(
ValueError, packaging.generate_script, group, entry_point, header,
template)
def default_entry_point():
"""
Return a default orange.widgets entry point for loading
default Orange Widgets.
"""
dist = pkg_resources.get_distribution("Orange3")
ep = pkg_resources.EntryPoint("Orange Widgets", "Orange.widgets",
dist=dist)
return ep
def widgets_entry_points():
"""
Return an `EntryPoint` iterator for all 'orange.widget' entry
points plus the default Orange Widgets.
"""
dist = pkg_resources.get_distribution("Orange")
ep = pkg_resources.EntryPoint("Orange Widgets", "Orange.widgets",
dist=dist)
return iter((ep,) +
tuple(pkg_resources.iter_entry_points(WIDGETS_ENTRY)))
def test_examples_order(self):
# register test entrypoints
dist_orange = pkg_resources.working_set.by_key['orange3']
ep_map = dist_orange.get_entry_map()
ep_first = pkg_resources.EntryPoint(
'!Testname', 'orangecontrib.any_addon.tutorials')
ep_last = pkg_resources.EntryPoint(
'exampletutorials', 'orangecontrib.other_addon.tutorials')
ep_map['orange.widgets.tutorials'] = {
ep_first.name: ep_first,
ep_last.name: ep_last
}
ep_names = [point.name for point in Config.examples_entry_points()]
self.assertLess(ep_names.index(ep_first.name),
ep_names.index("000-Orange3"))
self.assertLess(ep_names.index("000-Orange3"),
ep_names.index(ep_last.name))
del ep_map['orange.widgets.tutorials']
def test_entrypoint_tolerance(self):
# loosely based on Pandas test from:
# https://github.com/pandas-dev/pandas/pull/27488
# FIXME: Python 2 workaround because nonlocal doesn't exist
counters = {"init": 0}
def init_function():
counters["init"] += 1
raise ValueError("broken")
mod = types.ModuleType("_test_numba_bad_extension")
mod.init_func = init_function
try:
# will remove this module at the end of the test
sys.modules[mod.__name__] = mod
# We are registering an entry point using the "numba" package
# ("distribution" in pkg_resources-speak) itself, though these are
# normally registered by other packages.
dist = "numba"
entrypoints = pkg_resources.get_entry_map(dist)
my_entrypoint = pkg_resources.EntryPoint(
"init", # name of entry point
mod.__name__, # module with entry point object
attrs=["init_func"], # name of entry point object
dist=pkg_resources.get_distribution(dist),
)
entrypoints.setdefault("numba_extensions", {})["init"] = my_entrypoint
from numba.core import entrypoints
# Allow reinitialization
entrypoints._already_initialized = False
with warnings.catch_warnings(record=True) as w:
entrypoints.init_all()
bad_str = "Numba extension module '_test_numba_bad_extension'"
for x in w:
if bad_str in str(x):
break
else:
raise ValueError("Expected warning message not found")
# was our init function called?
self.assertEqual(counters["init"], 1)
finally:
# remove fake module
if mod.__name__ in sys.modules:
del sys.modules[mod.__name__]
def test_get_versions_with_plugins(monkeypatch):
import nose
import pkg_resources
monkeypatch.setattr(nose, '__version__', '1.2.3')
dist = pkg_resources.Distribution(project_name='myPlugin', version='4.5.6')
ep = pkg_resources.EntryPoint('name', 'module_name', dist=dist)
monkeypatch.setattr(
pkg_resources, 'iter_entry_points', lambda ept:
(x for x in (ep, ) if ept == nose.plugins.manager.
EntryPointPluginManager.entry_points[0][0]))
runner = NoseRunner(None)
assert runner.get_versions() == ['nose 1.2.3', ' myPlugin 4.5.6']
def examples_entry_points():
# type: () -> Iterable[pkg_resources.EntryPoint]
"""
Return an iterator over the entry points yielding 'Example Workflows'
"""
# `iter_entry_points` yields them in unspecified order, so we insert
# our first
try:
default_ep = pkg_resources.EntryPoint(
"Orange3",
"Orange.canvas.workflows",
dist=pkg_resources.get_distribution("Orange3-zh"))
except pkg_resources.DistributionNotFound:
default_ep = pkg_resources.EntryPoint(
"Orange3",
"Orange.canvas.workflows",
dist=pkg_resources.get_distribution("Orange3"))
return itertools.chain(
(default_ep, ),
pkg_resources.iter_entry_points("orange.widgets.tutorials"))
def setup(self):
dist = pkg_resources.get_distribution("pandas")
spec = importlib.machinery.ModuleSpec("my_backend", None)
mod = importlib.util.module_from_spec(spec)
mod.plot = lambda *args, **kwargs: 1
backends = pkg_resources.get_entry_map("pandas")
my_entrypoint = pkg_resources.EntryPoint("pandas_plotting_backend",
mod.__name__,
dist=dist)
backends["pandas_plotting_backends"][mod.__name__] = my_entrypoint
for i in range(10):
backends["pandas_plotting_backends"][str(i)] = my_entrypoint
sys.modules["my_backend"] = mod
def test_entrypoint_tolerance():
# FIXME: Python 2 workaround because nonlocal doesn't exist
counters = {"init": 0}
def init_function():
counters["init"] += 1
raise ValueError("broken")
mod = types.ModuleType("_test_mars_bad_extension")
mod.init_func = init_function
try:
# will remove this module at the end of the test
sys.modules[mod.__name__] = mod
# We are registering an entry point using the "mars" package
# ("distribution" in pkg_resources-speak) itself, though these are
# normally registered by other packages.
dist = "pymars"
entrypoints = pkg_resources.get_entry_map(dist)
my_entrypoint = pkg_resources.EntryPoint(
"init", # name of entry point
mod.__name__, # module with entry point object
attrs=["init_func"], # name of entry point object
dist=pkg_resources.get_distribution(dist),
)
entrypoints.setdefault("mars_extensions", {})["init"] = my_entrypoint
from .. import entrypoints
# Allow reinitialization
entrypoints.init_extension_entrypoints.cache_clear()
with warnings.catch_warnings(record=True) as w:
entrypoints.init_extension_entrypoints()
bad_str = "Mars extension module '_test_mars_bad_extension'"
for x in w:
if bad_str in str(x):
break
else:
raise ValueError("Expected warning message not found")
# was our init function called?
assert counters["init"] == 1
finally:
# remove fake module
if mod.__name__ in sys.modules:
del sys.modules[mod.__name__]
def test_generate_script(self):
group = 'console_scripts'
entry_point = pkg_resources.EntryPoint(name='test-ep',
module_name='pbr.packaging',
attrs=('LocalInstallScripts', ))
header = '#!/usr/bin/env fake-header\n'
template = ('%(group)s %(module_name)s %(import_target)s '
'%(invoke_target)s')
generated_script = packaging.generate_script(group, entry_point,
header, template)
expected_script = (
'#!/usr/bin/env fake-header\nconsole_scripts pbr.packaging '
'LocalInstallScripts LocalInstallScripts')
self.assertEqual(expected_script, generated_script)
def test_init_entrypoint(self):
# loosely based on Pandas test from:
# https://github.com/pandas-dev/pandas/pull/27488
# FIXME: Python 2 workaround because nonlocal doesn't exist
counters = {'init': 0}
def init_function():
counters['init'] += 1
mod = types.ModuleType("_test_numba_extension")
mod.init_func = init_function
try:
# will remove this module at the end of the test
sys.modules[mod.__name__] = mod
# We are registering an entry point using the "numba" package
# ("distribution" in pkg_resources-speak) itself, though these are
# normally registered by other packages.
dist = "numba"
entrypoints = pkg_resources.get_entry_map(dist)
my_entrypoint = pkg_resources.EntryPoint(
"init", # name of entry point
mod.__name__, # module with entry point object
attrs=['init_func'], # name of entry point object
dist=pkg_resources.get_distribution(dist)
)
entrypoints.setdefault('numba_extensions',
{})['init'] = my_entrypoint
import numba.entrypoints
# Allow reinitialization
numba.entrypoints._already_initialized = False
numba.entrypoints.init_all()
# was our init function called?
self.assertEqual(counters['init'], 1)
# ensure we do not initialize twice
numba.entrypoints.init_all()
self.assertEqual(counters['init'], 1)
finally:
# remove fake module
if mod.__name__ in sys.modules:
del sys.modules[mod.__name__]
def examples_entry_points():
# type: () -> Iterable[pkg_resources.EntryPoint]
"""
Return an iterator over the entry points yielding 'Example Workflows'
"""
# `iter_entry_points` yields them in unspecified order, so we order
# them by name. The default is at the beginning, unless another
# entrypoint precedes it alphabetically (e.g. starting with '!').
default_ep = pkg_resources.EntryPoint(
"000-Orange3",
"Orange.canvas.workflows",
dist=pkg_resources.get_distribution("Orange3"))
all_ep = list(
pkg_resources.iter_entry_points("orange.widgets.tutorials"))
all_ep.append(default_ep)
all_ep.sort(key=lambda x: x.name)
return iter(all_ep)
def test_init_entrypoint():
# FIXME: Python 2 workaround because nonlocal doesn't exist
counters = {"init": 0}
def init_function():
counters["init"] += 1
mod = types.ModuleType("_test_mars_extension")
mod.init_func = init_function
try:
# will remove this module at the end of the test
sys.modules[mod.__name__] = mod
# We are registering an entry point using the "mars" package
# ("distribution" in pkg_resources-speak) itself, though these are
# normally registered by other packages.
dist = "pymars"
entrypoints = pkg_resources.get_entry_map(dist)
my_entrypoint = pkg_resources.EntryPoint(
"init", # name of entry point
mod.__name__, # module with entry point object
attrs=["init_func"], # name of entry point object
dist=pkg_resources.get_distribution(dist),
)
entrypoints.setdefault("mars_extensions", {})["init"] = my_entrypoint
from .. import entrypoints
# Allow reinitialization
entrypoints.init_extension_entrypoints.cache_clear()
entrypoints.init_extension_entrypoints()
# was our init function called?
assert counters["init"] == 1
# ensure we do not initialize twice
entrypoints.init_extension_entrypoints()
assert counters["init"] == 1
finally:
# remove fake module
if mod.__name__ in sys.modules:
del sys.modules[mod.__name__]
def test_import_module_from_entrypoint(self):
config = {}
config["module_path"] = ""
config["name"] = "myep"
config["type"] = ""
config["module"] = ""
distro = pkg_resources.Distribution()
ep = pkg_resources.EntryPoint("myep", "os.path", dist=distro)
config["entrypoint"] = ep
opsdroid, loader = self.setup()
loader.modules_directory = "."
modules = {"myep": {}}
with mock.patch("opsdroid.loader.iter_entry_points") as mock_iter_entry_points:
mock_iter_entry_points.return_value = (ep,)
loaded = loader._load_modules("database", modules)
self.assertEqual(loaded[0]["config"]["name"], "myep")
def test_get_label_entrypoint(plugin_tmpfile):
# generate setuptools Distribution object
distrib_dir = os.path.dirname(plugin_tmpfile.strpath)
distrib = pkg_resources.Distribution(distrib_dir)
sys.path.append(distrib_dir)
# load the entry point
try:
entry_point = pkg_resources.EntryPoint(
'test_plugin', 'file_mod', dist=distrib)
plugin = handlers.EntryPointPlugin(entry_point)
plugin.load()
finally:
sys.path.remove(distrib_dir)
meta = plugin.get_meta_description()
assert meta['name'] == 'test_plugin'
assert meta['label'] == 'module label'
assert meta['type'] == handlers.EntryPointPlugin.PLUGIN_TYPE
assert meta['source'] == 'test_plugin = file_mod'
def test_register_backend_entrypoint():
# Code adapted from pandas backend entry point testing
# https://github.com/pandas-dev/pandas/blob/2470690b9f0826a8feb426927694fa3500c3e8d2/pandas/tests/plotting/test_backend.py#L50-L76
dist = pkg_resources.get_distribution("distributed")
if dist.module_path not in distributed.__file__:
# We are running from a non-installed distributed, and this test is invalid
pytest.skip("Testing a non-installed distributed")
mod = types.ModuleType("dask_udp")
mod.UDPBackend = lambda: 1
sys.modules[mod.__name__] = mod
entry_point_name = "distributed.comm.backends"
backends_entry_map = pkg_resources.get_entry_map("distributed")
if entry_point_name not in backends_entry_map:
backends_entry_map[entry_point_name] = dict()
backends_entry_map[entry_point_name]["udp"] = pkg_resources.EntryPoint(
"udp", mod.__name__, attrs=["UDPBackend"], dist=dist)
result = get_backend("udp")
assert result == 1
def test_find_importers_through_entry_points(mocker):
from passpie import importers
temp_dir = tempfile.mkdtemp()
sys.path.insert(0, temp_dir)
with open(os.path.join(temp_dir, 'fake_module.py'), 'w') as f:
f.write("""\
from passpie.importers import BaseImporter
class FakeKeepassImporterClass(BaseImporter):
pass
""")
import pkg_resources
fake_ep = pkg_resources.EntryPoint('fake_keepass',
'fake_module',
attrs=('FakeKeepassImporterClass', ))
mock_iter_entry_points = mocker.patch('pkg_resources.iter_entry_points',
return_value=iter([
fake_ep,
]))
try:
target_klass = None
for klass in importers._get_importers_from_entry_points():
if klass.__name__ == 'FakeKeepassImporterClass':
target_klass = klass
break
mock_iter_entry_points.assert_called_once_with('passpie_importers')
assert target_klass.__name__ == 'FakeKeepassImporterClass'
assert target_klass.__module__ == 'fake_module'
finally:
sys.path.remove(temp_dir)
shutil.rmtree(temp_dir, ignore_errors=True)
def test_register_entrypoint():
mod = types.ModuleType("my_backend")
mod.plot = lambda *args, **kwargs: 1
backends = pkg_resources.get_entry_map("pandas")
my_entrypoint = pkg_resources.EntryPoint(
"pandas_plotting_backend",
mod.__name__,
dist=pkg_resources.get_distribution("pandas"),
)
backends["pandas_plotting_backends"]["my_backend"] = my_entrypoint
# TODO: the docs recommend importlib.util.module_from_spec. But this works for now.
sys.modules["my_backend"] = mod
result = pandas.plotting._core._get_plot_backend("my_backend")
assert result is mod
# TODO: https://github.com/pandas-dev/pandas/issues/27517
# Remove the td.skip_if_no_mpl
with pandas.option_context("plotting.backend", "my_backend"):
result = pandas.plotting._core._get_plot_backend()
assert result is mod
def __init__(self,
cloud=None,
config=None,
session=None,
app_name=None,
app_version=None,
extra_services=None,
strict=False,
use_direct_get=False,
task_manager=None,
rate_limit=None,
oslo_conf=None,
service_types=None,
global_request_id=None,
strict_proxies=False,
**kwargs):
"""Create a connection to a cloud.
A connection needs information about how to connect, how to
authenticate and how to select the appropriate services to use.
The recommended way to provide this information is by referencing
a named cloud config from an existing `clouds.yaml` file. The cloud
name ``envvars`` may be used to consume a cloud configured via ``OS_``
environment variables.
A pre-existing :class:`~openstack.config.cloud_region.CloudRegion`
object can be passed in lieu of a cloud name, for cases where the user
already has a fully formed CloudRegion and just wants to use it.
Similarly, if for some reason the user already has a
:class:`~keystoneauth1.session.Session` and wants to use it, it may be
passed in.
:param str cloud: Name of the cloud from config to use.
:param config: CloudRegion object representing the config for the
region of the cloud in question.
:type config: :class:`~openstack.config.cloud_region.CloudRegion`
:param session: A session object compatible with
:class:`~keystoneauth1.session.Session`.
:type session: :class:`~keystoneauth1.session.Session`
:param str app_name: Name of the application to be added to User Agent.
:param str app_version: Version of the application to be added to
User Agent.
:param extra_services: List of
:class:`~openstack.service_description.ServiceDescription`
objects describing services that openstacksdk otherwise does not
know about.
:param bool use_direct_get:
For get methods, make specific REST calls for server-side
filtering instead of making list calls and filtering client-side.
Default false.
:param task_manager:
Ignored. Exists for backwards compat during transition. Rate limit
parameters should be passed directly to the `rate_limit` parameter.
:param rate_limit:
Client-side rate limit, expressed in calls per second. The
parameter can either be a single float, or it can be a dict with
keys as service-type and values as floats expressing the calls
per second for that service. Defaults to None, which means no
rate-limiting is performed.
:param oslo_conf: An oslo.config CONF object.
:type oslo_conf: :class:`~oslo_config.cfg.ConfigOpts`
An oslo.config ``CONF`` object that has been populated with
``keystoneauth1.loading.register_adapter_conf_options`` in
groups named by the OpenStack service's project name.
:param service_types:
A list/set of service types this Connection should support. All
other service types will be disabled (will error if used).
**Currently only supported in conjunction with the ``oslo_conf``
kwarg.**
:param global_request_id: A Request-id to send with all interactions.
:param strict_proxies:
If True, check proxies on creation and raise
ServiceDiscoveryException if the service is unavailable.
:type strict_proxies: bool
Throw an ``openstack.exceptions.ServiceDiscoveryException`` if the
endpoint for a given service doesn't work. This is useful for
OpenStack services using sdk to talk to other OpenStack services
where it can be expected that the deployer config is correct and
errors should be reported immediately.
Default false.
:param kwargs: If a config is not provided, the rest of the parameters
provided are assumed to be arguments to be passed to the
CloudRegion constructor.
"""
self.config = config
self._extra_services = {}
self._strict_proxies = strict_proxies
if extra_services:
for service in extra_services:
self._extra_services[service.service_type] = service
if not self.config:
if oslo_conf:
self.config = cloud_region.from_conf(
oslo_conf,
session=session,
app_name=app_name,
app_version=app_version,
service_types=service_types)
elif session:
self.config = cloud_region.from_session(
session=session,
app_name=app_name,
app_version=app_version,
load_yaml_config=False,
load_envvars=False,
rate_limit=rate_limit,
**kwargs)
else:
self.config = _config.get_cloud_region(cloud=cloud,
app_name=app_name,
app_version=app_version,
load_yaml_config=cloud
is not None,
load_envvars=cloud
is not None,
rate_limit=rate_limit,
**kwargs)
self._session = None
self._proxies = {}
self.__pool_executor = None
self._global_request_id = global_request_id
self.use_direct_get = use_direct_get
self.strict_mode = strict
# Call the _*CloudMixin constructors while we work on
# integrating things better.
_cloud._OpenStackCloudMixin.__init__(self)
_baremetal.BaremetalCloudMixin.__init__(self)
_block_storage.BlockStorageCloudMixin.__init__(self)
_clustering.ClusteringCloudMixin.__init__(self)
_coe.CoeCloudMixin.__init__(self)
_compute.ComputeCloudMixin.__init__(self)
_dns.DnsCloudMixin.__init__(self)
_floating_ip.FloatingIPCloudMixin.__init__(self)
_identity.IdentityCloudMixin.__init__(self)
_image.ImageCloudMixin.__init__(self)
_network_common.NetworkCommonCloudMixin.__init__(self)
_network.NetworkCloudMixin.__init__(self)
_object_store.ObjectStoreCloudMixin.__init__(self)
_orchestration.OrchestrationCloudMixin.__init__(self)
_security_group.SecurityGroupCloudMixin.__init__(self)
# Allow vendors to provide hooks. They will normally only receive a
# connection object and a responsible to register additional services
vendor_hook = kwargs.get('vendor_hook')
if not vendor_hook and 'vendor_hook' in self.config.config:
# Get the one from profile
vendor_hook = self.config.config.get('vendor_hook')
if vendor_hook:
try:
# NOTE(gtema): no class name in the hook, plain module:function
# Split string hook into module and function
try:
(package_name, function) = vendor_hook.rsplit(':')
if package_name and function:
import pkg_resources
ep = pkg_resources.EntryPoint('vendor_hook',
package_name,
attrs=(function, ))
hook = ep.resolve()
hook(self)
except ValueError:
self.log.warning('Hook should be in the entrypoint '
'module:attribute format')
except (ImportError, TypeError) as e:
self.log.warning('Configured hook %s cannot be executed: %s',
vendor_hook, e)
def test_entrypoint_handles_type_extensions(self):
# loosely based on Pandas test from:
# https://github.com/pandas-dev/pandas/pull/27488
import numba
def init_function():
# This init function would normally just call a module init via
# import or similar, for the sake of testing, inline registration
# of how to handle the global "_DummyClass".
class DummyType(numba.types.Type):
def __init__(self):
super(DummyType, self).__init__(name='DummyType')
@numba.extending.typeof_impl.register(_DummyClass)
def typer_DummyClass(val, c):
return DummyType()
@numba.extending.register_model(DummyType)
class DummyModel(numba.extending.models.StructModel):
def __init__(self, dmm, fe_type):
members = [
('value', numba.types.float64),
]
super(DummyModel, self).__init__(dmm, fe_type, members)
@numba.extending.unbox(DummyType)
def unbox_dummy(typ, obj, c):
value_obj = c.pyapi.object_getattr_string(obj, "value")
dummy_struct_proxy = numba.core.cgutils.create_struct_proxy(
typ)
dummy_struct = dummy_struct_proxy(c.context, c.builder)
dummy_struct.value = c.pyapi.float_as_double(value_obj)
c.pyapi.decref(value_obj)
err_flag = c.pyapi.err_occurred()
is_error = numba.core.cgutils.is_not_null(c.builder, err_flag)
return numba.extending.NativeValue(dummy_struct._getvalue(),
is_error=is_error)
@numba.extending.box(DummyType)
def box_dummy(typ, val, c):
dummy_struct_proxy = numba.core.cgutils.create_struct_proxy(
typ)
dummy_struct = dummy_struct_proxy(c.context, c.builder)
value_obj = c.pyapi.float_from_double(dummy_struct.value)
serialized_clazz = c.pyapi.serialize_object(_DummyClass)
class_obj = c.pyapi.unserialize(serialized_clazz)
res = c.pyapi.call_function_objargs(class_obj, (value_obj, ))
c.pyapi.decref(value_obj)
c.pyapi.decref(class_obj)
return res
mod = types.ModuleType("_test_numba_init_sequence")
mod.init_func = init_function
try:
# will remove this module at the end of the test
sys.modules[mod.__name__] = mod
# We are registering an entry point using the "numba" package
# ("distribution" in pkg_resources-speak) itself, though these are
# normally registered by other packages.
dist = "numba"
entrypoints = pkg_resources.get_entry_map(dist)
my_entrypoint = pkg_resources.EntryPoint(
"init", # name of entry point
mod.__name__, # module with entry point object
attrs=['init_func'], # name of entry point object
dist=pkg_resources.get_distribution(dist))
entrypoints.setdefault('numba_extensions',
{})['init'] = my_entrypoint
@njit
def foo(x):
return x
ival = _DummyClass(10)
foo(ival)
finally:
# remove fake module
if mod.__name__ in sys.modules:
del sys.modules[mod.__name__]
"""Tests for certbot.plugins.disco."""
import unittest
import mock
import pkg_resources
import six
import zope.interface
from certbot import errors
from certbot import interfaces
from certbot.plugins import standalone
from certbot.plugins import webroot
EP_SA = pkg_resources.EntryPoint("sa",
"certbot.plugins.standalone",
attrs=("Authenticator", ),
dist=mock.MagicMock(key="certbot"))
EP_WR = pkg_resources.EntryPoint("wr",
"certbot.plugins.webroot",
attrs=("Authenticator", ),
dist=mock.MagicMock(key="certbot"))
class PluginEntryPointTest(unittest.TestCase):
"""Tests for certbot.plugins.disco.PluginEntryPoint."""
def setUp(self):
self.ep1 = pkg_resources.EntryPoint("ep1",
"p1.ep1",
dist=mock.MagicMock(key="p1"))
self.ep1prim = pkg_resources.EntryPoint("ep1",
"p2.ep2",
def add_entry_point(self, group_name, name, the_class):
entry = pkg_resources.EntryPoint(name,
the_class.__module__,
attrs=(the_class.__name__, ),
dist=self)
self.entry_points[(group_name, entry.name)] = entry
def mock_iter_entry_points(_t, name=None):
return [pkg_resources.EntryPoint("fake", "fake", ["fake"])]
def fake_entries(group):
yield pkg_resources.EntryPoint('name1', 'pytest', ('raises',))
def dispatch(self,
component_type,
xml_parent,
component,
template_data={}):
"""This is a method that you can call from your implementation of
Base.gen_xml or component. It allows modules to define a type
of component, and benefit from extensibility via Python
entry points and Jenkins Job Builder :ref:`Macros <macro>`.
:arg string component_type: the name of the component
(e.g., `builder`)
:arg YAMLParser parser: the global YAML Parser
:arg Element xml_parent: the parent XML element
:arg dict template_data: values that should be interpolated into
the component definition
See :py:class:`jenkins_jobs.modules.base.Base` for how to register
components of a module.
See the Publishers module for a simple example of how to use
this method.
"""
if component_type not in self.modules_by_component_type:
raise JenkinsJobsException("Unknown component type: "
"'{0}'.".format(component_type))
entry_point = self.modules_by_component_type[component_type]
component_list_type = self.get_component_list_type(entry_point)
if isinstance(component, dict):
# The component is a singleton dictionary of name: dict(args)
name, component_data = next(iter(component.items()))
if template_data or isinstance(component_data, Jinja2Loader):
# Template data contains values that should be interpolated
# into the component definition. To handle Jinja2 templates
# that don't contain any variables, we also deep format those.
try:
component_data = deep_format(
component_data,
template_data,
self.jjb_config.yamlparser["allow_empty_variables"],
)
except Exception:
logging.error(
"Failure formatting component ('%s') data '%s'",
name,
component_data,
)
raise
else:
# The component is a simple string name, eg "run-tests"
name = component
component_data = {}
# Look for a component function defined in an entry point
eps = self._entry_points_cache.get(component_list_type)
if eps is None:
logging.debug("Caching entrypoints for %s" % component_list_type)
module_eps = []
# auto build entry points by inferring from base component_types
mod = pkg_resources.EntryPoint("__all__",
entry_point.module_name,
dist=entry_point.dist)
Mod = mod.load()
func_eps = [
Mod.__dict__.get(a) for a in dir(Mod)
if isinstance(Mod.__dict__.get(a), types.FunctionType)
]
for func_ep in func_eps:
try:
# extract entry point based on docstring
name_line = func_ep.__doc__.split("\n")
if not name_line[0].startswith("yaml:"):
logger.debug("Ignoring '%s' as an entry point" %
name_line)
continue
ep_name = name_line[0].split(" ")[1]
except (AttributeError, IndexError):
# AttributeError by docstring not being defined as
# a string to have split called on it.
# IndexError raised by name_line not containing anything
# after the 'yaml:' string.
logger.debug("Not including func '%s' as an entry point" %
func_ep.__name__)
continue
module_eps.append(
pkg_resources.EntryPoint(
ep_name,
entry_point.module_name,
dist=entry_point.dist,
attrs=(func_ep.__name__, ),
))
logger.debug(
"Adding auto EP '%s=%s:%s'" %
(ep_name, entry_point.module_name, func_ep.__name__))
# load from explicitly defined entry points
module_eps.extend(
list(
pkg_resources.iter_entry_points(
group="jenkins_jobs.{0}".format(component_list_type))))
eps = {}
for module_ep in module_eps:
if module_ep.name in eps:
raise JenkinsJobsException(
"Duplicate entry point found for component type: "
"'{0}', '{0}',"
"name: '{1}'".format(component_type, name))
eps[module_ep.name] = module_ep.load()
# cache both sets of entry points
self._entry_points_cache[component_list_type] = eps
logger.debug("Cached entry point group %s = %s",
component_list_type, eps)
# check for macro first
component = self.parser_data.get(component_type, {}).get(name)
if component:
if name in eps and name not in self.masked_warned:
self.masked_warned[name] = True
logger.warning("You have a macro ('%s') defined for '%s' "
"component type that is masking an inbuilt "
"definition" % (name, component_type))
for b in component[component_list_type]:
# Pass component_data in as template data to this function
# so that if the macro is invoked with arguments,
# the arguments are interpolated into the real defn.
self.dispatch(component_type, xml_parent, b, component_data)
elif name in eps:
func = eps[name]
func(self, xml_parent, component_data)
else:
raise JenkinsJobsException("Unknown entry point or macro '{0}' "
"for component type: '{1}'.".format(
name, component_type))
def default_entry_point():
dist = pkg_resources.get_distribution("Orange")
ep = pkg_resources.EntryPoint("Orange Canvas", __name__, dist=dist)
return ep
import sys
import os
import shlex
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('.'))
import pygments
import pkg_resources
distrib = pkg_resources.Distribution('.', {}, 'khufulexer', '1.0')
distrib.get_entry_map().update({'pygments.lexers':
{'khufu': pkg_resources.EntryPoint('khufu', 'khufulexer',
attrs=('KhufuLexer',), dist=distrib)}})
pkg_resources.working_set.add(distrib)
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = []
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
