Saravanan666/pypi-org huggingface dataset:
Package: bottle-config
Bottle Configuration – Configure Bottle from files.ContentsRequirementsInstallationUsageBug trackerContributingContributorsLicenseRequirementspython >= 2.6InstallationBottle Configurationshould be installed using pip:pip install bottle_configUsageThe application provide configuration like Django settings.settings.py:DEBUG = True
ANOTHER_OPTION = 'VALUE'import bottle
from bottle_config import config

app = bottle.Bottle()
app.install(config)

# See app.configimport bottle
from bottle_config import Config

app = bottle.Bottle()
app.install(Config('custom.default.module'))

# See app.configUse environment variableBOTTLE_CONFIGto set a configuration moduleBOTTLE_CONFIG=project.config.production python app.pyBug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/klen/bottle_config/issuesContributingDevelopment of starter happens at github:https://github.com/klen/bottle_configContributorsklen(Kirill Klenov)LicenseLicensed under aBSD license.
Package: bottlecors
BottleCorspip install bottlecorsand thenfrombottleimportBottlefrombottlecorsimportadd_cors,abortapp=Bottle()@app.get('/')defhome():"This just shows 404 always"abort(404,'msg')# Cors needs to be added after# all routes have been added to your appapp=add_cors(app)FeaturesFull blown corsSends docstring of function in options bodyAdds only for routes which have already been added
Package: bottle-cors
bottle-corsSimple plugin to easily enableCORSsupport inBottleroutes.ExamplefrombottleimportBottle,request,runfromtruckpad.bottle.corsimportCorsPlugin,enable_corsapp=Bottle()@app.get('/')defindex():"""CORS is disabled for this route"""return"cors is disabled here"@enable_cors@app.get('/endpoint_1')defendpoint_1():"""CORS is enabled for this route.OPTIONS requests will be handled by the plugin itself"""return"cors is enabled, OPTIONS handled by plugin"@enable_cors@app.route('/endpoint_2',method=['GET','POST','OPTIONS'])defendpoint_2():"""CORS is enabled for this route.OPTIONS requests will be handled by *you*"""ifrequest.method=='OPTIONS':# do something here?passreturn"cors is enabled, OPTIONS handled by you!"app.install(CorsPlugin(origins=['http://list.of.allowed.domains.com','https://another.domain.org']))run(app)
Package: bottle-cors2
BottleCORSCORS plugin for BottleInstallationPip</code></pre>
<h3>Source</h3>
<prelang="bash"><code>wgethttps://raw.githubusercontent.com/thepure12/bottle-cors/main/src/bottle_cors/bottle_cors.pyUsageInstall PluginfrombottleimportBottlefrombottle_corsimportEnableCorsapp=Bottle()plugin=EnableCors()app.install(plugin)
Package: bottle-cors-plugin
The easiest way to implement cors on your bottle py web applicationInstalling the pluginpip install bottle-cors-pluginafter this on your bottle app you need to import cors_plugin and install
for example.# -*- coding: utf-8 -*-frombottleimportapp,response,route,runfrombottle_cors_pluginimportcors_plugin@route('/',method='GET')deflanding():response.content_type='application/json'return{'status':'Works'}#Confugure the serverapp=app()app.install(cors_plugin('*'))ifname=="__main__":run(host='localhost',port=7000)On the cors_plugin function you can send a simple string or array of origins
this variable will set globaly on the plugin so you just set-it one time to add *
origins just don’t put anything on the functioncors_plugin()This will return the * originscors_plugin('https://google.com')with just google.com as and origin orcors_plugin(['https://google.com','http://google.com'])for multiple originsAbortsfor normal abort errors you need to import the abort of the cors_plugin like
thisfrombottle_cors_pluginimportabort@route('/',method='GET')deflanding():response.content_type='application/json'abort(500,'Hola')return{'status':'Works'}It works with all errors, and for custom error handler just import the cors_headers
to apply on the function example like this# -*- coding: utf-8 -*-fromimport_envimportosfrombottleimporterror,responsefrombottle_cors_pluginimportcors_headerserror_log=errorforstatus_codeinrange(200,600):@error(status_code)deferrorCustom(error_log):cors_headers()error_log.content_type='application/json'returnerror_log.body
Package: bottle-elastic
Bottle Elasticsearch==============.. image:: https://travis-ci.org/bsao/bottle-elastic.svg?branch=master:target: https://travis-ci.org/bsao/bottle-elasticThis bottle-elastic plugin integrates Elasticsearch with your Bottleapplication. It injects a Elastic connection in your route and handle thesession cycle.Support elasticsearch 2.xUsage Example:.. code-block:: pythonfrom bottle import Bottlefrom bottle_elastic import ElasticPluginfrom datetime import datetimeapp = Bottle()plugin = ElasticPlugin(hosts=["localhost:9200"])app.install(plugin)@app.route('/', method='GET')def index(elastic):# elastic search operationreturn "ok"@app.route('/create/', method='POST')def create(elastic):doc = {'name': 'bsao','text': 'Elasticsearch: cool.','timestamp': datetime.now(),}response = elastic.index(index="test-index", doc_type='tweet', id=1, body=doc)return response
Package: bottle-elastic-apm
Bottle Elastic APMSimple plugin to use ELK with APM server for your bottle applicationUsing default_appdefault_app()uses AppStack, so you only need to install it once.frombottleimportdefault_app,runfrombottle_elastic_apmimportElasticAPM,make_apm_clientELK_CONFIG={'service_name':'my-app',}app=default_app()app2=default_app()apm_client=make_apm_client(**ELK_CONFIG)# avoid multi client instancesapp.install(ElasticAPM(client=apm_client))@app.get('/')defindex():return'Hello world!'@app2.get('/2')defindex2():return'Hello world!'run(app)Using Bottle()Bottle()don't uses AppStack, so you need to install on all of them.frombottleimportBottle,runfrombottle_elastic_apmimportElasticAPM,make_apm_clientELK_CONFIG={'service_name':'my-app',}app=Bottle()app2=Bottle()app.mount('v2',app2)apm_client=make_apm_client(**ELK_CONFIG)# avoid multi client instancesapp.install(ElasticAPM(client=apm_client))app2.install(ElasticAPM(client=apm_client))@app.get('/')defindex():return'Hello world!'@app2.get('/2')defindex2():return'Hello world!'run(app)Avoid capture specific errorsfrombottleimportdefault_appfrombottle_elastic_apmimportElasticAPM,make_apm_clientELK_CONFIG={'service_name':'my-app',}app=default_app()apm_client=make_apm_client(**ELK_CONFIG)# avoid multi client instancesapp.install(ElasticAPM(client=apm_client,avoided_errors={(401,'JWT: Signature has expired',)}))
Package: bottle_errorsrest
bottle_errorsrest plugin for bottleAll errors are now returned bottle json format.If HTTPError receives a string becomes {‘message’: string}installationVia pip:pip install bottle_errorsrestOr clone:git clonehttps://github.com/agalera/bottle_errorsrest.gitexample server:frombottleimportget,install,run,HTTPErrorfrombottle_errorsrestimportErrorsRestPlugin@get("/")defexample():# {'message': 'oh no!'}raiseHTTPError(500,"oh no!")@get("/2")defexample2():# {'other_Example': 'oh no!'}raiseHTTPError(500,{'other_Example':'oh no!'})install(ErrorsRestPlugin())run(host="0.0.0.0",port="9988")Test:curlhttp://localhost:9988/--head;curlhttp://localhost:9988/HTTP/1.0500InternalServerErrorDate:Tue,27Sep201611:16:41GMTServer:WSGIServer/0.2CPython/3.4.3Content-Type:application/jsonContent-Length:20{"message":"oh no!"}curlhttp://localhost:9988/2--head;curlhttp://localhost:9988/2HTTP/1.0500InternalServerErrorDate:Tue,27Sep201611:16:41GMTServer:WSGIServer/0.2CPython/3.4.3Content-Type:application/jsonContent-Length:20{"other_Example":"oh no!"}curlhttp://localhost:9988/not_found--head;curlhttp://localhost:9988/not_foundHTTP/1.0404NotFoundDate:Tue,27Sep201611:11:39GMTServer:WSGIServer/0.2CPython/3.4.3Content-Length:38Content-Type:application/json{"message":"Not found: '/not_found'"}
Package: bottle-flash
bottle_flash============This plugin enables flash messages in bottle. Again, learn by example::from bottle import Bottlefrom bottle_flash import FlashPluginapp = Bottle()COOKIE_SECRET = 'super_secret_string'app.install(FlashPlugin(secret=COOKIE_SECRET))app.post('/create_user')def create_user():# Create the userapp.flash('Created !')To consume the flashed messages, you would do something like the following (jinja2). Here I am assuming that I get the "app" in the template context. This can be achieved with the bottle_renderer_ plugin.::{% set messages = app.get_flashed_messages() %}{% if messages %}<div id="flash_messages"><ul>{% for m in messages %}<li>{{ m[0] }}</li>{% endfor %}</ul></div>{% endif %}
Package: bottle_flash2
flash plugin for bottle. (Bottle-Flash2 is a fork ofBottle-Flash).Exampleapp.pyfrom bottle import Bottle, post, jinja2_template as template
from bottle_flash2 import FlashPlugin

