def app(loop, request):
return m.Application('rest',
loop=loop,
PLUGINS=['muffin_peewee'],
PEEWEE_CONNECTION='sqlite:///:memory:')
import muffin
app = muffin.Application(CONFIG='config.debug')
from models import Test
@app.view('/')
def hello(request):
return (yield from app.jade.render('index.jade'))
@app.view('/db-sync')
def db_sync(request):
return [t.data for t in Test.select()]
@app.view('/json')
def json(request):
return {'json': 'here'}
@app.view('/404')
def raise404(request):
raise muffin.HTTPNotFound
@app.view('/db-async')
def db_async(request):
results = yield from app.peewee.query(Test.select())
return [t.data for t in results]
"""Example application."""
import muffin
import muffin_jinja2
import muffin_babel
app = muffin.Application('babel', DEBUG=True)
jinja2 = muffin_jinja2.Plugin(app, template_folders=['example/templates'])
babel = muffin_babel.Plugin(app, locale_folders=['example/locales'])
@babel.locale_selector
async def get_locale(request, default='en'):
"""Return locale from GET lang param or automatically."""
locale = request.query.get('lang')
if not locale:
return await muffin_babel.select_locale_by_request(request, default)
return locale
@app.route('/')
async def index(request):
"""Localized Hello World."""
return await jinja2.render('base.html',
message=babel.gettext('Hello World!'))
.map(lambda item: item[1])\
.map(lambda item: setitem(container, "imageLinks", item))\
.get_or(None)
container["industryIdentifiers"] = isbn
container["source"] = "AM"
return container
response_txt = yield from do_request(url)
detail_link = yield from exctract_main_link(response_txt)
response_txt = yield from do_request(detail_link)
response = yield from exctract_metadata(detail_link, isbn)
return response
app = muffin.Application('amazon_scraper')
@asyncio.coroutine
def do_request(url, method="GET"):
response = yield from aiohttp.request(method, url)
text = yield from response.read()
return text
@app.register('/scrape')
def index(request):
amazon_url = "http://www.amazon.it/gp/search/search-alias=stripbooks&field-isbn="
laf_url = "http://www.lafeltrinelli.it/libri/rfrrrfrre/rdferd/"
flattened_qs = Option(request.query_string)\
import muffin
app = muffin.Application("web")
@app.register("/text")
def text(request):
return "Hello, World!"
PEEWEE_CONNECTION = 'postgres+pool://test:test@%s:3306/test' % HOST
PEEWEE_CONNECTION_PARAMS = {'encoding': 'utf-8', 'max_connections': 10}
REMOTE_URL = 'http://%s' % HOST
if os.environ.get('TEST'):
PEEWEE_CONNECTION = 'sqlite:///:memory:'
PEEWEE_CONNECTION_PARAMS = {}
REMOTE_URL = 'http://google.com'
app = muffin.Application(
'web',
PLUGINS=('muffin_peewee', 'muffin_jinja2'),
JINJA2_TEMPLATE_FOLDERS=os.path.dirname(os.path.abspath(__file__)),
PEEWEE_CONNECTION=PEEWEE_CONNECTION,
PEEWEE_CONNECTION_MANUAL=True,
PEEWEE_CONNECTION_PARAMS=PEEWEE_CONNECTION_PARAMS,
)
@app.ps.peewee.register
class Message(peewee.Model):
content = peewee.CharField(max_length=512)
@app.register('/json')
def json(request):
return {
def app(loop, test=False):
return muffin.Application('cached_app',
loop=loop,
PLUGINS=('muffin_dogpilecache', ))
""" Setup the application. """
import muffin
app = application = muffin.Application(
'example',
PLUGINS=[
'muffin_jinja2',
'muffin_babel',
'muffin_admin',
'muffin_peewee',
],
JINJA2_TEMPLATE_FOLDERS='example/templates',
JINJA2_AUTO_RELOAD=True,
ADMIN_TEMPLATE_LIST='custom_list.html',
ADMIN_TEMPLATE_HOME='custom_home.html',
ADMIN_I18N=True,
)
@app.register('/')
def index(request):
"""Index page."""
return "<a href='/admin'>Admin</a>"
from example.admin import * # noqa Register admin handlers
#!/usr/bin/env python
from argparse import ArgumentParser
from random import randrange
import socket
import logging
import subprocess as sp
import muffin
from aiohttp import web
from protocol import AdbProtocol
app = muffin.Application(__name__, DEBUG=True)
logging.basicConfig(level=logging.DEBUG)
protocol = AdbProtocol('/sdcard/DCIM/Camera', 'MarSoftS4A')
def url_for(route, **kwargs):
return app.router[route].url(parts=kwargs)
@app.register('/')
async def index(req):
with open('static/index.html', 'r') as i:
indexfile = i.read()
return indexfile
@app.register('/page/{n:[0-9]+}')
async def page(req):
import muffin
import os
import aiohttp
import peewee
app = muffin.Application(
'web',
PLUGINS=('muffin_peewee', 'muffin_jinja2'),
JINJA2_TEMPLATE_FOLDERS=os.path.dirname(os.path.abspath(__file__)),
PEEWEE_CONNECTION=
'postgres+pool://benchmark:benchmark@localhost:5432/benchmark',
PEEWEE_CONNECTION_MANUAL=True,
PEEWEE_CONNECTION_PARAMS={
'encoding': 'utf-8',
'max_connections': 10
},
)
@app.ps.peewee.register
class Message(peewee.Model):
content = peewee.CharField(max_length=512)
@app.register('/json')
def json(request):
return {'message': 'Hello, World!'}
@app.register('/remote')
def remote(request):
import muffin
app = muffin.Application('rest', PLUGINS=['muffin_rest', 'muffin_peewee'])
from example.api import * # noqa Register API Handlers
"""Example app."""
import muffin
import random
app = muffin.Application('sessions',
SESSION_SECRET_KEY='EXAMPLE_KEY',
SESSION_AUTO_MANAGE=True)
@app.route('/')
async def index(request):
"""Return JSON with current user session."""
return dict(request.session)
@app.route('/update')
async def update(request):
"""Update a current user's session."""
request.session['random'] = random.random()
return muffin.ResponseRedirect('/')
def app(loop):
return muffin.Application('sqlalchemy_app',
loop=loop,
PLUGINS=('muffin_sqlalchemy', ))
import datetime
import muffin
from bson import ObjectId
from aiohttp.web import json_response
from motor.motor_asyncio import AsyncIOMotorClient
from functools import partial
from umongo import Instance, Document, fields, ValidationError, set_gettext
from umongo.marshmallow_bonus import SchemaFromUmongo
import logging
logging.basicConfig(level=logging.DEBUG)
app = muffin.Application(__name__,
PLUGINS=('muffin_babel', ),
BABEL_LOCALES_DIRS=['translations'])
db = AsyncIOMotorClient()['demo_umongo']
instance = Instance(db)
set_gettext(app.ps.babel.gettext)
@app.ps.babel.locale_selector
def set_locale(request):
"""Get locale based on request Accept-Language header"""
return app.ps.babel.select_locale_by_request(request)
class MongoJsonEncoder(json.JSONEncoder):
def default(self, obj):
import muffin
import json
import os
import os.path
import subprocess as sp
import aiohttp as ah
from pathlib import Path
import yaml
from scrapinghub.hubstorage import HubstorageClient
app = muffin.Application('devsrv')
@app.register('/')
def root(request):
return 'server is running!'
#@app.register('/linktv')
#def linktv(request):
# html = '<p><a href="linktv/reload">reload</a></p>\n'
# for item in program_list:
# html += "<p>\n"
# title = item["title"]
# keyword = item["keyword"]
# filename = item["filename"]
# html += load_links(title, filename)
# html += "</p>\n"
# return html
#def load_links(title, filename):
import muffin
app = muffin.Application('web')
@app.register('/json')
def json(request):
return { 'message': 'Hello, World!' }
def test_app_logging_cfg():
dummy = {'dummy': 'dict'}
with patch('logging.config.dictConfig') as m:
muffin.Application('muffin', LOGGING=dummy)
m.assert_called_once_with(dummy)
import muffin
app = muffin.Application()
from models import Test
@app.view('/')
def hello(request):
return (yield from app.jade.render('index.jade'))
@app.view('/db-sync')
def db_sync(request):
return [t.data for t in Test.select()]
@app.view('/db-async')
def db_async(request):
results = yield from app.peewee.query(Test.select())
return [t.data for t in results]
@app.view('/json')
def json(request):
return {'json': 'here'}
@app.view('/404')
def raise404(request):
raise muffin.HTTPNotFound
import muffin
from aiohttp import web
from fn.monad import Option
import random
import os
import PIL
from PIL import Image
import json
app = muffin.Application('photogallery')
def resize_images(image):
img = Image.open(image)
img.thumbnail((img.size[0] * 0.8, img.size[1] * 0.8), PIL.Image.ANTIALIAS)
img.save(image, "JPEG")
def get_all_images():
return filter(lambda item: not item == ".DS_Store", os.listdir("uploaded"))
@app.register('/')
def index(request):
r = web.Response(text=json.dumps(
[dict(src="../uploaded/" + value) for value in get_all_images()]),
content_type="application/json")
r.headers['Access-Control-Allow-Origin'] = '*'
return r