Python Map.bind方法代码示例

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_basic_building():
    """Basic URL building"""
    map = Map([
        Rule('/', endpoint='index'),
        Rule('/foo', endpoint='foo'),
        Rule('/bar/<baz>', endpoint='bar'),
        Rule('/bar/<int:bazi>', endpoint='bari'),
        Rule('/bar/<float:bazf>', endpoint='barf'),
        Rule('/bar/<path:bazp>', endpoint='barp'),
        Rule('/hehe', endpoint='blah', subdomain='blah')
    ])
    adapter = map.bind('example.org', '/', subdomain='blah')

    assert adapter.build('index', {}) == 'http://example.org/'
    assert adapter.build('foo', {}) == 'http://example.org/foo'
    assert adapter.build('bar', {'baz': 'blub'}) == 'http://example.org/bar/blub'
    assert adapter.build('bari', {'bazi': 50}) == 'http://example.org/bar/50'
    assert adapter.build('barf', {'bazf': 0.815}) == 'http://example.org/bar/0.815'
    assert adapter.build('barp', {'bazp': 'la/di'}) == 'http://example.org/bar/la/di'
    assert adapter.build('blah', {}) == '/hehe'
    assert_raises(BuildError, lambda: adapter.build('urks'))

    adapter = map.bind('example.org', '/test', subdomain='blah')
    assert adapter.build('index', {}) == 'http://example.org/test/'
    assert adapter.build('foo', {}) == 'http://example.org/test/foo'
    assert adapter.build('bar', {'baz': 'blub'}) == 'http://example.org/test/bar/blub'
    assert adapter.build('bari', {'bazi': 50}) == 'http://example.org/test/bar/50'
    assert adapter.build('barf', {'bazf': 0.815}) == 'http://example.org/test/bar/0.815'
    assert adapter.build('barp', {'bazp': 'la/di'}) == 'http://example.org/test/bar/la/di'
    assert adapter.build('blah', {}) == '/test/hehe'

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_path():
    """URL routing path converter behavior"""
    map = Map(
        [
            Rule("/", defaults={"name": "FrontPage"}, endpoint="page"),
            Rule("/Special", endpoint="special"),
            Rule("/<int:year>", endpoint="year"),
            Rule("/<path:name>", endpoint="page"),
            Rule("/<path:name>/edit", endpoint="editpage"),
            Rule("/<path:name>/silly/<path:name2>", endpoint="sillypage"),
            Rule("/<path:name>/silly/<path:name2>/edit", endpoint="editsillypage"),
            Rule("/Talk:<path:name>", endpoint="talk"),
            Rule("/User:<username>", endpoint="user"),
            Rule("/User:<username>/<path:name>", endpoint="userpage"),
            Rule("/Files/<path:file>", endpoint="files"),
        ]
    )
    adapter = map.bind("example.org", "/")

    assert adapter.match("/") == ("page", {"name": "FrontPage"})
    assert_raises(RequestRedirect, lambda: adapter.match("/FrontPage"))
    assert adapter.match("/Special") == ("special", {})
    assert adapter.match("/2007") == ("year", {"year": 2007})
    assert adapter.match("/Some/Page") == ("page", {"name": "Some/Page"})
    assert adapter.match("/Some/Page/edit") == ("editpage", {"name": "Some/Page"})
    assert adapter.match("/Foo/silly/bar") == ("sillypage", {"name": "Foo", "name2": "bar"})
    assert adapter.match("/Foo/silly/bar/edit") == ("editsillypage", {"name": "Foo", "name2": "bar"})
    assert adapter.match("/Talk:Foo/Bar") == ("talk", {"name": "Foo/Bar"})
    assert adapter.match("/User:thomas") == ("user", {"username": "thomas"})
    assert adapter.match("/User:thomas/projects/werkzeug") == (
        "userpage",
        {"username": "thomas", "name": "projects/werkzeug"},
    )
    assert adapter.match("/Files/downloads/werkzeug/0.2.zip") == ("files", {"file": "downloads/werkzeug/0.2.zip"})

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_path():
    """URL routing path converter behavior"""
    map = Map([
        Rule('/', defaults={'name': 'FrontPage'}, endpoint='page'),
        Rule('/Special', endpoint='special'),
        Rule('/<int:year>', endpoint='year'),
        Rule('/<path:name>', endpoint='page'),
        Rule('/<path:name>/edit', endpoint='editpage'),
        Rule('/<path:name>/silly/<path:name2>', endpoint='sillypage'),
        Rule('/<path:name>/silly/<path:name2>/edit', endpoint='editsillypage'),
        Rule('/Talk:<path:name>', endpoint='talk'),
        Rule('/User:<username>', endpoint='user'),
        Rule('/User:<username>/<path:name>', endpoint='userpage'),
        Rule('/Files/<path:file>', endpoint='files'),
    ])
    adapter = map.bind('example.org', '/')

    assert adapter.match('/') == ('page', {'name':'FrontPage'})
    assert_raises(RequestRedirect, lambda: adapter.match('/FrontPage'))
    assert adapter.match('/Special') == ('special', {})
    assert adapter.match('/2007') == ('year', {'year':2007})
    assert adapter.match('/Some/Page') == ('page', {'name':'Some/Page'})
    assert adapter.match('/Some/Page/edit') == ('editpage', {'name':'Some/Page'})
    assert adapter.match('/Foo/silly/bar') == ('sillypage', {'name':'Foo', 'name2':'bar'})
    assert adapter.match('/Foo/silly/bar/edit') == ('editsillypage', {'name':'Foo', 'name2':'bar'})
    assert adapter.match('/Talk:Foo/Bar') == ('talk', {'name':'Foo/Bar'})
    assert adapter.match('/User:thomas') == ('user', {'username':'thomas'})
    assert adapter.match('/User:thomas/projects/werkzeug') == ('userpage', {'username':'thomas', 'name':'projects/werkzeug'})
    assert adapter.match('/Files/downloads/werkzeug/0.2.zip') == ('files', {'file':'downloads/werkzeug/0.2.zip'})

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
 def bind(self, server_name, script_name=None, subdomain=None,
          url_scheme='http', default_method='GET', path_info=None,
          query_args=None):
     org_adapter = _Map.bind(self, server_name, script_name, subdomain,
                             subdomain, url_scheme, default_method,
                             path_info, query_args)
     return self._convert_adapter(org_adapter)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_adapter_url_parameter_sorting():
    """Optional adapter URL parameter sorting"""
    map = Map([Rule('/', endpoint='index')], sort_parameters=True,
              sort_key=lambda x: x[1])
    adapter = map.bind('localhost', '/')
    assert adapter.build('index', {'x': 20, 'y': 10, 'z': 30},
        force_external=True) == 'http://localhost/?y=10&x=20&z=30'

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_request_direct_charset_bug():
    map = Map([Rule(u'/öäü/')])
    adapter = map.bind('localhost', '/')
    try:
        adapter.match(u'/öäü')
    except RequestRedirect, e:
        assert e.new_url == 'http://localhost/%C3%B6%C3%A4%C3%BC/'

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
class JSONResolver(object):
    """Resolve JSON objects based on rules in URL map."""

    def __init__(self, plugins=None, entry_point_group=None):
        """Initialize resolver with various plugins and entry point group."""
        self.pm = pluggy.PluginManager('jsonresolver')
        self.pm.add_hookspecs(hookspec)
        for plugin in plugins or []:
            self.pm.register(
                importlib.import_module(plugin)
            )
        if entry_point_group:
            self.pm.load_setuptools_entrypoints(entry_point_group)
        self.url_map = None

    def _build_url_map(self):
        """Build an URL map from registered plugins."""
        self.url_map = Map()
        self.pm.hook.jsonresolver_loader(url_map=self.url_map)

    def resolve(self, url):
        """Resolve given URL and use regitered loader."""
        if self.url_map is None:
            self._build_url_map()
        parts = urlsplit(url)
        loader, args = self.url_map.bind(parts.hostname).match(parts.path)
        return loader(**args)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_adapter_url_parameter_sorting():
    """Optional adapter URL parameter sorting"""
    map = Map([Rule("/", endpoint="index")], sort_parameters=True, sort_key=lambda x: x[1])
    adapter = map.bind("localhost", "/")
    assert (
        adapter.build("index", {"x": 20, "y": 10, "z": 30}, force_external=True) == "http://localhost/?y=10&x=20&z=30"
    )

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_external_building_with_port():
    """Test external URL building with port number"""
    map = Map([
        Rule('/', endpoint='index'),
    ])
    adapter = map.bind('example.org:5000', '/')
    built_url = adapter.build('index', {}, force_external=True)
    assert built_url == 'http://example.org:5000/', built_url

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_request_redirect_default_subdomain():
    map = Map([Rule(u'/foo', defaults={'bar': 42}, subdomain='test'),
               Rule(u'/foo/<int:bar>', subdomain='other')])
    adapter = map.bind('localhost', '/', subdomain='other')
    try:
        adapter.match(u'/foo/42')
    except RequestRedirect, e:
        assert e.new_url == 'http://test.localhost/foo'

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_request_redirect_default():
    map = Map([Rule(u'/foo', defaults={'bar': 42}),
               Rule(u'/foo/<int:bar>')])
    adapter = map.bind('localhost', '/')
    try:
        adapter.match(u'/foo/42')
    except RequestRedirect, e:
        assert e.new_url == 'http://localhost/foo'

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_request_direct_charset_bug():
    map = Map([Rule(u"/öäü/")])
    adapter = map.bind("localhost", "/")
    try:
        adapter.match(u"/öäü")
    except RequestRedirect, e:
        print repr(e.new_url)
        assert e.new_url == "http://localhost/%C3%B6%C3%A4%C3%BC/"

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

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
class WebRouter(ServerHttpProtocol):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.api_root = '/'
        self.url_map = Map([
            Rule('/',
                 endpoint=api.ServerInfoEndpoint),
            Rule('/paged_query',
                 endpoint=api.PagedQueryEndpoint),
            Rule('/metadata',
                 endpoint=api.MetadataInfoEndpoint),
            Rule('/metadata/groups',
                 endpoint=api.GroupCollectionEndpoint),
            Rule('/metadata/groups/<int:id>',
                 endpoint=api.GroupEndpoint),
            Rule('/metadata/people',
                 endpoint=api.PeopleCollectionEndpoint),
            Rule('/metadata/people/<int:id>',
                 endpoint=api.PeopleEndpoint),
            Rule('/metadata/albums',
                 endpoint=api.AlbumCollectionEndpoint),
            Rule('/metadata/albums/<int:id>',
                 endpoint=api.AlbumEndpoint),
            Rule('/metadata/songs',
                 endpoint=api.SongCollectionEndpoint),
            Rule('/metadata/songs/<int:id>',
                 endpoint=api.SongEndpoint),
            Rule('/metadata/tracks',
                 endpoint=api.TrackCollectionEndpoint),
            Rule('/metadata/tracks/<int:id>',
                 endpoint=api.TrackEndpoint),
            Rule('/audio',
                 endpoint=api.AudioCollectionEndpoint),
            Rule('/audio/<audio_name>.<format>',
                 endpoint=api.AudioEndpoint),
            Rule('/users',
                 endpoint=api.UserCollectionEndpoint),
            Rule('/users/<user_id>',
                 endpoint=api.UserEndpoint),
            Rule('/users/<user_id>/playlists',
                 endpoint=api.PlaylistCollectionEndpoint),
            Rule('/users/<user_id>/playlists/<pl_id>',
                 endpoint=api.PlaylistEndpoint),
            Rule('/users/<user_id>/playlists/<pl_id>/<entry_id>',
                 endpoint=api.PlaylistEntryEndpoint)
        ])

    @asyncio.coroutine
    def handle_request(self, message, payload):
        now = time.time()
        urls = self.url_map.bind(message.headers['HOST'], self.api_root)
        try:
            endpoint_type, path_args = urls.match(message.path)
        except NotFound:
            endpoint_type, path_args = api.NotFoundEndpoint, {}
        endpoint = endpoint_type(self)
        response = yield from endpoint.handle(path_args, message, payload)
        self.log_access(message, None, response, time.time() - now)

# 需要导入模块: from werkzeug.routing import Map [as 别名]
# 或者: from werkzeug.routing.Map import bind [as 别名]
def test_implicit_head():
    """Test implicit HEAD in URL rules where GET is present"""
    url_map = Map([
        Rule('/get', methods=['GET'], endpoint='a'),
        Rule('/post', methods=['POST'], endpoint='b')
    ])
    adapter = url_map.bind('example.org')
    assert adapter.match('/get', method='HEAD') == ('a', {})
    assert_raises(MethodNotAllowed, adapter.match, '/post', method='HEAD')