# Flash Setup
app = Bottle()
COOKIE_SECRET = 'super_secret_string'
app.install(FlashPlugin(secret=COOKIE_SECRET))

@post('/flash_sample_done')
def flash_sample():
    app.flash("flash message is here")

    # flash mesage is stored in list
    # Therefore, it is possible to store a multiple messages.
    app.flash("flash message 1")
    app.flash("flash message 2")

    return template('index.html', app = app)index.html{% set messages = app.get_flashed_messages() %}
{% if messages %}
<div id="flash_messages">
<ul>
{% for m in messages %}
<li>{{ m[0] }}</li>
{% endfor %}
</ul>
</div>
{% endif %}Bottle version (Test environment)version 0.12.9 or above later.

Latest Version -> '0.13-dev'LicenceMIT
Package: bottle-gui
IntroductionThis package is used to vizualize services inBottleweb framework.DocumentationFull module documentation and description can be found at Read the Docs:http://bottle-gui.readthedocs.org/Changelog0.2.1Small package metadata improvements.0.2.0Added support for blacklist (.BLACKLIST property). See tests for details.bottle_gui()function renamed to justgui(). There was package namedbottle_guiwith sourcebottle_gui.py`with functionbottle_gui. This is imho better.0.1.3Paths are now sorted alphabetically.0.1.2Fixed bug in MANIFEST.in.0.1.0Project created.
Package: bottle-haml
# bottle-hamlAn extension for using [Haml templates](http://haml.info/) in your [Bottle](http://bottlepy.org) applications.## Installation`bottle-haml` is available via PIP:pip install bottle-haml## UsageOnce installed, use is simple. Simply import the helper method `haml_template` as follows:from bottlehaml import haml_templateFrom there, usage is exactly the same as Bottle's built-in `template` method except it will search for files with the extension `.haml` and parse them as Haml.@route('/')def index():headlines = ["Tree Stuck in Cat, Firefighters Baffled","Local Pet Spider, Silky, Missing"]return haml_template('index', headlines=headlines)## Haml reference`bottle-haml` uses the [PyHaml](https://github.com/mikeboers/PyHAML) module to parse Haml into the Mako templates that Bottle uses. For a reference of the Haml syntax supported please see the PyHaml project's GitHub page.- - -Copyright (c) 2013 [WireLoad Inc.](http://www.wireload.com/)
Package: bottle-hotqueue
FIFO message queueplugin forbottle.pybased onHotQueuebottle.pyis a fast and simple micro-framework for python web-applications.HotQueueis a Python library that allows you to use Redis as a message queue within your Python programs.Installation$ pip install bottle-hotqueueFrom source$ python setup.py installDependenciesbottleandhotqueueGetting StartedImporting and using the plugin in Bottleimport bottle
from bottlehotqueue import Plugin


