def main(port): #Beaker options session_opts = { 'session.type': 'file', 'session.cookie_expires': True, 'session.data_dir': './.cache', 'session.auto': True } #Debug mode ? if port != 80 and port != 443: #Sqlite db file #mydbfile_solarmax = os.path.join(ROOT_PATH, "Solarmax_data2.s3db") #mydbfile_teleinfo = os.path.join(ROOT_PATH, "../teleinfo/Teleinfo_data.s3db") mydbfile_solarmax = os.path.join(ROOT_PATH, "../data/Solarmax_data2.s3db") mydbfile_teleinfo = os.path.join(ROOT_PATH, "../data/Teleinfo_data.s3db") access_log_file = 'access.log' #Run http test server on given port myserver = 'wsgiref' else: #Sqlite db file mydbfile_solarmax = DB_FILE_SOLAR mydbfile_teleinfo = DB_FILE_TELEINFO #Run CherryPy http or https server if port == 80: myserver = 'cherrypy' access_log_file = VAR_LOG_ACCESS elif port == 443: myserver = SSLCherryPyServer access_log_file = VAR_LOG_ACCESS_SSL #Create default bottle application app = default_app() myapp = SessionMiddleware(app, session_opts) handlers = [ TimedRotatingFileHandler(access_log_file, 'd', 7, 90), ] loggingapp = WSGILogger(myapp, handlers, ApacheFormatter()) #Plugins : SQLitePlugin give a connection in each functions with a db parameter install(SQLitePlugin(dbfile=mydbfile_solarmax)) plugin2 = SQLitePlugin(dbfile=mydbfile_teleinfo, keyword='db2') plugin2.name = "sqlite2" install(plugin2) #Run server run(app=loggingapp, host='0.0.0.0', port=port, server=myserver, reload=True)
def server(config, host="127.0.0.1"): install(SQLitePlugin(dbfile='ratings.db')) install(ConfigPlugin(config)) lInfo("server starting.") run(host=host, port=config["http_port"], debug=True, reloader=True) lInfo("server stopped.")
def test_app(app, test_ip): """A Webtest app.""" app.install(IPAuthPlugin(token_manager=TokenManager())) # It is not possible to use in-memory SQLite for testing. Because for every new connection table schema will be # empty. So temp file will be used for test database fd, dbfile = tempfile.mkstemp(suffix='.sqlite') sqlite_plugin = app.install(SQLitePlugin(dbfile=dbfile)) # Create database with sqlite3.connect(dbfile) as conn: conn.execute('CREATE TABLE access_log\n' ' (\n' ' id INTEGER PRIMARY KEY,\n' ' file_key BLOB,\n' ' access_date DATETIME,\n' ' last_access_date DATETIME\n' ' )') conn.commit() # Register IP t_app = TestApp(app, extra_environ={'REMOTE_ADDR': test_ip}) res = t_app.get('/register') assert 200 == res.status_code t_app.token = res.json['Token'] assert t_app.token is not None yield t_app # teardown if conn: conn.close() os.close(fd) os.unlink(sqlite_plugin.dbfile)
def runserver(port, ip, debug): frp = Process(target=file_removal, args=(settings.STATIC_PATH, )) frp.start() # TODO: Investigate ResourceWarning: unclosed <socket.socket fd=860, family=AddressFamily.AF_INET, # type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 11652), raddr=('127.0.0.1', 11642)> click.echo('Start server at: {}:{}'.format(ip, port)) api.install( SQLitePlugin(dbfile=os.path.abspath( os.path.join(settings.PROJECT_PATH, '..', settings.SQLITE_FILE_NAME)))) api.install(IPAuthPlugin()) run(app=api, host=ip, port=port, debug=debug, reloader=debug)
def server(config, host="127.0.0.1"): """ start the server part of avrateNG """ install(SQLitePlugin(dbfile='ratings.db')) install(ConfigPlugin(config)) lInfo("server starting.") run(host=host, port=config["http_port"], debug=False, reloader=False, fast=False) lInfo("server stopped.")
def main(host, port, quiet): # Initialize database conn = sqlite3.connect(db_file.name) # or use :memory: to put it in RAM cursor = conn.cursor() cursor.execute(""" CREATE TABLE event_log ( event_type TEXT, resource_name TEXT, event TEXT, event_time TIMESTAMP DEFAULT (datetime('now','localtime')) ) """) # Install sqlite bottle plugin install(SQLitePlugin(dbfile=db_file.name)) run(host=host, port=port, quiet=quiet)
from bottle import run, route, template, install, request # pip install bottle_sqlite from bottle_sqlite import SQLitePlugin install( SQLitePlugin( dbfile= r'/Users/govindarajanv/workstation/programming/python /inventory.db')) @route('/') def index(): return template("Hello {{name}}, Welcome to Bottle", name="User") @route('/show/<devicename>') def show_device(db, devicename): command = db.execute('SELECT id,os,name from devices where name =?', (devicename, )) row = command.fetchone() if row: return template('{{id}},{{name}},{{os}}', id=row['id'], name=row['name'], os=row['os']) else: return template("The specified device {{name}} does not exist", name=devicename)
from bottle import route, run, install, template, request from bottle_sqlite import SQLitePlugin install( SQLitePlugin(dbfile=r'/home/trp86/python-bottle/database/inventory.db')) @route('/show/<devicename>') def show_device(db, devicename): command = db.execute('SELECT id,name,os from devices where name = ?', (devicename, )) row = command.fetchone() or None if row: return template('{{id}},{{name}},{{os}}', id=row['id'], name=row['name'], os=row['os']) else: return template( 'The specified device with name :{{name}},couldnot be found!', name=devicename) @route('/show') def querylike(db): os = request.query.os or None id = request.query.id or None name = request.query.name or None print(os) print(id)
from bottle import * from bottle_sqlite import SQLitePlugin sqlite = SQLitePlugin(dbfile='test.db') install(sqlite) @route('/show') def showall(db): row = db.execute("SELECT * from student") if row: return template('showitem', items=row) return HTTPError(404, "Page not found") @route('/show/<item>') def show(item, db): row = db.execute("SELECT * from student where name like ?", ('%'+item+'%',)) if row: return template('showitem', items=row) return HTTPError(404, "Page not found") run(host='192.168.0.31', port=8008)
from bottle import route, install, template from bottle_sqlite import SQLitePlugin install(SQLitePlugin(dbfile='bd.db')) @route('/show/users') def show(db): c = db.execute('SELECT * FROM usuario ') row = c.fetchone() return template('<b>Hello {{name}}</b>!', name=row['nome']) def consulta(db, nome, senha): c = db.execute('SELECT * FROM usuario where nome = \'' + nome + '\' and senha = \'' + senha + '\'') row = c.fetchone() if row: return True else: return False def consulta_API(db, token): c = db.execute('SELECT * FROM usuario where token = \'' + token + '\'') row = c.fetchone() if row: return True else: return False
from bottle import Bottle, install, run, template, get, post, request, static_file, error, redirect, view from bottle_sqlite import SQLitePlugin import logging import json logger = logging.getLogger("readings") app = Bottle() app.install(SQLitePlugin(dbfile="./readings.db")) @app.error(404) @view("error404") def error404(error): ''' The generic error page found in the template error404.tpl under views is returned if a 404 - nor found error is generated ''' return @app.route('/about') @view("about") def about(): return @app.route("/json") def jsonview(db): c = db.execute("SELECT rowid, systolic, diastolic, heartrate, date, notes FROM Readings") r = [dict((c.description[i][0], value) \ for i, value in enumerate(row)) for row in c.fetchall()] return json.dumps(r)
#!/usr/bin/env python # −*− coding:utf−8 −*− from bottle import route, run, install, template, get, post, request from bottle_sqlite import SQLitePlugin install(SQLitePlugin(dbfile="film.db")) #//->Zugang zur DB richtig definieren #Zeichenerklärung: #//-> an dieser Stelle muss noch Folgendes programmiert werden #//<- Zeile zum Debuggen, später löschen @route("/") @route("/<place>", method='POST') @route("/<place>", method='GET') def film(db, place="home"): #Standard daten = [] #//<- Beispiel-Array nach Bedarf löschen #Baseline-Suche if place == "search_base": idfilm = request.forms.get( 'idfilm' ) #//<-Beispiel Daten aus einem Formular ziehen, nach Bedarf löschen query = "SELECT * FROM Film WHERE 1=1;" #//<- Beispiel query ausführen und Daten abrufen, nach Bedarf löschen c = db.execute(query) daten = c row = c.fetchone() #//<- Beispiel Daten abrufen idfilm = row[0] if place == "searchb_result": searchtext = request.forms.get('searchtext') """//-> Folgendes Schritt für Schritt programmieren zur TF*IDF-Suche $inhalt = explode(" ",$_POST['Suchfeld']);
import os, binascii from dateutil import parser as dateparser from bottle import run, get, post, delete, install, HTTPError, request from bottle_sqlite import SQLitePlugin from dbsetup import init_db from google_auth import gauth from app_conf import DBNAME from app_gcm import send_link init_db(DBNAME) install(SQLitePlugin(dbfile=DBNAME)) install(gauth) def to_dict(row): return dict( sha=row['sha'], url=row['url'], timestamp=row['timestamp'], # Convert integer to boolean deleted=(1 == row['deleted'])) @get('/') @get('/links') def list_links(db, userid): '''Return a complete list of all links''' args = [userid] deleted_part = ' AND deleted IS 0'
abort(400) # deadline format is %d/%m/%y %H:%M import datetime deadline = datetime.datetime.strptime( request.json.get('deadline', datetime.datetime.now()), "%d/%m/%y %H:%M") response.content_type = 'application/json' return put_data(db, idnum, column='deadline', data=deadline) @route('/schedule/<idnum>/complete', method='PUT') def put_complete(idnum, db): row = db.execute('SELECT * from schedule where id=?', [idnum]).fetchone() if row: complete = row['complete'] # toggle complete flag if complete == 0: complete = 1 else: complete = 0 response.content_type = 'application/json' return put_data(db, idnum, column='complete', data=complete) return HTTPError(404, "Data not found") if __name__ == "__main__": sqlite = SQLitePlugin(dbfile='schedule.db') install(sqlite) run(host='192.168.0.21', port=5000)
from bottle import route, run, request, install from bottle_sqlite import SQLitePlugin import json from sklearn.svm import SVR import numpy as np class state: model = SVR() cols = [] trained = False curState = state() install(SQLitePlugin(dbfile='./testDB.sqlite')) @route('/getTables', method='GET') def getTables(db): sql = "select name from sqlite_master where type='table'" c = db.execute(sql) tbls = [] for row in c: tbls.append(row[0]) return json.dumps(tbls) @route('/getColumns', method='POST') def getColumns(db): reqJson = request.json
# # app.py # Copyright (c) 2017 HTKエンジニアリング All Rights Reserved. # # Distributed under terms of the MIT license. from bottle import * from bottle_sqlite import SQLitePlugin from datetime import datetime import json # temperテーブル構造 # 0|time |text|0||0 # 1|sensor|text|0||0 # 2|temper|real|0||0 dbfile = 'data/temper.db' install(SQLitePlugin(dbfile=dbfile)) # -------------- # グラフページ # -------------- # jqPlot描画ページ(メインページ) @route('/') @route('/jqplot') def jqplot(): return template('base', title='テストページ', type='jqplot') # Highcharts描画ページ @route('/highcharts') def highcharts():
# Copyright (c) 2012, John M. Gabriele # License: MIT (see LICENSE.txt for details) from bottle import route, run, template, request, response,\ redirect, install from bottle_sqlite import SQLitePlugin import time, random, string install(SQLitePlugin(dbfile='db/site.db')) # ---------------------------------------------------------------------- # If the user is logged in, returns the username. def is_logged_in(db): cookie_session_id = request.get_cookie('session_id') if not cookie_session_id: return False c = db.execute('select user_id from sessions where session_id = ?', (cookie_session_id,)) row = c.fetchone() if row: c = db.execute('select username from users where id = ?', (row[0],)) row = c.fetchone() return row[0] else: return False # ----------------------------------------------------------------------
#!/usr/bin/env python # author: [email protected] import ConfigParser from bottle import route, install, run, template, static_file, response, PasteServer #, debug from bottle_sqlite import SQLitePlugin import json import urllib import urllib2 import datetime config = ConfigParser.RawConfigParser() config.read('config.ini') install(SQLitePlugin(dbfile=(config.get("pool", "database")))) @route('/api/btime') def blocktime(): response.headers['Cache-Control'] = 'public, max-age=100' payload = { 'requestType': 'getForging', 'secretPhrase': config.get("pool", "poolphrase") } opener = urllib2.build_opener(urllib2.HTTPHandler()) data = urllib.urlencode(payload) forging = json.loads( opener.open(config.get("pool", "nhzhost") + '/nhz', data=data).read()) getdl = forging["deadline"] dl = str(datetime.timedelta(seconds=getdl))
cur = db.cursor() # Create table try: cur.execute('''CREATE TABLE items (name text)''') except sqlite3.OperationalError: pass items = [('foo',), ('bar',), ('baz',)] cur.executemany("INSERT INTO items VALUES (?)", items) db.commit() db.close() plugin = SQLitePlugin(dbfile='/tmp/test.db') session_manager = bottlesession.CookieSession() valid_user = bottlesession.authenticator(session_manager) app = bottle.Bottle() app.install(plugin) @app.route('/') @app.route('/:name') @valid_user() def hello(name='world'): return '<h1>Hello %s!</h1>' % name.title() @app.route('/auth/login')
from bottle import static_file from bottle import template from bottle import install from bottle import abort, error, redirect from bottle_sqlite import SQLitePlugin from config import db_path, static_dir, views_dir import time import os import sys import json bottle.TEMPLATE_PATH.insert(0, views_dir) install(SQLitePlugin(dbfile=db_path)) def get_kwargs_base(title, db): return { 'categories': db.execute('SELECT * FROM category').fetchall(), 'recent_posts': db.execute( 'SELECT id,title FROM article ORDER BY publish_time DESC LIMIT 5'). fetchall(), 'title': title }
import requests, json from bottle import route, run, template, static_file, abort, install, request, response from imagga.color import ColorAPIClient # The database from bottle_sqlite import SQLitePlugin install(SQLitePlugin(dbfile='database.db')) # Import the config file from config import * class Instagram(object): """A small class for fetching photos from Instagram""" def __init__(self, client_id): super(Instagram, self).__init__() self.api_url = 'https://api.instagram.com/v1' self.client_id = client_id def get(self, resource, params=list()): url = self.api_url if resource == '/media/popular': url = self.append_client_id(url + resource) else: return False try: data = self.fetch_data(url)
from bottle import Bottle, request, response, abort, redirect from bottle_sqlite import SQLitePlugin from bcrypt import checkpw from jwt import encode, decode, DecodeError, ExpiredSignature import datetime import inspect app = application = Bottle() app.config.load_config('oj.cfg') app.install(SQLitePlugin(dbfile=app.config.get('sqlite.dbfile'))) exp_time = eval(app.config.get('jwt.exp_time')) jwt_secret = app.config.get('jwt.secret') class ErrorHandler: def get(self, ignore, default): def error_handler(error): from json import dumps from bottle import tob return tob( dumps({ "status_code": error.status_code, "status": error.status, "reason": error.body })) return error_handler
def install_db(): dbfile = os.path.join(app_root, 'todo.db') install(SQLitePlugin(dbfile=dbfile))
import paths.general_paths as general_paths import paths.user_paths as user_paths import paths.librarian_paths as librarian_paths from config import database_file, HOST # Create Bottle Object app = bottle.Bottle() # Database Configuration migrations_path = 'migrations/' caribou.upgrade(database_file, migrations_path) # Install Plugins app.install(message_plugin) app.install(SQLitePlugin(dbfile=database_file, pragma_foreign_keys=True)) # HTML Errors @app.error(404) def error404(error): return bottle.template('visitor_pages/page_not_found') @app.error(401) def error401(error): print("ERROR") try: bottle.redirect('/', 303) except bottle.HTTPResponse as res: return res
import datetime import json import random import secrets import types from beaker.middleware import SessionMiddleware import bottle from bottle import abort, run, static_file, request, response, route from bottle_sqlite import SQLitePlugin import cfg import utils app = bottle.app() app.install(SQLitePlugin(dbfile=cfg.DB_PATH, autocommit=False)) ROLE_ADMIN = 1 if cfg.CORS_ALLOW_ORIGIN: def add_cors_headers(res): res.headers[ 'Access-Control-Allow-Origin'] = cfg.CORS_ALLOW_ORIGIN or '*' res.headers[ 'Access-Control-Allow-Methods'] = 'PUT, GET, POST, DELETE, OPTIONS' res.headers[ 'Access-Control-Allow-Headers'] = 'Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token' res.headers['Access-Control-Allow-Credentials'] = 'true' @bottle.hook('before_request')
from bottle import Bottle, route, run, install, template, static_file, request, response from bottle_sqlite import SQLitePlugin import hashlib, json, datetime from tokendb import TokenDB #import bottle #application = application = bottle.default_app() #app = application = Bottle() app = Bottle() app.install(SQLitePlugin(dbfile='token.db')) @app.route('/static/<filepath:path>') def _static_file(filepath): return static_file(filepath, root='static') @app.route('/') def index(): return template('views/index.tpl') @app.route('/api/status') def api_status(db): name = request.GET.get('name') or request.forms.get('name') or '' token = request.GET.get('token') or request.forms.get('token') or '' #print 'Name:', name, ',Token:', token ''' check login ''' tdb = TokenDB(db) ret = tdb.admin_check(name, token)
from bottle import route, run, template, request, debug, install import bottle import bottle.ext.sqlite from bottle_sqlite import SQLitePlugin import bottle from bottle.ext import sqlite app = bottle.Bottle() plugin = SQLitePlugin(dbfile='cwags (11).sqlite') bottle.install(plugin) print app #HOST = '192.168.47.101' test_list = [ { 'protocol': 'proto1', 'service':'s1', 'plugin': 'plug1', 'value':1 }, { 'protocol': 'proto2', 'service':'s2', 'plugin': 'plug2', 'value':2 }, { 'protocol': 'proto3', 'service':'s3', 'plugin': 'plug3',
from bottle import template from bottle import install from bottle_sqlite import SQLitePlugin config = { 'log-file': './www.log', 'pid-file': './.www.pid', 'db-file': '../db/imgs.db', 'img-path': '../db/imgs', 'daemon': sys.argv[1] if len(sys.argv) > 1 else None } if config['daemon']: import daemon daemon.daemon_exec(config) install(SQLitePlugin(dbfile=config['db-file'])) templatestr = """<!DOCTYPE html> <html> <head> <title>BING IMAGE</title> <style> body{ max-width: 90%; margin: auto; padding-bottom:2em; background-color: #333333; color: #eeeeee; font-family: "Helvetica"; font-size: 2em; }
@route('/static/<filename:path>') def serve_static(filename): '''js, css, 画像などの静的ファイルを返す''' return static_file(filename, root=STATIC_DIR) @route('/presen_images/<filename:path>') def serve_images(filename): ''' プレゼン用画像を返す''' return static_file(filename, root=UPLOAD_DIR) if __name__ == '__main__': # 初回起動時のDBセットアップ with open('./schema.sql', 'r') as schema, sqlite3.connect('./peppre.db') as conn: conn.executescript(schema.read()) # bottle-sqlite をセットアップ install(SQLitePlugin(dbfile='./peppre.db')) # プレゼン画像保存ディレクトリを作成 if not os.path.isdir(UPLOAD_DIR): os.mkdir(UPLOAD_DIR) # LAN 内からのリクエストを受け付けるため host=0.0.0.0 を指定 run(host='0.0.0.0', port=8000, debug=True)
from bottle import * from bottle_sqlite import SQLitePlugin install(SQLitePlugin(dbfile='/tmp/test.db')) app = Bottle() @app.route('/index/<name:re:[0-9]*>') def index(name='world'): #return '<strong>hello {}!'.format(name) return template('form.html') @app.get('/login') def login_form(): return template('form') @app.post('/login') def login(): name = request.forms.get('name') password = request.forms.get('password') if name == 'admin' and password == 'pwd': return '<h1>successful!</h1>' else: #return '<p>sorry!</p>' #return template('form.html') #redirect('/login') abort(404)