Django

Code

Ticket #4380: output_charset.patch

File output_charset.patch, 13.7 kB (added by ctrochalakis, 4 months ago)

  • a/django/conf/__init__.py

    old new  
    99import os 
    1010import time     # Needed for Windows 
    1111from django.conf import global_settings 
     12from warnings import warn 
    1213 
    1314ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE" 
    1415 
    …… 
    9091        # as strings. 
    9192        tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS") 
    9293 
     94        # If DEFAULT_CHARSET is specified, populate OUTPUT_CHARSET from it. 
     95        try: 
     96            setattr(self, "OUTPUT_CHARSET", getattr(mod, "DEFAULT_CHARSET")) 
     97            warn("DEFAULT_CHARSET is deprecated. Use OUTPUT_CHARSET instead.", 
     98                DeprecationWarning, stacklevel=3) 
     99        except AttributeError, e: 
     100            pass 
     101 
    93102        for setting in dir(mod): 
    94103            if setting == setting.upper(): 
    95104                setting_value = getattr(mod, setting) 
    …… 
    97106                    setting_value = (setting_value,) # In case the user forgot the comma. 
    98107                setattr(self, setting, setting_value) 
    99108 
     109 
    100110        # Expand entries in INSTALLED_APPS like "django.contrib.*" to a list 
    101111        # of all those apps. 
    102112        new_installed_apps = [] 

  • a/django/conf/global_settings.py

    old new  
    102102# MIME type isn't manually specified. These are used to construct the 
    103103# Content-Type header. 
    104104DEFAULT_CONTENT_TYPE = 'text/html' 
    105 DEFAULT_CHARSET = 'utf-8' 
     105OUTPUT_CHARSET = 'utf-8' 
    106106 
    107107# Encoding of files read from disk (template and initial SQL files). 
    108108FILE_CHARSET = 'utf-8' 

  • a/django/core/mail.py

    old new  
    7878            result = [] 
    7979            for item in val.split(', '): 
    8080                nm, addr = parseaddr(item) 
    81                 nm = str(Header(nm, settings.DEFAULT_CHARSET)) 
     81                nm = str(Header(nm, settings.OUTPUT_CHARSET)) 
    8282                result.append(formataddr((nm, str(addr)))) 
    8383            val = ', '.join(result) 
    8484        else: 
    85             val = Header(force_unicode(val), settings.DEFAULT_CHARSET) 
     85            val = Header(force_unicode(val), settings.OUTPUT_CHARSET) 
    8686    return name, val 
    8787 
    8888class SafeMIMEText(MIMEText): 
    …… 
    220220        return self.connection 
    221221 
    222222    def message(self): 
    223         encoding = self.encoding or settings.DEFAULT_CHARSET 
    224         msg = SafeMIMEText(smart_str(self.body, settings.DEFAULT_CHARSET), self.content_subtype, encoding) 
     223        encoding = self.encoding or settings.OUTPUT_CHARSET 
     224        msg = SafeMIMEText(smart_str(self.body, settings.OUTPUT_CHARSET), self.content_subtype, encoding) 
    225225        if self.attachments: 
    226226            body_msg = msg 
    227227            msg = SafeMIMEMultipart(_subtype=self.multipart_subtype) 
    …… 
    288288        basetype, subtype = mimetype.split('/', 1) 
    289289        if basetype == 'text': 
    290290            attachment = SafeMIMEText(smart_str(content, 
    291                 settings.DEFAULT_CHARSET), subtype, settings.DEFAULT_CHARSET) 
     291                settings.OUTPUT_CHARSET), subtype, settings.OUTPUT_CHARSET) 
    292292        else: 
    293293            # Encode non-text attachments with base64. 
    294294            attachment = MIMEBase(basetype, subtype) 

  • a/django/core/serializers/python.py

    old new  
    7272        # Handle each field 
    7373        for (field_name, field_value) in d["fields"].iteritems(): 
    7474            if isinstance(field_value, str): 
    75                 field_value = smart_unicode(field_value, options.get("encoding", settings.DEFAULT_CHARSET), strings_only=True) 
     75                field_value = smart_unicode(field_value, options.get("encoding", settings.OUTPUT_CHARSET), strings_only=True) 
    7676 
    7777            field = Model._meta.get_field(field_name) 
    7878 

  • a/django/core/serializers/xml_serializer.py

    old new  
    2222        """ 
    2323        Start serialization -- open the XML document and the root element. 
    2424        """ 
    25         self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET)) 
     25        self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.OUTPUT_CHARSET)) 
    2626        self.xml.startDocument() 
    2727        self.xml.startElement("django-objects", {"version" : "1.0"}) 
    2828 

  • a/django/http/__init__.py

    old new  
    139139    This is immutable unless you create a copy of it. 
    140140 
    141141    Values retrieved from this class are converted from the given encoding 
    142     (DEFAULT_CHARSET by default) to unicode. 
     142    (OUTPUT_CHARSET by default) to unicode. 
    143143    """ 
    144144    def __init__(self, query_string, mutable=False, encoding=None): 
    145145        MultiValueDict.__init__(self) 
    …… 
    147147            # *Important*: do not import settings any earlier because of note 
    148148            # in core.handlers.modpython. 
    149149            from django.conf import settings 
    150             encoding = settings.DEFAULT_CHARSET 
     150            encoding = settings.OUTPUT_CHARSET 
    151151        self.encoding = encoding 
    152152        self._mutable = True 
    153153        for key, value in parse_qsl((query_string or ''), True): # keep_blank_values=True 
    …… 
    259259    def __init__(self, content='', mimetype=None, status=None, 
    260260            content_type=None): 
    261261        from django.conf import settings 
    262         self._charset = settings.DEFAULT_CHARSET 
     262        self._charset = settings.OUTPUT_CHARSET 
    263263        if mimetype: 
    264264            content_type = mimetype     # For backwards compatibility 
    265265        if not content_type: 
    266266            content_type = "%s; charset=%s" % (settings.DEFAULT_CONTENT_TYPE, 
    267                     settings.DEFAULT_CHARSET) 
     267                    settings.OUTPUT_CHARSET) 
    268268        if not isinstance(content, basestring) and hasattr(content, '__iter__'): 
    269269            self._container = content 
    270270            self._is_string = False 

  • a/django/test/client.py

    old new  
    6161    as an application/octet-stream; otherwise, str(value) will be sent. 
    6262    """ 
    6363    lines = [] 
    64     to_str = lambda s: smart_str(s, settings.DEFAULT_CHARSET) 
     64    to_str = lambda s: smart_str(s, settings.OUTPUT_CHARSET) 
    6565    for (key, value) in data.items(): 
    6666        if isinstance(value, file): 
    6767            lines.extend([ 

  • a/django/utils/translation/trans_real.py

    old new  
    6565class DjangoTranslation(gettext_module.GNUTranslations): 
    6666    """ 
    6767    This class sets up the GNUTranslations context with regard to output 
    68     charset. Django uses a defined DEFAULT_CHARSET as the output charset on 
     68    charset. Django uses a defined OUTPUT_CHARSET as the output charset on 
    6969    Python 2.4. With Python 2.3, use DjangoTranslation23. 
    7070    """ 
    7171    def __init__(self, *args, **kw): 

  • a/docs/email.txt

    old new  
    2828.. note:: 
    2929 
    3030    The character set of e-mail sent with ``django.core.mail`` will be set to 
    31     the value of your `DEFAULT_CHARSET`_ setting. 
     31    the value of your `OUTPUT_CHARSET`_ setting. 
    3232 
    33 .. _DEFAULT_CHARSET: ../settings/#default-charset 
     33.. _OUTPUT_CHARSET: ../settings/#output-charset 
    3434.. _EMAIL_HOST: ../settings/#email-host 
    3535.. _EMAIL_PORT: ../settings/#email-port 
    3636.. _EMAIL_HOST_USER: ../settings/#email-host-user 

  • a/docs/request_response.txt

    old new  
    4242    **New in Django development version** 
    4343 
    4444    A string representing the current encoding used to decode form submission 
    45     data (or ``None``, which means the ``DEFAULT_CHARSET`` setting is used). 
     45    data (or ``None``, which means the ``OUTPUT_CHARSET`` setting is used). 
    4646    You can write to this attribute to change the encoding used when accessing 
    4747    the form data. Any subsequent attribute accesses (such as reading from 
    4848    ``GET`` or ``POST``) will use the new ``encoding`` value.  Useful if you 
    49     know the form data is not in the ``DEFAULT_CHARSET`` encoding. 
     49    know the form data is not in the ``OUTPUT_CHARSET`` encoding. 
    5050 
    5151``GET`` 
    5252    A dictionary-like object containing all given HTTP GET parameters. See the 

  • a/docs/settings.txt

    old new  
    394394DEFAULT_CHARSET 
    395395--------------- 
    396396 
    397 Default: ``'utf-8'`` 
    398  
    399 Default charset to use for all ``HttpResponse`` objects, if a MIME type isn't 
    400 manually specified. Used with ``DEFAULT_CONTENT_TYPE`` to construct the 
    401 ``Content-Type`` header. 
     397``DEFAULT_CHARSET`` has been deprecated in favor of ``OUTPUT_CHARSET``. 
    402398 
    403399DEFAULT_CONTENT_TYPE 
    404400-------------------- 
    …… 
    406402Default: ``'text/html'`` 
    407403 
    408404Default content type to use for all ``HttpResponse`` objects, if a MIME type 
    409 isn't manually specified. Used with ``DEFAULT_CHARSET`` to construct the 
     405isn't manually specified. Used with ``OUTPUT_CHARSET`` to construct the 
    410406``Content-Type`` header. 
    411407 
    412408DEFAULT_FROM_EMAIL 
    …… 
    733729See `allowed date format strings`_. See also ``DATE_FORMAT``, 
    734730``DATETIME_FORMAT``, ``TIME_FORMAT`` and ``YEAR_MONTH_FORMAT``. 
    735731 
     732OUTPUT_CHARSET 
     733-------------- 
     734 
     735**New in Django development version** 
     736 
     737Default: ``'utf-8'`` 
     738 
     739Default charset to use for all ``HttpResponse`` objects, if a MIME type isn't 
     740manually specified. Used with ``DEFAULT_CONTENT_TYPE`` to construct the 
     741``Content-Type`` header. This setting deprecates ``DEFAULT_CHARSET``. 
     742 
    736743PREPEND_WWW 
    737744----------- 
    738745 

  • a/docs/templates_python.txt

    old new  
    14531453templating functions, call ``django.conf.settings.configure()`` with any 
    14541454settings you wish to specify. You might want to consider setting at least 
    14551455``TEMPLATE_DIRS`` (if you're going to use template loaders), 
    1456 ``DEFAULT_CHARSET`` (although the default of ``utf-8`` is probably fine) and 
     1456``OUTPUT_CHARSET`` (although the default of ``utf-8`` is probably fine) and 
    14571457``TEMPLATE_DEBUG``. All available settings are described in the 
    14581458`settings documentation`_, and any setting starting with *TEMPLATE_* 
    14591459is of obvious interest. 

  • a/docs/unicode.txt

    old new  
    6060If your code only uses ASCII data, it's safe to use your normal strings, 
    6161passing them around at will, because ASCII is a subset of UTF-8. 
    6262 
    63 Don't be fooled into thinking that if your ``DEFAULT_CHARSET`` setting is set 
     63Don't be fooled into thinking that if your ``OUTPUT_CHARSET`` setting is set 
    6464to something other than ``'utf-8'`` you can use that other encoding in your 
    65 bytestrings! ``DEFAULT_CHARSET`` only applies to the strings generated as 
     65bytestrings! ``OUTPUT_CHARSET`` only applies to the strings generated as 
    6666the result of template rendering (and e-mail). Django will always assume UTF-8 
    6767encoding for internal bytestrings. The reason for this is that the 
    68 ``DEFAULT_CHARSET`` setting is not actually under your control (if you are the 
     68``OUTPUT_CHARSET`` setting is not actually under your control (if you are the 
    6969application developer). It's under the control of the person installing and 
    7070using your application -- and if that person chooses a different setting, your 
    7171code must still continue to work. Ergo, it cannot rely on that setting. 
    …… 
    293293file, it will convert the data from this encoding to Unicode. (``FILE_CHARSET`` 
    294294is set to ``'utf-8'`` by default.) 
    295295 
    296 The ``DEFAULT_CHARSET`` setting controls the encoding of rendered templates. 
     296The ``OUTPUT_CHARSET`` setting controls the encoding of rendered templates. 
    297297This is set to UTF-8 by default. 
    298298 
    299299Template tags and filters 
    …… 
    345345methods of ``HttpRequest`` return data exactly as it was submitted by the 
    346346client. 
    347347 
    348 By default, the ``DEFAULT_CHARSET`` setting is used as the assumed encoding 
     348By default, the ``OUTPUT_CHARSET`` setting is used as the assumed encoding 
    349349for form data. If you need to change this for a particular form, you can set 
    350350the ``encoding`` attribute on an ``HttpRequest`` instance. For example:: 
    351351