### Navigation

- index
- modules |
- next |
- previous |
- TurboGears 2.1.5 documentation »
- Search:
- Extended Table of Contents »
- The Gears in Detail »
- Third-party components »

# `webob` – WebOb

## WebOb

class `webob.``Request`(environ, charset=(No Default), unicode_errors=(No Default), decode_param_names=(No Default), **kw)

  The default request implementation

class `webob.``Response`(body=None, status=None, headerlist=None, app_iter=None, request=None, content_type=None, conditional_response=None, **kw)

  Represents a WSGI response

  `RequestClass`

    alias of `Request`

  `accept_ranges`

    Gets and sets the `Accept-Ranges` header (HTTP spec section 14.5).

  `age`

    Gets and sets the `Age` header (HTTP spec section 14.6). Converts it using int.

  `allow`

    Gets and sets the `Allow` header (HTTP spec section 14.7). Converts it using list.

  `app_iter`

    Returns the app_iter of the response.

    If body was set, this will create an app_iter from that body (a single-item list)

  `app_iter_range`(start, stop)

    Return a new app_iter built from the response app_iter, that serves up only the given `start:stop` range.

  `body`

    The body of the response, as a `str`. This will read in the entire app_iter if necessary.

  `body_file`

    A file-like object that can be used to write to the body. If you passed in a list app_iter, that app_iter will be modified by writes.

  `cache_control`

    Get/set/modify the Cache-Control header (HTTP spec section 14.9)

  `charset`

    Get/set the charset (in the Content-Type)

  `conditional_response_app`(environ, start_response)

    Like the normal __call__ interface, but checks conditional headers:

    - If-Modified-Since (304 Not Modified; only on GET, HEAD)
    - If-None-Match (304 Not Modified; only on GET, HEAD)
    - Range (406 Partial Content; only on GET, HEAD)
  `content_disposition`

    Gets and sets the `Content-Disposition` header (HTTP spec section 19.5.1).

  `content_encoding`

    Gets and sets the `Content-Encoding` header (HTTP spec section 14.11).

  `content_language`

    Gets and sets the `Content-Language` header (HTTP spec section 14.12). Converts it using list.

  `content_length`

    Gets and sets the `Content-Length` header (HTTP spec section 14.17). Converts it using int.

  `content_location`

    Gets and sets the `Content-Location` header (HTTP spec section 14.14).

  `content_md5`

    Gets and sets the `Content-MD5` header (HTTP spec section 14.14).

  `content_range`

    Gets and sets the `Content-Range` header (HTTP spec section 14.16). Converts it using ContentRange object.

  `content_type`

    Get/set the Content-Type header (or None), without the charset or any parameters.

    If you include parameters (or `;` at all) when setting the content_type, any existing parameters will be deleted; otherwise they will be preserved.

  `content_type_params`

    A dictionary of all the parameters in the content type.

    (This is not a view, set to change, modifications of the dict would not be applied otherwise)

  `copy`()

    Makes a copy of the response

  `date`

    Gets and sets the `Date` header (HTTP spec section 14.18). Converts it using HTTP date.

  `delete_cookie`(key, path='/', domain=None)

    Delete a cookie from the client. Note that path and domain must match how the cookie was originally set.

    This sets the cookie to the empty string, and max_age=0 so that it should expire immediately.

  `encode_content`(encoding='gzip', lazy=False)

    Encode the content with the given encoding (only gzip and identity are supported).

  `environ`

    Get/set the request environ associated with this response, if any.

  `etag`

    Gets and sets the `ETag` header (HTTP spec section 14.19). Converts it using Entity tag.

  `expires`

    Gets and sets the `Expires` header (HTTP spec section 14.21). Converts it using HTTP date.

  classmethod `from_file`(fp)

    Reads a response from a file-like object (it must implement `.read(size)` and `.readline()`).

    It will read up to the end of the response, not the end of the file.

    This reads the response as represented by `str(resp)`; it may not read every valid HTTP response properly. Responses must have a `Content-Length`

  `headerlist`

    The list of response headers

  `headers`

    The headers in a dictionary-like object

  `last_modified`

    Gets and sets the `Last-Modified` header (HTTP spec section 14.29). Converts it using HTTP date.

  `location`

    Gets and sets the `Location` header (HTTP spec section 14.30).

  `md5_etag`(body=None, set_content_md5=False)

    Generate an etag for the response object using an MD5 hash of the body (the body parameter, or `self.body` if not given)

    Sets `self.etag` If `set_content_md5` is True sets `self.content_md5` as well

  `merge_cookies`(resp)

    Merge the cookies that were set on this response with the given resp object (which can be any WSGI application).

    If the resp is a `webob.Response` object, then the other object will be modified in-place.

  `pragma`

    Gets and sets the `Pragma` header (HTTP spec section 14.32).

  `request`

    Return the request associated with this response if any.

  `retry_after`

    Gets and sets the `Retry-After` header (HTTP spec section 14.37). Converts it using HTTP date or delta seconds.

  `server`

    Gets and sets the `Server` header (HTTP spec section 14.38).

  `set_cookie`(key, value='', max_age=None, path='/', domain=None, secure=False, httponly=False, comment=None, expires=None, overwrite=False)

    Set (add) a cookie for the response

  `status`

    The status string

  `status_int`

    The status as an integer

  `text`

    Get/set the unicode value of the body (using the charset of the Content-Type)

  `ubody`

    Deprecated alias for .text

  `unicode_body`

    Deprecated alias for .text

  `unset_cookie`(key, strict=True)

    Unset a cookie with the given name (remove it from the response).

  `vary`

    Gets and sets the `Vary` header (HTTP spec section 14.44). Converts it using list.

  `www_authenticate`

    Gets and sets the `WWW-Authenticate` header (HTTP spec section 14.47). Converts it using `parse_auth` and `serialize_auth`.

