def run_face_profile_detection(profile_area_dict, face_area_dict, text_area_dict): face_cascade = cv2.CascadeClassifier( "Data/haarcascade_frontalface_default.xml") temp_profile_area_path = "temp_profile_area.jpg" start_time = datetime.datetime.now() prev_is_face = False save_cond = False profile_index = 1028390 time_offset = 0 # in seconds face_profile_list = [] while True: screenshot = save_screen_shot( *[profile_area_dict[key] for key in profile_area_dict], temp_profile_area_path) profile_image = cv2.imread(temp_profile_area_path) face_image = Functions.get_child_image_from_parent_image( profile_image, profile_area_dict, face_area_dict, scale=0.5) text_image = Functions.get_child_image_from_parent_image( profile_image, profile_area_dict, text_area_dict) face_list = face_cascade.detectMultiScale( cv2.cvtColor(face_image, cv2.COLOR_BGR2GRAY), # grayscale version scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE) curr_is_face = len(face_list) != 0 if len(face_list) > 1: continue if curr_is_face and not prev_is_face: face_profile_list.append( Profile.FaceProfile(init_image=screenshot)) save_cond = True print("--------------------------") print("new prof added - profile {}".format(profile_index)) if save_cond: face_profile_list[-1].add_image_to_list(screenshot) print("\tadding face") if face_profile_list[-1].try_parsing_image( text_image=text_image, target_dir=Constants.profile_dir, seconds_into_video=(datetime.datetime.now() - start_time).total_seconds() * 2 + time_offset, profile_num=profile_index): save_cond = False profile_index += 1 prev_is_face = curr_is_face
def prof_response(self, arg_list): prof_name = " ".join(arg_list) prof_list = [ prof for prof in self.stevens.professor_list if prof_name in prof.name.lower() ] professor = None for prof in prof_list: if prof.name.lower() == prof_name: professor = prof if not prof_list: return "No professors with name {}".format(prof_name) elif len(prof_list) > 1 and professor is None: return "Multiple professors found: " + ", ".join( [prof.name.title() for prof in prof_list]) ret_str = "Professor {}:".format(professor.name) ret_str += "\n-------------" for day_code, section_list in professor.day_section_list_dict.items(): ret_str += "\n" + self.day_code_bict.find(day_code).title() for section in section_list: ret_str += "\n\t" + "{} - {}: Room {} - {}".format( Functions.get_pretty_time(section.start_time), Functions.get_pretty_time(section.end_time), section.room_name, section.name) return ret_str
def rewrite_projection_list(self, projection_list): if os.path.exists(self.scenario_json_path): os.remove(self.scenario_json_path) Functions.dict_to_json( [projection.to_dict() for projection in projection_list], self.scenario_json_path )
def get_dataframe(self): curr_datetime = self.start_datetime datetime_list = [] amount_list = [] while True: if curr_datetime >= self.end_datetime: break datetime_list.append(curr_datetime) amount_list.append(self.amount) if self.frequency == "daily": curr_datetime += datetime.timedelta(days=1) elif self.frequency == "weekly": curr_datetime += datetime.timedelta(days=7) elif self.frequency == "biweekly": curr_datetime += datetime.timedelta(days=14) elif self.frequency == "monthly": curr_datetime = Functions.add_months(curr_datetime, 1) elif self.frequency == "yearly": curr_datetime = Functions.add_months(curr_datetime, 12) data = {"result": amount_list} full_dataframe = pd.DataFrame(data, index=datetime_list, columns=list(data.keys())) full_dataframe = full_dataframe.sort_index() return full_dataframe
def __str__(self): ret_str = "CalendarInfo (from the 'LT Sheets -> Calendar Info' Google Sheet" + "\n" ret_str += Functions.tab_str(Functions.dict_to_str(self.ip_id_dict)) + "\n" ret_str += Functions.tab_str(Functions.dict_to_str(self.param_dict)) return ret_str
def __init__(self, parent_course, xml): self.xml = xml self.main_attrib_dict, self.meeting_dict_list, self.requirement_dict_list = self.get_dictionaries( ) self.section = self.main_attrib_dict.get("section") self.title = self.main_attrib_dict.get("title") self.call_number = self.main_attrib_dict.get("call_number") self.activity = str( Functions.find_first_occurrence_in_dicts("activity", *self.meeting_dict_list)) self.room = Functions.find_first_occurrence_in_dicts( "room", *self.meeting_dict_list) self.min_credit = self.main_attrib_dict.get("min_credit") self.max_credit = self.main_attrib_dict.get("max_credit") self.subject_id, self.course_id, self.id = self.get_subject_course_section_id_list( ) self.parent_course = parent_course self.day_list = Functions.find_first_occurrence_in_dicts( "day", *self.meeting_dict_list) self.start_time, self.end_time = self.get_times() self.time_dict = self.get_time_dict()
def check_dirs(self): if not os.path.exists(self.statement_source_files_dir): os.mkdir(self.statement_source_files_dir) if not os.path.exists(self.clean_statement_files_dir): os.mkdir(self.clean_statement_files_dir) if not os.path.exists(self.account_json_path): Functions.dict_to_json(self.account_dict, self.account_json_path)
def update_curr_balance(self): self.curr_balance = self.statement_cleaner.super_statement_df[ "running_balance"][-1] self.account_dict = self.get_account_dict() if not os.path.exists(self.account_json_path): os.remove(self.account_json_path) Functions.dict_to_json(self.account_dict, self.account_json_path)
def update_stevens(stevens, stevens_save_filename, room_schedule_url): if os.path.exists(stevens_save_filename): curr_time = datetime.datetime.today() time_elapsed = curr_time - stevens.time_updated if time_elapsed.total_seconds() > Constants.stevens_update_duration: stevens = Stevens.Stevens(room_schedule_url=room_schedule_url) Functions.pickle_object(stevens, stevens_save_filename) print("{} - Stevens object updated".format(curr_time)) return stevens
def do_prof_response(self, command_list): if not command_list: self.write_text(self.lt_sheets.sheet_to_simple_response("prof")) else: prof_name = " ".join(command_list) curr_time = datetime.datetime.today() prev_time = curr_time - datetime.timedelta(days=1) next_time = curr_time - datetime.timedelta(days=-1) day_code_list = Stevens.get_day_code_list([ prev_time.strftime("%A"), curr_time.strftime("%A"), next_time.strftime("%A") ]) found_prof_section_list_dict = {} for prof_key in self.stevens.prof_section_list_dict: if prof_name.lower() in prof_key.lower(): found_prof_section_list_dict[ prof_key] = self.stevens.prof_section_list_dict[ prof_key] if len(found_prof_section_list_dict) == 0: self.write_text("No professor found") elif len(found_prof_section_list_dict) > 1: str_ret = "Multiple professors found:" for found_prof_key in found_prof_section_list_dict: str_ret += "\n{}{}".format(Constants.groupme_tab, found_prof_key) self.write_text(str_ret) else: str_ret = "" for found_prof_key in found_prof_section_list_dict: str_ret += "Professor found: {}".format(found_prof_key) filtered_section_list = [] for section in found_prof_section_list_dict[ found_prof_key]: if section.day.lower() in day_code_list: filtered_section_list.append(section) if len(filtered_section_list) == 0: str_ret += "\n{}No sections found with day codes [{}]".format( Constants.groupme_tab, ", ".join(day_code_list)) else: for section in filtered_section_list: str_ret += "\n{}Room: {} | {}: {} - {}".format( Constants.groupme_tab, section.room.name, Stevens.get_day_from_code( section.day).title()[:3], Functions.get_nice_time_format( section.start_time), Functions.get_nice_time_format( section.end_time)) self.write_text(str_ret)
def add_components(self): Functions.add_to_layout( self, self.banner_image, Functions.add_to_layout( self.selector_group, AddSelectorButton.AddSelectorButton(stevens=self.stevens, selector_group=self.selector_group)), self.start_button )
def __init__(self): self.value_l_l_dict = {sheet.title: Functions.empty_strings_to_none(sheet.get_all_values()) for sheet in Google.get_google_sheets("LT Sheets")} self.value_list_list = self.value_l_l_dict["Calendar Info"] self.split_l_l_l = Functions.split_2d_list_by_vertical_none_list(self.value_list_list) self.ip_id_dict = self.get_ip_id_dict() self.param_dict = self.get_param_dict()
def simple_player_str(self): return Functions.str_to_length( "{} by {}".format( self.name, ", ".join([x.name for x in self.artist_list]) ), 30 ) + \ "[" + Functions.str_to_length(int((self.current_placement / self.duration) * 30) * "-", 30, do_dots=False) + "]"
def section_list_to_string(section_list): str_ret = "" for i, section in enumerate(section_list): if i != 0: str_ret += "\n" str_ret += "{}: {} - {} | {} ({})".format( get_day_from_code(section.day.lower())[:3].title(), Functions.get_nice_time_format(section.start_time), Functions.get_nice_time_format(section.end_time), section.course_name, section.professor) return str_ret
def get_statement_df(self): statement_df = pandas.DataFrame(data={ col_name: [] for col_name in Statement.Statement.col_name_list }) starting_balance = Functions.clean_money_str( self.dataframe["Beginning Balance"].iloc[0]) ending_balance = Functions.clean_money_str( self.dataframe["Ending Balance"].iloc[-1]) temp_dataframe = self.dataframe.drop(columns=[ "Statement Period Venmo Fees", "Year to Date Venmo Fees", "Beginning Balance", "Ending Balance", "Disclaimer" ]) temp_dataframe = temp_dataframe.drop(temp_dataframe.index[0]) temp_dataframe = temp_dataframe.drop(temp_dataframe.index[-1]) statement_df["date"] = [ datetime.datetime.strptime(x, "%Y-%m-%dT%H:%M:%S") for x in temp_dataframe["Datetime"] ] statement_df["amount"] = [ Functions.clean_money_str(x) for x in temp_dataframe["Amount (total)"] ] # statement_df["running_balance"] = temp_dataframe["Running Bal."] statement_df["transaction_code"] = list(temp_dataframe["ID"]) # statement_df["address"] = temp_dataframe["Description"] statement_df["description"] = list(temp_dataframe["Note"]) statement_df["status"] = list(temp_dataframe["Status"]) statement_df["funding_source"] = list(temp_dataframe["Funding Source"]) statement_df["destination"] = list(temp_dataframe["Destination"]) statement_df["from"] = list(temp_dataframe["From"]) statement_df["to"] = list(temp_dataframe["To"]) statement_df = statement_df.set_index(['date']) running_balance_list = [] for i, amount in enumerate(statement_df["amount"]): if i == 0: running_balance_list.append(starting_balance + amount) else: if statement_df["funding_source"][i] in ["Venmo balance", ""]: running_balance_list.append(running_balance_list[-1] + amount) else: running_balance_list.append(running_balance_list[-1]) running_balance_list[-1] = round(running_balance_list[-1], 2) statement_df["running_balance"] = running_balance_list return statement_df
def update_section_layout_from_course(self, course): self.pop_up.curr_course = course self.pop_up.selector_button.text = course.get_name() Functions.clear_layout(self.section_layout) grid_layout = GridLayout(cols=len(course.activity_dict.keys()), pos_hint={ 'center_x': .5, 'center_y': .5 }) for activity_key in course.activity_dict: grid_layout.add_widget( Label(text=Section.Section.activity_dict[activity_key], size_hint=(1, .1), pos_hint={ 'center_x': .5, 'center_y': .5 })) for activity_key in course.activity_dict: activity_layout = BoxLayout(orientation="vertical", padding=10, spacing=10, size_hint=(1, None), pos_hint={ 'center_x': .5, 'center_y': .5 }) activity_layout.bind( minimum_height=activity_layout.setter('height')) activity_layout.add_widget( ChoiceLayout(label_text="All", check_box_status=True)) for section in course.activity_dict[activity_key]: activity_layout.add_widget( ChoiceLayout(label_text=section.id, check_box_status=False)) scroll_view = ScrollView( size_hint=(1, 1), pos_hint={ 'center_x': .5, 'center_y': .5 }, do_scroll_x=False, ) scroll_view.add_widget(activity_layout) grid_layout.add_widget(scroll_view) self.section_layout.add_widget(grid_layout)
def __str__(self, **kwargs): header = "Section: {}".format(self.id) if kwargs.get("print_section_dicts"): ret_str = Functions.dict_to_string(self.main_attrib_dict, "main_attrib_dict") for i, meeting_dict in enumerate(self.meeting_dict_list): ret_str += "\n" + Functions.dict_to_string( meeting_dict, "meeting_dict: count = " + str(i)) for i, requirement_dict in enumerate(self.requirement_dict_list): ret_str += "\n" + Functions.dict_to_string( requirement_dict, "requirement_dict: count = " + str(i)) return header + "\n" + Functions.tab_string(ret_str) return header
def get_song_time_text(self): text = "{}/{}".format( Functions.milliseconds_to_minute_format( self.song.current_placement), Functions.milliseconds_to_minute_format(self.song.duration)) return EasyText.EasyText( text=text, x=0, y=self.screen_height * .8, size=self.screen_height / 5, font_file="FontFolder/Product Sans Regular.ttf", color=(255, 255, 255), opacity=140, draw_center=False)
def get_times(self): start_time = Functions.find_first_occurrence_in_dicts( "start_time", *self.meeting_dict_list) end_time = Functions.find_first_occurrence_in_dicts( "end_time", *self.meeting_dict_list) if (self.subject_id + self.course_id).replace( " ", "").lower() in ScheduleTests.test_schedule_0: print("{}: \t{} - {}\t{}".format( (self.subject_id + self.course_id + self.id).replace( " ", "").lower(), start_time, end_time, self.day_list)) if type(start_time) == str and type(end_time) == str: split_start_time = str(start_time).split(":") split_end_time = str(end_time).split(":") start_time = [int(split_start_time[0]), int(split_start_time[1])] end_time = [int(split_end_time[0]), int(split_end_time[1])] if start_time[0] < Constants.minimum_section_start: start_time[0] += 12 end_time[0] += 12 if (self.subject_id + self.course_id).replace( " ", "").lower() in ScheduleTests.test_schedule_0: print("\t", start_time[0], start_time[1], "\t | ", end_time[0], end_time[1]) if start_time[0] > 24: start_time[0] -= 12 if (self.subject_id + self.course_id).replace( " ", "").lower() in ScheduleTests.test_schedule_0: print("\ttime changed") if end_time[0] > 24: end_time[0] -= 12 if (self.subject_id + self.course_id).replace( " ", "").lower() in ScheduleTests.test_schedule_0: print("\ttime changed") start_time = datetime.time(start_time[0], start_time[1]) end_time = datetime.time(end_time[0], end_time[1]) if (self.subject_id + self.course_id).replace( " ", "").lower() in ScheduleTests.test_schedule_0: print("\t", start_time.strftime('%I:%M %p'), " | ", end_time.strftime('%I:%M %p')) return start_time, end_time
def __str__(self): statement_df = self.statement_df.copy() if statement_df.empty: return "empty dataframe" statement_df = statement_df.applymap(lambda x: Functions.str_to_length( x, 20, do_dots=True, do_left=True)) statement_df.columns = statement_df.columns.map( lambda x: Functions.str_to_length( x, 20, do_dots=True, do_left=True)) statement_df.index = statement_df.index.map( lambda x: Functions.str_to_length( x, 10, do_dots=True, do_left=True)) return statement_df.to_string()
def main(): twitch_credentials_dict = Functions.parse_json(Constants.twitch_credentials_file_path) twitch_oauth_dict = TwitchLib.get_oauth_dict(twitch_credentials_dict["client_id"], twitch_credentials_dict["secret"]) streamer = Streamer.Streamer( credentials_dict=twitch_credentials_dict, oauth_dict=twitch_oauth_dict, **TwitchLib.get_streamer_dict(twitch_credentials_dict["client_id"], twitch_oauth_dict["access_token"])["data"][0] ) print("Current followers as of {}:".format(Functions.get_pretty_time(datetime.datetime.now()))) print(Functions.tab_str("\n".join([str(x) for x in streamer.get_follower_list()]), 1)) print("-------------\n") streamer.listen_for_followers()
def download_statements(self): base_download_url = self.get_base_download_url() download_url_list = [] for start_date_str, end_date_str in self.get_start_end_date_tuple_list(): download_url_list.append(base_download_url.format(start_date=start_date_str, end_date=end_date_str)) print("Download url:", download_url_list[-1]) account = self.account_list[0] if self.current_statement_csv_name in os.listdir(account.statement_source_files_dir): os.remove(account.statement_source_files_dir + "/" + self.current_statement_csv_name) for i, (start_date_str, end_date_str) in enumerate(self.get_start_end_date_tuple_list()): download_url = base_download_url.format(start_date=start_date_str, end_date=end_date_str) print(start_date_str, end_date_str, " ", end="") new_csv_name = "{} to {}.csv".format(start_date_str, end_date_str) if i == 0: new_csv_name = self.current_statement_csv_name new_cvs_path = account.statement_source_files_dir + "/" + new_csv_name if not os.path.exists(new_cvs_path): print(download_url, end=" - ") for _ in range(4): self.driver.get(download_url) csv_path = Functions.wait_for_temp_file(self.parent_bank.profile.temp_download_dir, 4) if csv_path: os.rename(csv_path, new_cvs_path) break print(new_cvs_path, "created!") else: print(new_cvs_path, "exists!")
def __init__(self, **kwargs): self.child_widget = kwargs.get("child_widget") super().__init__(**Functions.remove_from_dict(kwargs, "child_widget")) self.add_widget(self.child_widget)
def get_term(self): xml_file_name = "StevensFiles/XML Sources/" + self.term_key + ".xml" if Functions.is_connected(): urllib.request.urlretrieve(Constants.term_url_dict[self.term_key], xml_file_name) return Term.Term(Et.parse(xml_file_name))
def __str__(self, **kwargs): ret_str = "Course ID: {}, section count: {}".format( self.id, len(self.section_list)) if kwargs.get("print_section_list"): for section in self.section_list: ret_str += "\n" + Functions.tab_string( section.__str__(**kwargs)) return ret_str
def __str__(self, **kwargs): ret_str = "Subject ID: {}, course count: {}".format( self.id, len(self.course_list)) if kwargs.get("print_course_list"): for course in self.course_list: ret_str += "\n" + Functions.tab_string( course.__str__(**kwargs)) return ret_str
def __init__(self, parent_account, file_path): self.file_path = file_path self.data_list_list = Functions.csv_to_list_list(self.file_path) self.dataframe = self.get_dataframe() super().__init__(parent_account, file_path, self.get_statement_df())
def get_dictionaries(self): main_attrib_dict = {} meeting_dict_list = [] requirement_dict_list = [] for element in self.xml.iter(): if element.tag == "Course": main_attrib_dict = Functions.clean_dict(element.attrib) elif element.tag == "Meeting": meeting_dict_list.append(Functions.clean_dict(element.attrib)) elif element.tag == "Requirement": requirement_dict_list.append( Functions.clean_dict(element.attrib)) else: print("Different Element Tag: " + element.tag) return main_attrib_dict, meeting_dict_list, requirement_dict_list
def __str__(self): ret_str = "name: {}".format(self.name) + "\t" ret_str += "article_count: {}".format(self.article_count) + "\t" ret_str += "keyword_list: {}".format(self.keyword_list) for i, article in enumerate(self.article_list): ret_str += "\n" ret_str += Functions.tab_str("Article {}: {}".format( i, str(article))) return ret_str
def get_subject_course_section_id_list(self): data_list = Functions.string_to_alternating_letter_to_num(self.section) subject_identifier = data_list[0] course_identifier = data_list[1] section_identifier = "".join(data_list[2:]) return subject_identifier, course_identifier, section_identifier