app = bottle.Bottle()
hotqueue = Plugin(keyword="myhotqueue")
app.install(hotqueue)


@app.post('/put/:value', myhotqueue={'queue': 'myqueue'})
def send_message(value, myqueue):
    """ This will put an item in the queue hotqueue:myqueue.
    """
    return myqueue.put(value)


@app.get('/get/', myhotqueue={'queue': 'myqueue'})
def get_message(myqueue):
    """ We will now try to get a item from hotqueue:myqueue.
        if the queue is empty, we instead raise a 404.
    """
    result = myqueue.get()
    if not result:
        raise bottle.HTTPError(404, "Queue is Empty")
    return result

bottle.run(app, host='', port=8080)The plugin will usejson(or simplejson if available) as the standard serializer. This behaviour can be reverted to match the default implementation by passing asjson=False when instantiating the plugin. It will then conform to the standard HotQueue way of serializing objects by using pickle (or cpickle if available).hotqueue = Plugin(keyword="myhotqueue", asjson=False)Writing a simple consumerimport json
from hotqueue import HotQueue


queue = HotQueue("myqueue", host="localhost", serializer=json)

for item in queue.consume():
    print itemMore on HotQueue:http://richardhenry.github.com/hotqueue/LicenseMITGithub linkshttps://github.com/defnull/bottlehttps://github.com/richardhenry/hotqueue
