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(
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:
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']
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']:
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)
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)
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
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)