Requêtes vers d'autres scrapers

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

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

Obtention des résultats d'un autre scraper (intégré ou un autre scraper JS), les arguments spécifiés sont :

• parser - nom du scraper (SE::Google, JS::Custom::Example)
• preset - préréglage des paramètres du scraper appelé
• overrideParams - hash avec les surcharges des paramètres du scraper appelé
• query - requête

Ignore partiellement le préréglage du scraper appelé, défini par le paramètre preset. Plus précisément, les paramètres useproxy, proxyChecker, proxybannedcleanup sont hérités du scraper qui appelle await this.parser.request.

Dans overrideParams, vous pouvez surcharger les paramètres du scraper appelé, les drapeaux suivants sont également disponibles :

overrideParams.resultArraysWithObjects

resultArraysWithObjects: 0 - détermine sous quelle forme retourner les tableaux de résultats du scraper appelé :

• si activé (1) - des tableaux d'objets seront retournés

  [{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]
• si désactivé (0) - des tableaux de valeurs standard seront retournés

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

Exemple :

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;
    }
}

Exemple de résultat :

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 - détermine s'il faut transmettre (1) ou non (0) data/pages[] dans la réponse, peut être utilisé pour l'optimisation

overrideParams.needResults

needResults: [ ... ] - liste des résultats qu'il est nécessaire de retourner.

Exemple :

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

Résultat :

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

astuce

Fonctionne de la même manière pour API::Server::Redis

overrideParams.skipProxySettingsInheritance

skipProxySettingsInheritance: 0 - cette option permet de désactiver l'héritage du paramètre useproxy pour le scraper appelé

Requêtes vers les scrapers supportant le mode par lots

L'appel aux scrapers fonctionnant en mode par lots est également supporté. Pour cela, il faut passer dans query un tableau de requêtes de type ['key1', 'key2', ...].

Le résultat du traitement par le scraper appelé sera contenu dans le tableau bulkResults, voici un exemple d'un tel tableau :

{
    "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
    }
}

Exemple d'appel à un autre scraper en mode par lots

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 // définit le nombre de requêtes dans le "lot"
    };

    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) // convertit le tableau d'objets set.bulkQueries en un tableau de type [query1, query2, ... query10]
        );
        if(success) {
            // remplit les résultats dans 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;
    }
}