Ejemplo n.º 1
0
    def __call__(self, req):
        parsed = urllib_parse.urlparse(req.url)

        # Get the netloc without any embedded credentials
        netloc = parsed.netloc.rsplit("@", 1)[-1]

        # Set the url of the request to the url without any credentials
        req.url = urllib_parse.urlunparse(parsed[:1] + (netloc,) + parsed[2:])

        # Use any stored credentials that we have for this netloc
        username, password = self.passwords.get(netloc, (None, None))

        # Extract credentials embedded in the url if we have none stored
        if username is None:
            username, password = self.parse_credentials(parsed.netloc)

        # Get creds from netrc if we still don't have them
        if username is None and password is None:
            netrc_auth = get_netrc_auth(req.url)
            username, password = netrc_auth if netrc_auth else (None, None)

        if username or password:
            # Store the username and password
            self.passwords[netloc] = (username, password)

            # Send the basic auth with this request
            req = HTTPBasicAuth(username or "", password or "")(req)

        # Attach a hook to handle 401 responses
        req.register_hook("response", self.handle_401)

        return req
Ejemplo n.º 2
0
    def __init__(self, requirement_string):
        try:
            req = REQUIREMENT.parseString(requirement_string)
        except ParseException as e:
            raise InvalidRequirement(
                'Parse error at "{0!r}": {1}'.format(
                    requirement_string[e.loc : e.loc + 8], e.msg
                )
            )

        self.name = req.name
        if req.url:
            parsed_url = urlparse.urlparse(req.url)
            if parsed_url.scheme == "file":
                if urlparse.urlunparse(parsed_url) != req.url:
                    raise InvalidRequirement("Invalid URL given")
            elif not (parsed_url.scheme and parsed_url.netloc) or (
                not parsed_url.scheme and not parsed_url.netloc
            ):
                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
            self.url = req.url
        else:
            self.url = None
        self.extras = set(req.extras.asList() if req.extras else [])
        self.specifier = SpecifierSet(req.specifier)
        self.marker = req.marker if req.marker else None
Ejemplo n.º 3
0
 def request(self, host, handler, request_body, verbose=False):
     parts = (self._scheme, host, handler, None, None, None)
     url = urllib_parse.urlunparse(parts)
     try:
         headers = {'Content-Type': 'text/xml'}
         response = self._session.post(url, data=request_body,
                                       headers=headers, stream=True)
         response.raise_for_status()
         self.verbose = verbose
         return self.parse_response(response.raw)
Ejemplo n.º 4
0
 def request(self, host, handler, request_body, verbose=False):
     parts = (self._scheme, host, handler, None, None, None)
     url = urllib_parse.urlunparse(parts)
     try:
         headers = {"Content-Type": "text/xml"}
         response = self._session.post(url, data=request_body, headers=headers, stream=True)
         response.raise_for_status()
         self.verbose = verbose
         return self.parse_response(response.raw)
     except requests.HTTPError as exc:
         logger.critical("HTTP error %s while getting %s", exc.response.status_code, url)
         raise
Ejemplo n.º 5
0
 def request(self, host, handler, request_body, verbose=False):
     parts = (self._scheme, host, handler, None, None, None)
     url = urllib_parse.urlunparse(parts)
     try:
         headers = {'Content-Type': 'text/xml'}
         response = self._session.post(url,
                                       data=request_body,
                                       headers=headers,
                                       stream=True)
         response.raise_for_status()
         self.verbose = verbose
         return self.parse_response(response.raw)
     except requests.HTTPError as exc:
         logger.critical(
             "HTTP error %s while getting %s",
             exc.response.status_code,
             url,
         )
         raise
Ejemplo n.º 6
0
    def __init__(self, requirement_string):
        try:
            req = REQUIREMENT.parseString(requirement_string)
        except ParseException as e:
            raise InvalidRequirement('Parse error at "{0!r}": {1}'.format(requirement_string[e.loc : e.loc + 8], e.msg))

        self.name = req.name
        if req.url:
            parsed_url = urlparse.urlparse(req.url)
            if parsed_url.scheme == "file":
                if urlparse.urlunparse(parsed_url) != req.url:
                    raise InvalidRequirement("Invalid URL given")
            elif not (parsed_url.scheme and parsed_url.netloc) or (not parsed_url.scheme and not parsed_url.netloc):
                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
            self.url = req.url
        else:
            self.url = None
        self.extras = set(req.extras.asList() if req.extras else [])
        self.specifier = SpecifierSet(req.specifier)
        self.marker = req.marker if req.marker else None
