Python _cpcompat.SimpleCookie类代码示例

 def __init__(self):
     self.status = None
     self.header_list = None
     self._body = []
     self.time = time.time()
     self.headers = httputil.HeaderMap()
     dict.update(self.headers, {'Content-Type': 'text/html',
      'Server': 'CherryPy/' + cherrypy.__version__,
      'Date': httputil.HTTPDate(self.time)})
     self.cookie = SimpleCookie()

    def run(self, method, path, query_string, req_protocol, headers, rfile):
        response = cherrypy.serving.response
        self.stage = 'run'
        try:
            self.error_response = cherrypy.HTTPError(500).set_response
            self.method = method
            path = path or '/'
            self.query_string = query_string or ''
            self.params = {}
            rp = (int(req_protocol[5]), int(req_protocol[7]))
            sp = (int(self.server_protocol[5]), int(self.server_protocol[7]))
            self.protocol = min(rp, sp)
            response.headers.protocol = self.protocol
            url = path
            if query_string:
                url += '?' + query_string
            self.request_line = '%s %s %s' % (method, url, req_protocol)
            self.header_list = list(headers)
            self.headers = httputil.HeaderMap()
            self.rfile = rfile
            self.body = None
            self.cookie = SimpleCookie()
            self.handler = None
            self.script_name = self.app.script_name
            self.path_info = pi = path[len(self.script_name):]
            self.stage = 'respond'
            self.respond(pi)
        except self.throws:
            raise
        except:
            if self.throw_errors:
                raise
            else:
                cherrypy.log(traceback=True, severity=40)
                if self.show_tracebacks:
                    body = format_exc()
                else:
                    body = ''
                r = bare_error(body)
                response.output_status, response.header_list, response.body = r

        if self.method == 'HEAD':
            response.body = []
        try:
            cherrypy.log.access()
        except:
            cherrypy.log.error(traceback=True)

        if response.timed_out:
            raise cherrypy.TimeoutError()
        return response

    def __init__(self):
        self.status = None
        self.header_list = None
        self._body = []
        self.time = time.time()

        self.headers = httputil.HeaderMap()
        # Since we know all our keys are titled strings, we can
        # bypass HeaderMap.update and get a big speed boost.
        dict.update(self.headers, {
            'Content-Type': 'text/html',
            'Server': 'CherryPy/' + cherrypy.__version__,
            'Date': httputil.HTTPDate(self.time),
        })
        self.cookie = SimpleCookie()

class Response(object):
    """An HTTP Response, including status, headers, and body."""

    status = ""
    """The HTTP Status-Code and Reason-Phrase."""

    header_list = []
    """
    A list of the HTTP response headers as (name, value) tuples.
    In general, you should use response.headers (a dict) instead. This
    attribute is generated from response.headers and is not valid until
    after the finalize phase."""

    headers = httputil.HeaderMap()
    """
    A dict-like object containing the response headers. Keys are header
    names (in Title-Case format); however, you may get and set them in
    a case-insensitive manner. That is, headers['Content-Type'] and
    headers['content-type'] refer to the same value. Values are header
    values (decoded according to :rfc:`2047` if necessary).

    .. seealso:: classes :class:`HeaderMap`, :class:`HeaderElement`
    """

    cookie = SimpleCookie()
    """See help(Cookie)."""

    body = ResponseBody()
    """The body (entity) of the HTTP response."""

    time = None
    """The value of time.time() when created. Use in HTTP dates."""

    timeout = 300
    """Seconds after which the response will be aborted."""

    timed_out = False
    """
    Flag to indicate the response should be aborted, because it has
    exceeded its timeout."""

    stream = False
    """If False, buffer the response body."""

    def __init__(self):
        self.status = None
        self.header_list = None
        self._body = []
        self.time = time.time()

        self.headers = httputil.HeaderMap()
        # Since we know all our keys are titled strings, we can
        # bypass HeaderMap.update and get a big speed boost.
        dict.update(
            self.headers,
            {
                "Content-Type": "text/html",
                "Server": "CherryPy/" + cherrypy.__version__,
                "Date": httputil.HTTPDate(self.time),
            },
        )
        self.cookie = SimpleCookie()

    def collapse_body(self):
        """Collapse self.body to a single string; replace it and return it."""
        if isinstance(self.body, basestring):
            return self.body

        newbody = []
        for chunk in self.body:
            if py3k and not isinstance(chunk, bytes):
                raise TypeError("Chunk %s is not of type 'bytes'." % repr(chunk))
            newbody.append(chunk)
        newbody = ntob("").join(newbody)

        self.body = newbody
        return newbody

    def finalize(self):
        """Transform headers (and cookies) into self.header_list. (Core)"""
        try:
            code, reason, _ = httputil.valid_status(self.status)
        except ValueError:
            raise cherrypy.HTTPError(500, sys.exc_info()[1].args[0])

        headers = self.headers

        self.status = "%s %s" % (code, reason)
        self.output_status = ntob(str(code), "ascii") + ntob(" ") + headers.encode(reason)

        if self.stream:
            # The upshot: wsgiserver will chunk the response if
            # you pop Content-Length (or set it explicitly to None).
            # Note that lib.static sets C-L to the file's st_size.
            if dict.get(headers, "Content-Length") is None:
                dict.pop(headers, "Content-Length", None)
        elif code < 200 or code in (204, 205, 304):
            # "All 1xx (informational), 204 (no content),
            # and 304 (not modified) responses MUST NOT
            # include a message-body."
