def turn_page(Statement): Statement = Statement.split() ops = PageOps(Statement) options = [ ("n", "Next Verse", ops.do_next_page), ("p", "Previous Verse", ops.do_last_page), ("q", "Quit Classic Verse", say_done), ] do_menu("Verse Ref", "Option = ", options, "%")
def main(): # Get a list of plotter.plot()'s exported functions (values from the dict) plot_functions = list(plotter.plot().values()) # Get the plot() function's signature (arguments list) plot_signature = str(inspect.signature(plotter.plot)) # Get the functions's names, signatures, and their docstring comments plot_function_names = [] plot_function_signatures = [] plot_function_docs = [] for plot_function in plot_functions: # I'm formatting the function identifiers to look like dict keys: plot_function_names.append('[\'' + plot_function.__name__ + '\']') plot_function_signatures.append(str(inspect.signature(plot_function))) plot_function_docs.append(plot_function.__doc__) # Kill the tkinter window that plotter.plot() created. # (The 5th function in the dict, plot_functions[4], is an alias for # destroy().) plot_functions[4]() while True: choice = menu.do_menu('Choose one to see its description:', [ 'Module plotter (plotter.py)', 'Function plotter.plot', 'Functions returned by plotter.plot' ]) if choice is None: # Exit choice break # out of program loop if choice == 1: print('\nModule plotter:') print(plotter.__doc__) elif choice == 2: print() plot_header = 'Function plot' + plot_signature print( textwrap.fill(plot_header, initial_indent='', subsequent_indent=' ')) print('\n' + my_dedent(plotter.plot.__doc__)) elif choice == 3: # Present submenu of functions returned by plot() while True: choice = menu.do_menu(('Choose a function returned by '\ 'plotter.plot() to see its description:'), plot_function_names) if choice is None: # Exit choice break # out of inner loop print() plot_function_header = 'Function ' + \ plot_function_names[choice-1] + \ plot_function_signatures[choice-1] print( textwrap.fill(plot_function_header, initial_indent='', subsequent_indent=' ')) print() print(my_dedent(plot_function_docs[choice - 1], trim_limit=8))
def do_lookups(): """ Ways to lookup books & verses """ options = [ ("l", "List Books", do_list), ("c", "Classic book:chapter:verse", do_book_cv), ("s", "Sierra #", do_book_vnum), ("r", "Read From", do_read_from), ("b", "Manage Bookmarks", do_read_bkmrk), ("q", "Quit", say_done), ] do_menu("Find Verse", "Option = ", options, "?")
def display_options(self): options = [ ("a", "lnup", self.do_lineadv), ("z", "pgup", self.do_pageadv), ("s", "lndn", self.do_linedec), ("x", "pgdn", self.do_pagedec), ("g", "goto", self.do_goto), ("q", "Quit Program", quit), ] self.do_display() do_menu("Main Menu", "Option = ", options, "#") self.EndOfPage()
def begin(self): val = do_menu("What would you like to do (-1 for quitting) ", self.__initial_options) if(val == 0): self.create_survey() self.add_questions_to_survey() else: self.goodbye()
def hack(screen): if do_menu(screen) == 1: world = read("world") else: world = make_world() write(world, "world") main(screen, world)
def add_questions_to_survey(self): val = -1 while val != -2: questions = get_questions() val = do_menu("Choose a question to add (-1 for new questions -2 to finish) ", questions, -2) if(val == -1): self.create_question_version() elif(val >= 0): self.add_question(questions[val])
def create_question(self, question_version_id): response_id = -1 while response_id == -1: question = input("What is the prompt for your question? (-1 for same)") if question == "-1": question = self.__current_question_version_name question_type = self.__question_type[do_menu("What type of question ", self.__question_type, 0)] health_data = True if do_menu("Is there sleep data? ", ["No", "Yes"], False) == 1 else False answer = [] key = 0 if input("Would you like your answers to just be Yes / No? (y is you want this)") == 'y': answer = ['Yes', 'No'] else: while key != "-1": key = input("Provide a value ") answer.append(key) if input(f"You are going to insert a questions {question} with answer {answer} with type {question_type} and health data {health_data} are you sure (-1 for no)") == "-1": continue response_id = insert_question(question, str(answer), question_type, question_version_id, health_data)
def add_question(self, val): survey_id = self.__survey_id question_id = val[0] last_question = self.__last_question_id category = "" category_num = do_menu("Pick a category (-1 to make new category) ", self.__categories) if(category_num == -1): self.__categories.append(input("Make a new category ")) category = self.__categories[-1] else: category = self.__categories[category_num] if input(f"Are you sure you want to add question to survey {survey_id}, {question_id}, {last_question}, {category}? (-1 to not)") == "-1": return self.__last_question_id = insert_survey_question(survey_id, question_id, last_question, category)
def create_question_version(self): question_versions = get_question_versions() question_version_names = get_items_of_index(question_versions, 1) val = do_menu("Choose a question version (-1 to make a new one) ", question_version_names) question_version_id = -1 if(val == -1): while question_version_id == -1: version_name = input("What do you want to name your question? ") self.__current_question_version_name = version_name question_version_id = insert_question_version(version_name) else: question_version_id = question_versions[val][0] self.__current_question_version_name = question_versions[val][1] self.create_question(question_version_id)
def create_survey(self, dont_use = ""): survey_items_total = get_survey_versions() survey_items = get_items_of_index(survey_items_total, 1) val = do_menu("What survey version would you like to base this off of (-1 for making new survey version) ", survey_items) if val == -1: self.__survey_version_id = self.create_survey_version() else: self.__survey_version_id = survey_items_total[val][0] self.__current_survey_version_name = survey_items_total[val][1] self.__current_question_version_description = survey_items_total[val][2] ret_val= -1 while(ret_val == -1): print("Now to make the actual survey; (-1 to use same) ") survey_name = input("Give a survey name ") if survey_name == "-1": survey_name = self.__current_survey_version_name description = self.__current_survey_version_description ret_val = insert_survey(survey_name, description, self.__survey_version_id) else: description = input("Give a survey description ") ret_val = insert_survey(survey_name, description, self.__survey_version_id) self.__survey_id = ret_val return ret_val
def main(): """Program execution starts here.""" url = "http://sites.cs.queensu.ca/courses/cisc121/a2/logons.txt" data = web_scraper.scrape(url) n = len(data) data = parse_logons.logons_to_list_of_dicts(data) # The data list (and the file it came from) are in chronological # order. That means data is currently sorted by timestamp. sort_on_key = "timestamp" main_menu_title = "Select an operation:" main_menu_choices = [ "Sort logons data", "Show a selection of the data", f"Search for a particular {sort_on_key}" ] sort_on_menu_title = "Select a key to sort on:" sort_on_menu_choices = list(data[0].keys()) sort_menu_title = "Select a sort algorithm:" sort_menu_choices = [ "Insertion sort", "Bubble sort", "Bubble sort (optimized)", "Selection sort" ] while True: choice = menu.do_menu(main_menu_title, main_menu_choices) if choice is None: return # Exit main() (and program). if choice == 1: # Sort logons data. while True: sort_on_choice = menu.do_menu(sort_on_menu_title, sort_on_menu_choices) if sort_on_choice is None: break # Return to main menu. sort_on_key = sort_on_menu_choices[sort_on_choice - 1] # Change last choice in main menu to reflect the new # sort_on_choice. main_menu_choices[ -1] = f"Search for a particular {sort_on_key}" sort_choice = menu.do_menu(sort_menu_title, sort_menu_choices) if sort_choice is None: break # Return to main menu. # If we're here, we can proceed with a sort. print() if sort_choice == 1: # Insertion sort sort_function = dict_quad_sorts.insertion_sort elif sort_choice == 2: # Bubble sort sort_function = dict_quad_sorts.bubble_sort elif sort_choice == 3: # Bubble sort (opt) sort_function = dict_quad_sorts.bubble_sort_opt else: # Selection sort sort_function = dict_quad_sorts.selection_sort # Do the sort. print(f"Sorting on key '{sort_on_key}'...") sort_function(data, sort_on_key) print("Done.") # Show it worked. long_list_printer.print_list(data, 5) elif choice == 2: # Show a selection of the data. long_list_printer.print_list(data, 10) elif choice == 3: # Search for a specific value. search_val = input(f"\nSearch for what {sort_on_key}? ") found_at = dict_bin_search.search(data, sort_on_key, search_val) if found_at is None: print(f"{sort_on_key} {search_val} not found.") else: print(f"{sort_on_key} {search_val} found at position "\ f"{found_at}.")
def main(): # Set up main menu and sub-menus. main_menu_choices = ["Temperatures", "Distances", "Weights"] temperatures_menu_choices = [ "Celsius to Fahrenheit", "Fahrenheit to Celsius", "Celsius to Kelvin", "Kelvin to Celsius", "Fahrenheit to Kelvin", "Kelvin to Fahrenheit" ] distances_menu_choices = [ "Miles to Kilometres", "Kilometres to Miles", "Feet to Metres", "Metres to Feet", "Inches to Centimetres", "Centimetres to Inches" ] weights_menu_choices = [ "Tons to Tonnes", "Tonnes to Tons", "Pounds to Kilograms", "Kilograms to Pounds", "Ounces to Grams", "Grams to Ounces" ] # Loop until user wants to quit. while True: # Declare main menu choice = menu.do_menu("Choose a conversion type:", main_menu_choices) if choice is None: # Did the user choose "Exit?" break # Yes, then exit. if choice == 1: # User chose temperature conversions. while True: # Loop until user wants to return to the main menu. choice = menu.do_menu("Choose a temperature conversion", temperatures_menu_choices) if choice is None: break if choice is 1: # Celsius to Fahrenheit chosen. cels = get_int.input_int("\nDegrees Celsius: ") print((f"\n{cels} degrees Celsius is " f"{cels_to_fahr(cels):.1f} " "degrees Fahrenheit.")) if choice is 2: # Fahrenheit to Celsius chosen. fahr = get_int.input_int("\nDegrees Fahrenheit: ") print((f"\n{fahr} degrees Fahrenheit is " f"{fahr_to_cels(fahr):.1f} " "degrees Celsius.")) if choice is 3: # Celsius to Kelvin chosen. cels = get_int.input_int("\nDegrees Celsius: ") print((f"\n{cels} degrees Celsius is " f"{cels_to_kelv(cels):.1f} " "Kelvin.")) if choice is 4: # Kelvin to Celsius chosen. kelv = get_int.input_int("\nKelvin: ") print((f"\n{kelv} Kelvin is " f"{kelv_to_cels(kelv):.1f} " "degrees Celsius")) if choice is 5: # Fahrenheit to Kelvin chosen. fahr = get_int.input_int("\nDegrees Fahrenheit: ") print((f"\n{fahr} degrees Fahrenheit is " f"{fahr_to_kelv(fahr):.1f} " "Kelvin.")) else: # Kelvin to Fahrenheit chosen. kelv = get_int.input_int("\nKelvin: ") print((f"\n{kelv} Kelvin is " f"{kelv_to_fahr(kelv):.1f} " "degrees Fahrenheit.")) if choice == 2: # User chose distance conversions. while True: # Loop until user wants to return to the main menu. choice = menu.do_menu("Choose a distance conversion", distances_menu_choices) if choice is None: break if choice is 1: # Miles to Kilometres chosen. miles = get_int.input_int("\nMiles: ") print((f"\n{miles} miles is " f"{miles_to_kiloms(miles):.1f} " "kilometres.")) if choice is 2: # Kilometres to Miles chosen. kiloms = get_int.input_int("\nKilometres: ") print((f"\n{kiloms} kilometres is " f"{kiloms_to_miles(kiloms):.1f} " "miles.")) if choice is 3: # Feet to Metres chosen. feet = get_int.input_int("\nFeet: ") print((f"\n{feet} feet is " f"{feet_to_metres(feet):.1f} " "metres.")) if choice is 4: # Metres to Feet chosen. metres = get_int.input_int("\nMetres: ") print((f"\n{metres} metres is " f"{metres_to_feet(metres):.1f} " "feet.")) if choice is 5: # Inches to Centimetres chosen. ins = get_int.input_int("\nInches: ") print((f"\n{ins} inches is " f"{inches_to_centims(ins):.1f} " "centimetres.")) else: # Centimetres to Inches chosen. cms = get_int.input_int("\nCentimetres: ") print((f"\n{cms} Kelvin is " f"{centims_to_inches(cms):.1f} " "inches.")) if choice == 3: # User chose weight conversions. while True: # Loop until user wants to return to the main menu. choice = menu.do_menu("Choose a weight conversion", weights_menu_choices) if choice is None: break if choice is 1: # Tons to Tonnes chosen. tons = get_int.input_int("\nTons: ") print((f"\n{tons} tons is " f"{tons_to_tonnes(tons):.1f} " "tonnes.")) if choice is 2: # Tonnes to Tons chosen. tonnes = get_int.input_int("\nTonnes: ") print((f"\n{tonnes} tonnes is " f"{tonnes_to_tons(tonnes):.1f} " "tons.")) if choice is 3: # Pounds to Kilograms chosen. lbs = get_int.input_int("\nPounds: ") print((f"\n{lbs} pounds is " f"{pounds_to_kgrams(lbs):.1f} " "kilograms.")) if choice is 4: # Kilograms to Pounds chosen. kgs = get_int.input_int("\nKilograms: ") print((f"\n{kgs} kilograms is " f"{kgrams_to_pounds(kgs):.1f} " "pounds.")) if choice is 5: # Ounces to Grams chosen. oz = get_int.input_int("\nOunces: ") print((f"\n{oz} ounces is " f"{ounces_to_grams(oz):.1f} " "grams.")) else: # Grams to Ounces chosen. grams = get_int.input_int("\nGrams: ") print((f"\n{grams} grams is " f"{grams_to_ounces(grams):.1f} " "ounces."))
def main(): while True: # main menu while loop # Do menu choices user_choice = menu.do_menu("Main Menu", ["Generate sort time files", "Plot average sort times"]) if user_choice is None: break # exit choice print('\nValid choice:', user_choice) if user_choice == 1: # first menu choice - generate tests while True: # Sub menu user_choice = menu.do_menu("Select a sort", ["Bubble sort", "Insertion Sort", "Optimized bubble sort", "Selection sort"]) if user_choice is None: break # exit choice print('\nValid choice:', user_choice) if user_choice == 1: # Generating test files for bubble sort # Calling the data test function to generate the csv file print("\nGenerating test files.. for " + counting_quad_sorts.bubble_sort.__name__) collect_function_performance_data.test_function(counting_quad_sorts.bubble_sort, MAX_N, NUM_TESTS) print("\n" + counting_quad_sorts.bubble_sort.__name__ + ".csv generated") elif user_choice == 2: # Generating test files for insertion sort # Calling the data test function to generate the csv file print("\nGenerating test files.. for " + counting_quad_sorts.insertion_sort.__name__) collect_function_performance_data.test_function(counting_quad_sorts.insertion_sort, MAX_N, NUM_TESTS) print("\n" + counting_quad_sorts.insertion_sort.__name__ + ".csv generated") elif user_choice == 3: # Generating test files for optimized bubble sort # Calling the data test function to generate the csv file print("\nGenerating test files.. for " + counting_quad_sorts.opt_bubble_sort.__name__) collect_function_performance_data.test_function(counting_quad_sorts.opt_bubble_sort, MAX_N, NUM_TESTS) print("\n" + counting_quad_sorts.opt_bubble_sort.__name__ + ".csv generated") elif user_choice == 4: # Generating test files for selection sort # Calling the data test function to generate the csv file print("\nGenerating test files.. for " + counting_quad_sorts.selection_sort.__name__) collect_function_performance_data.test_function(counting_quad_sorts.selection_sort, MAX_N, NUM_TESTS) print("\n" + counting_quad_sorts.selection_sort.__name__ + ".csv generated") elif user_choice == 2: # 2nd menu choice plot average sort times # n num of choices while True: # Sub menu file_path = file_chooser.get_file_path_and_name(pattern='*.csv') # file_path is a list of the csv files if file_path is None: break # exit choice if file_path != None: # if there exists a file(s) in file_path print('Path:', file_path[0]) # display its path print('File:', file_path[1]) print('Both:', file_path[0] + "\\" + file_path[1]) print("\nCalculating Averages for " + file_path[1]) # Calculates the column averages for that particular csv file col_avg = file_column_averages.get_file_column_averages(file_path[1]) print("\n Plotting Graph: " + file_path[1][:len(file_path[1]) - 4]) # Plotting the graph of the averages # Setting up graph plot_graph = plotter.plot(title=file_path[1][:len(file_path[1]) - 4], origin_x=15, origin_y=15, scale_x=6, scale_y=0.11, bg='darkseagreen1') plot_graph['draw_axes'](tick_length=4, tick_interval_y=100) # set up axes # Plot each point by for loop for x in range(len(col_avg)): plot_graph['plot_point'](x, col_avg[x], 6 , colour='red') # color red # the n^2/2 function, commented out # plot_graph['plot_function'](lambda x: (x ** 2) / 2 if x >= 0 else None) # plot_graph['put_text']('T(n) = n^2/2', x=70, y=150, size=12, colour='black') # Labels T (100s), n, legend, t(n) = filename plot_graph['put_text']('T\n(100s)', 2, 5500, size=9, colour='Black') plot_graph['put_text']('n', 100, 100, size=9, colour='Black') plot_graph['put_text']('Legend:', x=70, y=450, size=12, colour='blue') plot_graph['put_text']('T(n) = ' + file_path[1][:len(file_path[1]) - 4], x=70, y=300, size=12, colour='red') plot_graph['block']() # Module exits when user closes the canvas window.
def main(): """Program execution starts here.""" intersections = read_intersections("intersections.data") intersection_list = [] for i in range(len(intersections)): intersection_list.append(intersections[i]['name'].strip(' ')) #sel_intersection = intersections[0]['name'] sel_intersection = "4589" df = get_dataset(sel_intersection, intersections) x_train, x_test, y_train, y_test = preprocessing(df) model_file = search(intersections, 'name', sel_intersection) main_menu = [ "CAPSTONE TRAFFIC PREDICTION", "Select Intersection", "List of Intersections", "Train Intersection", "Test Intersection (Accuracy)", "Route Check" ] train_menu = [ "Train Mode:", "Train from scratch w/ events", "Train from file w/ events", "Train from scratch", "Train from file", ] route_check_menu = [ "Train Mode:", "Train from scratch w/ events", "Train from file w/ events", "Train from scratch", "Train from file", ] while True: print("Currently Selected Intersection:", sel_intersection) choice = menu.do_menu(main_menu) model = LSTMModel(x_train.shape[1], y_train.shape[1]) if choice is None: return # Exit main() (and program). if choice == 1: # Select Intersection temp_menu = ["Please Select a New Intersection"] for line in intersections: option = line["name"] + ": " + line["street"] temp_menu.append(option) choice = menu.do_menu(temp_menu) if choice is not None: sel_intersection = intersections[choice - 1]['name'] print(sel_intersection, "set as current intersection.") df = get_dataset(sel_intersection, intersections) x_train, x_test, y_train, y_test = preprocessing(df) model_file = search(intersections, 'name', sel_intersection) if model_file is not None: model_file = intersections[model_file]['model'] #try: model.load_network('./model/'+str(sel_intersection)+'.hdf') #except: # print("File for loading model is not found! Creating a new model from scratch") # model.init_network(hidden_size=50) elif choice == 2: # List Intersections print_intersections(intersections) elif choice == 3: model = LSTMModel(x_train.shape[1], y_train.shape[1]) # Train Intersections # TODO test each option choice = menu.do_menu(train_menu) if choice == 1: x_train, x_test, y_train, y_test = preprocessing(df, events=True) model = LSTMModel(x_train.shape[1], y_train.shape[1]) intersection_idx = search(intersections, 'name', sel_intersection) model_file = "model/" + sel_intersection + ".hdf" #if os.path.exists(model_file): #os.remove(model_file) model.init_network(hidden_size=50) elif choice == 2: x_train, x_test, y_train, y_test = preprocessing(df, events=True) model = LSTMModel(x_train.shape[1], y_train.shape[1]) intersection_idx = search(intersections, 'name', sel_intersection) model_file = "model/" + sel_intersection + ".hdf" if os.path.exists(model_file): model.load_network(model_file) else: print("Model does not exist, starting from scratch") model.init_network(hidden_size=50) elif choice == 3: x_train, x_test, y_train, y_test = preprocessing(df, events=False) model = LSTMModel(x_train.shape[1], y_train.shape[1]) intersection_idx = search(intersections, 'name', sel_intersection) model_file = "model/" + sel_intersection + ".hdf" if os.path.exists(model_file): os.remove(model_file) model.init_network(hidden_size=50) elif choice == 4: x_train, x_test, y_train, y_test = preprocessing(df, events=False) model = LSTMModel(x_train.shape[1], y_train.shape[1]) intersection_idx = search(intersections, 'name', sel_intersection) model_file = "model/" + sel_intersection + ".hdf" if os.path.exists(model_file): model.load_network(model_file) else: print("Model does not exist, starting from scratch") model.init_network(hidden_size=50) try: e = int(input("Enter Epochs to train for (Default=50): ")) model.epochs = e except ValueError: print("Invalid number entered, using default value") model.train(x_train, y_train, './'+ model_file) intersections[intersection_idx]['model'] = model_file save_intersections(intersections, "intersections.data") elif choice == 4: # Test Intersections model_file = "model/" + sel_intersection + ".hdf" model = LSTMModel(x_train.shape[1], y_train.shape[1]) if os.path.exists(model_file): model.load_network(model_file) test_output = model.get_accuracy(x_test, y_test) N, S, E, W = confusion_matrix(test_output, y_test, True) else: print("Please train intersection first") elif choice == 5: model = LSTMModel(x_train.shape[1], y_train.shape[1], intersection_list) # Route Check x_data = [] day_week = [1,2,3,4,5,6,7] season=[1,2,3,4] time_str = '' flag = 0 x_data = [] peak = 0 while flag == 0: num_inter = input("Please enter intersection number: ") if num_inter in intersection_list: flag = 1 num_inter = int(num_inter) #x_data.append(int(num_inter)) else: print("Intersection not found!") flag = 0 while flag == 0: week = [0,0,0,0,0,0,0] num_day = input("Please enter the day of the week:\nOptions:\n1:Sunday\n2:Monday\n3:Tuesday\n4:Wednesday\n5:Thursday\n6:Friay\n7:Saturday\n") num_day = int(num_day) if num_day in day_week: flag = 1 week[num_day-1] = 1 x_data = x_data + week else: print("Day of the week not found!") flag = 0 while flag == 0: time_day = input("Please enter the time of the day (ex. 17:30): ") temp = time_day.split(':') if len(temp) == 2: hour = int(temp[0]) * 60 if hour > 9 and hour < 17: peak = 1 time = hour + int(temp[1]) time_d = float(time) / float(1440) if time_d > 1.0: print("Please enter time in the proper format!") else: x_data.append(time_d) flag = 1 else: print("Please enter time in the proper format!") flag = 0 while flag == 0: seasons = [0,0,0,0] season_input = input("Please enter the season:\n1:Summer\n2:Fall\n3:Winter\n4:Spring\n") season_input = int(season_input) if season_input in season: flag = 1 seasons[season_input-1] = 1 x_data = x_data + seasons else: print("Season not found!") # add [0,0] for events x_data.append(peak) x_data = x_data + [0,0] x_test = np.array([x_data]) x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1)) res = model.predict(x_test, num_inter) print("Prediction: " + str(res))
pager.page_dec() do_display() def do_linedec(): pager.line_inc() do_display() def do_pagedec(): pager.page_inc() do_display() def do_goto(): which = input("Go to: ") if which.isnumeric(): pager.set_line(int(which)) do_display() else: print("meh...") options = [ ("a", "lnup", do_linedec), ("z", "pgup", do_pagedec), ("s", "lndn", do_lineadv), ("x", "pgdn", do_pageadv), ("g", "goto", do_goto), ("q", "Quit Program", quit), ] do_display() do_menu("Main Menu", "Option = ", options, "#") print('.')
def main(): """Program execution starts here.""" # Set up main menu and sub-menus. main_menu_choices = ["Temperatures", "Distances", "Weights"] temperatures_menu_choices = [ "Celsius to Fahrenheit", # 1 "Fahrenheit to Celsius", # 2 "Farenheit to Kelvin", # 3 "Celsius to Kelvin", # 4 "Kelvin to Farenheit", # 5 "Kelvin to Celsius", # 6 ] distances_menu_choices = [ "Miles to Kilometers", # 1 "Kilometres to Miles", # 2 "Feet to Metres", # 3 "Metres to Feet", # 4 "Inches to Centimetres", # 5 "Centimetres to Inches", # 6 ] weights_menu_choices = [ "Tons to Tonnes", # 1 "Tonnes to Tons", # 2 "Pounds to Kilograms", # 3 "Kilograms to Pounds", # 4 "Ounces to Grams", # 5 "Grams to Ounces", # 6 ] # Loop until user wants to quit. while True: choice = menu.do_menu("Choose a conversion type:", main_menu_choices) # Did the user choose "Exit?" if choice is None: # Yes, then exit. break if choice == 1: # User chose temperature conversions. # Loop until user wants to return to the main menu. while True: choice = menu.do_menu("Choose a temperature conversion", temperatures_menu_choices) if choice is None: break if choice is 1: # Celsius to Fahrenheit chosen. cels = get_int.input_int("\nDegrees Celsius: ") print((f"\n{cels} degrees Celsius is: " f"{temperatures.cels_to_fahr(cels):.1f} " "degrees Fahrenheit.")) if choice is 2: # Fahrenheit to Celsius chosen. fahr = get_int.input_int("\nDegrees Fahrenheit: ") print((f"\n{fahr} degrees Fahrenheit is: " f"{temperatures.fahr_to_cels(fahr):.1f} " "degrees Celsius.")) if choice is 3: # Farenheit to kelvin chosen fahr = get_int.input_int("\nDegrees Farenheit: ") print((f"\n{fahr} degrees Fahrenheit is: " f"{temperatures.fahr_to_kelv(fahr):.1f}" " degrees Kelvin.")) if choice is 4: # Celsius to Kelvin chosen cels = get_int.input_int("\nDegrees Celsius: ") print((f"\n{cels} degrees Celsius is: " f"{temperatures.cels_to_kelv(cels):.1f}" " degrees Kelvin.")) if choice is 5: # Kelvin to Farenheit chosen kelv = get_int.input_int("\nDegrees Kelvin: ") print((f"\n{kelv} degrees Kelvin is: " f"{temperatures.kelv_to_fahr(kelv):.1f}" " degrees Farenheit.")) if choice is 6: # Kelvin to Celsius chosen kelv = get_int.input_int("\nDegrees Kelvin: ") print((f"\n{kelv} degrees Kelvin is: " f"{temperatures.kelv_to_cels(kelv):.1f}" " degrees Celsius.")) if choice == 2: # User chose distance conversions. # Loop until user wants to return to the main menu. while True: choice = menu.do_menu("Choose a distance conversion", distances_menu_choices) if choice is None: break if choice is 1: # Miles to Kilometeres chosen. miles = get_int.input_int("\nMiles: ") print((f"\n{miles} miles is: " f"{distances.miles_to_kiloms(miles):.1f} " " kilometers.")) if choice is 2: # Kilometers to Miles chosen. kiloms = get_int.input_int("\nKilometers: ") print((f"\n{kiloms} kilometers is: " f"{distances.kiloms_to_miles(kiloms):.1f} " " miles.")) if choice is 3: # Feet to meters chosen feet = get_int.input_int("\nFeet: ") print((f"\n{feet} feet is: " f"{distances.feet_to_metres(feet):.1f}" " meters.")) if choice is 4: # Meters to feet chosen metres = get_int.input_int("\nMeters: ") print((f"\n{metres} meters is: " f"{distances.metres_to_feet(metres):.1f}" " feet.")) if choice is 5: # Inches to centimeters chosen inches = get_int.input_int("\nInches: ") print((f"\n{inches} inches is: " f"{distances.inches_to_centims(inches):.1f}" " centimeters.")) if choice is 6: # Centimeters to inches chosen centims = get_int.input_int("\nCentimeters: ") print((f"\n{centims} centimeters is: " f"{distances.centims_to_inches(centims):.1f}" " Inches")) if choice == 3: # User chose weight conversions. # Loop until user wants to return to the main menu. while True: choice = menu.do_menu("Choose a weight conversion", weights_menu_choices) if choice is None: break if choice is 1: # tons to tonnes. tons = get_int.input_int("\nTons: ") print((f"\n{tons} tons is: " f"{weights.tons_to_tonnes(tons):.1f} " " tonnes.")) if choice is 2: # Tonnes to tons chosen tonnes = get_int.input_int("\nTonnes: ") print((f"\n{tonnes} Tonnes is: " f"{weights.tonnes_to_tons(tonnes):.1f} " " tons.")) if choice is 3: # Pounds to kilograms chosen pounds = get_int.input_int("\nPounds: ") print((f"\n{pounds} pounds is: " f"{weights.pounds_to_kgrams(pounds):.1f}" " kilograms.")) if choice is 4: # Meters to feet chosen kgrams = get_int.input_int("\nKilograms: ") print((f"\n{kgrams} kilograms is: " f"{weights.kgrams_to_pounds(kgrams):.1f}" " pounds.")) if choice is 5: # Ounces to grams chosen ounces = get_int.input_int("\nOunces: ") print((f"\n{ounces} ounces is: " f"{weights.ounces_to_grams(ounces):.1f}" " grams.")) if choice is 6: # Centimeters to inches chosen grams = get_int.input_int("\nGrams: ") print((f"\n{grams} grams is: " f"{weights.grams_to_ounces(grams):.1f}" " ounces."))
def use_wireless(): # restart tcp port os.system("adb tcpip 5555") phone_one = IP_PREFIX + input('IP Address of phone 1\n') phone_two = IP_PREFIX + input('IP Address of phone 2\n') connect(phone_one) pull_phone() # adb_wireless_disconnect() # adb_wireless_connect(phone_two) def pull_phone(): reported_command(f"adb pull {REMOTE} {LOCAL}") def reset_connection(): reported_command("adb disconnect") reported_command("adb kill-server") if __name__ == '__main__': reset_connection() print("\n当前WIFI信息:") WIFI_INFO = reported_command('netsh WLAN show interfaces') choice = do_menu(f"Change IP Prefix? Current One is \"{IP_PREFIX}\"", ["Yes", "No"]) if choice == 1: IP_PREFIX = input("Input a new one.") use_wireless()