Python urlpatterns.format_suffix_patterns函数代码示例

def recommender_patterns():
    return format_suffix_patterns(patterns('',
                                           # TODO, should be listed in a higher level
                                           # url(r'^v1.6/$',
                                           #     views.APIRootView.as_view(),
                                           #     name="api_root"),
                                           url(r'^public/recommender/?$',
                                               views.RecommenderAPIView.as_view(
                                               ),
                                               name="recommender-recommender"),
                                           url(r'^public/events/?$',
                                               views.EventsAPIView.as_view(),
                                               name="recommender-events"),
                                           url(r'^private/items/?$',
                                               views.ItemsAPIView.as_view(),
                                               name="recommender-items"),
                                           url(r'^public/recommender/redirect/?$',
                                               views.recommended_item_redirect,
                                               name="recommender-redirect"),
                                           url(r'^private/keywords/?$',
                                               views.KeywordAPIView.as_view(),
                                               name="recommender-keywords"),
                                           url(r'^private/stick_lists/?$',
                                               views.RecommendStickListsAPIView.as_view(),
                                               name="recommender-stick_lists"),
                                           url(r'^private/recommender/custom_lists/?$',
                                               views.RecommendCustomListsAPIView.as_view(),
                                               name="recommender-custom_lists"),
                                           ))

    def test_trailing_slash(self):
        factory = APIRequestFactory()
        urlpatterns = format_suffix_patterns([
            url(r'^test/$', dummy_view),
        ])
        resolver = RegexURLResolver(r'^/', urlpatterns)

        test_paths = [
            (URLTestPath('/test.api', (), {'format': 'api'}), True),
            (URLTestPath('/test/.api', (), {'format': 'api'}), False),
            (URLTestPath('/test.api/', (), {'format': 'api'}), True),
        ]

        for test_path, expected_resolved in test_paths:
            request = factory.get(test_path.path)
            try:
                callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)
            except Resolver404:
                callback, callback_args, callback_kwargs = (None, None, None)
            if not expected_resolved:
                assert callback is None
                continue

            assert callback_args == test_path.args
            assert callback_kwargs == test_path.kwargs

    def _resolve_urlpatterns(self, urlpatterns, test_paths, allowed=None):
        factory = APIRequestFactory()
        try:
            urlpatterns = format_suffix_patterns(urlpatterns, allowed=allowed)
        except Exception:
            self.fail("Failed to apply `format_suffix_patterns` on  the supplied urlpatterns")
        resolver = make_url_resolver(r'^/', urlpatterns)
        for test_path in test_paths:
            try:
                test_path, expected_resolved = test_path
            except (TypeError, ValueError):
                expected_resolved = True

            request = factory.get(test_path.path)
            try:
                callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)
            except Resolver404:
                callback, callback_args, callback_kwargs = (None, None, None)
                if expected_resolved:
                    raise
            except Exception:
                self.fail("Failed to resolve URL: %s" % request.path_info)

            if not expected_resolved:
                assert callback is None
                continue

            assert callback_args == test_path.args
            assert callback_kwargs == test_path.kwargs

    def get_urls(self):
        """
        Append non-viewset views to the urls
        generated by the original `get_urls` method.
        """
        # URLs for simple views
        ret = []
        for prefix, viewset, basename in self.registry:

            # Skip viewsets
            if issubclass(viewset, viewsets.ViewSetMixin):
                continue

            # URL regex
            regex = '{prefix}{trailing_slash}$'.format(
                prefix=prefix,
                trailing_slash=self.trailing_slash
            )

            # The view name has to have suffix "-list" due to specifics
            # of the DefaultRouter implementation.
            ret.append(url(
                regex, viewset.as_view(),
                name='{0}-list'.format(basename)
            ))

        # Format suffixes
        ret = format_suffix_patterns(ret, allowed=['json', 'html'])

        # Prepend URLs for viewsets and return
        return super(DefaultRouterWithSimpleViews, self).get_urls() + ret

    def get_urls(self):
        ret = []

        if self.include_root_view:
            root_url = url(r'^$', self.get_api_root_view(),
                           name=self.root_view_name)
            ret.append(root_url)
        for prefix, viewset, basename in self.registry:
            lookup = self.get_lookup_regex(viewset)
            lookup_list = self.get_lookup_regexes(viewset)
            if lookup_list:
                # lookup = lookups[0]
                lookup_list = [u'/'.join(k) for k in lookup_list]
            else:
                lookup_list = [u'']
            routes = self.get_routes(viewset)
            for route in routes:
                mapping = self.get_method_map(viewset, route.mapping)
                if not mapping:
                    continue
                for lookups in lookup_list:
                    regex = route.url.format(
                        prefix=prefix,
                        lookup=lookup,
                        lookups=lookups,
                        trailing_slash=self.trailing_slash,
                        extra=self.get_extra_lookup_regexes(route)
                    )
                    view = viewset.as_view(mapping, **route.initkwargs)
                    name = route.name.format(basename=basename)
                    ret.append(url(regex, view, name=name))
        if self.include_format_suffixes:
            ret = format_suffix_patterns(ret, allowed=['[a-z0-9]+'])
        return ret

 def _resolve_urlpatterns(self, urlpatterns, test_paths):
     factory = APIRequestFactory()
     try:
         urlpatterns = format_suffix_patterns(urlpatterns)
     except Exception:
         self.fail("Failed to apply `format_suffix_patterns` on  the supplied urlpatterns")
     resolver = urlresolvers.RegexURLResolver(r'^/', urlpatterns)
     for test_path in test_paths:
         request = factory.get(test_path.path)
         try:
             callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)
         except Exception:
             self.fail("Failed to resolve URL: %s" % request.path_info)
         self.assertEqual(callback_args, test_path.args)
         self.assertEqual(callback_kwargs, test_path.kwargs)

    def get_urls(self):
        """
        Generate the list of URL patterns, including a default root view
        for the API, and appending `.json` style format suffixes.
        """
        urls = super(DefaultRouter, self).get_urls()

        if self.include_root_view:
            view = self.get_api_root_view(schema_urls=urls)
            root_url = url(r'^$', view, name=self.root_view_name)
            urls.append(root_url)

        if self.include_format_suffixes:
            urls = format_suffix_patterns(urls)

        return urls

