Django

Code

Ticket #1484: 1484.m-r.6.diff

File 1484.m-r.6.diff, 6.4 kB (added by Maniac <Maniac@SoftwareManiacs.Org>, 2 years ago)

Patch 5 for magic-removal: corrected settings import

  • django/http/__init__.py

    old new  
    22from pprint import pformat 
    33from urllib import urlencode 
    44from django.utils.datastructures import MultiValueDict 
     5import cgi 
     6from StringIO import StringIO 
    57 
    68try: 
    79    # The mod_python version is more efficient, so try importing it first. 
    …… 
    3537    def get_full_path(self): 
    3638        return '' 
    3739 
    38 def parse_file_upload(header_dict, post_data): 
     40class FileDict(dict): 
     41    "Keeps uploaded file as a file-like object and reads its content on demand" 
     42    def __getitem__(self, name): 
     43        if name=='content' and not 'content' in self: 
     44            self['file'].seek(0, 2) 
     45            size = self['file'].tell() 
     46            self['file'].seek(0, 0) 
     47            self['content']=self['file'].read(size) 
     48        return dict.__getitem__(self, name) 
     49 
     50    def __deepcopy__(self, memo={}): 
     51        self['content'] # make sure file content is loaded 
     52        import copy 
     53        result = self.__class__() 
     54        memo[id(self)] = result 
     55        for key, value in dict.items(self): 
     56            dict.__setitem__(result, copy.deepcopy(key, memo), copy.deepcopy(value, memo)) 
     57        return result 
     58 
     59class FieldStorage(cgi.FieldStorage): 
     60    "cgi.FieldStorage with ability to store files on disk or in memory" 
     61    def make_file(self, binary=None): 
     62        from django.conf import settings 
     63        if settings.STORE_UPLOAD_ON_DISK: 
     64            return cgi.FieldStorage.make_file(self, binary) 
     65        else: 
     66            return StringIO() 
     67 
     68def parse_file_upload(post_stream, environ): 
    3969    "Returns a tuple of (POST MultiValueDict, FILES MultiValueDict)" 
    40     import email, email.Message 
    41     from cgi import parse_header 
    42     raw_message = '\r\n'.join(['%s:%s' % pair for pair in header_dict.items()]) 
    43     raw_message += '\r\n\r\n' + post_data 
    44     msg = email.message_from_string(raw_message) 
     70    fs = FieldStorage(post_stream, environ=environ) 
    4571    POST = MultiValueDict() 
    4672    FILES = MultiValueDict() 
    47     for submessage in msg.get_payload(): 
    48         if isinstance(submessage, email.Message.Message): 
    49             name_dict = parse_header(submessage['Content-Disposition'])[1] 
    50             # name_dict is something like {'name': 'file', 'filename': 'test.txt'} for file uploads 
    51             # or {'name': 'blah'} for POST fields 
    52             # We assume all uploaded files have a 'filename' set. 
    53             if name_dict.has_key('filename'): 
    54                 assert type([]) != type(submessage.get_payload()), "Nested MIME messages are not supported" 
    55                 if not name_dict['filename'].strip(): 
     73    for key in fs.keys(): 
     74        # We can't use FieldStorage.getlist to get contents of a  
     75        # field as a list because for file fields it returns only filenames 
     76        if type(fs[key]) == type([]): 
     77            field_list = fs[key] 
     78        else: 
     79            field_list = [fs[key]] 
     80        for field in field_list: 
     81            if hasattr(field, 'filename') and field.filename is not None: 
     82                if not field.filename.strip(): 
    5683                    continue 
    5784                # IE submits the full path, so trim everything but the basename. 
    5885                # (We can't use os.path.basename because it expects Linux paths.) 
    59                 filename = name_dict['filename'][name_dict['filename'].rfind("\\")+1:] 
    60                 FILES.appendlist(name_dict['name'], { 
     86                filename = field.filename[field.filename.rfind("\\") + 1:] 
     87                FILES.appendlist(key, FileDict({ 
    6188                    'filename': filename, 
    62                     'content-type': (submessage.has_key('Content-Type') and submessage['Content-Type'] or None), 
    63                     'content': submessage.get_payload(), 
    64                 }) 
     89                    'content-type': field.type, 
     90                    'file': field.file, 
     91                })) 
    6592            else: 
    66                 POST.appendlist(name_dict['name'], submessage.get_payload()) 
     93                POST.appendlist(key, field.value) 
    6794    return POST, FILES 
    6895 
    6996class QueryDict(MultiValueDict): 

  • django/conf/global_settings.py

    old new  
    209209# Hint: you really don't! 
    210210TRANSACTIONS_MANAGED = False 
    211211 
     212# Whether to store uploaded files in temp files rather than in memory. 
     213# Storing files on disk may be necessary for accepting large files. 
     214STORE_UPLOAD_ON_DISK = False 
     215 
    212216############## 
    213217# MIDDLEWARE # 
    214218############## 

  • django/core/handlers/wsgi.py

    old new  
    6969        # Populates self._post and self._files 
    7070        if self.environ['REQUEST_METHOD'] == 'POST': 
    7171            if self.environ.get('CONTENT_TYPE', '').startswith('multipart'): 
    72                 header_dict = dict([(k, v) for k, v in self.environ.items() if k.startswith('HTTP_')]) 
    73                 header_dict['Content-Type'] = self.environ.get('CONTENT_TYPE', '') 
    74                 self._post, self._files = http.parse_file_upload(header_dict, self.raw_post_data) 
     72                self._post, self._files = http.parse_file_upload(self.environ['wsgi.input'], self.environ) 
    7573            else: 
    7674                self._post, self._files = http.QueryDict(self.raw_post_data), datastructures.MultiValueDict() 
    7775        else: 

  • django/core/handlers/modpython.py

    old new  
    2626    def _load_post_and_files(self): 
    2727        "Populates self._post and self._files" 
    2828        if self._req.headers_in.has_key('content-type') and self._req.headers_in['content-type'].startswith('multipart'): 
    29             self._post, self._files = http.parse_file_upload(self._req.headers_in, self.raw_post_data) 
     29            environ = dict(self.META) 
     30            environ['CONTENT_LENGTH'] = environ['HTTP_CONTENT_LENGTH'] 
     31            environ['CONTENT_TYPE'] = environ['HTTP_CONTENT_TYPE'] 
     32            self._post, self._files = http.parse_file_upload(self._req, environ) 
    3033        else: 
    3134            self._post, self._files = http.QueryDict(self.raw_post_data), datastructures.MultiValueDict() 
    3235