Ejemplo n.º 7
0
 def request(self, host, handler, request_body, verbose=False):
     # type: (str, str, Dict[str, str], bool) -> None
     parts = (_scheme, host, handler, None, None, None)
     url = urllib_parse.urlunparse(parts)
     try:
         headers = {'Content-Type': 'text/xml'}
         response = _session.post(url,
                                  data=request_body,
                                  headers=headers,
                                  stream=True)
         raise_for_status(response)
         verbose = verbose
         return parse_response(response.raw)
     except NetworkConnectionError as exc:
         assert exc.response
         logger.critical(
             "HTTP error %s while getting %s",
             exc.response.status_code,
             url,
         )
         raise
Ejemplo n.º 8
0
def _clean_link(url):
    # type: (str) -> str
    """Makes sure a link is fully encoded.  That is, if a ' ' shows up in
    the link, it will be rewritten to %20 (while not over-quoting
    % or other characters)."""
    # Split the URL into parts according to the general structure
    # `scheme://netloc/path;parameters?query#fragment`. Note that the
    # `netloc` can be empty and the URI will then refer to a local
    # filesystem path.
    result = urllib_parse.urlparse(url)
    # In both cases below we unquote prior to quoting to make sure
    # nothing is double quoted.
    if result.netloc == "":
        # On Windows the path part might contain a drive letter which
        # should not be quoted. On Linux where drive letters do not
        # exist, the colon should be quoted. We rely on urllib.request
        # to do the right thing here.
        path = urllib_request.pathname2url(
            urllib_request.url2pathname(result.path))
    else:
        path = urllib_parse.quote(urllib_parse.unquote(result.path))
    return urllib_parse.urlunparse(result._replace(path=path))
Ejemplo n.º 9
0
def _clean_link(url):
    # type: (str) -> str
    """Makes sure a link is fully encoded.  That is, if a ' ' shows up in
    the link, it will be rewritten to %20 (while not over-quoting
    % or other characters)."""
    # Split the URL into parts according to the general structure
    # `scheme://netloc/path;parameters?query#fragment`. Note that the
    # `netloc` can be empty and the URI will then refer to a local
    # filesystem path.
    result = urllib_parse.urlparse(url)
    # In both cases below we unquote prior to quoting to make sure
    # nothing is double quoted.
    if result.netloc == "":
        # On Windows the path part might contain a drive letter which
        # should not be quoted. On Linux where drive letters do not
        # exist, the colon should be quoted. We rely on urllib.request
        # to do the right thing here.
        path = urllib_request.pathname2url(
            urllib_request.url2pathname(result.path))
    else:
        path = urllib_parse.quote(urllib_parse.unquote(result.path))
    return urllib_parse.urlunparse(result._replace(path=path))
Ejemplo n.º 10
0
<<<<<<< HEAD
        # type: (str, PipSession, bool) -> None
=======
>>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71
        xmlrpc_client.Transport.__init__(self, use_datetime)
        index_parts = urllib_parse.urlparse(index_url)
        self._scheme = index_parts.scheme
        self._session = session

    def request(self, host, handler, request_body, verbose=False):
<<<<<<< HEAD
        # type: (str, str, Dict[str, str], bool) -> None
=======
>>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71
        parts = (self._scheme, host, handler, None, None, None)
        url = urllib_parse.urlunparse(parts)
        try:
            headers = {'Content-Type': 'text/xml'}
            response = self._session.post(url, data=request_body,
                                          headers=headers, stream=True)
<<<<<<< HEAD
            raise_for_status(response)
            self.verbose = verbose
            return self.parse_response(response.raw)
        except NetworkConnectionError as exc:
            assert exc.response
=======
            response.raise_for_status()
            self.verbose = verbose
            return self.parse_response(response.raw)
        except requests.HTTPError as exc: