def recurse_patterns(path, pattern_list, page_id, default_args=None, nested=False): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = pattern.regex.pattern # make sure we don't get patterns that start with more than one '^'! app_pat = app_pat.lstrip('^') path = path.lstrip('^') regex = r'^%s%s' % (path, app_pat) if not nested else r'^%s' % (app_pat) if isinstance(pattern, RegexURLResolver): # include default_args args = pattern.default_kwargs if default_args: args.update(default_args) if DJANGO_1_8: # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) # see lines 243 and 236 of urlresolvers.py to understand the next line resolver._urlconf_module = recurse_patterns( regex, pattern.url_patterns, page_id, args, nested=True) else: # see lines 243 and 236 of urlresolvers.py to understand the next line urlconf_module = recurse_patterns(regex, pattern.url_patterns, page_id, args, nested=True) # this is an 'include', recurse! resolver = RegexURLResolver(regex, urlconf_module, pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id else: # Re-do the RegexURLPattern with the new regular expression args = pattern.default_args if default_args: args.update(default_args) resolver = RegexURLPattern(regex, pattern.callback, args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
def test_response_messages(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ --- responseMessages: - code: 403 message: Not authorized. - code: 404 message: Not found. """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() messages = parser.get_response_messages() self.assertEqual(2, len(messages)) self.assertEqual(messages[0]['message'], 'Not authorized.') self.assertEqual(messages[1]['message'], 'Not found.')
def get_resolver(cls): if cls._resolver: return cls._resolver pats = [] for rule in Rule.on_site.all(): view = redirect_to params = {} if rule.target_view: view = rule.target_view if rule.target_params: params = dict( QueryDict(rule.target_params, mutable=True).items()) if rule.target_url_name: params = {'url': reverse(rule.target_url_name, kwargs=params)} if rule.target_url: params = {'url': rule.target_url} if rule.redirection_type: params['status_code'] = rule.redirection_type pats.append((r'^%s$' % rule.pattern, view, params)) urlpatterns = patterns('', *pats) resolver = RegexURLResolver(r'^/', urlpatterns) resolver.app_name = 'redirector' cls._resolver = resolver return resolver
def test_custom_response_class(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ --- type: name: required: true type: string url: required: false type: url """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() generator = DocumentationGenerator() serializer = generator._get_method_serializer(introspector) response_class = generator._get_method_response_type( parser, serializer, class_introspector, introspector) self.assertEqual(response_class, 'SerializedAPIPostResponse') self.assertEqual(serializer, None) self.assertIn('SerializedAPIPostResponse', generator.explicit_response_types)
def load_app(app, root_module=None): module = None try: module = loadModule(app + '.rpc') except ImportError as err: print "**** failed to load {0}.rpc! ****".format(app) print "**** missing dependencies ****" print "**** {0} ****".format(err) except SyntaxError as serr: print "\t{0}: ".format(app), print "fail" print "Exception in user code:" print '-' * 60 traceback.print_exc(file=sys.stdout) print '-' * 60 except Exception as err: print "\t{0}: ".format(app), print "fail" print "Exception in user code:" print '-' * 60 traceback.print_exc(file=sys.stdout) print '-' * 60 if module: if not root_module: root_module = module urls = RegexURLResolver( '^' + getattr(module, 'URL_PREFIX', app.split('.')[-1]) + "/", root_module) # print urls.url_patterns # print "" urlpatterns.append(urls) return module
def _get_plugin_patterns(self): log.debug("PluginURLPattern._get_plugin_patterns") from pylucid_project.apps.pylucid.models.pluginpage import PluginPage from pylucid_project.apps.pylucid.models.pagemeta import PageMeta from pylucid_project.apps.pylucid.models.pagetree import PageTree plugin_pages = PluginPage.objects.all() all_page_metas = PageMeta.objects.filter( pagetree__page_type=PageTree.PLUGIN_TYPE) pattern_list = [] for plugin_page in plugin_pages: plugin_instance = plugin_page.get_plugin() page_metas = all_page_metas.filter(pagetree=plugin_page.pagetree) for page_meta in page_metas: url_prefix = page_meta.get_absolute_url() log.debug("add patterns for url prefix: %r" % url_prefix) prefixed_urlpatterns = plugin_instance.get_prefix_urlpatterns( url_prefix, plugin_page.urls_filename) log_urls(urlpatterns=prefixed_urlpatterns) pattern_list += prefixed_urlpatterns debug_log_urls(pattern_list) log_urls(urlpatterns=pattern_list) plugin_patterns = RegexURLResolver(r'', pattern_list) return plugin_patterns
def get_resolver(cls): if '_routablepage_urlresolver' not in cls.__dict__: subpage_urls = cls.get_subpage_urls() cls._routablepage_urlresolver = RegexURLResolver( r'^/', subpage_urls) return cls._routablepage_urlresolver
def test_omit_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ My post view with custom post parameters --- omit_parameters: - form parameters: - name: name type: string required: true """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() params = parser.discover_parameters(introspector) self.assertEqual(0, len(params))
def url(regex, view, kwargs=None, name=None, prefix=''): if isinstance(view, (list,tuple)): 如果是 list 或者 tuple # For include(...) processing. 处理包含 include(...) urlconf_module, app_name, namespace = view # 此处返回 RegexURLResolver, 区分下面返回 RegexURLPattern return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace)
def subclass_view(self, request, path): """ Forward any request to a custom view of the real admin. """ ct_id = int(request.GET.get('ct_id', 0)) if not ct_id: # See if the path started with an ID. try: pos = path.find('/') if pos == -1: object_id = long(path) else: object_id = long(path[0:pos]) except ValueError: raise Http404("No ct_id parameter, unable to find admin subclass for path '{0}'.".format(path)) ct_id = self.model.objects.values_list('polymorphic_ctype_id', flat=True).get(pk=object_id) real_admin = self._get_real_admin_by_ct(ct_id) resolver = RegexURLResolver('^', real_admin.urls) resolvermatch = resolver.resolve(path) # May raise Resolver404 if not resolvermatch: raise Http404("No match for path '{0}' in admin subclass.".format(path)) return resolvermatch.func(request, *resolvermatch.args, **resolvermatch.kwargs)
def recurse_patterns(path, pattern_list, page_id): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = pattern.regex.pattern # make sure we don't get patterns that start with more than one '^'! if not app_pat.endswith('$'): return newpatterns app_pat = app_pat.lstrip('^') path = path.lstrip('^') regex = r'^%s%s' % (path, app_pat) if isinstance(pattern, RegexURLResolver): # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'poser_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id # see lines 243 and 236 of urlresolvers.py to understand the next line resolver._urlconf_module = recurse_patterns( regex, pattern.url_patterns, page_id) else: # Re-do the RegexURLPattern with the new regular expression resolver = RegexURLPattern(regex, pattern.callback, pattern.default_args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
def recurse_patterns(path, pattern_list, page_id): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = pattern.regex.pattern if app_pat.startswith('^'): app_pat = app_pat[1:] regex = r'^%s%s' % (path, app_pat) if isinstance(pattern, RegexURLResolver): # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id # see lines 243 and 236 of urlresolvers.py to understand the next line resolver._urlconf_module = recurse_patterns( regex, pattern.url_patterns, page_id) else: # Re-do the RegexURLPattern with the new regular expression resolver = RegexURLPattern(regex, pattern.callback, pattern.default_args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
def setUp(self): # Patterns with a "catch all" view (thing) at the end. self.patterns_catchall = RegexURLResolver('^/', patterns('', multiurl( url(r'^(\w+)/$', person, name='person'), url(r'^(\w+)/$', place, name='place'), url(r'^(\w+)/$', thing, name='thing'), ) )) # Patterns with no "catch all" - last view could still raise ContinueResolving. self.patterns_no_fallthrough = RegexURLResolver('^/', patterns('', multiurl( url(r'^(\w+)/$', person, name='person'), url(r'^(\w+)/$', place, name='place'), ) ))
def include_urlpatterns(regex, module): """ Usage: # in top-level module code: urlpatterns = include_urlpatterns(r'^profile/', 'apps.myapp.views.profile') """ return [RegexURLResolver(regex, module)]
def test_build_body_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') params = introspector.build_body_parameters() self.assertEqual('CommentSerializer', params['name'])
def test_no_urls_exception(self): """ RegexURLResolver should raise an exception when no urlpatterns exist. """ resolver = RegexURLResolver(r'^$', self.urls) self.assertRaisesMessage(ImproperlyConfigured, "The included urlconf regressiontests.urlpatterns_reverse.no_urls "\ "doesn't have any patterns in it", getattr, resolver, 'url_patterns')
def resolver(self, request): """ Returns a RegexURLResolver for the request's urlconf. If the request does not have a urlconf object, then the default of settings.ROOT_URLCONF is used. """ urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) return RegexURLResolver(r'^/', urlconf)
def register_url_resolver(self, app): # Install module URL resolver # @todo: Legacy django part? try: mr = self.urlresolvers[app.module, None] except KeyError: mr = patterns("") self.urlpatterns += [RegexURLResolver("^%s/" % app.module, mr, namespace=app.module)] self.urlresolvers[app.module, None] = mr # Install application URL resolver try: ar = self.urlresolvers[app.module, app.app] except KeyError: ar = patterns("") mr += [RegexURLResolver("^%s/" % app.app, ar, namespace=app.app)] self.urlresolvers[app.module, app.app] = ar return ar
def test_build_form_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') params = introspector.build_form_parameters() self.assertEqual(len(CommentSerializer().get_fields()), len(params))
def route(self, request, path_components): if not self.live: raise Http404 resolver = RegexURLResolver(r"^", self.app) path = request.path[len(self.url):] view, args, kwargs = resolver.resolve(path) self._view = view return (self, args, kwargs)
def get_subresolver(view_class, path=None): """ Create a subresolver for an ApplicationView Resolver will have path as base path/regex. """ path = r'' if path is None else r'^{}/'.format(path) return RegexURLResolver(path, urlconf_name=view_class.urlconf_name, namespace=view_class.namespace, app_name=view_class.app_name)
def resolver(request): """ Returns a RegexURLResolver for the request's urlconf. If the request does not have a urlconf object, then the default of settings.ROOT_URLCONF is used. """ from django.conf import settings urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) return RegexURLResolver(r"^/", urlconf)
def _get_view_and_args(path, request): """ Return the view at ``path`` and its named and positional arguments. Django will raise a Resolver404 exception if ``path`` doesn't exist. """ # Let's use urlconf from request object, if available: urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) resolver = RegexURLResolver(r"^/", urlconf) return resolver.resolve(path)
def test_no_urls_exception(self): """ RegexURLResolver should raise an exception when no urlpatterns exist. """ resolver = RegexURLResolver(r'^$', settings.ROOT_URLCONF) self.assertRaisesMessage(ImproperlyConfigured, "The included urlconf 'urlpatterns_reverse.no_urls' does not " "appear to have any patterns in it. If you see valid patterns in " "the file then the issue is probably caused by a circular import.", getattr, resolver, 'url_patterns')
def ajax_url(regex, view, ajax_name, default=None, group=None, kwargs=None): if isinstance(view, (list, tuple)): urlconf_module, app_name, namespace = view AjaxTracker.Instance().add_ajax_url(regex, ajax_name, default, group) return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace) if isinstance(view, six.string_types): raise ImproperlyConfigured('Invalid view specified (%s). Are you passing the callable?' % view) AjaxTracker.Instance().add_ajax_url(regex, ajax_name, default, group) return RegexURLPattern(regex, view, kwargs, ajax_name)
def handle(self, *args, **options): if len(args) != 0: raise CommandError("Command doesn't accept any arguments") self.excluded_paths = options.get('excluded_paths') if not self.excluded_paths: self.excluded_paths = [] # Walking through all urls, starting from the root UrlConf urlconf = settings.ROOT_URLCONF rootresolver = RegexURLResolver(r'^/', urlconf) self._walk_urlresolver("/", rootresolver)
def url(regex, view, kwargs=None, name=None, prefix=''): if isinstance(view, (list, tuple)): # For include(...) processing. urlconf_module, app_name, namespace = view return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace) else: if isinstance(view, six.string_types): if not view: raise ImproperlyConfigured('Empty URL pattern view name not permitted (for pattern %r)' % regex) if prefix: view = prefix + '.' + view return RegexURLPattern(regex, view, kwargs, name)
def handle(self, *args, **options): if len(args) != 0: raise CommandError("Command doesn't accept any arguments") self.excluded_paths = options.get('excluded_paths') if not self.excluded_paths: self.excluded_paths = [] self.verbosity = int(options.get('verbosity')) # Parcours des urls depuis la racine urlconf = settings.ROOT_URLCONF rootresolver = RegexURLResolver(r'^/', urlconf) self._walk_urlresolver("/", rootresolver)
def url(regex, view, kwargs=None, name=None, prefix=''): if type(view) == list: # For include(...) processing. return RegexURLResolver(regex, view[0], kwargs) else: if isinstance(view, str): if not view: raise ImproperlyConfigured( 'Empty URL pattern view name not permitted (for pattern %r)' % regex) if prefix: view = prefix + '.' + view return RegexURLPattern(regex, view, kwargs, name)
def test_get_method_summary_without_docstring(self): class MyListView(ListCreateAPIView): """ My comment """ pass class_introspector = ViewSetIntrospector( MyListView, '/{pk}', RegexURLResolver(r'^/(?P<{pk}>[^/]+)$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') method_docs = introspector.get_summary() self.assertEqual("My comment", method_docs)