def search_patterns():
    return format_suffix_patterns(patterns('',
                                           # TODO, should be listed in a higher level
                                           # url(r'^v1.6/$',
                                           #     views.api_root,
                                           #     name="api_root"),
                                           url(r'^public/search/?$',
                                               views.ProductsSearch.as_view(),
                                               name="products-search"),
                                           url(r'^public/suggest/?$',
                                               views.QuerySuggest.as_view(),
                                               name="query-suggest"),
                                           url(r'^public/keywords/?$',
                                               views.Keywords.as_view(),
                                               name="keywords"),
                                           ))

    def get_urls(self):
        # Keep trailing slash value...
        trailing_slash = self.trailing_slash

        # Generate base URLs without format.
        base_urls = super(SubRouterWithFormat, self).get_urls()

        # Generate the same URLs, but forcing to omit the trailing_slash.
        self.trailing_slash = ''
        extra_urls = super(SubRouterWithFormat, self).get_urls()

        # Reset trailing slash and add format to our extra URLs.
        self.trailing_slash = trailing_slash
        extra_urls = format_suffix_patterns(extra_urls, suffix_required=True)

        # Return the addition of both lists of URLs.
        return base_urls + extra_urls

    def get_urls(self):
        """
        Return a list of URL regexs, this extends the default by adding a
        {prefix}-list route that accepts a lookup url kwarg.
        """
        urls = super(MultiLookupRouter, self).get_urls()

        extra_urls = []
        for prefix, viewset, basename in self.registry:
            lookup_fields = getattr(viewset, 'lookup_fields', None)
            if lookup_fields:
                route = routers.Route(
                    url=r'^{prefix}/{lookup}{trailing_slash}$',
                    mapping={
                        'delete': 'destroy',
                        'get': 'list',
                        'post': 'create',
                    },
                    name='{basename}-list',
                    detail=False,
                    initkwargs={'suffix': 'List'})
                self.multi = True
                lookup = self.get_lookup_regex(viewset)
                # reset
                self.multi = False
                regex = route.url.format(
                    prefix=prefix,
                    lookup=lookup,
                    trailing_slash=self.trailing_slash)

                mapping = self.get_method_map(viewset, route.mapping)
                if not mapping:
                    continue
                initkwargs = route.initkwargs.copy()
                initkwargs.update({
                    'basename': basename,
                    'detail': route.detail,
                })
                view = viewset.as_view(mapping, **initkwargs)
                name = route.name.format(basename=basename)
                extra_urls.append(url(regex, view, name=name))

        if self.include_format_suffixes:
            extra_urls = format_suffix_patterns(extra_urls)
        urls.extend(extra_urls)
        return urls

    def get_urls(self):
        """
        Generate the list of URL patterns, including a default root view
        for the API, and appending `.json` style format suffixes.
        """
        urls = []

        if self.include_root_view:
            root_url = url(r'^$', self.get_api_root_view(), name='api-root')
            urls.append(root_url)

        default_urls = super(DefaultRouter, self).get_urls()
        urls.extend(default_urls)

        if self.include_format_suffixes:
            urls = format_suffix_patterns(urls)

        return urls

    def get_urls(self):
        """
        Return the URL patterns handled by this router.

        Include a default root view for the API, and appending `.json` style
        format suffixes.
        """
        urls = []
        assert self.include_root_view
        assert self.include_format_suffixes
        root_url = url(
            r'^$', self.get_api_root_view(), name=self.root_view_name)
        urls.append(root_url)

        default_urls = super(DefaultRouter, self).get_urls()
        urls.extend(default_urls)

        # Add format suffix versions
        # Include special-case of view_features allowing .html as well
        furls = format_suffix_patterns(urls, allowed=self.allowed_ext)
        urls = []
        for u in furls:
            assert not isinstance(u, RegexURLResolver)
            match = (
                u.name == 'viewfeatures-detail' and
                'api|json' in u.regex.pattern)
            if match:
                pattern = u.regex.pattern.replace('api|json', 'api|json|html')
                view = u._callback or u._callback_str
                u = url(pattern, view, u.default_args, u.name)
            urls.append(u)

        # Add redirects for list views
        assert not self.trailing_slash
        redirect_urls = []
        for u in default_urls:
            if u.name.endswith('-list'):
                pattern = u.regex.pattern.replace('$', '/$')
                view = RedirectView.as_view(
                    pattern_name=u.name, permanent=False, query_string=True)
                redirect_urls.append(url(pattern, view))
        return urls + redirect_urls

