Restore constants to uppercase

babelfish/__init__.py

@@ -12,7 +12,7 @@
 
 from .converters import (LanguageConverter, LanguageReverseConverter, LanguageEquivalenceConverter, CountryConverter,
     CountryReverseConverter)
-from .country import country_converters, countries, country_matrix, Country
+from .country import country_converters, COUNTRIES, COUNTRY_MATRIX, Country
 from .exceptions import Error, LanguageConvertError, LanguageReverseError, CountryConvertError, CountryReverseError
-from .language import language_converters, languages, language_matrix, Language
-from .script import scripts, Script
+from .language import language_converters, LANGUAGES, LANGUAGE_MATRIX, Language
+from .script import SCRIPTS, Script

babelfish/converters/alpha2.py

@@ -6,12 +6,12 @@
 #
 from __future__ import unicode_literals
 from . import LanguageEquivalenceConverter
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class Alpha2Converter(LanguageEquivalenceConverter):
     CASE_SENSITIVE = True
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         if iso_language.alpha2:
             SYMBOLS[iso_language.alpha3] = iso_language.alpha2

babelfish/converters/alpha3b.py

@@ -6,12 +6,12 @@
 #
 from __future__ import unicode_literals
 from . import LanguageEquivalenceConverter
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class Alpha3BConverter(LanguageEquivalenceConverter):
     CASE_SENSITIVE = True
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         if iso_language.alpha3b:
             SYMBOLS[iso_language.alpha3] = iso_language.alpha3b

babelfish/converters/alpha3t.py

@@ -6,12 +6,12 @@
 #
 from __future__ import unicode_literals
 from . import LanguageEquivalenceConverter
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class Alpha3TConverter(LanguageEquivalenceConverter):
     CASE_SENSITIVE = True
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         if iso_language.alpha3t:
             SYMBOLS[iso_language.alpha3] = iso_language.alpha3t

babelfish/converters/countryname.py

@@ -6,7 +6,7 @@
 #
 from __future__ import unicode_literals
 from . import CountryReverseConverter, CaseInsensitiveDict
-from ..country import country_matrix
+from ..country import COUNTRY_MATRIX
 from ..exceptions import CountryConvertError, CountryReverseError
 
 
@@ -15,7 +15,7 @@ def __init__(self):
         self.codes = set()
         self.to_name = {}
         self.from_name = CaseInsensitiveDict()
-        for country in country_matrix:
+        for country in COUNTRY_MATRIX:
             self.codes.add(country.name)
             self.to_name[country.alpha2] = country.name
             self.from_name[country.name] = country.alpha2

babelfish/converters/name.py

@@ -6,12 +6,12 @@
 #
 from __future__ import unicode_literals
 from . import LanguageEquivalenceConverter
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class NameConverter(LanguageEquivalenceConverter):
     CASE_SENSITIVE = False
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         if iso_language.name:
             SYMBOLS[iso_language.alpha3] = iso_language.name

babelfish/converters/scope.py

@@ -7,13 +7,13 @@
 from __future__ import unicode_literals
 from . import LanguageConverter
 from ..exceptions import LanguageConvertError
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class ScopeConverter(LanguageConverter):
     FULLNAME = {'I': 'individual', 'M': 'macrolanguage', 'S': 'special'}
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         SYMBOLS[iso_language.alpha3] = iso_language.scope
     codes = set(SYMBOLS.values())
 

babelfish/converters/type.py

@@ -7,13 +7,13 @@
 from __future__ import unicode_literals
 from . import LanguageConverter
 from ..exceptions import LanguageConvertError
-from ..language import language_matrix
+from ..language import LANGUAGE_MATRIX
 
 
 class LanguageTypeConverter(LanguageConverter):
     FULLNAME = {'A': 'ancient', 'C': 'constructed', 'E': 'extinct', 'H': 'historical', 'L': 'living', 'S': 'special'}
     SYMBOLS = {}
-    for iso_language in language_matrix:
+    for iso_language in LANGUAGE_MATRIX:
         SYMBOLS[iso_language.alpha3] = iso_language.type
     codes = set(SYMBOLS.values())
 

babelfish/country.py

@@ -11,18 +11,18 @@
 from .converters import ConverterManager
 
 
-countries = {}
-country_matrix = []
+COUNTRIES = {}
+COUNTRY_MATRIX = []
 
-#: The namedtuple used in the :data:`country_matrix`
+#: The namedtuple used in the :data:`COUNTRY_MATRIX`
 IsoCountry = namedtuple('IsoCountry', ['name', 'alpha2'])
 
 f = resource_stream('babelfish', 'data/iso-3166-1.txt')
 f.readline()
 for l in f:
     iso_country = IsoCountry(*l.decode('utf-8').strip().split(';'))
-    countries[iso_country.alpha2] = iso_country.name
-    country_matrix.append(iso_country)
+    COUNTRIES[iso_country.alpha2] = iso_country.name
+    COUNTRY_MATRIX.append(iso_country)
 f.close()
 
 
