def __init__(self):
     self._simple_cases_regexes = [
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.SimpleCasesRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.BetweenRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.OneWordPeriodRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.MonthWithYear),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.MonthNumWithYear),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.YearRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WeekOfMonthRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WeekOfYearRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.MonthFrontBetweenRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.MonthFrontSimpleCasesRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.QuarterRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.QuarterRegexYearFront),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.AllHalfYearRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.SeasonRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WhichWeekRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.RestOfDateRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.LaterEarlyPeriodRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.WeekWithWeekDayRangeRegex)
     ]
     self._illegal_year_regex = RegExpUtility.get_safe_reg_exp(
         BaseDateTime.IllegalYearRegex)
     self._year_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.YearRegex)
     self._till_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.TillRegex)
     self._followed_unit = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.FollowedDateUnit)
     self._number_combined_with_unit = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.NumberCombinedWithDateUnit)
     self._past_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.PastPrefixRegex)
     self._future_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.NextPrefixRegex)
     self._week_of_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.WeekOfRegex)
     self._month_of_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.MonthOfRegex)
     self._date_unit_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.DateUnitRegex)
     self._in_connector_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.InConnectorRegex)
     self._range_unit_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.RangeUnitRegex)
     self._date_point_extractor = BaseDateExtractor(
         EnglishDateExtractorConfiguration())
     self._integer_extractor = EnglishIntegerExtractor()
     self._number_parser = BaseNumberParser(
         EnglishNumberParserConfiguration())
     self._duration_extractor = BaseDurationExtractor(
         EnglishDurationExtractorConfiguration())
     self._range_connector_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.RangeConnectorRegex)
Example #2
0
 def __init__(self, culture_info: CultureInfo):
     if culture_info is None:
         culture_info = CultureInfo(Culture.English)
     super().__init__(culture_info)
     self._internal_number_extractor = EnglishNumberExtractor(
         NumberMode.DEFAULT)
     self._internal_number_parser = AgnosticNumberParserFactory.get_parser(
         ParserType.NUMBER, EnglishNumberParserConfiguration(culture_info))
 def __init__(self, config):
     self._cardinal_extractor: BaseNumberExtractor = EnglishCardinalExtractor()
     self._number_parser: BaseNumberParser = BaseNumberParser(EnglishNumberParserConfiguration())
     self._followed_unit: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.DurationFollowedUnit)
     self._suffix_and_regex: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.SuffixAndRegex)
     self._number_combined_with_unit: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.NumberCombinedWithDurationUnit)
     self._an_unit_regex: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.AnUnitRegex)
     self._all_date_unit_regex: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.AllRegex)
     self._half_date_unit_regex: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.HalfRegex)
     self._inexact_number_unit_regex: Pattern = RegExpUtility.get_safe_reg_exp(EnglishDateTime.InexactNumberUnitRegex)
     self._unit_map: Dict[str, int] = EnglishDateTime.UnitMap
     self._unit_value_map: Dict[str, int] = EnglishDateTime.UnitValueMap
     self._double_numbers: Dict[str, float] = EnglishDateTime.DoubleNumbers
Example #4
0
    def __init__(self):
        BaseDateParserConfiguration.__init__(self)

        self._utility_configuration = EnglishDateTimeUtilityConfiguration()
        self._unit_map = EnglishDateTime.UnitMap
        self._unit_value_map = EnglishDateTime.UnitValueMap
        self._season_map = EnglishDateTime.SeasonMap
        self._cardinal_map = EnglishDateTime.CardinalMap
        self._day_of_week = EnglishDateTime.DayOfWeek
        self._month_of_year = EnglishDateTime.MonthOfYear
        self._numbers = EnglishDateTime.Numbers
        self._double_numbers = EnglishDateTime.DoubleNumbers
        self._cardinal_extractor = EnglishCardinalExtractor()
        self._integer_extractor = EnglishIntegerExtractor()
        self._ordinal_extractor = EnglishOrdinalExtractor()
        self._check_both_before_after = EnglishDateTime.CheckBothBeforeAfter
        self._day_of_month = {
            **BaseDateTime.DayOfMonthDictionary,
            **EnglishDateTime.DayOfMonth
        }
        self._time_zone_parser = BaseTimeZoneParser()
        self._number_parser = BaseNumberParser(
            EnglishNumberParserConfiguration())
        self._date_extractor = BaseDateExtractor(
            EnglishDateExtractorConfiguration())
        self._time_extractor = BaseTimeExtractor(
            EnglishTimeExtractorConfiguration())
        self._duration_extractor = BaseDurationExtractor(
            EnglishDurationExtractorConfiguration())
        self._date_period_extractor = BaseDatePeriodExtractor(
            EnglishDatePeriodExtractorConfiguration())
        self._time_period_extractor = BaseTimePeriodExtractor(
            EnglishTimePeriodExtractorConfiguration())
        self._date_time_extractor = BaseDateTimeExtractor(
            EnglishDateTimeExtractorConfiguration())
        self._date_time_period_extractor = BaseDateTimePeriodExtractor(
            EnglishDateTimePeriodExtractorConfiguration())
        self._duration_parser = BaseDurationParser(
            EnglishDurationParserConfiguration(self))
        self._date_parser = BaseDateParser(
            EnglishDateParserConfiguration(self))
        self._time_parser = EnglishTimeParser(
            EnglishTimeParserConfiguration(self))
        self._date_period_parser = BaseDatePeriodParser(
            EnglishDatePeriodParserConfiguration(self))
        self._time_period_parser = BaseTimePeriodParser(
            EnglishTimePeriodParserConfiguration(self))
        self._date_time_parser = BaseDateTimeParser(
            EnglishDateTimeParserConfiguration(self))
        self._date_time_period_parser = BaseDateTimePeriodParser(
            EnglishDateTimePeriodParserConfiguration(self))
