Python compat.url函数代码示例

def apply_suffix_patterns(urlpatterns, suffix_pattern, suffix_required):
    ret = []
    for urlpattern in urlpatterns:
        if isinstance(urlpattern, RegexURLResolver):
            # Set of included URL patterns
            regex = urlpattern.regex.pattern
            namespace = urlpattern.namespace
            app_name = urlpattern.app_name
            kwargs = urlpattern.default_kwargs
            # Add in the included patterns, after applying the suffixes
            patterns = apply_suffix_patterns(urlpattern.url_patterns,
                                             suffix_pattern,
                                             suffix_required)
            ret.append(url(regex, include(patterns, namespace, app_name), kwargs))

        else:
            # Regular URL pattern
            regex = urlpattern.regex.pattern.rstrip('$') + suffix_pattern
            view = urlpattern._callback or urlpattern._callback_str
            kwargs = urlpattern.default_args
            name = urlpattern.name
            # Add in both the existing and the new urlpattern
            if not suffix_required:
                ret.append(urlpattern)
            ret.append(url(regex, view, kwargs, name))

    return ret

 def test_included_urls(self):
     nested_patterns = patterns("", url(r"^path$", dummy_view))
     urlpatterns = patterns("", url(r"^test/", include(nested_patterns), {"foo": "bar"}))
     test_paths = [
         URLTestPath("/test/path", (), {"foo": "bar"}),
         URLTestPath("/test/path.api", (), {"foo": "bar", "format": "api"}),
         URLTestPath("/test/path.asdf", (), {"foo": "bar", "format": "asdf"}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

 def test_included_urls(self):
     nested_patterns = patterns(
         '',
         url(r'^path$', dummy_view)
     )
     urlpatterns = patterns(
         '',
         url(r'^test/', include(nested_patterns), {'foo': 'bar'}),
     )
     test_paths = [
         URLTestPath('/test/path', (), {'foo': 'bar', }),
         URLTestPath('/test/path.api', (), {'foo': 'bar', 'format': 'api'}),
         URLTestPath('/test/path.asdf', (), {'foo': 'bar', 'format': 'asdf'}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

    def get_urls(self):
        """
        Use the registered viewsets to generate a list of URL patterns.
        """
        ret = []

        for prefix, viewset, basename in self.registry:
            lookup = self.get_lookup_regex(viewset)
            routes = self.get_routes(viewset)

            for route in routes:

                # Only actions which actually exist on the viewset will be bound
                mapping = self.get_method_map(viewset, route.mapping)
                if not mapping:
                    continue

                # Build the url pattern
                regex = route.url.format(
                    prefix=prefix,
                    lookup=lookup,
                    trailing_slash=self.trailing_slash
                )
                view = viewset.as_view(mapping, **route.initkwargs)
                name = route.name.format(basename=basename)
                ret.append(url(regex, view, name=name))

        return ret

    def get_urls(self):
        """Return a list of URL patterns, including a default root view
        for the API, and appending format suffixes.

        Unlike the superclass method, ensure that format suffixes also
        strip trailing slashes.
        """
        answer = []

        # Add all urlpatterns from the superclass method to the answer,
        # but modify the .format URL to expunge the trailing slash.
        for urlpattern in super(Router, self).get_urls():
            if '/\\.(?P<format>' in urlpattern.regex.pattern:
                answer.append(url(
                    urlpattern.regex.pattern.replace('/\\.(?P<format>',
                                                     '\\.(?P<format>'),
                    urlpattern._callback or urlpattern._callback_str,
                    urlpattern.default_args,
                    urlpattern.name,
                ))
            else:
                answer.append(urlpattern)

        # Any urlpatterns defined by child routers should also
        # be included here.
        for prefix, child in self.children.items():
            for urlpattern in child.get_urls():
                answer.append(urlpattern)

        # Done; return the final answer.
        return answer

 def test_default_args(self):
     urlpatterns = patterns("", url(r"^test$", dummy_view, {"foo": "bar"}))
     test_paths = [
         URLTestPath("/test", (), {"foo": "bar"}),
         URLTestPath("/test.api", (), {"foo": "bar", "format": "api"}),
         URLTestPath("/test.asdf", (), {"foo": "bar", "format": "asdf"}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

 def test_format_suffix(self):
     urlpatterns = patterns("", url(r"^test$", dummy_view))
     test_paths = [
         URLTestPath("/test", (), {}),
         URLTestPath("/test.api", (), {"format": "api"}),
         URLTestPath("/test.asdf", (), {"format": "asdf"}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

 def test_default_args(self):
     urlpatterns = patterns(
         '',
         url(r'^test$', dummy_view, {'foo': 'bar'}),
     )
     test_paths = [
         URLTestPath('/test', (), {'foo': 'bar', }),
         URLTestPath('/test.api', (), {'foo': 'bar', 'format': 'api'}),
         URLTestPath('/test.asdf', (), {'foo': 'bar', 'format': 'asdf'}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

 def test_format_suffix(self):
     urlpatterns = patterns(
         '',
         url(r'^test$', dummy_view),
     )
     test_paths = [
         URLTestPath('/test', (), {}),
         URLTestPath('/test.api', (), {'format': 'api'}),
         URLTestPath('/test.asdf', (), {'format': 'asdf'}),
     ]
     self._resolve_urlpatterns(urlpatterns, test_paths)

    def setUp(self):
        class NoteSerializer(serializers.HyperlinkedModelSerializer):
            class Meta:
                model = RouterTestModel
                lookup_field = "uuid"
                fields = ("url", "uuid", "text")

        class NoteViewSet(viewsets.ModelViewSet):
            queryset = RouterTestModel.objects.all()
            serializer_class = NoteSerializer
            lookup_field = "uuid"

        RouterTestModel.objects.create(uuid="123", text="foo bar")

        self.router = SimpleRouter()
        self.router.register(r"notes", NoteViewSet)

        from rest_framework.tests import test_routers

        urls = getattr(test_routers, "urlpatterns")
        urls += patterns("", url(r"^", include(self.router.urls)))

    def setUp(self):
        class NoteSerializer(serializers.HyperlinkedModelSerializer):
            class Meta:
                model = RouterTestModel
                lookup_field = 'uuid'
                fields = ('url', 'uuid', 'text')

        class NoteViewSet(viewsets.ModelViewSet):
            queryset = RouterTestModel.objects.all()
            serializer_class = NoteSerializer
            lookup_field = 'uuid'

        RouterTestModel.objects.create(uuid='123', text='foo bar')

        self.router = SimpleRouter()
        self.router.register(r'notes', NoteViewSet)

        from rest_framework.tests import test_routers
        urls = getattr(test_routers, 'urlpatterns')
        urls += patterns('',
            url(r'^', include(self.router.urls)),
        )

def format_suffix_patterns(urlpatterns, suffix_required=False, allowed=None):
    """
    Supplement existing urlpatterns with corresponding patterns that also
    include a '.format' suffix.  Retains urlpattern ordering.

    urlpatterns:
        A list of URL patterns.

    suffix_required:
        If `True`, only suffixed URLs will be generated, and non-suffixed
        URLs will not be used.  Defaults to `False`.

    allowed:
        An optional tuple/list of allowed suffixes.  eg ['json', 'api']
        Defaults to `None`, which allows any suffix.
    """
    suffix_kwarg = api_settings.FORMAT_SUFFIX_KWARG
    if allowed:
        if len(allowed) == 1:
            allowed_pattern = allowed[0]
        else:
            allowed_pattern = '(%s)' % '|'.join(allowed)
        suffix_pattern = r'\.(?P<%s>%s)$' % (suffix_kwarg, allowed_pattern)
    else:
        suffix_pattern = r'\.(?P<%s>[a-z]+)$' % suffix_kwarg

    ret = []
    for urlpattern in urlpatterns:
        # Form our complementing '.format' urlpattern
        regex = urlpattern.regex.pattern.rstrip('$') + suffix_pattern
        view = urlpattern._callback or urlpattern._callback_str
        kwargs = urlpattern.default_args
        name = urlpattern.name
        # Add in both the existing and the new urlpattern
        if not suffix_required:
            ret.append(urlpattern)
        ret.append(url(regex, view, kwargs, name))
    return ret

    class FilterFieldsQuerysetView(generics.ListCreateAPIView):
        queryset = FilterableItem.objects.all()
        serializer_class = FilterableItemSerializer
        filter_fields = ['decimal', 'date']
        filter_backends = (filters.DjangoFilterBackend,)

    class GetQuerysetView(generics.ListCreateAPIView):
        serializer_class = FilterableItemSerializer
        filter_class = SeveralFieldsFilter
        filter_backends = (filters.DjangoFilterBackend,)

        def get_queryset(self):
            return FilterableItem.objects.all()

    urlpatterns = patterns('',
        url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
        url(r'^$', FilterClassRootView.as_view(), name='root-view'),
        url(r'^get-queryset/$', GetQuerysetView.as_view(),
            name='get-queryset-view'),
    )


class CommonFilteringTestCase(TestCase):
    def _serialize_object(self, obj):
        return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}

    def setUp(self):
        """
        Create 10 FilterableItem instances.
        """
        base_data = ('a', Decimal('0.25'), datetime.date(2012, 10, 8))

        queryset = FilterableItem.objects.all()
        serializer_class = FilterableItemSerializer
        filter_fields = ["decimal", "date"]
        filter_backends = (filters.DjangoFilterBackend,)

    class GetQuerysetView(generics.ListCreateAPIView):
        serializer_class = FilterableItemSerializer
        filter_class = SeveralFieldsFilter
        filter_backends = (filters.DjangoFilterBackend,)

        def get_queryset(self):
            return FilterableItem.objects.all()

    urlpatterns = patterns(
        "",
        url(r"^(?P<pk>\d+)/$", FilterClassDetailView.as_view(), name="detail-view"),
        url(r"^$", FilterClassRootView.as_view(), name="root-view"),
        url(r"^get-queryset/$", GetQuerysetView.as_view(), name="get-queryset-view"),
    )


class CommonFilteringTestCase(TestCase):
    def _serialize_object(self, obj):
        return {"id": obj.id, "text": obj.text, "decimal": obj.decimal, "date": obj.date}

    def setUp(self):
        """
        Create 10 FilterableItem instances.
        """
        base_data = ("a", Decimal("0.25"), datetime.date(2012, 10, 8))
        for i in range(10):

from django.db import models
from django.test import TestCase
from rest_framework import serializers
from rest_framework.compat import patterns, url


def dummy_view(request, pk):
    pass

urlpatterns = patterns('',
    url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'),
    url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'),
    url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'),
    url(r'^foreignkeytarget/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'),
    url(r'^nullableforeignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'),
)


# ManyToMany

class ManyToManyTarget(models.Model):
    name = models.CharField(max_length=100)


class ManyToManySource(models.Model):
    name = models.CharField(max_length=100)
    targets = models.ManyToManyField(ManyToManyTarget, related_name='sources')


class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer):
    sources = serializers.ManyHyperlinkedRelatedField(view_name='manytomanysource-detail')