def format_patterns(urlpatterns):
    "If a URL pattern ends in a slash, it should be able to be rendered as different types"
    suffixes = ['json', 'jsonld', 'jsonld-browse', 'ttl', 'ttl-browse']
    ret = []
    for urlpattern in urlpatterns:
        if isinstance(urlpattern, RegexURLPattern):
            pattern = urlpattern.regex.pattern
            is_empty = pattern == '^$'

            if is_empty or pattern.endswith('/$'):
                regex = '^' if is_empty else urlpattern.regex.pattern[:-2]
                view = urlpattern._callback or urlpattern._callback_str
                kwargs = urlpattern.default_args
                name = urlpattern.name

                stripped_url = url(regex, view, kwargs, name)

                ret.append(format_suffix_patterns([stripped_url], True, suffixes)[0])
        ret.append(urlpattern)
    return ret

 def get_urls(self):
     result = []
     
     for prefix, viewset, basename in self.registry:
         model = shortcuts.get_model(viewset)
         lookup = shortcuts.get_lookup_url_regex(shortcuts.get_lookup_field(viewset))
         routes = self.get_routes(viewset)
         for route in routes:
             mapping = self.get_method_map(viewset, route.mapping)
             
             if not mapping: continue
             
             kwargs = self.get_format_dict(model, None, prefix=prefix, lookup=lookup)
             regex = self.get_regex(shortcuts.url_format(route.url, **kwargs))
             view = viewset.as_view(mapping, **route.initkwargs)
             name = shortcuts.name_format(route.name, **kwargs)
             result.append(url(regex, view, name=name))
             
     result = format_suffix_patterns(result, allowed=self.format_suffixes)
     
     return result

    def get_root_urls(self, viewset, name):
        lookup = self.get_lookup_regex(viewset)
        routes = self.get_routes(viewset)
        urls = []
        for route in routes:
            pattern = route.url.format(
                prefix='',
                lookup=lookup,
                trailing_slash=self.trailing_slash,
            )

            # Remove leading slash from detail view URLs
            pattern = pattern.replace('/', '', 1)

            mapping = self.get_method_map(viewset, route.mapping)
            if not mapping:
                continue
            view = viewset.as_view(mapping, **route.initkwargs)
            urls.append(url(pattern, view, name=name))

        return format_suffix_patterns(urls)