diff --git a/README.md b/README.md index 95b1c4b..0c0e906 100644 --- a/README.md +++ b/README.md @@ -59,9 +59,16 @@ In [2]: apertium.append_pair_path('..') ### Translation Performing Translations +Method 1: ```python In [1]: import apertium In [2]: t = apertium.Translator('eng', 'spa') In [3]: t.translate('cats') Out[3]: 'Gatos' ``` +Method 2: +```python +In [1]: import apertium +In [2]: apertium.translate('eng', 'spa', 'I love you') +Out[2]: 'Te quieres' +``` diff --git a/apertium/__init__.py b/apertium/__init__.py index fc8d119..4472b8d 100644 --- a/apertium/__init__.py +++ b/apertium/__init__.py @@ -12,8 +12,8 @@ class ModeNotInstalled(ValueError): pass -def update_modes(pair_path): # type: (str) -> None - modes = search_path(pair_path) +def update_modes(path): # type: (str) -> None + modes = search_path(path) if modes['pair']: for path, lang_src, lang_trg in modes['pair']: pairs['%s-%s' % (lang_src, lang_trg)] = path @@ -25,14 +25,14 @@ def update_modes(pair_path): # type: (str) -> None generators[lang_pair] = (dirpath, modename) -def append_pair_path(pair_path): # type: (str) -> None - pair_paths.append(pair_path) - update_modes(pair_path) +def append_path(path): # type: (str) -> None + paths.append(path) + update_modes(path) -pair_paths = ['/usr/share/apertium', '/usr/local/share/apertium'] +paths = ['/usr/share/apertium', '/usr/local/share/apertium'] analyzers = {} # type: Dict[str, Tuple[str, str]] generators = {} # type: Dict[str, Tuple[str, str]] pairs = {} # type: Dict[str, str] -for pair_path in pair_paths: - update_modes(pair_path) +for path in paths: + update_modes(path) diff --git a/apertium/analysis/__init__.py b/apertium/analysis/__init__.py index b445b1d..78a9885 100644 --- a/apertium/analysis/__init__.py +++ b/apertium/analysis/__init__.py @@ -16,6 +16,18 @@ def __init__(self, lang): # type: (Analyzer, str) -> None else: self.path, self.mode = apertium.analyzers[self.lang] + def __repr__(self): # type: (Analyzer) -> str + """ + returns the representation of this Analyzer class object + """ + return "Analyzer(lang='%s')" % self.lang + + def __str__(self): # type: (Analyzer) -> str + """ + returns the printable str representation of the object + """ + return "" % self.mode + def _get_commands(self): # type: (Analyzer) -> List[List[str]] if self.lang not in self.analyzer_cmds: mode_path, mode = apertium.analyzers[self.lang] diff --git a/apertium/generation/__init__.py b/apertium/generation/__init__.py index 470fbfe..65dbf1c 100644 --- a/apertium/generation/__init__.py +++ b/apertium/generation/__init__.py @@ -10,7 +10,24 @@ class Generator: def __init__(self, lang): # type: (Generator, str) -> None self.generator_cmds = {} # type: Dict[str, List[List[str]]] - self.lang = lang # type: str + self.lang = to_alpha3_code(lang) # type: str + if self.lang in apertium.generators: + self.path, self.mode = apertium.generators[self.lang] + self.commands = list(self._get_commands()) + else: + raise apertium.ModeNotInstalled(self.lang) + + def __repr__(self): # type: (Generator) -> str + """ + returns the representation of this Generator class object + """ + return "Generator(lang='%s')" % self.lang + + def __str__(self): # type: (Generator) -> str + """ + returns the printable str representation of the object + """ + return "" % self.mode def _get_commands(self): # type: (Generator) -> List[List[str]] if self.lang not in self.generator_cmds: diff --git a/apertium/translation/__init__.py b/apertium/translation/__init__.py index d7f41b1..e3f1013 100644 --- a/apertium/translation/__init__.py +++ b/apertium/translation/__init__.py @@ -14,6 +14,18 @@ def __init__(self, l1, l2): # type: (Translator, str, str) -> None self.l1 = l1 self.l2 = l2 + def __repr__(self): # type: (Translator) -> str + """ + returns the representation of this Translator class object + """ + return "Translator(pair='%s-%s')" % (self.l1, self.l2) + + def __str__(self): # type: (Translator) -> str + """ + returns the printable str representation of the Translator object + """ + return "" % apertium.pairs['%s-%s' % (self.l1, self.l2)].split('/')[-1] + def _get_commands(self, l1, l2): # type: (Translator, str, str) -> List[List[str]] if (l1, l2) not in self.translation_cmds: mode_path = apertium.pairs['%s-%s' % (l1, l2)] diff --git a/tests/__init__.py b/tests/__init__.py index 3de7e36..fa8df87 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -30,6 +30,14 @@ def test_uninstalled_mode(self): with self.assertRaises(apertium.ModeNotInstalled): analyzer = apertium.Analyzer('spa') + def test_repr(self): + analyzer = apertium.Analyzer('en') + self.assertEqual(repr(analyzer), "Analyzer(lang='eng')") + + def test_str(self): + analyzer = apertium.Analyzer('en') + self.assertEqual(str(analyzer), "") + class TestGenerate(unittest.TestCase): def test_generator_single(self): @@ -48,9 +56,8 @@ def test_generator_bare(self): self.assertEqual(lexical_units, 'cat') def test_generator_uninstalled_mode(self): - generator = apertium.Generator('spa') with self.assertRaises(apertium.ModeNotInstalled): - generator.generate('cat') + generator = apertium.Generator('spa') def test_single(self): wordform = apertium.generate('en', '^cat$') @@ -68,6 +75,14 @@ def test_uninstalled_mode(self): with self.assertRaises(apertium.ModeNotInstalled): apertium.generate('spa', 'cat') + def test_repr(self): + generator = apertium.Generator('eng') + self.assertEqual(repr(generator), "Generator(lang='eng')") + + def test_str(self): + generator = apertium.Generator('eng') + self.assertEqual(str(generator), "") + class TestTranslate(unittest.TestCase): def test_translator_en_spa(self): @@ -78,3 +93,11 @@ def test_translator_en_spa(self): def test_en_spa(self): translated = apertium.translate('eng', 'spa', 'cats') self.assertEqual(translated, 'Gatos') + + def test_repr(self): + translator = apertium.Translator('eng', 'spa') + self.assertEqual(repr(translator), "Translator(pair='eng-spa')") + + def test_str(self): + translator = apertium.Translator('eng', 'spa') + self.assertEqual(str(translator), "")