`webob.``html_escape`(s)

  HTML-escape a string or object

  This converts any non-string objects passed into it to strings (actually, using `unicode()`). All values returned are non-unicode strings (using `&#num;` entities for all non-ASCII characters).

  None is treated specially, and returns the empty string.

`webob.``timedelta_to_seconds`(td)

  Converts a timedelta instance to seconds.

### `webob.acceptparse`

class `webob.acceptparse.``Accept`(header_value)

  Represents a generic `Accept-*` style header.

  This object should not be modified. To add items you can use `accept_obj + 'accept_thing'` to get a new object

  `best_match`(offers, default_match=None)

    Returns the best match in the sequence of offered types.

    The sequence can be a simple sequence, or you can have `(match, server_quality)` items in the sequence. If you have these tuples then the client quality is multiplied by the server_quality to get a total. If two matches have equal weight, then the one that shows up first in the offers list will be returned.

    But among matches with the same quality the match to a more specific requested type will be chosen. For example a match to text/* trumps /.

    default_match (default None) is returned if there is no intersection.

  `best_matches`(fallback=None)

    Return all the matches in order of quality, with fallback (if given) at the end.

  `first_match`(offers)

    DEPRECATED Returns the first allowed offered type. Ignores quality. Returns the first offered type if nothing else matches; or if you include None at the end of the match list then that will be returned.

  static `parse`(value)

    Parse `Accept-*` style header.

    Return iterator of `(value, quality)` pairs. `quality` defaults to 1.

  `quality`(offer, modifier=1)

    Return the quality of the given offer. Returns None if there is no match (not 0).

class `webob.acceptparse.``NilAccept`

  Represents an Accept header with no value.

  `MasterClass`

    alias of `Accept`

class `webob.acceptparse.``NoAccept`

class `webob.acceptparse.``MIMEAccept`(header_value)

  Represents the `Accept` header, which is a list of mimetypes.

  This class knows about mime wildcards, like `image/*`

  `accept_html`()

    Returns true if any HTML-like type is accepted

  `accepts_html`

    Returns true if any HTML-like type is accepted

class `webob.acceptparse.``MIMENilAccept`
  `MasterClass`

    alias of `MIMEAccept`

### `webob.byterange`

class `webob.byterange.``Range`(ranges)

  Represents the Range header.

  This only represents `bytes` ranges, which are the only kind specified in HTTP. This can represent multiple sets of ranges, but no place else is this multi-range facility supported.

  `content_range`(length)

    Works like range_for_length; returns None or a ContentRange object

    You can use it like:

        response.content_range = req.range.content_range(response.content_length)

    Though it’s still up to you to actually serve that content range!

  classmethod `parse`(header)

    Parse the header; may return None if header is invalid

  static `parse_bytes`(header)

    Parse a Range header into (bytes, list_of_ranges). ranges in list_of_ranges are non-inclusive (unlike the HTTP header).

    Will return None if the header is invalid

  `range_for_length`(length)

    If there is only one range, and if it is satisfiable by the given length, then return a (begin, end) non-inclusive range of bytes to serve. Otherwise return None

  `satisfiable`(length)

    Returns true if this range can be satisfied by the resource with the given byte length.

class `webob.byterange.``ContentRange`(start, stop, length)

  Represents the Content-Range header

  This header is `start-stop/length`, where start-stop and length can be `*` (represented as None in the attributes).

  classmethod `parse`(value)

    Parse the header. May return None if it cannot parse.

### `webob.cachecontrol`

Represents the Cache-Control header

class `webob.cachecontrol.``exists_property`(prop, type=None)

  Represents a property that either is listed in the Cache-Control header, or is not listed (has no value)

class `webob.cachecontrol.``value_property`(prop, default=None, none=None, type=None)

  Represents a property that has a value in the Cache-Control header.

  When no value is actually given, the value of self.none is returned.

class `webob.cachecontrol.``CacheControl`(properties, type)

  Represents the Cache-Control header.

  By giving a type of `'request'` or `'response'` you can control what attributes are allowed (some Cache-Control values only apply to requests or responses).

  `copy`()

    Returns a copy of this object.

  classmethod `parse`(header, updates_to=None, type=None)

    Parse the header, returning a CacheControl object.

    The object is bound to the request or response object `updates_to`, if that is given.

  `update_dict`

    alias of `UpdateDict`

`webob.cachecontrol.``serialize_cache_control`(properties)

### `webob.etag`

Does parsing of ETag-related headers: If-None-Matches, If-Matches

Also If-Range parsing

`webob.etag.``AnyETag`

`webob.etag.``NoETag`

class `webob.etag.``ETagMatcher`(etags, weak_etags=())

  Represents an ETag request. Supports containment to see if an ETag matches. You can also use `etag_matcher.weak_contains(etag)` to allow weak ETags to match (allowable for conditional GET requests, but not ranges or other methods).

  classmethod `parse`(value)

    Parse this from a header value

class `webob.etag.``IfRange`(etag=None, date=None)

  Parses and represents the If-Range header, which can be an ETag or a date

  `match`(etag=None, last_modified=None)

    Return True if the If-Range header matches the given etag or last_modified

  `match_response`(response)

    Return True if this matches the given `webob.Response` instance.

  classmethod `parse`(value)

    Parse this from a header value.

`webob.etag.``NoIfRange`

### mod:webob.exc

#### HTTP Exception

This module processes Python exceptions that relate to HTTP exceptions by defining a set of exceptions, all subclasses of HTTPException. Each exception, in addition to being a Python exception that can be raised and caught, is also a WSGI application and `webob.Response` object.

This module defines exceptions according to RFC 2068 [1] : codes with 100-300 are not really errors; 400’s are client errors, and 500’s are server errors. According to the WSGI specification [2] , the application can call `start_response` more then once only under two conditions: (a) the response has not yet been sent, or (b) if the second and subsequent invocations of `start_response` have a valid `exc_info` argument obtained from `sys.exc_info()`. The WSGI specification then requires the server or gateway to handle the case where content has been sent and then an exception was encountered.

Exception
  HTTPException
    HTTPOk
      - 200 - HTTPOk
      - 201 - HTTPCreated
      - 202 - HTTPAccepted
      - 203 - HTTPNonAuthoritativeInformation
      - 204 - HTTPNoContent
      - 205 - HTTPResetContent
      - 206 - HTTPPartialContent
    HTTPRedirection
      - 300 - HTTPMultipleChoices
      - 301 - HTTPMovedPermanently
      - 302 - HTTPFound
      - 303 - HTTPSeeOther
      - 304 - HTTPNotModified
      - 305 - HTTPUseProxy
      - 306 - Unused (not implemented, obviously)
      - 307 - HTTPTemporaryRedirect
    HTTPError
      HTTPClientError
        - 400 - HTTPBadRequest
        - 401 - HTTPUnauthorized
        - 402 - HTTPPaymentRequired
        - 403 - HTTPForbidden
        - 404 - HTTPNotFound
        - 405 - HTTPMethodNotAllowed
        - 406 - HTTPNotAcceptable
        - 407 - HTTPProxyAuthenticationRequired
        - 408 - HTTPRequestTimeout
        - 409 - HTTPConflict
        - 410 - HTTPGone
        - 411 - HTTPLengthRequired
        - 412 - HTTPPreconditionFailed
        - 413 - HTTPRequestEntityTooLarge
        - 414 - HTTPRequestURITooLong
        - 415 - HTTPUnsupportedMediaType
        - 416 - HTTPRequestRangeNotSatisfiable
        - 417 - HTTPExpectationFailed
      HTTPServerError
        - 500 - HTTPInternalServerError
        - 501 - HTTPNotImplemented
        - 502 - HTTPBadGateway
        - 503 - HTTPServiceUnavailable
        - 504 - HTTPGatewayTimeout
        - 505 - HTTPVersionNotSupported

#### Subclass usage notes:

The HTTPException class is complicated by 4 factors:

> 1. The content given to the exception may either be plain-text or as html-text.
> 2. The template may want to have string-substitutions taken from the current `environ` or values from incoming headers. This is especially troublesome due to case sensitivity.
> 3. The final output may either be text/plain or text/html mime-type as requested by the client application.
> 4. Each exception has a default explanation, but those who raise exceptions may want to provide additional detail.

Subclass attributes and call parameters are designed to provide an easier path through the complications.

Attributes:

> `code`
>   the HTTP status code for the exception
> `title`
>   remainder of the status line (stuff after the code)
> `explanation`
>   a plain-text explanation of the error message that is not subject to environment or header substitutions; it is accessible in the template via %(explanation)s
> `detail`
>   a plain-text message customization that is not subject to environment or header substitutions; accessible in the template via %(detail)s
> `body_template`
>   a content fragment (in HTML) used for environment and header substitution; the default template includes both the explanation and further detail provided in the message

Parameters:

> `detail`
>   a plain-text override of the default `detail`
> `headers`
>   a list of (k,v) header pairs
> `comment`
>   a plain-text additional information which is usually stripped/hidden for end-users
> `body_template`
>   a string.Template object containing a content fragment in HTML that frames the explanation and further detail

To override the template (which is HTML content) or the plain-text explanation, one must subclass the given exception; or customize it after it has been created. This particular breakdown of a message into explanation, detail and template allows both the creation of plain-text and html messages for various clients as well as error-free substitution of environment variables and headers.

The subclasses of `_HTTPMove` (`HTTPMultipleChoices`, `HTTPMovedPermanently`, `HTTPFound`, `HTTPSeeOther`, `HTTPUseProxy` and `HTTPTemporaryRedirect`) are redirections that require a `Location` field. Reflecting this, these subclasses have two additional keyword arguments: `location` and `add_slash`.

Parameters:

> `location`
>   to set the location immediately
> `add_slash`
>   set to True to redirect to the same URL as the request, except with a `/` appended

Relative URLs in the location will be resolved to absolute.

References:

[1] | http://www.python.org/peps/pep-0333.html#error-handling

[2] | http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5

`webob.exc.``no_escape`(value)

`webob.exc.``strip_tags`(value)

class `webob.exc.``HTTPException`(message, wsgi_response)

class `webob.exc.``WSGIHTTPException`(detail=None, headers=None, comment=None, body_template=None, **kw)

class `webob.exc.``HTTPError`(detail=None, headers=None, comment=None, body_template=None, **kw)

  base class for status codes in the 400’s and 500’s

  This is an exception which indicates that an error has occurred, and that any work in progress should not be committed. These are typically results in the 400’s and 500’s.

class `webob.exc.``HTTPRedirection`(detail=None, headers=None, comment=None, body_template=None, **kw)

  base class for 300’s status code (redirections)

  This is an abstract base class for 3xx redirection. It indicates that further action needs to be taken by the user agent in order to fulfill the request. It does not necessarly signal an error condition.

class `webob.exc.``HTTPOk`(detail=None, headers=None, comment=None, body_template=None, **kw)

  Base class for the 200’s status code (successful responses)

  code: 200, title: OK

class `webob.exc.``HTTPCreated`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that request has been fulfilled and resulted in a new resource being created.

  code: 201, title: Created

class `webob.exc.``HTTPAccepted`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that the request has been accepted for processing, but the processing has not been completed.

  code: 202, title: Accepted

class `webob.exc.``HTTPNonAuthoritativeInformation`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that the returned metainformation in the entity-header is not the definitive set as available from the origin server, but is gathered from a local or a third-party copy.

  code: 203, title: Non-Authoritative Information

class `webob.exc.``HTTPNoContent`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that the server has fulfilled the request but does not need to return an entity-body, and might want to return updated metainformation.

  code: 204, title: No Content

class `webob.exc.``HTTPResetContent`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that the the server has fulfilled the request and the user agent SHOULD reset the document view which caused the request to be sent.

  code: 205, title: Reset Content

class `webob.exc.``HTTPPartialContent`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPOk`

  This indicates that the server has fulfilled the partial GET request for the resource.

  code: 206, title: Partial Content

class `webob.exc.``HTTPMultipleChoices`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the requested resource corresponds to any one of a set of representations, each with its own specific location, and agent-driven negotiation information is being provided so that the user can select a preferred representation and redirect its request to that location.

  code: 300, title: Multiple Choices

class `webob.exc.``HTTPMovedPermanently`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the requested resource has been assigned a new permanent URI and any future references to this resource SHOULD use one of the returned URIs.

  code: 301, title: Moved Permanently

class `webob.exc.``HTTPFound`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the requested resource resides temporarily under a different URI.

  code: 302, title: Found

class `webob.exc.``HTTPSeeOther`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the response to the request can be found under a different URI and SHOULD be retrieved using a GET method on that resource.

  code: 303, title: See Other

class `webob.exc.``HTTPNotModified`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPRedirection`

  This indicates that if the client has performed a conditional GET request and access is allowed, but the document has not been modified, the server SHOULD respond with this status code.

  code: 304, title: Not Modified

class `webob.exc.``HTTPUseProxy`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the requested resource MUST be accessed through the proxy given by the Location field.

  code: 305, title: Use Proxy

class `webob.exc.``HTTPTemporaryRedirect`(detail=None, headers=None, comment=None, body_template=None, location=None, add_slash=False)

  subclass of `_HTTPMove`

  This indicates that the requested resource resides temporarily under a different URI.

  code: 307, title: Temporary Redirect

class `webob.exc.``HTTPClientError`(detail=None, headers=None, comment=None, body_template=None, **kw)

  base class for the 400’s, where the client is in error

  This is an error condition in which the client is presumed to be in-error. This is an expected problem, and thus is not considered a bug. A server-side traceback is not warranted. Unless specialized, this is a ‘400 Bad Request’

class `webob.exc.``HTTPBadRequest`(detail=None, headers=None, comment=None, body_template=None, **kw)

class `webob.exc.``HTTPUnauthorized`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the request requires user authentication.

  code: 401, title: Unauthorized

class `webob.exc.``HTTPPaymentRequired`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  code: 402, title: Payment Required

class `webob.exc.``HTTPForbidden`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server understood the request, but is refusing to fulfill it.

  code: 403, title: Forbidden

class `webob.exc.``HTTPNotFound`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server did not find anything matching the Request-URI.

  code: 404, title: Not Found

class `webob.exc.``HTTPMethodNotAllowed`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the method specified in the Request-Line is not allowed for the resource identified by the Request-URI.

  code: 405, title: Method Not Allowed

class `webob.exc.``HTTPNotAcceptable`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates the resource identified by the request is only capable of generating response entities which have content characteristics not acceptable according to the accept headers sent in the request.

  code: 406, title: Not Acceptable

class `webob.exc.``HTTPProxyAuthenticationRequired`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This is similar to 401, but indicates that the client must first authenticate itself with the proxy.

  code: 407, title: Proxy Authentication Required

class `webob.exc.``HTTPRequestTimeout`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the client did not produce a request within the time that the server was prepared to wait.

  code: 408, title: Request Timeout

class `webob.exc.``HTTPConflict`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the request could not be completed due to a conflict with the current state of the resource.

  code: 409, title: Conflict

class `webob.exc.``HTTPGone`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the requested resource is no longer available at the server and no forwarding address is known.

  code: 410, title: Gone

class `webob.exc.``HTTPLengthRequired`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the the server refuses to accept the request without a defined Content-Length.

  code: 411, title: Length Required

class `webob.exc.``HTTPPreconditionFailed`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the precondition given in one or more of the request-header fields evaluated to false when it was tested on the server.

  code: 412, title: Precondition Failed

class `webob.exc.``HTTPRequestEntityTooLarge`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server is refusing to process a request because the request entity is larger than the server is willing or able to process.

  code: 413, title: Request Entity Too Large

class `webob.exc.``HTTPRequestURITooLong`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server is refusing to service the request because the Request-URI is longer than the server is willing to interpret.

  code: 414, title: Request-URI Too Long

class `webob.exc.``HTTPUnsupportedMediaType`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server is refusing to service the request because the entity of the request is in a format not supported by the requested resource for the requested method.

  code: 415, title: Unsupported Media Type

class `webob.exc.``HTTPRequestRangeNotSatisfiable`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  The server SHOULD return a response with this status code if a request included a Range request-header field, and none of the range-specifier values in this field overlap the current extent of the selected resource, and the request did not include an If-Range request-header field.

  code: 416, title: Request Range Not Satisfiable

class `webob.exc.``HTTPExpectationFailed`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indidcates that the expectation given in an Expect request-header field could not be met by this server.

  code: 417, title: Expectation Failed

class `webob.exc.``HTTPUnprocessableEntity`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the server is unable to process the contained instructions. Only for WebDAV.

  code: 422, title: Unprocessable Entity

class `webob.exc.``HTTPLocked`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the resource is locked. Only for WebDAV

  code: 423, title: Locked

class `webob.exc.``HTTPFailedDependency`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPClientError`

  This indicates that the method could not be performed because the requested action depended on another action and that action failed. Only for WebDAV.

  code: 424, title: Failed Dependency

class `webob.exc.``HTTPServerError`(detail=None, headers=None, comment=None, body_template=None, **kw)

  base class for the 500’s, where the server is in-error

  This is an error condition in which the server is presumed to be in-error. This is usually unexpected, and thus requires a traceback; ideally, opening a support ticket for the customer. Unless specialized, this is a ‘500 Internal Server Error’

class `webob.exc.``HTTPInternalServerError`(detail=None, headers=None, comment=None, body_template=None, **kw)

class `webob.exc.``HTTPNotImplemented`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server does not support the functionality required to fulfill the request.

  code: 501, title: Not Implemented

class `webob.exc.``HTTPBadGateway`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request.

  code: 502, title: Bad Gateway

class `webob.exc.``HTTPServiceUnavailable`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server is currently unable to handle the request due to a temporary overloading or maintenance of the server.

  code: 503, title: Service Unavailable

class `webob.exc.``HTTPGatewayTimeout`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI (e.g. HTTP, FTP, LDAP) or some other auxiliary server (e.g. DNS) it needed to access in attempting to complete the request.

  code: 504, title: Gateway Timeout

class `webob.exc.``HTTPVersionNotSupported`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server does not support, or refuses to support, the HTTP protocol version that was used in the request message.

  code: 505, title: HTTP Version Not Supported

class `webob.exc.``HTTPInsufficientStorage`(detail=None, headers=None, comment=None, body_template=None, **kw)

  subclass of `HTTPServerError`

  This indicates that the server does not have enough space to save the resource.

  code: 507, title: Insufficient Storage

class `webob.exc.``HTTPExceptionMiddleware`(application)

  Middleware that catches exceptions in the sub-application. This does not catch exceptions in the app_iter; only during the initial calling of the application.

  This should be put very close to applications that might raise these exceptions. This should not be applied globally; letting expected exceptions raise through the WSGI stack is dangerous.

### `webob.multidict`

Gives a multi-value dictionary object (MultiDict) plus several wrappers

class `webob.multidict.``MultiDict`(*args, **kw)

  An ordered dictionary that can have multiple values for each key. Adds the methods getall, getone, mixed and extend and add to the normal dictionary interface.

  `add`(key, value)

    Add the key and value, not overwriting any previous value.

  `dict_of_lists`()

    Returns a dictionary where each key is associated with a list of values.

  classmethod `from_fieldstorage`(fs)

    Create a dict from a cgi.FieldStorage instance

  `getall`(key)

    Return a list of all values matching the key (may be an empty list)

  `getone`(key)

    Get one value matching the key, raising a KeyError if multiple values were found.

  `mixed`()

    Returns a dictionary where the values are either single values, or a list of values when a key/value appears more than once in this dictionary. This is similar to the kind of dictionary often used to represent the variables in a web request.

  classmethod `view_list`(lst)

    Create a dict that is a view on the given list

class `webob.multidict.``UnicodeMultiDict`(multi, encoding=None, errors='strict', decode_keys=False)

  A MultiDict wrapper that decodes returned values to unicode on the fly. Decoding is not applied to assigned values.

  The key/value contents are assumed to be `str`/`strs` or `str`/`FieldStorages` (as is returned by the `paste.request.parse_` functions).

  Can optionally also decode keys when the `decode_keys` argument is True.

  `FieldStorage` instances are cloned, and the clone’s `filename` variable is decoded. Its `name` variable is decoded when `decode_keys` is enabled.

  `add`(key, value)

    Add the key and value, not overwriting any previous value.

  `dict_of_lists`()

    Returns a dictionary where each key is associated with a list of values.

  `getall`(key)

    Return a list of all values matching the key (may be an empty list)

  `getone`(key)

    Get one value matching the key, raising a KeyError if multiple values were found.

  `mixed`()

    Returns a dictionary where the values are either single values, or a list of values when a key/value appears more than once in this dictionary. This is similar to the kind of dictionary often used to represent the variables in a web request.

class `webob.multidict.``NestedMultiDict`(*dicts)

  Wraps several MultiDict objects, treating it as one large MultiDict

class `webob.multidict.``NoVars`(reason=None)

  Represents no variables; used when no variables are applicable.

  This is read-only

### `webob.request`

class `webob.request.``FakeCGIBody`(vars, content_type)

`webob.request.``_cgi_FieldStorage__repr__patch`(self)

  monkey patch for FieldStorage.__repr__

  Unbelievably, the default __repr__ on FieldStorage reads the entire file content instead of being sane about it. This is a simple replacement that doesn’t do that

### `webob.response`

class `webob.response.``ResponseBodyFile`(response)
  `encoding`

    The encoding of the file (inherited from response.charset)

class `webob.response.``AppIterRange`(app_iter, start, stop)

  Wraps an app_iter, returning just a range of bytes