def generate_isolates(self): for isolate in config.ISOLATE_LIST: # Randomly select an individual random_individual = self.get_random_individual() random_individual_id = random_individual.id # Randomly select a sample type sample_type = random.choice(config.ISOLATE_SAMPLE_TYPE) # Generate an isolate id isolate_id = isolate # Is the randomly selected individual an in patient if random_individual_id < len(self.movement.individual_list): # randomly select a date within the individuals admissions # Random admission random_admission = random.choice(random_individual.admission_list) random_date = radar.random_date( start=random_admission.admission_date, stop=random_admission.discharge_date, ) building_sent_from_name = config.ISOLATE_IN_PATIENT_SAMPLE_BUILDING building_sent_from_location = "unkown" # Otherwise the individual is an outpatient else: # Generate a random date random_date = radar.random_date( start=config.DATE_START, stop=config.DATE_END ) building_sent_from = random.choice(config.ISOLATE_OUT_PATIENT_SAMPLE_BUILDING) building_sent_from_name = building_sent_from.get('name') building_sent_from_location = random.choice(building_sent_from.get('locations')) # Randomly select an antibiogram result set random_antibiogram = self.antibiogram.choose_random_antibiogram() new_isolate = Isolate(isolate_id) new_isolate.individual_id = random_individual_id new_isolate.sample_type = sample_type new_isolate.sample_description = random.choice(config.ISOLATE_SAMPLE_DESCRIPTION) new_isolate.date_sent = random_date new_isolate.sent_from_location = building_sent_from_location new_isolate.sent_from_name = building_sent_from_name new_isolate.antibiogram = random_antibiogram #mapped_antibiogram = self.antibiogram.get_antibiogram_map(random_antibiogram, ANTIBIOGRAM_ANTIBIOTICS) self.isolate_list.append(new_isolate)
def insert_treatment_plan_1(n, doc_ssn1, doc_snn_2, pat_snn1, pat_snn_2): inserts = "INSERT INTO Treatment_plan (id, doctor_ssn, patient_ssn, discharge_date, hospitalization_date, diagnoses, procedures) VALUES \n" for k in range(n): diagnoses = random.choice(list(random_data.treatments.keys())) inserts += "({}, {}, {}, '{}', '{}', '{}', '{}'),\n".format( k, random.randint(doc_ssn1, doc_snn_2 - 1), random.randint(pat_snn1, pat_snn_2 - 1), radar.random_date(start=datetime.date(year=2014, month=5, day=24), stop=datetime.date(year=2015, month=5, day=24)), radar.random_date(start=datetime.date(year=2012, month=5, day=24), stop=datetime.date(year=2013, month=5, day=24)), diagnoses, random.choice(random_data.treatments[diagnoses])) inserts = inserts[:-2] + ';\n' return inserts
def test_02_random_date(self): """ Test ``radar.random_datetime``. """ res = radar.random_date() self.assertTrue(isinstance(res, datetime.date)) return res
def generate_dates(time_slices, forecast_windows, start_date, end_date, load_prev_files, output_slices_path): if load_prev_files and os.path.exists(output_slices_path): with open(output_slices_path, "rb") as prev_slices: dataset_slices = pickle.load(prev_slices) return dataset_slices elif type(time_slices) is list: dataset_slices = time_slices with open(output_slices_path, "wb+") as save_path: pickle.dump(dataset_slices, save_path) return dataset_slices else: forecast_windows = [timedelta(weeks=x * 52) for x in forecast_windows] largest_window = max(forecast_windows) effective_end_date = end_date - largest_window feature_slices = [ random_date(start_date, effective_end_date) for x in range(time_slices) ] dataset_slices = [] for feature_slice in feature_slices: for forecast_window in forecast_windows: label_slice = feature_slice + forecast_window dataset_slices.append((feature_slice, label_slice)) os.makedirs(os.path.dirname(output_slices_path), exist_ok=True) with open(output_slices_path, "wb+") as save_path: pickle.dump(dataset_slices, save_path) return dataset_slices
def get_random_visitor(start_date, end_date): d = start_date random_date = radar.random_date(start=start_date, stop=end_date) wh_uri = WH_LOGS_SOURCE + random_date.strftime('%Y-%m-%d') + '.json' vistors = None try: response = requests.get(wh_uri) response.raise_for_status() # rv = random.sample(response.json(),len(response.json())) rv_json = random.choice(response.json()) if rv_json['place'] != 'White House': get_random_visitor(start_date, end_date) else: # get the date rvdate = datetime.datetime.strptime(rv_json['date'], '%Y-%m-%d') v_date = rvdate.strftime('%b %d, %Y') v = rv_json['visitor'] vname = v['first_name'] + ' ' + v['last_name'] title = v['title'] if v['title'] else '' org = v['organization']['name'] if v['organization'] else '' txt = 'On ' + v_date + ' ' + vname + ' ' + title + ' ' + org + ' visited the White House' print txt print(len(txt)) return ' '.join(txt.split()) except requests.exceptions.HTTPError as err: get_random_visitor(start_date, end_date)
def test_02_random_date(self): """ Test ``radar.random_datetime``. """ res = radar.random_date() self.assertTrue(isinstance(res, datetime.date)) return res
def get_random_visitor(self, start_date, end_date): d = start_date random_date = radar.random_date(start=start_date, stop=end_date) wh_uri = WH_LOGS_SOURCE + random_date.strftime('%Y-%m-%d') + '.json' vistors = None txt = None try: response = requests.get(wh_uri) response.raise_for_status() rv_json = random.choice(response.json()) if rv_json['place'] != 'White House': get_random_visitor(start_date, end_date) else: # get the date rvdate = datetime.datetime.strptime(rv_json['date'], '%Y-%m-%d') v_date = rvdate.strftime('%b %d, %Y') v = rv_json['visitor'] vname = v['first_name'] + ' ' + v['last_name'] title = v['title'] if v['title'] else '' org = v['organization']['name'] if v['organization'] else '' txt = '{0} {1} {2} {3} visited the White House'.format( v_date, vname, title, org) except requests.exceptions.HTTPError as err: get_random_visitor(start_date, end_date) return txt
def gen_datetime(self, from_date, to_date): from_date = from_date.split('-') return radar.random_date( start=datetime(year=from_date.year, month=from_date.month, day=from_date.day), stop=datetime(year=to_date.year, month=to_date.month, day=to_date.day))
def create_config(seed): random.seed(seed) random.shuffle(amis) random.shuffle(household) name_laughingmistress(laughingmistress) random.shuffle(seamstresses) ## pick a random date somewhere between bd and the end of the year story_start_time = radar.random_date(start=datetime.datetime(year=1832, month=6, day=7), stop=datetime.datetime(year=1832, month=12, day=31)) if story_start_time.hour < 8: story_start_time = story_start_time + timedelta(hours=8) if story_start_time.hour > 20: story_start_time = story_start_time - timedelta(hours=8) ## pick the place where they're walking story_start_place = random.choice(Place.listof) ## pick a protagonist if random.random() < 0.3: protagonist = cosette else: protagonist = amis[0] ## pick a confidant if protagonist == cosette: confidant = random.choice(household) elif protagonist == marius: confidant = random.choice(household + [courfeyrac]) elif protagonist == courfeyrac: amis.pop(0) amis.append(marius) random.shuffle(amis) amis.insert(0, courfeyrac) confidant = amis[1] else: confidant = amis[1] ## pick a garment if protagonist.gender == 'F': garment = random.choice([x for x in Garment.listof if x.gender == 'F']) else: garment = random.choice([x for x in Garment.listof if x.gender == 'M']) # pick a seamstress seamstress = seamstresses[0] config = Config(protagonist, confidant, seamstress, story_start_place, story_start_time, garment, amis, household, seamstresses) return config
def test_04_random_date_with_ranges_given(self): """ Test ``radar.random_date`` with ranges given. """ start = datetime.date(year=2000, month=5, day=24) stop = datetime.date(year=2013, month=5, day=24) res = radar.random_date(start=start, stop=stop) self.assertTrue(isinstance(res, datetime.date)) self.assertTrue(res > start) self.assertTrue(res < stop) return res
def test_04_random_date_with_ranges_given(self): """ Test ``radar.random_date`` with ranges given. """ start = datetime.date(year=2000, month=5, day=24) stop = datetime.date(year=2013, month=5, day=24) res = radar.random_date(start=start, stop=stop) self.assertTrue(isinstance(res, datetime.date)) self.assertTrue(res > start) self.assertTrue(res < stop) return res
def insert_prescribe( l, emp_ssn1, emp_ssn2, pat_ssn1, pat_ssn2 ): # l - number of prescribes, i:j - available employee ssn, m:m - available patient ssn inserts = "INSERT INTO Prescribe (employee_ssn, patient_ssn, description, date) VALUES\n " for k in range(l): inserts += "({}, {}, '{}', '{}'),\n".format( random.randint(emp_ssn1, emp_ssn2 - 1), random.randint(pat_ssn1, pat_ssn2 - 1), "Doctor attends patient", radar.random_date(start=datetime.date(year=2015, month=5, day=24), stop=datetime.date(year=2019, month=5, day=24))) inserts = inserts[:-2] + ';\n' return inserts
def insert_analysis_result(i, pat_ssn1, pat_ssn2): inserts = "INSERT INTO Analysis_result (id, patient_ssn, type, result, date) VALUES\n " for j in range(i): inserts += "({}, {}, '{}', '{}', '{}'),\n".format( j, random.randint(pat_ssn1, pat_ssn2 - 1), random.choice(random_data.analysis_types), 'Medical result', radar.random_date(start=datetime.date(year=2015, month=5, day=24), stop=datetime.date(year=2019, month=5, day=24)), ) inserts = inserts[:-2] + ';\n' return inserts
def insert_log(i): # i - number of logs id's inserts = "INSERT INTO Log (id, name, description, time) VALUES \n" for k in range(i): inserts += "({}, '{}', '{}', '{}'),\n".format( k, "log_{}".format(k), "initialization", radar.random_date(start=datetime.datetime(year=2015, month=5, day=24), stop=datetime.datetime(year=2019, month=5, day=24))) inserts = inserts[:-2] + ';\n' return inserts
def test_06_random_date_with_string_ranges_given(self): """ Test ``radar.random_date`` with string ranges given. """ start = '2012-05-24' stop='2013-05-24' dt_start = datetime.date(year=2012, month=5, day=24) dt_stop = datetime.date(year=2013, month=5, day=24) res = radar.random_date(start=start, stop=stop) self.assertTrue(isinstance(res, datetime.date)) self.assertTrue(res > dt_start) self.assertTrue(res < dt_stop) return res
def test_06_random_date_with_string_ranges_given(self): """ Test ``radar.random_date`` with string ranges given. """ start = '2012-05-24' stop = '2013-05-24' dt_start = datetime.date(year=2012, month=5, day=24) dt_stop = datetime.date(year=2013, month=5, day=24) res = radar.random_date(start=start, stop=stop) self.assertTrue(isinstance(res, datetime.date)) self.assertTrue(res > dt_start) self.assertTrue(res < dt_stop) return res
def insert_patient( pat_ssn1, pat_ssn2, room_id1, room_id2): # i:j - available ssn's m:n - available room_id's inserts = "INSERT INTO Patient (ssn, name, surname, gender, weight, birth_date, height, blood_type, phone, country, city, street, building, room_id) VALUES \n" for k in range(pat_ssn1, pat_ssn2): inserts += "({}, '{}', '{}', '{}', {}, '{}', {}, '{}', '+{}', '{}', '{}', '{}', {}, {}),\n".format( k, random.choice(random_data.names), random.choice(random_data.surnames), random.choice(random_data.genders), random.randint(45, 100), radar.random_date(start=datetime.date(year=1960, month=5, day=24), stop=datetime.date(year=2013, month=5, day=24)), random.randint(80, 220), random.choice(random_data.blood_type), random.randint(10**11, 10**12 - 1), random.choice(random_data.countries), random.choice(random_data.cities), random.choice(random_data.street), random.randint(1, 10), random.randint(room_id1, room_id2 - 1)) inserts = inserts[:-2] + ';\n' return inserts
def create_outbreak_source(self): #FIXME: USe the antibiogram object helpers!! chosen_antibiogram = self.antibiogram.choose_random_antibiogram() # FIXME: Caused an issue where a continual loop ran out of options # FYI: Could argue that in real life the same strain will occur completley unrelated # Remove the antibiogram so that it cannot be used again creating noise #self.antibiogram.antibiogram_list.remove(chosen_antibiogram) chosen_individual = self.choose_suitable_individual() chosen_individual_id = chosen_individual.id # Randomly choose a location to start the outbreak chosen_location = random.choice(chosen_individual.location_list) # Pick a date to start the outbreak date_of_infection = radar.random_date( start=chosen_location.admission_date, stop=chosen_location.discharge_date, ) self.outbreak_source = { 'antibiogram': chosen_antibiogram, 'individual': chosen_individual, 'location': chosen_location, 'date_of_infection': date_of_infection, 'level': 1 } self.writer.writerow({ 'source_individual': "", 'individual': chosen_individual_id, 'location': chosen_location.name, 'date_of_infection': date_of_infection, 'level': 1 }) self.isolate_start_id += 1 self.add_isolate(self.isolate_start_id, chosen_individual_id, date_of_infection)
def generate(self): evictions = [] if not os.path.isfile("addresses.db"): raise FileNotFoundError("Did you generate the sqlite database yet?") connection = sqlite3.connect("addresses.db") c = connection.cursor() sql_to_execute = 'SELECT * FROM address ORDER BY RANDOM() LIMIT {}'.format(self.params["number_to_generate"]) rows = c.execute(sql_to_execute).fetchall() connection.close() for row in rows: evictions.append({ key: val for key, val in zip(self.headers, row) }) for eviction in evictions: eviction["date"] = str(radar.random_date( start = self.params["start_date"], stop = self.params["end_date"] )) evictions.sort(key = lambda d: d["date"]) return evictions
def insert_treatment_plan(n, doc_ssn1, doc_snn_2, pat_snn1, pat_snn_2): ans = "" ids = list(range(0, n)) random.shuffle(ids) doc_snn = [] for j in range(n): doc_snn.append(random.randint(doc_ssn1, doc_snn_2 - 1)) pat_snn = [] for j in range(n): pat_snn.append(random.randint(pat_snn1, pat_snn_2 - 1)) two_weeks = 1209600 treats = list(open("Treatments.txt")) for i in range(len(treats)): treats[i] = treats[i].replace("\n", "") while treats.count(""): treats.remove("") string = "" for i, pro in enumerate(treats): string += "({}, '{}'),\n".format(i, pro.split(";")[0]) ans += "INSERT INTO Diagnoses VALUES \n" + string[:-2] + ";\n\n" c = 0 string = "" thing = {} opthing = {} for i, pro in enumerate(treats): a = [] for e2 in pro.split(";")[1:]: if (not (e2 in opthing)): string += "({}, '{}'),\n".format(c, e2) a.append(c) opthing[e2] = c c += 1 else: a.append(opthing[e2]) thing[i] = a ans += "INSERT INTO Procedures VALUES \n" + string[:-2] + ";\n\n" string1 = "" string2 = "" string3 = "" for i in range(n): hos_date = radar.random_date(start=datetime.date(year=2015, month=1, day=1), stop=datetime.date(year=2019, month=1, day=1)) timestamp = datetime.datetime.combine(hos_date, datetime.time(0, 0)).timestamp() dis_date = datetime.date.fromtimestamp(timestamp + two_weeks) string1 += "({}, {}, {}, '{}', '{}'),\n".format( ids[i], doc_snn[i], pat_snn[i], dis_date, hos_date) illness = random.sample(range(len(treats)), 3) for e in illness: string2 += "({}, {}),\n".format(ids[i], e) string3 += "({}, {}),\n".format(ids[i], random.choice(thing[e])) ans += "INSERT INTO Treatment_plan VALUES\n" + string1[:-2] + ";\n\n" ans += "INSERT INTO Treatment_diagnoses VALUES\n" + string2[:-2] + ";\n\n" ans += "INSERT INTO Treatment_procedures VALUES\n" + string3[:-2] + ";\n\n" return ans
recordValue[13] = initial #n recordValue[14] = firstName #o recordValue[15] = COL_P #p recordValue[16] = lastName #q recordValue[17] = street #r recordValue[18] = apt #s recordValue[19] = COL_T #t recordValue[20] = city #u recordValue[21] = state #v recordValue[22] = zipcode #w recordValue[23] = COL_X #x recordValue[24] = COL_Y[0] #y Residency Code - U dob = radar.random_date(start=datetime.date(year=startDobYear, month=1, day=1), stop=datetime.date(year=endDobYear, month=12, day=30)) recordValue[25] = dateFormat(dob) #z recordValue[26] = random.choice(COL_AA) #aa recordValue[27] = random.choice(COL_AB) #ab recordValue[28] = COL_AC #ac recordValue[29] = COL_AD #ad recordValue[30] = COL_AE #ae recordValue[31] = COL_AF #af recordValue[32] = COL_AG #ag recordValue[33] = COL_AH #ah recordValue[34] = email #ai recordValue[35] = COL_AJ #aj
def generate_date_of_birth(): return radar.random_date( start = datetime.date(1971,1,1), stop = Zombie.DATE_OF_OUTBREAK - datetime.timedelta(weeks=11*52) )
def generate_date_of_rebirth(): return radar.random_date( start = Zombie.DATE_OF_OUTBREAK, stop = datetime.date.today() )
def gen_datetime(self): return radar.random_date( start=datetime(year=2018, month=1, day=1), stop=datetime(year=2019, month=10, day=26))
def Populate(N=5): for _ in range(N): fake_cmtsNombre = choice([ 'VILLA EL SALVADOR1', 'SAN JUAN4', '1EROMAYO1', 'CHORRILLOS1', 'MAGDALENA2', 'MAGDALENA1', 'SAN JUAN1', 'SAN JUAN2', 'SAN JUAN3' ]) fake_nodoNombre = choice([ 'CA', 'CU', 'CV', 'LC', 'LF', 'LM', 'LO', 'MA', 'MI', 'P3', 'PI', 'RA', 'RO', 'SB', 'SI', 'SV', 'T1', 'VI', 'WA' ]) fake_trobaNombre = 'R' + str(randrange(100, 105)) fake_nombre = choice([ 'Jhon', 'Sansa', 'Tyron', 'Aria', 'Brie', 'Bran', 'Ned', 'Rob', 'Robet', 'Summer', 'Ghost', 'Lady', 'Cathelyn' ]) fake_apellido = choice([ 'Dominguez', 'Lu', 'Ra', 'Zen', 'Brian', 'Tarth', 'Snow', 'Sand', 'Targaryen', 'Stark', 'Lannister', 'Black Fire' ]) fake_codigoCliente = randrange(100000, 9999999) fake_remedy = 'CRQ0000' + str(randrange(393881, 399999)) fake_estado = choice(['Cerrado', 'Abierto']) fake_corteS_N = choice(['True', 'False']) fake_tipoTrabajo = choice([ "PARTICION_OPTICA", "ACONDICIONAR_FUENTE_DE_ENERGIA", "CONEXIONADO_DE_DISPOSITIVOS", "PARTICION_COAXIAL", "CONEXIONADO", "CAMBIO_DE_TROBA", "TRABAJO_DE_EMERGENCIA" ]) fake_remitente = choice([ 'Jhon', 'Sansa', 'Tyron', 'Aria', 'Brie', 'Bran', 'Ned', 'Rob', 'Robet', 'Summer', 'Ghost', 'Lady', 'Cathelyn' ]) fake_grupoCoordinador = choice([ 'Busqueda y saneamiento', 'Capacidad y procesos', 'Energia', 'Huaweia', 'Ingenieria Core IP', 'Ingenieria de Datos', 'Ingenieria Facilities', 'metro y Backhaul', 'Transporte' ]) fake_riesgo = choice(['1', '2', '3', '4', '5']) fake_site = choice([ 'San Borja', 'Carhuacoto', 'La Victoria', 'Lince', 'Cedros', 'Urubamba', 'Huancas', 'Tuman_Ura', 'San Juan', 'Higuereta' ]) fake_fechaInicio = radar.random_date(start='2019-02-05', stop='2019-02-12') fake_fechaFin = radar.random_date(start='2019-03-10', stop='2019-05-18') cmts1 = Cmts.objects.get_or_create(cmtsNombre=fake_cmtsNombre)[0] nodo1 = Nodo.objects.get_or_create(nodoNombre=fake_nodoNombre, cmts=cmts1)[0] troba1 = Troba.objects.get_or_create(trobaNombre=fake_trobaNombre, nodo=nodo1)[0] infoPlanta1 = InfoPlanta.objects.get_or_create( remedy=fake_remedy, estado=fake_estado, corteS_N=fake_corteS_N, tipoTrabajo=fake_tipoTrabajo, troba=troba1)[0] infoCore1 = InfoCore.objects.get_or_create( remedy=fake_remedy, remitente=fake_remitente, grupoCoordinador=fake_grupoCoordinador, riesgo=fake_riesgo, site=fake_site, cmts=cmts1)[0] tareaProgramada = TareaProgramada.objects.get_or_create( fechaInicio=fake_fechaInicio, fechaFin=fake_fechaFin, infoCore=infoCore1, infoPlanta=infoPlanta1) usuario = Usuario.objects.get_or_create( nombre=fake_nombre, apellido=fake_apellido, codigoCliente=fake_codigoCliente, troba=troba1)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import radar import datetime print('随机日期 %s' % radar.random_date()) print('随机日期+时间 %s' % radar.random_datetime()) print('随机时间 %s' % radar.random_time()) print('指定范围随机日期 %s' % radar.random_date(start=datetime.datetime(year=1985, month=1, day=1), stop=datetime.datetime(year=1989, month=12, day=30))) print( '指定范围随机日期+时间 %s' % radar.random_datetime(start=datetime.datetime(year=1985, month=1, day=1), stop=datetime.datetime(year=1989, month=12, day=30))) print('指定范围随机时间 %s' % radar.random_time( start="2018-01-10T09:00:10", stop="2018-01-10T18:00:00", )) # 默认使用 重量级的python-dateutil库解析日期,选择使用轻量级的radar.utils.parse(快5倍) print('指定范围随机时间 %s' % radar.random_time(start="2018-01-10T09:00:10", stop="2018-01-10T18:00:00", parse=radar.utils.parse))
def generate_trans_date(count, start, end): dates = [] for i in range(count): date = radar.random_date(start=start, stop=end) dates.append(date) return dates
def initiate_outbreak_phase(self, previous_phase_output): current_phase_output = [] outbreak_results = [] outbreak_in_progress = True level = self.outbreak_source.get('level') while outbreak_in_progress: # Increment the phase level level += 1 for source in previous_phase_output: source_individual_id = source.get('individual').id # Check to see if this individual has already been a source of infection if source_individual_id in self.infected_individuals: continue print("New source %s" % source_individual_id) # Record the source so that they cannot be re-infected self.infected_individuals.append(source_individual_id) # get all individuals who have shared the locations at the same time for individual in self.movement.individual_list: current_individual_id = individual.id # Check if the individual has already been infected (different to the source check!!) uptodate_outbreak_list = outbreak_results + current_phase_output if self.individual_already_part_of_outbreak(source_individual_id, current_individual_id, uptodate_outbreak_list): continue overlapping_location = self.individual_overlap_location(source, individual) if overlapping_location and self.transmission_occured(): overlap_location_name = overlapping_location.get('overlap_location_name') overlap_start = overlapping_location.get('overlap_start') overlap_end = overlapping_location.get('overlap_end') # Pick a date to simulate a transmission date_of_transmission = radar.random_date( start=overlap_start, stop=overlap_end, ) # Pick a date within the overlap to create a sample date, this would be ideal to know but not # realistic in the real world, the date would be after. # TODO: Define a metric of delay between the date of transmission vs sample current_phase_output.append({ 'source_individual': source_individual_id, 'individual': individual, # Individual object 'location': overlap_location_name, 'date_of_infection': date_of_transmission, 'overlap_start': overlap_start, 'overlap_end': overlap_end, }) self.writer.writerow({ 'source_individual': source_individual_id, 'individual': current_individual_id, 'location': overlap_location_name, 'date_of_infection': date_of_transmission, 'level': level }) self.stats.add_isolate() # Generate an isolate id isolate_id = self.isolate_start_id + len(self.master_isolate_list) self.add_isolate(isolate_id, current_individual_id, date_of_transmission) # if the outbreak has finished if not current_phase_output: outbreak_in_progress = False else: # store the result outbreak_results = outbreak_results + current_phase_output # Set the next phase for another pass if required previous_phase_output = current_phase_output # Initialise current as empty current_phase_output = [] return outbreak_results
from __future__ import print_function from dateutil.parser import parse as dateuitil_parser import radar print(radar.random_date(start='2013-05-24', stop='2013-07-01', parse=dateuitil_parser)) print(radar.random_datetime(start='2013-05-24T00:00:00', stop='2013-05-24T23:59:59', parse=radar.utils.parse)) start = radar.utils.parse('2012-01-01') stop = radar.utils.parse('2013-01-01') print(radar.random_datetime(start=start, stop=stop)) print(radar.random_datetime(start=start)) print(radar.random_datetime(stop=stop)) print(radar.random_time(start='2012-01-01T00:00:00', stop='2012-01-01T23:59:59'))
# coding=utf-8 import radar random_date = radar.random_date(start='2017-02-05', stop='2017-05-05')
def get_random_date(min, max): return radar.random_date(start=min, stop=max)