Python Map.iter_rules方法代码示例

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [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)
        )

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [as 别名]
def test_rule_templates():
    """Rule templates"""
    testcase = RuleTemplate(
        [ Submount('/test/$app',
          [ Rule('/foo/', endpoint='handle_foo')
          , Rule('/bar/', endpoint='handle_bar')
          , Rule('/baz/', endpoint='handle_baz')
          ]),
          EndpointPrefix('${app}',
          [ Rule('/${app}-blah', endpoint='bar')
          , Rule('/${app}-meh', endpoint='baz')
          ]),
          Subdomain('$app',
          [ Rule('/blah', endpoint='x_bar')
          , Rule('/meh', endpoint='x_baz')
          ])
        ])

    url_map = Map(
        [ testcase(app='test1')
        , testcase(app='test2')
        , testcase(app='test3')
        , testcase(app='test4')
        ])

    out = sorted([(x.rule, x.subdomain, x.endpoint)
                  for x in url_map.iter_rules()])

    assert out == ([
        ('/blah', 'test1', 'x_bar'),
        ('/blah', 'test2', 'x_bar'),
        ('/blah', 'test3', 'x_bar'),
        ('/blah', 'test4', 'x_bar'),
        ('/meh', 'test1', 'x_baz'),
        ('/meh', 'test2', 'x_baz'),
        ('/meh', 'test3', 'x_baz'),
        ('/meh', 'test4', 'x_baz'),
        ('/test/test1/bar/', '', 'handle_bar'),
        ('/test/test1/baz/', '', 'handle_baz'),
        ('/test/test1/foo/', '', 'handle_foo'),
        ('/test/test2/bar/', '', 'handle_bar'),
        ('/test/test2/baz/', '', 'handle_baz'),
        ('/test/test2/foo/', '', 'handle_foo'),
        ('/test/test3/bar/', '', 'handle_bar'),
        ('/test/test3/baz/', '', 'handle_baz'),
        ('/test/test3/foo/', '', 'handle_foo'),
        ('/test/test4/bar/', '', 'handle_bar'),
        ('/test/test4/baz/', '', 'handle_baz'),
        ('/test/test4/foo/', '', 'handle_foo'),
        ('/test1-blah', '', 'test1bar'),
        ('/test1-meh', '', 'test1baz'),
        ('/test2-blah', '', 'test2bar'),
        ('/test2-meh', '', 'test2baz'),
        ('/test3-blah', '', 'test3bar'),
        ('/test3-meh', '', 'test3baz'),
        ('/test4-blah', '', 'test4bar'),
        ('/test4-meh', '', 'test4baz')
    ])

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [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
        )

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [as 别名]
def test_rule_templates():
    """Rule templates"""
    testcase = RuleTemplate(
        [
            Submount(
                "/test/$app",
                [
                    Rule("/foo/", endpoint="handle_foo"),
                    Rule("/bar/", endpoint="handle_bar"),
                    Rule("/baz/", endpoint="handle_baz"),
                ],
            ),
            EndpointPrefix("foo_", [Rule("/blah", endpoint="bar"), Rule("/meh", endpoint="baz")]),
            Subdomain("meh", [Rule("/blah", endpoint="x_bar"), Rule("/meh", endpoint="x_baz")]),
        ]
    )

    url_map = Map([testcase(app="test1"), testcase(app="test2"), testcase(app="test3"), testcase(app="test4")])

    out = [(x.rule, x.subdomain, x.endpoint) for x in url_map.iter_rules()]
    assert out == (
        [
            ("/test/test1/foo/", "", "handle_foo"),
            ("/test/test1/bar/", "", "handle_bar"),
            ("/test/test1/baz/", "", "handle_baz"),
            ("/blah", "", "foo_bar"),
            ("/meh", "", "foo_baz"),
            ("/blah", "meh", "x_bar"),
            ("/meh", "meh", "x_baz"),
            ("/test/test2/foo/", "", "handle_foo"),
            ("/test/test2/bar/", "", "handle_bar"),
            ("/test/test2/baz/", "", "handle_baz"),
            ("/blah", "", "foo_bar"),
            ("/meh", "", "foo_baz"),
            ("/blah", "meh", "x_bar"),
            ("/meh", "meh", "x_baz"),
            ("/test/test3/foo/", "", "handle_foo"),
            ("/test/test3/bar/", "", "handle_bar"),
            ("/test/test3/baz/", "", "handle_baz"),
            ("/blah", "", "foo_bar"),
            ("/meh", "", "foo_baz"),
            ("/blah", "meh", "x_bar"),
            ("/meh", "meh", "x_baz"),
            ("/test/test4/foo/", "", "handle_foo"),
            ("/test/test4/bar/", "", "handle_bar"),
            ("/test/test4/baz/", "", "handle_baz"),
            ("/blah", "", "foo_bar"),
            ("/meh", "", "foo_baz"),
            ("/blah", "meh", "x_bar"),
            ("/meh", "meh", "x_baz"),
        ]
    )

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [as 别名]
def make_application (setup_graph):

    site_config = setup_graph.value (None, a, WALD.SiteConfig)
    project_root = setup_graph.value (site_config, WALD.projectRoot)
    site_root = setup_graph.value (site_config, WALD.siteRoot)

    base = setup_graph.value (site_config, WALD.base)

    ld = wald.storage.tools.LinkedData (project_root, site_root)

    endpoints = {}

    rules = []
    for dataset in setup_graph[:a:WALD.Dataset]:
        name = setup_graph.value (dataset, DC.identifier)

        readOnly = bool (setup_graph.value (dataset, WALD.readOnly))
        if not readOnly:
            # The following sets up the edit endpoint for a dataset.
            endpoints['edit ' + name] = patch_endpoint (setup_graph, ld, dataset)
            rules.append (Rule ('/' + name + '/', methods=[ 'PATCH', 'POST' ],
                                endpoint='edit ' + name))

        data_graph = setup_graph.value (dataset, WALD.dataGraph)
        edit_graph = setup_graph.value (dataset, WALD.editGraph)

        ldf_base = iri_join (base, 'fragments', name).rstrip ('/')
        for g, ldf in [ (data_graph, ldf_base),
                        (edit_graph, iri_join (ldf_base, 'edit').rstrip ('/')) ]:
            path = '/' + g.replace (base, '').lstrip ('/').rstrip ('/') + '/'
            endpoint = 'named graph redirect ' + g
            endpoints[endpoint] = redirect_endpoint (ldf)
            rules.append (Rule (path, methods=[ 'GET' ], endpoint=endpoint))

    routing_map = Map (rules)

    for rule in routing_map.iter_rules ():
        print (rule.description ())

    @LimitedRequest.application
    def application (request):
        adapter = routing_map.bind_to_environ (request.environ)
        try:
            endpoint, values = adapter.match ()
            return endpoints[endpoint] (request, **values)
        except werkzeug.exceptions.HTTPException as e:
            return e

    return application

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import iter_rules [as 别名]