#.........这里部分代码省略.........

    def run(self, method, path, query_string, req_protocol, headers, rfile):
        r"""Process the Request. (Core)

        method, path, query_string, and req_protocol should be pulled directly
        from the Request-Line (e.g. "GET /path?key=val HTTP/1.0").

        path
            This should be %XX-unquoted, but query_string should not be.

            When using Python 2, they both MUST be byte strings,
            not unicode strings.

            When using Python 3, they both MUST be unicode strings,
            not byte strings, and preferably not bytes \x00-\xFF
            disguised as unicode.

        headers
            A list of (name, value) tuples.

        rfile
            A file-like object containing the HTTP request entity.

        When run() is done, the returned object should have 3 attributes:

          * status, e.g. "200 OK"
          * header_list, a list of (name, value) tuples
          * body, an iterable yielding strings

        Consumer code (HTTP servers) should then access these response
        attributes to build the outbound stream.

        """
        response = cherrypy.serving.response
        self.stage = "run"
        try:
            self.error_response = cherrypy.HTTPError(500).set_response

            self.method = method
            path = path or "/"
            self.query_string = query_string or ""
            self.params = {}

            # Compare request and server HTTP protocol versions, in case our
            # server does not support the requested protocol. Limit our output
            # to min(req, server). We want the following output:
            #     request    server     actual written   supported response
            #     protocol   protocol  response protocol    feature set
            # a     1.0        1.0           1.0                1.0
            # b     1.0        1.1           1.1                1.0
            # c     1.1        1.0           1.0                1.0
            # d     1.1        1.1           1.1                1.1
            # Notice that, in (b), the response will be "HTTP/1.1" even though
            # the client only understands 1.0. RFC 2616 10.5.6 says we should
            # only return 505 if the _major_ version is different.
            rp = int(req_protocol[5]), int(req_protocol[7])
            sp = int(self.server_protocol[5]), int(self.server_protocol[7])
            self.protocol = min(rp, sp)
            response.headers.protocol = self.protocol

            # Rebuild first line of the request (e.g. "GET /path HTTP/1.0").
            url = path
            if query_string:
                url += "?" + query_string
            self.request_line = "%s %s %s" % (method, url, req_protocol)

            self.header_list = list(headers)
            self.headers = httputil.HeaderMap()

            self.rfile = rfile
            self.body = None

            self.cookie = SimpleCookie()
            self.handler = None

            # path_info should be the path from the
            # app root (script_name) to the handler.
            self.script_name = self.app.script_name
            self.path_info = pi = path[len(self.script_name) :]

            self.stage = "respond"
            self.respond(pi)

        except self.throws:
            raise
        except:
            if self.throw_errors:
                raise
            else:
                # Failure in setup, error handler or finalize. Bypass them.
                # Can't use handle_error because we may not have hooks yet.
                cherrypy.log(traceback=True, severity=40)
                if self.show_tracebacks:
                    body = format_exc()
                else:
                    body = ""
                r = bare_error(body)
                response.output_status, response.header_list, response.body = r

        if self.method == "HEAD":
            # HEAD requests MUST NOT return a message-body in the response.
