def __init__(self, title, link, description, language=None, author_email=None,
         author_name=None, author_link=None, subtitle=None, categories=None,
         feed_url=None, feed_copyright=None, feed_guid=None, ttl=None, **kwargs):
     to_unicode = lambda s: force_text(s, strings_only=True)
     if categories:
         categories = [force_text(c) for c in categories]
     if ttl is not None:
         # Force ints to unicode
         ttl = force_text(ttl)
     self.feed = {
         'title': to_unicode(title),
         'link': iri_to_uri(link),
         'description': to_unicode(description),
         'language': to_unicode(language),
         'author_email': to_unicode(author_email),
         'author_name': to_unicode(author_name),
         'author_link': iri_to_uri(author_link),
         'subtitle': to_unicode(subtitle),
         'categories': categories or (),
         'feed_url': iri_to_uri(feed_url),
         'feed_copyright': to_unicode(feed_copyright),
         'id': feed_guid or link,
         'ttl': ttl,
     }
     self.feed.update(kwargs)
     self.items = []
 def add_item(self, title, link, description, author_email=None,
     author_name=None, author_link=None, pubdate=None, comments=None,
     unique_id=None, enclosure=None, categories=(), item_copyright=None,
     ttl=None, **kwargs):
     """
     Adds an item to the feed. All args are expected to be Python Unicode
     objects except pubdate, which is a datetime.datetime object, and
     enclosure, which is an instance of the Enclosure class.
     """
     to_unicode = lambda s: force_text(s, strings_only=True)
     if categories:
         categories = [to_unicode(c) for c in categories]
     if ttl is not None:
         # Force ints to unicode
         ttl = force_text(ttl)
     item = {
         'title': to_unicode(title),
         'link': iri_to_uri(link),
         'description': to_unicode(description),
         'author_email': to_unicode(author_email),
         'author_name': to_unicode(author_name),
         'author_link': iri_to_uri(author_link),
         'pubdate': pubdate,
         'comments': to_unicode(comments),
         'unique_id': to_unicode(unique_id),
         'enclosure': enclosure,
         'categories': categories or (),
         'item_copyright': to_unicode(item_copyright),
         'ttl': ttl,
     }
     item.update(kwargs)
     self.items.append(item)
Beispiel #3
0
    def test_iri_to_uri(self):
        self.assertEqual(iri_to_uri('red%09ros\xe9#red'),
            'red%09ros%C3%A9#red')

        self.assertEqual(iri_to_uri('/blog/for/J\xfcrgen M\xfcnster/'),
            '/blog/for/J%C3%BCrgen%20M%C3%BCnster/')

        self.assertEqual(iri_to_uri('locations/%s' % urlquote_plus('Paris & Orl\xe9ans')),
            'locations/Paris+%26+Orl%C3%A9ans')
 def urls(self):
     "Returns a list of (value, URL) tuples."
     # First, check the urls() method for each plugin.
     plugin_urls = []
     for plugin_name, plugin in self.model.model_databrowse().plugins.items():
         urls = plugin.urls(plugin_name, self)
         if urls is not None:
             return zip(self.values(), urls)
     if self.field.rel:
         m = EasyModel(self.model.site, self.field.rel.to)
         if self.field.rel.to in self.model.model_list:
             lst = []
             for value in self.values():
                 if value is None:
                     continue
                 url = '%s%s/%s/objects/%s/' % (self.model.site.root_url, m.model._meta.app_label, m.model._meta.module_name, iri_to_uri(value._get_pk_val()))
                 lst.append((smart_text(value), url))
         else:
             lst = [(value, None) for value in self.values()]
     elif self.field.choices:
         lst = []
         for value in self.values():
             url = '%s%s/%s/fields/%s/%s/' % (self.model.site.root_url, self.model.model._meta.app_label, self.model.model._meta.module_name, self.field.name, iri_to_uri(self.raw_value))
             lst.append((value, url))
     elif isinstance(self.field, models.URLField):
         val = list(self.values())[0]
         lst = [(val, iri_to_uri(val))]
     else:
         lst = [(list(self.values())[0], None)]
     return lst
Beispiel #5
0
 def handle_simple(cls, name):
     try:
         from djangocg.conf import settings
     except ImportError:
         prefix = ''
     else:
         prefix = iri_to_uri(getattr(settings, name, ''))
     return prefix
Beispiel #6
0
def add_domain(domain, url, secure=False):
    protocol = 'https' if secure else 'http'
    if url.startswith('//'):
        # Support network-path reference (see #16753) - RSS requires a protocol
        url = '%s:%s' % (protocol, url)
    elif not (url.startswith('http://')
            or url.startswith('https://')
            or url.startswith('mailto:')):
        url = iri_to_uri('%s://%s%s' % (protocol, domain, url))
    return url
