def setUp(self):
# Patterns with a "catch all" view (thing) at the end.
self.patterns_catchall = urlresolvers.URLResolver(RegexPattern(r'^/'), [
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
url(r'^(\w+)/$', thing, name='thing'),
)
])
self.patterns_pathall = urlresolvers.URLResolver(RegexPattern(r'^/'), i18n_patterns(
multiurl(
path('<str:name>/', brand, name='brand'),
path('<str:name>/', model, name='model'),
),
))
# Patterns with no "catch all" - last view could still raise ContinueResolving.
self.patterns_no_fallthrough = urlresolvers.URLResolver(RegexPattern(r'^/'), [
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
)
])
def create_django_route(dispatcher: Dispatcher) -> List[URLPattern]:
view_variants = []
viewset_variants = []
for view_variant in dispatcher.view_variants:
if isinstance(view_variant.handler, DRFViewMixinWrapper):
vv = viewset_variants
else:
vv = view_variants
vv.append(view_variant)
rv = []
# Prepare URLPatterns similar to http://www.django-rest-framework.org/api-guide/routers/#usage
if view_variants:
django_route_name = f'{dispatcher.route_namespace}.{dispatcher.route_name}'
pattern = dispatcher.route_pattern.lstrip('/') # removes django warnings
pattern = complete_route_pattern(pattern, dispatcher.route_rules, _django_rule_format)
regex_pattern = f'^{pattern}$'
callback = PredicatedHandler(dispatcher.route_rules, view_variants)
log.debug(f'Creating Django URL "{regex_pattern}" as the handler named "{dispatcher.route_name}" in the namespace "{dispatcher.route_namespace}".')
rv.append(URLPattern(RegexPattern(regex_pattern, is_endpoint=True), callback, dispatcher.route_extra_kwargs, django_route_name))
if viewset_variants:
django_route_name = f'{dispatcher.route_namespace}.{dispatcher.route_name}-drf_viewset'
pattern = dispatcher.route_pattern.lstrip('/') # removes django warnings
pattern = complete_route_pattern(pattern, dispatcher.route_rules, _django_rule_format)
drf_pattern = '(?P<__frameapp_dynamic_viewset__>/(?P<pk>[^/.]+))?'
regex_pattern = f'^{pattern}{drf_pattern}$'
callback = PredicatedHandler(dispatcher.route_rules, viewset_variants)
log.debug(f'Creating DRF URL "{regex_pattern}" as the handler named "{dispatcher.route_name}" in the namespace "{dispatcher.route_namespace}".')
rv.append(URLPattern(RegexPattern(regex_pattern, is_endpoint=True), callback, dispatcher.route_extra_kwargs, django_route_name))
return rv
def test_process_resolver_recurses_for_nested_resolvers(wrap_fun):
cb = Mock()
resolver = URLResolver(RegexPattern(r'^foo/$'), [])
resolver.callback = cb
injector = Mock()
process_resolver(URLResolver(RegexPattern(r'^$'), [resolver]), injector)
wrap_fun.assert_has_calls([call(cb, injector)])
def abc(request, route):
endpoints = RelativeEndpoint.objects.annotate(final_endpoint=Concat(
'base_endpoint__endpoint', 'regex_endpoint')).all()
endpoint = None
for _route in endpoints:
f = RegexPattern('^' + _route.final_endpoint + '$')
if f.match(route) is not None:
endpoint = _route
break
if endpoint is None:
raise NotFound('Matching api endpoint not found')
response = Response(endpoint.fields.all())
return JsonResponse(response.create_response())
def render(self, context):
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = URLResolver(RegexPattern(r'^/'), urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
return view(context['request'], *args,
**kwargs).content.decode(settings.DEFAULT_CHARSET)
raise "%r is not callable" % view
except:
if getattr(settings, 'TEMPLATE_DEBUG', False):
raise
return ""
def test_process_resolver_wraps_resolver_callback(wrap_fun):
resolver = URLResolver(RegexPattern(r'^$'), [])
cb = Mock()
resolver.callback = cb
injector = Mock()
process_resolver(resolver, injector)
wrap_fun.assert_has_calls([call(cb, injector)])
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 = URLResolver(RegexPattern(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 test_process_resolver_repopulates_resolver():
resolver = URLResolver(RegexPattern(r'^$'), [])
resolver._populate()
with patch.object(resolver, '_populate') as populate:
process_resolver(resolver, Mock())
populate.assert_called_once_with()
def get_resolver(cls):
if "_routablepage_urlresolver" not in cls.__dict__:
subpage_urls = cls.get_subpage_urls()
cls._routablepage_urlresolver = URLResolver(
RegexPattern(r"^/"), subpage_urls)
return cls._routablepage_urlresolver
def crud_impl(request, rest_path):
m = URLResolver(RegexPattern(r'^'), urlpatterns).resolve(rest_path)
return m.func(request=request,
model=model,
**all,
**kwargs[m.func.__name__],
**m.kwargs)
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 = getattr(pattern, 'pattern', 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, URLResolver):
# 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
urlconf_module = recurse_patterns(regex,
pattern.url_patterns,
page_id,
args,
nested=True)
# this is an 'include', recurse!
regex_pattern = RegexPattern(regex)
resolver = URLResolver(regex_pattern, urlconf_module,
pattern.default_kwargs, pattern.app_name,
pattern.namespace)
else:
# Re-do the URLPattern with the new regular expression
args = pattern.default_args
if default_args:
args.update(default_args)
regex_pattern = RegexPattern(regex,
name=pattern.name,
is_endpoint=True)
resolver = URLPattern(regex_pattern, pattern.callback, args,
pattern.name)
resolver.page_id = page_id
newpatterns.append(resolver)
return newpatterns
def get(self, request):
urls = []
resolver = URLResolver(RegexPattern(r'^/'), 'e_logs.business_logic.dictionaries.urls')
for url in filter(lambda x: isinstance(x[0], str), list(resolver.reverse_dict.items())):
link = '/api/bl/dicts/' + url[1][0][0][0]
urls.append({"title": url[0], "link": link, 'name':link.split('/')[-2]})
return JsonResponse(urls, safe=False)
def make_url_resolver(regex, urlpatterns):
try:
# Django 2.0
from django.urls.resolvers import RegexPattern
return RegexURLResolver(RegexPattern(regex), urlpatterns)
except ImportError:
# Django < 2.0
return RegexURLResolver(regex, urlpatterns)
def setUp(self):
# Patterns with a "catch all" view (thing) at the end.
self.patterns_catchall = urlresolvers.URLResolver(
RegexPattern(r'^/'), [
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 = urlresolvers.URLResolver(
RegexPattern(r'^/'), [
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
)
])
def route(self, request, path_components):
if not self.live:
raise Http404
resolver = URLResolver(RegexPattern(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 test_nontranslated_regex_compiled_once(self):
provider = RegexPattern('^foo/$')
with translation.override('de'):
de_compiled = provider.regex
with translation.override('fr'):
# compiled only once, regardless of language
error = AssertionError('tried to compile non-translated url regex twice')
with mock.patch('django.urls.resolvers.re.compile', side_effect=error):
fr_compiled = provider.regex
self.assertEqual(de_compiled.pattern, '^foo/$')
self.assertEqual(fr_compiled.pattern, '^foo/$')
def abc(request, route):
endpoints = RelativeEndpoint.objects.annotate(
final_endpoint=Concat('base_endpoint__endpoint', 'regex_endpoint')).all()
endpoint = None
# metas = RelativeEndpoint.objects.filter()
url_params = {}
for _route in endpoints:
regex = _route_to_regex(_route.final_endpoint)
f = RegexPattern(regex[0])
is_match = f.match(route)
if is_match is not None:
url_params = is_match[2]
endpoint = _route
break
if endpoint is None:
raise NotFound('Matching api endpoint not found')
if request.method != endpoint.method:
raise NotAllowed("This method is not allowed")
response = Response(endpoint.fields.all(), endpoint.meta_data, request.GET.get('pageNo', '1'), url_params, request.GET.dict())
return JsonResponse(response.create_response())
def get_resolver(cls):
if '_routablepage_urlresolver' not in cls.__dict__:
subpage_urls = cls.get_subpage_urls()
if django.VERSION >= (2, 0):
cls._routablepage_urlresolver = URLResolver(
RegexPattern(r'^/'), subpage_urls)
else: # Django 1.11 fallback
cls._routablepage_urlresolver = RegexURLResolver(
r'^/', subpage_urls)
return cls._routablepage_urlresolver
def __init__(self, resolver_func, view_func):
self.resolver_func = resolver_func
self.view_func = view_func
super().__init__(
# Note - this regex matches nothing
# We implement our own resolve() method, and we ignore this.
# It still needs to be a valid regex, though, or urls.reverse() will break.
RegexPattern(r'^(?!x)x'),
view_func,
)
def __init__(self, regex, urlconf_name, default_kwargs=None, app_name=None, namespace=None, module=None): # noqa D102
self._module = module
if app_name is None and namespace is not None:
app_name = namespace
pattern = RegexPattern(regex, is_endpoint=False)
super(ModuleURLResolver, self).__init__(
pattern,
urlconf_name,
default_kwargs,
app_name=app_name,
namespace=namespace,
)
def test_translated_regex_compiled_per_language(self):
provider = RegexPattern(translation.gettext_lazy('^foo/$'))
with translation.override('de'):
de_compiled = provider.regex
# compiled only once per language
error = AssertionError('tried to compile url regex twice for the same language')
with mock.patch('django.urls.resolvers.re.compile', side_effect=error):
de_compiled_2 = provider.regex
with translation.override('fr'):
fr_compiled = provider.regex
self.assertEqual(fr_compiled.pattern, '^foo-fr/$')
self.assertEqual(de_compiled.pattern, '^foo-de/$')
self.assertEqual(de_compiled, de_compiled_2)
def process_request(request):
resolver = URLResolver(RegexPattern(r'^/'), settings.ROOT_URLCONF)
try:
callback, callback_args, callback_kwargs = resolver.resolve(
request.path)
return callback(request, *callback_args, **callback_kwargs)
except Resolver404 as e:
pass
except Http404 as e:
return HttpResponseNotFound(str(e))
return get_response(request)
def url_sites(regex, view, kwargs=None, name=None, prefix=''):
#pylint:disable=unused-argument
if not view:
raise ImproperlyConfigured(
'Empty URL pattern view name not permitted (for pattern %r)' %
regex)
if isinstance(view, (list, tuple)):
# For include(...) processing.
pattern = RegexPattern(regex, is_endpoint=False)
urlconf_module, app_name, namespace = view
return RegexURLResolver(
pattern,
urlconf_module,
kwargs,
app_name=app_name,
namespace=namespace,
)
if callable(view):
pattern = RegexPattern(regex, name=name, is_endpoint=True)
return DjangoRegexURLPattern(pattern, view, kwargs, name)
raise TypeError('view must be a callable or a list/tuple'\
' in the case of include().')
def check_settings(app_configs, **kwargs):
errors = []
r = RoutePattern(settings.PATH) if settings.TYPE_PATTERN == settings.ROUTE else RegexPattern(settings.PATH)
invalid_keys = [arg for arg in settings.PATH_REQUIRED_ARGS if arg not in r.regex.groupindex.keys()]
if invalid_keys:
errors.append(
Error(
'PATH in settings does not contains: ' + ', '.join(invalid_keys),
obj=settings.PATH
)
)
if not getattr(app_settings, 'MEDIA_ROOT', None):
errors.append(Error('Set MEDIA_ROOT in settings'))
return errors
def test_process_resolver_wraps_pattern_callbacks(wrap_fun):
cb1 = Mock()
pattern1 = URLPattern('', cb1)
cb2 = Mock()
pattern2 = URLPattern('', cb2)
resolver = URLResolver(RegexPattern(r'^$'), [pattern1, pattern2])
injector = Mock()
process_resolver(resolver, injector)
wrap_fun.assert_has_calls([
call(cb1, injector),
call(cb2, injector),
])
def __init__(self, regex, default_args=None, name=None, app_name=None):
self.dmp = apps.get_app_config('django_mako_plus')
if app_name or self.dmp.options['DEFAULT_APP']:
self.dmp.register_app(app_name)
default_args = merge_dicts(
{'dmp_app': app_name or self.dmp.options['DEFAULT_APP']},
default_args)
if isinstance(regex, str) and RegexPattern is not None:
regex = RegexPattern(regex, name=name, is_endpoint=True)
# this is a bit of a hack, but the super constructor needs
# a view function. Our resolve() function ignores this view function
# so we'll just creeate a no-op placeholder so super is happy.
def no_op_view(request):
raise Http404()
super().__init__(regex, no_op_view, default_args, name=name)
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 = URLResolver(RegexPattern(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 __init__(self,
regex,
urlconf_name,
default_kwargs=None,
app_name=None,
namespace=None,
wrap=None):
regex_pattern = RegexPattern(regex)
super(DecorateRegexURLResolver,
self).__init__(regex_pattern, urlconf_name, default_kwargs,
app_name, namespace)
if isinstance(wrap, (tuple, list)):
self.wrap = wrap
elif wrap:
self.wrap = [wrap]
else:
self.wrap = []
self.regex = regex_pattern.regex
def detype_pattern(pattern):
"""
return an equivalent pattern that accepts arbitrary values for path parameters.
de-typing the path will ease determining a matching route without having properly
formatted dummy values for all path parameters.
"""
if isinstance(pattern, URLResolver):
return URLResolver(
pattern=detype_pattern(pattern.pattern),
urlconf_name=[detype_pattern(p) for p in pattern.url_patterns],
default_kwargs=pattern.default_kwargs,
app_name=pattern.app_name,
namespace=pattern.namespace,
)
elif isinstance(pattern, URLPattern):
return URLPattern(
pattern=detype_pattern(pattern.pattern),
callback=pattern.callback,
default_args=pattern.default_args,
name=pattern.name,
)
elif isinstance(pattern, RoutePattern):
return RoutePattern(
route=re.sub(r'<\w+:(\w+)>', r'<\1>', pattern._route),
name=pattern.name,
is_endpoint=pattern._is_endpoint
)
elif isinstance(pattern, RegexPattern):
detyped_regex = pattern._regex
for name, regex in analyze_named_regex_pattern(pattern._regex).items():
detyped_regex = detyped_regex.replace(
f'(?P<{name}>{regex})',
f'(?P<{name}>[^/]+)',
)
return RegexPattern(
regex=detyped_regex,
name=pattern.name,
is_endpoint=pattern._is_endpoint
)
else:
warn(f'unexpected pattern "{pattern}" encountered while simplifying urlpatterns.')
return pattern
def test_get_urls():
"""
Calling get_urls returns an URLConf with the correctly formed paths pointing to
their corresponding views
"""
registry = Registry()
mock_request_handler = lambda request: None # noqa: E731
class TestIntegration(BaseIntegration):
name = "some-integration"
def get_urls(self):
return [path("v1/path/", mock_request_handler)]
registry.register(TestIntegration)
urlconf = registry.get_urls()
resolver = URLResolver(RegexPattern(r"^/"), urlconf)
valid_paths = ["/api/integrations/some-integration/v1/path/"]
for valid_path in valid_paths:
resolver_match = resolver.resolve(valid_path)
assert resolver_match.func == mock_request_handler
def event_url(route, view, name=None, require_live=True):
if callable(view):
pattern = RegexPattern(route, name=name, is_endpoint=True)
pattern._require_live = require_live
return URLPattern(pattern, view, {}, name)
raise TypeError('view must be a callable.')
