Exemplo n.º 1
0
    def __process_response_update_alarms_action(self, response: Response) -> bool:
        """
        Procesa las respuestas de la acción alarm-update que permite actualizar las alarmas

        :param response: Respuesta obtenida del servidor después de consultar las alarmas
        :type response: Response
        :return: La cantidad de alarmas encontradas, si no existen, se retorna None
        :rtype: dict
        """

        updated: bool = False
        if response is None:
            self.debug("La respuesta de la API es nula")
            return updated

        # Si la respuesta es válida, retorno el resultado en formato JSON.
        # Sino, imprimo el error y retorno un None
        if response.status_code == 200:
            response_json: dict = convert_bytes_to_json(response.content)
            data: dict = response_json.get('alarm-update-response-list')
            response: dict = data.get('alarm-responses').get('alarm')
            updated = response.get('@error') == 'Success'

            if not updated:
                self.error(f'Se presentó un error realizando la actualización')
                self.debug(response)

            return updated

        self.error(f'Consultando la API de SPECTRUM: {response.status_code}')
        return updated
Exemplo n.º 2
0
    def _process_api_response(self,
                              response: Response,
                              commands: List[str],
                              raw_text: bool = False) -> List[Any]:
        """
        Normalize the API response including handling errors; adding the sent command into
        the returned data strucutre; make response structure consistent for raw_text and
        structured data.
        """

        response_list = json.loads(response.text)
        if isinstance(response_list, dict):
            response_list = [response_list]

        # Add the 'command' that was executed to the response dictionary
        for i, response_dict in enumerate(response_list):
            response_dict["command"] = commands[i]

        new_response = []
        for response in response_list:

            # Detect errors
            self._error_check(response)

            # Some commands like "show run" can have a None result
            cmd_response = response.get("result")
            if cmd_response is None:
                cmd_response = {}

            # Normalize the response data structure
            response_dict = {"command": response["command"]}
            if response and raw_text:
                response_dict["result"] = cmd_response.get("msg")
            elif response and not raw_text:
                response_dict["result"] = cmd_response.get("body")
            else:
                raise NXAPIError(
                    "Unexpected value encountered processing response.")
            new_response.append(response_dict)

        return new_response
Exemplo n.º 3
0
    def format_response(self, response: requests.Response, query: dict):
        """Return the formatted response as defined in wrapper/output_format.py.

        Args:
            response: The requests response returned by `call_api`.
            query: The query dict used as defined in wrapper/input_format.py.

        Returns:
            The formatted response.
        """
        if self.result_format == "json" or self.result_format == "jsonld":
            # Load into dict
            response = response.json()

            # Modify response to fit the defined wrapper output format
            response["dbQuery"] = response.get("query", {})
            response["query"] = query
            if ("result" in response) and (len(response["result"]) > 0):
                response["result"] = response.pop("result")[0]
            else:
                response["result"] = {
                    "total": -1,
                    "start": -1,
                    "pageLength": -1,
                    "recordsDisplayed": len(response.get("records", [])),
                }
            for record in response.get("records") or []:
                if ("url" in record) and (len(record["url"]) >
                                          0) and ("value" in record["url"][0]):
                    record["uri"] = record["url"][0]["value"]
                authors = []
                for author in record.get("creators") or []:
                    authors.append(author["creator"])
                record["authors"] = authors
                record["pages"] = {
                    "first": record.get("startingPage"),
                    "last": record.get("endingPage"),
                }
                if self.collection == "openaccess":
                    record["openAccess"] = True
                elif "openaccess" in record:
                    record["openAccess"] = (record.pop("openaccess") == "true")

                # Delete all undefined fields
                utils.clean_output(record, OUTPUT_FORMAT["records"][0])
            '''
            Convert from springers format to a more usable format.
                "facets": [{
                    "name": "Name of the category",
                    "values": [{
                        "value": "Value in the category",
                        "count": "Number of occurrences of this value",
                    }],
                }],
            to:
                "facets": {
                    "category": {
                        "name": "int: counter",
                    },
                },
            See wrapper/output_format.py.
            '''
            new_facets = {
                "countries": {},
                "keywords": [],
            }
            for facet in response.get("facets") or []:
                facet_name = facet.get("name")
                if not facet_name:
                    continue
                for value in facet["values"]:
                    val_name = value.get("value")
                    if not val_name:
                        continue

                    if facet_name == "country":
                        # Convert to ISO 3166-1 alpha-2 codes
                        try:
                            iso = utils.get(
                                pycountry.countries.search_fuzzy(val_name), 0)
                        except LookupError:
                            iso = None
                        # If no match was found the full name is readd.
                        val_name = iso.alpha_2 if iso else val_name
                        new_facets["countries"][val_name] = int(
                            value.get("count", 0))
                    # elif facet_name in ["keyword", "subject"]:
                    elif facet_name == "keyword":
                        keyword = {
                            "text": val_name.lower(),
                            "value": int(value.get("count", 0)),
                        }
                        new_facets["keywords"].append(keyword)

            response["facets"] = new_facets

            # Delete all undefined fields
            utils.clean_output(response)

            return response

        else:
            print(
                f"No formatter defined for {self.result_format}. Returning raw response."
            )
            return response.text
