Ejemplo n.º 1
0
    def test_random_sample_unique(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        # Too many items requested
        with self.assertRaises(ValueError):
            provider.random_sample_unique('abcde', 6)

        # Duplicate inputs reduced to unique set
        with self.assertRaises(ValueError):
            provider.random_sample_unique('aabcd', 5)

        # Same length
        sample = provider.random_sample_unique('aabcd', 4)
        self.assertEqual(sample, set('abcd'))

        sample = provider.random_sample_unique('abcde', 5)
        self.assertEqual(sample, set('abcde'))

        # Length = 3
        sample = provider.random_sample_unique('abcde', 3)
        self.assertEqual(len(sample), 3)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 1
        sample = provider.random_sample_unique('abcde', 1)
        self.assertEqual(len(sample), 1)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 0
        sample = provider.random_sample_unique('abcde', 0)
        self.assertEqual(sample, set())
Ejemplo n.º 2
0
    def test_random_sample_unique(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        # Too many items requested
        with self.assertRaises(ValueError):
            provider.random_sample('abcde', 6)

        # Same length
        sample = provider.random_sample('abcd', 4)
        assert sorted(sample) == list('abcd')

        sample = provider.random_sample('abcde', 5)
        assert sorted(sample) == list('abcde')

        # Length = 3
        sample = provider.random_sample('abcde', 3)
        assert len(sample) == 3
        assert set(sample).issubset(set('abcde'))

        # Length = 1
        sample = provider.random_sample('abcde', 1)
        assert len(sample) == 1
        assert set(sample).issubset(set('abcde'))

        # Length = 0
        sample = provider.random_sample('abcde', 0)
        assert sample == []
Ejemplo n.º 3
0
    def test_random_element(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        choices = ('a', 'b', 'c', 'd')
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = {'a': 5, 'b': 2, 'c': 2, 'd': 1}
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = {'a': 0.5, 'b': 0.2, 'c': 0.2, 'd': 0.1}
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)
Ejemplo n.º 4
0
    def test_random_element(self):
        from faker.providers import BaseProvider

        provider = BaseProvider(None)

        choices = ("a", "b", "c", "d")
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = {"a": 5, "b": 2, "c": 2, "d": 1}
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = {"a": 0.5, "b": 0.2, "c": 0.2, "d": 0.1}
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)
Ejemplo n.º 5
0
    def test_random_element(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(None)

        choices = ('a', 'b', 'c', 'd')
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = {'a': 5, 'b': 2, 'c': 2, 'd':1 }
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)


        choices = {'a': 0.5, 'b': 0.2, 'c': 0.2, 'd':0.1}
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)
Ejemplo n.º 6
0
class BaseProviderTestCase(unittest.TestCase):
    def setUp(self):
        self.factory = Faker('en_US')
        self.factory.seed(0)
        self.provider = BaseProvider(generator=self.factory)

    def test_random_digit_or_empty(self):
        ret = self.provider.random_digit_or_empty()
        assert isinstance(ret, int)
        assert ret >= 0 and ret <= 9

        self.factory.seed(1)
        assert self.provider.random_digit_or_empty() == ''

    def test_random_digit_not_null_or_empty(self):
        ret = self.provider.random_digit_not_null_or_empty()
        assert isinstance(ret, int)
        assert ret >= 0 and ret <= 9

        self.factory.seed(1)
        assert self.provider.random_digit_not_null_or_empty() == ''

    def test_randomize_nb_elements(self):
        assert self.provider.randomize_nb_elements(number=1, le=True,
                                                   ge=True) == 1

        assert self.provider.randomize_nb_elements(le=True, ge=True) == 10

        number = 9999
        random_times = 100
        lower_bound = int(number * 0.6)
        upper_bound = int(number * 1.4)

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number, le=True)
            assert res >= lower_bound
            assert res <= number, "'{}' is not <= than '{}'".format(
                res, number)

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number, ge=True)
            assert res >= number
            assert res <= upper_bound

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number)
            assert res >= lower_bound
            assert res <= upper_bound