#.........这里部分代码省略.........

#.........这里部分代码省略.........
    encode back to bytes and re-decode to whatever encoding you like later.
    """

    protocol = (1, 1)
    """The HTTP protocol version corresponding to the set
    of features which should be allowed in the response. If BOTH
    the client's request message AND the server's level of HTTP
    compliance is HTTP/1.1, this attribute will be the tuple (1, 1).
    If either is 1.0, this attribute will be the tuple (1, 0).
    Lower HTTP protocol versions are not explicitly supported."""

    params = {}
    """
    A dict which combines query string (GET) and request entity (POST)
    variables. This is populated in two stages: GET params are added
    before the 'on_start_resource' hook, and POST params are added
    between the 'before_request_body' and 'before_handler' hooks."""

    # Message attributes
    header_list = []
    """
    A list of the HTTP request headers as (name, value) tuples.
    In general, you should use request.headers (a dict) instead."""

    headers = httputil.HeaderMap()
    """
    A dict-like object containing the request headers. Keys are header
    names (in Title-Case format); however, you may get and set them in
    a case-insensitive manner. That is, headers['Content-Type'] and
    headers['content-type'] refer to the same value. Values are header
    values (decoded according to :rfc:`2047` if necessary). See also:
    httputil.HeaderMap, httputil.HeaderElement."""

    cookie = SimpleCookie()
    """See help(Cookie)."""

    rfile = None
    """
    If the request included an entity (body), it will be available
    as a stream in this attribute. However, the rfile will normally
    be read for you between the 'before_request_body' hook and the
    'before_handler' hook, and the resulting string is placed into
    either request.params or the request.body attribute.

    You may disable the automatic consumption of the rfile by setting
    request.process_request_body to False, either in config for the desired
    path, or in an 'on_start_resource' or 'before_request_body' hook.

    WARNING: In almost every case, you should not attempt to read from the
    rfile stream after CherryPy's automatic mechanism has read it. If you
    turn off the automatic parsing of rfile, you should read exactly the
    number of bytes specified in request.headers['Content-Length'].
    Ignoring either of these warnings may result in a hung request thread
    or in corruption of the next (pipelined) request.
    """

    process_request_body = True
    """
    If True, the rfile (if any) is automatically read and parsed,
    and the result placed into request.params or request.body."""

    methods_with_bodies = ("POST", "PUT")
    """
    A sequence of HTTP methods for which CherryPy will automatically
    attempt to read a body from the rfile."""

class Response(object):
    status = ''
    header_list = []
    headers = httputil.HeaderMap()
    cookie = SimpleCookie()
    body = ResponseBody()
    time = None
    timeout = 300
    timed_out = False
    stream = False

    def __init__(self):
        self.status = None
        self.header_list = None
        self._body = []
        self.time = time.time()
        self.headers = httputil.HeaderMap()
        dict.update(self.headers, {'Content-Type': 'text/html',
         'Server': 'CherryPy/' + cherrypy.__version__,
         'Date': httputil.HTTPDate(self.time)})
        self.cookie = SimpleCookie()

    def collapse_body(self):
        if isinstance(self.body, basestring):
            return self.body
        newbody = ''.join([ chunk for chunk in self.body ])
        self.body = newbody
        return newbody

    def finalize(self):
        try:
            code, reason, _ = httputil.valid_status(self.status)
        except ValueError:
            raise cherrypy.HTTPError(500, sys.exc_info()[1].args[0])

        headers = self.headers
        self.output_status = ntob(str(code), 'ascii') + ntob(' ') + headers.encode(reason)
        if self.stream:
            if dict.get(headers, 'Content-Length') is None:
                dict.pop(headers, 'Content-Length', None)
        elif code < 200 or code in (204, 205, 304):
            dict.pop(headers, 'Content-Length', None)
            self.body = ntob('')
        elif dict.get(headers, 'Content-Length') is None:
            content = self.collapse_body()
            dict.__setitem__(headers, 'Content-Length', len(content))
        self.header_list = h = headers.output()
        cookie = self.cookie.output()
        if cookie:
            for line in cookie.split('\n'):
                if line.endswith('\r'):
                    line = line[:-1]
                name, value = line.split(': ', 1)
                if isinstance(name, unicodestr):
                    name = name.encode('ISO-8859-1')
                if isinstance(value, unicodestr):
                    value = headers.encode(value)
                h.append((name, value))

    def check_timeout(self):
        if time.time() > self.time + self.timeout:
            self.timed_out = True

class Request(object):
    prev = None
    local = httputil.Host('127.0.0.1', 80)
    remote = httputil.Host('127.0.0.1', 1111)
    scheme = 'http'
    server_protocol = 'HTTP/1.1'
    base = ''
    request_line = ''
    method = 'GET'
    query_string = ''
    query_string_encoding = 'utf8'
    protocol = (1, 1)
    params = {}
    header_list = []
    headers = httputil.HeaderMap()
    cookie = SimpleCookie()
    rfile = None
    process_request_body = True
    methods_with_bodies = ('POST', 'PUT')
    body = None
    dispatch = cherrypy.dispatch.Dispatcher()
    script_name = ''
    path_info = '/'
    login = None
    app = None
    handler = None
    toolmaps = {}
    config = None
    is_index = None
    hooks = HookMap(hookpoints)
    error_response = cherrypy.HTTPError(500).set_response
    error_page = {}
    show_tracebacks = True
    show_mismatched_params = True
    throws = (KeyboardInterrupt, SystemExit, cherrypy.InternalRedirect)
    throw_errors = False
    closed = False
    stage = None
    namespaces = _cpconfig.NamespaceSet(**{'hooks': hooks_namespace,
     'request': request_namespace,
     'response': response_namespace,
     'error_page': error_page_namespace,
     'tools': cherrypy.tools})

    def __init__(self, local_host, remote_host, scheme = 'http', server_protocol = 'HTTP/1.1'):
        self.local = local_host
        self.remote = remote_host
        self.scheme = scheme
        self.server_protocol = server_protocol
        self.closed = False
        self.error_page = self.error_page.copy()
        self.namespaces = self.namespaces.copy()
        self.stage = None

    def close(self):
        if not self.closed:
            self.closed = True
            self.stage = 'on_end_request'
            self.hooks.run('on_end_request')
            self.stage = 'close'

    def run(self, method, path, query_string, req_protocol, headers, rfile):
        response = cherrypy.serving.response
        self.stage = 'run'
        try:
            self.error_response = cherrypy.HTTPError(500).set_response
            self.method = method
            path = path or '/'
            self.query_string = query_string or ''
            self.params = {}
            rp = (int(req_protocol[5]), int(req_protocol[7]))
            sp = (int(self.server_protocol[5]), int(self.server_protocol[7]))
            self.protocol = min(rp, sp)
            response.headers.protocol = self.protocol
            url = path
            if query_string:
                url += '?' + query_string
            self.request_line = '%s %s %s' % (method, url, req_protocol)
            self.header_list = list(headers)
            self.headers = httputil.HeaderMap()
            self.rfile = rfile
            self.body = None
            self.cookie = SimpleCookie()
            self.handler = None
            self.script_name = self.app.script_name
            self.path_info = pi = path[len(self.script_name):]
            self.stage = 'respond'
            self.respond(pi)
        except self.throws:
            raise
        except:
            if self.throw_errors:
                raise
            else:
                cherrypy.log(traceback=True, severity=40)
                if self.show_tracebacks:
                    body = format_exc()
                else:
                    body = ''
                r = bare_error(body)
#.........这里部分代码省略.........