async def METHOD_NAME(
        _,
        pquery: PqueryFormArgs,
        raw_queries: Dict[str, List[str]],
        subcpath: str,
        user_id: int,
        collator_locale: str):
    """
    Calculate paradigmatic query providing existing concordances. Althought the calculation
    consists of multiple independent freq. distrib. calculations, several tests have shown
    that there is almost no gain from running the calculations in parallel. So we stick with
    async Tasks by default. But for testing/benchmarking purposes, there are also some
    alternative implementations is the 'extra' package.
    pquery --
    raw_queries -- a mapping between conc_id and actual query understood by Manatee
    subcpath -- a root path to user subcorpora
    user_id -- user ID
    collator_locale -- a locale used for collation within the current corpus
    """
    specif_futures = []
    for conc_id in pquery.conc_ids:
        freq_args = create_freq_calc_args(
            pquery=pquery, conc_id=conc_id, raw_queries=raw_queries, subcpath=subcpath, user_id=user_id,
            collator_locale=collator_locale)
        specif_futures.append(asyncio.create_task(calculate_freqs_bg(freq_args)))
    # calculate auxiliary data for the "(almost) never" condition
    cond1_futures = []
    if pquery.conc_subset_complements:
        for conc_id in pquery.conc_subset_complements.conc_ids:
            freq_args = create_freq_calc_args(
                pquery=pquery, conc_id=conc_id, raw_queries=raw_queries, subcpath=subcpath, user_id=user_id,
                collator_locale=collator_locale, flimit_override=1)
            cond1_futures.append(asyncio.create_task(calculate_freqs_bg(freq_args)))
    # calculate auxiliary data (the superset here) for the "(almost) always" condition
    cond2_future = None
    if pquery.conc_superset:
        freq_args = create_freq_calc_args(
            pquery=pquery, conc_id=pquery.conc_superset.conc_id, raw_queries=raw_queries, subcpath=subcpath,
            user_id=user_id, collator_locale=collator_locale)
        cond2_future = asyncio.create_task(calculate_freqs_bg(freq_args))
    # merge frequencies of individual realizations
    realizations = await asyncio.gather(*specif_futures)
    merged = defaultdict(lambda: [])
    for freq_table in realizations:
        freq_info = extract_freqs(freq_table)
        for word, freq in freq_info:
            merged[word].append(freq)
    for w in list(merged.keys()):
        if len(merged[w]) < len(pquery.conc_ids):  # all the realizations must be present
            del merged[w]
    if len(cond1_futures) > 0:
        # ask for the results of the "(almost) never"
        # and filter out values with too high ratio of "opposite examples"
        complements = defaultdict(lambda: 0)
        for cond1_item in (await asyncio.gather(*cond1_futures)):
            for v, freq in extract_freqs(cond1_item):
                complements[v] += freq
        for k in [k2 for k2 in merged.keys() if k2 in complements]:
            ratio = complements[k] / (sum(merged[k]) + complements[k])
            if ratio * 100 > pquery.conc_subset_complements.max_non_matching_ratio:
                del merged[k]
    if cond2_future is not None:
        # ask for the results of the "(almost) always"
        # and filter out values found as extra instances too many times in the superset
        cond2_freqs = defaultdict(
            lambda: 0, **dict((v, f) for v, f in extract_freqs(await cond2_future)))
        for k in list(merged.keys()):
            if cond2_freqs[k] == 0:  # => not in superset
                del merged[k]
            elif cond2_freqs[k] > sum(merged[k]):  # if there are extra instances in the superset
                ratio = 100 - sum(merged[k]) / cond2_freqs[k] * 100
                if ratio > pquery.conc_superset.max_non_matching_ratio:
                    del merged[k]
    items = list((w, ) + tuple(freq) for w, freq in merged.items())
    total_row = [('total', len(items)) + tuple(None for _ in range(len(pquery.conc_ids) - 1))]
    return total_row + sorted(items, key=lambda v: sum(v[1:]), reverse=True)