Ejemplo n.º 7
0
class BaseProviderTestCase(unittest.TestCase):
    def setUp(self):
        self.factory = Faker('en_US')
        self.factory.seed(0)
        self.provider = BaseProvider(generator=self.factory)

    def test_random_digit_or_empty(self):
        ret = self.provider.random_digit_or_empty()
        assert isinstance(ret, int)
        assert ret >= 0 and ret <= 9

        self.factory.seed(1)
        assert self.provider.random_digit_or_empty() == ''

    def test_random_digit_not_null_or_empty(self):
        ret = self.provider.random_digit_not_null_or_empty()
        assert isinstance(ret, int)
        assert ret >= 0 and ret <= 9

        self.factory.seed(1)
        assert self.provider.random_digit_not_null_or_empty() == ''

    def test_randomize_nb_elements(self):
        assert self.provider.randomize_nb_elements(number=1, le=True, ge=True) == 1

        assert self.provider.randomize_nb_elements(le=True, ge=True) == 10

        number = 9999
        random_times = 100
        lower_bound = int(number * 0.6)
        upper_bound = int(number * 1.4)

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number, le=True)
            assert res >= lower_bound
            assert res <= number, "'{}' is not <= than '{}'".format(res, number)

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number, ge=True)
            assert res >= number
            assert res <= upper_bound

        for _ in range(random_times):
            res = self.provider.randomize_nb_elements(number=number)
            assert res >= lower_bound
            assert res <= upper_bound
