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 = int(path) else: object_id = int(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 = URLResolver("^", 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 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 _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 render(self, context): """ Render the view node """ 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(r'^/', urlconf) view, args, kwargs = resolver.resolve(url_or_view) # pylint: disable=bare-except 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): render_fnc = view(context['request'], *args, **kwargs).content.\ decode('unicode_escape') return render_fnc raise "%r is not callable" % view # pylint: disable=bare-except except: if settings.DEBUG_PROPAGATE_EXCEPTIONS: raise return ""
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 make_url_resolver(regex, urlpatterns): try: # Django 2.0 from django.urls.resolvers import RegexPattern return URLResolver(RegexPattern(regex), urlpatterns) except ImportError: # Django < 2.0 return URLResolver(regex, urlpatterns)
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 process_resolver(resolver: URLResolver, injector: Injector) -> None: if resolver.callback: resolver.callback = wrap_fun(resolver.callback, injector) for pattern in resolver.url_patterns: if isinstance(pattern, URLPattern) and pattern.callback: pattern.callback = wrap_fun(pattern.callback, injector) elif isinstance(pattern, URLResolver): process_resolver(pattern, injector) if resolver._populated: resolver._populate()
def _get_django_urlpatterns(json_urlpatterns): """ Parse JSON URLconf, and return a list of Django urlpatterns. :param json_urlpatterns: list of JSON URLconf dicts :return: list of Django URLResolver and URLPattern objects """ django_urlpatterns = [] for json_url in json_urlpatterns: includes = json_url.get("includes") if includes: # Make a URLResolver included_django_urlpatterns = _get_django_urlpatterns(includes) isLocalePrefix = json_url.get("isLocalePrefix") if isLocalePrefix: # Make a LocalePrefixPattern. # Custom sub-classes are allowed. LocalePrefixPatternClass = locate(json_url.get("classPath")) if not issubclass(LocalePrefixPatternClass, LocalePrefixPattern): raise ValueError( f"Locale prefix class {json_url.get('classPath')} " f"is not a subclass of LocalePrefixPattern") django_url = URLResolver(LocalePrefixPatternClass(), included_django_urlpatterns) else: # Make an include(...) PatternClass, regex = _get_pattern_class_and_regex(json_url) pattern = PatternClass(regex, is_endpoint=False) django_url = URLResolver( pattern, included_django_urlpatterns, app_name=json_url.get("app_name"), namespace=json_url.get("namespace"), ) else: # Make a URLPattern name = json_url.get("name") PatternClass, regex = _get_pattern_class_and_regex(json_url) pattern = PatternClass(regex, name=name, is_endpoint=True) # Make a dummy view so the URL Pattern is valid. # If this view is ever actually rendered, it will return 404. # Note we're also ignoring the kwargs that can be added to url() definitions. # These are not used to generate urls, they are just passed to the view. django_url = URLPattern(pattern, Http404View.as_view(), name=name) django_urlpatterns.append(django_url) return django_urlpatterns
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 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 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)
class HandlerResolver(object): def __init__(self, conf): try: self.resolver = RegexURLResolver(r'^', conf) except NameError: self.resolver = URLResolver(RegexPattern(r'^'), conf) def resolve(self, update): try: resolver_match = self.resolver.resolve(update.message.text) return resolver_match except AttributeError: resolver_match = self.resolver.resolve(update.callback_query.data) return resolver_match except Resolver404: raise HandlerNotFound("No handler configured for %s" % update.message.text)
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_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 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 i18n_patterns(*urls, prefix_default_language=True): """Add the language code prefix to every URL pattern within this function. This may only be used in the root URLconf, not in an included URLconf. """ if not settings.USE_I18N: return list(urls) return [ URLResolver( ActiveLocalePrefixPattern(prefix_default_language=prefix_default_language), list(urls), ) ]
def get_url_resolver(self): """ Access the URL resolver of the page type. """ if self._url_resolver is None: if self.urls is None: return None elif isinstance(self.urls, string_types): mod = import_module(self.urls) if not hasattr(mod, 'urlpatterns'): raise ImproperlyConfigured("URLConf `{0}` has no urlpatterns attribute".format(self.urls)) patterns = getattr(mod, 'urlpatterns') elif isinstance(self.urls, (list, tuple)): patterns = self.urls else: raise ImproperlyConfigured("Invalid value for '{0}.urls', must be string, list or tuple.".format(self.__class__.__name__)) if django.VERSION > (2, 0): self._url_resolver = URLResolver(RegexPattern(r'^/'), patterns) else: self._url_resolver = URLResolver(r'^/', patterns) return self._url_resolver
def i18n_patterns(*urls, prefix_default_language=True): """ Replacement for django.conf.urls.i18_patterns that uses ISO3166LocalePrefixPattern instead of django.urls.resolvers.LocalePrefixPattern. """ if not settings.USE_I18N: return list(urls) return [ URLResolver( ISO3166LocalePrefixPattern( prefix_default_language=prefix_default_language), list(urls), ) ]
def execute(self): self.load_all_endpoints( URLResolver(r'^/', settings.ROOT_URLCONF).url_patterns) for url_pattern, lookup_str, url_name in self.all_patterns: if not self.app_names or self.is_url_inside_specified_app( lookup_str): self.create_tests_for_endpoint(url_pattern, url_name) if self.disable_migrations: self._disable_native_migrations() self._set_fixture_path() call_command_kwargs = self._get_call_command_kwargs() call_command('test', 'django_smoke_tests', **call_command_kwargs)
def test_export_custom_locale_prefix_pattern_class(mock_urlconf_module): mock_urlconf_module.urlpatterns = [ URLResolver(CustomLocalePrefixPattern(), [url(r"^$", View.as_view(), name="index")]) ] assert export_urlconf.as_json("mock_urlconf_module") == [{ "isLocalePrefix": True, "classPath": "tests.django_urlconf_export.test_export_urlconf.CustomLocalePrefixPattern", "includes": [{ "regex": "^$", "name": "index" }], }]
def i18n_patterns(*urls): """ Add the language code prefix to every URL pattern within this function. This may only be used in the root URLconf, not in an included URLconf. NOTE: Modified from i18n_patterns in Django 2.2 / 3.0, see: https://github.com/django/django/blob/3.0/django/conf/urls/i18n.py#L8-L20 Modifications: - Raises ImproperlyConfigured if settings.USE_I18N is False - Forces prefix_default_language to True, so urls always include the locale - Does not accept prefix_default_language as a kwarg, due to the above - Uses our custom URL prefix pattern, to support our locale codes """ if not settings.USE_I18N: raise ImproperlyConfigured("Kuma requires settings.USE_I18N to be True.") return [URLResolver(KumaLocalePrefixPattern(), list(urls))]
def decorate_pattern(self, pattern): if isinstance(pattern, URLResolver): decorated = URLResolver( pattern.pattern, DecoratedPatterns(pattern.urlconf_module, self.decorators), pattern.default_kwargs, pattern.app_name, pattern.namespace, ) else: callback = pattern.callback for decorator in reversed(self.decorators): callback = decorator(callback) decorated = URLPattern( pattern.pattern, callback, pattern.default_args, pattern.name, ) return decorated
def _path(route, view, kwargs=None, name=None, Pattern=None): """Copied from django.urls.conf (Django 2.0) and modified to return our Resolver/Matcher.""" if isinstance(view, (list, tuple)): # For include(...) processing. pattern = Pattern(route, is_endpoint=False) urlconf_module, app_name, namespace = view return URLResolver( pattern, urlconf_module, kwargs, app_name=app_name, namespace=namespace, ) elif callable(view): pattern = Pattern(route, name=name, is_endpoint=True) return LocaleURLPattern(pattern, view, kwargs, name) else: raise TypeError( 'view must be a callable or a list/tuple in the case of include().' )
def get_url_info(pattern, parent_pattern, parent_namespace): login_required, permission_required = get_perms(pattern.callback) if parent_namespace and not parent_namespace == 'None': full_name = f'{parent_namespace}:{pattern.name}' else: full_name = pattern.name urls_list.append({ 'url_name': full_name, 'url_url': URLResolver._join_route(str(parent_pattern), str(pattern.pattern)), 'view_name': pattern.callback.__name__, 'view_path': pattern.lookup_str, 'login_required': login_required, 'permission_required': permission_required, })
class AppPageMixin: @property def url_config(self): raise NotImplementedError('url_config') def reverse(self, name, *args, **kwargs): sub_url = self._apppage_url_resolver.reverse(name, *args, **kwargs) return self.url + sub_url.lstrip('/') def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._apppage_url_resolver = URLResolver( RegexPattern(r'^{}'.format(self.url)), self.url_config) def route(self, request, path_components): # url config takes precedence over normal wagtail routing try: view, args, kwargs = self._apppage_url_resolver.resolve( request.path) except Resolver404: return super().route(request, path_components) else: return RouteResult(self, args=(view, args, kwargs)) def serve(self, request, view=None, args=None, kwargs=None): if args is None: args = [] if kwargs is None: kwargs = {} if view is None: return super().serve(request, *args, **kwargs) request.parent_page = self # if this is a class-based view, we'll make the parent page available as an attribute as well if getattr(view, 'view_class', None): view.view_class.parent_page = self return view(request, *args, **kwargs)
def __init__(self, conf): try: self.resolver = RegexURLResolver(r'^', conf) except NameError: self.resolver = URLResolver(RegexPattern(r'^'), conf)
def get_resolver(url, url_config): return URLResolver(RegexPattern(r'^{}'.format(url)), url_config)
def tenant_patterns(*urls): """ Add the tenant prefix to every URL pattern within this function. This may only be used in the root URLconf, not in an included URLconf. """ return [URLResolver(TenantPrefixPattern(), list(urls))]
def get_resolver(patterns=None): patterns = patterns or redirectpatterns return URLResolver(RegexPattern(r"^/"), patterns)