def app(self):
app = Sanic(__name__)
self.jinja = SanicJinja2(
app,
loader=FileSystemLoader(
[str(app_root / 'datasette' / 'templates')]),
autoescape=True,
)
self.jinja.add_env('escape_css_string', escape_css_string, 'filters')
self.jinja.add_env('quote_plus', lambda u: urllib.parse.quote_plus(u),
'filters')
self.jinja.add_env('escape_table_name', escape_sqlite_table_name,
'filters')
app.add_route(IndexView.as_view(self), '/<as_json:(.jsono?)?$>')
# TODO: /favicon.ico and /-/static/ deserve far-future cache expires
app.add_route(favicon, '/favicon.ico')
app.static('/-/static/', str(app_root / 'datasette' / 'static'))
app.add_route(DatabaseView.as_view(self),
'/<db_name:[^/\.]+?><as_json:(.jsono?)?$>')
app.add_route(DatabaseDownload.as_view(self),
'/<db_name:[^/]+?><as_db:(\.db)$>')
app.add_route(TableView.as_view(self),
'/<db_name:[^/]+>/<table:[^/]+?><as_json:(.jsono?)?$>')
app.add_route(
RowView.as_view(self),
'/<db_name:[^/]+>/<table:[^/]+?>/<pk_path:[^/]+?><as_json:(.jsono?)?$>'
)
return app
def test_template_basics(self):
app = get_app()
jinja = SanicJinja2(app, autoescape=True)
babel.Babel(app, default_locale='de_DE')
t = lambda x, request: jinja.render_source('{{ %s }}' % x, request)
request, response = app.test_client.get('/')
assert t("gettext('Hello %(name)s!', name='Peter')", request) == \
'Hallo Peter!'
assert t("ngettext('%(num)s Apple', '%(num)s Apples', 3)",
request) == '3 Äpfel'
assert t("ngettext('%(num)s Apple', '%(num)s Apples', 1)",
request) == '1 Apfel'
assert jinja.render_source('''
{% trans %}Hello {{ name }}!{% endtrans %}
''',
request,
name='Peter').strip() == 'Hallo Peter!'
assert jinja.render_source('''
{% trans num=3 %}{{ num }} Apple
{%- pluralize %}{{ num }} Apples{% endtrans %}
''',
request,
name='Peter').strip() == '3 Äpfel'
def add_routes(self):
"""TBD."""
self.jinja = SanicJinja2(
self.app,
# enable_async=False,
auto_reload=False)
self.app.static(
'/static',
os.path.dirname(os.path.abspath(sys.modules['__main__'].__file__))
+ '/static')
self.app.add_route(self.handle, '/', methods=['GET', 'POST'])
self.app.add_route(
self.async_good,
'/good',
)
self.app.add_route(
self.action_bad,
'/bad',
)
self.app.add_route(
self.action_ugly,
'/ugly',
)
self.app.add_route(
self.action_about,
'/about',
)
self.app.add_route(self.stickers_api, '/stickers')
self.app.add_route(self.stickers_api_packs, '/stickers/<packs>')
self.app.add_route(self.stickers_api_packs_stickers,
'/stickers/<packs>/<stickers>')
def _setup_jinja2_renderer(self):
spf, plugin_name, plugin_prefix = self.spf_reg
loader = PackageLoader(__name__, 'templates')
enable_async = cur_py_version >= async_req_version
context = restplus.get_context_from_spf(self.spf_reg)
# Don't try to use an already registered Jinja2-plugin, it causes too much incompatibility with template
# loaders. Just use a new one of our own.
j2 = SanicJinja2(context.app,
loader=loader,
pkg_name=plugin_name,
enable_async=enable_async)
def swagger_static(filename):
nonlocal self
spf, plugin_name, plugin_prefix = self.spf_reg
endpoint = '{}.static'.format(str(self._uid))
return restplus.spf_resolve_url_for(spf,
endpoint,
filename=filename)
def config():
nonlocal self, context
app = context.app
if isinstance(app, Blueprint):
return {}
return app.config
if enable_async:
async def api_renderer(request, api, request_context):
"""Render a SwaggerUI for a given API"""
nonlocal j2, swagger_static, config
j2.add_env('swagger_static', swagger_static)
j2.add_env('config', config())
return await j2.render_async('swagger-ui.html',
request,
title=api.title,
specs_url=api.specs_url,
additional_css=api.additional_css)
else:
def api_renderer(request, api, request_context):
"""Render a SwaggerUI for a given API"""
nonlocal j2, swagger_static, config
j2.add_env('swagger_static', swagger_static)
j2.add_env('config', config())
return j2.render('swagger-ui.html',
request,
title=api.title,
specs_url=api.specs_url,
additional_css=api.additional_css)
return api_renderer
def run(args):
app = Sanic('brego')
app.static('/static/', 'brego/client/')
jinja = SanicJinja2(app, pkg_name='brego')
db = SensorDB()
http_sensor_stream_route(app, args.sensors_socket)
websocket_sensor_stream_route(app, args.sensors_socket)
dashboard_route(app, jinja)
devices_route(app, db)
app.run(host=args.host,
port=args.port,
debug=True,
protocol=WebSocketProtocol)
from sanic_jinja2 import SanicJinja2
from peewee_async import Manager, PooledMySQLDatabase
jinja2 = SanicJinja2()
database = PooledMySQLDatabase('gateway',
host='10.39.34.123',
port=3306,
user='******',
password='******')
objects = Manager(database)
from jinja2 import PackageLoader, select_autoescape
from sanic_session import InMemorySessionInterface, RedisSessionInterface
import asyncio_redis
import asyncio
import json, logging
import traceback as tb
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s - %(name)s - %(filename)s[%(lineno)d] - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
jinja = SanicJinja2(
loader=PackageLoader('templates'),
autoescape=select_autoescape(['html', 'xml']),
)
app = Sanic(__name__)
app.static('/static', './static')
HOST = {}
class Redis:
_pool = None
async def get_redis_pool(self):
if not self._pool:
self._pool = await asyncio_redis.Pool.create(host='localhost',
port=6379,
self.registered = True
@property
def config(self):
if self.app:
return self.app.config
return {}
def url_for(self, *args, **kwargs):
return self.app.url_for(*args, **kwargs)
apidoc = Apidoc('restplus_doc', None)
loader = PackageLoader(__name__, 'templates')
j2 = SanicJinja2(apidoc, loader)
module_path = os.path.abspath(os.path.dirname(__file__))
module_static = os.path.join(module_path, 'static')
if os.path.isdir(module_static):
apidoc.static('/swaggerui', module_static)
else:
apidoc.static('/swaggerui', './sanic_restplus/static')
def swagger_static(filename):
#url = j2.app.url_for('restplus_doc.static')
return '/swaggerui/bower/swagger-ui/dist/{0}'.format(filename)
def config():
if not self._pool:
self._pool = await asyncio_redis.Pool.create(host='localhost',
port=6379,
poolsize=10)
return self._pool
config = configparser.ConfigParser()
config.read('config.ini')
app = Sanic()
app.config.REQUEST_MAX_SIZE = 100 * 1024 * 1024 # 100MB
app.static('/r', './resources')
app.static('/static', './static')
jinja = SanicJinja2(app)
redis_connection = Redis()
q = Queue(connection=redis_connection)
dynamodb = boto3.resource('dynamodb')
redis = Redis_pool()
# pass the getter method for the connection pool into the session
session_interface = RedisSessionInterface(redis.get_redis_pool)
es = Elasticsearch([config['ELASTICSEARCH']['HOST']],
use_ssl=True,
ca_certs=certifi.where())
@app.middleware('request')
async def add_session_to_request(request):
from sanic import Sanic
from sanic.response import text, json
from sanic.exceptions import RequestTimeout, ServerError
from sanic_jinja2 import SanicJinja2, PackageLoader
from graphql.execution.executors.asyncio import AsyncioExecutor
from a_tuin.constants import SESSION, EXCEPTIONS_TRAPPED
from glod.configuration import configuration
from glod.db.engine import Session # it is important to import from glod.db.engine in order that the session is bound to a db engine
from glod.api.schema import schema
from glod.server.graphql_compatibility_wrapper import GraphQLCompatibilityWrapper
LOG = logging.getLogger(__file__)
app = Sanic(__name__)
jinja = SanicJinja2(app, PackageLoader('glod', 'crudl/templates'))
@app.middleware('request')
async def add_session_to_request(request):
# before each request initialize a session
# using the client's request
request[SESSION] = Session()
@app.middleware('response')
async def commit_session(request, response):
if request.get(EXCEPTIONS_TRAPPED):
raise ServerError(request[EXCEPTIONS_TRAPPED])
# after each request commit and close the session
from sanic import Sanic
from sanic_jinja2 import SanicJinja2
jinja = SanicJinja2()
def create_app(config):
app = Sanic(__name__)
app.config.from_object(config)
app.static(config.STATIC_URL, config.STATIC_PATH)
jinja.init_app(app, pkg_name=__name__)
register_blueprints(app)
@app.route('/')
@jinja.template('index.html')
async def index(request):
return
return app
def register_blueprints(app):
# Import bp-s from app modules
from app.sample_module import sample_module
# Register bp-s
app.blueprint(sample_module)
from sanic import Sanic, response
from sanic.response import json
from password_generator import PasswordGenerator
from sanic_jinja2 import SanicJinja2
app = Sanic("OnIn Password Generator")
app.config.from_pyfile('generator.conf')
app.static('/static', './static')
jinja = SanicJinja2(app, pkg_name="main")
@app.route("/")
async def instructions(request):
api_url = app.url_for('generate')
return jinja.render("index.html",
request,
api_url=api_url,
policies=app.config.POLICY)
@app.route("/generate_password", version=1)
async def generate(request):
pwo = PasswordGenerator()
# Получаем политику, если передали в запросе
if 'policy' in request.args and request.args['policy'][0]:
if request.args['policy'][0].upper() in app.config.POLICY:
# Есть в списке, выбираем ее
policy = request.args['policy'][0].upper()
else:
# Не нашли, выбираем политику по-умолчанию
def create_template_env():
jinja = SanicJinja2()
jinja.env.filters['datetimefilter'] = datetimefilter
return jinja
@time: 2019/7/24 4:32 PM
@desc:
'''
import time
from sanic import response
from sanic import request
from sanic.request import json_loads
import xmltodict
import random
from sanic.response import json_dumps, text, json
from sanic import Sanic
from sanic_jinja2 import SanicJinja2
app = Sanic(__name__)
jinja = SanicJinja2(app, loader=None, pkg_name='', pkg_path='')
from sanic import Blueprint
#
# 客户码： （拉单）秘钥： 管理账号：K12478670 （初始）密码：Uy0La9NE(!qazxsW2) （重量）秘钥：
# K11122126 重量秘钥 7d35f6f98e025b85b75c283260af5d09
config = {
"YTO": "YTO",
"UrlOrder":
"http://service.yto56.net.cn/CommonOrderModeBPlusServlet.action",
"UrlWeight":
"http://116.228.115.225:6183/3rdface/open-service/persist/weight",
"ClientID": "K11122126",
"ClientSec": "D570nY8Y",
from urllib.parse import urlunparse
from aiocache import cached, caches
from sanic import Sanic
from sanic.response import redirect
from sanic_compress import Compress
from sanic_jinja2 import SanicJinja2
from victims.data import Data
from victims.settings import CACHE, DEBUG, STATIC_DIR, TITLE
app = Sanic("vitimas_da_intolerancia")
app.static("/static", str(STATIC_DIR))
jinja = SanicJinja2(app, pkg_name="victims")
caches.set_config(CACHE)
Compress(app)
@app.middleware("request")
def force_https(request):
if DEBUG:
return None
host = request.headers.get("Host", "")
protocol = "https" if request.transport.get_extra_info(
"sslcontext") else "http"
if request.headers.get("x-forwarded-proto", protocol) == "http":
args = ("https", host, request.path, None, request.query_string, None)
url = urlunparse(args)
return redirect(url)
from jinja2 import select_autoescape, FileSystemLoader
from sanic_jinja2 import SanicJinja2
import os
jinja2 = SanicJinja2(
enable_async=True,
autoescape=select_autoescape(['html', 'xml']),
)
path = os.path.dirname(os.path.dirname(__file__))
bp_path = os.path.join(path, 'blueprints')
tpl_path = [
os.path.join(p, 'templates') for p in os.listdir(bp_path)
if not p.startswith('__')
]
tpl_path.append(os.path.join(path, 'templates'))
def init(app):
jinja2.init_app(app, loader=FileSystemLoader(tpl_path))
from sanic import Sanic
from sanic_jinja2 import SanicJinja2
from violence.data import Data
app = Sanic()
jinja = SanicJinja2(app, pkg_name='violence')
app_data = Data(refresh_cache=True)
app_data.reload_from_google_spreadsheet()
@app.route("/")
@jinja.template('index.html')
async def test(request):
return {'cases': app_data.cases}
context["objects"] = cfg.user_models
context["url_prefix"] = cfg.route
context["admin_panel_version"] = __version__
context["round_number"] = cfg.round_number
context["admin_users_route"] = cfg.admin_users_table_name
context["cfg"] = cfg
return html(
self.render_string(template, request, **context),
status=status,
headers=headers,
)
SanicJinja2.render = render_with_updated_context
jinja = SanicJinja2(loader=loader)
class CompositeCsvSettings(BaseModel):
...
# todo
class App:
""" class to store links to main app data app.config and DB"""
config = {}
db = None
class ColorSchema(BaseModel):
import asyncio
import json
from concurrent.futures import ThreadPoolExecutor
from sanic import Sanic, response
from sanic_jinja2 import SanicJinja2
from sanic_httpauth import HTTPBasicAuth
import b2browser
import config
app = Sanic("b2browser")
app.static("/static", "./static")
auth = HTTPBasicAuth()
jinja = SanicJinja2(app, pkg_name="b2browser")
b2browser.B2.setup(config.application_key_id, config.application_key,
config.bucket_name)
@auth.verify_password
def verify_password(username, password):
# and b2browser.utils.hash_password(config.app_salt, password) == config.password
return (username == config.username and password == config.password)
@app.listener("after_server_start")
def create_task_queues(app, loop):
app.threaded_executor = ThreadPoolExecutor(config.thread_pool_size)
app.updates_queue = asyncio.Queue(maxsize=1_000)
from urllib.parse import urlparse
from aiocache import cached, caches
from sanic import Sanic
from sanic_compress import Compress
from sanic_jinja2 import SanicJinja2
from victims.data import Data
from victims.settings import (CACHE_DATA_FOR, REDIS_DB, REDIS_URL,
REFRESH_CACHE_ON_LOAD, STATIC_DIR, TITLE)
app = Sanic('vitimas_da_intolerancia')
app.static('/static', str(STATIC_DIR))
Compress(app)
jinja = SanicJinja2(app, pkg_name='victims')
app_data = Data(refresh_cache=REFRESH_CACHE_ON_LOAD)
redis = urlparse(REDIS_URL)
caches.set_config({
'default': {
'cache': 'aiocache.RedisCache',
'namespace': 'sanic-cache',
'timeout': CACHE_DATA_FOR,
'endpoint': redis.hostname,
'port': redis.port,
'db': REDIS_DB,
'serializer': {
'class': 'aiocache.serializers.PickleSerializer'
},
}
})
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from sanic import Sanic
from sanic_session import Session, InMemorySessionInterface
from sanic_jinja2 import SanicJinja2
app = Sanic()
session = Session(app, interface=InMemorySessionInterface())
jinja = SanicJinja2(app, session=session)
@app.route("/")
async def index(request):
jinja.flash(request, "success message", "success")
jinja.flash(request, "info message", "info")
jinja.flash(request, "warning message", "warning")
jinja.flash(request, "error message", "error")
jinja.session(request)["user"] = "******"
return jinja.render("index.html", request, greetings="Hello, sanic!")
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000, debug=True)
import asyncio
from pathlib import Path
import log
from markdown import markdown
from sanic import Sanic, response
from sanic_jinja2 import SanicJinja2
from sanic_openapi import doc
from app import helpers, settings, utils
app = Sanic(name="memegen")
helpers.configure(app)
jinja = SanicJinja2(app, pkg_name="app")
@app.get("/")
@doc.exclude(True)
@jinja.template("index.html")
async def index(request):
html = markdown(
text=Path("README.md").read_text(),
extensions=["pymdownx.magiclink", "markdown.extensions.tables"],
)
html = html.replace("<code></code>", "<code> </code>")
html = html.replace(
"https://api.memegen.link/docs",
f"{settings.SCHEME}://{settings.SERVER_NAME}/docs",
)
return {"content": html}
import sanic.exceptions
import sanic.request
import sanic.response
from jinja2 import FileSystemLoader
from sanic_jinja2 import SanicJinja2
from sanic_session import InMemorySessionInterface, Session
from sanic_openid_connect_provider import setup_client
oicp_logger = logging.getLogger("oicp")
oicp_logger.setLevel(logging.INFO)
oicp_logger.addHandler(logging.StreamHandler())
app = sanic.Sanic()
session = Session(app, interface=InMemorySessionInterface())
jinja = SanicJinja2(app, loader=FileSystemLoader("./templates"), enable_async=True)
oicp_client = setup_client(
app=app,
callback_path="/callback",
client_id=os.environ["AZURE_CLIENT_ID"],
client_secret=os.environ["AZURE_CLIENT_SECRET"],
signature_type="RS256", # Azure only supports RS256
autodiscover_base=os.environ["AZURE_BASE"],
scopes=("openid", "profile", "email", "User.Read"),
)
@app.route("/secret", methods=["GET"])
@oicp_client.login_required()
async def secret(request: sanic.request.Request) -> sanic.response.BaseHTTPResponse:
from os import environ
from os.path import join, dirname
from sanic_jinja2 import SanicJinja2
from dotenv import load_dotenv
envpath = join(dirname(__file__), '.env')
load_dotenv(envpath)
DB_USER = environ.get('POSTGRES_USER')
DB_PASSWORD = environ.get('POSTGRES_PASSWORD')
DB_NAME = environ.get('POSTGRES_DB')
DB_PORT = environ.get('POSTGRES_PORT', 5432)
DB_HOST = environ.get('POSTGRES_HOST')
DB_URL = f'postgresql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}'
JINJA = SanicJinja2()
SECRET_KEY = environ.get('SECRET_KEY')
SESSION_TIME = 1800
LEEWAY_SESSION_TIME = 25
__all__ = [
'JINJA',
'DB_URL',
'SECRET_KEY',
'SESSION_TIME',
'LEEWAY_SESSION_TIME',
]
from sanic.websocket import WebSocketProtocol
from sanic_auth import Auth, User
from sanic_jinja2 import SanicJinja2
import asyncio_redis
from channel import Channel, response_message
from redis_handle import redis_pub_sub
from db_driver import redis_set_get, pg_set_get
from ws_handle import receive_ws_channel, ws_room_send_chat
session = {}
app = Sanic(__name__)
app: asyncio_redis.Pool
app.config.AUTH_LOGIN_ENDPOINT = 'login'
auth = Auth(app)
jinja = SanicJinja2(app, pkg_path='template')
@app.listener('before_server_start')
async def setup(app, loop):
app.conn = await redis_pub_sub.create_connection_pool()
@app.listener('after_server_stop')
async def close_db(app, loop):
await app.close()
@app.middleware('request')
async def add_session(request):
request['session'] = session
from errors_handling import CustomError
from sanic.exceptions import abort
from sanic import Sanic
from sanic import response, request
from sanic_jinja2 import SanicJinja2
from two_phase_commit import TwoPhaseCommit
from response_caching import ResponseCaching
from time import sleep
import json
app = Sanic(__name__)
jinja = SanicJinja2(app, autoescape=True)
# if this is set to false and in docker flask_env is not development, the "debug" logging will not be shown
app.config['DEBUG'] = True
# Setup elk stack
# host_logger = 'localhost'
host_logger = 'logstash'
port_logger = 5000
# Get you a test logger
test_logger = logging.getLogger('python-logstash-logger')
# Set it to whatever level you want - default will be info
test_logger.setLevel(logging.DEBUG)
# Create a handler for it
async_handler = AsynchronousLogstashHandler(host_logger,
import os
import re
from sanic import Sanic
from sanic.response import json, html
from draw import draw
from sanic_jinja2 import SanicJinja2
static_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../static')
templates_path = os.path.join(
os.path.join(os.path.dirname(__file__), 'templates'))
app = Sanic()
jinja = SanicJinja2(app) # Use jinja2 for template engine
app.static('/static', static_path) # Images
app.static('/', templates_path)
@app.route('/')
async def test(request):
return jinja.render('index.html')
@app.route('/draw')
async def handle(request):
if not 'word2' in request.args or not 'word3' in request.args:
return json({"message": "word2 and word3 must be provided!"})
pattern = re.compile(r'^[A-Z0-9]{1}$')
word1 = 'I' # request.args['word1'][0]
word2 = request.args['word2'][0]
from sanic import Sanic
from sanic_jinja2 import SanicJinja2
from gino.ext.sanic import Gino
app = Sanic(__name__)
app.config.from_pyfile('config')
jinja = SanicJinja2(app, pkg_path=f'../{app.config.FRONTEND_PATH}/templates')
db = Gino()
db.init_app(app)
app.static('static', app.config.FRONTEND_PATH)
import libreban.routes
import libreban.model
import os
from sanic import Sanic
from sanic.response import json
from sanic_jinja2 import SanicJinja2
_dir = os.path.dirname(os.path.dirname(__file__))
# 一定要 才能读取绝对路径, 如果是相对路径呢
app = Sanic('my_project')
app.static('/static', f'./static')
jinja = SanicJinja2(app, pkg_name='main', pkg_path='./templates')
@app.route('/')
async def index(request):
# calc
# 30s
return jinja.render('index.html', request, my_title='Hello, sanic!')
# api
@app.route('/get_user_name')
async def get_user_name(request):
return json({'name': 'Tom'})
# api
@app.route('/get_data')
async def get_data(request):
# calc
a = {b
app.config.from_pyfile(config_file)
app.config.SESSION_COOKIE_SECRET_KEY = app.config.SECRET
app.config.SESSION_COOKIE_SECURE = False
app.config.SESSION_COOKIE_MAX_AGE = 3600 * 24 * 15
sanic_cookiesession.setup(app)
os.chdir(os.path.dirname(__file__))
app.static('/static', './static')
app.static('/favicon.ico', './static/images/favicon.ico')
app.static('/robots.txt', './static/robots.txt')
jinja = SanicJinja2(app, enable_async=False, autoescape=True)
render = jinja.render
render_async = jinja.render_async
pagination = {
'_head': '<ul class="pagination">',
'_end': '</ul>',
'_normal': '<li><a href="{href}" rel="prev" style="text-decoration: none">{label}</a></li>',
'_actived': '<li class="active"><a href="{href}" rel="prev" style="text-decoration: none">{label}</a></li>',
'_gap': '<li class="disabled"><span>{gap}</span></li>',
'_prev_label': '<i class="left arrow icon"></i>',
'_next_label': '<i class="right arrow icon"></i>',
'_prev_disabled': '<li class="disabled"><span>«</span></li>',
'_next_disabled': '<li class="disabled"><span>»</span></li>',
'_prev_normal': '<li><a href="{href}" rel="prev" style="text-decoration: none">«</a></li>',