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, 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 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 __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 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_application(dbconf=None,cusconf=None,secret=None): log.startLogging(sys.stdout) base.update_secret(secret) utils.update_secret(secret) log.msg("start init application...") TEMPLATE_PATH.append("./customer/views/") ''' install plugins''' engine,metadata = models.get_engine(dbconf) sqla_pg = sqla_plugin.Plugin(engine,metadata,keyword='db',create=False,commit=False,use_kwargs=False) session = sqla_pg.new_session() _sys_param_value = functools.partial(get_param_value,session) _get_member_by_name = functools.partial(get_member_by_name,session) _get_account_by_number = functools.partial(get_account_by_number,session) _get_online_status = functools.partial(get_online_status,session) MakoTemplate.defaults.update(**dict( get_cookie = get_cookie, fen2yuan = utils.fen2yuan, fmt_second = utils.fmt_second, request = request, sys_param_value = _sys_param_value, system_name = _sys_param_value("2_member_system_name"), get_member = _get_member_by_name, get_account = _get_account_by_number, is_online = _get_online_status )) websock.connect( _sys_param_value('3_radiusd_address'), _sys_param_value('4_radiusd_admin_port') ) mainapp.install(sqla_pg)
def remove_plugin_templates_path(path): global env tmpl_path = make_templates_from_plugin_path(path) if tmpl_path in template_path: template_path.remove(tmpl_path) # for webhooks TEMPLATE_PATH.remove(tmpl_path) # for webviews env = Environment(loader=FileSystemLoader(template_path)) # ditch and recreate a new templating environment
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 page(project, page='index'): # 设定模版目录 TEMPLATE_PATH.append('./projects/%s/pages/' % project) context = { 'url': request.url, 'req': request.params } return jinja2_template(page, **context)
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 init_application(dbconf=None,consconf=None,secret=None): log.startLogging(sys.stdout) log.msg("start init application...") base.update_secret(secret) utils.update_secret(secret) TEMPLATE_PATH.append("./admin/views/") ''' install plugins''' log.msg("init plugins..") engine,metadata = models.get_engine(dbconf) sqla_pg = sqla_plugin.Plugin(engine,metadata,keyword='db',create=False,commit=False,use_kwargs=False) session = sqla_pg.new_session() _sys_param_value = functools.partial(get_param_value,session) _get_product_name = functools.partial(get_product_name,session) log.msg("init template context...") MakoTemplate.defaults.update(**dict( get_cookie = get_cookie, fen2yuan = utils.fen2yuan, fmt_second = utils.fmt_second, currdate = utils.get_currdate, request = request, sys_param_value = _sys_param_value, get_product_name = _get_product_name, system_name = _sys_param_value("1_system_name"), radaddr = _sys_param_value('3_radiusd_address'), adminport = _sys_param_value('4_radiusd_admin_port'), permit = permit, all_menus = permit.build_menus(order_cats=[u"系统管理",u"营业管理",u"运维管理"]) )) # connect radiusd websocket admin port log.msg("init websocket client...") wsparam = (MakoTemplate.defaults['radaddr'],MakoTemplate.defaults['adminport'],) reactor.callLater(3, websock.connect,*wsparam) log.msg("init tasks...") reactor.callLater(5, tasks.start_online_stat_job, sqla_pg.new_session) log.msg("init operator rules...") for _super in session.query(models.SlcOperator.operator_name).filter_by(operator_type=0): permit.bind_super(_super[0]) log.msg("install plugins...") mainapp.install(sqla_pg) ops_app.install(sqla_pg) bus_app.install(sqla_pg) card_app.install(sqla_pg) mainapp.mount("/ops",ops_app) mainapp.mount("/bus",bus_app) mainapp.mount("/card",card_app) #create dir try:os.makedirs(os.path.join(APP_DIR,'static/xls')) except:pass
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 setup_app(): root = os.path.dirname(os.path.abspath(__file__)) session_opts = { 'session.type': 'file', 'session.cookie_expires': 3600 * 10, 'session.data_dir': os.path.join(root, 'data/'), 'session.auto': True } app = Bottle() app = setup_routing(app) TEMPLATE_PATH.append(os.path.join(root, 'templates/')) TEMPLATE_PATH.remove('./views/') app = SessionMiddleware(app, session_opts) return app
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 page(project, page): # 设定模版目录 TEMPLATE_PATH.append('./projects/%s/pages/' % project) TEMPLATE_PATH.append('./projects/%s/layouts/' % project) site = 'http://%s' % request.environ.get('HTTP_HOST') context = { 'project': project, 'page': page, 'site': site, 'url': request.url, 'req': request.params, 'base': '/%s/' % project, 'static': '%s/%s/%s/' % (site, ASSET_NAME, project) } return jinja2_template(page, **context)
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 getimage(app): """Get image file.""" # append source directory to TEMPLATE_PATH so template is found srcdir = os.path.abspath(os.path.dirname(__file__)) TEMPLATE_PATH.append(srcdir) staticbase = '_static' buildpath = os.path.join(app.outdir, staticbase) try: os.makedirs(buildpath) except OSError: if not os.path.isdir(buildpath): raise if app.config.sphinxmark_image == 'default': imagefile = 'watermark-draft.png' imagepath = os.path.join(srcdir, imagefile) copy(imagepath, buildpath) LOG.debug('[sphinxmark] Using default image: ' + imagefile) elif app.config.sphinxmark_image == 'text': imagefile = createimage(app, srcdir, buildpath) LOG.debug('[sphinxmark] Image: ' + imagefile) else: imagefile = app.config.sphinxmark_image if app.config.html_static_path: staticpath = app.config.html_static_path[0] else: staticpath = '_static' LOG.debug('[sphinxmark] static path: ' + staticpath) imagepath = os.path.join(app.confdir, staticpath, imagefile) LOG.debug('[sphinxmark] Imagepath: ' + imagepath) try: copy(imagepath, buildpath) except Exception: message = ("Cannot find '%s'. Put watermark images in the " "'_static' directory or specify the location using " "'html_static_path'." % imagefile) LOG.warning(message) LOG.warning('Failed to add watermark.') return return(buildpath, imagefile)
def __init__(self, args=None): # Init args self.args = args # Init stats # Will be updated within Bottle route self.stats = None # Init Bottle self._app = Bottle() # Enable CORS (issue #479) self._app.install(EnableCors()) # Define routes self._route() # Update the template path (glances/outputs/bottle) TEMPLATE_PATH.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'bottle')) # Path where the statics files are stored self.STATIC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static')
def __init__(self, args=None): # Init args self.args = args # Init stats # Will be updated within Bottle route self.stats = None # Init Bottle self._app = Bottle() self._route() # Update the template path (glances/outputs/bottle) TEMPLATE_PATH.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'bottle')) # Path where the statics files are stored self.STATIC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'static') # Define the style (CSS) list (hash table) for stats self.__style_list = { 'DEFAULT': '', 'UNDERLINE': 'underline', 'BOLD': 'bold', 'SORT': 'sort', 'OK': 'ok', 'FILTER': 'filter', 'TITLE': 'title', 'CAREFUL': 'careful', 'WARNING': 'warning', 'CRITICAL': 'critical', 'OK_LOG': 'ok_log', 'CAREFUL_LOG': 'careful_log', 'WARNING_LOG': 'warning_log', 'CRITICAL_LOG': 'critical_log', 'NICE': 'nice', 'STATUS': 'status', 'PROCESS': '' }
def shift_local(): import os from bottle import TEMPLATE_PATH, default_app ON_OPENSHIFT = False if os.environ.has_key('OPENSHIFT_REPO_DIR'): ON_OPENSHIFT = True if ON_OPENSHIFT: TEMPLATE_PATH.append(os.path.join(os.environ['OPENSHIFT_HOMEDIR'], 'runtime/repo/wsgi/views/')) application=default_app() else: import commands from bottle import run print "AdNail - Interfaces disponibles: " print commands.getoutput("/sbin/ifconfig | egrep -o '^[a-z].......'") intfz = raw_input('Introduce la interfaz a utilizar: ') comand = "/sbin/ifconfig "+intfz+" | egrep -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | egrep -v '*(0|255)$'" iphost = commands.getoutput(comand) print "La IP del Servidor es: ", iphost run(host=iphost, port=8080, debug=True)
from bottle import route, default_app @route('/name/<name>') def nameindex(name='Stranger'): return '<strong>Hello, %s!</strong>' % name @route('/') def index(): return '<strong>Hello World!</strong>' # This must be added in order to do correct path lookups for the views import os from bottle import TEMPLATE_PATH TEMPLATE_PATH.append( os.path.join(os.environ['OPENSHIFT_REPO_DIR'], 'wsgi/views/')) application = default_app()
# Static routes: css, js, images, ... @get('/<filename:re:.*\.js>') def javascripts(filename): return static_file(filename, root=os.environ['OPENSHIFT_REPO_DIR']+'/wsgi/static/js') @get('/<filename:re:.*\.css>') def stylesheets(filename): return static_file(filename, root=os.environ['OPENSHIFT_REPO_DIR']+'/wsgi/static/css') @get('/<filename:re:.*\.(jpg|png|gif|ico)>') def images(filename): return static_file(filename, root=os.environ['OPENSHIFT_REPO_DIR']+'/wsgi/static/img') @get('/<filename:re:.*\.(eot|ttf|woff|svg)>') def fonts(filename): return static_file(filename, root=os.environ['OPENSHIFT_REPO_DIR']+'/wsgi/static/fonts') @get('/<filename:re:.*\.(doc|pdf)>') def fonts(filename): return static_file(filename, root=os.environ['OPENSHIFT_REPO_DIR']+'/wsgi/static/resources') # This must be added in order to do correct path lookups for the views import os from bottle import TEMPLATE_PATH TEMPLATE_PATH.append(os.path.join(os.environ['OPENSHIFT_REPO_DIR'], 'wsgi/views/')) application=default_app()
__author__ = 'arobres' from bottle import run, template, Bottle, request, response, auth_basic, redirect, static_file, TEMPLATE_PATH from constants import THEME, SUBJECT, MESSAGES from collections import defaultdict import ujson from sys import argv import os from time import sleep TEMPLATE_PATH.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "."))) app = Bottle() user_list = [] USER_ATTRIBUTES = {'name', 'username', 'password', 'role', 'email'} FORUM_ATTRIBUTES = {'theme', 'subject', 'message'} ROLES = ['QA', 'DEVELOPER', 'MANAGER'] THEMES = ['Security', 'Development', 'Automation', 'Testing'] user_messages_dict = defaultdict(list) forum_messages_dict = defaultdict(list) def check_username(username, password): for user in user_list: if user['username'] == username: if user['password'] == password: return True return False
#-*-coding:utf8;-*- #qpy:3 #Liwal WebApp #http://localhost:8080/ """ main.py """ import json from pprint import pprint from bottle import route, run, template, TEMPLATE_PATH with open('/storage/emulated/0/qpython/repos/Liwal/settings.json' ) as settings_file: settings = json.load(settings_file) pprint(settings) TEMPLATE_PATH.insert(0, settings['root_path'] + 'views') #import controllers: import controller.home run(host=settings['host'], port=settings['port'])
# -*- coding: utf-8 -*- __version__ = '0.1' import sys import os from bottle import Bottle, TEMPLATE_PATH app = Bottle(autojson=False) app_root_path = sys.path[0] TEMPLATE_PATH.append(os.path.join(app_root_path, "project", "views")) TEMPLATE_PATH.remove("./views/") from project.controller import *
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
#!/usr/bin/env python # -*- encoding: utf-8 -*- from bottle import get, post, redirect, request, run, static_file, template, TEMPLATE_PATH from calendar import month_name from datetime import date from os import getenv from os.path import dirname, join as path_join from py2neo import Graph, watch from demo.moviegraph.model import Movie, Person, Comment home = dirname(__file__) static = path_join(home, "static") TEMPLATE_PATH.insert(0, path_join(home, "views")) # Set up a link to the local graph database. graph = Graph(password=getenv("NEO4J_PASSWORD")) watch("neo4j.bolt") @get('/css/<filename:re:.*\.css>') def get_css(filename): return static_file(filename, root=static, mimetype="text/css") @get('/images/<filename:re:.*\.png>') def get_image(filename): return static_file(filename, root=static, mimetype="image/png")
from bottle import get, post, route, run, template, TEMPLATE_PATH, request, redirect, static_file import os TEMPLATE_PATH.insert(0, "./views") root = os.getcwd() #------------------------------------------------------------------------------------------------ # DATABASE CONNECTIVITY #------------------------------------------------------------------------------------------------ # import pymongo # client = pymongo.MongoClient("mongodb://*****:*****@route('/static/<filepath:path>') def serve_static(filepath): myroot = os.path.join(root, "static") return static_file(filepath, root=myroot) @get('/') @get('/home') def home(): return template('home')
# -*- 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])
"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)
def __init__(self): self.BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # テンプレートファイルを設置するディレクトリのパスを指定 TEMPLATE_PATH.append(self.BASE_DIR + "/templetes") self.md = markdown.Markdown() self.html = ''
from beaker.middleware import SessionMiddleware from mining.controllers.api import api_app from mining.controllers.stream import stream_app from mining.controllers.export import export_app from mining.utils import conf from mining.auth import auth from mining.settings import TEMPLATE_PATH, STATIC_PATH from mining.celeryc import celery_app from mining.bin.scheduler import scheduler_app from mining.bin.demo.build_admin import build reload(sys) sys.setdefaultencoding('utf-8') T.insert(0, TEMPLATE_PATH) session_opts = { 'session.type': 'file', 'session.data_dir': '/tmp/openmining.data', 'session.lock_dir': '/tmp/openmining.lock', 'session.cookie_expires': 50000, 'session.auto': True } app = SessionMiddleware(Bottle(), session_opts) app.wrap_app.mount('/api', api_app) app.wrap_app.mount('/stream', stream_app) app.wrap_app.mount('/export', export_app) app.wrap_app.install(auth)
from bottle import request, response, route, run, static_file, template, TEMPLATE_PATH import os import io from ..imgsteg import Imgsteg base = os.path.abspath(os.path.dirname(__file__)) TEMPLATE_PATH.insert(0, os.path.join(base, "views/")) file = None @route('/static/<filename:path>') def send_static(filename): return static_file(filename, root=os.path.join(base, 'static/')) @route("/") def index(): return template('index') @route("/api/<command>", method="POST") def inversion(command): im = Imgsteg(file) # print(command) new_im = None if command == "original": new_im = im.im elif command == "inversion":
# -- determine where I launch python and config lib path # base_dir = os.path.dirname(__file__) # third_party_path = os.path.abspath(os.path.join(base_dir, 'third_party' )) # sys.path.insert(0, third_party_path) # -- common bottle importation with warnings.catch_warnings(): warnings.simplefilter("ignore") from bottle import TEMPLATE_PATH, Bottle, run, static_file, debug, request from bottle import jinja2_view as view, jinja2_template as template debug(True) base_dir = os.path.dirname(__file__) TEMPLATE_PATH.append(os.path.abspath(os.path.join(base_dir, 'views'))) # -- the instance app is important app = Bottle() # -- serve static files, files located in static static_folder = 'static' _static_folder = os.path.join(os.path.dirname(__file__), static_folder) @app.route('/stats/region/:chrom', method='GET') def stats_region(chrom): # Note: chrom is give as an argument # we then extract start and end using HTML GET start = request.GET.get('start', '').strip()
def __init__(self): self._app = Bottle() self._controller = video_controller.make_video_controller() TEMPLATE_PATH.insert(0, os.path.join(app_path, 'views')) SimpleTemplate.defaults['get_url'] = self._app.get_url
def build_application(): # XXX Define application routes in this class app = Bottle() # Pretty much this entire function needs to be written for your 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('/', name='index') # XXX URL to page @view('index') # XXX Name of template def index(): 'A simple form that shows the date' import datetime now = datetime.datetime.now() # any local variables can be used in the template return locals() # XXX User list page @app.route('/users', name='user_list') # XXX URL to page @view('users') # XXX Name of template def user_list(): 'A simple page from a dabase.' db = dbwrap.session() users = db.query(model.User).order_by(model.User.name) # any local variables can be used in the template return locals() # XXX User details dynamically-generated URL @app.route('/users/<username>', name='user') # XXX URL to page @view('user') # XXX Name of template def user_info(username): 'A simple page from a dabase.' user = model.user_by_name(username) # any local variables can be used in the template return locals() # XXX A simple form example, not used on the demo site @app.route('/form') # XXX URL to page @view('form') # XXX Name of template def static_form(): 'A simple form processing example' form = NewUserFormProcessor(request.forms.decode()) if request.method == 'POST' and form.validate(): # XXX Do something with form fields here # if successful redirect('/users/%s' % form.name.data) # any local variables can be used in the template return locals() # XXX Create a new user, form processing, including GET and POST @app.get('/new-user', name='user_new') # XXX GET URL to page @app.post('/new-user') # XXX POST URL to page @view('user-new') # XXX Name of template def new_user(): 'A sample of interacting with a form and a database.' form = NewUserFormProcessor(request.forms.decode()) if request.method == 'POST' and form.validate(): db = dbwrap.session() sean = model.User(full_name=form.full_name.data, name=form.name.data, email_address=form.email_address.data) db.add(sean) db.commit() redirect(app.get_url('user', username=form.name.data)) # any local variables can be used in the template return locals() # REQUIRED: return the application handle herre return app
format="%(asctime)s - %(levelname)s - %(message)s") CLIENT_ID = "e29426dfb22c41cdbc92122fbb9c398c" CLIENT_SECRET = "837fd2824bec47e5a003419165674bdd" SCOPE = "user-top-read user-read-recently-played playlist-modify-public playlist-modify-private" CACHE = ".spotifyoauthcache" CLIENT_CREDENTIALS = SpotifyClientCredentials(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) SP_OAUTH2 = oauth2.SpotifyOAuth(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri="http://localhost:8000/verified", scope=SCOPE, cache_path=CACHE) LIMIT = 50 OFFSET = 0 TEMPLATE_PATH.insert(0, "") # global functions def get_token(): access_token = "" token_info = SP_OAUTH2.get_cached_token() if token_info: access_token = token_info["access_token"] else: url = request.url code = SP_OAUTH2.parse_response_code(url) if code: print("Found Spotify auth code in Request URL! " "Trying to get valid access token...")
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():
import os from bottle import Bottle, route, run, request, response, static_file from bottle import TEMPLATE_PATH, jinja2_template as template app = Bottle() #ボトルのインスタンス作成 # index.pyが設置されているディレクトリの絶対パスを取得 BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # テンプレートファイルを設置するディレクトリのパスを指定 TEMPLATE_PATH.append(BASE_DIR + "/views") # python ./main.py を直接実行したときはローカルサーバーを立ち上げる if __name__ == "__main__": run(app=app, host="localhost", port=8081, quiet=False, reloader=True)
#!/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():
def main(template_path): TEMPLATE_PATH.insert(0, template_path) @get("/static/<filename>") def serve_static_files(filename): """Function to serve CSS and JS files""" return static_file(filename, root='python-pyzftp/static') @route("/zftp", method=["GET", "POST"]) def process_form(): """Function to display main webpage and process the form contents""" global statuses, anyerror if not anyerror: machine = "" userid = "" pswd = "" ftno = 1 checked1 = "checked" checked2 = "" checked3 = "checked" checked4 = "" dsn = "" filname = "" else: for k1, v1 in statuses.items(): machine = v1["machine"] userid = v1["userid"] pswd = v1["pswd"] ftno = "" checked1 = "" checked2 = "" checked3 = "" checked4 = "" dsn = "" filname = "" break if request.method == "GET": return template("zftpmain", machine=machine, userid=userid, pswd=pswd, ftno=ftno, checked1=checked1, checked2=checked2, checked3=checked3, checked4=checked4, dsn=dsn, filname=filname, anyerror=anyerror, statuses=statuses) elif request.method == "POST": statuses = {} anyerror = False ismachine_exist = True iscred_exist = True isfile_exist = True iserror = False # get all the name attributes from the submitted form keylst = list(request.forms.keys()) trnsfr1lst = [key for key in keylst if "trsfrno" in key] trnsfr2lst = [ int(key.replace("trsfrno", "")) for key in trnsfr1lst ] machine = request.forms.get("machine") userid = request.forms.get("userid") pswd = request.forms.get("pswd") # try catch hostname/ip error try: host = FTP(machine) except: ismachine_exist = False # try catch credentials error try: if ismachine_exist: host.login(userid, pswd) except: iscred_exist = False host.quit() if not ismachine_exist or not iscred_exist: iserror = True anyerror = True threads = [] for trsfrno in trnsfr2lst: ckey1 = "ftpverb-radio" + str(trsfrno) ckey2 = "ftpformat-radio" + str(trsfrno) if request.forms.get(ckey1) == "receive": get = True else: get = False if request.forms.get(ckey2) == "text": text = True else: text = False dsnkey = "dsn" + str(trsfrno) filnamekey = "filename" + str(trsfrno) dsn = request.forms.get(dsnkey) dsn = dsn.replace("'", "") dsn = dsn.replace('"', "") dsn = "'" + dsn + "'" filname = request.forms.get(filnamekey) if get: if text: # log = f"{trsfrno} transfer starts.." # print(log) thread = Thread(target=gettext, args=(machine, userid, pswd, trsfrno, dsn, filname, ismachine_exist, iscred_exist, isfile_exist, iserror)) threads.append(thread) else: # log = f"{trsfrno} transfer starts.." # print(log) thread = Thread(target=getbinary, args=(machine, userid, pswd, trsfrno, dsn, filname, ismachine_exist, iscred_exist, isfile_exist, iserror)) threads.append(thread) else: if text: # log = f"{trsfrno} transfer starts.." # print(log) thread = Thread(target=puttext, args=(machine, userid, pswd, trsfrno, dsn, filname, ismachine_exist, iscred_exist, isfile_exist, iserror)) threads.append(thread) else: # log = f"{trsfrno} transfer starts.." # print(log) thread = Thread(target=putbinary, args=(machine, userid, pswd, trsfrno, dsn, filname, ismachine_exist, iscred_exist, isfile_exist, iserror)) threads.append(thread) for thread in threads: thread.daemon = True thread.start() for thread in threads: thread.join() redirect("/zftp/status") @route("/zftp/status", method=["GET"]) def showmessages(): """Function to display status webpage""" return template("zftpstatus", statuses=statuses) run(host="localhost", port=9001, debug=True) # uses socket - localhost:9001 return
# -*- coding: utf-8 -*- __version__ = '0.1' from bottle import Bottle, TEMPLATE_PATH app = Bottle() TEMPLATE_PATH.append("./chanelist/views/") from chanelist.controllers import *
from bottle import TEMPLATE_PATH, install, run, BaseRequest import os from logit import logit TEMPLATE_PATH.insert(0, os.getenv('SITE_TEMPLATES', '')) # routes are here and use default_app, to be after app and db setup import routes.web_handlers import routes.api_handlers BaseRequest.MEMFILE_MAX = 1024 * 1024 logit('starting breadcrumbs') if __name__ == '__main__': run(host=os.getenv('SITE_HOST', '127.0.0.1'), port=eval(os.getenv('SITE_PORT', "8080")), debug=eval(os.getenv('SITE_DEBUG', 'True')))
import os from bottle import TEMPLATE_PATH, route, static_file, template, install, request from app.apod import Apod BASE_PATH = os.path.dirname(os.path.abspath(__file__)) TEMPLATE_PATH.append(BASE_PATH + "/templates") @route('/', method='GET') @route('/<date>', method='GET') def index(date=None): return template('index.tpl') @route('/about', method='GET') def about(): return template('about.tpl') @route('/apod/:date', method='GET') def apod(date): apod = Apod(date) return { "title": apod.title, "image_credit": apod.image_credit, "low_res_image_path": apod.low_res_image_path, "high_res_image_path": apod.high_res_image_path, "explanation": apod.explanation.decode('utf-8', 'ignore'), "date": apod.date,
from bottle import route, run, template, request, redirect, error, static_file, TEMPLATE_PATH, get, post, hook, app from bottle.ext import beaker from datetime import datetime, date import sqlite3 import os import datetime import json import websockets abs_app_dir_path = os.path.dirname(os.path.realpath(__file__)) abs_views_path = os.path.join(abs_app_dir_path, "views") abs_static_path = os.path.join(abs_app_dir_path, "static") TEMPLATE_PATH.insert(0, abs_views_path) session_opts = { "session.type": "file", "session.cookie_expires": True, "session.data_dir": "./data", "session.auto": True } app = beaker.middleware.SessionMiddleware(app(), session_opts) @hook("before_request") def setup_request(): request.session = request.environ["beaker.session"] @route("/static/<filename>") def server_static(filename):
return template('jornada', datos=datos, ronda=ronda) @error(404) def error404(error): return template('errores') @error(500) def error500(error): return template('errores') @error(405) def error405(error): return template('errores') ON_OPENSHIFT = False if os.environ.has_key('OPENSHIFT_REPO_DIR'): ON_OPENSHIFT = True if ON_OPENSHIFT: TEMPLATE_PATH.append( os.path.join(os.environ['OPENSHIFT_HOMEDIR'], 'app-root/repo/wsgi/views/')) application = default_app() else: run(host='localhost', port=8080)
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()
def register_ui_views(app): BaseTemplate.defaults['app'] = app # Template global variable # Location of HTML templates TEMPLATE_PATH.insert( 0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../templates'))) # TODO: API and UI must use the same adapter adapter_type = ZKAdapter # TODO: format errors in a nice UI instead of abort # Routes to static content @app.route('/<path:re:favicon.ico>') @app.route('/static/<path:path>', name='static') def static(path): 'Serve static content.' return static_file(path, root='flags/static/') @app.route('/', name='applications', method=["GET", "POST"]) @view('applications') # Name of template def index(): if request.method == "POST": application_name = request.forms.new_application if application_name: try: with adapter_type() as adapter: adapter.create_application(application_name) except KeyExistsError: abort(409, "Application %s already exists." % application_name) else: abort(400, "Please provide a name for the new application.") default = "Enabled" if settings.DEFAULT_VALUE else "Disabled" with adapter_type() as adapter: applications = adapter.get_applications() # any local variables can be used in the template return locals() @app.route('/<application_name>/features', name='features', method=["GET", "POST"]) @view('features') # Name of template def features(application_name): application_name = application_name.lower() saved = False added = False error = None abort = False if request.method == "POST": feature_chck_name_tmpl = "%s_checkbox" segment_chck_name_tmpl = "%s_%s_checkbox" option_chck_name_tmpl = "%s_%s_%s_checkbox" with adapter_type() as adapter: segments = adapter.get_all_segments(application_name) features = adapter.get_all_features(application_name) for feature in features: # a checkbox is checked if it exists in request.forms feature_dict = { "feature_toggled": True if request.forms.get(feature_chck_name_tmpl % feature) else False, "segmentation": { segment: { "toggled": True if request.forms.get( segment_chck_name_tmpl % (feature, segment)) else False, "options": { option: True if request.forms.get( option_chck_name_tmpl % (feature, segment, option)) else False for option in segments[segment] } } for segment in segments } } adapter.update_feature(application_name, feature, feature_dict) saved = True default = "Enabled" if settings.DEFAULT_VALUE else "Disabled" try: with adapter_type() as adapter: features = adapter.get_all_features(application_name) except KeyDoesNotExistError: error = "Application %s does not exist." % application_name abort = True # any local variables can be used in the template return locals() # TODO: change this crappy URL later @app.post('/<application_name>/create', name='create') @view('features') # Name of template def create_feature(application_name): application_name = application_name.lower() feature_name = request.forms.new_feature added = False saved = False error = None abort = False if feature_name: try: with adapter_type() as adapter: adapter.create_feature(application_name, feature_name) added = True except KeyExistsError: error = ("Feature %s already exists for application %s." % (feature_name, application_name)) else: error = "Please provide a name for the new feature." # TODO: redirect to features instead of this block default = "Enabled" if settings.DEFAULT_VALUE else "Disabled" try: with adapter_type() as adapter: features = adapter.get_all_features(application_name) except KeyDoesNotExistError: error = "Application %s does not exist." % application_name abort = True # any local variables can be used in the template return locals() @app.route('/<application_name>/segments', name='segments', method=["GET", "POST"]) @view('segments') # Name of template def segments(application_name): application_name = application_name.lower() if request.method == "POST": segment_name = request.forms.new_segment if segment_name: try: with adapter_type() as adapter: adapter.create_segment(application_name, segment_name) except KeyExistsError: abort( 409, "Segment %s already exists for application %s." % (segment_name, application_name)) else: abort(400, "Please provide a name for the new segment.") try: with adapter_type() as adapter: segments = adapter.get_all_segments(application_name) except KeyDoesNotExistError: abort(404, "Application %s does not exist." % application_name) # any local variables can be used in the template return locals() @app.post('/<application_name>/options/<segment>', name='options') def options(application_name, segment): option_name = request.forms.new_option if option_name: try: with adapter_type() as adapter: adapter.create_segment_option(application_name, segment, option_name) except KeyExistsError: abort( 409, "Option %s already exists for segment %s in " "application %s." % (option_name, segment, application_name)) else: abort(400, "Please provide a name for the new segment option.") redirect(app.get_url('segments', application_name=application_name))
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 = ""):
from bottle import get from bottle import request from bottle import response from bottle import TEMPLATE_PATH import datetime import logging import json import os.path sys.path.append(os.path.join(os.path.dirname(sys.argv[0]), '../../')) import core.adaat app = Bottle() #~ xpath = os.path.join(os.path.dirname(__file__), 'views') xpath = os.path.dirname(os.path.realpath(__file__)) #~ print("xpath", xpath) TEMPLATE_PATH.insert(0, os.path.join(xpath, "views")) #---------------------------------- # define logger # prepare logging #--------------------------------- d = os.path.dirname(sys.argv[0]) LOG_FILENAME = os.path.join(d,u'tmp','logging_mishkal.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) myLogger.setLevel(logging.INFO) # in production use logging.INFO
import os import sys from bottle import run, template, route, request, static_file, Response, app, TEMPLATE_PATH from datahandle import dataeng import time import datetime TEMPLATE_PATH.insert( 0, 'C:/Users/BRUNO - PC/REPOS_GIT/DataloggerDHT22/Tests web server/Python/webserver' ) NAME_DB = 'fauba_dataloggers.db' DIRECTORY_DB = "C:/Users/BRUNO - PC/REPOS_GIT/DataloggerDHT22/Tests web server/Python/webserver" MEASUREMENTS_TABLE_NAME = 'MEASUREMENTS' DEVICES_STATE_TABLE_NAME = 'DEVICES_STATUS' DB_COLUMN_NAME_ID_TRANSCEIVER = 'ID_TRANSCEIVER' DB_COLUMN_NAME_BATTERY_LEVEL = 'BATTERY_LEVEL' DB_COLUMN_NAME_ID_SENSOR = 'ID_SENSOR' DB_COLUMN_NAME_TIMESTAMP = 'TIMESTAMP' DB_COLUMN_NAME_DATE_TIME = 'DATE_TIME' DB_COLUMN_NAME_TEMPERATURE = 'TEMPERATURE' DB_COLUMN_NAME_HUMIDITY = 'HUMIDITY' localdir = str(sys.path[0]) def initDB(dir, nameDB): print('DB directory to open: ' + str(dir + '\\' + nameDB)) #debug db = dataeng.DataEngine( dir + '\\' + nameDB, debugmode=False ) #Create DataEngine object with the database directory. Will create dir if it doesn't exist.
import logging import os from jinja2 import Environment, FileSystemLoader from bottle import TEMPLATE_PATH log = logging.getLogger(__name__) 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): log.debug("Templates directory found for this plugin [%s]" % tmpl_path)
__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):
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import unicode_literals import os import sys import click from bottle import static_file, Bottle, run, TEMPLATE_PATH, request from beaker.middleware import SessionMiddleware from requester import settings from requester.routes import Routes from requester.utils import validate_input, hash_password import sqlite3 TEMPLATE_PATH.insert(0, settings.TEMPLATE_PATH) session_opts = { 'session.type': 'cookie', 'session.cookie_expires': True, 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.validate_key': True, 'session.auto': True, } app = SessionMiddleware(Bottle(), session_opts) # Bottle Routes app.wrap_app.merge(Routes) @app.wrap_app.route('/assets/<path:path>', name='assets')
import os import sqlite3 # 課題2の答えはここ(一番右) 時間を取得するためにimportする from bottle import route, run, debug, template, request, static_file, error, redirect, response , datetime , get, TEMPLATE_PATH # secrets.token_hex([nbytes=None]) # 十六進数のランダムなテキスト文字列を返します。文字列は nbytes のランダムなバイトを持ち、各バイトは二つの十六進数に変換されます。nbytes が None の場合や与えられなかった場合は妥当なデフォルト値が使われます。 import secrets TEMPLATE_PATH.insert(0, os.path.abspath(os.path.join(os.path.dirname("__file__"), "../ref03"))) secret_cookie = secrets.token_hex() print(secret_cookie) @route('/') def index(): print("ここでもsecret_cookie:" + secret_cookie) return template('index') # GET /register => 登録画面を表示 # POST /register => 登録処理をする @route('/register',method=["GET", "POST"]) def register(): # 登録ページを表示させる if request.method == "GET": # ログインしてないからクッキーがセットされてない name = request.get_cookie("user_id" , secret="secret_cookie") if name is None: return template("register") else:
import os import ssl # Note: any modules that supply bottle functionality need to be imported # here even though they aren't used directly. import shared_cfg import authentication import navigation import manage_passwords log = logging.getLogger(__name__) # Tell bottle to look in these directories for templates. RBB_EXPORT_DIRECTORY = 'web-ui_exported' GENERATED_TEMPLATE_DIRECTORY = 'generated_templates' TEMPLATE_PATH.append('./{0}/'.format(RBB_EXPORT_DIRECTORY)) TEMPLATE_PATH.append('./{0}/'.format(GENERATED_TEMPLATE_DIRECTORY)) @get('/css/<filename:re:.*\.css>') def send_css(filename): global RBB_EXPORT_DIRECTORY return static_file(filename, root='{0}/css'.format(RBB_EXPORT_DIRECTORY)) @get('/fonts/<filename:re:.*\.(eot|svg|ttf|woff)>') def send_font(filename): global RBB_EXPORT_DIRECTORY return static_file(filename, root='{0}/fonts'.format(RBB_EXPORT_DIRECTORY))
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())
# Licença Pública Geral GNU para maiores detalhes. # # Você deve ter recebido uma cópia da Licença Pública Geral GNU # junto com este programa, se não, veja em <http://www.gnu.org/licenses/> """Handle http requests. .. moduleauthor:: Carlo Oliveira <*****@*****.**> """ import os import sys import logging as log from bottle import TEMPLATE_PATH LOG_LEVEL = int(os.getenv("LABASELOG", log.ERROR)) log.basicConfig(level=LOG_LEVEL) P_N_O_D_E_D = "S_N_O_D_E-%02d" HERE = os.path.dirname(__file__) SRC_DIR = os.path.join(HERE, "views") # add your project directory to the sys.path project_home = HERE # os.path.join(here, "src/") if project_home not in sys.path: sys.path = [project_home] + sys.path # make sure the default templates directory is known to Bottle templates_dir = os.path.join(project_home, 'views/') if templates_dir not in TEMPLATE_PATH: TEMPLATE_PATH.insert(0, templates_dir)
import os import pymongo import string from bottle import TEMPLATE_PATH, route, jinja2_template as template, request, response from models import * from bottle import static_file, request import urllib import urllib2 import sys import json import datetime TEMPLATE_PATH.append('./templates') sys.path.append('./backend/configs') sys.path.append('./backend') import apilib APP_CONFIG = {} APP_CONFIG["DBNAME"] = "gigzibit" APP_CONFIG["LOGTABLE"] = "log" APP_CONFIG["THUMBNAIL_COLOR"] = "#FEFEFE" APP_CONFIG["HEADING_COLOR"] = "#EBE0D6" APP_CONFIG["NAV_COLOR"] = "#FDFDFA" @route('/bootstrap/<dir1>/<dir2>/:filename') def serve_static(dir1, dir2, filename): return static_file(dir1 + '/' + dir2 + '/' + filename, root='./bootstrap/docs/') @route('/HTML-KickStart/<dir1>/:filename') def serve_static(dir1, filename): return static_file(dir1 + '/' + filename, root='./HTML-KickStart/')
from bottle import run, template, static_file, get, post, delete, request, TEMPLATE_PATH import json import os import database_sql TEMPLATE_PATH.insert(0, os.path.dirname(__file__)) @get("/admin") def admin_portal(): return template("pages/admin.html") @get("/") def index(): return template("index.html") @get('/js/<filename:re:.*\.js>') def javascripts(filename): return static_file(filename, root='js') @get('/css/<filename:re:.*\.css>') def stylesheets(filename): return static_file(filename, root='css') @get('/images/<filename:re:.*\.(jpg|png|gif|ico)>') def images(filename): return static_file(filename, root='images')