Skip to main content

Library for building modular applications

Project description

pipeline status coverage report PyPI Status PyPI Version PyPI Python PyPI License PyPI Format


pip install applipy

Applipy lets you:

  • implement self-contained or interdependant Modules that you can tell applipy to load for the application through the config file
  • implement AppHandles: instances that implement application lifecycle methods
  • modules can register multiple AppHandles that will be run concurrently
  • load your application from a configuration file
  • you can have multiple configuration file (i.e. one per environment: local, dev, prod, staging, etc.)
  • tell applipy which environment to load through an environment variable APPLIPY_ENV
  • applipy will gracefully manage the lifecycle of your application
  • define protocol handlers for a given URI scheme in configuration values. With these you can implement secrets that can be accessed by the application through the configuration.


An application can be defined by using a JSON (or YAML, if pyyaml is installed).

# dev.yaml
  name: demo
    - applipy_http.HttpModule
    - applipy_prometheus.PrometheusModule

logging.level: DEBUG

  port: 8080

Save a file dev.yaml with the contents in the snipet above and run the following commands:

$ pip install pyyaml applipy applipy_http applipy_prometheus
$ applipy

The configuration file above defines an application named demo that installs the applipy web module and the Prometheus module.

You can try it by going to http://localhost:8080. To see some metrics you have to call at least twice on the endpoint.

Applipy will search for a configuration file named ${APPLIPY_CONFIG_PATH}/${APPLIPY_ENV}.json (and ${APPLIPY_CONFIG_PATH}/${APPLIPY_ENV}.yaml, if pyyaml is installed). The default values are: APPLIPY_ENV=dev and APPLIPY_CONFIG_PATH=..

Another option is to indicate the file directly, using applipy -f ./path/to/file.yaml.


AppHandle is the interface through wich applipy manages the lifecycle of the application. An AppHandle implementation looks like this:

from asyncio import get_event_loop

from applipy import AppHandle

class MyDemoApp(AppHandle):

    async def on_init(self):
        print('initialize resources')
        self.future = get_event_loop().create_future()

    async def on_start(self):
        print('run long lived application here')
        await self.future

    async def on_shutdown(self):
        print('close and release resources')

As you can see above there is three methods exposed by AppHandles that let applipy run your application.

Applipy is capable of running multiple AppHandles concurrently, taking advantage of async in python.

The lifecycle of an application follow the following diagram:

  AppHandle.on_start()        applipy cli
           │                SIGINT   SIGTERM   [Your own stopping mechanism]
           ▼                   └────────┴───────┬───────────┘
start_long_running_task()                       ▼
           │                            Application.stop()
           ▼                                    │

shutdown_timeout can be set in the app configuration using the key app.shutdown_timeout_seconds. Defaults to 1 second.

It is expected that AppHandle.on_shutdown() will be used to indicate any long running tasks to stop and cleanup, and do any required cleanup itself.

Generally, AppHandle implementations are added to the applipy application by including the modules they are part of and registering the AppHandle in the module configure() function.


In applipy, modules are the building blocks of an application. They allow to bind instances/classes/providers to types by exposing the an applipy_inject.Injector's bind() function, register application handles by exposing the Application's register() function and define dependencies across modules.

An example of a module implementation looks like this:


from applipy import Config, Module, LoggingModule
from logging import Logger
from demo_app import MyDemoApp

class MyModule(Module):

    def __init__(self, config: Config):
        self._config = config

    def configure(self, bind, register):
        bind(str, 'ModuleDemo')

    def depends_on(cls):
        return (LoggingModule,)

The way you add modules to an application is through the configuration file by defining a list of fully qualified names of Module implementations with the key app.modules:

    - applipy_http.HttpModule
    - applipy_prometheus.PrometheusModule
    - mymodule.MyModule

Modules can only receive one parameter in their constructor and it is a Config instance, as shown in the code above. If your module does not need access to the configuration, you can just not implement a __init__ or have it not have arguments (other than self).

The configure() method is run by the applipy Application when it is started and its purpose is to allow for binding types and registering application handles. Check the extended Module documentation in /docs/

Finally, the depends_on() class method returns a tuple of the module types the module depends on. In the example above, because the application handle registered by the module requires a logging.Logger, the module declares a dependency with the LoggingModule because we know that it binds the logging.Logger type.


For a deeper dive on the features and details feel free to check the /docs subdirectory and the code itself!

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

applipy-2.2.0.tar.gz (14.9 kB view hashes)

Uploaded source

Built Distribution

applipy-2.2.0-py3-none-any.whl (16.5 kB view hashes)

Uploaded py3

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor NVIDIA NVIDIA PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page