Improved repr

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'
+```

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)

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 "<Analyzer: '%s'>" % 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]

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 "<Generator: '%s'>" % self.mode
 
     def _get_commands(self):  # type: (Generator) -> List[List[str]]
         if self.lang not in self.generator_cmds:

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 "<Translator: '%s'>" % 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)]

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), "<Analyzer: 'eng-morph'>")
+
 
 class TestGenerate(unittest.TestCase):
     def test_generator_single(self):
@@ -48,9 +56,8 @@ def test_generator_bare(self):
         self.assertEqual(lexical_units, 'cat<n><pl>')
 
     def test_generator_uninstalled_mode(self):
-        generator = apertium.Generator('spa')
         with self.assertRaises(apertium.ModeNotInstalled):
-            generator.generate('cat<n><pl>')
+            generator = apertium.Generator('spa')
 
     def test_single(self):
         wordform = apertium.generate('en', '^cat<n><pl>$')
@@ -68,6 +75,14 @@ def test_uninstalled_mode(self):
         with self.assertRaises(apertium.ModeNotInstalled):
             apertium.generate('spa', 'cat<n><pl>')
 
+    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), "<Generator: 'eng-gener'>")
+
 
 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), "<Translator: 'en-es.mode'>")