Ejemplo n.º 8
0
    def test_random_sample_unique(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(None)

        sample = provider.random_sample_unique('abcde', 3)
        self.assertEqual(len(sample), 3)
        self.assertTrue(sample.issubset(set('abcde')))

        # Same length
        sample = provider.random_sample_unique('abcde', 5)
        self.assertEqual(sample, set('abcde'))

        # Length = 1
        sample = provider.random_sample_unique('abcde', 1)
        self.assertEqual(len(sample), 1)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 0
        sample = provider.random_sample_unique('abcde', 0)
        self.assertEqual(sample, set())

        # Length = 0
        self.assertRaises(ValueError, provider.random_sample_unique, 'abcde', 6)
Ejemplo n.º 9
0
    def add_provider_alias(self, provider_name: str, new_name: str) -> None:
        """
        Adds a copy of a provider, with a different name
        :param provider_name: Name of original provider
        :param new_name: New name
        :example:
        >>>add_provider_alias(provider_name="name", new_name="person")
        >>>self.faker.person()
        """
        original = getattr(self.faker, provider_name)

        new_provider = BaseProvider(self.faker)
        setattr(new_provider, new_name, original)
        self.faker.add_provider(new_provider)
Ejemplo n.º 10
0
    def ssn(cls):
        """
        Returns a 11 digits Belgian SSN called "rijksregisternummer" as a string

        The first 6 digits represent the birthdate with (in order) year, month and day.
        The second group of 3 digits is represents a sequence number (order of birth).
        It is even for women and odd for men.
        For men the range starts at 1 and ends 997, for women 2 until 998.
        The third group of 2 digits is a checksum based on the previous 9 digits (modulo 97).
        Divide those 9 digits by 97, subtract the remainder from 97 and that's the result.
        For persons born in or after 2000, the 9 digit number needs to be proceeded by a 2
        (add 2000000000) before the division by 97.
                
        """

        # see http://nl.wikipedia.org/wiki/Burgerservicenummer (in Dutch)
        def _checksum(digits):
            res = 97 - (digits % 97)
            return res

        # Generate a date (random)
        mydate = DateProvider.date()
        # Convert it to an int
        elms = mydate.split("-")
        # Adjust for year 2000 if necessary
        if elms[0][0] == '2':
            above = True
        else:
            above = False
        # Only keep the last 2 digits of the year
        elms[0] = elms[0][2:4]
        # Simulate the gender/sequence - should be 3 digits
        seq = BaseProvider.random_int(1, 998)
        # Right justify sequence and append to list
        seq_str = "{:0>3}".format(seq)
        elms.append(seq_str)
        # Now convert list to an integer so the checksum can be calculated
        date_as_int = int("".join(elms))
        if above:
            date_as_int += 2000000000
        # Generate checksum
        s = _checksum(date_as_int)
        s_rjust = "{:0>2}".format(s)
        # return result as a string
        elms.append(s_rjust)
        return "".join(elms)
Ejemplo n.º 11
0
    def test_random_element(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        choices = ('a', 'b', 'c', 'd')
        pick = provider.random_element(choices)
        assert pick in choices

        # dicts not allowed because they introduce dependency on PYTHONHASHSEED
        with self.assertRaises(ValueError):
            provider.random_element({})

        choices = OrderedDict([('a', 5), ('b', 2), ('c', 2), ('d', 1)])
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)

        choices = OrderedDict([('a', 0.5), ('b', 0.2), ('c', 0.2), ('d', 0.1)])
        pick = provider.random_element(choices)
        self.assertTrue(pick in choices)
Ejemplo n.º 12
0
    def test_random_sample_unique(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(None)

        sample = provider.random_sample_unique('abcde', 3)
        self.assertEqual(len(sample), 3)
        self.assertTrue(sample.issubset(set('abcde')))

        # Same length
        sample = provider.random_sample_unique('abcde', 5)
        self.assertEqual(sample, set('abcde'))

        # Length = 1
        sample = provider.random_sample_unique('abcde', 1)
        self.assertEqual(len(sample), 1)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 0
        sample = provider.random_sample_unique('abcde', 0)
        self.assertEqual(sample, set())

        # Length = 0
        with self.assertRaises(ValueError):
            provider.random_sample_unique('abcde', 6)
Ejemplo n.º 13
0
    def test_random_number(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        number = provider.random_number(10, True)
        assert len(str(number)) == 10
Ejemplo n.º 14
0
 def setUp(self):
     generator = Generator()
     self.provider = BaseProvider(generator)
Ejemplo n.º 15
0
class TestBaseProvider(unittest.TestCase):
    def setUp(self):
        generator = Generator()
        self.provider = BaseProvider(generator)

    def test_lexify_empty_text(self):
        text = ''

        lexified = self.provider.lexify(text)
        self.assertFalse(lexified)
        lexified = self.provider.lexify(text, letters='someletters')
        self.assertFalse(lexified)

    def test_lexify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))
        for letter in lexified:
            self.assertIn(letter, letters)

    def test_lexify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))
        for letter in lexified:
            self.assertIn(letter, letters + '# ')

    def test_bothify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))
        for letter in bothify:
            self.assertIn(letter, letters)

    def test_bothify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))
        for letter in bothify:
            self.assertIn(letter, letters + '0123456789# ')

    def test_bothify_empty_text(self):
        text = ''

        bothified = self.provider.lexify(text)
        self.assertFalse(bothified)
        bothified = self.provider.lexify(text, letters='someletters')
        self.assertFalse(bothified)
