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 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 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 _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
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 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 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 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
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)