response = force_unicode(response.body).encode(settings.DEFAULT_CHARSET)

        response = force_unicode(response.body).encode(settings.DEFAULT_CHARSET)

        return int(response.body)

        response = force_unicode(response.body).encode(settings.DEFAULT_CHARSET)

        self.assertEqual(repr(response.body), '\'<?xml version="1.0" encoding="utf-8"?>\\n<django-test version="1.0">\\n <object pk="1" model="django_roa_server.remotepage">\\n  <field type="CharField" name="title">A custom serialized page</field>\\n </object>\\n</django-test>\'')

from restkit.httpc import HttpClient, HTTPResponse, ResponseStream

from restkit.rest import Resource, RestClient

from optparse import OptionParser

from urlparse import parse_qs as parse_qs

            self.query = parse_qs(parts[3])

        res = restkit.Resource(uri.uri)

        res.add_authorization(httpc.BasicAuth((uri.username, uri.password)))

    result = res.request(method, path=uri.path, payload=payload, headers=headers, **uri.query)

        return result.body

            for block in result.body_file:

                f.write(block)

                      help='the name of the file to write to')

import restkit

import warnings

class deprecated_property(object):

    """

    Wraps a decorator, with a deprecation warning or error

    """

    def __init__(self, decorator, attr, message, warning=True):

        self.decorator = decorator

        self.attr = attr

        self.message = message

        self.warning = warning

    def __get__(self, obj, type=None):

        if obj is None:

            return self

        self.warn()

        return self.decorator.__get__(obj, type)

    def __set__(self, obj, value):

        self.warn()

        self.decorator.__set__(obj, value)

    def __delete__(self, obj):

        self.warn()

        self.decorator.__delete__(obj)

    def __repr__(self):

        return '<Deprecated attribute %s: %r>' % (

            self.attr,

            self.decorator)

    def warn(self):

        if not self.warning:

            raise DeprecationWarning(

                'The attribute %s is deprecated: %s' % (self.attr, self.message))

        else:

            warnings.warn(

                'The attribute %s is deprecated: %s' % (self.attr, self.message),

                DeprecationWarning,

                stacklevel=3)

    """ default error class """

        self.status = http_code

    def _status_int__get(self):

        """

        The status as an integer

        """

        return self.status

    def _status_int__set(self, http_code):

        self.status = http_code

    status_int = property(_status_int__get, _status_int__set, doc=_status_int__get.__doc__)

    status_code = deprecated_property(

        status_int, 'status_code', 'use .status_int instead',

        warning=False)

            return str(self.__dict__)

class ProxyError(Exception):

    """ raised when proxy error happend"""

import time

import urlparse

from eventlet.green import httplib as ehttplib

import restkit

from restkit import errors

from restkit.pool import get_proxy_auth, PoolInterface

url_parser = urlparse.urlparse

eventlet_httplib = False

def wrap_eventlet_ehttplib():

    if eventlet_httplib: return

    import httplib

    ehttplib.BadStatusLine = httplib.BadStatusLine

wrap_eventlet_ehttplib()

class ConnectionPool(Pool, PoolInterface):

    def __init__(self, uri, use_proxy=False, key_file=None,

            cert_file=None, min_size=0, max_size=4, **kwargs):

        Pool.__init__(self, min_size, max_size)

        self.key_file = key_file

        self.cert_file = cert_file

    def _make_proxy_connection(self, proxy):

        if self.uri.scheme == 'https':

            proxy_auth = get_proxy_auth()

            if proxy_auth:

                proxy_auth = 'Proxy-authorization: %s' % proxy_auth

            port = self.uri.port

            if not port:

                port = 443

            proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % (self.uri.hostname, port)

            user_agent = 'User-Agent: %s\r\n' % restkit.USER_AGENT

            proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth, user_agent)

            proxy_uri = url_parser(proxy)

            if not proxy_uri.port:

                proxy_uri.port = '80'

            # Connect to the proxy server, very simple recv and error checking

            p_sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

            p_sock.connect((proxy_uri.host, int(proxy_uri.port)))

            p_sock.sendall(proxy_pieces)

            response = ''

            # Wait for the full response.

            while response.find("\r\n\r\n") == -1:

                response += p_sock.recv(8192)

            p_status = response.split()[1]

            if p_status != str(200):

                raise errors.ProxyError('Error status=%s' % str(p_status))

            # Trivial setup for ssl socket.

            ssl = socket.ssl(p_sock, None, None)

            fake_sock = ehttplib.FakeSocket(p_sock, ssl)

            # Initalize ehttplib and replace with the proxy socket.

            connection = ehttplib.HTTPConnection(proxy_uri.host)

            connection.sock=fake_sock

            return connection

        else:

            proxy_uri = url_parser(proxy)

            if not proxy_uri.port:

                proxy_uri.port = '80'

            return ehttplib.HTTPConnection(proxy_uri.hostname, proxy_uri.port)

        return None

    def make_connection(self):

        if self.use_proxy:

            proxy = ''

            if self.uri.scheme == 'https':

                proxy = os.environ.get('https_proxy')

            elif self.uri.scheme == 'http':

                proxy = os.environ.get('http_proxy')

            if proxy:

                return self._make_proxy_connection(proxy)

        kwargs = {}

        if hasattr(ehttplib.HTTPConnection, 'timeout'):

            kwargs['timeout'] = self.timeout

        if self.uri.port:

            kwargs['port'] = self.uri.port

        if self.uri.scheme == "https":

            kwargs.update(dict(key_file=self.key_file, cert_file=self.cert_file))

            connection = ehttplib.HTTPSConnection(self.uri.hostname, **kwargs)

        else:

            connection = ehttplib.HTTPConnection(self.uri.hostname, **kwargs)

        setattr(connection, "started", time.time())

        return connection

        return self.make_connection()

    def clear(self):

        self.free()