def reverse(viewname, urlconf=None, args=None, kwargs=None, prefix=None, current_app=None):
    if urlconf is None:
        urlconf = get_urlconf()
    resolver = get_resolver(urlconf)
    args = args or []
    kwargs = kwargs or {}

    if prefix is None:
        prefix = get_script_prefix()

    if not isinstance(viewname, six.string_types):
        view = viewname
    else:
        parts = viewname.split(':')
        parts.reverse()
        view = parts[0]
        path = parts[1:]

        resolved_path = []
        ns_pattern = ''
        while path:
            ns = path.pop()

            # Lookup the name to see if it could be an app identifier
            try:
                app_list = resolver.app_dict[ns]
                # Yes! Path part matches an app in the current Resolver
                if current_app and current_app in app_list:
                    # If we are reversing for a particular app,
                    # use that namespace
                    ns = current_app
                elif ns not in app_list:
                    # The name isn't shared by one of the instances
                    # (i.e., the default) so just pick the first instance
                    # as the default.
                    ns = app_list[0]
            except KeyError:
                pass

            try:
                extra, resolver = resolver.namespace_dict[ns]
                resolved_path.append(ns)
                ns_pattern = ns_pattern + extra
            except KeyError as key:
                if resolved_path:
                    raise NoReverseMatch(
                        "%s is not a registered namespace inside '%s'" %
                        (key, ':'.join(resolved_path)))
                else:
                    raise NoReverseMatch("%s is not a registered namespace" %
                                         key)
        if ns_pattern:
            resolver = get_ns_resolver(ns_pattern, resolver)

    return iri_to_uri(resolver._reverse_with_prefix(view, prefix, *args, **kwargs))
Beispiel #8
0
def _generate_cache_key(request, method, headerlist, key_prefix):
    """Returns a cache key from the headers given in the header list."""
    ctx = hashlib.md5()
    for header in headerlist:
        value = request.META.get(header, None)
        if value is not None:
            ctx.update(value)
    path = hashlib.md5(force_bytes(iri_to_uri(request.get_full_path())))
    cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
        key_prefix, method, path.hexdigest(), ctx.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)
Beispiel #9
0
 def build_absolute_uri(self, location=None):
     """
     Builds an absolute URI from the location and the variables available in
     this request. If no location is specified, the absolute URI is built on
     ``request.get_full_path()``.
     """
     if not location:
         location = self.get_full_path()
     if not absolute_http_url_re.match(location):
         current_uri = '%s://%s%s' % ('https' if self.is_secure() else 'http',
                                      self.get_host(), self.path)
         location = urljoin(current_uri, location)
     return iri_to_uri(location)
Beispiel #10
0
def _generate_cache_header_key(key_prefix, request):
    """Returns a cache key for the header cache."""
    path = hashlib.md5(force_bytes(iri_to_uri(request.get_full_path())))
    cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
        key_prefix, path.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)
Beispiel #11
0
 def get_full_path(self):
     # RFC 3986 requires query string arguments to be in the ASCII range.
     # Rather than crash if this doesn't happen, we encode defensively.
     return '%s%s' % (self.path, self.environ.get('QUERY_STRING', '') and ('?' + iri_to_uri(self.environ.get('QUERY_STRING', ''))) or '')
 def __init__(self, url, length, mime_type):
     "All args are expected to be Python Unicode objects"
     self.length, self.mime_type = length, mime_type
     self.url = iri_to_uri(url)
Beispiel #13
0
 def __init__(self, redirect_to, *args, **kwargs):
     parsed = urlparse(redirect_to)
     if parsed.scheme and parsed.scheme not in self.allowed_schemes:
         raise SuspiciousOperation("Unsafe redirect to URL with protocol '%s'" % parsed.scheme)
     super(HttpResponseRedirectBase, self).__init__(*args, **kwargs)
     self['Location'] = iri_to_uri(redirect_to)
 def url(self):
     return '%s%s/%s/%s/%s/' % (self.model.site.root_url, self.model.model._meta.app_label, self.model.model._meta.module_name, self.field.field.name, iri_to_uri(self.value))
def iriencode(value):
    """Escapes an IRI value for use in a URL."""
    return force_text(iri_to_uri(value))
 def url(self):
     return '%s%s/%s/objects/%s/' % (self.model.site.root_url, self.model.model._meta.app_label, self.model.model._meta.module_name, iri_to_uri(self.pk()))
Beispiel #17
0
 def test_iri_to_uri_idempotent(self):
     self.assertEqual(iri_to_uri(iri_to_uri('red%09ros\xe9#red')),
         'red%09ros%C3%A9#red')