Abfragen an andere Scraper

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

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

Abrufen von Ergebnissen von einem anderen Parser (integriert oder ein anderer JS-Parser), wobei folgende Argumente angegeben werden:

• parser - Name des Parsers (SE::Google, JS::Custom::Example)
• preset - Einstellungs-Preset des aufgerufenen Parsers
• overrideParams - Hash mit Überschreibungen der Einstellungen des aufgerufenen Parsers
• query - Abfrage

Ignoriert teilweise das Preset des aufgerufenen Parsers, das durch den Parameter preset definiert wird. Insbesondere werden die Einstellungen useproxy, proxyChecker, proxybannedcleanup von dem Parser übernommen, der await this.parser.request aufruft.

In overrideParams können Parameter des aufgerufenen Parsers überschrieben werden, außerdem sind folgende Flags verfügbar:

overrideParams.resultArraysWithObjects

resultArraysWithObjects: 0 - bestimmt, in welcher Form die Ergebnis-Arrays des aufgerufenen Parsers zurückgegeben werden:

• wenn aktiviert (1) - werden Arrays von Objekten zurückgegeben

  [{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]
• wenn deaktiviert (0) - werden Standard-Arrays von Werten zurückgegeben

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

Beispiel:

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

Beispielergebnis:

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 - bestimmt, ob data/pages[] in der Antwort übertragen werden soll (1) oder nicht (0), kann zur Optimierung verwendet werden

overrideParams.needResults

needResults: [ ... ] - Liste der Ergebnisse, die zurückgegeben werden sollen.

Beispiel:

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

Ergebnis:

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

Tipp

Funktioniert analog für API::Server::Redis

overrideParams.skipProxySettingsInheritance

skipProxySettingsInheritance: 0 - diese Option ermöglicht es, die Vererbung des Parameters useproxy für den aufgerufenen Parser zu deaktivieren

Abfragen an Parser, die den Batch-Modus unterstützen

Es wird auch der Aufruf von Scrapern unterstützt, die im Batch-Modus arbeiten. Dazu muss in query ein Array von Abfragen in der Form ['key1', 'key2', ...] übergeben werden.

Das Ergebnis der Verarbeitung durch den aufgerufenen Parser wird im Array bulkResults enthalten sein, unten ein Beispiel für ein solches Array:

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

Beispiel für den Aufruf eines anderen Parsers im Batch-Modus

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 // legt die Anzahl der Abfragen im "Batch" fest
    };

    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) // wandelt das Array von Objekten set.bulkQueries in ein Array der Form um [query1, query2, ... query10]
        );
        if(success) {
            // füllt die Ergebnisse in 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;
    }
}