def test_run_own_code_on(self):
lingua_franca.load_language('en')
# nice_number() has a run_own_code_on for unrecognized languages,
# because backwards compatibility requires it to fall back on
# str(input_value) rather than failing loudly
#
# 'cz' is not a supported language, so the function will raise
# an UnsupportedLanguageError, but nice_number() is decorated with
# @localized_function(run_own_code_on=[UnsupportedLanguageError])
self.assertEqual(lingua_franca.format.nice_number(123, lang='cz'),
"123")
self.assertEqual(lingua_franca.format.nice_number(123.45, speech=False, lang='cz'),
"123.45")
# It won't intercept other exceptions, though!
with self.assertRaises(ModuleNotFoundError):
unload_all_languages()
lingua_franca.format.nice_number(123.45)
# ModuleNotFoundError: No language module loaded.
with self.assertRaises(ValueError):
@localized_function("not an error type")
def foo_must_fail():
pass
with self.assertRaises(ValueError):
@localized_function(print)
def bar_must_fail_too():
pass
with self.assertRaises(ValueError):
@localized_function([1, 2, 3])
def baz_must_fail_as_well():
pass
def test_full_lang_code(self):
unload_all_languages()
self.assertEqual(lingua_franca.get_default_lang(), None)
# Return default full lang code if no primary code is passed
lingua_franca.load_language('en')
self.assertEqual(lingua_franca.get_full_lang_code(), 'en-us')
lingua_franca.load_language('es')
lingua_franca.set_default_lang('es')
self.assertEqual(lingua_franca.get_full_lang_code(), 'es-es')
# Go look up the default full code for a provided primary code
self.assertEqual(lingua_franca.get_full_lang_code('de'), 'de-de')
# Fail on wrong type, or language not recognized
with self.assertRaises(TypeError):
lingua_franca.get_full_lang_code(12)
# TODO remove this test and replace with the one below as soon as practical
self.assertWarns(DeprecationWarning, lingua_franca.get_full_lang_code,
"bob robertson")
# TODO this is the version of the test we should use once invalid lang
# params are deprecated:
#
# with self.assertRaises(
# lingua_franca.internal.UnsupportedLanguageError):
# lingua_franca.get_full_lang_code("bob robertson")
unload_all_languages()
def test_gender(self):
with self.assertRaises(FunctionNotLocalizedError):
get_gender("person") # lang="en-us"
load_language("pt")
self.assertEqual(get_gender("person", lang="pt"), None)
self.assertEqual(get_gender("vaca", lang="pt"), "f")
load_language("it")
self.assertEqual(get_gender('cavallo', lang='it'), 'm')
def test_auto_default_language(self):
lingua_franca.load_language('en')
# Load two languages, ensure first is default
lingua_franca.load_languages(['en', 'es'])
self.assertEqual(lingua_franca.get_default_lang(), 'en')
self.assertEqual(lingua_franca.parse.extract_number('one'), 1)
unload_all_languages()
def test_primary_lang_code(self):
unload_all_languages()
lingua_franca.load_language('en')
# should default to the default lang with no input
self.assertEqual(lingua_franca.get_primary_lang_code(), 'en')
with self.assertRaises(TypeError):
lingua_franca.get_primary_lang_code(12)
unload_all_languages()
def test_load_on_demand(self):
unload_all_languages()
lingua_franca.load_language("en")
lingua_franca.config.load_langs_on_demand = True
self.assertEqual(lingua_franca.parse.extract_number("one", lang="en"),
1)
self.assertEqual(lingua_franca.parse.extract_number("uno", lang="es"),
1)
lingua_franca.config.load_langs_on_demand = False
# English should still be loaded, but not Spanish
self.assertEqual(lingua_franca.parse.extract_number("one", lang="en"),
1)
with self.assertRaises(NoSuchModuleError):
lingua_franca.parse.extract_number("uno", lang="es")
unload_all_languages()
def test_load_language(self):
lingua_franca.load_language('en')
# Verify that English is loaded and, since it's the only language
# we've loaded, also the default.
self.assertEqual(lingua_franca.get_default_lang(), 'en')
# Verify that English's default full code is 'en-us'
self.assertEqual(lingua_franca.get_full_lang_code('en'), 'en-us')
# Verify that this is also our current full code
self.assertEqual(lingua_franca.get_default_loc(), 'en-us')
self.assertFalse('es' in lingua_franca.get_active_langs())
# Verify that unloaded languages can't be invoked explicitly
self.assertRaises(ModuleNotFoundError,
lingua_franca.parse.extract_number,
'uno', lang='es')
unload_all_languages()
def test_default_language_singles(self):
# Load languages one at a time, ensure first is default
self.assertEqual(lingua_franca.get_active_langs(), [])
lingua_franca.load_language('en')
self.assertEqual(lingua_franca.get_default_lang(), 'en')
lingua_franca.load_language('es')
self.assertEqual(lingua_franca.get_default_lang(), 'en')
self.assertEqual(lingua_franca.parse.extract_number('dos'), False)
self.assertEqual(lingua_franca.parse.extract_number('dos', lang='es'),
2)
# Verify default language failover
lingua_franca.unload_language('en')
self.assertEqual(lingua_franca.get_default_lang(), 'es')
unload_all_languages()
def setUpModule():
load_language('pt-pt')
set_default_lang('pt')
def setUpModule():
load_language('sv-se')
def setUpModule():
load_language('es')
set_default_lang('es')
def setUpModule():
load_language('it-it')
set_default_lang('it')
def setUpModule():
load_language("pl-pl")
set_default_lang("pl")
def setUpModule():
load_language('de-de')
def test_type_error(self):
with self.assertRaises(TypeError):
lingua_franca.load_language(12)
def setUpModule():
load_language('nl')
def setUpModule():
load_language('da-dk')
set_default_lang('da')
import pytest
from pathlib import Path
from lingua_franca import load_language
from lingua_franca.internal import UnsupportedLanguageError
from mycroft.configuration import Configuration, set_default_lf_lang
from mycroft.util.format import (TimeResolution, nice_number, nice_time,
nice_date, nice_date_time, nice_year,
nice_duration, nice_duration_dt,
pronounce_number, date_time_format, join_list)
# The majority of these tests are explicitly written for English.
# Changes to the default language are tested below.
default_lang = "en-us"
load_language(default_lang)
NUMBERS_FIXTURE_EN = {
1.435634: '1.436',
2: '2',
5.0: '5',
0.027: '0.027',
0.5: 'a half',
1.333: '1 and a third',
2.666: '2 and 2 thirds',
0.25: 'a forth',
1.25: '1 and a forth',
0.75: '3 forths',
1.75: '1 and 3 forths',
3.4: '3 and 2 fifths',
16.8333: '16 and 5 sixths',
def setUpModule():
load_language('hu-hu')
set_default_lang('hu')
def setUpModule():
load_language('nl-nl')
set_default_lang('nl-nl')
def test_function_not_localized_error(self):
lingua_franca.load_language('en')
with self.assertRaises(
lingua_franca.internal.FunctionNotLocalizedError):
lingua_franca.parse.is_ordinal("twelve")
unload_all_languages()
import lingua_franca
from jarvis.skills import intent_manager
from jarvis.skills.daily.timer import TimerSkill
from jarvis.skills.entertainement.decide import DecideSkill
from jarvis.skills.entertainement.jokes import JokesSkill
from jarvis.skills.entertainement.spotify import SpotifySkill
from jarvis.skills.entertainement.weather import WeatherSkill
from jarvis.skills.productivity.speedtest import SpeedTestSkill
from jarvis.skills.research.wikipedia import WikipediaSkill
from jarvis.utils import languages_utils, flask_utils
if __name__ == '__main__':
# Load lingua franca in the memory
# Supported : English French German Hungarian Italian Portuguese Swedish
lingua_franca.load_language(
lang=languages_utils.get_language_only_country())
# Tests
WikipediaSkill().register()
JokesSkill().register()
SpotifySkill().register()
SpeedTestSkill().register()
DecideSkill().register()
TimerSkill().register()
WeatherSkill().register()
# Load all skills
intent_manager.load_all_skills()
# Train Padatious models
intent_manager.train_padatious()
"""Tests for the mycroft skill's get_response variations."""
from os.path import dirname, join
from threading import Thread
import time
from unittest import TestCase, mock
from lingua_franca import load_language
from mycroft import MycroftSkill
from mycroft.messagebus import Message
from test.unittests.mocks import base_config, AnyCallable
load_language("en-us")
def create_converse_responder(response, skill):
"""Create a function to inject a response into the converse method.
The function waits for the converse method to be replaced by the
_wait_response logic and afterwards injects the provided response.
Args:
response (str): Sentence to inject.
skill (MycroftSkill): skill to monitor.
"""
default_converse = skill.converse
converse_return = None
def wait_for_new_converse():
def setUpModule():
load_language("cs-cz")
set_default_lang("cs")
def setUpModule():
load_language('fr-fr')
set_default_lang('fr')
def setUpModule():
load_language("de-de")
set_default_lang("de")