Ejemplo n.º 16
0
    def test_random_number(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        number = provider.random_number(10, True)
        self.assertEqual(len(str(number)), 10)
Ejemplo n.º 17
0
 def setUp(self):
     self.factory = Faker('en_US')
     self.factory.seed(0)
     self.provider = BaseProvider(generator=self.factory)
class TestBaseProvider(unittest.TestCase):
    def setUp(self):
        generator = Generator()
        self.provider = BaseProvider(generator)

    def test_lexify_empty_text(self):
        text = ''

        lexified = self.provider.lexify(text)
        self.assertFalse(lexified)
        lexified = self.provider.lexify(text, letters='someletters')
        self.assertFalse(lexified)

    def test_lexify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))
        for letter in lexified:
            self.assertIn(letter, letters)

    def test_lexify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, string_types)
        self.assertEqual(len(lexified), len(text))
        for letter in lexified:
            self.assertIn(letter, letters + '# ')

    def test_bothify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))
        for letter in bothify:
            self.assertIn(letter, letters)

    def test_bothify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, string_types)
        self.assertEqual(len(bothify), len(text))
        for letter in bothify:
            self.assertIn(letter, letters + '0123456789# ')

    def test_bothify_empty_text(self):
        text = ''

        bothified = self.provider.lexify(text)
        self.assertFalse(bothified)
        bothified = self.provider.lexify(text, letters='someletters')
        self.assertFalse(bothified)

    def test_hexify(self):
        text = '^^^'

        for i in range(1000):
            hexified = self.provider.hexify(text)
            for c in hexified:
                self.assertIn(c, string.hexdigits[:-6])
                self.assertNotIn(c, string.hexdigits[-6:])

        for i in range(1000):
            hexified = self.provider.hexify(text, upper=True)
            for c in hexified:
                self.assertIn(c, string.hexdigits[:-6].upper())
                self.assertNotIn(c, string.hexdigits[-6:].lower())

    def test_random_letter(self):
        for i in range(100):
            letter = self.provider.random_letter()
            self.assertTrue(letter.isalpha())

    def test_random_lowercase_letter(self):
        for i in range(100):
            letter = self.provider.random_lowercase_letter()
            self.assertTrue(letter.isalpha())
            self.assertEqual(letter.lower(), letter)

    def test_random_uppercase_letter(self):
        for i in range(100):
            letter = self.provider.random_uppercase_letter()
            self.assertTrue(letter.isalpha())
            self.assertEqual(letter.upper(), letter)
Ejemplo n.º 19
0
class TestBaseProvider(unittest.TestCase):
    def setUp(self):
        generator = Generator()
        self.provider = BaseProvider(generator)

    def test_lexify_empty_text(self):
        text = ''

        lexified = self.provider.lexify(text)
        assert not lexified
        lexified = self.provider.lexify(text, letters='someletters')
        assert not lexified

    def test_lexify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, six.string_types)
        assert len(lexified) == len(text)

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, six.string_types)
        assert len(lexified) == len(text)
        for letter in lexified:
            assert letter in letters

    def test_lexify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        lexified = self.provider.lexify(text)
        self.assertIsInstance(lexified, six.string_types)
        assert len(lexified) == len(text)

        # A set of letters to choose from
        lexified = self.provider.lexify(text, letters=letters)
        self.assertIsInstance(lexified, six.string_types)
        assert len(lexified) == len(text)
        for letter in lexified:
            assert letter in letters + '# '

    def test_bothify_only_letters(self):
        text = '???'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, six.string_types)
        assert len(bothify) == len(text)

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, six.string_types)
        assert len(bothify) == len(text)
        for letter in bothify:
            assert letter in letters

    def test_bothify_mixed_values(self):
        text = '?#? ?# ## ??'
        letters = 'someletters'

        # all letters to choose from
        bothify = self.provider.bothify(text)
        self.assertIsInstance(bothify, six.string_types)
        assert len(bothify) == len(text)

        # A set of letters to choose from
        bothify = self.provider.bothify(text, letters=letters)
        self.assertIsInstance(bothify, six.string_types)
        assert len(bothify) == len(text)
        for letter in bothify:
            assert letter in letters + '0123456789# '

    def test_bothify_empty_text(self):
        text = ''

        bothified = self.provider.lexify(text)
        assert not bothified
        bothified = self.provider.lexify(text, letters='someletters')
        assert not bothified

    def test_hexify(self):
        text = '^^^'

        for i in range(1000):
            hexified = self.provider.hexify(text)
            for c in hexified:
                assert c in string.hexdigits[:-6]
                assert c not in string.hexdigits[-6:]

        for i in range(1000):
            hexified = self.provider.hexify(text, upper=True)
            for c in hexified:
                assert c in string.hexdigits[:-6].upper()
                assert c not in string.hexdigits[-6:].lower()

    def test_random_letter(self):
        for i in range(100):
            letter = self.provider.random_letter()
            assert letter.isalpha()

    def test_random_lowercase_letter(self):
        for i in range(100):
            letter = self.provider.random_lowercase_letter()
            assert letter.isalpha()
            assert letter.lower() == letter

    def test_random_uppercase_letter(self):
        for i in range(100):
            letter = self.provider.random_uppercase_letter()
            assert letter.isalpha()
            assert letter.upper() == letter
