本文整理汇总了Python中werkzeug.routing.Map.add方法的典型用法代码示例。如果您正苦于以下问题:Python Map.add方法的具体用法?Python Map.add怎么用?Python Map.add使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类werkzeug.routing.Map
的用法示例。
在下文中一共展示了Map.add方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class App:
def __init__(self):
self._url_map = Map(strict_slashes=False)
def route(self, rule, **kwargs):
def decorator(func):
kwargs['endpoint'] = func
self._url_map.add(Rule(rule, **kwargs))
return func
return decorator
def _dispatch(self, request):
adapter = self._url_map.bind_to_environ(request.environ)
try:
endpoint, values = adapter.match()
return endpoint(request, **values)
except HTTPException as e:
return e
def __call__(self, env, sr):
request = AppRequest(env)
response = self._dispatch(request)
after_handlers = getattr(request, '_after_request_handlers', None)
if after_handlers:
for h in after_handlers:
response = h(response) or response
return response(env, sr)
示例2: Mapper
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class Mapper(object):
def __init__(self, import_name):
self.import_name = import_name
self.url_map = Map()
self.url_views = {}
@property
def url_rules(self):
return self.url_map.iter_rules()
def build_endpoint(self, endpoint):
return '{0}.{1}'.format(self.import_name, endpoint)
def add_route(self, rule, endpoint, view_func=None, **options):
options['endpoint'] = endpoint
self.url_map.add(Rule(rule, **options))
if view_func:
self.url_views[endpoint] = view_func
def route(self, rule, **options):
def decorator(func):
endpoint = options.pop('endpoint', func.__name__)
endpoint = self.build_endpoint(endpoint)
self.add_route(rule, endpoint, func, **options)
return func
return decorator
def add_map(self, map, prefix='', rule_factory=Submount):
self.url_views.update(map.url_views)
self.url_map.add(
rule_factory('/%s' % prefix.rstrip('/'), map.url_rules)
)
示例3: build_urls
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
def build_urls():
views = {
'famfamfam/get' : famfamfam.get,
'admin/configuration' : configure.nut,
'admin/eb' : configure.eb,
'admin/eb_rec' : configure.eb_rec,
'admin/eb_fix' : configure.fix_nodes,
'admin/index' : configure.list
}
# secure the admin area
from util.decorators import require_admin
for key in views:
if key.startswith('admin'):
views[key] = require_admin(views[key])
admin_tabs = []
url_map = Map(rules())
for nut in NutSettings().nuts:
mod = __import__('hazel.nuts.%s.urls' % nut, fromlist=['hazel.nuts.%s' % nut])
pub, pub_views, admin, admin_views, tabs = mod.build_rules()
url_map.add(EndpointPrefix('nut:%s/' % nut, pub))
url_map.add(EndpointPrefix('nut:%s/' % nut,
[Submount('/admin/%s' % nut, admin)]))
admin_tabs.extend([(rule.endpoint, name) for name, rule in tabs])
views.update([(rule.endpoint, fn) for rule, fn in pub_views])
# secure admin
views.update([(rule.endpoint, require_admin(fn)) for rule, fn in admin_views])
# tell the layout engine about the enabled modules
from util.decorators import jinja_const
jinja_const('admin_tabs', admin_tabs)
return url_map, views
示例4: InputReqApp
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [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]
示例5: make_url_map
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
def make_url_map(self):
url_map = Map()
for provider in self._providers:
rule = provider.get_url_rule()
rule.endpoint = provider
url_map.add(rule)
return url_map
示例6: Cup
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [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
示例7: Dispatcher
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class Dispatcher(object):
"""Dispatch requests based on a WSGI environment.
The routes are loaded from the <package>/config/routes file, and each line should be blank,
a comment, or one of the following:
<route> <page class>
<route> redirect:<url>
<route> template:<filename>
"""
def __init__(self, app):
"""Load the URL routing map and instantiate the responders."""
self.app = app
# Set up URL routing
self.map = Map()
routes_file = file(os.path.join(app.directory, 'config', 'routes'), 'r')
for line in routes_file:
# Split the line from one of the documented formats
parts = line.split()
if len(parts) == 0 or parts[0][0] == '#':
# Ignore comments and blank lines
continue
if len(parts) != 2:
raise ConfigurationError("Error in routes file: %s" % line)
path, destination = parts
if ':' in destination:
# Responder explicitly specified
responder_name, extra = destination.split(':', 1)
responder_type = responder_types.get(responder_name, None)
if responder_type is None:
raise ConfigurationError("Invalid destination '%s' in routes file" % destination)
responder = responder_type(extra)
else:
# Default to PageResponder if there's no ':' in the destination
responder = PageResponder(destination)
for p, r in responder.get_routes(path): # FIXME: Better names for p and r
rule = Rule(p, endpoint=r, methods=r.methods)
self.map.add(rule)
self.map.update()
def dispatch(self, environ):
try:
request = Request(environ)
urls = self.map.bind_to_environ(environ)
responder, args = urls.match()
with Context(self.app, environ, request, args) as context:
for hook in self.app.get_hook_functions('pre-request'):
hook(context)
context.response = responder(context)
for hook in self.app.get_hook_functions('post-request'):
context.response = hook(context) or context.response
return context.response
# HTTPExceptions are returned as the response, while any other
# exceptions are re-raised to be either caught by the in-browser debugger
# or generate a 500 response.
except HTTPException, e:
return e
示例8: RestRouter
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class RestRouter(object):
def __init__(self, json_encoder):
self.handlers = {}
self.map = Map()
self.encoder = json_encoder
def add_rule(self, rule, fn):
if rule.endpoint in self.handlers:
raise ValueError("Endpoint {} already present".format(rule.endpoint))
self.handlers[rule.endpoint] = fn
self.map.add(rule)
def add_resource(self, service, path):
rules = RestRules(path)
for method in RestRules.METHOD_NAMES:
if callable(getattr(service, method, None)):
self.add_rule(getattr(rules, method), getattr(service, method))
def __call__(self, request, response):
matcher = self.map.bind_to_environ(request.environ)
endpoint, args = matcher.match()
handler = self.handlers[endpoint]
result = handler(args, request)
if isinstance(result, Response):
return result
elif result is not None:
response.set_data(self.encoder.encode(result))
response.content_type = 'application/json'
return response
else:
return response
示例9: server
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
def server(path='/'):
try:
account = g.account
application = g.account.application
# prepare the jinja environment. This is used for regular routes
# and special handlers such as 404
template_lookup = {t.key: t.jinja2 for t in application.templates}
loader = DictLoader(template_lookup)
jinja_env = SandboxedEnvironment(
extensions=['application.app.pyjade.ext.jinja.PyJadeExtension'],
loader=loader)
# default helper utils
path = PathUtil(request.environ)
get = GetUtil(request)
static = StaticUtil()
# load template data. 404 can also use these
template_data = {}
template_data['path'] = path
template_data['get'] = get
template_data['cms'] = cms
template_data['static'] = static
template_data['deployment'] = config.TEMPLATE_GLOBAL_DEPLOYMENT
template_data['markdown'] = service.markdown
template_content = {}
for content in application.static_contents:
template_content.update(content.data)
template_data['content'] = template_content
# find the route with werkzeug
url_map = Map()
for route in application.routes:
# skip non string rules like 404. These should be handled by exceptions
if not route.rule.isnumeric():
url_map.add(Rule(route.rule, endpoint=route.template_name))
urls = url_map.bind_to_environ(request.environ)
endpoint, args = urls.match()
template_data['path'].add_placeholders(args)
app_template = jinja_env.get_template(endpoint)
page_content = app_template.render(**template_data)
app.record_transfer(page_content)
return page_content
except NotFound as e:
# find the template for a 404 handler if specified
for route in application.routes:
if route.rule == '404':
app_template = jinja_env.get_template(route.template_name)
not_found_page = app_template.render(**template_data)
app.record_transfer(not_found_page)
return not_found_page, 404
return '404', 404
except Exception as e:
return '500 internal error', 500
示例10: BrownAnt
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class BrownAnt(object):
"""The app which could manage whole crawler system."""
def __init__(self):
self.url_map = Map(strict_slashes=False, host_matching=True)
def add_url_rule(self, host, rule_string, endpoint, **options):
"""Add a url rule to the app instance.
The url rule is the same with Flask apps and other Werkzeug apps.
:param host: the matched hostname. e.g. "www.python.org"
:param rule_string: the matched path pattern. e.g. "/news/<int:id>"
:param endpoint: the endpoint name as a dispatching key such as the
qualified name of the object.
"""
rule = Rule(rule_string, host=host, endpoint=endpoint, **options)
self.url_map.add(rule)
def parse_url(self, url_string):
"""Parse the URL string with the url map of this app instance.
:param url_string: the origin URL string.
:returns: the tuple as `(url, url_adapter, query_args)`, the url is
parsed by the standard library `urlparse`, the url_adapter is
from the werkzeug bound URL map, the query_args is a
multidict from the werkzeug.
"""
url = urlparse.urlparse(url_string)
url_adapter = self.url_map.bind(server_name=url.hostname,
url_scheme=url.scheme,
path_info=url.path)
query_args = url_decode(url.query)
return url, url_adapter, query_args
def dispatch_url(self, url_string):
"""Dispatch the URL string to the target endpoint function.
:param url_string: the origin URL string.
:returns: the return value of calling dispatched function.
"""
url, url_adapter, query_args = self.parse_url(url_string)
try:
endpoint, kwargs = url_adapter.match()
except NotFound:
raise NotSupported(url_string)
handler = import_string(endpoint)
request = Request(args=query_args)
return handler(request, **kwargs)
def mount_site(self, site):
"""Mount a supported site to this app instance.
:param site: the site instance be mounted.
"""
site.play_actions(target=self)
示例11: Sockets
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class Sockets(object):
def __init__(self, app=None):
#: Compatibility with 'Flask' application.
#: The :class:`~werkzeug.routing.Map` for this instance. You can use
#: this to change the routing converters after the class was created
#: but before any routes are connected.
self.url_map = Map()
#: Compatibility with 'Flask' application.
#: All the attached blueprints in a dictionary by name. Blueprints
#: can be attached multiple times so this dictionary does not tell
#: you how often they got attached.
self.blueprints = {}
self._blueprint_order = []
if app:
self.init_app(app)
def init_app(self, app):
app.wsgi_app = SocketMiddleware(app.wsgi_app, app, self)
def route(self, rule, **options):
def decorator(f):
endpoint = options.pop('endpoint', None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
def add_url_rule(self, rule, _, f, **options):
self.url_map.add(Rule(rule, endpoint=f))
def register_blueprint(self, blueprint, **options):
"""
Registers a blueprint for web sockets like for 'Flask' application.
Decorator :meth:`~flask.app.setupmethod` is not applied, because it
requires ``debug`` and ``_got_first_request`` attributes to be defined.
"""
first_registration = False
if blueprint.name in self.blueprints:
assert self.blueprints[blueprint.name] is blueprint, (
'A blueprint\'s name collision occurred between %r and '
'%r. Both share the same name "%s". Blueprints that '
'are created on the fly need unique names.'
% (blueprint, self.blueprints[blueprint.name], blueprint.name))
else:
self.blueprints[blueprint.name] = blueprint
self._blueprint_order.append(blueprint)
first_registration = True
blueprint.register(self, options, first_registration)
示例12: BaseDispatcher
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class BaseDispatcher(object):
request_class = None
response_class = None
auth_class = None
def __init__(self):
self.url_map = Map()
def add_resource(self, resource, parent_resource=None):
if parent_resource:
try:
for rule in self.url_map.iter_rules(parent_resource.on_detail):
detail_rule = rule
rulefactory = Submount(detail_rule.rule, (resource,))
except AttributeError:
raise AttributeError(
'The parent resource must define the "on_detail" method')
else:
rulefactory = resource
self.url_map.add(rulefactory)
def dispatch_request(self, request):
adapter = self.url_map.bind_to_environ(request.environ)
endpoint, params = adapter.match()
params.update(data=request.data)
params.update(request.args)
if endpoint.requires_auth:
endpoint = self.auth_class(endpoint, request)
return endpoint(params)
def __call__(self, environ, start_response):
request = self.request_class(environ)
try:
response = self.response_class(self.dispatch_request(request))
except HTTPException as e:
response = self.response_class({'error': e.description}, e.code, headers=e.get_headers())
return response(environ, start_response)
def run(self, host='127.0.0.1', port=5000,
use_debugger=True, use_reloader=True):
from werkzeug.serving import run_simple
run_simple(
host,
port,
self,
use_debugger=use_debugger,
use_reloader=use_reloader
)
示例13: load_websites
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
def load_websites(self):
"""Load the websites and build a map of the website names to the ID
in database for quick connection to the website
"""
website_obj = self.pool.get("nereid.website")
url_map_obj = self.pool.get('nereid.url_map')
# Load all url maps first because many websites might reuse the same
# URL map and it might be faster to load them just once
url_map_ids = url_map_obj.search([])
url_maps = dict.fromkeys(url_map_ids)
for url_map_id in url_map_ids:
url_map = Map() # Define a new map
# Add the static url
url_map.add(
self.url_rule_class(
self.static_url_path + '/<path:filename>',
endpoint = 'static'
)
)
url_rules = url_map_obj.get_rules_arguments(url_map_id)
for url in url_rules:
rule = self.url_rule_class(url.pop('rule'), **url)
rule.provide_automatic_options = True
url_map.add(rule) # Add rule to map
if (not url['build_only']) and not(url['redirect_to']):
# Add the method to the view_functions list if the
# endpoint was not a build_only url
self.view_functions[url['endpoint']] = self.get_method(
url['endpoint']
)
url_maps[url_map_id] = url_map
website_ids = website_obj.search([])
for website in website_obj.browse(website_ids):
self.websites[website.name] = {
'id': website.id,
'url_map': url_maps[website.url_map.id],
'application_user': website.application_user.id,
'guest_user': website.guest_user.id,
'company': website.company.id,
}
# Finally add the view_function for static
self.view_functions['static'] = self.send_static_file
示例14: Sockets
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class Sockets(object):
def __init__(self, app=None):
self.url_map = Map()
if app:
self.init_app(app)
def init_app(self, app):
app.wsgi_app = SocketMiddleware(app.wsgi_app, app, self)
def route(self, rule, **options):
def decorator(f):
endpoint = options.pop("endpoint", None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
def add_url_rule(self, rule, _, f, **options):
self.url_map.add(Rule(rule, endpoint=f))
示例15: App
# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import add [as 别名]
class App(object):
def __init__(self):
self.urls = Map()
def route(self, pat):
def decorator(fun):
self.urls.add(Rule(pat, endpoint=fun))
return decorator
def dispatch_request(self, req, res):
adapter = self.urls.bind_to_environ(req.environ)
try:
endpoint, values = adapter.match()
return endpoint(req, res, **values)
except HTTPException as e:
return e
def __call__(self, environ, start_response):
request = Request(environ)
response = Response(environ, start_response)
Task(self.dispatch_request(request, response))
return response