async def change_date(ctx, old_date:str = "-", new_date:str = "-", room:str = 1): '''Change date of event''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return old_event_date = string_to_date(old_date) new_event_date = string_to_date(new_date) if not old_event_date: await ctx.send(ERROR_MSG['invalid_date'].format(old_date)) return if not new_event_date: await ctx.send(ERROR_MSG['invalid_date'].format(new_date)) return event = cal.get_event(old_event_date, room) if not event: await ctx.send("Couldn't find any event at {} on room {}.".format( old_event_date.strftime(TIME_FORMATER), room)) return event.date = new_event_date cal.upload_event(event) await print_date_pretty(ctx, "We changed the date of event", event)
def __init__(self, first_date, second_date): """ :param first_date: first date string to be compared :param second_date: second date string to be compared """ self.first_date = string_to_date(first_date, "%Y-%m-%d") self.second_date = string_to_date(second_date, "%Y-%m-%d")
def get_rates(self, currency, tenor, start=None, end=None): if tenor is not None: match = re.search('(\\d+)([mMwW])', tenor) if match is not None: tenor_i = int(match.group(1)) m_w = match.group(2) key = 'rates-' + str( datetime.date.today()) + str(tenor_i) + m_w res = self.__storage.get(key) if res is None: end = datetime.date.today() start = None if m_w in ['m', 'M']: start = utils.month_delta(end, tenor_i * -1) elif m_w in ['w', 'W']: start = end - datetime.timedelta(days=7 * tenor_i) rates = self.__rates_service.get_rates_dynamics( currency, start, end).to_json() self.__storage.add(key, rates) return rates else: return res else: s_start = utils.string_to_date(start, "%Y-%m-%d") s_end = utils.string_to_date(end, "%Y-%m-%d") return self.__rates_service.get_rates_dynamics( currency, s_start, s_end).to_json()
def get_services(agency, day=None, exp=True): """ Read the calendar.txt file and return a dict where the key is the service_id and the value is a tuple with the rest of the fields. If today is provided, will filter them and return only those service_id's active today. If exp = True (default), accounts for service exceptions included in calendar_dates.txt :param agency: a str identifying the transit agency. Assumes a agency.zip GTFS archive. :param day: an 8-char str or int specifying a day. Optional. :param exp: bool, whether or not to account for CalException s active today :returns a dict of tuples, representing calendar information in the agency GTFS file. If today is provided then this dict includes only services active today. """ dicto = {} cal = get_gtfs_df(webloc, agency, 'calendar') # calendar.txt header: # service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date if day is not None: date = u.string_to_date(day) dow = date.strftime("%A").lower() # lowercase name not number for _, row in cal.iterrows(): startstring, endstring = row['start_date'], row['end_date'] startdate, enddate = u.string_to_date(startstring), u.string_to_date( endstring) if day is None or\ (row[dow]==1 and startdate <= date <= enddate): # dicto[row['service_id']] = Service(int(row['monday']), int(row['tuesday']), int(row['wednesday']), int(row['thursday']), int(row['friday']), int(row['saturday']), int(row['sunday']), startstring, endstring) # Start accounting for exceptions: if day is not None and exp is True: exceptions = get_exceptions(agency, day) for x in exceptions: thisserviceid = x.service_id if x.exception_type == 1: # Service ID is activated today if thisserviceid not in dicto: # service ID should be added and is not currently in dict servicetup = get_services( agency )[thisserviceid] # Write tuple by recursively calling function dicto[x.service_id] = servicetup elif x.exception_type == 2: if thisserviceid in dicto: # Service has been disabled for today del dicto[x.service_id] # remove it from dict # print 'Returning ', len(dicto), 'service types active for today.' return dicto
def filter_stats(self, stats): """ cut runtime from 24s -> 15s :param stats: :return: list of Statistics objects """ pred_dates = [string_to_date(d.date) for d in self.preds] oldest_pred = dt.date.today() for date in pred_dates: if date < oldest_pred: oldest_pred = date return [s for s in stats if not string_to_date(s.date) < oldest_pred]
def rotate(dataset, new): cur_date = datetime.datetime.now() cur_date_string = utils.date_to_string(cur_date) cur_month = cur_date.month cur_weekday = cur_date.isoweekday() cur_week = cur_date.isocalendar()[1] cur_day = cur_date.day yst_day = (cur_date - datetime.timedelta(days=1)).day cur_hour = cur_date.hour cur_year = cur_date.year utils.create_snapshot(dataset, cur_date_string) snap_list = utils.get_snapshot_list(dataset) for snap in snap_list: snap_tag = snap.split("@")[-1] snap_date = utils.string_to_date(snap_tag) if \ snap_date.year != cur_year or \ (snap_date.month != cur_month and snap_date.day != 1) or \ (snap_date.isoweekday() < cur_weekday and snap_date.isocalendar()[1] != cur_week and snap_date.isoweekday() != 1 and snap_date.day != 1) or \ (snap_date.day != cur_day and snap_date.day != yst_day and snap_date.hour != 0) or \ (snap_date.day == yst_day and snap_date.hour < cur_hour and snap_date.hour != 0): print("Deleting snapshot {}".format(snap)) utils.delete_snapshot(snap)
async def new(ctx, date:str="today", room:str=None, as_gm:str=False): '''Set up new event''' if room: room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return free_slots = cal.get_free_slot(event_date) if not free_slots: await ctx.send("Sorry, on {} we don't have any room available :frowning2:".format(event_date.strftime(TIME_FORMATER))) return if room in free_slots: old_slot = room room = free_slots[0] await ctx.send("Sorry, on {} room {} is already book, but we reserved you room {}".format( event_date.strftime(TIME_FORMATER), old_slot, room)) if not room: room = free_slots[0] event = PnPParty(event_date, ctx.author.name if as_gm else None, [], room) cal.upload_event(event) await print_date_pretty(ctx, "We create a new event", event)
def get_fetch_date(self, user_id): datetime_str = self._db.child("users").child(user_id).child( "last_fetch").get().val() if datetime_str: return string_to_date(datetime_str) else: return None
def test_date(): import datetime now = datetime.datetime.now() d = utils.string_to_date("201810010900") yesterday_date = (d - datetime.timedelta(days=1)).day print yesterday_date
async def del_gm(ctx, date:str ="today", room:str = 1): '''Remove yourself as a game master''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if event and event.gm == ctx.author.name: del event.gm cal.upload_event(event) await ctx.send("Remove you successful from event: {} - room {}".format( event_date.strftime(TIME_FORMATER), room )) return else: await ctx.send("There is no event to remove you as gm from to given date {} on room {}".format( event_date.strftime(TIME_FORMATER), room ))
async def gm(ctx, date:str ="today", room:str = 1): '''Register yourself as a game master''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if event: if event.gm == "": event.gm = ctx.author.name else: await ctx.send("There can be only one GM: {}".format(event.gm)) return else: event = PnPParty(event_date, ctx.author.name, [], room) cal.upload_event(event) await print_date_pretty(ctx, "Add you as new GM for", event)
def add_event(title: str, description: str, name: str, email: str, url: str, source: str, start_now: bool, end_now: bool, offset: int = None, start_date: str = None, end_date: str = None): assert not (offset is not None and start_now and end_now) assert (start_date is None) == (end_date is None) if start_date is None and end_date is None: day = datetime.now() if offset is not None: day += timedelta(days=offset) CalendarApiAdapter( creds_path=os.environ['GOOGLE_CALENDAR_API_CREDS_PATH']).add_event( title=title, description=description, email=email, name=name, url=url, source=source, start_now=start_now, end_now=end_now, date=day) else: start_date_ = string_to_date(start_date) end_date_ = string_to_date(end_date) for date in [ start_date_ + timedelta(days=i) for i in range((end_date_ - start_date_).days) ]: CalendarApiAdapter( creds_path=os.environ['GOOGLE_CALENDAR_API_CREDS_PATH'] ).add_event(title=title, description=description, email=email, name=name, url=url, source=source, start_now=start_now, end_now=end_now, date=date)
def fetch_artices(self, date_limit=None): self.create_result_csv() if date_limit is None: date_limit = '1970-01-01' logger.debug('Fetching articles data') self.articles = [] for counter, url in enumerate(self.urls): logger.info('Fetching article {}/{}'.format( counter + 1, len(self.urls))) article = ArticleParser.get_article_obj_from_url(url) if string_to_date(article.date) >= string_to_date(date_limit): self.add_article(article, True) else: logger.info('Stopped fetching as articles too old') break print('..') self.csv_file.close()
def get_persons_between_dates(self): """ Returns filtered list of all persons born between dates :return: list of person dictionaries """ return list( filter( lambda person: self.first_date < string_to_date( person["dob"]["date"], "%Y-%m-%dT%H:%M:%S.%fZ") < self. second_date, self.get_all_persons().dicts()))
def load_more(driver, date_limit=None): date_limit = string_to_date(date_limit) logger.debug('Will now load more articles. Date limit: ' + str(date_limit)) while True: last_article_date = string_to_date(get_last_date(driver)) logger.debug('Last article date = ' + str(last_article_date)) if last_article_date < date_limit: logger.debug('Article too old. Not loading any more articles') break else: logger.debug('Article under limit. Loading more articles') load_more_button = driver.find_element_by_xpath( "//button[@class='btn posts-listing__more-btn']") logger.debug("Found load more button") load_more_button.click() logger.debug('Pressed load more button') sleep(4)
def parse_tender(html): """ Parse a tender HTML and return a dictionary with information such as: title, description, published etc """ soup = BeautifulSoup(html, 'html.parser') documents = find_by_class(soup, "lnkShowDocument", "a") description = find_by_class(soup, "ungm-list-item ungm-background", "div") description = description[1].text.strip().lstrip('Description') nodes = find_by_class(soup, "nodeName", "span") scraped_nodes = [parent.find_all("span")[0].text for parent in nodes[1:]] with open(json_unspsc_codes, 'rb') as fp: codes = json.load(fp) unspsc_codes = [ code['id'] for code in codes if code['id_ungm'] in scraped_nodes ] notice_type = find_by_class(soup, "status-tag", "span", True) title = find_by_class(soup, "title", "span", True) organization = find_by_class(soup, "highlighted", "span", True) reference = soup.find('span', text = re.compile('Reference:')).next_sibling.next_sibling.text published = soup.find('span', text = re.compile('Published on:')).next_sibling.next_sibling.text deadline = soup.find('span', text = re.compile('Deadline on:')).next_sibling.next_sibling.text tender = { 'source': 'UNGM', 'notice_type': notice_type, 'title': title, 'organization': organization, 'reference': reference, 'published': string_to_date(published) or date.today(), 'deadline': string_to_datetime(deadline[:17]), 'description': description, 'unspsc_codes': ', '.join(unspsc_codes), 'documents': [ { 'name': document.text.strip(), 'download_url': ENDPOINT_URI + documents[0]['href'] } for document in documents ], } gmt = deadline gmt = gmt[gmt.find("GMT")+4:gmt.find(")")] if gmt: tender['deadline'] -= timedelta(hours=float(gmt)) tender['deadline'] += timedelta(hours=get_local_gmt()) return tender
def __init__(self, start_date, num_of_days): self.files: List[str] = get_files_of_dir(self.const.DIR_MACHINE_CSVS) self.num_of_days: int = num_of_days self.max_length: int = self.num_of_days * 86400 date: datetime.datetime = string_to_date(start_date) self.dates: List[datetime.datetime] = [ date + datetime.timedelta(days=x) for x in range(0, num_of_days) ] self.dates = sorted(self.dates) self.dates: List[str] = [ date.strftime('%Y-%m-%d') for date in self.dates ] if not exists(self.const.DIR_PLOTS): mkdir(self.const.DIR_PLOTS)
async def overview(ctx, date:str = None): '''Show an overview over future pnp parties''' if date: event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return events = cal.get_events_on_date(event_date) else: events = cal.get_all_future_events() if not events: await ctx.send("Couldn't find any date!") return await print_date_pretty(ctx, "You ask for an overview", events)
async def add_title(ctx, title:str, date:str ="today", room:str ="1"): '''Add title to event''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if event: event.title = title cal.upload_event(event) await print_date_pretty(ctx, "We changed title of event", event)
async def del_player(ctx, date:str ="today", room:str = 1, player_name:str=None): '''Remove yourself from a event.''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if not player_name: success = event.remove_player(ctx.author.name) if success: await ctx.send("Successful removed you from player list on {} at room {}".format( event_date.strftime(TIME_FORMATER), room )) cal.upload_event(event) return await ctx.send("Couldn't find you on {} room {} as player. We searched with your name {}".format( event_date.strftime(TIME_FORMATER), room, ctx.author.name )) return if player_name and event.gm == ctx.author.name: success = event.remove_player(player_name) if success: await ctx.send("Successful removed {} from player list on {} at room {}".format( player_name, event_date.strftime(TIME_FORMATER), room )) cal.upload_event(event) return await ctx.send("Couldn't find {} on {} room {} as player.".format( player_name, event_date.strftime(TIME_FORMATER), room )) return await ctx.send(ERROR_MSG['insufficient_rights'])
def populate_deceased(self): logger.info('Populating deceased.') session = self._db_client.get_session() for row in self._read_workbook('Deceased'): (r_inquest_id, r_last_name, r_given_name, r_age, r_age_unit, r_sex, r_death_location, r_death_date, r_death_cause, r_death_cause_id, r_death_manner_id, r_inquest_reason_id) = row # Validate inquest type. # TODO: remove. if r_inquest_reason_id.startswith('MANDATORY_'): # An inquest is either 'Discretionary' or 'Mandatory-<reason>'; this makes 'Mandatory' redundant. inquest_reason_id = r_inquest_reason_id.replace( 'MANDATORY_', '') else: inquest_reason_id = r_inquest_reason_id # TODO: validate that deceased age is < 18. last_name = utils.format_as_title(r_last_name, utils.NullBehaviour.NULL_TO_NULL) given_names = utils.format_string(r_given_name, utils.NullBehaviour.NULL_TO_NULL) session.add( models.Deceased( inquestId=r_inquest_id, inquestReasonId=inquest_reason_id, deathMannerId=utils.format_as_id( r_death_manner_id), # TODO: remove format_as_id call. deathCauseId=r_death_cause_id, deathCause=utils.format_string(r_death_cause), deathDate=utils.string_to_date(r_death_date), deathLocation=utils.format_string( r_death_location, utils.NullBehaviour.NULL_TO_NULL), lastName=last_name, givenNames=given_names, age=utils.string_to_int(r_age), ageUnit=utils.format_string(r_age_unit), sex=utils.format_string(r_sex))) session.commit()
async def attend(ctx, date:str ="today", room:str=1): '''Attend at a event''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if event: event.add_player(ctx.author.name) else: event = PnPParty(event_date,player_list=[ctx.author.name]) await ctx.send("We create a new event on {} at room {}".format(event_date.strftime(TIME_FORMATER), room)) cal.upload_event(event) await ctx.send("You're registered as player for {} in room {}".format(event_date.strftime(TIME_FORMATER), room))
def task_4(): ''' Return the data for rentals with 01/06/1999 <= lease start date <= 31/08/2007 ''' reader = utils.get_masts_as_list() lease_start_header = 'Lease Start Date' lease_start_header_index = utils.get_header_index(lease_start_header) range_start = date(1999, 6, 1) range_end = date(2007, 8, 31) res = [] for item in reader: lease_start_date_str = item[lease_start_header_index] if utils.is_date_string_in_range(lease_start_date_str, range_start, range_end): item[lease_start_header_index] = utils.date_to_string( utils.string_to_date(lease_start_date_str)) res.append(item) return res
def get_rates_dynamics(self, currency, from_date, to_date): if self.__cur_mapping is None: self.__cur_mapping = self.get_currencies() if self.__cur_mapping is None or len(self.__cur_mapping) == 0: logging.debug(u'Initialization failed') return ApiResponse( has_error=True, error_description='Connection error on initialization') if currency not in self.__cur_mapping: return ApiResponse( has_error=True, error_description='Unsupported/unknown currency') currency_id = self.__cur_mapping[currency] uri = self.url_dynamics \ .replace("{ccy_id}", str(currency_id)) \ .replace("{from}", utils.date_to_string(from_date, self.DATE_FORMAT)) \ .replace("{to}", utils.date_to_string(to_date, self.DATE_FORMAT)) response = self.__client.get_response(uri) if response.has_error: return ApiResponse(has_error=True, error_description='Connection error') j_resp = json.loads(response.response_text) rates = {} for item in j_resp: date = utils.string_to_date(item['Date'], self.ISO_DATE_FORMAT) str_date = utils.date_to_string(date, self.DATE_FORMAT) rate = item['Cur_OfficialRate'] rates[str_date] = rate return ApiResponse( result=collections.OrderedDict(sorted(rates.items())))
async def add_player(ctx, date:str ="no value given", room:str = "no value given", player_name:str=None): '''As gm add players to your event''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if event and ctx.author.name == event.gm: event.add_player(player_name) else: await ctx.send("Couldn't find any event at {} on room {} with you as GM. Please create an event first.".format( event_date.strftime(TIME_FORMATER), room)) return cal.upload_event(event) await ctx.send("You're registered {} as player for {} in room {}".format(player_name, event_date.strftime(TIME_FORMATER), room))
def parse_winner(html): """ Parse a contract award HTML and return a dictionary with information such as: title, reference, vendor etc """ soup = BeautifulSoup(html, 'html.parser') description = soup.find_all('div', CSS_DESCRIPTION) vendor_list = [] for vendors_div in soup.find_all(id=CSS_VENDOR_LIST): vendors = vendors_div.descendants for vendor in vendors: if vendor.name == 'div' and vendor.get('class', '') == ['editableListItem']: vendor_list.append(vendor.text.strip()) vendor_list = ', '.join(vendor_list) title = find_by_label(soup, CSS_TITLE) organization = find_by_label(soup, CSS_ORGANIZATION) reference = find_by_label(soup, CSS_REFERENCE) tender_fields = { 'source': 'UNGM', 'title': to_unicode(title.string), 'organization': to_unicode(organization.string), 'reference': to_unicode(reference.string.strip()), 'description': to_unicode(str(description[0])), } award_date = find_by_label(soup, CSS_AWARD_DATE) value = find_by_label(soup, CSS_VALUE) winner_fields = { 'award_date': string_to_date(award_date.string) or date.today(), 'vendor': vendor_list, 'value': float(value.string or 0) if value.string else None } if winner_fields['value']: winner_fields['currency'] = 'USD' return tender_fields, winner_fields
async def delete(ctx, date:str="no date given", room:str= "no room given"): '''Delete an event on given date and room.''' room, err_msg = validate_room(room) if not room: await ctx.send(err_msg) return event_date = string_to_date(date) if not event_date: await ctx.send(ERROR_MSG['invalid_date'].format(date)) return event = cal.get_event(event_date, room) if not event: await ctx.send("No event found to delete :frowning2:") return if not event.gm or event.gm == ctx.author.name: cal.delet_event(event) await ctx.send("Deleted event on {} in room {}!".format(event_date.strftime(TIME_FORMATER), room)) return await ctx.send(ERROR_MSG['insufficient_rights'])
with open('../files/dados_safra_milho_conab.csv', 'r') as arquivo_csv: reader = csv.reader(arquivo_csv, delimiter=',') year = 2013 month = 1 collection = 'historical_data_daily' for colunm in reader: if year < 2021: for week in calendar.monthcalendar(year, month): for day in week: if day != 0: date = utils.format_number( day, 2) + '.' + utils.format_number( month, 2) + '.' + str(year) date = utils.string_to_date(date) if server.db_select(collection, ['date'], [date]) == None: server.db_insert( collection, ['date', 'br_production'], [date, utils.string_to_float(colunm[1])]) else: server.db_update(collection, {"date": date}, { 'br_production': utils.string_to_float(colunm[1]) }) if server.db_select(collection, ['date'], [date]) == None: server.db_insert( collection, ['date', 'br_plateau_area'],
import csv import server as server from datetime import timedelta import utils with open('../files/dolar_brl_semanal.csv', 'r') as arquivo_csv: reader = csv.reader(arquivo_csv, delimiter=',') for idx, colunm in enumerate(reader): if idx > 1: collection = 'historical_data_weekly' keys = [ 'date', 'dolar', 'open_dolar', 'max_dolar', 'min_dolar', 'var_dolar' ] values = [ utils.string_to_date(colunm[0]), utils.string_to_float(colunm[1]), utils.string_to_float(colunm[2]), utils.string_to_float(colunm[3]), utils.string_to_float(colunm[4]), utils.string_to_float(colunm[5]) ] colunm[0] = utils.string_to_date(colunm[0]) - timedelta(days=1) if server.db_select(collection, [keys[0]], [values[0]]) == None: server.db_insert(collection, keys, values) else: for i, *_ in enumerate(colunm): if i >= 1: server.db_update(collection, {keys[0]: values[0]}, {keys[i]: values[i]})
def test_string_to_date(): # testing with the default input format test_str_date = '23 Nov 2019' tester_output = date(2019, 11, 23) assert string_to_date(test_str_date) == tester_output
def populate_documents(self): logger.info('Populating documents.') session = self._db_client.get_session() document_sources = set('NO PUBLISH') for row in self._read_workbook('Documents'): (r_serial, r_reference_type, r_name, r_citation, r_date, r_link, r_document_source, r_source_id, r_reference_id, r_primary, r_document_type) = row document_source_id = utils.format_as_id(r_document_source) # Create document source type if it does not exist. # TODO: create export table? if utils.format_as_id(r_document_source) not in document_sources: session.add( models.DocumentSource( documentSourceId=document_source_id, name=utils.format_string(r_document_source), )) session.flush() document_sources.add(document_source_id) # Upload document to S3 if respective file exists locally. link = None if document_source_id == 'INQUESTS_CA': s3_link = self._upload_document_if_exists( r_reference_type, r_name, r_date, r_source_id, r_serial, int(r_reference_id)) if s3_link is not None: link = s3_link elif document_source_id != 'NO PUBLISH': link = r_link if r_reference_type == self._REFERENCE_TYPE_AUTHORITY: authority_document = models.AuthorityDocument( authorityId=r_reference_id, authorityDocumentTypeId=utils.format_as_id( r_document_type, utils.NullBehaviour.NULL_TO_NULL), sourceId=r_source_id, isPrimary=r_primary, name=utils.format_string(r_name), citation=utils.format_string( r_citation, utils.NullBehaviour.NULL_TO_NULL), created=utils.string_to_date( r_date, utils.NullBehaviour.NULL_TO_NULL), ) session.add(authority_document) session.flush() if link is not None: session.add( models.AuthorityDocumentLinks( authorityDocumentId=authority_document. authorityDocumentId, documentSourceId=document_source_id, link=link, )) elif r_reference_type == self._REFERENCE_TYPE_INQUEST: inquest_document = models.InquestDocument( inquestId=r_reference_id, inquestDocumentTypeId=utils.format_as_id( r_document_type, utils.NullBehaviour.NULL_TO_NULL), name=utils.format_string(r_name), created=utils.string_to_date(r_date), ) session.add(inquest_document) session.flush() if link is not None: session.add( models.InquestDocumentLinks( inquestDocumentId=inquest_document. inquestDocumentId, documentSourceId=document_source_id, link=link, )) session.commit()
for data in list_of_json: call_uuid = data["variables"].get("call_uuid", None) domain_uuid = data["variables"].get("domain_uuid", None) domain_name = data["variables"].get("domain_name", None) call_direction = data["variables"].get("call_direction", None) last_bridge_hangup_cause = data["variables"].get( "last_bridge_hangup_cause", None) caller_id_name = data["variables"].get("caller_id_name", None) caller_destination = data["variables"].get("caller_destination", None) origination_callee_id_name = data["variables"].get( "origination_callee_id_name", None) last_sent_callee_id_number = data["variables"].get( "last_sent_callee_id_number", None) str_start_stamp = clean_string(data["variables"].get("start_stamp", None)) start_stamp = string_to_date(str_start_stamp) str_end_stamp = clean_string(data["variables"].get("end_stamp", None)) end_stamp = string_to_date(str_end_stamp) str_voicemail_answer_stamp = clean_string(data["variables"].get( "voicemail_answer_stamp", None)) voicemail_answer_stamp = string_to_date(str_voicemail_answer_stamp) billsec = data["variables"].get("billsec", None) dialstatus = data["variables"].get("dialstatus", None) hangup_cause = data["variables"].get("hangup_cause", None) intercept = data["variables"].get("intercept", None) read_result = data["variables"].get("read_result", None) cur.execute(