Ejemplo n.º 20
0
def GetFakerDataFromList(arr):
    '''arr = ('a', 'b', 'c', 'd') , choose one from list
    '''
    provider = BaseProvider(None)
    data = pick = provider.random_element(arr)
    return
Ejemplo n.º 21
0
 def setUp(self):
     self.factory = Faker('en_US')
     Faker.seed(0)
     self.provider = BaseProvider(generator=self.factory)
Ejemplo n.º 22
0
    def test_random_sample_unique(self):
        from faker.providers import BaseProvider
        provider = BaseProvider(self.generator)

        # Too many items requested
        with self.assertRaises(ValueError):
            provider.random_sample_unique('abcde', 6)

        # Duplicate inputs reduced to unique set
        with self.assertRaises(ValueError):
            provider.random_sample_unique('aabcd', 5)

        # Same length
        sample = provider.random_sample_unique('aabcd', 4)
        self.assertEqual(sample, set('abcd'))

        sample = provider.random_sample_unique('abcde', 5)
        self.assertEqual(sample, set('abcde'))

        # Length = 3
        sample = provider.random_sample_unique('abcde', 3)
        self.assertEqual(len(sample), 3)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 1
        sample = provider.random_sample_unique('abcde', 1)
        self.assertEqual(len(sample), 1)
        self.assertTrue(sample.issubset(set('abcde')))

        # Length = 0
        sample = provider.random_sample_unique('abcde', 0)
        self.assertEqual(sample, set())
Ejemplo n.º 23
0
def write_docs(*args, **kwargs):
    from faker import Faker, documentor
    from faker.config import DEFAULT_LOCALE, AVAILABLE_LOCALES
    from faker.providers import BaseProvider

    fake = Faker(locale=DEFAULT_LOCALE)
    doc = documentor.Documentor(fake)

    # Write docs for fakers.providers.BaseProvider
    base_provider = BaseProvider(fake)
    fname = os.path.join(DOCS_ROOT, 'providers', 'BaseProvider.rst')
    with open(fname, 'wb') as fh:
        write_base_provider(fh, doc, base_provider)

    # Write docs for default locale providers
    base_provider_formatters = list(dir(BaseProvider))
    formatters = doc.get_formatters(with_args=True,
                                    with_defaults=True,
                                    excludes=base_provider_formatters)
    for provider, fakers in formatters:
        provider_name = doc.get_provider_name(provider)
        fname = os.path.join(DOCS_ROOT, 'providers', '%s.rst' % provider_name)
        with open(fname, 'wb') as fh:
            write(fh, ':github_url: hide\n\n')
            write_provider(fh, doc, provider, fakers)

    # Write providers index page
    with open(os.path.join(DOCS_ROOT, 'providers.rst'), 'wb') as fh:
        write(fh, ':github_url: hide\n\n')
        write(fh, 'Providers\n')
        write(fh, '=========\n')
        write(fh, '.. toctree::\n')
        write(fh, '   :maxdepth: 2\n\n')
        write(fh, '   providers/BaseProvider\n')
        [
            write(fh, '   providers/%s\n' % doc.get_provider_name(provider))
            for provider, fakers in formatters
        ]

    # Write docs for locale-specific providers
    AVAILABLE_LOCALES = sorted(AVAILABLE_LOCALES)
    for lang in AVAILABLE_LOCALES:
        fname = os.path.join(DOCS_ROOT, 'locales', '%s.rst' % lang)
        with open(fname, 'wb') as fh:
            write(fh, ':github_url: hide\n\n')
            title = 'Language {}\n'.format(lang)
            write(fh, title)
            write(fh, '=' * len(title))
            write(fh, '\n')
            fake = Faker(locale=lang)
            d = documentor.Documentor(fake)

            for p, fs in d.get_formatters(with_args=True,
                                          with_defaults=True,
                                          locale=lang,
                                          excludes=base_provider_formatters):
                write_provider(fh, d, p, fs)

    # Write locales index page
    with open(os.path.join(DOCS_ROOT, 'locales.rst'), 'wb') as fh:
        write(fh, ':github_url: hide\n\n')
        write(fh, 'Locales\n')
        write(fh, '=======\n')
        write(fh, '.. toctree::\n')
        write(fh, '   :maxdepth: 2\n\n')
        [write(fh, '   locales/%s\n' % lang) for lang in AVAILABLE_LOCALES]
