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())
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 == []
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)
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)
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)
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
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
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)
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)
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)
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)
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)
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
def setUp(self): generator = Generator() self.provider = BaseProvider(generator)
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_random_number(self): from faker.providers import BaseProvider provider = BaseProvider(self.generator) number = provider.random_number(10, True) self.assertEqual(len(str(number)), 10)
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)
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
def GetFakerDataFromList(arr): '''arr = ('a', 'b', 'c', 'd') , choose one from list ''' provider = BaseProvider(None) data = pick = provider.random_element(arr) return
def setUp(self): self.factory = Faker('en_US') Faker.seed(0) self.provider = BaseProvider(generator=self.factory)
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]
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