Package: bottle-i18n
The bottle-i18n plugin integrates the multilingual internationalization servicesgettextfrom Python with your Bottle application.Usage Example:#!/usr/bin/python

import bottle, os
from bottle.ext.i18n import I18NPlugin, I18NMiddleware, i18n_defaults, i18n_view, i18n_template

i18n_defaults(bottle.SimpleTemplate, bottle.request)

def get():
    app = bottle.Bottle()

    @app.route('/')
    def index():
    return bottle.template("<b>{{_('hello')}} I18N<b/>?")

    @app.route('/world')
    def variable():
        return bottle.template("<b>{{_('hello %(variable)s', {'variable': world})}}<b/>?", {'world': app._('world')})


    @app.route('/view')
    @i18n_view('hello', function="i18n_view")
    def tmpl_app_hello():
        return {}

    @app.route('/tmpl')
    def tmpl_app_hello():
        return i18n_template('hello', function="i18n_template")


    lang_app = bottle.Bottle()

    @lang_app.route('/')
    def sub():
        return bottle.template("current language is {{lang()}}")

    app.mount(app = lang_app, prefix = '/lang', skip = None)

    return I18NMiddleware(app, I18NPlugin(domain='messages', default='en', locale_dir='./locale'))

if __name__ == '__main__':
    bottle.run(app=get(), host='localhost', port='8000', quiet=False, reloader=True, debug=True)Running the above example it automatically loads the default languageenif in the URL the langauge code or theHTTP_ACCEPT_LANGUAGEsent from the browser is missing.The URL structure is as followhttp://localhost:8000/<language-code>/<route>
Package: bottle-jade
Bottle Jade – Short description.ContentsRequirementsInstallationUsageConfigurationBug trackerContributingContributorsLicenseRequirementspython >= 2.6InstallationBottle Jadeshould be installed using pip:pip install bottle-jadeUsagefrom bottle import Bottle
from bottle_jade import JadePlugin
from os import path as op

app = Bottle()
templates = op.dirname(op.abspath(__file__))
jade = app.install(JadePlugin(template_folder=templates))

@app.route('/')
def index():
    context = {'var': 'value'}
    return jade.render('index.jade', **context)

@app.route('/simple')
@jade.view('simple.jade')
def simple():
    context = {}
    return contextConfigurationJADE_CACHE_SIZE – Number of templates which will be cached (200)
