Top

qcloudsms_py.httpclient module

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import, division, print_function

import json
import sys
import socket

if sys.version_info >= (3,):
    from http import client as httplib
    from urllib import parse as urlparse
else:
    import httplib
    import urlparse


class HTTPRequest(object):

     def __init__(self, url, method="GET", headers=None, body=None,
                  connect_timeout=None, request_timeout=None):
         """
         :param url: HTTP request URL.
         :param method:  (optiona) HTTP method.
         :param headers: (optional) Dictionary for HTTP request headers.
         :param body: (optional) Dictionary for HTTP request body.
         :param connect_timeout: (optional) HTTP connection timeout.
         :param request_timeout: (optional) HTTP request timeout.
         """
         self.url = url
         self.method = method
         self.headers = headers
         self.body = body
         self.connect_timeout = connect_timeout
         self.request_timeout = request_timeout


class HTTPResponse(object):

    def __init__(self, request, code, body, headers=None, reason=None):
        """
         :param request: HTTPRequest instance.
         :param code:  HTTP status code.
         :param body: Raw bytes of HTTP response body.
         :param headers: (optional) Dictionary for HTTP response headers.
         :param reason: (optional) HTTP status reason.
         """
        self.request = request
        self.code = code
        self.body = body
        self.headers = headers
        self.reason = reason or httplib.responses.get(code, "Unknown")

    def ok(self):
        if self.code == 200 or self.code == "200":
            return True
        return False

    def json(self):
        return json.loads(self.body, encoding="utf-8")


class HTTPError(Exception):

    def __init__(self, code, reason=None):
        self.code = code
        self.reason = reason or httplib.responses.get(code, "Unknown")
        super(HTTPError, self).__init__(code, reason)

    def __str__(self):
        return "HTTP {}: {}".format(self.code, self.reason)
    __repr__ = __str__


if sys.version_info >= (3,):
    unicode_type = str
else:
    unicode_type = unicode


def utf8(value):
    """Converts a string argument to a byte string.

    If the argument is already a byte string or None, it is returned
    unchanged. Otherwise it must be a unicode string and is encoded
    as utf8.

    NOTE: This method copy from https://github.com/tornadoweb/tornado and
          copyright belongs to the original author.
    """
    if isinstance(value, (bytes, type(None))):
        return value
    if not isinstance(value, unicode_type):
        raise TypeError(
            "Expected bytes, unicode, or None; got %r" % type(value)
        )
    return value.encode("utf-8")



def http_fetch(req):
    """Fetch HTTP response by given HTTP request.

    :param req: HTTPRequest instance
    """
    result = urlparse.urlparse(req.url)
    if result.scheme == "https":
        conn = httplib.HTTPSConnection(
            result.hostname,
            port=result.port,
            timeout=req.connect_timeout
        )
    else:
        conn = httplib.HTTPConnection(
            result.hostname,
            port=result.port,
            timeout=req.connect_timeout
        )
    try:
        conn.request(
            req.method,
            "{}?{}".format(result.path, result.query),
            body=utf8(json.dumps(req.body)),
            headers=req.headers
        )
        response = conn.getresponse()
        res = HTTPResponse(
            request=req,
            code=response.status,
            body=response.read(),
            headers=dict(response.getheaders()),
            reason=response.reason
        )
    except socket.gaierror:
        # client network error, raise
        raise
    except OSError:
        # client network error, raise
        raise
    finally:
        conn.close()
    return res

Functions

def http_fetch(

req)

Fetch HTTP response by given HTTP request.

:param req: HTTPRequest instance

def http_fetch(req):
    """Fetch HTTP response by given HTTP request.

    :param req: HTTPRequest instance
    """
    result = urlparse.urlparse(req.url)
    if result.scheme == "https":
        conn = httplib.HTTPSConnection(
            result.hostname,
            port=result.port,
            timeout=req.connect_timeout
        )
    else:
        conn = httplib.HTTPConnection(
            result.hostname,
            port=result.port,
            timeout=req.connect_timeout
        )
    try:
        conn.request(
            req.method,
            "{}?{}".format(result.path, result.query),
            body=utf8(json.dumps(req.body)),
            headers=req.headers
        )
        response = conn.getresponse()
        res = HTTPResponse(
            request=req,
            code=response.status,
            body=response.read(),
            headers=dict(response.getheaders()),
            reason=response.reason
        )
    except socket.gaierror:
        # client network error, raise
        raise
    except OSError:
        # client network error, raise
        raise
    finally:
        conn.close()
    return res

def utf8(

value)

Converts a string argument to a byte string.

If the argument is already a byte string or None, it is returned unchanged. Otherwise it must be a unicode string and is encoded as utf8.

