ape.plugins

ape.plugins.register(plugin_type: Type[ape.plugins.pluggy_patch.PluginType], **hookimpl_kwargs) Callable

Register your plugin to ape. You must call this decorator to get your plugins included in ape’s plugin ecosystem.

Usage example:

@plugins.register(plugins.AccountPlugin)  # 'register()' example
def account_types():
    return AccountContainer, KeyfileAccount
Parameters
  • plugin_type (Type[PluginType]) – The plugin type to register.

  • hookimpl_kwargs – Return-values required by the plugin type.

Returns

Callable

Base

class ape.plugins.pluggy_patch.PluginType

Bases: object

The base plugin class in ape. There are several types of plugins available in ape, such as the Config or EcosystemPlugin. Each one of them subclass this class. It is used to namespace the plugin hooks for the registration process, and to ensure overall conformance to type interfaces as much as possible.

ape.plugins.pluggy_patch.plugin_manager = <pluggy.manager.PluginManager object>

A manager responsible for registering and accessing plugins (singleton).

Accounts

class ape.plugins.account.AccountPlugin

Bases: ape.plugins.pluggy_patch.PluginType

An account-related plugin. The plugin must register both an ape.api.accounts.AccountContainerAPI as well as an ape.api.accounts.AccountAPI.

account_types() Tuple[Type[ape.api.accounts.AccountContainerAPI], Type[ape.api.accounts.AccountAPI]]

A hook for returning a tuple of an account container and an account type. Each account-base plugin defines and returns their own types here.

Usage example:

@plugins.register(plugins.AccountPlugin)
def account_types():
    return AccountContainer, KeyfileAccount
Returns

Tuple[Type[AccountContainerAPI], Type[AccountAPI]]

Compiler

class ape.plugins.compiler.CompilerPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin that implements the ape.api.CompilerAPI, such as the ape-solidity plugin or the ape-vyper plugin.

register_compiler() Tuple[Tuple[str], Type[ape.api.compiler.CompilerAPI]]

A hook for returning the set of file extensions the plugin handles and the compiler class that can be used to compile them.

Usage example:

@plugins.register(plugins.CompilerPlugin)
def register_compiler():
    return (".json",), InterfaceCompiler
Returns

Tuple[Tuple[str], Type[CompilerAPI]]

Config

class ape.plugins.config.Config

Bases: ape.plugins.pluggy_patch.PluginType

A registered config item. Plugins register config implementations when they allow additional user-configuration, set in the ape-config.yaml. See the ConfigManager documentation for more information on the ape-config.yaml.

config_class() Type[ape.api.config.PluginConfig]

A hook that returns a PluginConfig parser class that can be used to deconstruct the user config options for this plugins.

NOTE: If none are specified, all injected ape.api.config.PluginConfig’s are empty.

Usage example:

@plugins.register(plugins.Config)
def config_class():
    return MyPluginConfig
Returns

Type[PluginConfig]

Converter

class ape.plugins.converter.ConversionPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin for converting values. The ape-ens plugin is an example of a conversion-plugin.

converters() Iterator[Tuple[str, Type[ape.api.convert.ConverterAPI]]]

A hook that returns an iterator of tuples of a string ABI type and a ConverterAPI subclass.

Usage example:

@plugins.register(plugins.ConversionPlugin)
def converters():
    yield int, MweiConversions
Returns

Iterator[tuple[str, Type[ConverterAPI]]]

Network

class ape.plugins.network.EcosystemPlugin

Bases: ape.plugins.pluggy_patch.PluginType

An ecosystem plugin, such as ape-ethereum. See the ape.api.networks.EcosystemAPI for more information on what is required to implement an ecosystem plugin.

ecosystems() Iterator[Type[ape.api.networks.EcosystemAPI]]

A hook that must return an iterator of ape.api.networks.EcosystemAPI subclasses.

Usage example:

@plugins.register(plugins.EcosystemPlugin)
def ecosystems():
    yield Ethereum
Returns

Iterator[Type[EcosystemAPI]]

class ape.plugins.network.ExplorerPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin for a blockchain explorer, such as ape-etherscan.

explorers() Iterator[Tuple[str, str, Type[ape.api.explorers.ExplorerAPI]]]

A hook that must return an iterator of tuples of:

  • the target ecosystem plugin’s name

  • the network it works with (which must be valid network in the ecosystem)

  • a ExplorerAPI subclass

Usage example:

@plugins.register(plugins.ExplorerPlugin)
def explorers():
    yield "ethereum", "mainnet", MyBlockExplorer
Returns

Iterator[tuple[str, str, Type[ape.api.explorers.ExplorerAPI]]]

class ape.plugins.network.NetworkPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A network plugin, such as mainnet or ropsten. Likely, registering networks will happen soon after registering the ecosystem, as an ecosystem requires networks.

networks() Iterator[Tuple[str, str, Type[ape.api.networks.NetworkAPI]]]

A hook that must return an iterator of tuples of:

Usage example:

@plugins.register(plugins.NetworkPlugin)
def networks():
    yield "ethereum", "ShibaChain", ShibaNetwork
Returns

Iterator[tuple[str, str, Type[NetworkAPI]]]

class ape.plugins.network.ProviderPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin representing a network provider, which is the main API responsible for making requests against a blockchain. Example provider plugins projects include ape-infura as well as ape-alchemy.

providers() Iterator[Tuple[str, str, Type[ape.api.providers.ProviderAPI]]]

A hook that must return an iterator of tuples of:

  • the target ecosystem plugin’s name

  • the network it works with (which must be valid network in the ecosystem)

  • a ape.api.providers.ProviderAPI subclass

Usage example:

@plugins.register(plugins.ProviderPlugin)
def providers():
    yield "ethereum", "local", MyProvider
Returns

Iterator[tuple[str, str, Type[ProviderAPI]]]

Project

class ape.plugins.project.DependencyPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin for downloading packages and creating ProjectPlugin implementations.

dependencies() Dict[str, Type[ape.api.projects.DependencyAPI]]

A hook that returns a DependencyAPI mapped to its ape-config.yaml file dependencies special key. For example, when configuring GitHub dependencies, you set the github key in the dependencies: block of your ape-config.yaml file and it will automatically use this DependencyAPI implementation.

Returns

Type[DependencyAPI]

class ape.plugins.project.ProjectPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin for converting files to a PackageManifest. The default project plugin is the ApeProject. Otherwise, you can define your own project implementation for converting a set of files to a PackageManifest, such as one that resolves dependencies via .gitmodules.

projects() Iterator[Type[ape.api.projects.ProjectAPI]]

A hook that returns a ProjectAPI subclass type.

Returns

Type[ProjectAPI]

Query

class ape.plugins.query.QueryPlugin

Bases: ape.plugins.pluggy_patch.PluginType

A plugin for querying chains.

query_engines() Iterator[Type[QueryAPI]]

A hook that returns an iterator of types of a QueryAPI subclasses

Usage example:

@plugins.register(plugins.QueryPlugin)
def query_engines():
    yield PostgresEngine
Returns

Iterator[Type[QueryAPI]]