JADE_PRETTY – Enable pretty output (True)
JADE_TEMPLATE_FOLDER – Set path to templates folder (templates)
JADE_ENCODING – Set templates’ encoding (UTF-8)Bug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/klen/bottle-jade/issuesContributingDevelopment of Bottle Jade happens at:https://github.com/klen/bottle-jadeContributorsklen(Kirill Klenov)LicenseLicensed under aBSD license.
Package: bottle-json-pretty
bottle-json-prettyA plugin for theBottle Web Frameworkthat returns pretty formatted JSON.
The plugin extends the default JSON formatter's behavior by adding theindentkeyword argument to each call.
This is supported by at least the standard libraryjson,ujson, andsimplejson(1,2,3).Indent level and formatting during production can be controlled via the initializer.frombottleimportBottlefrombottle_json_prettyimportJSONPrettyPluginapp=Bottle(autojson=False)app.install(JSONPrettyPlugin(indent=2,pretty_production=True))@app.get('/')defbottle_test():return{'status':'ok','code':200,'messages':[],'result':{'test':{'working':True}}}app.run()
Package: bottlejwt
bottlejwtJWT plugin for bottleinstallationVia pip:pip install bottlejwtOr clone:git clone https://github.com/agalera/bottlejwt.gitexample server:importtimefrombottlejwtimportJwtPluginfrombottleimportBottle,requestpermissions={"user":0,"service":1,"admin":2}jwt_secret_key="s3cr3tk3y!!ch@ng3m3"defvalidation(auth,auth_value):returnpermissions[auth["type"]]>=permissions[auth_value]app=Bottle()app.install(JwtPlugin(validation,jwt_secret_key,algorithm="HS512"))@app.post("/login")deflogin():"""receive:{'client_id': 'user','client_secret': 'password'}response:{'access_token': 'token','type': 'bearer'}"""# example for mongodb'''user = db.users.find_one({"client_id": request.json["client_id"],"client_secret": hash_password(request.json["client_secret"]),},{"_id": False, "client_secret": False},)'''# Any data we consider good, implement a logic instead of doing thisuser={"client_id":request.json["client_id"],"type":"user"}ifnotuser:raiseHTTPError(403,"Invalid user or password")user["exp"]=time.time()+86400# 1 dayreturn{"access_token":JwtPlugin.encode(user),"type":"bearer"}@app.get('/jwt_info',auth='user')defjwt_info(auth):returnauthif__name__=='__main__':app.run(host='127.0.0.1',port=9999)Test by curl:curlhttp://localhost:9988/?access_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQExample client:importrequestsresponse=requests.post('http://localhost:9999/login',json={'client_id':'user','client_secret':'password'}).json()token=f"{response['type']}{response['access_token']}"# option 1 - Headersrequests.get('http://localhost:9999/jwt_info',headers={'Authorization':token})# response'''{'client_id': 'user','type': 'user','exp': 1670421559.047136,'token': '...'}'''# option 2 - url argumentrequests.get(f'http://localhost:9999/jwt_info?access_token={response["access_token"]}',)'''{'client_id': 'user','type': 'user','exp': 1670421559.047136,'token': '...'}'''Create Token:frombottlejwtimportJwtPlugin# is a singleton, you only need to initialize once.# * If you did install () also workJwtPlugin(validation,'secret',algorithm='HS256')print(JwtPlugin.encode({'name':'pepito'}))
Package: bottle-jwt3
BottleJWTJWT Plugin for Bottle. Adds functionality to protect routes via JWT and adds options for role based authentication.InstallationSourcewgethttps://raw.githubusercontent.com/thepure12/bottle-jwt/main/src/bottle_jwt/bottle_jwt.pyUsageInstall PluginfrombottleimportBottlefrombottle_jwtimportJWTPluginapp=Bottle()plugin=JWTPlugin(jwt_key="changeme")app.install(plugin)@app.route("/token",method="POST")deftoken():passGetting a TokenThe default route for getting a token is "/token". Token routes only except POST requests and will pass post data as keyword arguments into the authentication (auth) function. The auth function creates the JWT payload which is encoded and returned to the requester.$curllocalhost/token{"message":"Method Not Allowed, use POST for authentication"}$curl-XPOSTlocalhost/token{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlcyI6WyJndWVzdCJdLCJleHAiOjE2ODMxMjcxODd9.5OkXOdRGbloRr4oI2pjeJoBqQvSaE-pkuaZoaAtKKSU"}Custom AuthdefmyAuth(**kwargs):token={"exp":datetime.utcnow()+timedelta(minutes=5),"roles":["user","admin"]}returntokenplugin=JWTPlugin(jwt_key="changeme",auth_func=myAuth)Failed authenetication can be handled by raising an AuthFailed exception.frombottle_jwtimportdefmyAuth(username,password):ifmyHash(username,password)!=expected_hash:raiseAuthFailed()Additional Token PathsIt might be useful to have multiple token paths to enable the use of multiple auth functions. Each token path is mapped to one auth function but one auth function may be mapped to multiple token paths.plugin=JWTPlugin(jwt_key="changeme")plugin.addTokenPath("token2")plugin.addTokenPath("token3",auth_func=myAuth)Protecting RoutesProtecting a route is handled via Bottle's route config. This simplest way to protect a route is to add a "roles" option to a route's config and set it to True. Roles can all be set to a list of strings (the roles required to access the route) or a callable that returns a boolean or list of strings.@route("/protected1",roles=True)defprotected():pass@route("/protected2",roles=["user","admin"])defprotected():pass@route("/protected3",roles=myRolesFunc)defprotected():pass
Package: bottle-log
Improved logging for Bottle.UseIn order to catch exceptions from other plugins the LoggingPlugin should be
the first plugin you install to the application.importbottlefrombottle_logimportLoggingPluginapp=bottle.Bottle()app.install(LoggingPlugin(app.config))@app.get('/test')deftest(logger):logger.warning('This is only a test')return{}ConfigurationThe plugin uses the following configuration keys:logging.levelThe logging level. Possible values:debug,info,warning,error,critical.
Defaults towarning.logging.formatThe logging format. See the python logging documentation for the format.
Defaults to “[%(asctime)s] %(levelname)s: %(name)s: %(message)s”logging.utcIfTrue, the default, time stamps are in UTC.LoggingThe standard logger, used by theloggerkeyword, prints to stderr by default.Exception loggingThis plugin also provides an exception logger (‘bottle.exception’). By default
this logger does nothing, since bottle prints all exceptions to stderr, but it can be
useful if you want to log exceptions to somewhere else.
For example, logging to Logentries:importbottlefromlogentriesimportLogentriesHandlerfrombottle_logimportLoggingPluginapp=bottle.Bottle()app.install(LoggingPlugin(app.config))le_handler=LogentriesHandler('logentries-api-token')logging.getLogger('bottle.exception').addHandler(le_handler)
Package: bottle-login
Bottle Login – Implement users’ sessions in Bottle web framework.ContentsRequirementsInstallationUsageBug trackerContributingContributorsLicenseRequirementspython >= 2.6InstallationBottle Loginshould be installed using pip:pip install bottle-loginUsagefrom bottle import Bottle, request, redirect
from bottle_login import LoginPlugin

