Imported Django from private SVN repository (created from r. 8825)

git-svn-id: http://code.djangoproject.com/svn/django/trunk@3 bcc190cf-cafb-0310-a4f2-bffc1f526a37

1 files changed, 319 insertions, 0 deletions

diff --git a/django/utils/httpwrappers.py b/django/utils/httpwrappers.py
new file mode 100644
index 0000000000..513a5bc0d7
--- /dev/null
+++ b/django/utils/httpwrappers.py
@@ -0,0 +1,319 @@
+from Cookie import SimpleCookie
+from pprint import pformat
+import datastructures
+
+DEFAULT_MIME_TYPE = 'text/html'
+
+class HttpRequest(object): # needs to be new-style class because subclasses define "property"s
+    "A basic HTTP request"
+    def __init__(self):
+        self.GET, self.POST, self.COOKIES, self.META, self.FILES = {}, {}, {}, {}, {}
+        self.path = ''
+
+    def __repr__(self):
+        return '<HttpRequest\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' % \
+            (pformat(self.GET), pformat(self.POST), pformat(self.COOKIES),
+            pformat(self.META))
+
+    def __getitem__(self, key):
+        for d in (self.POST, self.GET):
+            if d.has_key(key):
+                return d[key]
+        raise KeyError, "%s not found in either POST or GET" % key
+
+    def get_full_path(self):
+        return ''
+
+class ModPythonRequest(HttpRequest):
+    def __init__(self, req):
+        self._req = req
+        self.path = req.uri
+
+    def __repr__(self):
+        return '<ModPythonRequest\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' % \
+            (pformat(self.GET), pformat(self.POST), pformat(self.COOKIES),
+            pformat(self.META))
+
+    def get_full_path(self):
+        return '%s%s' % (self.path, self._req.args and ('?' + self._req.args) or '')
+
+    def _load_post_and_files(self):
+        "Populates self._post and self._files"
+        if self._req.headers_in.has_key('content-type') and self._req.headers_in['content-type'].startswith('multipart'):
+            self._post, self._files = parse_file_upload(self._req)
+        else:
+            self._post, self._files = QueryDict(self._req.read()), datastructures.MultiValueDict()
+
+    def _get_request(self):
+        if not hasattr(self, '_request'):
+           self._request = datastructures.MergeDict(self.POST, self.GET)
+        return self._request
+
+    def _get_get(self):
+        if not hasattr(self, '_get'):
+            self._get = QueryDict(self._req.args)
+        return self._get
+
+    def _set_get(self, get):
+        self._get = get
+
+    def _get_post(self):
+        if not hasattr(self, '_post'):
+            self._load_post_and_files()
+        return self._post
+
+    def _set_post(self, post):
+        self._post = post
+
+    def _get_cookies(self):
+        if not hasattr(self, '_cookies'):
+            self._cookies = parse_cookie(self._req.headers_in.get('cookie', ''))
+        return self._cookies
+
+    def _set_cookies(self, cookies):
+        self._cookies = cookies
+
+    def _get_files(self):
+        if not hasattr(self, '_files'):
+            self._load_post_and_files()
+        return self._files
+
+    def _get_meta(self):
+        "Lazy loader that returns self.META dictionary"
+        if not hasattr(self, '_meta'):
+            self._meta = {
+                'AUTH_TYPE':         self._req.ap_auth_type,
+                'CONTENT_LENGTH':    self._req.clength, # This may be wrong
+                'CONTENT_TYPE':      self._req.content_type, # This may be wrong
+                'GATEWAY_INTERFACE': 'CGI/1.1',
+                'PATH_INFO':         self._req.path_info,
+                'PATH_TRANSLATED':   None, # Not supported
+                'QUERY_STRING':      self._req.args,
+                'REMOTE_ADDR':       self._req.connection.remote_ip,
+                'REMOTE_HOST':       None, # DNS lookups not supported
+                'REMOTE_IDENT':      self._req.connection.remote_logname,
+                'REMOTE_USER':       self._req.user,
+                'REQUEST_METHOD':    self._req.method,
+                'SCRIPT_NAME':       None, # Not supported
+                'SERVER_NAME':       self._req.server.server_hostname,
+                'SERVER_PORT':       self._req.server.port,
+                'SERVER_PROTOCOL':   self._req.protocol,
+                'SERVER_SOFTWARE':   'mod_python'
+            }
+            for key, value in self._req.headers_in.items():
+                key = 'HTTP_' + key.upper().replace('-', '_')
+                self._meta[key] = value
+        return self._meta
+
+    GET = property(_get_get, _set_get)
+    POST = property(_get_post, _set_post)
+    COOKIES = property(_get_cookies, _set_cookies)
+    FILES = property(_get_files)
+    META = property(_get_meta)
+    REQUEST = property(_get_request)
+
+def parse_file_upload(req):
+    "Returns a tuple of (POST MultiValueDict, FILES MultiValueDict), given a mod_python req object"
+    import email, email.Message
+    from cgi import parse_header
+    raw_message = '\r\n'.join(['%s:%s' % pair for pair in req.headers_in.items()])
+    raw_message += '\r\n\r\n' + req.read()
+    msg = email.message_from_string(raw_message)
+    POST = datastructures.MultiValueDict()
+    FILES = datastructures.MultiValueDict()
+    for submessage in msg.get_payload():
+        if isinstance(submessage, email.Message.Message):
+            name_dict = parse_header(submessage['Content-Disposition'])[1]
+            # name_dict is something like {'name': 'file', 'filename': 'test.txt'} for file uploads
+            # or {'name': 'blah'} for POST fields
+            # We assume all uploaded files have a 'filename' set.
+            if name_dict.has_key('filename'):
+                assert type([]) != type(submessage.get_payload()), "Nested MIME messages are not supported"
+                if not name_dict['filename'].strip():
+                    continue
+                # IE submits the full path, so trim everything but the basename.
+                # (We can't use os.path.basename because it expects Linux paths.)
+                filename = name_dict['filename'][name_dict['filename'].rfind("\\")+1:]
+                FILES.appendlist(name_dict['name'], {
+                    'filename': filename,
+                    'content-type': (submessage.has_key('Content-Type') and submessage['Content-Type'] or None),
+                    'content': submessage.get_payload(),
+                })
+            else:
+                POST.appendlist(name_dict['name'], submessage.get_payload())
+    return POST, FILES
+
+class QueryDict(datastructures.MultiValueDict):
+    """A specialized MultiValueDict that takes a query string when initialized.
+    This is immutable unless you create a copy of it."""
+    def __init__(self, query_string):
+        try:
+            from mod_python.util import parse_qsl
+        except ImportError:
+            from cgi import parse_qsl
+        if not query_string:
+            self.data = {}
+            self._keys = []
+        else:
+            self.data = {}
+            self._keys = []
+            for name, value in parse_qsl(query_string, True): # keep_blank_values=True
+                if name in self.data:
+                    self.data[name].append(value)
+                else:
+                    self.data[name] = [value]
+                if name not in self._keys:
+                    self._keys.append(name)
+        self._mutable = False
+
+    def __setitem__(self, key, value):
+        if not self._mutable:
+            raise AttributeError, "This QueryDict instance is immutable"
+        else:
+            self.data[key] = [value]
+            if not key in self._keys:
+                self._keys.append(key)
+
+    def setlist(self, key, list_):
+        if not self._mutable:
+            raise AttributeError, "This QueryDict instance is immutable"
+        else:
+            self.data[key] = list_
+            if not key in self._keys:
+                self._keys.append(key)
+
+    def copy(self):
+        "Returns a mutable copy of this object"
+        cp = datastructures.MultiValueDict.copy(self)
+        cp._mutable = True
+        return cp
+
+    def assert_synchronized(self):
+        assert(len(self._keys) == len(self.data.keys())), \
+            "QueryDict data structure is out of sync: %s %s" % (str(self._keys), str(self.data))
+
+    def items(self):
+        "Respect order preserved by self._keys"
+        self.assert_synchronized()
+        items = []
+        for key in self._keys:
+            if key in self.data:
+                items.append((key, self.data[key][0]))
+        return items
+
+    def keys(self):
+        self.assert_synchronized()
+        return self._keys
+
+def parse_cookie(cookie):
+    if cookie == '':
+        return {}
+    c = SimpleCookie()
+    c.load(cookie)
+    cookiedict = {}
+    for key in c.keys():
+        cookiedict[key] = c.get(key).value
+    return cookiedict
+
+class HttpResponse:
+    "A basic HTTP response, with content and dictionary-accessed headers"
+    def __init__(self, content='', mimetype=DEFAULT_MIME_TYPE):
+        self.content = content
+        self.headers = {'Content-Type':mimetype}
+        self.cookies = SimpleCookie()
+        self.status_code = 200
+
+    def __str__(self):
+        "Full HTTP message, including headers"
+        return '\n'.join(['%s: %s' % (key, value)
+            for key, value in self.headers.items()]) \
+            + '\n\n' + self.content
+
+    def __setitem__(self, header, value):
+        self.headers[header] = value
+
+    def __delitem__(self, header):
+        try:
+            del self.headers[header]
+        except KeyError:
+            pass
+
+    def __getitem__(self, header):
+        return self.headers[header]
+
+    def has_header(self, header):
+        "Case-insensitive check for a header"
+        header = header.lower()
+        for key in self.headers.keys():
+            if key.lower() == header:
+                return True
+        return False
+
+    def set_cookie(self, key, value='', max_age=None, path='/', domain=None, secure=None):
+        self.cookies[key] = value
+        for var in ('max_age', 'path', 'domain', 'secure'):
+            val = locals()[var]
+            if val is not None:
+                self.cookies[key][var.replace('_', '-')] = val
+
+    def get_content_as_string(self, encoding):
+        """
+        Returns the content as a string, encoding it from a Unicode object if
+        necessary.
+        """
+        if isinstance(self.content, unicode):
+            return self.content.encode(encoding)
+        return self.content
+
+    # The remaining methods partially implement the file-like object interface.
+    # See http://docs.python.org/lib/bltin-file-objects.html
+    def write(self, content):
+        self.content += content
+
+    def flush(self):
+        pass
+
+    def tell(self):
+        return len(self.content)
+
+class HttpResponseRedirect(HttpResponse):
+    def __init__(self, redirect_to):
+        HttpResponse.__init__(self)
+        self['Location'] = redirect_to
+        self.status_code = 302
+
+class HttpResponseNotModified(HttpResponse):
+    def __init__(self):
+        HttpResponse.__init__(self)
+        self.status_code = 304
+
+class HttpResponseNotFound(HttpResponse):
+    def __init__(self, content='', mimetype=DEFAULT_MIME_TYPE):
+        HttpResponse.__init__(self, content, mimetype)
+        self.status_code = 404
+
+class HttpResponseForbidden(HttpResponse):
+    def __init__(self, content='', mimetype=DEFAULT_MIME_TYPE):
+        HttpResponse.__init__(self, content, mimetype)
+        self.status_code = 403
+
+class HttpResponseGone(HttpResponse):
+    def __init__(self, content='', mimetype=DEFAULT_MIME_TYPE):
+        HttpResponse.__init__(self, content, mimetype)
+        self.status_code = 410
+
+class HttpResponseServerError(HttpResponse):
+    def __init__(self, content='', mimetype=DEFAULT_MIME_TYPE):
+        HttpResponse.__init__(self, content, mimetype)
+        self.status_code = 500
+
+def populate_apache_request(http_response, mod_python_req):
+    "Populates the mod_python request object with an HttpResponse"
+    mod_python_req.content_type = http_response['Content-Type'] or DEFAULT_MIME_TYPE
+    del http_response['Content-Type']
+    if http_response.cookies:
+        mod_python_req.headers_out['Set-Cookie'] = http_response.cookies.output(header='')
+    for key, value in http_response.headers.items():
+        mod_python_req.headers_out[key] = value
+    mod_python_req.status = http_response.status_code
+    mod_python_req.write(http_response.get_content_as_string('utf-8'))