本文整理汇总了Python中werkzeug.routing.Map.bind_to_environ方法的典型用法代码示例。如果您正苦于以下问题:Python Map.bind_to_environ方法的具体用法?Python Map.bind_to_environ怎么用?Python Map.bind_to_environ使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类werkzeug.routing.Map
的用法示例。
在下文中一共展示了Map.bind_to_environ方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Shortly
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Shortly(object):
def __init__(self, config):
self.redis = redis.Redis(config['redis_host'], config['redis_port'])
template_path = os.path.join(os.path.dirname(__file__), 'templates')
self.jinja_env = Environment(loader=FileSystemLoader(template_path), autoescape=True)
self.url_map = Map([
Rule('/', endpoint='new_url'),
Rule('/<short_id>', endpoint='follow_short_link'),
Rule('/<short_id>+',endpoint='short_link_details')
])
def insert_url(self, url):
short_id = self.redis.get('reverse-url:' + url)
if short_id is not None:
return short_id
url_num = self.redis.incr('last-url-id')
short_id = base36_encode(url_num)
self.redis.set('url-target:' + short_id, url)
self.redis.set('reverse-url:' + url, short_id)
return short_id
def render_template(self, template_name, **context):
t = self.jinja_env.get_template(template_name)
return Response(t.render(context), mimetype='text/html')
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except HTTPException, e:
return e
示例2: Server
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Server(object):
def __init__(self, config):
self.url_map = Map([
Rule('/', endpoint='generate_buy_list'),
])
self.magic_set_library = Magic_Set_Library()
def generate_buy_list(self, request):
params = self._parse_query_string(request.query_string)
boosters = []
for magic_set, booster_count in params.iteritems():
for i in range(int(booster_count)):
boosters.append(self.magic_set_library.make_booster(magic_set))
card_map = {}
for booster in boosters:
for card in booster:
card_map[card] = card_map.get(card, 0) + 1
ret_str = ""
for card, count in sorted(card_map.iteritems(), key=lambda x:x[0]):
ret_str += "%s %s\n" %(count, card.name)
return Response(ret_str)
def _parse_query_string(self, query_string):
if not query_string:
return {}
return dict(map(lambda x:(x.split('=')[0], x.split('=')[1]), query_string.strip().split('&')))
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, endpoint)(request, **values)
except HTTPException, e:
return e
示例3: test_external_building_with_port_bind_to_environ_wrong_servername
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def test_external_building_with_port_bind_to_environ_wrong_servername():
"""Test external URL building with port number (map.bind_to_environ) with wrong server name raises ValueError"""
map = Map([
Rule('/', endpoint='index'),
])
environ = create_environ('/', 'http://example.org:5000/')
assert_raises(ValueError, lambda: map.bind_to_environ(environ, server_name="example.org"))
示例4: Shortly
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Shortly(object):
def __init__(self, config):
self.redis = redis.Redis(config['redis_host'], config['redis_port'])
template_path = os.path.join(os.path.dirname(__file__), 'templates')
self.jinja_env = Environment(loader=FileSystemLoader(template_path),
autoescape=True)
self.url_map = Map([
Rule('/', endpoint='new_url'),
Rule('/<short_id>', endpoint='follow_short_link'),
Rule('/<short_id>+', endpoint='short_link_details')
])
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
def render_template(self, template_name, **context):
t = self.jinja_env.get_template(template_name)
return Response(t.render(context), mimetype='text/html')
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except HTTPException, e:
return e
示例5: App
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class App(object):
def __init__(self, name=__name__):
modules = import_all_module(name)
self.rules = []
self.views = []
for module in modules:
for k, v in module.__dict__.items():
if inspect.isclass(v) and issubclass(v, Resource)\
and v is not Resource:
self.rules.extend(v.rules)
if module not in self.views:
self.views.append(module)
self.url_map = Map(self.rules)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
endpoint, values = adapter.match()
for view in self.views:
if hasattr(view, endpoint):
return getattr(view, endpoint)(request, endpoint, values)
def __call__(self, environ, start_response):
request = Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
示例6: KeyProtectedApp
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class KeyProtectedApp(object):
'''
Base class for a WSGI-app with a GET paramter based auhtentication.
'''
@property
def routing(self):
'''
Must return a dict like {'url':'endpoint'}
'''
raise NotImplementedError
def __init__(self):
self.url_map = Map(
[Rule(k, endpoint=v) for k, v in self.routing.iteritems()])
def dispatch_request(self, request):
if not validate_key(request.args.get('key', '')):
raise Forbidden
endpoint, kw = self.url_map.bind_to_environ(request.environ).match()
return getattr(self, endpoint)(request, **kw)
def __call__(self, environ, start_response):
request = Request(environ)
try:
response = self.dispatch_request(request)
except HTTPException, e:
response = e
return response(environ, start_response)
示例7: App
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class App():
def __init__(self, work_dir):
self.work_dir = work_dir
self.admin = adm_server.create_admin(self)
self.task = None
self.task_lock = Lock()
self.users = {}
self.roles = None
self._busy = 0
self.pid = os.getpid()
self.task_server_modified = False
self.task_client_modified = True
self.under_maintenance = False
self.work_dir = self.admin.work_dir
self.jam_dir = os.path.dirname(jam.__file__)
self.jam_version = jam.version()
self.application_files = {
'/': self.work_dir,
'/jam/': self.jam_dir,
'/static/': os.path.join(self.jam_dir, 'static' )
}
self.fileserver = SharedDataMiddleware(None, self.application_files, cache_timeout=0.1)
self.url_map = Map([
Rule('/', endpoint='root_file'),
Rule('/<file_name>', endpoint='root_file'),
Rule('/js/<file_name>', endpoint='file'),
Rule('/css/<file_name>', endpoint='file'),
Rule('/jam/js/<file_name>', endpoint='file'),
Rule('/jam/js/ace/<file_name>', endpoint='file'),
Rule('/jam/css/<file_name>', endpoint='file'),
Rule('/jam/img/<file_name>', endpoint='file'),
Rule('/api', endpoint='api'),
Rule('/upload', endpoint='upload')
])
def get_task(self):
if self.task is None:
with self.task_lock:
if self.task is None:
adm_server.create_task(self)
return self.task
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
request = Request(environ)
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
if endpoint in ['file', 'root_file']:
return self.serve_file(environ, start_response, endpoint, **values)
elif endpoint in ['api', 'upload']:
response = getattr(self, 'on_' + endpoint)(request, **values)
except HTTPException, e:
if peek_path_info(environ) == 'ext':
response = self.on_ext(request)
else:
response = e
return response(environ, start_response)
示例8: holla_base_app
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class holla_base_app(object):
"""
This Class provide a Response Obj as an alias of HTTP_Resp.Response
Usage: Let get_resp obj return a Response obj, and you don't need to do anything else
"""
def __init__(self):
self.Response = Response # Just an alias of Response Class
self.url_map = Map([])
pass
def route(self, url, methods = None):
def decorator(callback):
add_Route(url, callback, self.url_map, methods)
return callback
return decorator
def get_resp(self, env):
self.env = env
adapter = self.url_map.bind_to_environ(self.env)
try:
endpoint, values = adapter.match()
return Response(endpoint(**values))
except NotFound, e:
return Response(status = 404)
except HTTPException, e:
return Response(status = 500)
示例9: RpcServer
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class RpcServer(object):
def __init__(self, callbacks=None, host='', port=8000, ):
self.host = host
self.port = port
self.views = {'get_rpc': self.get_rpc,
'images': self.get_file,
'save_file': self.save_file,
'get_log' : self.get_log}
self.url_map = Map([Rule('/', endpoint='get_rpc'),
Rule('/jsonrpc', endpoint='get_rpc'),
Rule('/images', endpoint='images'),
Rule('/upload', endpoint='save_file'),
Rule('/log', endpoint='get_log')])
# add the method names and the handlers to the dispatcher methods.
if callbacks:
for keys in callbacks.keys():
dispatcher[keys] = callbacks[keys]
def get_rpc(self, environ, request):
response = JSONRPCResponseManager.handle(request.data, dispatcher)
return Response(response.json, mimetype="application/json")
def get_file(self, environ, request):
try:
file = open('images/'+request.query_string.decode(), 'rb')
except Exception as e:
debug_logger.debug("could not read file" + str(e))
raise NotFound()
return Response(wrap_file(environ, file), direct_passthrough=True)
def save_file(self, environ, request):
try:
file = request.files['image']
filename = 'images/'+request.form["btn_name"].strip('"')+".jpg"
id = request.form['btn_id']
txt = request.form['btn_text'].strip('"')
file.save(filename)
dispatcher['update_image'](id, txt, filename)
except Exception:
return NotFound()
return Response("Ok")
def get_log(self, environ, request):
response = dispatcher['get_log_data']()
return Response(response, mimetype="application/json")
@responder
def application(self, environ, start_response):
request = Request(environ)
urls = self.url_map.bind_to_environ(environ)
return urls.dispatch(lambda e, v: self.views[e](environ, request, **v),
catch_http_exceptions=True)
def start(self):
self.app = run_simple(self.host, self.port, self.application)
示例10: NovoMapia
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class NovoMapia(object):
def __init__(self, config):
template_path = os.path.join(os.path.dirname(__file__), 'templates')
self.jinja_env = Environment(loader=FileSystemLoader(template_path),autoescape=True)
self.url_map = Map([
Rule('/', endpoint='index'),
Rule('/index.html', endpoint='index'),
Rule('/<source>', endpoint='index'),
Rule('/json/<source>', endpoint='json'),
Rule('/json/<source>/', endpoint='json'),
])
def render_template(self, template_name, **context):
t = self.jinja_env.get_template(template_name)
return Response(t.render(context), mimetype='text/html')
def dispatch_request(self, request):
return Response('Hello World!')
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except HTTPException, e:
return e
示例11: Cup
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class Cup(object):
def __init__(self, with_static=True):
if with_static:
self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {
'/static': os.path.join(os.path.dirname(__file__), 'static')
})
self.url_map = Map()
self.views = {}
def add_url_rule(self, url, endpt, func):
self.url_map.add(Rule(url, endpoint=endpt))
self.views[endpt] = func
def getView(self, endpoint):
return self.views[endpoint]
def route(self, url):
def decorator(func):
self.add_url_rule(url, func.__name__, func)
def decorated(*args, **kwargs):
func(*args, **kwargs)
return decorated
return decorator
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
data = self.getView(endpoint)(request, **values)
return Response(data, mimetype="text/html")
except HTTPException, e:
print "e"
return e
示例12: application
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def application(environ, start_response):
request = Request(environ)
if os.path.exists(PATH):
with open(PATH) as yaml:
data = load(yaml)
else:
data = {}
urls = {}
for reference in data.get("references", []):
urls[reference.get("alias")] = reference.get("url")
url_map = Map([
Rule('/<alias>', endpoint='shortener'),
])
adapter = url_map.bind_to_environ(request.environ)
endpoint, values = adapter.match()
alias = values["alias"]
if alias not in urls:
raise NotFound()
response = redirect(urls[alias])
return response(environ, start_response)
示例13: handle_url
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
def handle_url(aConfig, environ, session):
def handle_index(environ, session):
statuscode, mimetype, body = handle_static(
aConfig, environ, aConfig["gConfig"]["applications"][app]["static"]["page"]["indexpage"]
)
return statuscode, mimetype, body
statuscode, mimetype, body = 200, "text/json", "{}"
app = aConfig["gConfig"]["wsgi"]["application"]
urllist = []
for key in aConfig["gConfig"]["applications"][app]["url_mapping"].keys():
urllist.append(Rule(key, endpoint=aConfig["gConfig"]["applications"][app]["url_mapping"][key]))
urlmap = Map(urllist, converters={"bool": BooleanConverter})
urls = urlmap.bind_to_environ(environ)
try:
endpoint, args = urls.match()
if endpoint == "handle_index":
statuscode, mimetype, body = handle_index(environ, session)
else:
body = json.dumps({"result": u"access_deny"}, ensure_ascii=True, indent=4)
# except HTTPException, e:
except Exception as e:
traceback.print_exc()
body = json.dumps({"result": u"error:%s" % e.message}, ensure_ascii=True, indent=4)
return statuscode, mimetype, body
示例14: NichtParasoup
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class NichtParasoup(object):
# init webserver with routing
def __init__(self):
self.url_map = Map([
Rule('/', endpoint='root'),
Rule('/status', endpoint='cache_status'),
Rule('/get', endpoint='cache_get'),
Rule('/imagelist', endpoint='show_imagelist'),
Rule('/blacklist', endpoint='show_blacklist'),
Rule('/flush', endpoint='flush'),
Rule('/reset', endpoint='reset'),
])
# proxy call to the wsgi_app
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
# calculate the request and use the defined map to route
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return getattr(self, 'on_' + endpoint)(request, **values)
except HTTPException as e:
return e
# the wsgi app itself
def wsgi_app(self, environ, start_response):
request = Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
# start page with js and scroll
def on_root(self, request):
return Response(tmpl.root, mimetype='text/html')
# map function for print the status
def on_cache_status(self, request):
return Response(cache_status())
# map function for getting an image url
def on_cache_get(self, request):
return Response(cache_get())
# map function for showing blacklist
def on_show_blacklist(self, request):
return Response(show_blacklist())
# map function for showing imagelist
def on_show_imagelist(self, request):
return Response(show_imagelist())
# map function for flushing (deleting everything in cache)
def on_flush(self, request):
return Response(flush())
# map function for resetting (deleting everythign in cache and blacklist)
def on_reset(self, request):
return Response(reset())
示例15: InputReqApp
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind_to_environ [as 别名]
class InputReqApp(object):
def __init__(self):
self.url_map = Map()
self.url_map.add(Rule('/test/<path:url>', endpoint=self.direct_input_request))
self.url_map.add(Rule('/test-postreq', endpoint=self.post_fullrequest))
def direct_input_request(self, environ, url=''):
inputreq = DirectWSGIInputRequest(environ)
return inputreq.reconstruct_request(url)
def post_fullrequest(self, environ):
params = dict(parse_qsl(environ.get('QUERY_STRING', '')))
inputreq = POSTInputRequest(environ)
return inputreq.reconstruct_request(params['url'])
def __call__(self, environ, start_response):
urls = self.url_map.bind_to_environ(environ)
try:
endpoint, args = urls.match()
except HTTPException as e:
return e(environ, start_response)
result = endpoint(environ, **args)
start_response('200 OK', [('Content-Type', 'text/plain; charset=utf-8')])
return [result]