Project layout

create a Project folder:

$ mkdir First-App
$ cd First-App

$ mkdir config
$ mkdir log
$ mkdir first_app

• First-App, The Project name.
• config, applications default configfiles
• log, application.log is created in this folder
• first_app, the python package with your applications files

    /First-App
        /setup.py
        /config
            /default.conf
        /first_app
            /Controllers
            /Engines
                /__init__.py
                /templates
                /webadmin
            /Interfaces
            /Rules
            /Sources
            /__init__.py
            /__main__.py
            /defaultconfig.py
            /main.py

setup.py:

• package_data, make sure to include html templates
• entry_points, the entry point will make it easy to launch application

from setuptools import setup, find_packages
from first_app import __version__ as app_version

NAME = "First-App"
MAIN_PACKAGE = "first_app"

setup(
    name=NAME,
    version=app_version,
    packages=find_packages(exclude=['contrib', 'docs', 'tests', 'config']),    
    install_requires=[
        'netdef'
    ],
    package_data={
        MAIN_PACKAGE: [
            'Engines/templates/*.html',
            'Engines/templates/*/*.html'
        ]
    },    
    entry_points={
        'console_scripts': [
            '{NAME}={MAIN_PACKAGE}.__main__:cli'.format(NAME=NAME, MAIN_PACKAGE=MAIN_PACKAGE),
        ],
    },
)

first_app/__init__.py:

__version__ = '0.1.0'

first_app/__main__.py:

from netdef.__main__ import entrypoint

def run_app():
    from . import main

def get_template_config():
    from . import defaultconfig
    return defaultconfig.template_config_string

def cli():
    # entrypoint: console_scripts
    entrypoint(run_app, get_template_config)

if __name__ == '__main__':
    # entrypoint: python -m console_scripts 
    entrypoint(run_app, get_template_config)

first_app/defaultconfig.py:

template_config_string = \
"""[general]
identifier = First-App
version = 1
"""

default_config_string = \
"""[general]
[config]
[ExpressionExecutor]
[webadmin]
host = 0.0.0.0
port = 8000
user = admin
password = admin

[webadmin_views]

[logging]
logglevel = 20
loggformat = %(asctime)-15s %(levelname)-9s: %(name)-11s: %(message)s
loggdatefmt = %Y-%m-%d %H:%M:%S
to_console = 1
to_file = 1

[logginglevels]
werkzeug = 40

[rules]

[controllers]

[controller_aliases]

[sources]

[source_aliases]
"""

first_app/main.py:

import os
from netdef.Controllers import Controllers
from netdef.Sources import Sources
from netdef.Rules import Rules
from netdef.Engines import ThreadedWebGuiEngine
from netdef.Shared import Shared
from netdef.utils import setup_logging, handle_restart
from . import defaultconfig

def main():
    # init shared-module
    try:
        install_path = os.path.dirname(__file__)
        proj_path = os.getcwd()
        config_string = defaultconfig.default_config_string
        shared = Shared.Shared("First-App", install_path, proj_path, config_string)
    except ValueError as error:
        print(error)
        raise SystemExit(1)

    # configure logging
    setup_logging(shared.config)

    controllers = Controllers.Controllers(shared)
    controllers.load([__package__, 'netdef'])

    sources = Sources.Sources(shared)
    sources.load([__package__, 'netdef'])

    rules = Rules.Rules(shared)
    rules.load([__package__, 'netdef'])

    # the engine connects webadmin, controllers, sources and rules.
    engine = ThreadedWebGuiEngine.ThreadedWebGuiEngine(shared)
    engine.add_controller_classes(controllers)
    engine.add_source_classes(sources)
    engine.add_rule_classes(rules)
    engine.load([__package__, 'netdef'])

    engine.init()
    engine.start()
    engine.block() # until ctrl-c or SIG_TERM
    engine.stop()

    # if restart-button in webadmin is pressed:
    handle_restart(shared, engine)

main()

config/default.conf:

[general]
identifier = First-App
version = 1