Ejemplo n.º 24
0
    def build_eobs_uat_env(self, cr, uid, data, context=None):
        wards = data.get('wards') if data.get('wards') else 10
        beds = data.get('beds') if data.get('beds') else 10
        patients = data.get('patients') if data.get('patients') else 10
        begin_date = data.get(
            'begin_date') if data.get('begin_date') else dt.now().strftime(dtf)
        fake = self.next_seed_fake()
        api = self.pool['nh.eobs.api']
        activity_pool = self.pool['nh.activity']
        patient_pool = self.pool['nh.clinical.patient']
        location_pool = self.pool['nh.clinical.location']
        context_pool = self.pool['nh.clinical.context']
        user_pool = self.pool['res.users']
        pos_pool = self.pool['nh.clinical.pos']
        pos_ids = pos_pool.search(cr, uid, [], context=context)
        if not pos_ids:
            pos_ids = [self.create(cr, uid, 'nh.clinical.pos')]
        pos_location_id = location_pool.search(
            cr, uid, [('pos_id', '=', pos_ids[0])])[0]

        adt_uid = user_pool.search(
            cr, uid,
            [['groups_id.name', 'in', ['NH Clinical ADT Group']]],
            context=context)
        if not adt_uid:
            adt_uid = self.create(
                cr, uid, 'res.users', 'user_adt', {'pos_id': pos_ids[0]})
        else:
            adt_uid = adt_uid[0]
        context_ids = context_pool.search(
            cr, uid, [['name', '=', 'eobs']], context=context)

        # LOCATIONS
        ward_ids = [self.create(
            cr, uid, 'nh.clinical.location', 'location_ward',
            {'context_ids': [[6, False, context_ids]],
             'parent_id': pos_location_id,
             'name': 'Ward '+str(w), 'code': str(w)}
        ) if not location_pool.search(
            cr, uid,
            [['code', '=', str(w)], ['parent_id', '=', pos_location_id],
             ['usage', '=', 'ward']], context=context
        ) else location_pool.search(
            cr, uid,
            [['code', '=', str(w)], ['parent_id', '=', pos_location_id],
             ['usage', '=', 'ward']], context=context
        )[0] for w in range(wards)]

        bed_ids = {}
        bed_codes = {}
        for w in range(wards):
            bed_ids[str(w)] = [self.create(
                cr, uid, 'nh.clinical.location', 'location_bed',
                {'context_ids': [[6, False, context_ids]],
                 'parent_id': ward_ids[w],
                 'name': 'Bed '+str(b), 'code': str(w)+str(b)}
            ) if not location_pool.search(
                cr, uid,
                [['code', '=', str(w)+str(b)],
                 ['parent_id.code', '=', str(w)],
                 ['usage', '=', 'bed']], context=context
            ) else location_pool.search(
                cr, uid,
                [['code', '=', str(w)+str(b)],
                 ['parent_id.code', '=', str(w)],
                 ['usage', '=', 'bed']], context=context
            )[0] for b in range(beds)]
            for b in range(beds):
                bed = location_pool.read(
                    cr, uid, bed_ids[str(w)][b], ['is_available'],
                    context=context)
                bed_codes[str(w)+str(b)] = {
                    'available': bed['is_available'], 'ward': str(w)}

        # USERS

        wm_ids = {}
        n_ids = {}
        h_ids = {}
        d_ids = {}
        for w in range(wards):
            wm_ids[str(w)] = self.create(
                cr, uid, 'res.users', 'user_ward_manager',
                {'name': 'WM'+str(w), 'login': '******'+str(w),
                 'password': '******'+str(w),
                 'location_ids': [[6, False, [ward_ids[w]]]]}
            ) if not user_pool.search(
                cr, uid, [['login', '=', 'WM'+str(w)]], context=context
            ) else user_pool.search(
                cr, uid, [['login', '=', 'WM'+str(w)]], context=context)[0]
            n_ids[str(w)] = self.create(
                cr, uid, 'res.users', 'user_nurse',
                {'name': 'N'+str(w), 'login': '******'+str(w),
                 'password': '******'+str(w),
                 'location_ids': [[6, False, bed_ids[str(w)]]]}
            ) if not user_pool.search(
                cr, uid, [['login', '=', 'N'+str(w)]], context=context
            ) else user_pool.search(
                cr, uid, [['login', '=', 'N'+str(w)]], context=context)[0]
            h_ids[str(w)] = self.create(
                cr, uid, 'res.users', 'user_hca',
                {'name': 'H'+str(w), 'login': '******'+str(w),
                 'password': '******'+str(w),
                 'location_ids': [[6, False, bed_ids[str(w)]]]}
            ) if not user_pool.search(
                cr, uid, [['login', '=', 'H'+str(w)]], context=context
            ) else user_pool.search(
                cr, uid, [['login', '=', 'H'+str(w)]], context=context)[0]
            d_ids[str(w)] = self.create(
                cr, uid, 'res.users', 'user_doctor',
                {'name': 'D'+str(w), 'login': '******'+str(w),
                 'password': '******'+str(w),
                 'location_ids': [[6, False, bed_ids[str(w)]]]}
            ) if not user_pool.search(
                cr, uid, [['login', '=', 'D'+str(w)]], context=context
            ) else user_pool.search(
                cr, uid, [['login', '=', 'D'+str(w)]], context=context)[0]

        # PATIENT REGISTER

        patient_identifiers = []
        for p in range(patients):
            hospital_number = BaseProvider.numerify('#######')
            while patient_pool.search(
                    cr, uid,
                    [['other_identifier', '=', hospital_number]],
                    context=context):
                hospital_number = BaseProvider.numerify('#######')
            nhs_number = BaseProvider.numerify('##########')
            while patient_pool.search(
                    cr, uid,
                    [['patient_identifier', '=', nhs_number]],
                    context=context):
                nhs_number = BaseProvider.numerify('##########')
            gender = fake.random_element(['M', 'F'])
            data = {
                'patient_identifier': nhs_number,
                'family_name': fake.last_name(),
                'given_name': fake.first_name(),
                'dob': fake.date_time_between(
                    start_date="-85y", end_date="now").strftime(dtf),
                'gender': gender,
                'sex': gender,
                'ethnicity': fake.random_element(patient_pool._ethnicity)[0]
            }
            api.register(cr, adt_uid, hospital_number, data, context=context)
            patient_identifiers.append(hospital_number)

        # PATIENT ADMISSION

        count = 0
        for b in bed_codes.keys():
            if not bed_codes[b]['available']:
                continue
            if len(patient_identifiers) <= count:
                break
            data = {
                'location': bed_codes[b]['ward'],
                'start_date': begin_date
            }
            wm_uid = wm_ids[bed_codes[b]['ward']]
            api.admit(
                cr, adt_uid, patient_identifiers[count], data, context=context)
            placement_id = activity_pool.search(
                cr, uid,
                [['patient_id.other_identifier', '=',
                  patient_identifiers[count]],
                 ['data_model', '=', 'nh.clinical.patient.placement']],
                context=context)
            if not placement_id:
                osv.except_osv(
                    'Error!',
                    'The patient placement was not triggered after admission!')
            location_id = location_pool.search(
                cr, uid,
                [['usage', '=', 'bed'], ['code', '=', b],
                 ['parent_id.usage', '=', 'ward'],
                 ['parent_id.code', '=', bed_codes[b]['ward']]],
                context=context)
            if not location_id:
                osv.except_osv(
                    'Error!',
                    'Cannot complete placement. Location not found!')
            activity_pool.submit(
                cr, wm_uid, placement_id[0],
                {'date_started': begin_date, 'location_id': location_id[0]},
                context=context)
            activity_pool.complete(
                cr, wm_uid, placement_id[0], context=context)
            activity_pool.write(
                cr, uid, placement_id[0],
                {'date_terminated': begin_date}, context=context)
            count += 1

        # SUBMIT NEWS OBSERVATIONS OVER A PERIOD OF TIME

        ews_activity_ids = activity_pool.search(
            cr, uid,
            [['patient_id.other_identifier', 'in', patient_identifiers],
             ['data_model', '=', 'nh.clinical.patient.observation.ews'],
             ['state', 'not in', ['completed', 'cancelled']]], context=context)
        activity_pool.write(
            cr, uid, ews_activity_ids, {'date_scheduled': begin_date},
            context=context)

        current_date = dt.strptime(begin_date, dtf)
        while current_date < dt.now():
            ews_activity_ids = activity_pool.search(
                cr, uid,
                [['patient_id.other_identifier', 'in', patient_identifiers],
                 ['data_model', '=', 'nh.clinical.patient.observation.ews'],
                 ['state', 'not in', ['completed', 'cancelled']],
                 ['date_scheduled', '<=', current_date.strftime(dtf)]],
                context=context)
            nearest_date = False
            for ews_id in ews_activity_ids:
                ews_data = {
                    'respiration_rate': fake.random_element(
                        [18]*90 + [11]*8 + [24]*2),
                    'indirect_oxymetry_spo2': fake.random_element(
                        [99]*90 + [95]*8 + [93]*2),
                    'oxygen_administration_flag': fake.random_element(
                        [False]*96 + [True]*4),
                    'blood_pressure_systolic': fake.random_element(
                        [120]*90 + [110]*8 + [100]*2),
                    'blood_pressure_diastolic': 80,
                    'avpu_text': fake.random_element(
                        ['A']*97 + ['V', 'P', 'U']),
                    'pulse_rate': fake.random_element(
                        [65]*90 + [50]*8 + [130]*2),
                    'body_temperature': fake.random_element(
                        [37.5]*93 + [36.0]*7),
                }
                ews_activity = activity_pool.browse(
                    cr, uid, ews_id, context=context)
                n_uid = n_ids[ews_activity.location_id.parent_id.code]
                activity_pool.submit(
                    cr, n_uid, ews_id, ews_data, context=context)
                activity_pool.complete(cr, n_uid, ews_id, context=context)
                ews_activity = activity_pool.browse(
                    cr, uid, ews_id, context=context)
                overdue = fake.random_element(
                    [False, False, False, False, False, False, False, True,
                     True, True])
                if overdue:
                    complete_date = current_date + td(days=1)
                else:
                    complete_date = current_date + td(
                        minutes=ews_activity.data_ref.frequency-10)
                activity_pool.write(
                    cr, uid, ews_id,
                    {'date_terminated': complete_date.strftime(dtf)},
                    context=context)
                triggered_ews_id = activity_pool.search(
                    cr, uid,
                    [['creator_id', '=', ews_id],
                     ['data_model', '=', 'nh.clinical.patient.observation.ews']
                     ], context=context)
                if not triggered_ews_id:
                    osv.except_osv(
                        'Error!',
                        'The NEWS observation was not triggered after previous'
                        ' submission!')
                triggered_ews = activity_pool.browse(
                    cr, uid, triggered_ews_id[0], context=context)
                activity_pool.write(
                    cr, uid, triggered_ews_id[0],
                    {'date_scheduled': (
                        complete_date + td(
                            minutes=triggered_ews.data_ref.frequency
                        )).strftime(dtf)
                     }, context=context)
                if not nearest_date or complete_date + td(
                        minutes=triggered_ews.data_ref.frequency
                ) < nearest_date:
                    nearest_date = complete_date + td(
                        minutes=triggered_ews.data_ref.frequency)
            current_date = nearest_date
        return True