def app():
guid = str(uuid4())
app = Sanic(__name__ + guid)
#app.test_client_class = TestClient
realm = SanicPluginRealm(app)
realm.register_plugin(restplus)
yield app
def api(self, app):
blueprint = Blueprint('api', __name__)
realm = SanicPluginRealm(blueprint)
plugin, reg = realm.register_plugin(restplus)
api = Api(reg)
app.register_blueprint(blueprint)
yield api
def test_spf_singleton_1(realm):
"""
Registering the toolkit twice on the same app should return
an indentical instance of the realm
:return:
"""
app1 = realm._app
realm.register_plugin(instance)
realm2 = SanicPluginRealm(app1)
assert realm == realm2
def test_spf_singleton_2(realm):
"""
Registering the toolkit twice, but with different apps should return
two different spfs
:return:
"""
app1 = realm._app
app2 = Sanic('test_realm_singleton_2_1')
realm.register_plugin(instance)
realm2 = SanicPluginRealm(app2)
assert realm != realm2
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
from sanic_plugin_toolkit.plugins.contextualize import instance as contextualize
app = Sanic(__name__)
realm = SanicPluginRealm(app)
@contextualize.listener('after_server_start')
async def setup_db(app, loop, context):
from sqlalchemy import create_engine
shared_context = context.shared
engine = create_engine('sqlite:///orm_in_detail.sqlite')
shared_context['db'] = engine
from sqlalchemy.orm import sessionmaker
session = sessionmaker()
session.configure(bind=engine)
shared_context['dbsession'] = session
async def get_user_session(db_session):
# Hypothetical get_user_session function
return {"username": "******"}
@contextualize.middleware(priority=4)
async def db_request_middleware(request, context):
shared_context = context.shared
request_context = shared_context.request
db_session = shared_context.dbsession
user_session = await get_user_session(db_session)
def realm_bp(request):
a = app_with_name(request.node.name)
b = Blueprint("TestBP", "blueprint")
realm = SanicPluginRealm(b)
manager = TestManager(a)
return realm, a
def realm(request):
a = app_with_name(request.node.name)
manager = TestManager(a)
return SanicPluginRealm(a)
from uuid import uuid4
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
from sanic_session_sptk.plugin import session
from sanic_plugin_toolkit.plugins import contextualize
app = Sanic(__name__)
sptk = SanicPluginRealm(app)
session_reg = sptk.register_plugin(session, interface=None)
ctx = sptk.register_plugin(contextualize)
@ctx.route("/")
def index(request, context):
session = context.shared.request[id(request)].session
token = session.get("RememberMe", None)
if token is None:
session['RememberMe'] = token = str(uuid4())
return text("{} {}".format(id(request), token))
if __name__ == "__main__":
app.run(host="127.0.0.1", port="9997", debug=True, auto_reload=False)
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
from examples import my_plugin
from examples import my_blueprint
app = Sanic(__name__)
# mp = MyPlugin(app) //Legacy registration example
realm = SanicPluginRealm(my_blueprint.api_v1)
realm.register_plugin(my_plugin)
app.blueprint(my_blueprint.api_v1)
@app.route('/')
def index(request):
return text("hello world")
if __name__ == "__main__":
app.run("127.0.0.1", port=8098, debug=True, auto_reload=False)
from sanic import Sanic
from sanic_restplus import Api, fields, Resource
from sanic_restplus.cors import crossdomain
from sanic_restplus.restplus import restplus
from sanic_plugin_toolkit import SanicPluginRealm
app = Sanic(__name__)
realm = SanicPluginRealm(app)
rest_assoc = realm.register_plugin(restplus)
api = Api(version='1.0', title='Todo API', description='A simple TODO API')
ns = api.namespace('todos', description='TODO operations')
TODOS = {
'todo1': {
'task': 'build an API'
},
'todo2': {
'task': '?????'
},
'todo3': {
'task': 'profit!'
},
}
todo = api.model(
'Todo',
{'task': fields.String(required=True, description='The task details')})
listed_todo = api.model(
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
from sanic_plugin_toolkit.plugins import contextualize
from sanic_metrics import sanic_metrics
app = Sanic(__name__)
realm = SanicPluginRealm(app)
ctx = realm.register_plugin(contextualize)
metrics = realm.register_plugin(sanic_metrics,
opt={'type': 'out'},
log={'format': 'vcombined'})
@app.route("/")
def index(request):
return text("hello world")
@ctx.route("/override")
async def orr(request, context):
rctx = context.for_request(request)
shared_ctx = context.shared
shared_rctx = shared_ctx.for_request(request)
override_metrics = {'status': "999"}
shared_rctx['override_metrics'] = override_metrics
return text("hello world")
if __name__ == "__main__":
app.run("127.0.0.1", 8083, debug=True, auto_reload=False, access_log=False)
class MyPlugin(SanicPlugin):
def __init__(self, *args, **kwargs):
super(MyPlugin, self).__init__(*args, **kwargs)
instance = MyPlugin()
@instance.middleware(priority=6, with_context=True, attach_to="cleanup")
def mw1(request, context):
context['test1'] = "test"
print("Doing Cleanup!")
app = Sanic(__name__)
realm = SanicPluginRealm(app)
assoc_reg = realm.register_plugin(instance)
@app.route('/')
def index(request):
return text("hello world")
@app.websocket('/test1')
async def we_test(request, ws):
print("hi")
return
if __name__ == "__main__":
from sanic.response import text
from sanic_testing import TestManager
from sanic_plugin_toolkit import SanicPlugin, SanicPluginRealm
class TestPlugin(SanicPlugin):
pass
# The following tests are taken directly from Sanic source @ v0.6.0
# and modified to test the SanicPlugin, rather than Sanic
exception_handler_app = Sanic('test_exception_handler')
test_manager = TestManager(exception_handler_app)
realm = SanicPluginRealm(exception_handler_app)
test_plugin = TestPlugin()
@test_plugin.route('/1')
def handler_1(request):
raise InvalidUsage("OK")
@test_plugin.route('/2')
def handler_2(request):
raise ServerError("OK")
@test_plugin.route('/3')
def handler_3(request):
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
from sanic_plugin_toolkit.plugins.contextualize import instance as contextualize
app = Sanic(__name__)
app.config['STK_LOAD_INI'] = True
app.config['STK_INI_FILE'] = 'example_stk.ini'
realm = SanicPluginRealm(app)
# We can get the assoc object from SPF, it is already registered
contextualize = realm.get_plugin_assoc('Contextualize')
@contextualize.middleware
def middle3(request, context):
shared = context.shared
r = shared.request
r.test = "true"
@contextualize.middleware(priority=7)
def middle4(request, context):
shared = context.shared
r = shared.request
_ = r.test
@contextualize.route('/1/<args>')
def index2(request, args, context):
shared = context.shared
from sanic import Sanic
from sanic.response import text
from sanic_plugin_toolkit import SanicPluginRealm
#from examples.my_plugin import my_plugin
from examples import my_plugin
from examples.my_plugin import MyPlugin
from logging import DEBUG
app = Sanic(__name__)
# mp = MyPlugin(app) //Legacy registration example
realm = SanicPluginRealm(app)
my_plugin = realm.register_plugin(my_plugin)
@app.route('/')
def index(request):
return text("hello world")
if __name__ == "__main__":
app.run("127.0.0.1", port=8098, debug=True, auto_reload=False)
@instance.middleware(priority=2, with_context=True)
def mw4(request, context):
log = context.log
print(context)
log(DEBUG, "Hello Middleware")
@instance.route('/test_plugin', with_context=False)
def t1(request):
return text('from plugin!')
app = Sanic(__name__)
mp = MyPlugin(app)
realm = SanicPluginRealm(app)
try:
assoc_reg = realm.register_plugin(
MyPlugin) # already registered! (line 57)
except ValueError as ve:
assoc_reg = ve.args[1]
@app.route('/')
def index(request):
return text("hello world")
if __name__ == "__main__":
app.run("127.0.0.1", port=8098, debug=True, workers=2, auto_reload=False)