def _request()

in odps/rest.py [0:0]

• 64 lines of code
• 25 McCabe index (conditional complexity)

    def _request(self, url, method, stream=False, **kwargs):
        self.upload_survey_log()

        region_name = kwargs.pop("region_name", None)

        logger.debug("Start request.")
        logger.debug("%s: %s", method.upper(), url)
        if logger.getEffectiveLevel() <= logging.DEBUG:
            for k, v in kwargs.items():
                logger.debug("%s: %s", k, v)

        # Construct user agent without handling the letter case.
        headers = kwargs.get("headers", {})
        headers = {k: str(v) for k, v in six.iteritems(headers)}
        headers["User-Agent"] = self._user_agent
        if self.namespace:
            headers["x-odps-namespace-id"] = self.namespace
        kwargs["headers"] = headers
        params = kwargs.setdefault("params", {})

        actions = kwargs.pop("actions", None) or kwargs.pop("action", None) or []
        if isinstance(actions, six.string_types):
            actions = [actions]
        if actions:
            separator = "?" if "?" not in url else "&"
            url += separator + "&".join(actions)

        curr_project = kwargs.pop("curr_project", None) or self.project
        if "curr_project" not in params and curr_project is not None:
            params["curr_project"] = curr_project

        curr_schema = kwargs.pop("curr_schema", None) or self.schema
        if "curr_schema" not in params and curr_schema is not None:
            params["curr_schema"] = curr_schema

        timeout = kwargs.pop("timeout", None)
        req = requests.Request(method, url, **kwargs)
        prepared_req = req.prepare()
        logger.debug("request url + params %s", prepared_req.path_url)

        prepared_req.headers.pop("Authorization", None)
        prepared_req.headers.pop("application-authentication", None)
        self._account.sign_request(
            prepared_req, self._endpoint, region_name=region_name
        )
        if getattr(self, "_app_account", None) is not None:
            self._app_account.sign_request(
                prepared_req, self._endpoint, region_name=region_name
            )

        if any(v is None for v in prepared_req.headers.values()):
            none_headers = [k for k, v in prepared_req.headers.items() if v is None]
            raise TypeError(
                "Value of headers %s cannot be None" % ", ".join(none_headers)
            )

        try:
            res = self.session.send(
                prepared_req,
                stream=stream,
                timeout=timeout or (options.connect_timeout, options.read_timeout),
                verify=options.verify_ssl,
                proxies=self._proxy,
            )
        except ConnectTimeout:
            raise errors.ConnectTimeout(
                "Connecting to endpoint %s timeout." % self._endpoint
            )

        logger.debug("response.status_code %d", res.status_code)
        logger.debug("response.headers: \n%s", res.headers)
        if not stream:
            logger.debug("response.content: %s\n", res.content)
        # Automatically detect error
        if not self.is_ok(res):
            errors.throw_if_parsable(res, self._endpoint, self._tag)
        return res