Python compat.str函数代码示例

    def test_invalid_timeout(self):
        with pytest.raises(ValueError) as e:
            requests.get(httpbin("get"), timeout=(3, 4, 5))
        assert "(connect, read)" in str(e)

        with pytest.raises(ValueError) as e:
            requests.get(httpbin("get"), timeout="foo")
        assert "must be an int or float" in str(e)

 def line(self):
     """Return Status-Line"""
     original = self._orig.raw._original_response
     return str('HTTP/{version} {status} {reason}'.format(
          version='.'.join(str(original.version)),
          status=original.status,
          reason=original.reason
      ))

def make_response_message(response):
    """Make an `HTTPMessage` from `requests.models.Response`."""
    encoding = response.encoding or 'ISO-8859-1'
    original = response.raw._original_response
    response_headers = response.headers
    return HTTPMessage(
        line='HTTP/{version} {status} {reason}'.format(
                version='.'.join(str(original.version)),
                status=original.status, reason=original.reason,),
        headers=str(original.msg),
        body=response.content.decode(encoding) if response.content else '',
        content_type=response_headers.get('Content-Type'))

    def test_iter_lines(self):

        lines = (0, 2, 10, 100)

        for i in lines:
            r = get(httpbin('stream', str(i)), prefetch=False)
            lines = list(r.iter_lines())
            len_lines = len(lines)

            self.assertEqual(i, len_lines)

        # Test 'dangling' fragment in responses that do not terminate in
        # a newline.
        quote = (
            '''Why will he not upon our fair request\n'''
            '''Untent his person and share the air with us?'''
        )

        # Make a request and monkey-patch its contents
        r = get(httpbin('get'))
        r.raw = StringIO(quote)

        # Make sure iter_lines doesn't chop the trailing bit
        lines = '\n'.join(r.iter_lines())
        self.assertEqual(lines, quote)

def safe_str(obj):
    """ return the byte string representation of obj """
    try:
        return str(obj)
    except UnicodeEncodeError:
        # obj is unicode
        return unicode(obj).encode('unicode_escape')

def update_cookies(cookies, resp):
    if 'SNUID' not in cookies:
        p = re.compile(r'(?<=SNUID=)\w+')
        cookies['SNUID'] = p.findall(resp.text)[0]
        suv = ''.join([str(int(time.time()*1000000) + random.randint(0, 1000))])
        cookies['SUV'] = suv
    return cookies

    def test_iter_lines(self):

        lines = (0, 2, 10, 100)

        for i in lines:
            r = get(httpbin('stream', str(i)), prefetch=False)
            lines = list(r.iter_lines())
            len_lines = len(lines)

            self.assertEqual(i, len_lines)

        # Tests that trailing whitespaces within lines do not get stripped.
        # Tests that a trailing non-terminated line does not get stripped.
        quote = (
            '''Agamemnon  \n'''
            '''\tWhy will he not upon our fair request\r\n'''
            '''\tUntent his person and share the air with us?'''
        )

        # Make a request and monkey-patch its contents
        r = get(httpbin('get'), prefetch=False)
        r.raw = StringIO(quote)

        lines = list(r.iter_lines())
        len_lines = len(lines)
        self.assertEqual(len_lines, 3)

        joined = lines[0] + '\n' + lines[1] + '\r\n' + lines[2]
        self.assertEqual(joined, quote)

 def test_unicode_header_name(self):
     requests.put(
         httpbin('put'),
         headers={
             str('Content-Type'): 'application/octet-stream'  # compat.str is unicode.
         },
         data='\xff'
     )

def safe_unicode(obj, *args):
    """ return the unicode representation of obj """
    try:
        return unicode(obj, *args)
    except UnicodeDecodeError:
        # obj is byte string
        ascii_text = str(obj).encode('string_escape')
        return unicode(ascii_text)

def test_urllib3_pool_connection_closed(httpbin):
    s = requests.Session()
    s.mount('http://', HTTPAdapter(pool_connections=0, pool_maxsize=0))

    try:
        s.get(httpbin('status/200'))
    except ConnectionError as e:
        assert u"Pool is closed." in str(e)

 def test_http_error(self):
     error = requests.exceptions.HTTPError()
     self.assertEqual(error.response, None)
     response = requests.Response()
     error = requests.exceptions.HTTPError(response=response)
     self.assertEqual(error.response, response)
     error = requests.exceptions.HTTPError('message', response=response)
     self.assertEqual(str(error), 'message')
     self.assertEqual(error.response, response)

 def test_http_error(self):
     error = requests.exceptions.HTTPError()
     assert not error.response
     response = requests.Response()
     error = requests.exceptions.HTTPError(response=response)
     assert error.response == response
     error = requests.exceptions.HTTPError("message", response=response)
     assert str(error) == "message"
     assert error.response == response

def _get_response(args):

    auto_json = args.data and not args.form
    if args.json or auto_json:
        # JSON
        if 'Content-Type' not in args.headers:
            args.headers['Content-Type'] = TYPE_JSON

        if 'Accept' not in args.headers:
            # Default Accept to JSON as well.
            args.headers['Accept'] = 'application/json'

        if isinstance(args.data, dict):
            # If not empty, serialize the data `dict` parsed from arguments.
            # Otherwise set it to `None` avoid sending "{}".
            args.data = json.dumps(args.data) if args.data else None

    elif args.form:
        # Form
        if not args.files and 'Content-Type' not in args.headers:
            # If sending files, `requests` will set
            # the `Content-Type` for us.
            args.headers['Content-Type'] = TYPE_FORM


    # Fire the request.
    try:
        credentials = None
        if args.auth:
            auth_type = (requests.auth.HTTPDigestAuth
                         if args.auth_type == 'digest'
                         else requests.auth.HTTPBasicAuth)
            credentials = auth_type(args.auth.key, args.auth.value)

        return requests.request(
            method=args.method.lower(),
            url=args.url if '://' in args.url else 'http://%s' % args.url,
            headers=args.headers,
            data=args.data,
            verify={'yes': True, 'no': False}.get(args.verify, args.verify),
            timeout=args.timeout,
            auth=credentials,
            proxies=dict((p.key, p.value) for p in args.proxy),
            files=args.files,
            allow_redirects=args.allow_redirects,
            params=args.queries,
        )

    except (KeyboardInterrupt, SystemExit):
        sys.stderr.write('\n')
        sys.exit(1)
    except Exception as e:
        if args.traceback:
            raise
        sys.stderr.write(str(e.message) + '\n')
        sys.exit(1)

def _get_response(parser, args, stdin, stdin_isatty):

    if not stdin_isatty:
        if args.data:
            parser.error('Request body (stdin) and request '
                                'data (key=value) cannot be mixed.')
        args.data = stdin.read()

    if args.json or (not args.form and args.data):
        # JSON
        if not args.files and (
            'Content-Type' not in args.headers
            and (args.data or args.json)):
                args.headers['Content-Type'] = TYPE_JSON
        if stdin_isatty:
            # Serialize the parsed data.
            args.data = json.dumps(args.data)
        if 'Accept' not in args.headers:
            # Default Accept to JSON as well.
            args.headers['Accept'] = 'application/json'
    elif not args.files and 'Content-Type' not in args.headers:
        # Form
        args.headers['Content-Type'] = TYPE_FORM

    # Fire the request.
    try:
        credentials = None
        if args.auth:
            auth_type = (requests.auth.HTTPDigestAuth
                         if args.auth_type == 'digest'
                         else requests.auth.HTTPBasicAuth)
            credentials = auth_type(args.auth.key, args.auth.value)

        return requests.request(
            method=args.method.lower(),
            url=args.url if '://' in args.url else 'http://%s' % args.url,
            headers=args.headers,
            data=args.data,
            verify={'yes': True, 'no': False}.get(args.verify, args.verify),
            timeout=args.timeout,
            auth=credentials,
            proxies=dict((p.key, p.value) for p in args.proxy),
            files=args.files,
            allow_redirects=args.allow_redirects,
        )

    except (KeyboardInterrupt, SystemExit):
        sys.stderr.write('\n')
        sys.exit(1)
    except Exception as e:
        if args.traceback:
            raise
        sys.stderr.write(str(e.message) + '\n')
        sys.exit(1)

def converte_dicionario_unicode_em_ascii(data):
    if isinstance(data, str):
        try:
            return str(data)
        except:
            return data
    elif isinstance(data, collections.Mapping):
        return dict(list(map(converte_dicionario_unicode_em_ascii, iter(list(data.items())))))
    elif isinstance(data, collections.Iterable):
        return type(data)(list(map(converte_dicionario_unicode_em_ascii, data)))
    else:
        return data