urllib.request.HTTPHandler

Here are the examples of the python api urllib.request.HTTPHandler taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

4 Examples 7

Example 1

Project: py-gocd Source File: server.py
    def _add_basic_auth(self):
        auth_handler = HTTPBasicAuthHandler(
            HTTPPasswordMgrWithDefaultRealm()
        )
        auth_handler.add_password(
            realm=None,
            uri=self.host,
            user=self.user,
            passwd=self.password,
        )
        install_opener(build_opener(
            auth_handler,
            HTTPHandler(debuglevel=self.request_debug_level),
            HTTPSHandler(debuglevel=self.request_debug_level),
        ))

Example 2

Project: alfred-python Source File: request.py
    def __init__(self, url, **kwargs):
        self.request = None
        self.response = None
        self.code = -1
        self.info = {}
        self.cookieJar = None
        self.reason = ''

        data = kwargs.get('data', None)
        if data:
            if isinstance(data, dict):
                data = urlencode(data)
            if not isinstance(data, basestring):
                raise ValueError('data must be string or dict')

        request_type = kwargs.get('type', 'POST')
        if data and isinstance(request_type, basestring) and request_type.upper()!='POST':
            url = '{}?{}'.format(url, data)
            data = None # GET data must be None

        self.request = urlRequest(url, data)

        # referer
        referer = kwargs.get('referer', None)
        if referer:
            self.request.add_header('referer', referer)

        # user-agent
        user_agent = kwargs.get('user_agent', None)
        if user_agent:
            self.request.add_header('User-Agent', user_agent)

        # auth
        auth = kwargs.get('auth', None)
        if auth and isinstance(auth, dict) and 'usr' in auth:
            auth_string = base64.b64encode('{}:{}'.format(auth.get('usr',''), auth.get('pwd','')))
            self.request.add_header('Authorization', 'Basic {}'.format(auth_string))  

        # cookie
        cookie = kwargs.get('cookie', None)
        cj = None
        if cookie:
            if isinstance(cookie, CookieJar):
                cj = cookie
            elif isinstance(cookie, dict):
                result = []
                for k, v in cookie.items():
                    result.append('{}={}'.format(k, v))
                cookie = '; '.join(result)
            elif isinstance(cookie, Cookie.BaseCookie):
                cookie = cookie.output(header='')
            if isinstance(cookie, basestring):
                self.request.add_header('Cookie', cookie)
        if cj is None:
            cj = CookieJar()

        #! TODO: proxy


        # build opener
        debuglevel = 1 if kwargs.get('debug', False) else 0
        opener = build_opener(
            HTTPHandler(debuglevel=debuglevel),
            HTTPSHandler(debuglevel=debuglevel),
            HTTPCookieProcessor(cj)
        )

        # timeout
        timeout = kwargs.get('timeout')
        if not isinstance(timeout, int):
            timeout = _DEFAULT_TIMEOUT

        try:
            self.response = opener.open(self.request, timeout=timeout)
            self.code = self.response.getcode()
            self.header = self.response.info().dict
            self.cookieJar = cj
        except HTTPError as e:
            self.code = e.code
            self.reason = '{}'.format(e)
            raise e
        except URLError as e:
            self.code = -1
            self.reason = e.reason
            raise e
        except Exception as e:
            self.code = -1
            self.reason = '{}'.format(e)
            raise e

Example 3

Project: tonicdnscli Source File: connect.py
Function: request
def request(uri, method, data, token=''):
    """Request to TonicDNS API.

    Arguments:

        uri:     TonicDNS API URI
        method:  TonicDNS API request method
        data:    Post data to TonicDNS API
        token:   TonicDNS API authentication token
    """
    socket.setdefaulttimeout(__timeout__)

    obj = urllib.build_opener(urllib.HTTPHandler)

    # encoding json
    encoded = json.JSONEncoder(object).encode(data)

    # encoding utf8
    data_utf8 = encoded.encode('utf-8')
    req = urllib.Request(uri, data=data_utf8)

    # When encoded(=data) is False, retrieve data as GET method.
    if encoded:
        req.add_header('Content-Type', 'application/json')

    if token:
        req.add_header('x-authentication-token', token)

    req.get_method = lambda: method

    try:
        res = obj.open(req)
        return res

    except urllib.URLError as e:
        sys.stderr.write("ERROR: %s\n" % e)
        exit(1)

    except urllib.HTTPError as e:
        sys.stderr.write("ERROR: %s\n" % e)
        exit(1)

Example 4

Project: sonata Source File: covers_lastfm.py
def on_cover_fetch(artist, album, on_save_cb, on_err_cb):
    handler = urllib.request.HTTPHandler()
    opener = urllib.request.build_opener(handler)
    opener.addheaders = [("User-Agent", make_user_agent())]

    # First, find the link to the master release of this album
    search_url = "http://ws.audioscrobbler.com/2.0/?%s" % (
        urllib.parse.urlencode({
            "method": "album.getInfo",
            "artist": artist,
            "album": album,
            "api_key": API_KEY,
            "format": "json",
        }))

    logger.debug("Querying %r...", search_url)
    response = opener.open(search_url)
    lastfm = json.loads(response.read().decode('utf-8'))

    if 'error' in lastfm:
        logger.warning("Can't find cover on Last.fm: %s (err=%d)",
                       lastfm['message'], lastfm['error'])
        return

    for image in lastfm['album']['image']:
        if image['size'] != 'mega':
            continue

        url = image['#text']
        if url == '':
            logger.info("Found an album on Last.fm, but no cover :( %s",
                        lastfm['album']['url'])
            continue

        logger.debug("Downloading %r", url)
        try:
            response = opener.open(url)
        except urllib.error.URLError as e:
            logger.warning("Can't download %r: %s", url, e)
            if on_err_cb("Can't download %r: %s" % (url, e)):
                break
            else:
                continue

        if not on_save_cb(response):
            break