Python get_specs примеры использования

Пример #1

Файл: test_runner_datetime.py Проект: wxrui/Recognizers-Text

import importlib
import re
import datetime
import pytest
from runner import get_specs, CULTURES
from recognizers_date_time import recognize_datetime

MODELFUNCTION = {'DateTime': recognize_datetime}


@pytest.mark.parametrize(
    'culture, model, options, context, source, expected_results',
    get_specs(recognizer='DateTime', entity='Extractor'))
def test_datetime_extractor(culture, model, options, context, source,
                            expected_results):

    reference_datetime = get_reference_date(context)
    language = get_language(culture)
    extractor = create_extractor(language, model, options)

    result = extractor.extract(source, reference_datetime)

    assert len(result) == len(expected_results)
    for actual, expected in zip(result, expected_results):
        simple_extractor_assert(actual, expected, 'text', 'Text')
        simple_extractor_assert(actual, expected, 'type', 'Type')
        simple_extractor_assert(actual, expected, 'start', 'Start')
        simple_extractor_assert(actual, expected, 'length', 'Length')


@pytest.mark.parametrize(

Пример #2

import pytest
from runner import get_specs
from recognizers_number_with_unit.number_with_unit.number_with_unit_recognizer import recognize_age, recognize_currency, recognize_dimension, recognize_temperature

MODELFUNCTION = {
    'Age': recognize_age,
    'Currency': recognize_currency,
    'Temperature': recognize_temperature,
    'Dimension': recognize_dimension,
}


@pytest.mark.parametrize(
    'culture, model, options, context, source, expected_results',
    get_specs(recognizer='NumberWithUnit', entity='Model'))
def test_number_with_unit_recognizer(culture, model, options, context, source,
                                     expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for actual, expected in zip(results, expected_results):
        assert actual.text == expected['Text']
        assert actual.type_name == expected['TypeName']
        resoultion_assert(actual, expected, ['value', 'unit', 'isoCurrency'])


def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)


def resoultion_assert(actual, expected, props):
    if expected['Resolution'] is None:

Пример #3

import pytest
from runner import get_specs
from recognizers_number.number import NumberRecognizer

MODELFUNCTION = {
    'NumberModel': NumberRecognizer.recognize_number,
    'OrdinalModel': NumberRecognizer.recognize_ordinal,
    'PercentModel': NumberRecognizer.recognize_percentage,
}

def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)

@pytest.mark.parametrize('culture, model, source, expected_results', get_specs('Number'))
def test_number_recognizer(culture, model, source, expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for expected, actual in zip(expected_results, results):
        assert expected['TypeName'] == actual.type_name
        assert expected['Text'] == actual.text
        assert expected['Resolution']['value'] == actual.resolution['value']

Пример #4

Файл: test_runner_sequence.py Проект: yanhuiw/Recognizers-Text

import pytest
from runner import get_specs
from recognizers_sequence.sequence.sequence_recognizer import recognize_phone_number, recognize_email

MODEL_FUNCTION = {
    'PhoneNumber': recognize_phone_number,
    'Email': recognize_email,
}


@pytest.mark.parametrize(
    'culture, model, options, context, source, expected_results',
    get_specs(recognizer='Sequence', entity='Model'))
def test_sequence_recognizer(culture, model, options, context, source,
                             expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for actual, expected in zip(results, expected_results):
        assert actual.type_name == expected['TypeName']
        assert actual.text == expected['Text']
        assert actual.resolution['value'] == expected['Resolution']['value']
        resolution_assert(actual, expected, ['value', 'score'])


def get_results(culture, model, source):
    return MODEL_FUNCTION[model](source, culture)


def resolution_assert(actual, expected, props):
    for prop in props:
        if prop in expected['Resolution']:

Пример #5

Файл: test_runner_choice.py Проект: zhamppx97/Recognizers-Text

import pytest
from runner import get_specs
from recognizers_choice import recognize_boolean

MODELFUNCTION = {'Boolean': recognize_boolean}


@pytest.mark.parametrize(
    'culture, model, options, context, source, expected_results',
    get_specs(recognizer='Choice', entity='Model'))
def test_choice_recognizer(culture, model, options, context, source,
                           expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for actual, expected in zip(results, expected_results):
        assert actual.type_name == expected['TypeName']
        assert actual.text == expected['Text']
        assert actual.resolution['value'] == expected['Resolution']['value']


def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)

Пример #6

Файл: test_runner_number.py Проект: yazici/Recognizers-Text

import pytest
from runner import get_specs
from recognizers_number.number.number_recognizer import recognize_number, recognize_ordinal, recognize_percentage

MODELFUNCTION = {
    'Number': recognize_number,
    'Ordinal': recognize_ordinal,
    'Percent': recognize_percentage,
}


@pytest.mark.parametrize(
    'culture, model, options, context, source, expected_results',
    get_specs(recognizer='Number', entity='Model'))
def test_number_recognizer(culture, model, options, context, source,
                           expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for actual, expected in zip(results, expected_results):
        assert actual.type_name == expected['TypeName']
        assert actual.text == expected['Text']
        assert actual.start == expected['Start']
        assert actual.end == expected['End']
        assert actual.resolution['value'] == expected['Resolution']['value']


def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)

Пример #7

import pytest
from runner import get_specs
from recognizers_number_with_unit.number_with_unit import NumberWithUnitRecognizer

MODELFUNCTION = {
    'AgeModel': NumberWithUnitRecognizer.recognize_age,
    'CurrencyModel': NumberWithUnitRecognizer.recognize_currency,
    'TemperatureModel': NumberWithUnitRecognizer.recognize_temperature,
    'DimensionModel': NumberWithUnitRecognizer.recognize_dimension,
}


def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)


@pytest.mark.parametrize('culture, model, source, expected_results',
                         get_specs('NumberWithUnit'))
def test_number_with_unit_recognizer(culture, model, source, expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for expected, actual in zip(expected_results, results):
        assert expected['Text'] == actual.text
        assert expected['TypeName'] == actual.type_name
        if expected['Resolution'] is None:
            assert actual.resolution is None
        else:
            expected_resolution = expected['Resolution']
            assert expected_resolution['value'] == actual.resolution.value
            assert expected_resolution['unit'] == actual.resolution.unit

Пример #8

Файл: test_runner_number.py Проект: yooper/Recognizers-Text

import pytest
from runner import get_specs
from recognizers_number.number.number_recognizer import recognize_number, recognize_ordinal, recognize_percentage

MODELFUNCTION = {
    'Number': recognize_number,
    'Ordinal': recognize_ordinal,
    'Percent': recognize_percentage,
}

@pytest.mark.parametrize('culture, model, options, context, source, expected_results', get_specs(recognizer='Number', entity='Model'))
def test_number_recognizer(culture, model, options, context, source, expected_results):
    results = get_results(culture, model, source)
    assert len(results) == len(expected_results)
    for actual, expected in zip(results, expected_results):
        assert actual.type_name == expected['TypeName']
        assert actual.text == expected['Text']
        assert actual.start == expected['Start']
        assert actual.end == expected['End']
        assert actual.resolution['value'] == expected['Resolution']['value']

def get_results(culture, model, source):
    return MODELFUNCTION[model](source, culture)