Consultas a otros extractores

await this.parser.request(parser, preset, overrideParams, query)

await this.parser.request(parser, preset, overrideParams, query)

Obtención de resultados de otro extractor (integrado o de otro extractor JS), se especifican como argumentos:

• parser - nombre del extractor (SE::Google, JS::Custom::Example)
• preset - ajuste preestablecido de configuración del extractor llamado
• overrideParams - hash con las sobreescrituras de configuración del extractor llamado
• query - consulta

Ignora parcialmente el ajuste preestablecido del extractor llamado, que se establece mediante el parámetro preset. Específicamente, las configuraciones useproxy, proxyChecker, proxybannedcleanup se toman del extractor que llama a await this.parser.request.

En overrideParams se pueden sobreescribir los parámetros del extractor llamado, también están disponibles los siguientes indicadores:

overrideParams.resultArraysWithObjects

resultArraysWithObjects: 0 - determina en qué formato devolver los arreglos de resultados del extractor llamado:

• si está activado (1) - se devolverán arreglos de objetos

  [{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]
• si está desactivado (0) - se devolverán arreglos estándar de valores

  ['link1', 'anchor1', 'link2', 'anchor2', ...]

Ejemplo:

import { BaseParser } from 'a-parser-types';

class JS_DocExample extends BaseParser {
    static defaultConf: typeof BaseParser.defaultConf = {
        results_format: "$links.format('$link\n')",
        results: {
            arrays: {
                links: ['Links', [
                    ['link', 'link']
                ]]
            }
        }
    }

    async parse(set, results) {
        let response = await this.parser.request('SE::Google', 'default', {
            resultArraysWithObjects: 1,
            pagecount: 1
        }, set.query)
        results.success = response.success;
        
        if(response.success) {
            response.serp.forEach(element => {
                results.links.push(element.link);
            });
        }

        return results;
    }
}

Ejemplo de resultado:

https://www.speedtest.net/
https://www.investopedia.com/terms/t/t-test.asp
https://www.cdc.gov/coronavirus/2019-ncov/testing/diagnostic-testing.html
https://fast.com/
https://www.thinkwithgoogle.com/feature/testmysite/
https://projectstream.google.com/speedtest
https://www.nhs.uk/conditions/coronavirus-covid-19/testing/
https://www.fda.gov/consumers/consumer-updates/coronavirus-disease-2019-testing-basics
https://zoom.us/test
https://www.gov.uk/get-coronavirus-test
https://en.wikipedia.org/wiki/Test_(assessment)
...

overrideParams.needData

needData: 1 - determina si se transmite (1) o no (0) en la respuesta data/pages[], puede usarse para optimización

overrideParams.needResults

needResults: [ ... ] - lista de resultados que es necesario devolver.

Ejemplo:

let response = await this.parser.request('SE::Bing', 'default', {
    needResults: [
        'totalcount'
    ]
}, set.query)

Resultado:

{"success":1,"info":{"success":1,"retries":0},"totalcount":"2130000000"}

sugerencia

Funciona de la misma manera para API::Server::Redis

overrideParams.skipProxySettingsInheritance

skipProxySettingsInheritance: 0 - esta opción permite desactivar la herencia del parámetro useproxy para el extractor llamado

Consultas a extractores que admiten el modo por lotes

También se admite la comunicación con extractores que funcionan en modo por lotes. Para ello, en query se debe pasar un arreglo de consultas del tipo ['key1', 'key2', ...].

El resultado del procesamiento por el extractor llamado se contendrá en el arreglo bulkResults, a continuación un ejemplo de dicho arreglo:

{
    "bulkResults": [
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key1",
            "data": "..."
        },
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key2",
            "data": "..."
        },
        {
            "success": 1,
            "someArrayResult": [...],
            "someFlatResult": '...',
            "query": "key3",
            "data": "..."
        }
    ],
    "success": 1,
    "info": {
        "success": 1,
        "retries": 1
    }
}

Ejemplo de llamada a otro extractor en modo por lotes

import { BaseParser } from 'a-parser-types';

export class JS_Example_BulkQueries extends BaseParser {
    static defaultConf: typeof BaseParser.defaultConf = {
        version: '1.0.0',
        results: {
            flat: [
                ['views', 'Views count per month']
            ]
        },
        results_format: "$query: $views\\n",
        SE_Yandex_Direct_Frequency_preset: 'default',
        bulkQueries: 10 // establecemos la cantidad de consultas en el "paquete"
    };

    static editableConf: typeof BaseParser.editableConf = [
        ['SE_Yandex_Direct_Frequency_preset', ['combobox', 'SE::Yandex::Direct::Frequency preset']]
    ];

    async parse(set, results) {
        const { success, bulkResults } = await this.parser.request(
            'SE::Yandex::Direct::Frequency',
            this.conf.SE_Yandex_Direct_Frequency_preset,
            { useAccounts: 1 },
            set.bulkQueries.map((el) => el.query) // convertimos el arreglo de objetos set.bulkQueries en un arreglo del tipo [query1, query2, ... query10]
        );
        if(success) {
            // completamos los resultados en results.bulkResults
            for(let query_number = 0; query_number < set.bulkQueries.length; query_number++) {
                results.bulkResults[query_number].views = bulkResults[query_number].views;
                results.bulkResults[query_number].success = bulkResults[query_number].success;
            }
        }

        return results;
    }
}