#.........这里部分代码省略.........
                self.socketio.emit('state', {
                    'uri': uri,
                    'resource': resource
                }, room=request.sid)

            join_room(uri)

        @socketio.on('unsubscribe', namespace=self.namespace)
        def handle_unsubscribe(uri):
            leave_room(uri)

        @socketio.on_error(self.namespace)
        def handle_error(e):
            if isinstance(e, SocketAPIError):
                # Instances of SocketAPIError are forwarded to the client.
                self.socketio.emit('api_error', {
                    'error':  e.__class__.__name__,
                    'message': str(e)
                }, room=request.sid)
            else:
                # Other errors are considered server errors and should not be
                # forwarded to the client, except in debug mode.
                self.socketio.emit('server_error', {
                    'error':  e.__class__.__name__,
                    'message': str(e) if current_app.debug else None
                }, room=request.sid)

            # Log the error.
            current_app.logger.exception(e)

    def resource_creator(self, rule):
        # Make sure the given rule corresponds to a list uri.
        if not rule.endswith('/'):
            raise InvalidURIError('resource creators should be registered on list uri')

        def decorate(fn):
            @wraps(fn)
            def decorated(*args, **kwargs):
                return fn(*args, **kwargs)

            # Register a new POST route for the given rule.
            self.routes.add(Rule(rule, endpoint=decorated, methods=['POST']))

            return decorated
        return decorate

    def resource_getter(self, rule):
        def decorate(fn):
            @wraps(fn)
            def decorated(*args, **kwargs):
                return fn(*args, **kwargs)

            # Register a new GET route for the given rule.
            self.routes.add(Rule(rule, endpoint=decorated, methods=['GET']))

            return decorated
        return decorate

    def resource_patcher(self, rule):
        # Make sure the rule doesn't correspond to a list.
        if rule.endswith('/'):
            raise InvalidURIError('cannot register resource patchers on a list uri')

        def decorate(fn):
            @wraps(fn)
            def decorated(*args, **kwargs):
                return fn(*args, **kwargs)

            # Check if there already is a route to catch patch requests on the
            # given rule.
            for route in self.routes.iter_rules():
                if (route.rule == rule) and ('PATCH' in route.methods):
                    break
            else:
                # Register a new PATCH route for the given rule.
                self.routes.add(Rule(rule, methods=['PATCH']))

            # Register the given patch handler.
            if rule not in self.patch_handlers:
                self.patch_handlers[rule] = []
            self.patch_handlers[rule].append(decorated)

            return decorated
        return decorate

    def resource_deleter(self, rule):
        # Make sure the rule doesn't correspond to a list.
        if rule.endswith('/'):
            raise InvalidURIError('cannot register resource deleters on a list uri')

        def decorate(fn):
            @wraps(fn)
            def decorated(*args, **kwargs):
                return fn(*args, **kwargs)

            # Register a new DELETE route for the given rule.
            self.routes.add(Rule(rule, endpoint=decorated, methods=['DELETE']))

            return decorated
        return decorate