entrypointer 1.0.3

Looking Up an Entrypoint

We’ll begin with an example. Let’s say your application looks for an entrypoint named “hook” in the entrypoint group “example_app.example_group”. This can be as simple as:

hook = entrypointer.eps.example_app.example_group['hook']

If the named entrypoint doesn’t exist, this will raise a KeyError, but you can use the get() method to return something else instead:

hook = entrypointer.eps.example_app.example_group.get('hook')

For a hook method, your application may actually prefer to call all defined hooks. This can be accomplished like so:

for hook in entrypointer.eps.example_app.example_group.get_all('hook', []):
    hook('calling your hook')

Some applications may wish to use entrypoint group names that happen to not be valid Python identifiers, e.g., “Example App.Example Group”. This can be accomplished with a simple getattr() call on entrypoint.eps:

group = getattr(entrypointer.eps, 'Example App.Example Group')

The only restriction on a group name is that no component can start with a leading underscore (‘_’).

Using Entrypoints without entrypointer.eps

The entrypointer.eps object is provided for convenience; it is not required to be used. To obtain a dictionary-like object for an entrypoint group, simply instantiate the entrypointer.EntrypointDict class:

group = entrypointer.EntrypointDict('example_app.example_group')
hooks = group.get_all('hook')

This class provides all of the basic dict methods, such as keys() and values(). It also provides variants, such as items_all(), which yield list-like objects of entrypoints. This allows use of entrypoints for a wide variety of effects, such as the “hook” pattern demonstrated above, or for extending commands your application makes available, or for a variety of other uses.

Obtaining a List of Entrypoints

Although it is recommended to use the entrypointer.EntrypointDict class for accessing entrypoints, it is possible to use the list-like object, entrypointer.EntrypointList, directly. It is instantiated with the entrypoint group name and the name of the entrypoint itself, e.g.:

hooks = entrypointer.EntrypointList('example_app.example_group', 'hook')

Efficiency Considerations

The pkg_resources.iter_entry_points() function is somewhat slow. The entrypointer.EntrypointList and entrypointer.EntrypointDict classes are designed to call it as few times as possible and cache the results for future use. Further, they are optimized for the common case of using the first entrypoint with a given name; they stop loading entrypoints after the first one that loads successfully. Finally, these classes do their work lazily, calling pkg_resources.iter_entry_points() only when necessary to implement the method being called. This causes the expense of using entrypoints to be amortized over the lifetime of the application, while still maintaining a high speed due to the caching. However, one side effect of this caching is that changes to the installed packages that would be picked up by calling pkg_resources.iter_entry_points() will not be detected when using entrypointer; if this is important to your application, you may want to call the entrypointer.EntrypointDict and entrypoint.EntrypointList classes directly and discard them when you are done; note that this will reduce the efficiency, as they will need to call pkg_resources.iter_entry_points() more frequently.