@@ -55,7 +55,7 @@ class Country(CountryMeta(str('CountryBase'), (object,), {})):
 
     """
     def __init__(self, country):
-        if country not in countries:
+        if country not in COUNTRIES:
             raise ValueError('%r is not a valid country' % country)
 
         #: ISO-3166 2-letter country code

babelfish/language.py

@@ -14,18 +14,18 @@
 from .script import Script
 
 
-languages = set()
-language_matrix = []
+LANGUAGES = set()
+LANGUAGE_MATRIX = []
 
-#: The namedtuple used in the :data:`language_matrix`
+#: The namedtuple used in the :data:`LANGUAGE_MATRIX`
 IsoLanguage = namedtuple('IsoLanguage', ['alpha3', 'alpha3b', 'alpha3t', 'alpha2', 'scope', 'type', 'name', 'comment'])
 
 f = resource_stream('babelfish', 'data/iso-639-3.tab')
 f.readline()
 for l in f:
     iso_language = IsoLanguage(*l.decode('utf-8').split('\t'))
-    languages.add(iso_language.alpha3)
-    language_matrix.append(iso_language)
+    LANGUAGES.add(iso_language.alpha3)
+    LANGUAGE_MATRIX.append(iso_language)
 f.close()
 
 
@@ -75,9 +75,9 @@ class Language(LanguageMeta(str('LanguageBase'), (object,), {})):
 
     """
     def __init__(self, language, country=None, script=None, unknown=None):
-        if unknown is not None and language not in languages:
+        if unknown is not None and language not in LANGUAGES:
             language = unknown
-        if language not in languages:
+        if language not in LANGUAGES:
             raise ValueError('%r is not a valid language' % language)
         self.alpha3 = language
         self.country = None

babelfish/script.py

@@ -10,12 +10,12 @@
 
 
 #: Script code to script name mapping
-scripts = {}
+SCRIPTS = {}
 
 #: List of countries in the ISO-15924 as namedtuple of code, number, name, french_name, pva and date
-script_matrix = []
+SCRIPT_MATRIX = []
 
-#: The namedtuple used in the :data:`script_matrix`
+#: The namedtuple used in the :data:`SCRIPT_MATRIX`
 IsoScript = namedtuple('IsoScript', ['code', 'number', 'name', 'french_name', 'pva', 'date'])
 
 f = resource_stream('babelfish', 'data/iso15924-utf8-20131012.txt')
@@ -25,8 +25,8 @@
     if not l or l.startswith('#'):
         continue
     script = IsoScript._make(l.split(';'))
-    script_matrix.append(script)
-    scripts[script.code] = script.name
+    SCRIPT_MATRIX.append(script)
+    SCRIPTS[script.code] = script.name
 f.close()
 
 
@@ -39,7 +39,7 @@ class Script(object):
 
     """
     def __init__(self, script):
-        if script not in scripts:
+        if script not in SCRIPTS:
             raise ValueError('%r is not a valid script' % script)
 
         #: ISO-15924 4-letter script code
@@ -48,7 +48,7 @@ def __init__(self, script):
     @property
     def name(self):
         """English name of the script"""
-        return scripts[self.code]
+        return SCRIPTS[self.code]
 
     def __hash__(self):
         return hash(self.code)

babelfish/tests.py

@@ -10,7 +10,7 @@
 import sys
 from unittest import TestCase, TestSuite, TestLoader, TextTestRunner
 from pkg_resources import resource_stream  # @UnresolvedImport
-from babelfish import (languages, Language, Country, Script, language_converters, country_converters,
+from babelfish import (LANGUAGES, Language, Country, Script, language_converters, country_converters,
     LanguageReverseConverter, LanguageConvertError, LanguageReverseError, CountryReverseError)
 
 
@@ -143,7 +143,7 @@ def test_converter_name(self):
 
 class TestLanguage(TestCase, _Py26FixTestCase):
     def test_languages(self):
-        self.assertEqual(len(languages), 7874)
+        self.assertEqual(len(LANGUAGES), 7874)
 
     def test_wrong_language(self):
         self.assertRaises(ValueError, lambda: Language('zzz'))
@@ -206,14 +206,14 @@ def test_converter_opensubtitles(self):
         self.assertRaises(LanguageConvertError, lambda: Language('aaa').opensubtitles)
         self.assertEqual(len(language_converters['opensubtitles'].codes), 606)
 
-        # test with all the languages from the opensubtitles api
+        # test with all the LANGUAGES from the opensubtitles api
         # downloaded from: http://www.opensubtitles.org/addons/export_languages.php
         f = resource_stream('babelfish', 'data/opensubtitles_languages.txt')
         f.readline()
         for l in f:
             idlang, alpha2, _, upload_enabled, web_enabled = l.decode('utf-8').strip().split('\t')
             if not int(upload_enabled) and not int(web_enabled):
-                # do not test languages that are too esoteric / not widely available
+                # do not test LANGUAGES that are too esoteric / not widely available
                 continue
             self.assertEqual(Language.fromopensubtitles(idlang).opensubtitles, idlang)
             if alpha2: