← Back to branch summary

~grupoesoc/cubicerp-addons/7.0

« back to all changes in this revision

Viewing changes to report_geraldo/lib/geraldo/site/newsite/site-geraldo/django/utils/encoding.py

  • Committer: Cubic ERP
  • Date: 2014-01-07 15:38:09 UTC
  • Revision ID: info@cubicerp.com-20140107153809-4jmif3zoi8rcveve
[ADD] cubicReport

Show diffs side-by-side

added added

removed removed

Lines of Context:
report_geraldo/lib/geraldo/site/newsite/site-geraldo/django/utils/encoding.py
 
1
import types
 
2
import urllib
 
3
import datetime
 
4
from django.utils.functional import Promise
 
5
 
 
6
class DjangoUnicodeDecodeError(UnicodeDecodeError):
 
7
    def __init__(self, obj, *args):
 
8
        self.obj = obj
 
9
        UnicodeDecodeError.__init__(self, *args)
 
10
 
 
11
    def __str__(self):
 
12
        original = UnicodeDecodeError.__str__(self)
 
13
        return '%s. You passed in %r (%s)' % (original, self.obj,
 
14
                type(self.obj))
 
15
 
 
16
class StrAndUnicode(object):
 
17
    """
 
18
    A class whose __str__ returns its __unicode__ as a UTF-8 bytestring.
 
19
 
 
20
    Useful as a mix-in.
 
21
    """
 
22
    def __str__(self):
 
23
        return self.__unicode__().encode('utf-8')
 
24
 
 
25
def smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
 
26
    """
 
27
    Returns a unicode object representing 's'. Treats bytestrings using the
 
28
    'encoding' codec.
 
29
 
 
30
    If strings_only is True, don't convert (some) non-string-like objects.
 
31
    """
 
32
    if isinstance(s, Promise):
 
33
        # The input is the result of a gettext_lazy() call.
 
34
        return s
 
35
    return force_unicode(s, encoding, strings_only, errors)
 
36
 
 
37
def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
 
38
    """
 
39
    Similar to smart_unicode, except that lazy instances are resolved to
 
40
    strings, rather than kept as lazy objects.
 
41
 
 
42
    If strings_only is True, don't convert (some) non-string-like objects.
 
43
    """
 
44
    if strings_only and isinstance(s, (types.NoneType, int, long, datetime.datetime, datetime.date, datetime.time, float)):
 
45
        return s
 
46
    try:
 
47
        if not isinstance(s, basestring,):
 
48
            if hasattr(s, '__unicode__'):
 
49
                s = unicode(s)
 
50
            else:
 
51
                try:
 
52
                    s = unicode(str(s), encoding, errors)
 
53
                except UnicodeEncodeError:
 
54
                    if not isinstance(s, Exception):
 
55
                        raise
 
56
                    # If we get to here, the caller has passed in an Exception
 
57
                    # subclass populated with non-ASCII data without special
 
58
                    # handling to display as a string. We need to handle this
 
59
                    # without raising a further exception. We do an
 
60
                    # approximation to what the Exception's standard str()
 
61
                    # output should be.
 
62
                    s = ' '.join([force_unicode(arg, encoding, strings_only,
 
63
                            errors) for arg in s])
 
64
        elif not isinstance(s, unicode):
 
65
            # Note: We use .decode() here, instead of unicode(s, encoding,
 
66
            # errors), so that if s is a SafeString, it ends up being a
 
67
            # SafeUnicode at the end.
 
68
            s = s.decode(encoding, errors)
 
69
    except UnicodeDecodeError, e:
 
70
        raise DjangoUnicodeDecodeError(s, *e.args)
 
71
    return s
 
72
 
 
73
def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
 
74
    """
 
75
    Returns a bytestring version of 's', encoded as specified in 'encoding'.
 
76
 
 
77
    If strings_only is True, don't convert (some) non-string-like objects.
 
78
    """
 
79
    if strings_only and isinstance(s, (types.NoneType, int)):
 
80
        return s
 
81
    if isinstance(s, Promise):
 
82
        return unicode(s).encode(encoding, errors)
 
83
    elif not isinstance(s, basestring):
 
84
        try:
 
85
            return str(s)
 
86
        except UnicodeEncodeError:
 
87
            if isinstance(s, Exception):
 
88
                # An Exception subclass containing non-ASCII data that doesn't
 
89
                # know how to print itself properly. We shouldn't raise a
 
90
                # further exception.
 
91
                return ' '.join([smart_str(arg, encoding, strings_only,
 
92
                        errors) for arg in s])
 
93
            return unicode(s).encode(encoding, errors)
 
94
    elif isinstance(s, unicode):
 
95
        return s.encode(encoding, errors)
 
96
    elif s and encoding != 'utf-8':
 
97
        return s.decode('utf-8', errors).encode(encoding, errors)
 
98
    else:
 
99
        return s
 
100
 
 
101
def iri_to_uri(iri):
 
102
    """
 
103
    Convert an Internationalized Resource Identifier (IRI) portion to a URI
 
104
    portion that is suitable for inclusion in a URL.
 
105
 
 
106
    This is the algorithm from section 3.1 of RFC 3987.  However, since we are
 
107
    assuming input is either UTF-8 or unicode already, we can simplify things a
 
108
    little from the full method.
 
109
 
 
110
    Returns an ASCII string containing the encoded result.
 
111
    """
 
112
    # The list of safe characters here is constructed from the printable ASCII
 
113
    # characters that are not explicitly excluded by the list at the end of
 
114
    # section 3.1 of RFC 3987.
 
115
    if iri is None:
 
116
        return iri
 
117
    return urllib.quote(smart_str(iri), safe='/#%[]=:;$&()+,!?*')
 
118