Exemplo n.º 4
0
    def format_response(self, response: requests.Response, query: dict,
                        db_query: Union[dict, str]):
        """Return the formatted response as defined in wrapper/output_format.py.

        Args:
            response: The requests response returned by `call_api`.
            query: The query dict used as defined in wrapper/input_format.py.
            body: The HTTP body of the query.

        Returns:
            The formatted response.
        """
        if self.result_format == "application/json":
            # Load into dict
            response = response.json()

            if self.collection == "search/sciencedirect":
                # Modify response to fit the defined wrapper output format
                response["query"] = query
                response["dbQuery"] = db_query
                response["apiKey"] = self.api_key
                response["result"] = {
                    "total": response.get("resultsFound", -1),
                    "start": self.__start_record + 1,
                    "pageLength": self.show_num,
                    "recordsDisplayed": len(response.get("results", []))
                }
                response["records"] = response.pop(
                    "results") if "results" in response else []
                for record in response.get("records") or []:
                    authors = []
                    for author in record.get("authors") or []:
                        authors.append(author["name"])
                    record["authors"] = authors
                    if "sourceTitle" in record:
                        record["publicationName"] = record.pop("sourceTitle")
                    record["publisher"] = "ScienceDirect"

                    # Delete all undefined fields
                    utils.clean_output(record, OUTPUT_FORMAT["records"][0])
            elif self.collection == "metadata/article":
                # TODO!
                raise NotImplementedError(
                    "No formatter defined for the metadata collection yet.")
            elif self.collection == "search/scopus":
                response = response.get("search-results")
                if not response:
                    # We need to only fill the error message. The rest is filled like normal and the
                    # records loop will not be executed.
                    response = utils.invalid_output(
                        *[None] * 3, "Scopus returned unknown format.", None,
                        None)
                response["query"] = query
                response["dbQuery"] = utils.get(
                    response,
                    "opensearch:Query",
                    "@searchTerms",
                    default=db_query,
                )
                response["apiKey"] = self.api_key
                response["records"] = response.pop(
                    "entry") if "entry" in response else []
                # Elsevier returns an object with an error field stating that the results are empty.
                if len(response["records"]
                       ) == 1 and "error" in response["records"][0]:
                    response["records"] = []
                response["result"] = {
                    "total": response.get("opensearch:totalResults", -1),
                    "start": self.__start_record + 1,
                    "pageLength": self.show_num,
                    "recordsDisplayed": len(response.get("records", [])),
                }
                countries = {}
                all_titles = ""
                for record in response.get("records"):
                    record["contentType"] = record.get("subtypeDescription")
                    record["title"] = record.get("dc:title")
                    all_titles += record["title"] + " " if record[
                        "title"] else ""
                    record["authors"] = [record.get("dc:creator")]
                    record["publicationName"] = record.get(
                        "prism:publicationName")
                    record["openAccess"] = record.get("openaccess")
                    record["doi"] = record.get("prism:doi")
                    record["publisher"] = "Elsevier"
                    record["publicationDate"] = record.get("prism:coverDate")
                    record["publicationType"] = record.get(
                        "prism:aggregationType")
                    record["issn"] = record.get("prism:issn")
                    record["volume"] = record.get("prism:volume")

                    page_range = record.get("prism:pageRange")
                    page_range = page_range.split("-") if page_range else []
                    record["pages"] = {
                        "first":
                        page_range[0] if len(page_range) > 0 else None,
                        "last": page_range[1] if len(page_range) > 1 else None,
                    }

                    for link_dict in record.get("link") or []:
                        if link_dict.get("@ref") == "scopus":
                            record["uri"] = link_dict.get("@href")
                            break

                    # Extract countries and their counter
                    country = utils.get(record, "affiliation", 0,
                                        "affiliation-country")
                    if country:
                        # Convert to ISO 3166-1 alpha-2 codes
                        try:
                            iso = utils.get(
                                pycountry.countries.search_fuzzy(country), 0)
                        except LookupError:
                            iso = None
                        # If no match was found the full name is readd.
                        country = iso.alpha_2 if iso else country
                        if country in countries:
                            countries[country] += 1
                        else:
                            countries[country] = 1

                    # Delete all undefined fields
                    utils.clean_output(record, OUTPUT_FORMAT["records"][0])

                keywords = utils.titles_to_keywords(all_titles)
                response["facets"] = {
                    "countries": countries,
                    "keywords": keywords,
                }

            # Delete all undefined fields
            utils.clean_output(response)

            return response
        else:
            print(
                f"No formatter defined for {self.result_format}. Returning response body."
            )
            return response.text