class TestInitializationNumberRecognizer():
    control_model = NumberModel(
        AgnosticNumberParserFactory.get_parser(
            ParserType.NUMBER, EnglishNumberParserConfiguration()),
        EnglishNumberExtractor(NumberMode.PURE_NUMBER))
    english_culture = Culture.English
    spanish_culture = Culture.Spanish
    invalid_culture = "vo-id"

    def assert_models_equal(self, expected, actual):
        assert actual.model_type_name == expected.model_type_name
        assert isinstance(actual.extractor, type(expected.extractor))
        assert isinstance(actual.parser.config, type(expected.parser.config))

    def assert_models_distinct(self, expected, actual):
        assert actual.model_type_name == expected.model_type_name
        assert not isinstance(actual.extractor, type(expected.extractor))
        assert not isinstance(actual.parser.config, type(
            expected.parser.config))

    def test_without_culture_use_target_culture(self):
        recognizer = NumberRecognizer(self.english_culture)
        self.assert_models_equal(self.control_model,
                                 recognizer.get_number_model())

    def test_withOtherCulture_not_use_target_culture(self):
        recognizer = NumberRecognizer(self.english_culture)
        self.assert_models_distinct(
            self.control_model,
            recognizer.get_number_model(self.spanish_culture))

    def test_with_invalid_culture_use_target_culture(self):
        recognizer = NumberRecognizer(self.spanish_culture)
        self.assert_models_equal(
            self.control_model,
            recognizer.get_number_model(self.invalid_culture))

    def test_with_invalid_culture_and_without_fallback_throw_error(self):
        recognizer = NumberRecognizer()
        with pytest.raises(ValueError):
            recognizer.get_number_model(self.invalid_culture, False)

    def test_with_invalid_culture_as_target_and_without_fallback_throw_error(
            self):
        recognizer = NumberRecognizer(self.invalid_culture)
        with pytest.raises(ValueError):
            recognizer.get_number_model(None, False)

    def test_without_target_culture_and_without_culture_fallback_to_english_culture(
            self):
        recognizer = NumberRecognizer()
        self.assert_models_equal(self.control_model,
                                 recognizer.get_number_model())

    def test_initialization_with_int_option_resolve_options_enum(self):
        recognizer = NumberRecognizer(self.english_culture, NumberOptions.NONE,
                                      False)
        assert (recognizer.options & NumberOptions.NONE) == NumberOptions.NONE

    def test_initialization_with_invalid_options_throw_error(self):
        with pytest.raises(ValueError):
            NumberRecognizer(self.invalid_culture, -1)
