Refactoring in builtin providers

mimesis/__init__.py

@@ -28,5 +28,8 @@
     'Text',
     'Transport',
     'UnitSystem',
+    'Cryptographic',
+
+    # Has all:
     'Generic',
 ]

mimesis/builtins/__init__.py

@@ -2,10 +2,12 @@
 from .ja import JapanSpecProvider
 from .ru import RussiaSpecProvider
 from .pt_br import BrazilSpecProvider
+from .de import GermanySpecProvider
 
 __all__ = [
     'USASpecProvider',
     'JapanSpecProvider',
     'RussiaSpecProvider',
     'BrazilSpecProvider',
+    'GermanySpecProvider',
 ]

mimesis/builtins/base.py

@@ -0,0 +1,9 @@
+from random import Random
+
+from mimesis.providers import Code
+
+
+class BaseSpecProvider(object):
+    def __init__(self):
+        self.random = Random()
+        self.code = Code().custom_code

mimesis/builtins/de.py

@@ -0,0 +1,23 @@
+from mimesis.utils import pull
+from mimesis.builtins.base import BaseSpecProvider
+
+
+class GermanySpecProvider(BaseSpecProvider):
+    def __init__(self):
+        super().__init__()
+        self._data = pull('builtin.json', 'de')
+
+    class Meta:
+        name = 'germany_provider'
+
+    def noun(self, plural=False):
+        """Return a random noun in German.
+
+        :param plural: Return noun in plural.
+        :return: Noun.
+        """
+
+        key = 'plural' if \
+            plural else 'noun'
+
+        return self.random.choice(self._data[key])

mimesis/builtins/en.py

@@ -1,19 +1,13 @@
-from random import choice, randint
+from mimesis.builtins.base import BaseSpecProvider
 
-from mimesis.providers.code import Code
 
-# Internal
-_custom_code = Code().custom_code
-
-
-class USASpecProvider(object):
+class USASpecProvider(BaseSpecProvider):
     """Class that provides special data for en"""
 
     class Meta:
         name = 'usa_provider'
 
-    @staticmethod
-    def tracking_number(service='usps'):
+    def tracking_number(self, service='usps'):
         """Generate random tracking number for USPS, FedEx and UPS.
 
         :param service: Post service.
@@ -37,27 +31,28 @@ def tracking_number(service='usps'):
                 '1Z@####@##########',
             ),
         }
-        mask = choice(services[service])
-        return _custom_code(mask=mask)
+        mask = self.random.choice(services[service])
+        return self.code(mask=mask)
 
-    @staticmethod
-    def ssn():
+    def ssn(self):
         """Generate a random, but valid Social Security Number.
 
         :returns: Random SSN
         :Example:
             569-66-5801
         """
         # Valid SSNs exclude 000, 666, and 900-999 in the area group
-        area = randint(1, 899)
+        area = self.random.randint(1, 899)
         if area == 666:
             area = 665
 
         return '{:03}-{:02}-{:04}'.format(
-            area, randint(1, 99), randint(1, 9999))
+            area,
+            self.random.randint(1, 99),
+            self.random.randint(1, 9999),
+        )
 
-    @staticmethod
-    def personality(category='mbti'):
+    def personality(self, category='mbti'):
         """Generate a type of personality.
 
         :param category: Category.
@@ -71,6 +66,6 @@ def personality(category='mbti'):
                  'ESTJ', 'ESFJ', 'ENFJ', 'ENTJ')
 
         if category.lower() == 'rheti':
-            return randint(1, 10)
+            return self.random.randint(1, 10)
 
-        return choice(mbtis)
+        return self.random.choice(mbtis)

mimesis/builtins/ru.py

@@ -1,72 +1,65 @@
-from random import choice, randint
+from mimesis.builtins.base import BaseSpecProvider
+from mimesis.utils import pull, check_gender
 
-from mimesis.exceptions import JSONKeyError
-from mimesis.providers.code import Code
-from mimesis.utils import pull
 
-# Internal
-_custom_code = Code().custom_code
+class RussiaSpecProvider(BaseSpecProvider):
+    """Specific data for Russian language"""
 
-
-class RussiaSpecProvider(object):
-    """Specific data for russian language (ru)"""
+    def __init__(self):
+        super().__init__()
+        self._data = pull('builtin.json', 'ru')
 
     class Meta:
         name = 'russia_provider'
 
-    @staticmethod
-    def generate_sentence():
+    def generate_sentence(self):
         """Generate sentence from the parts.
 
         :return: Sentence.
         :rtype: str
         """
-        data = pull('text.json', 'ru')['sentence']
-        sentence = [choice(data[k]) for k in ('head', 'p1', 'p2', 'tail')]
+        sentences = self._data['sentence']
+        sentence = [
+            self.random.choice(sentences[k]) for k
+            in ('head', 'p1', 'p2', 'tail')
+        ]
         return '{0} {1} {2} {3}'.format(*sentence)
 
-    @staticmethod
-    def patronymic(gender='female'):
+    def patronymic(self, gender=None):
         """Generate random patronymic name.
 
         :param gender: Gender of person.
         :return: Patronymic name.
         :Example:
             Алексеевна.
         """
-        gender = gender.lower()
-
-        try:
-            patronymic = pull('personal.json', 'ru')['patronymic']
-            return choice(patronymic[gender])
-        except:
-            raise JSONKeyError(
-                'Not exist key. Please use one of ["female", "male"]')
+        gender = check_gender(gender)
+        patronymics = self._data['patronymic'][gender]
+        return self.random.choice(patronymics)
 
-    @staticmethod
-    def passport_series(year=None):
+    def passport_series(self, year=None):
         """Generate random series of passport.
 
         :param year: Year of manufacture.
         :return: Series.
         :Example:
             02 15.
         """
-        year = randint(10, 16) if not \
+        year = self.random.randint(10, 16) if not \
             year else year
 
-        region = randint(1, 99)
+        region = self.random.randint(1, 99)
         return '{:02d} {}'.format(region, year)
 
-    @staticmethod
-    def passport_number():
+    def passport_number(self):
         """Generate random passport number.
 
         :return: Number.
         :Example:
             560430
         """
-        return randint(100000, 999999)
+        return self.random.randint(
+            100000, 999999)
 
     def series_and_number(self):
         """Generate a random passport number and series.
@@ -80,8 +73,7 @@ def series_and_number(self):
             self.passport_number(),
         )
 
-    @staticmethod
-    def snils():
+    def snils(self):
         """Generate Individual insurance account number (SNILS).
         This method does not generate SNILS using algorithm and
         it's mean that SNILS generated by this method can be invalid.
@@ -91,5 +83,5 @@ def snils():
             451-952-540-41.
         """
         mask = '###-###-###-##'
-        snils = _custom_code(mask=mask)
+        snils = self.code(mask=mask)
         return snils