NOTE: This method copy from https://github.com/tornadoweb/tornado and copyright belongs to the original author.

def utf8(value):
    """Converts a string argument to a byte string.

    If the argument is already a byte string or None, it is returned
    unchanged. Otherwise it must be a unicode string and is encoded
    as utf8.

    NOTE: This method copy from https://github.com/tornadoweb/tornado and
          copyright belongs to the original author.
    """
    if isinstance(value, (bytes, type(None))):
        return value
    if not isinstance(value, unicode_type):
        raise TypeError(
            "Expected bytes, unicode, or None; got %r" % type(value)
        )
    return value.encode("utf-8")

Classes

class HTTPError

class HTTPError(Exception):

    def __init__(self, code, reason=None):
        self.code = code
        self.reason = reason or httplib.responses.get(code, "Unknown")
        super(HTTPError, self).__init__(code, reason)

    def __str__(self):
        return "HTTP {}: {}".format(self.code, self.reason)
    __repr__ = __str__

Ancestors (in MRO)

Class variables

var args

var message

Instance variables

var code

var reason

Methods

def __init__(

self, code, reason=None)

def __init__(self, code, reason=None):
    self.code = code
    self.reason = reason or httplib.responses.get(code, "Unknown")
    super(HTTPError, self).__init__(code, reason)

class HTTPRequest

class HTTPRequest(object):

     def __init__(self, url, method="GET", headers=None, body=None,
                  connect_timeout=None, request_timeout=None):
         """
         :param url: HTTP request URL.
         :param method:  (optiona) HTTP method.
         :param headers: (optional) Dictionary for HTTP request headers.
         :param body: (optional) Dictionary for HTTP request body.
         :param connect_timeout: (optional) HTTP connection timeout.
         :param request_timeout: (optional) HTTP request timeout.
         """
         self.url = url
         self.method = method
         self.headers = headers
         self.body = body
         self.connect_timeout = connect_timeout
         self.request_timeout = request_timeout

Ancestors (in MRO)

Instance variables

var body

var connect_timeout

var headers

var method

var request_timeout

var url

Methods

def __init__(

self, url, method='GET', headers=None, body=None, connect_timeout=None, request_timeout=None)

:param url: HTTP request URL. :param method: (optiona) HTTP method. :param headers: (optional) Dictionary for HTTP request headers. :param body: (optional) Dictionary for HTTP request body. :param connect_timeout: (optional) HTTP connection timeout. :param request_timeout: (optional) HTTP request timeout.

def __init__(self, url, method="GET", headers=None, body=None,
             connect_timeout=None, request_timeout=None):
    """
    :param url: HTTP request URL.
    :param method:  (optiona) HTTP method.
    :param headers: (optional) Dictionary for HTTP request headers.
    :param body: (optional) Dictionary for HTTP request body.
    :param connect_timeout: (optional) HTTP connection timeout.
    :param request_timeout: (optional) HTTP request timeout.
    """
    self.url = url
    self.method = method
    self.headers = headers
    self.body = body
    self.connect_timeout = connect_timeout
    self.request_timeout = request_timeout

class HTTPResponse

class HTTPResponse(object):

    def __init__(self, request, code, body, headers=None, reason=None):
        """
         :param request: HTTPRequest instance.
         :param code:  HTTP status code.
         :param body: Raw bytes of HTTP response body.
         :param headers: (optional) Dictionary for HTTP response headers.
         :param reason: (optional) HTTP status reason.
         """
        self.request = request
        self.code = code
        self.body = body
        self.headers = headers
        self.reason = reason or httplib.responses.get(code, "Unknown")

    def ok(self):
        if self.code == 200 or self.code == "200":
            return True
        return False

    def json(self):
        return json.loads(self.body, encoding="utf-8")

Ancestors (in MRO)

Instance variables

var body

var code

var headers

var reason

var request

Methods

def __init__(

self, request, code, body, headers=None, reason=None)

:param request: HTTPRequest instance. :param code: HTTP status code. :param body: Raw bytes of HTTP response body. :param headers: (optional) Dictionary for HTTP response headers. :param reason: (optional) HTTP status reason.

def __init__(self, request, code, body, headers=None, reason=None):
    """
     :param request: HTTPRequest instance.
     :param code:  HTTP status code.
     :param body: Raw bytes of HTTP response body.
     :param headers: (optional) Dictionary for HTTP response headers.
     :param reason: (optional) HTTP status reason.
     """
    self.request = request
    self.code = code
    self.body = body
    self.headers = headers
    self.reason = reason or httplib.responses.get(code, "Unknown")

def json(

self)

def json(self):
    return json.loads(self.body, encoding="utf-8")

def ok(

self)

def ok(self):
    if self.code == 200 or self.code == "200":
        return True
    return False