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.')