app = Bottle()
app.config['SECRET_KEY'] = 'secret'

login = app.install(LoginPlugin())

@login.load_user
def load_user_by_id(user_id):
    # Load user by id here


# Some application views

@app.route('/')
def index():
    current_user = login.get_user()
    return current_user.name

@app.route('/signout')
def signout():
    # Implement logout
    login.logout_user()
    return redirect('/')

@app.route('/signin')
def signin():
    # Implement login (you can check passwords here or etc)
    user_id = int(request.GET.get('user_id'))
    login.login_user(user_id)
    return redirect('/')Bug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/klen/bottle-login/issuesContributingDevelopment of Bottle Login happens at:https://github.com/klen/bottle-loginContributorsklen(Kirill Klenov)LicenseLicensed under aBSD license.
Package: bottle-manage
Bottle Manage – Short description.ContentsRequirementsInstallationUsageBug trackerContributingContributorsLicenseRequirementspython >= 2.6InstallationBottle Manageshould be installed using pip:pip install bottle-manageUsagemanage.py:from bottle import Bottle
from bottle_manage import Manage

app = Bottle()
manage = Manage(app)

@manage.shell
def context():
    from .models import Partner, Record, db # noqa
    ctx = locals()
    ctx['app'] = app
    ctx['db'] = db.database
    return ctx


@manage.command
def db():
    """ Initialize the database."""
    from peewee_migrate.core import Router
    router = Router(
        os.path.join(app.config['ROOT_DIR'], 'migrations'), DATABASE=app.config['DATABASE_URI'])
    router.run()


@manage.command
def runserver(reloader=False, debug=False, port=5000):
    """ Run the application. """
    app.run(reloader=reloader, debug=debug, port=port)


if __name__ == '__main__':
    manage()$ ./manage.py --helpBug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/klen/bottle-manage/issuesContributingDevelopment of Bottle Manage happens at:https://github.com/klen/bottle-manageContributorsklen(Kirill Klenov)LicenseLicensed under aBSD license.