# -*- coding: utf-8 -

#

# Copyright (c) 2008, 2009 Benoit Chesneau <benoitc@e-engura.com> 

#

# Permission to use, copy, modify, and distribute this software for any

# purpose with or without fee is hereby granted, provided that the above

# copyright notice and this permission notice appear in all copies.

#

# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

import restkit.errors

import webob.exc

class WebobResourceError(webob.exc.WSGIHTTPException):

    def __init__(self, msg=None, http_code=None, response=None):

        webob.exc.WSGIHTTPException.__init__(self)

        http_code = http_code or 500

        klass = webob.exc.status_map[http_code]

        self.code = http_code

        self.title = klass.title

        self.status = '%s %s' % (self.code, self.title)

        self.explanation = msg

        self.response = response

        # default params

        self.msg = msg

    def _status_int__get(self):

        """

        The status as an integer

        """

        return int(self.status.split()[0])

    def _status_int__set(self, value):

        self.status = value

    status_int = property(_status_int__get, _status_int__set, doc=_status_int__get.__doc__)

    status_code = restkit.errors.deprecated_property(

        status_int, 'status_code', 'use .status_int instead',

        warning=False)

    def _get_message(self):

        return self.explanation

    def _set_message(self, msg):

        self.explanation = msg or ''

    message = property(_get_message, _set_message)

webob_exceptions = False

def wrap_exceptions():

    """ wrap restkit exception to return WebBob exceptions"""

    global webob_exceptions

    if webob_exceptions: return

    restkit.errors.ResourceError = WebobResourceError

    webob_exceptions = True

# -*- coding: utf-8 -

#

# Copyright (c) 2008, 2009 Benoit Chesneau <benoitc@e-engura.com> 

#

# Permission to use, copy, modify, and distribute this software for any

# purpose with or without fee is hereby granted, provided that the above

# copyright notice and this permission notice appear in all copies.

#

# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#

import mimetypes

import os

import re

import urllib

from restkit.utils import to_bytestring, url_quote

MIME_BOUNDARY = 'END_OF_PART'

def form_encode(obj, charser="utf8"):

    tmp = []

    for key, value in obj.items():

        tmp.append("%s=%s" % (url_quote(key), 

                url_quote(value)))

    return to_bytestring("&".join(tmp))

class BoundaryItem(object):

    def __init__(self, name, value, fname=None, filetype=None, filesize=None):

        self.name = url_quote(name)

        if value is not None and not hasattr(value, 'read'):

            value = url_quote(value)

            self.size = len(value)

        self.value = value

        if fname is not None:

            if isinstance(fname, unicode):

                fname = fname.encode("utf-8").encode("string_escape").replace('"', '\\"')

            else:

                fname = fname.encode("string_escape").replace('"', '\\"')

        self.fname = fname

        if filetype is not None:

            filetype = to_bytestring(filetype)

        self.filetype = filetype

        if isinstance(value, file) and filesize is None:

            try:

                value.flush()

            except IOError:

                pass

            self.size = int(os.fstat(value.fileno())[6])

    def encode_hdr(self, boundary):

        """Returns the header of the encoding of this parameter"""

        boundary = url_quote(boundary)

        headers = ["--%s" % boundary]

        if self.fname:

            disposition = 'form-data; name="%s"; filename="%s"' % (self.name,

                    self.fname)

        else:

            disposition = 'form-data; name="%s"' % self.name

        headers.append("Content-Disposition: %s" % disposition)

        if self.filetype:

            filetype = self.filetype

        else:

            filetype = "text/plain; charset=utf-8"

        headers.append("Content-Type: %s" % filetype)

        headers.append("Content-Length: %i" % self.size)

        headers.append("")

        headers.append("")

        return "\r\n".join(headers)

    def encode(self, boundary):

        """Returns the string encoding of this parameter"""

        value = self.value

        if re.search("^--%s$" % re.escape(boundary), value, re.M):

            raise ValueError("boundary found in encoded string")

        return "%s%s\r\n" % (self.encode_hdr(boundary), value)

    def iter_encode(self, boundary, blocksize=16384):

        if not hasattr(self.value, "read"):

            yield self.encode(boundary)

        else:

            yield self.encode_hdr(boundary)

            while True:

                block = self.value.read(blocksize)

                if not block:

                    yield "\r\n"

                    break

                yield block

