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)
