def test_bottle(path, method='GET', form={}):
from bottle import TEMPLATE_PATH
TEMPLATE_PATH.insert(0, '../views')
TEMPLATE_PATH.insert(0, 'views')
app = XXX_mywebapp.XXX_setup_web_interface()
data = '&'.join(['%s=%s' % (k, v) for k, v in form.items()])
from bottle import run, CGIServer
from StringIO import StringIO
import os
os.environ['REQUEST_METHOD'] = method
os.environ['PATH_INFO'] = path
os.environ['SCRIPT_NAME'] = path
os.environ['QUERY_STRING'] = ''
os.environ['SERVER_PROTOCOL'] = 'HTTP/1.1'
os.environ['CONTENT_LENGTH'] = str(len(data))
old_stdout = sys.stdout
sys.stdout = new_stdout = StringIO()
old_stdin = sys.stdin
sys.stdin = new_stdin = StringIO(data)
new_stdin.seek(0)
run(app, server=CGIServer)
sys.stdin = old_stdin
sys.stdout = old_stdout
return new_stdout.getvalue()
def test_bottle(path, method='GET', form={}):
from bottle import TEMPLATE_PATH
TEMPLATE_PATH.insert(0, '../views')
TEMPLATE_PATH.insert(0, 'views')
app = XXX_mywebapp.XXX_setup_web_interface()
data = '&'.join(['%s=%s' % (k, v) for k, v in form.items()])
from bottle import run, CGIServer
from StringIO import StringIO
import os
os.environ['REQUEST_METHOD'] = method
os.environ['PATH_INFO'] = path
os.environ['SCRIPT_NAME'] = path
os.environ['QUERY_STRING'] = ''
os.environ['SERVER_PROTOCOL'] = 'HTTP/1.1'
os.environ['CONTENT_LENGTH'] = str(len(data))
old_stdout = sys.stdout
sys.stdout = new_stdout = StringIO()
old_stdin = sys.stdin
sys.stdin = new_stdin = StringIO(data)
new_stdin.seek(0)
run(app, server=CGIServer)
sys.stdin = old_stdin
sys.stdout = old_stdout
return new_stdout.getvalue()
def __init__(self, config=None, args=None):
# Init config
self.config = config
# Init args
self.args = args
# Init stats
# Will be updated within Bottle route
self.stats = None
# cached_time is the minimum time interval between stats updates
# i.e. HTTP/Restful calls will not retrieve updated info until the time
# since last update is passed (will retrieve old cached info instead)
self.timer = Timer(0)
# Load configuration file
self.load_config(config)
# Init Bottle
self._app = Bottle()
# Enable CORS (issue #479)
self._app.install(EnableCors())
# Password
if args.password != '':
self._app.install(auth_basic(self.check_auth))
# Define routes
self._route()
# Path where the statics files are stored
self.STATIC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static/public')
# Paths for templates
TEMPLATE_PATH.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static/templates'))
def __init__(self, port, hbusMaster):
"""Class constructor
@param port HTTP port
@param hbusMaster main master object reference for manipulation
"""
try:
views = pkg_resources.resource_filename("hbussd",
"data/views")
# distribution found!
TEMPLATE_PATH.insert(0, views)
self.static_file_path =\
pkg_resources.resource_filename("hbussd",
"data/web_static")
except pkg_resources.DistributionNotFound:
pass
##Server port
self.port = port
##main master object
self.hbusMaster = hbusMaster
##Minimum object level visible on web interface
self.objectLevel = 0
#get logger
self.logger = logging.getLogger('hbussd.hbusweb')
def __init__(self, infoscreen, folder, apiport):
super(InfoScreenWebServer, self).__init__()
# We need access to the infoscreen base object in order to manipulate it
self.infoscreen = infoscreen.base
# Get the folder path so we can build paths to templates etc.
self.folder = folder
# Set up the api
self.api = "http://localhost:{}/api/".format(apiport)
# Set up templates
tpls = os.path.join(self.folder, "web", "templates")
TEMPLATE_PATH.insert(0, tpls)
# Initialise dictionary for custom web pages provided by screens
self.custom_screens = {}
# Build the dictionary of available screens
self.process_plugins()
# Define our routes
self.route("/configure/<screen>", callback=self.update_config, method="GET")
self.route("/configure/<screen>", callback=self.save_config, method="POST")
self.route("/view/<screen>", callback=self.view)
self.route("/", callback=self.list_screens, method=["GET", "POST"])
# See if there are any custom screens
self.add_custom_routes()
def __init__(self, infoscreen, folder, apiport):
super(InfoScreenWebServer, self).__init__()
# We need access to the infoscreen base object in order to manipulate it
self.infoscreen = infoscreen.base
# Get the folder path so we can build paths to templates etc.
self.folder = folder
# Set up the api
self.api = "http://localhost:{}/api/".format(apiport)
# Set up templates
tpls = os.path.join(self.folder, "web", "templates")
TEMPLATE_PATH.insert(0, tpls)
# Initialise dictionary for custom web pages provided by screens
self.custom_screens = {}
# Build the dictionary of available screens
self.process_plugins()
# Define our routes
self.route("/configure/<screen>",
callback=self.update_config,
method="GET")
self.route("/configure/<screen>",
callback=self.save_config,
method="POST")
self.route("/view/<screen>", callback=self.view)
self.route("/", callback=self.list_screens, method=["GET", "POST"])
# See if there are any custom screens
self.add_custom_routes()
def get_images_of_this_month():
client = DropboxClient(DROPBOX_TOKEN)
manager = DatastoreManager(client)
datastore = manager.open_default_datastore()
offer_table = datastore.get_table('offers')
offers = offer_table.query()
images_to_show = []
for offer in offers: # dropbox.datastore.Record
name = offer.get('offerName')
begin = datetime.datetime.strptime(offer.get('begin'),
"%Y-%m-%d").date()
end = datetime.datetime.strptime(offer.get('end'), "%Y-%m-%d").date()
begin_month = '{:02d}'.format(begin.month)
end_month = '{:02d}'.format(end.month)
current_month = '{:02d}'.format(datetime.datetime.now().month)
year = '{:4d}'.format(datetime.datetime.now().year)
if current_month == begin_month or current_month == end_month:
# belong to the current month, so we show it
images_to_show.append(name)
images_paths = download_and_save_images(images_to_show, year,
current_month)
TEMPLATE_PATH.insert(0, 'pages/')
return template('galeria', images=images_paths)
def main():
# Set global variables from the command line
global blogFolder
global s3Bucket
blogFolder = sys.argv[1]
s3Bucket = sys.argv[2]
# For any folders that are reserved by Aeriter
if blogFolder == "templates":
exit()
# Read configuration for the blog
global config
config = ConfigParser.ConfigParser()
config.read(blogFolder + '/settings.cfg')
# You'll want to do this at the beginning of the process
shutil.rmtree(blogFolder + '/rendered', ignore_errors=True)
make_sure_path_exists(blogFolder + '/rendered')
# Ensure the correct template is being rendered
TEMPLATE_PATH.insert(0,'./views/%s' % config.get("Settings", "theme"))
# This processes the individual .md files and places them in the "rendered" folder under
# their respective relative paths.
global postMetaData
postMetaData = []
for file in glob.glob(blogFolder + "/*.md"):
if file[-9:] == '-draft.md':
continue
postMetaData.append(renderPost(file, blogFolder, config))
genNavPages(postMetaData, blogFolder, config)
sendToS3(s3Bucket, blogFolder)
def recommendations():
TEMPLATE_PATH.insert(0, '')
s = session()
# 1. Classify labeled news
rows = s.query(News).filter(News.label != None).all()
X, y = [], []
for row in rows:
X.append(row.title)
y.append(row.label)
X = [clean(x).lower() for x in X]
model = NaiveBayesClassifier()
model.fit(X, y)
# 2. Get unlabeled news
new_rows = s.query(News).filter(News.label == None).all()
# 3. Get predictions
marked = []
for row in new_rows:
marked.append((model.predict(row.title.split()), row))
# 4. Print ranked table
return template('news_ranked', rows=marked)
def test_wsgi_XXX_Test_Name(self):
'''Test of web interface via WSGI interface'''
from webtest import TestApp
from bottle import TEMPLATE_PATH
TEMPLATE_PATH.insert(0, '../views')
TEMPLATE_PATH.insert(0, 'views')
app = XXX_mywebapp.XXX_setup_web_interface()
harness = TestApp(app)
def setUp(self):
from webtest import TestApp
from bottle import TEMPLATE_PATH
TEMPLATE_PATH.insert(0, '../')
self.app = controller.build_application()
self.harness = TestApp(self.app)
self.username = "******"
self.password = "******"
self.wrong_password = "******"
def test_wsgi_XXX_Test_Name(self): '''Test of web interface via WSGI interface''' from webtest import TestApp from bottle import TEMPLATE_PATH TEMPLATE_PATH.insert(0, '../views') TEMPLATE_PATH.insert(0, 'views') app = XXX_mywebapp.XXX_setup_web_interface() harness = TestApp(app)
def start(host="localhost", port=8080):
"""
Run the web server
"""
# set TEMPLATE_PATH to use an absolute path pointing to our directory
abs_app_dir_path = os.path.dirname(os.path.realpath(__file__))
abs_views_path = os.path.join(abs_app_dir_path, 'templates')
TEMPLATE_PATH.insert(0, abs_views_path)
run(host=host, port=port)
print(f"Running web-server on http://{host}:{port}/")
def add_plugin_templates_path(path):
global env
tmpl_path = make_templates_from_plugin_path(path)
if os.path.exists(tmpl_path):
logging.debug("Templates directory found for this plugin [%s]" % tmpl_path)
template_path.append(tmpl_path) # for webhooks
TEMPLATE_PATH.insert(0, tmpl_path) # for webviews
env = Environment(loader=FileSystemLoader(template_path)) # ditch and recreate a new templating environment
return
logging.debug("No templates directory found for this plugin [Looking for %s]" % tmpl_path)
def add_plugin_templates_path(path):
global env
tmpl_path = make_templates_from_plugin_path(path)
if os.path.exists(tmpl_path):
log.debug("Templates directory found for this plugin [%s]" % tmpl_path)
template_path.append(tmpl_path) # for webhooks
TEMPLATE_PATH.insert(0, tmpl_path) # for webviews
# Ditch and recreate a new templating environment
env = Environment(loader=FileSystemLoader(template_path))
return
log.debug("No templates directory found for this plugin [Looking for %s]" % tmpl_path)
def __update_template_path():
# Sometimes, when caching templates bottle doesn't clear the faulty
# templates and the error persists even upon restarting the app.
# The solution is to clear the templates explicitly with this statement:
TEMPLATES.clear()
for m in registered_methods:
method_path = unicode('./{0}/{1}/'.format(config.FP_SUBDIR, m.subdir))
if method_path not in TEMPLATE_PATH:
TEMPLATE_PATH.insert(0, method_path)
logger.info('updated TEMPLATE_PATH')
def setUp(self):
dbwrap.connect(connect='sqlite:///:memory:')
dbwrap.Base.metadata.create_all()
db = dbwrap.session()
model.create_sample_data()
self.db = db
from webtest import TestApp
from bottle import TEMPLATE_PATH
TEMPLATE_PATH.insert(0, '../views')
self.app = website.build_application()
self.harness = TestApp(self.app)
def start():
parser = ArgumentParser(prog=sys.argv[0],
description="Pollux'NZ City configurator")
parser.add_argument("-V",
'--version',
action='version',
version="%(prog)s version 0")
parser.add_argument("-D",
"--debug",
dest="debug",
action="store_true",
default=False,
help="Debug mode")
parser.add_argument(
"-p",
"--path",
dest="path",
default="/etc/pollux",
help='path to configuration directory. e.g. /etc/pollux/')
parser.add_argument("-l",
"--lib",
dest="lib_path",
default="/usr/lib/pollux",
help='Directory where the modules lay')
# HOST ARGUMENT
parser.add_argument("-H",
"--host",
dest="host",
default='0.0.0.0',
help='Host to serve the web application on.')
# PORT ARGUMENT
parser.add_argument(
"-P",
"--port",
dest="port",
default='8080',
help='Port to be used for serving the web application.')
args = parser.parse_args(sys.argv[1:])
TEMPLATE_PATH.insert(0, pollux.views.__path__[0])
config = Configuration(args.path + "/", args.lib_path)
sensors = Sensors(args.path + "/")
install(config)
install(sensors)
return args
def skin_check(conn):
curs = conn.cursor()
skin = './views/acme/'
try:
curs.execute('select data from other where name = "skin"')
skin_exist = curs.fetchall()
if (skin_exist):
if (os.path.exists(
os.path.abspath('./views/' + skin_exist[0][0] +
'/index.tpl')) == 1):
skin = './views/' + skin_exist[0][0] + '/'
except:
pass
TEMPLATE_PATH.insert(0, skin)
def __init__(self):
self.project_name = "Watering System"
board_name = HARDWARE_CONFIG.kit
board_module = "{0}.hardware.{1}".format(__package__, board_name)
board_class_name = "{0}Board".format(board_name.capitalize())
self.board = getattr(import_module(board_module), board_class_name)()
GPIO.setmode(GPIO.BOARD)
self.schedule = {}
self.water_level = []
resource_package = __name__
package_root = resource_filename(resource_package, "")
TEMPLATE_PATH.insert(0, package_root)
self.server = Bottle()
self.server.route("/", callback=self.serve_index)
self.server.route("/styles.css", callback=self.serve_css)
self.server.route("/on", callback=self.get_on)
self.server.route("/off", callback=self.get_off)
self.server.route("/schedule",
method="GET",
callback=self.get_schedule)
self.server.route("/schedule",
method="PUT",
callback=self.put_schedule)
GPIO.setup(self.board.FLOW_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.board.FLOW_PIN,
GPIO.BOTH,
callback=self.flow_changed,
bouncetime=300)
GPIO.setup(self.board.PUMP_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.board.PUMP_PIN,
GPIO.BOTH,
callback=self.pump_changed,
bouncetime=300)
self.monitor_water_level_job = SCHEDULER.add_job(
self.monitor_water_level, "interval", seconds=10)
self.monitor_flow_job = SCHEDULER.add_job(self.monitor_flow,
"interval",
seconds=10)
def work(p,rp,nonesym,timec,timebg,btc,btbg,etc,etbg,showetflag,showbtflag):
global port, static_path, nonesymbol, timecolor, timebackground, btcolor, btbackground, etcolor, etbackground, showbt, showet
port = p
static_path = rp
nonesymbol = nonesym
timecolor = timec
timebackground = timebg
btcolor = btc
btbackground = btbg
etcolor = etc
etbackground = etbg
showet = showetflag
showbt = showbtflag
TEMPLATE_PATH.insert(0,rp)
s = WSGIServer(("0.0.0.0", p), default_app(), handler_class=WebSocketHandler)
s.serve_forever()
def work(p,rp,nonesym,timec,timebg,btc,btbg,etc,etbg,showetflag,showbtflag):
global port, static_path, nonesymbol, timecolor, timebackground, btcolor, btbackground, etcolor, etbackground, showbt, showet
port = p
static_path = rp
nonesymbol = nonesym
timecolor = timec
timebackground = timebg
btcolor = btc
btbackground = btbg
etcolor = etc
etbackground = etbg
showet = showetflag
showbt = showbtflag
TEMPLATE_PATH.insert(0,rp)
s = WSGIServer(("0.0.0.0", p), default_app(), handler_class=WebSocketHandler)
s.serve_forever()
def build_application(env='dev'):
app = Bottle()
# with app:
# Our application object is now the default
# for all shortcut functions and decorators
nlp = get_stanford_nlp()
say_words = read_say_words()
with open("web/config.js", "w") as f:
host = host_dict[env]
f.write('getViewUrl = {{\n\turl:\'http://{}:{}\'\n}}'.format(host[0], host[1]))
BaseTemplate.defaults['app'] = app # XXX Template global variable
TEMPLATE_PATH.insert(0, 'views') # XXX Location of HTML templates
# XXX Routes to static content
# @app.route('/<path:re:favicon.ico>')
# @app.route('/static/<path:path>')
# def static(path):
# 'Serve static content.'
# return static_file(path, root='static/')
# XXX Index page
@app.route('/') # XXX URL to page
@view('index') # XXX Name of template
def index():
"""
:return:
"""
return static_file('index.html', root=WEB_DIR)
@app.route('/static/<filename:path>')
def send_static(filename):
return static_file(filename, root=WEB_DIR)
@app.post('/views', name='view')
def fetch_views():
sentence = request.forms.getunicode('sentence')
views = get_views(sentence, nlp, say_words)
view_dict = [{"person": person, "verb": verb, "view": view} for person, verb, view in views]
return json.dumps(view_dict)
return app
def __init__(self):
debug(True)
TEMPLATE_PATH.insert(0, './templates')
logging.basicConfig(format='%(asctime)s: [%(levelname)s]: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.WARN)
logging.getLogger('autobrowser').setLevel(logging.DEBUG)
self.redis = redis.StrictRedis.from_url(self.REDIS_URL,
decode_responses=True)
self.app = default_app()
self.init_routes()
self.client = docker.from_env()
def start():
parser = ArgumentParser(prog=sys.argv[0],
description="Pollux'NZ City configurator")
parser.add_argument("-V", '--version', action='version', version="%(prog)s version 0")
parser.add_argument("-D",
"--debug",
dest="debug",
action="store_true",
default=False,
help="Debug mode")
parser.add_argument("-p",
"--path",
dest="path",
default="/etc/pollux",
help='path to configuration directory. e.g. /etc/pollux/')
parser.add_argument("-l",
"--lib",
dest="lib_path",
default="/usr/lib/pollux",
help='Directory where the modules lay')
# HOST ARGUMENT
parser.add_argument("-H",
"--host",
dest="host",
default='0.0.0.0',
help='Host to serve the web application on.')
# PORT ARGUMENT
parser.add_argument("-P",
"--port",
dest="port",
default='8080',
help='Port to be used for serving the web application.')
args = parser.parse_args(sys.argv[1:])
TEMPLATE_PATH.insert(0,pollux.views.__path__[0])
config = Configuration(args.path+"/",args.lib_path)
sensors = Sensors(args.path+"/")
install(config)
install(sensors)
return args
def __init__(self,
name=None,
arm=None,
panel=None,
log_level=INFO,
template_path="data/templates/",
static_path="data/static/",
resources_search_path=None):
LogMixin.__init__(self, name=name, level=log_level)
self.log_info('log level set to %s',
self.log_effective_level_as_string)
if resources_search_path:
self.log_info('processing resource search path :')
for pkg in resources_search_path:
self.log_info('+ ' + pkg)
path = resource_filename(pkg, template_path)
self.log_info(' + template path : %s', path)
if path not in TEMPLATE_PATH:
if not os.path.isdir(path):
raise ValueError('path not found: ' + path)
TEMPLATE_PATH.insert(0, path)
self.log_info(" added to bottle.TEMPLATE_PATH")
else:
self.log_info(" already in bottle.TEMPLATE_PATH")
path = resource_filename(pkg, static_path)
if path not in STATIC_PATH:
self.log_info(' + static path : %s', path)
if not os.path.isdir(path):
raise ValueError('path not found: ' + path)
STATIC_PATH.insert(0, path)
self.log_info(" added to STATIC_PATH")
else:
self.log_info(" already in STATIC_PATH")
Bottle.__init__(self)
self.arm = arm
self.panel = panel
self.route('/help', 'GET', callback=self.get_help)
self.route('/static/<filepath:path>',
'GET',
callback=self.serve_static)
def init(root="/home/isanz"):
global ROOT
global application
global i18n
TEMPLATE_PATH.insert(0, root)
ROOT = root
i18n_defaults(SimpleTemplate, request)
#print >>sys.stderr, "Starting up, log=" + str(log) + " db=" + str(db)
session_opts = {
'session.type': 'file',
'session.cookie_expires': True,
'session.data_dir': './sessions',
'session.auto': True
}
i18n = I18NPlugin(domain='messages', default='en', locale_dir=ROOT+'colours/locale')
app = I18NMiddleware(default_app(), i18n)
application = SessionMiddleware(app, session_opts)
def __init__(self, config=None, args=None):
# Init config
self.config = config
# Init args
self.args = args
# Init stats
# Will be updated within Bottle route
self.stats = None
# cached_time is the minimum time interval between stats updates
# i.e. HTTP/RESTful calls will not retrieve updated info until the time
# since last update is passed (will retrieve old cached info instead)
self.timer = Timer(0)
# Load configuration file
self.load_config(config)
# Set the bind URL
self.bind_url = 'http://{}:{}/'.format(self.args.bind_address,
self.args.port)
# Init Bottle
self._app = Bottle()
# Enable CORS (issue #479)
self._app.install(EnableCors())
# Password
if args.password != '':
self._app.install(auth_basic(self.check_auth))
# Define routes
self._route()
# Path where the statics files are stored
self.STATIC_PATH = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'static/public')
# Paths for templates
TEMPLATE_PATH.insert(
0,
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'static/templates'))
def runserver(port, ip, debug, dev=False):
click.echo('Start server at: {}:{}'.format(ip, port))
if dev and 'true' == str(dev).lower():
# 设置运行环境
os.environ['run_env'] = 'dev'
# 加载bottle
from app import settings
from app.routes import Routes
TEMPLATE_PATH.insert(0, settings.TEMPLATE_PATH)
session_opts = {'session.type': 'file', 'session.auto': True}
app = SessionMiddleware(Bottle(), session_opts)
# Bottle Routes
app.wrap_app.merge(Routes)
@app.wrap_app.route('/assets/<path:path>', name='assets')
def assets(path):
yield static_file(path, root=settings.STATIC_PATH)
run(app=app, host=ip, port=port, debug=debug, reloader=debug)
def __init__(self):
self.project_name = "Watering System"
board_name = HARDWARE_CONFIG.kit
board_module = "{0}.hardware.{1}".format(__package__, board_name)
board_class_name = "{0}Board".format(board_name.capitalize())
self.board = getattr(import_module(board_module), board_class_name)()
self.schedule = {}
self.moisture = []
resource_package = __name__
package_root = resource_filename(resource_package, "")
TEMPLATE_PATH.insert(0, package_root)
self.server = Bottle()
self.server.route("/", callback=self.serve_index)
self.server.route("/styles.css", callback=self.serve_css)
self.server.route("/on", callback=self.get_on)
self.server.route("/off", callback=self.get_off)
self.server.route("/schedule",
method="GET",
callback=self.get_schedule)
self.server.route("/schedule",
method="PUT",
callback=self.put_schedule)
self.monitor_moisture_job = SCHEDULER.add_job(self.monitor_moisture,
"interval",
minutes=5)
self.monitor_flow_job = SCHEDULER.add_job(self.monitor_flow,
"cron",
hour="0-23")
import os
import jinja2
from google.appengine.api import memcache
from jinja2 import Template
from bottle import Bottle, request, response, static_file
from bottle import TEMPLATE_PATH as T
PROJECT_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)))
TEMPLATE_PATH = os.path.join(PROJECT_PATH, 'templates')
JINJA_ENVIRONMENT = jinja2.Environment(
loader=jinja2.FileSystemLoader(TEMPLATE_PATH),
extensions=['jinja2.ext.autoescape'],
autoescape=True)
STATIC_PATH = os.path.join(PROJECT_PATH, 'assets')
T.insert(0, TEMPLATE_PATH)
app = Bottle()
@app.route('/')
def index():
def file_exist(file):
return os.path.isfile("{}/images/logo/{}.png".format(
STATIC_PATH, file))
langs = memcache.get('langs')
if not langs:
langs = os.listdir("./vim_template/langs")
memcache.add('langs', langs, 3600)
worker_pelican,\
worker_shootup
# Global Variables, Bottle Settings
################################################
config_path = os.path.join(os.path.dirname(__file__),
'../../config.json')
with open(config_path) as config_file:
config = json.load(config_file)
db_path = config['basket']['path']
engine = create_engine(db_path)
Session = sessionmaker(bind=engine)
DB = Session()
TEMPLATE_PATH.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__),
'views')))
redis_conn = Redis()
Q = Queue(connection=redis_conn)
# Static Resources
################################################
@route('/static/<filename:path>')
def send_static(filename):
return static_file(filename, root=os.path.join(os.path.dirname(__file__),
'static/'))
# Pages
################################################
@route('/')
from bottle import Bottle, TEMPLATE_PATH
from bottle.ext import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite:///database.db', echo=True)
app = Bottle()
TEMPLATE_PATH.insert(0, 'app/views/')
plugin = sqlalchemy.Plugin(engine,
Base.metadata,
keyword='db',
create=True,
commit=True,
use_kwargs=False)
app.install(plugin)
from app.controllers import default
from app.models import tables
"Initialize demo bottle application"
import logging
import logging.config
from bottle import Bottle, request, TEMPLATE_PATH
from rackspace_app import config
APP = Bottle()
TEMPLATE_PATH.insert(0, '/home/umeshbhaskaran/r_demo/bottle/rackspace_app/templates')
# Loading Configurations
APP.config.update(config.Config.__dict__)
# Configuring logger
LOGGER = logging.getLogger('rackspace_app')
HANDLER = logging.FileHandler('/tmp/rackspace_app.log')
FORMATTER = logging.Formatter(
'%(asctime)s %(levelname)s %(filename)s:%(lineno)d %(message)s')
HANDLER.setFormatter(FORMATTER)
LOGGER.addHandler(HANDLER)
LOGGER.setLevel(logging.DEBUG)
import logging
from json import dumps
import sys
import commands
from datetime import datetime
import os
import re
# Logging First!
logging.basicConfig(format='localhost - - [%(asctime)s] %(message)s', level=logging.DEBUG)
log = logging.getLogger("bottle")
# Basic Vars
INSTALLDIR = '/app'
APPDIR = INSTALLDIR #+ '/bottle' #os.path.dirname(sys.argv[0])
TEMPLATE_PATH.insert(0, APPDIR +'/views')
dbfile = APPDIR + '/bottle.db'
d = {}
aaa = Cork(APPDIR + '/auth')
__version__ = '0.9.0'
osversion = commands.getoutput('uname') + " " + commands.getoutput('uname -r')
d['version'] = __version__
d['osversion'] = osversion
# Enable bottle debug logging - is this even useful?
debug(True)
# Create Bottle instance
rootapp = Bottle()
import bottle_session
from bottle import Bottle, TEMPLATE_PATH
from bottle.ext import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite:///database.db', echo=True)
app = Bottle()
TEMPLATE_PATH.insert(0, 'app/views/')
plugin = sqlalchemy.Plugin(
engine,
Base.metadata,
keyword='db',
create=True,
commit=True,
use_kwargs=False
)
plugin_session = bottle_session.SessionPlugin(cookie_lifetime=120)
app.install(plugin)
app.install(plugin_session)
from app.controllers import default
from app.models import tables
@url https://github.com/fgaim
"""
import os
import json
from datetime import datetime
from bottle import Bottle, TEMPLATE_PATH, template, response
from . import utils
from . import core
app = Bottle()
abs_path = os.path.dirname(os.path.realpath(__file__))
abs_views_path = os.path.join(abs_path, 'views')
TEMPLATE_PATH.insert(0, abs_views_path)
EXCLUDE_SELF = False # Do not report to `/gpustat` calls.
@app.route('/')
def index():
gpustats = core.all_gpustats()
now = datetime.now().strftime('Updated at %Y-%m-%d %H-%M-%S')
return template('index', gpustats=gpustats, update_time=now)
@app.route('/gpustat', methods=['GET'])
def report_gpustat():
"""
Returns the gpustat of this host.
#coding='utf8'
from bottle import error, route, static_file, debug, run, request, response, template, TEMPLATE_PATH, PasteServer
#from gevent import monkey; monkey.patch_all()
#from time import sleep
import RPi.GPIO as GPIO
GPIO_OUT = 12
def light_init():
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_OUT, GPIO.OUT)
debug(True)
TEMPLATE_PATH.insert(0, './')
@error(403)
def mistake403(code):
return 'The parameter you passed has the wrong format!'
@error(404)
def mistake404(code):
return 'Sorry, this page does not exist!'
@route('/stat/<filepath:path>')
def static(filepath):
return static_file(filepath, root='./stat/')
@route('/')
def light_html():
return template('light')
@route('/light')
import os
import config
from bottle import TEMPLATE_PATH, static_file, request, response,\
template, redirect
TEMPLATE_PATH.insert(0, os.path.join(os.path.dirname(__file__), './templates'))
from aiobottle import AsyncBottle
app = AsyncBottle()
from . import bottle_login
login_plugin = bottle_login.Plugin()
app.install(login_plugin)
from . import views
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': 7 * 24 * 60 * 60,
'session.data_dir': 'run',
'session.auto': True
}
server = SessionMiddleware(app, session_opts)
import bottle
from bottle import debug, error, get, post, request, response, route, run, static_file, template, TEMPLATE_PATH
import json
import operator
from beaker.middleware import SessionMiddleware
import sys
sys.path.insert(0, './lib/')
import crawler_db
import env_server
import google_authenticator
TEMPLATE_PATH.insert(0,'./views/')
# GLOBAL
URLS_PER_PAGE = 10
session_opts = {
'session.type': 'file',
'session.cookie_expires': 300,
'session.data_dir': './data',
'session.auto': True
}
app = SessionMiddleware(bottle.app(), session_opts)
@error(404)
def error404(error):
output = template('error_page')
return output
import requests
import jinja2
from jinja2 import Template
from bottle import Bottle, request, response, static_file
from bottle import TEMPLATE_PATH as T
PROJECT_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)))
TEMPLATE_PATH = os.path.join(PROJECT_PATH, 'views')
JINJA_ENVIRONMENT = jinja2.Environment(
loader=jinja2.FileSystemLoader(TEMPLATE_PATH),
extensions=['jinja2.ext.autoescape'],
autoescape=True)
STATIC_PATH = os.path.join(PROJECT_PATH, 'assets')
T.insert(0, TEMPLATE_PATH)
app = Bottle()
@app.route('/')
def index():
def file_exist(file):
return os.path.isfile("{}/images/logo/{}.png".format(
STATIC_PATH, file))
template = JINJA_ENVIRONMENT.get_template('index.html')
url = "https://api.github.com/repos/avelino/.vimrc/contents/langs"
langs = [g["name"] for g in json.loads(requests.get(url).text)]
nameRe = re.compile ("^[a-zA-Z0-9_-]+$")
configfile = file(os.getenv("NIXPASTE_CONFIG", "config.json"), "r")
config = json.load(configfile)
configfile.close()
# TypeError: Key has type <type 'unicode'> (not a string)
for k,v in config.items():
del config[k]
config[str(k)] = v
app = Bottle()
app.config.update (config)
TEMPLATE_PATH.insert(0, os.path.abspath (config["VIEWS"]))
def mergeConfig(**v):
c = copy(config)
c.update(v)
return c
class Storage:
def __init__ (self, config):
self.config = config
def hashname (self, num):
h = hashlib.pbkdf2_hmac('sha256', str(num), self.config["SALT"], 200000, self.config["LENGTH"])
return base64.urlsafe_b64encode(h)
def firstview (self, hashname):
import sys, os
sys.path.append('/var/www/SiteUppity')
from bottle import Bottle, route, view, run, template, static_file, TEMPLATE_PATH
TEMPLATE_PATH.insert(0, os.path.abspath(os.path.dirname(__file__)))
import subprocess, re, json, httplib, requests
application = Bottle()
@application.route('/index.html')
@application.route('/default.html')
@application.route('/')
@view('index')
def index():
pass
@application.route('/favicon.ico')
def fav():
return static_file('favicon.ico', root='/var/www/SiteUppity')
@application.route('/robots.txt')
def robot():
return static_file('robots.txt', root='/var/www/SiteUppity')
@application.route('/getresponse/<secure:int>/<d>/<path>/')
@application.route('/getresponse/<secure:int>/<d>/<path>')
@application.route('/getresponse/<secure:int>/<d>/')
@application.route('/getresponse/<secure:int>/<d>')
def getresponse(secure, d, path = ""):
__author__ = 'SolPie'
import os
from datetime import datetime
from bottle import (Bottle, request, redirect,static_file, TEMPLATE_PATH, jinja2_template as render_template)
from settings import *
app = Bottle()
TEMPLATE_PATH.insert(0, TEMPLATES_PATH)
from utils.dbm import PhotoDBM, TrashDBM
from utils.photos import walkPhotos, walkTrash, Photo
from utils.md5 import md5_bytes, md5_path
## slash test
# from utils.bottleEx import StripPathMiddleware
#
# app = app()
# appEx = StripPathMiddleware(app=app)
##
##dbm test
db = PhotoDBM()
db.open(DB_PATH)
# p = db.get('test')
# p.filename = 'file.jpg'
# p.md5num = 'fe334edf'
# p.path = 23
# p.title = 'hello world'
# db.set('test', p)
__version__ = '3.1.2'
from bottle import TEMPLATE_PATH, route, template, static_file, error, request, response, redirect, default_app
from sqlalchemy import create_engine, MetaData
from sqlalchemy import Table, Column, Integer, String, DateTime, Boolean, ForeignKey
from sqlalchemy import select, func
import smtplib
from email.mime.text import MIMEText
from pyzufall.satz import satz
from datetime import datetime, timedelta
import random
import os.path
import sys
basepath = os.path.dirname(__file__)
TEMPLATE_PATH.insert(0, basepath + '/views/')
app = default_app()
app.config.setdefault('debug', False)
app.config.setdefault('satzgenerator.database', '')
# Konfiguration laden
app.config.load_config('config.ini')
if app.config['debug']:
from bottle import debug
if app.config['satzgenerator.database'] == 'mysql':
user = app.config['satzgenerator.mysql.user']
password = app.config['satzgenerator.mysql.password']
from bottle import request, response, TEMPLATE_PATH, static_file
from bottle import jinja2_template as template
from PyDebrid import __path__
from PyDebrid.application import app
from PyDebrid.serienjunkies import SerienjunkiesLink
from PyDebrid.container import ContainerDecrypter
import hashlib
TEMPLATE_PATH.insert(0,__path__[0]+"/data/")
@app.route("/")
def index():
return template("pydebrid.html", queue=app.pydebrid.pimp.links)
@app.route("/favicon.ico")
def favicon():
return static_file("favicon.ico", root=__path__[0]+"/data/")
@app.route("/list")
def list():
#return {'links': sorted(app.pydebrid.pimp.links.values(), key = lambda link: link['perc'])}
return app.pydebrid.pimp.links
@app.route("/remove/<link>")
def remove(link):
if link in app.pydebrid.pimp.links:
app.pydebrid.pimp.bitchlist[link].cancle()
return {'message': 'Removed Link'}
@app.post("/add_och")
def add_och():
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from bottle import route, run, get, request, Bottle, redirect, static_file, SimpleTemplate, TEMPLATE_PATH, template
from FirebaseClient import *
import json
import requests
import imojify
import translate
from random import randrange
TEMPLATE_PATH.insert(0, '../front-end/')
root = Bottle()
@root.get('/')
def server_root():
return template('index')
@root.get('/favicon.ico')
def get_favicon():
return server_static('favicon.ico')
# serve static files
@root.route('/static/<filename>')
def server_static(filename):
root = "../front-end/"
return True
else:
return False
def num_words(tweet):
sanitized_tweet = re.sub("[^\s\w\d\-']", "", tweet)
words = sanitized_tweet.split()
count = 0
for word in words:
if check_if_word(word):
count += 1
return count
TEMPLATE_PATH.insert(0, "views")
@route("/")
@route("/<username>")
@view("index")
def greet(username=None):
if username:
tweets = get_tweets(username)
else:
tweets = None
return dict(tweets=tweets)
run(host="localhost", port=8080, debug=True)
WSGI server. The simplest is CGI::
from wsgiref.handlers import CGIHandler
CGIHandler().run(app)
Check out the file ``xychan.dh.cgi`` for a working CGI script, and
``xychan.dh.passenger`` for a Passenger WSGI deployment.
"""
from bottle import TEMPLATE_PATH, default_app, request, cookie_is_encoded
import os
STATIC_PATH = __path__[0] + os.sep + 'static'
TEMPLATE_PATH.insert(0, __path__[0] + os.sep + 'templates')
from basics import *
from .db import DbSessionMiddleware, configure_db
from .image_store import configure_image_dir
from .context import context_middleware
def strip_path_middleware(app):
def _strip_path_app(environ, start_response):
environ['PATH_INFO'] = environ['PATH_INFO'].rstrip('/')
return app(environ, start_response)
return _strip_path_app
app = strip_path_middleware(
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import os
import click
from bottle import static_file, Bottle, run, TEMPLATE_PATH
from beaker.middleware import SessionMiddleware
from calculo import settings
from calculo.routes import Routes
TEMPLATE_PATH.insert(0, settings.TEMPLATE_PATH)
session_opts = {
'session.type': 'file',
'session.auto': True
}
app = SessionMiddleware(Bottle(), session_opts)
# Bottle Routes
app.wrap_app.merge(Routes)
@app.wrap_app.route('/assets/<path:path>', name='assets')
def assets(path):
yield static_file(path, root=settings.STATIC_PATH)
@click.group()
def cmds():
#!/usr/bin/python
# -*- coding: utf-8 -*-
from bottle import Bottle
from bottle import debug, run
from bottle import redirect, abort, static_file
from bottle import jinja2_template as template
from bottle import request, response, local
from bottle import TEMPLATE_PATH
from mysession import get_session_info, set_session_info
from mysession import deco_session_check
from setting import CUSTOM_TPL_PATH
TEMPLATE_PATH.insert(0, CUSTOM_TPL_PATH)
app = Bottle()
app.mount('/test', __import__('test').app)
@app.route('/center')
def handel_redirect():
return redirect(request.path+'/')
@app.route('/')
@deco_session_check
def handle_index():
return '我是首页'
if __name__ == '__main__':
__author__ = 'Konglx'
import logging
import os
from jinja2 import Environment, FileSystemLoader
from bottle import TEMPLATE_PATH
def make_templates_path(root):
return root + os.sep + 'templates'
system_templates_path = make_templates_path(os.path.dirname(__file__))
template_path = [system_templates_path]
TEMPLATE_PATH.insert(0, system_templates_path) # for views
env = Environment(loader=FileSystemLoader(template_path))
def tenv():
return env
def make_templates_from_plugin_path(plugin_path):
return make_templates_path(os.sep.join(plugin_path.split(os.sep)[:-1]))
def add_plugin_templates_path(path):
global env
tmpl_path = make_templates_from_plugin_path(path)
if os.path.exists(tmpl_path):
import json, sys
# Extend the bottle class to initialize the DB and config
class WhisperApp(Bottle):
def __init__(self, catchall=True, autojson=True):
self.app_config = _init.init_config() # Necessary due to naming conflicts in the Bottle class
self.database = _database
self.utils = _utils
_init.init_db()
super().__init__()
app = WhisperApp()
app.install(SQLitePlugin(dbfile="whisper/db/whisper.db"))
TEMPLATE_PATH.insert(0, 'whisper/views')
# Todo: add cookies.
@app.route('/', template="index")
def index(db):
stats = app.database.get_stats(db)
if stats is None:
return dict(sent=None, opened=None)
else:
sent, opened = stats
return dict(sent=sent, opened=opened)
@app.route('/faq', template="faq")
def faq():
return dict()
# -*- coding: utf-8 -*-
import os
from bottle import Bottle, request, response
from bottle import jinja2_template as template
from bottle import TEMPLATE_PATH
from faker import Faker
import pickle
import uuid
import redis
import json
TEMPLATE_PATH.insert(0, os.path.join(os.path.dirname(__file__), 'views'))
app = Bottle()
def mount_json(object_base):
fake = Faker()
obj = {}
for key, value in object_base.items():
if isinstance(value, dict):
obj[key] = mount_json(value)
continue
if isinstance(value, list):
if value[0] in dir(fake):
try:
if value[0] == 'list_email':
obj[key] = [fake.email() for n in range(value[1])]
continue
func = getattr(fake, value[0])
obj[key] = func(value[1])
def insert(self, statement):
conn = MySQLdb.Connection(host=self.db_host, user=self.db_username, passwd=self.db_password, db=self.db_name)
curs = conn.cursor()
curs.execute(statement)
conn.commit()
conn.close()
def select(self, statement):
conn = MySQLdb.Connection(host=self.db_host, user=self.db_username, passwd=self.db_password, db=self.db_name)
curs = conn.cursor()
curs.execute(statement)
conn.commit()
result = curs.fetchall()
return result
conn.close()
TEMPLATE_PATH.insert(0,'/apps/helloyou/templates/')
@get('/')
def index():
return template('index')
@post('/hello')
def hello():
name = request.forms.get('name')
if name:
db = dbc()
db.insert('insert into guests (name) values ("%s")' % name)
return template('<b>Hello {{name}}</b>!<p><hr><br><a href="/">Back</a><br><a href="/list">List entries</a><p>', name=name)
else:
return template('index')
from bottle import route, response, request, get, post, TEMPLATE_PATH, template, static_file, redirect, abort
import redis
import uuid
from src import util, user
red = redis.StrictRedis(host='redis_01',port=6379,db=0)
TEMPLATE_PATH.insert(0,'/var/www/html/templates')
@get('/game/new')
def newGame():
new_hash = uuid.uuid4()
red.hset('sfb:game:' + str(new_hash), 'init', 1)
red.lpush('sfb:game:list', str(new_hash))
return str(new_hash)
@get('/game/<hash>')
def viewGame(hash):
cur_user = user.checkIfLoggedIn()
cur_players = red.hget('sfb:game:' + hash,'players')
if cur_players == None or len(cur_players) < 4:
red.lpush('sfb:game:' + hash + ':players',cur_user)
else:
return "Game is at maximum capacity"
if cur_user:
if red.hget('sfb:game:' + hash, 'init'):
num_players = red.lrange('sfb:game:' + hash + ':players',0,-1)
return template('game',hash=hash,user=cur_user,num_players=num_players)
return "This game does not exist"
abort(401,util.error401())
import os
from bottle import (get, post, redirect, request, route, run, static_file,
template, TEMPLATE_PATH, error)
import utils
import json
TEMPLATE_PATH.insert(0, os.path.dirname(__file__))
# Static Routes
@get("/js/<filepath:re:.*\.js>")
def js(filepath):
return static_file(filepath, root="./js")
@get("/css/<filepath:re:.*\.css>")
def css(filepath):
return static_file(filepath, root="./css")
@get("/images/<filepath:re:.*\.(jpg|png|gif|ico|svg)>")
def img(filepath):
return static_file(filepath, root="./images")
@route('/')
def index():
sectionTemplate = "./templates/home.tpl"
return template("./pages/index.html",
version=utils.getVersion(),
session_opts = {
# 'session.auto': True,
'session.cookie_expires': True,
'session.encrypt_key': 'please use a random key and keep it secret!',
'session.httponly': True,
# 'session.secure': True, # Uncoment when using with SSL
'session.timeout': 3600 * 24, # 1 day
'session.type': 'cookie',
'session.validate_key': True,
}
app_session = SessionMiddleware(app, session_opts)
# Misc settings
PROJECT_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)))
TEMPLATE_PATH.insert(0, '{0}/templates'.format(PROJECT_PATH))
# Session hook
@app.hook('before_request')
def setup_request():
"""Make session object accessible on all requests"""
request.session = request.environ.get('beaker.session')
# Static files
@app.get('/static/<filename:path>')
def static_files(filename):
"""Serve static files"""
return static_file(filename, root='{0}/static/'.format(PROJECT_PATH))
from bottle import static_file
from bottle import template
from bottle import view
from bottle import get
from bottle import request
from bottle import response
from bottle import TEMPLATE_PATH
import json
import os.path
import datetime
import logging
import adaat
app = Bottle()
WEB_PATH = os.path.dirname(os.path.realpath(__file__))
TEMPLATE_PATH.insert(0, os.path.join(WEB_PATH, "views"))
# define logger
# prepare logging
d = os.path.dirname(sys.argv[0])
LOG_FILENAME = os.path.join(d, u'tmp', 'logging_yaziji.out')
logging.basicConfig(
filename=LOG_FILENAME,
level=logging.INFO,
)
myLogger = logging.getLogger('Mishkal')
h = logging.StreamHandler(
) # in production use WatchedFileHandler or RotatingFileHandler
h.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
myLogger.addHandler(h)