class MultipartForm(object):

    def __init__(self, params, boundary, headers):

        self.boundary = boundary

        self.boundaries = []

        self.size = 0

        self.content_length = headers.get('Content-Length')

        if hasattr(params, 'items'):

            params = params.items()

        for param in params:

            name, value = param

            if hasattr(value, "read"):

                fname = getattr(value, 'name')

                if fname is not None:

                    filetype = ';'.join(filter(None, mimetypes.guess_type(fname)))

                else:

                    filetype = None

                if not isinstance(value, file) and self.content_length is None:

                    value = value.read()

                boundary = BoundaryItem(name, value, fname, filetype)

            else:

                 boundary = BoundaryItem(name, value)

            self.boundaries.append(boundary)

    def get_size(self):

        if self.content_length is not None:

            return int(self.content_length)

        size = 0

        for boundary in self.boundaries:

            size = size + boundary.size

        return size

    def __iter__(self):

        for boundary in self.boundaries:

            for block in boundary.iter_encode(self.boundary):

                yield block

        yield "--%s--\r\n" % self.boundary

def multipart_form_encode(params, headers, boundary):

    headers = headers or {}

    boundary = urllib.quote_plus(boundary)

    body = MultipartForm(params, boundary, headers)

    headers['Content-Type'] = "multipart/form-data; boundary=%s" % boundary

    headers['Content-Length'] = str(body.get_size())

    return body, headers

import gzip

from StringIO import StringIO

import zlib

from restkit import pool

MAX_CHUNK_SIZE = 16384

        """ path auth info to the request """

    def response(self, response):

        """ allow us to store new auth info from the response.

        if something is wrong, should return True to redo 

        the request. Else return False.

        """

    def __init__(self, username, password):

        self.credentials = (username, password)

        headers['authorization'] = 'Basic ' + base64.encodestring("%s:%s" % self.credentials)[:-1]

class HTTPResponse(object):

    """ Object containing response."""

    charset = "utf8"

    unicode_errors = 'strict'

    def __init__(self, response, release_callback):

        self.resp = response

        self.release_callback = release_callback

        self.headerslist = response.getheaders()

        self.status = "%s %s" % (response.status, response.reason)

        self.status_int = response.status

        self.version = response.version

        headers = {}

        for key, value in self.headerslist:

            headers[key.lower()] = value

        self.headers = headers

        self.closed = False

        self._body = ""

    def get_body(self, stream=False):

        if self._body:

            return self._body

        body = _decompress_content(self, stream=stream)

        if not stream:

            self._body = body

        return body

    @property

    def unicode_body(self):

        if not self.charset:

            raise AttributeError(

                "You cannot access HTTPResponse.unicode_body unless charset is set")

        body = self.get_body()

        return body.decode(self.charset, self.unicode_errors)

    @property

    def body(self):

        """ get body in one bytestring """

        return self.get_body()

    @property

    def body_file(self):

        """ get body as a file object """

        return self.get_body(stream=True)

    def close(self):

        """ close the response"""

        if not self.closed:

            self.closed = True

            self.release_callback()

            if not self.resp.isclosed():

                self.resp.close()

    max_redirections = 5

    pool_class = pool.ConnectionPool

    response_class = HTTPResponse

    def __init__(self, follow_redirect=True, force_follow_redirect=False, 

            response_class=None, pool_class=None, **conn_opts):

        self.use_proxy = conn_opts.get("use_proxy", False)

        self.conn_opts = conn_opts

        self._http_pool = {}

        if response_class is not None:

            self.response_class = response_class

        if pool_class is not None:

    def _get_pool(self, uri):

        if conn_key in self._http_pool:

            pool = self._http_pool[conn_key]

        else:

            pool = self.pool_class(uri, **self.conn_opts)

            self._http_pool[conn_key] = pool

        return pool

    def _get_connection(self, uri):

        pool = self._get_pool(uri)

        return  pool.get()

        pool = self._get_pool(uri)

    def _clean_pool(self, uri):

        pool = self._get_pool(uri)

        pool.clear()

            connection = self._get_connection(uri)

                    if isinstance(body, types.StringTypes) or hasattr(body, 'read'):