Example #6
0
    def initialize_configuration(self):
        # region English
        self.register_model(
            'NumberModel', Culture.English, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, EnglishNumberParserConfiguration()),
                EnglishNumberExtractor(NumberMode.PURE_NUMBER)))
        self.register_model(
            'OrdinalModel', Culture.English, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, EnglishNumberParserConfiguration()),
                EnglishOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.English, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, EnglishNumberParserConfiguration()),
                EnglishPercentageExtractor()))
        # endregion

        # region German
        # self.register_model('NumberModel', Culture.German, lambda options: NumberModel(
        #    AgnosticNumberParserFactory.get_parser(
        #        ParserType.NUMBER, GermanNumberParserConfiguration()),
        #    GermanNumberExtractor(NumberMode.PURE_NUMBER)
        # ))
        # self.register_model('OrdinalModel', Culture.German, lambda options: OrdinalModel(
        #    AgnosticNumberParserFactory.get_parser(
        #        ParserType.ORDINAL, GermanNumberParserConfiguration()),
        #    GermanOrdinalExtractor()
        # ))
        # self.register_model('PercentModel', Culture.German, lambda options: PercentModel(
        #    AgnosticNumberParserFactory.get_parser(
        #        ParserType.PERCENTAGE, GermanNumberParserConfiguration()),
        #    GermanPercentageExtractor()
        # ))
        # endregion

        # region Chinese
        self.register_model(
            'NumberModel', Culture.Chinese, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, ChineseNumberParserConfiguration()),
                ChineseNumberExtractor()))
        self.register_model(
            'OrdinalModel', Culture.Chinese, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, ChineseNumberParserConfiguration()),
                ChineseOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.Chinese, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, ChineseNumberParserConfiguration()),
                ChinesePercentageExtractor()))
        # endregion

        # region Japanese
        self.register_model(
            'NumberModel', Culture.Japanese, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, JapaneseNumberParserConfiguration()),
                JapaneseNumberExtractor()))
        self.register_model(
            'OrdinalModel', Culture.Japanese, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, JapaneseNumberParserConfiguration()),
                JapaneseOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.Japanese, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, JapaneseNumberParserConfiguration()
                ), JapanesePercentageExtractor()))
        # endregion

        # region Spanish
        self.register_model(
            'NumberModel', Culture.Spanish, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, SpanishNumberParserConfiguration()),
                SpanishNumberExtractor(NumberMode.PURE_NUMBER)))
        self.register_model(
            'OrdinalModel', Culture.Spanish, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, SpanishNumberParserConfiguration()),
                SpanishOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.Spanish, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, SpanishNumberParserConfiguration()),
                SpanishPercentageExtractor()))
        # endregion

        # region Portuguese
        self.register_model(
            'NumberModel', Culture.Portuguese, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, PortugueseNumberParserConfiguration()),
                PortugueseNumberExtractor(NumberMode.PURE_NUMBER)))
        self.register_model(
            'OrdinalModel', Culture.Portuguese, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, PortugueseNumberParserConfiguration()),
                PortugueseOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.Portuguese, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, PortugueseNumberParserConfiguration(
                    )), PortuguesePercentageExtractor()))
        # endregion

        # region French
        self.register_model(
            'NumberModel', Culture.French, lambda options: NumberModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.NUMBER, FrenchNumberParserConfiguration()),
                FrenchNumberExtractor(NumberMode.PURE_NUMBER)))
        self.register_model(
            'OrdinalModel', Culture.French, lambda options: OrdinalModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.ORDINAL, FrenchNumberParserConfiguration()),
                FrenchOrdinalExtractor()))
        self.register_model(
            'PercentModel', Culture.French, lambda options: PercentModel(
                AgnosticNumberParserFactory.get_parser(
                    ParserType.PERCENTAGE, FrenchNumberParserConfiguration()),
                FrenchPercentageExtractor()))
 def __init__(self):
     self._simple_cases_regexes = [
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.SimpleCasesRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.BetweenRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.OneWordPeriodRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.MonthWithYear),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.MonthNumWithYear),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.YearRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WeekOfMonthRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WeekOfYearRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.MonthFrontBetweenRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.MonthFrontSimpleCasesRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.QuarterRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.QuarterRegexYearFront),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.AllHalfYearRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.SeasonRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.WhichWeekRegex),
         RegExpUtility.get_safe_reg_exp(EnglishDateTime.RestOfDateRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.LaterEarlyPeriodRegex),
         RegExpUtility.get_safe_reg_exp(
             EnglishDateTime.WeekWithWeekDayRangeRegex)
     ]
     self._illegal_year_regex = RegExpUtility.get_safe_reg_exp(
         BaseDateTime.IllegalYearRegex)
     self._year_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.YearRegex)
     self._till_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.TillRegex)
     self._followed_unit = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.FollowedDateUnit)
     self._number_combined_with_unit = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.NumberCombinedWithDateUnit)
     self._past_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.PreviousPrefixRegex)
     self._future_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.NextPrefixRegex)
     self._week_of_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.WeekOfRegex)
     self._month_of_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.MonthOfRegex)
     self._date_unit_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.DateUnitRegex)
     self._in_connector_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.InConnectorRegex)
     self._range_unit_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.RangeUnitRegex)
     self._date_point_extractor = BaseDateExtractor(
         EnglishDateExtractorConfiguration())
     self._integer_extractor = EnglishIntegerExtractor()
     self._number_parser = BaseNumberParser(
         EnglishNumberParserConfiguration())
     self._duration_extractor = BaseDurationExtractor(
         EnglishDurationExtractorConfiguration())
     self._range_connector_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.RangeConnectorRegex)
     self._now_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.NowRegex)
     self._within_next_prefix_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.WithinNextPrefixRegex)
     self._time_unit_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.TimeUnitRegex)
     self._future_suffix_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.FutureSuffixRegex)
     self._ago_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.AgoRegex)
     self._later_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.LaterRegex)
     self._less_than_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.LessThanRegex)
     self._more_than_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.MoreThanRegex)
     self._duration_date_restrictions = EnglishDateTime.DurationDateRestrictions
     self._year_period_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.YearPeriodRegex)
     self._month_num_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.MonthNumRegex)
     self._century_suffix_regex = RegExpUtility.get_safe_reg_exp(
         EnglishDateTime.CenturySuffixRegex)
     self._ordinal_extractor = EnglishOrdinalExtractor()
     # TODO When the implementation for these properties is added, change the None values to their respective Regexps
     self._cardinal_extractor = EnglishCardinalExtractor()