def setUp(self):
from django.core.urlresolvers import RegexURLResolver
urlconf = "regressiontests.urlpatterns_reverse.urls_error_handlers"
urlconf_callables = "regressiontests.urlpatterns_reverse.urls_error_handlers_callables"
self.resolver = RegexURLResolver(r"^$", urlconf)
self.callable_resolver = RegexURLResolver(r"^$", urlconf_callables)
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 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, default_args=None):
"""
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 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
# include default_args
args = pattern.default_kwargs
if default_args:
args.update(default_args)
# 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)
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 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
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)
# This is a bit hacky, usually a RegexURLResolver uses the urlconf_name
# to resolve URLs, but we just override the url_patterns...
resolver.page_id = page_id
resolver.url_patterns = 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 flatpage(request, url):
"""
Copy of a `flatpage` view from `django.contrib.flatpages`. Use our `FlatPage` model instead of django one.
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
try:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
except Http404:
# XXX: Temporary redirection of the old person URLs to the new URLs
resolver = RegexURLResolver(r'^/', HUMAN_PATTERNS)
match = resolver.resolve(url)
if Person.objects.filter(is_active=True, human__nickname=match.kwargs['slug']).exists():
return HttpResponsePermanentRedirect(urljoin('/people/person/', url[1:]))
raise
return render_flatpage(request, f)
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 _resolve(self, path):
urlconf = settings.ROOT_URLCONF
resolver=RegexURLResolver(r'^/', urlconf)
view_function, func_args, func_kwargs = resolver.resolve(path)
module_name = view_function.__module__
func_name = view_function.func_name
return module_name, func_name, func_args, func_kwargs
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 route(self, request, path_components):
if not self.live:
raise Http404
resolver = RegexURLResolver(r"^", self.APP_PREFIX + self.app)
path = request.path[len(self.url):]
view, args, kwargs = resolver.resolve(path)
self._view = view
return (self, args, kwargs)
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 _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 thing_app(request, space_id, thing_id):
space = get_object_or_404(Space, pk=space_id)
template_module_name = 'template_2' # TODO hard coded for the mo
module_name = '%s.%s.application' % (os.path.basename(settings.TEMPLATE_APPS_DIR), template_module_name)
exec 'import %s as app_module' % module_name
app = app_module.Application()
resolver = RegexURLResolver(r'^/', app.urlpatterns)
base_path = reverse('sim.views.thing_app', kwargs={ 'space_id':space_id, 'thing_id':thing_id })
local_path = request.path[len(base_path) - 1:]
view_function = resolver.resolve(local_path)
return view_function[0](request)
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:
raise Http404("No ct_id parameter, unable to find admin subclass for path '{0}'.".format(path))
real_admin = self._get_real_admin_by_ct(ct_id)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404("No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args, **resolvermatch.kwargs)
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 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 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 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 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 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_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 handle_message(self, message, bot_service):
"""
Process incoming message generating a response to the sender.
:param message: Generic message received from provider
:param bot_service: Service Integration
:type bot_service: IntegrationBot :class:`IntegrationBot <permabots.models.bot.IntegrationBot>`
.. note:: Message content will be extracted by IntegrationBot
"""
urlpatterns = []
state_context = {}
chat_state = bot_service.get_chat_state(message)
for handler in caching.get_or_set_related(self, 'handlers', 'response',
'request', 'target_state'):
if handler.enabled:
source_states = caching.get_or_set_related(
handler, 'source_states')
if chat_state:
state_context = chat_state.ctx
if not source_states or (chat_state and chat_state.state
in source_states):
urlpatterns.append(handler.urlpattern())
resolver = RegexURLResolver(r'^', urlpatterns)
try:
resolver_match = resolver.resolve(
bot_service.message_text(message))
except Resolver404:
logger.warning("Handler not found for %s" % message)
else:
callback, callback_args, callback_kwargs = resolver_match
logger.debug("Calling callback:%s for message %s with %s" %
(callback, message, callback_kwargs))
text, keyboard, target_state, context = callback(
self,
message=message,
service=bot_service.identity,
state_context=state_context,
**callback_kwargs)
if target_state:
self.update_chat_state(bot_service, message, chat_state,
target_state, context)
keyboard = bot_service.build_keyboard(keyboard)
bot_service.send_message(bot_service.get_chat_id(message), text,
keyboard, message)
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 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 url(self, value):
"""
Return valid url or empty string.
"""
resolver = RegexURLResolver(r'^/', settings.ROOT_URLCONF)
checked = []
try:
while value not in checked:
checked.append(value)
if MACRO_RE.match(value):
if MACRO_RE.sub(MACRO_REPL, value):
raise ReplaceDone
else:
raise ReplaceFailed
scheme, authority, path, query, fragment = urlsplit(value)
if not scheme and not authority and not path:
raise ReplaceDone
if (scheme and scheme.lower() not in self.check_schemes) or\
(authority and authority.lower() not in self.check_sites):
raise ReplaceDone
try:
callback, callback_args, callback_kwargs = resolver.resolve(path)
except Exception:
raise ReplaceFailed
try:
try:
setting = self.views[callback]
except KeyError:
if self.check_unregistered:
data_from_view(path, query)
raise ReplaceDone
if setting.get('disable', False):
raise ReplaceFailed
obj = object_from_view(path, query, setting['context'])
path = macro(obj)
if setting.get('remove_query', False):
query = None
value = urljoin(None, None, path, query, fragment)
raise ReplaceDone
except ReplaceRedirect, redirect:
value = redirect.target
scheme, authority, path, query, fragment = urlsplit(value)
if scheme == 'http' and authority == 'testserver':
value = urljoin(None, None, path, query, fragment)
else:
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 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 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 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 widget_view(self, request, app_label, widget_name, path):
name = '%s.%s' % (app_label, widget_name)
if name not in self._registry:
raise Http404
state = DashboardState.objects.get_for_user(request.user)
data = json.loads(state.data)
names = []
for column in data['columns']:
for row in column:
names.append(row['name'])
if name not in names:
raise Http404
widget = self._registry[name]
urls = widget.urls
if urls is None:
raise Http404
resolver = RegexURLResolver(r'^', _URLConfModule(urls))
callback, args, kwargs = resolver.resolve(path)
return callback(request, *args, **kwargs)
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:
raise Http404(
"No ct_id parameter, unable to find admin subclass for path '{0}'."
.format(path))
real_admin = self._get_real_admin_by_ct(ct_id)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404(
"No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args,
**resolvermatch.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 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
class ErrorHandlerResolutionTests(TestCase):
"""Tests for handler400, handler404 and handler500"""
def setUp(self):
urlconf = 'urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def test_named_handlers(self):
handler = (empty_view, {})
self.assertEqual(self.resolver.resolve_error_handler(400), handler)
self.assertEqual(self.resolver.resolve_error_handler(404), handler)
self.assertEqual(self.resolver.resolve_error_handler(500), handler)
def test_callable_handers(self):
handler = (empty_view, {})
self.assertEqual(self.callable_resolver.resolve_error_handler(400), handler)
self.assertEqual(self.callable_resolver.resolve_error_handler(404), handler)
self.assertEqual(self.callable_resolver.resolve_error_handler(500), handler)
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 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 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)
class HandlerResolver(object):
def __init__(self, conf):
self.resolver = RegexURLResolver(r'^', conf)
def resolve(self, update):
try:
resolver_match = self.resolver.resolve(update.message.text)
return resolver_match
except Resolver404:
raise HandlerNotFound("No handler configured for %s" % update.message.text)
class ErrorHandlerResolutionTests(SimpleTestCase):
"""Tests for handler400, handler404 and handler500"""
def setUp(self):
urlconf = 'urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def test_named_handlers(self):
handler = (empty_view, {})
self.assertEqual(self.resolver.resolve_error_handler(400), handler)
self.assertEqual(self.resolver.resolve_error_handler(404), handler)
self.assertEqual(self.resolver.resolve_error_handler(500), handler)
def test_callable_handers(self):
handler = (empty_view, {})
self.assertEqual(self.callable_resolver.resolve_error_handler(400), handler)
self.assertEqual(self.callable_resolver.resolve_error_handler(404), handler)
self.assertEqual(self.callable_resolver.resolve_error_handler(500), handler)
class ErrorHandlerResolutionTests(TestCase):
"""Tests for handler404 and handler500"""
def setUp(self):
from django.core.urlresolvers import RegexURLResolver
urlconf = 'regressiontests.urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'regressiontests.urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def test_named_handlers(self):
from .views import empty_view
handler = (empty_view, {})
self.assertEqual(self.resolver.resolve404(), handler)
self.assertEqual(self.resolver.resolve500(), handler)
def test_callable_handers(self):
from .views import empty_view
handler = (empty_view, {})
self.assertEqual(self.callable_resolver.resolve404(), handler)
self.assertEqual(self.callable_resolver.resolve500(), handler)
def subclass_view(self, request, path):
type = int(request.GET.get('type', 0))
if not type:
try:
pos = path.find('/')
if pos == -1:
object_id = long(path)
else:
object_id = long(path[0:pos])
except ValueError:
raise Http404("No type parameter, unable to find admin subclass for path '{0}'.".format(path))
type = self._get_type_by_object_id(object_id)
real_admin = self._get_real_admin(type)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404("No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args, **resolvermatch.kwargs)
class ErrorHandlerResolutionTests(TestCase):
"""Tests for handler404 and handler500"""
def setUp(self):
from django.core.urlresolvers import RegexURLResolver
urlconf = 'regressiontests.urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'regressiontests.urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def test_named_handlers(self):
from views import empty_view
handler = (empty_view, {})
self.assertEqual(self.resolver.resolve404(), handler)
self.assertEqual(self.resolver.resolve500(), handler)
def test_callable_handers(self):
from views import empty_view
handler = (empty_view, {})
self.assertEqual(self.callable_resolver.resolve404(), handler)
self.assertEqual(self.callable_resolver.resolve500(), handler)
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 = []
# Walking through all urls, starting from the root UrlConf
urlconf = settings.ROOT_URLCONF
rootresolver = RegexURLResolver(r'^/', urlconf)
self._walk_urlresolver("/", rootresolver)
def handle_message(self, message, bot_service):
"""
Process incoming message generating a response to the sender.
:param message: Generic message received from provider
:param bot_service: Service Integration
:type bot_service: IntegrationBot :class:`IntegrationBot <permabots.models.bot.IntegrationBot>`
.. note:: Message content will be extracted by IntegrationBot
"""
urlpatterns = []
state_context = {}
chat_state = bot_service.get_chat_state(message)
for handler in caching.get_or_set_related(self, 'handlers', 'response', 'request', 'target_state'):
if handler.enabled:
source_states = caching.get_or_set_related(handler, 'source_states')
if chat_state:
state_context = chat_state.ctx
if not source_states or (chat_state and chat_state.state in source_states):
urlpatterns.append(handler.urlpattern())
resolver = RegexURLResolver(r'^', urlpatterns)
try:
resolver_match = resolver.resolve(bot_service.message_text(message))
except Resolver404:
logger.warning("Handler not found for %s" % message)
else:
callback, callback_args, callback_kwargs = resolver_match
logger.debug("Calling callback:%s for message %s with %s" %
(callback, message, callback_kwargs))
text, keyboard, target_state, context = callback(self, message=message, service=bot_service.identity,
state_context=state_context, **callback_kwargs)
if target_state:
self.update_chat_state(bot_service, message, chat_state, target_state, context)
keyboard = bot_service.build_keyboard(keyboard)
bot_service.send_message(bot_service.get_chat_id(message), text, keyboard, message)
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 resolve_subpage(self, path):
"""
This finds a view method/function from a URL path.
"""
resolver = RegexURLResolver(r'^', self.get_subpage_urls())
return resolver.resolve(path)
'''
def test_d(req):
return 'this is child url test page.'
child_urlpatterns = [
url(r'^d/$', test_d),
]
urlpatterns = [
url(r'^$', v_index), #url 创建RegexURLResolver对象
url(r'^blogs/$', v_blogs),
url(r'^news/$', v_news),
url(r'^test/', include(child_urlpatterns)),
]
resolvs = RegexURLResolver(r'^/', urlpatterns)
'''
# RegexURLResolver 的第二个参数同url的第二个参数 ，会根据类型进行不同处理,
# 当第二个参数类型是字符串时，会先进行导出之后,在提取urlpatterns属性
resolvs = RegexURLResolver(r'^/', 'app.root_url')
urls = ['/news/', '/blogs/', '/whoami/', '/', '/test/d/', 'a/b/c/d']
for url in urls:
try:
match = resolvs.resolve(url)
print('match {}'.format(url))
print(match.func(None))
except Exception as e:
print('not match {}'.format(url))
def resolve_view(self, request):
urls = self.function_or_urlconf
resolver = RegexURLResolver(r"^/", urls)
return resolver.resolve(request.path_info)
from django.contrib.sites.models import Site
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse, RegexURLResolver
from django.test import TestCase
import waiter
from waiter.apis.twitter import TwitterMenu
import mox
import urllib
import random
import oauth2
from django.utils import simplejson
test_class = TestCase
try:
resolver = RegexURLResolver(r'^/', settings.ROOT_URLCONF)
resolver.resolve404()
from django.template.loader import get_template
from django.template import TemplateDoesNotExist
try:
get_template('404.html')
except TemplateDoesNotExist:
test_class = object
print """
*** bluebird.tests.views.py ***
To run these tests you must define a 404.html in one of your template
directories.
""".strip()
print "*"*80
raw_input("Press enter to continue: ")
except AttributeError:
class MultiviewTests(unittest.TestCase):
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 test_resolve_match_first(self):
m = self.patterns_catchall.resolve('/jane/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Person: Jane Doe")
def test_resolve_match_middle(self):
m = self.patterns_catchall.resolve('/sf/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Place: San Francisco")
def test_resolve_match_last(self):
m = self.patterns_catchall.resolve('/bacon/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Thing: Bacon")
def test_resolve_match_faillthrough(self):
m = self.patterns_no_fallthrough.resolve('/bacon/')
with self.assertRaises(Resolver404):
m.func(request=None, *m.args, **m.kwargs)
def test_no_match(self):
with self.assertRaises(Resolver404):
self.patterns_catchall.resolve('/eggs/and/bacon/')
def test_reverse(self):
self.assertEqual('joe/', self.patterns_catchall.reverse('person', 'joe'))
self.assertEqual('joe/', self.patterns_catchall.reverse('place', 'joe'))
self.assertEqual('joe/', self.patterns_catchall.reverse('thing', 'joe'))
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('person')
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('argh', 'xyz')
def reverse_subpage(self, name, *args, **kwargs):
"""
This method does the same job as Djangos' built in "urlresolvers.reverse()" function for subpage urlconfs.
"""
resolver = RegexURLResolver(r'^', self.get_subpage_urls())
return self.url + resolver.reverse(name, *args, **kwargs)
def setUp(self):
urlconf = 'urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def __init__(self, conf):
self.resolver = RegexURLResolver(r'^', conf)
def setUp(self):
from django.core.urlresolvers import RegexURLResolver
urlconf = 'urlpatterns_reverse.urls_error_handlers'
urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables'
self.resolver = RegexURLResolver(r'^$', urlconf)
self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def process_rest_request(message, urls=settings.ROOT_URLCONF):
try:
data = json.loads(message.content['text'])
except:
logger.debug("Error parsing JSON")
return False
if 'datatype' not in data or data['datatype'] != 'request':
return False
for i in ['url', 'method']:
if i not in data:
return False
def return_403(reason='Access denied'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 403,
'reason': reason
})
})
return False
def return_404(reason='Not found'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 404,
'reason': reason
})
})
return False
def return_500(reason='Internal server error'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 500,
'reason': reason
})
})
return False
try:
resolver = RegexURLResolver(r'^/', urls)
except:
logger.exception("Something went wrong when constructing the urlresolver")
return return_500()
split_url = urlsplit(data['url'])
try:
callback, callback_args, callback_kwargs = resolver.resolve(split_url.path)
except:
logger.exception("No matches found for url %s", data['url'])
return return_404()
request = ChannelRestRequest(message, method=data['method'].upper())
request.path = split_url.path
if 'meta' in data:
request.META = data['meta']
if 'body' in data:
body_data = data['body'].encode('utf-8')
request._stream = six.BytesIO(body_data)
request.META['CONTENT_LENGTH'] = len(body_data)
request.META['QUERY_PARAMS'] = split_url.query
request.fix_meta()
if split_url.query:
request.GET.update(dict(parse_qsl(split_url.query)))
response = None
request_middleware = []
for middleware_path in settings.MIDDLEWARE_CLASSES:
if not middleware_path.startswith('django'):
mw_class = import_string(middleware_path)
try:
mw_instance = mw_class()
if hasattr(mw_instance, 'process_request'):
request_middleware.append(mw_instance.process_request)
except MiddlewareNotUsed as exc:
if settings.DEBUG:
if six.text_type(exc):
logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
else:
logger.debug('MiddlewareNotUsed: %r', middleware_path)
continue
try:
for middleware_method in request_middleware:
response = middleware_method(request)
if response:
break
response = callback(request, *callback_args, **callback_kwargs)
except:
logger.exception("Something went wrong procesing the view.")
return return_500()
response.render()
response_packet = {
'datatype': data['datatype'],
'meta': dict(response.items()),
'status_code': response.status_code,
}
if response.content:
response_packet['body'] = response.content.decode('utf-8')
if hasattr(response, 'status_text'):
response_packet['reason'] = response.status_text
if 'message_id' in data:
response_packet['message_id'] = data['message_id']
message.reply_channel.send({"text": json.dumps(response_packet)})
return True