def main(): guitars = [] print("My guitars!") name = input("Name: ") while name != "": year = int(input("Year: ")) cost = float(input("Cost: $")) new_guitar = Guitar(name, year, cost) guitars.append(new_guitar) name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: guitars.sort() print("These are my guitars: ") for i, guitar in enumerate(guitars, 1): if guitar.is_vintage(): vintage = "(Vintage)" else: vintage = "" print("Guitar {}: {:<20} ({}), worth ${:10,.2f} {}".format( i, guitar.name, guitar.year, guitar.cost, vintage)) else: print("No guitars?!")
def main(): guitars = [] print("My guitars!") name = input("Name: ") while name != "": year = int(input("Year: ")) cost = float(input("Cost: $")) guitar_to_add = Guitar(name, year, cost) guitars.append(guitar_to_add) print(guitar_to_add, "added.") name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: guitars.sort() print("These are my guitars:") for i, guitar in enumerate(guitars): vintage_string = "" if guitar.is_vintage(): vintage_string = "(vintage)" print("Guitar {0}: {1.name:>30} ({1.year}), worth ${1.cost:10,.2f}\ {2}".format(i + 1, guitar, vintage_string)) else: print("No guitars :( Quick, go and buy one!")
def main(): """Guitar program, using Guitar class.""" guitars = [] print("My guitars!") name = input("Name: ") while name != "": year = int(input("Year: ")) cost = float(input("Cost: $")) guitar_to_add = Guitar(name, year, cost) guitars.append(guitar_to_add) print(guitar_to_add, "added.") name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: guitars.sort(key=attrgetter("year")) print("These are my guitars:") for i, guitar in enumerate(guitars): vintage_string = "" if guitar.is_vintage(): vintage_string = "(vintage)" print("Guitar {}: {:>20} ({}), worth ${:10,.2f}{}".format(i + 1, guitar.name, guitar.year, guitar.cost, vintage_string)) else: print("No guitars!")
def main(): """Guitar program is worked by Guitar class""" print("My guitars!") name = input("Name: ") while name != "": year = int(input("year: ")) cost = float(input("Cost: $")) add_information = Guitar(name, year, cost) guitars.append(add_information) print(add_information, "added.") name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: guitars.sort( ) # sorting by year through the __lt__ method in Guitar class print("These are my guitars:") for thing, things in enumerate(guitars): # display number of guitar vintage_string = "" if things.is_vintage(): vintage_string = "(vintage)" print("Guitar {}: {:>20} ({}), worth ${:10,.2f}{}".format( thing, things.name, things.year, things.cost, vintage_string)) else: print("No guitars")
def main(): """Guitar program, using Guitar class.""" guitars = [] print("My guitars!") name = input("Name: ") while name != "": year = int(input("Year: ")) cost = float(input("Cost: $")) guitar_to_add = Guitar(name, year, cost) guitars.append(guitar_to_add) print(guitar_to_add, "added.") name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: # lists, strings and other collections are False when empty, True when non-empty # In order for sorting to work on Guitar objects, # at least the __lt__ method must be defined in Guitar class guitars.sort() print("These are my guitars:") for i, guitar in enumerate(guitars): vintage_string = "" if guitar.is_vintage(): vintage_string = "(vintage)" print("Guitar {0}: {1.name:>30} ({1.year}), worth ${1.cost:10,.2f}\ {2}".format(i + 1, guitar, vintage_string)) else: print("No guitars :( Quick, go and buy one!")
def main(): guitar1 = Guitar("Fender Stratocaster", 2014, 765.40) guitar2 = Guitar("Gibson", 1922, 16000) guitar3 = Guitar("line", 2010, 1965) guitars = [guitar1,guitar2,guitar3] for i,guitar in enumerate(guitars): print("Guitar {}: {}".format(i,guitar))
def main(): """Guitar program, using Guitar class.""" guitars = [] print("My guitars!") guitar_name = input("Name: ") while guitar_name != "": guitar_year = int(input("Year: ")) guitar_cost = float(input("Cost: $")) guitar = Guitar(guitar_name, guitar_year, guitar_cost) guitars.append(guitar) print(str(guitar) + " added.") guitar_name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: # lists, strings and other collections are False when empty, True when non-empty # In order for sorting to work on Guitar objects, # at least the __lt__ method must be defined in Guitar class guitars.sort() print("These are my guitars:") i = 1 for guitar in guitars: is_vintage = "" if guitar.is_vintage(): is_vintage = "(vintage)" print("Guitar {}: {} ({}), worth $ {:.2f} {}".format(i, guitar.name, guitar.year, guitar.cost, is_vintage)) i += 1 else: print("No any guitars.")
def main(): guitars = [] print("My guitars!") name = input("Name: ") while name != "": year = int(input("Year: ")) cost = float(input("Cost: $")) add_guitar = Guitar(name, year, cost) guitars.append(add_guitar) print(add_guitar, " added.") name = input("Name: ") guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) if guitars: guitars.sort() print("These are my guitars: ") for index, guitar in enumerate(guitars, 1): is_vintage = "(vintage)" if guitar.is_vintage() else "" print( "Guitar {0}: {1.name:>10} ({1.year}), worth ${1.cost:10,.2f} {2}" .format(index, guitar, is_vintage)) else: print("No guitars :( Quick, go and buy one!")
def test_string_tab(net, test_data): net.load_state_dict(torch.load('2fac_checkpoint.pt')) net.eval() criterion = nn.MSELoss() testset = MyDataset(parameters=test_data['parameters'], cqt_spectrograms=test_data['cqt_spec']) testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2) inputs, targets = iter(testloader).next() inputs = inputs.to(device) targets = targets.to(device) gt_samples = [] gt_stringNumbers = [] gt_tabs = [] for i in range(len(targets)): gt_stringNumber, gt_tab = targets.cpu().numpy()[i] guitar = Guitar(options=Options()) gt_stringNumbers.append(gt_stringNumber) gt_tabs.append(gt_tab) #print("gt_stringNumber: %.3f, gt_tab: %.3f" % (gt_stringNumber, gt_tab)) audio_buffer = sequencer.play_note(guitar, int(round(gt_stringNumber)), int(round(gt_tab))) #cqt_spec = cqt_transform.compute_cqt_spec(audio_buffer).T #padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1])) gt_samples.append(audio_buffer) with open("2fac_gt_data.pkl", 'wb') as fh: data_dict = {'gt_samples' : np.array(gt_samples), 'gt_stringNumbers' : np.array(gt_stringNumbers), 'gt_tabs' : np.array(gt_tabs), 'gt_cqts' : inputs.cpu().numpy()} pkl.dump(data_dict, fh) fh.close() preds = net(inputs.unsqueeze_(1)) preds = preds.detach().cpu().numpy() pred_samples = [] pred_cqts = [] pred_stringNumbers = [] pred_tabs = [] for i in range(preds.shape[0]): pred_stringNumber, pred_tab = preds[i] guitar = Guitar(options=Options()) #print("pred_stringNumber: %d, pred_tab: %d" % (int(round(pred_stringNumber)), int(round(pred_tab)))) pred_stringNumbers.append(pred_stringNumber) pred_tabs.append(pred_tab) audio_buffer = sequencer.play_note(guitar, int(round(pred_stringNumber)), int(round(pred_tab))) cqt_spec = cqt_transform.compute_cqt_spec(audio_buffer, n_bins=336, bins_per_octave=48, hop_length=256).T padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1])) pred_cqts.append(padded_cqt.T) pred_samples.append(audio_buffer) with open("2fac_pred_data.pkl", 'wb') as fh: data_dict = {'pred_samples' : np.array(pred_samples), 'pred_stringNumbers' : np.array(pred_stringNumbers), 'pred_tabs' : np.array(pred_tabs), 'pred_cqts' : pred_cqts} pkl.dump(data_dict, fh) fh.close() print('test_loss: %.3f' % evaluate(net, testloader))
def main(): gibson = Guitar("Gibson L-5 CES", 1922, 16045.40) another = Guitar("Another Guitar", 2013, 10904.75) print(f"{gibson.name} get_age() - Expected 98. Got {gibson.get_age()}") print(f"{another.name} get_age() - Expected 7. Got {another.get_age()}") print(f"{gibson.name} is_vintage() - Expected True. Got {gibson.is_vintage()}") print(f"{another.name} is_vintage() - Expected False. Got {another.is_vintage()}")
def __init__(self, **kwargs): """ Construct main app. """ super().__init__(**kwargs) # Basic data example - list of Guitar objects - could be loaded from a file or something self.guitars = [Guitar("Gibson L-5 CES", 1922, 16035.40), Guitar("Line 6 JTV-59", 2010, 1512.9), Guitar("Ukelele", 2017, 99.95)]
def main(): """Test Guitar Class functionality.""" first_guitar = Guitar("Gibson L-5 CES", 1922, 16035.40) second_guitar = Guitar("Another Guitar", 2013, 1500.12) print("{} get_age() - Expected {}. Got {}".format(first_guitar.name, 99, first_guitar.get_age())) print("{} get_age() - Expected {}. Got {}".format(second_guitar.name, 8, second_guitar.get_age())) print("{} is_vintage() - Expected {}. Got {}".format(first_guitar.name, True, first_guitar.is_vintage())) print("{} is_vintage() - Expected {}. Got {}".format(second_guitar.name, False, second_guitar.is_vintage()))
def main(): """ get information of guitars and print them """ guitars = [] # create the list to store guitar information # get_guitars(guitars) # get user input of guitar information guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) # for testing guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) # for testing print_guitars(guitars) # print guitar information
def main(): """Test guitar.py module for errors.""" guitar_one = Guitar("Gibson L-5 CE", 1922, 16035.40) # Expected: 99, True guitar_two = Guitar("Martin OM-45", 1930, 265000.00) # Expected: 91, True guitar_three = Guitar("Jazzmaster Squier", 1990, 399.00) # Expected: 31, False print(f"{guitar_one.name} get_age() - Expected 99. Got {guitar_one.get_age()}") print(f"{guitar_two.name} get_age() - Expected 91. Got {guitar_two.get_age()}") print(f"{guitar_three.name} get_age() - Expected 31. Got {guitar_three.get_age()}") print(f"{guitar_one.name} is_vintage() - Expected True. Got {guitar_one.is_vintage()}") print(f"{guitar_two.name} is_vintage() - Expected True. Got {guitar_two.is_vintage()}") print(f"{guitar_three.name} is_vintage() - Expected False. Got {guitar_three.is_vintage()}")
def test(): guitar1 = Guitar('Gibson L-5 CES', 1922, 16035.40) guitar2 = Guitar('Another Guitar', 2013, 10000.00) print('{} get_age() - Expected {}. Got {}'.format(guitar1.name, 98, guitar1.get_age())) print('{} get_age() - Expected {}. Got {}'.format(guitar2.name, 7, guitar1.get_age())) print('{} is_vintage() - Expected {}. Got {}'.format( guitar1.name, True, guitar1.is_vintage())) print('{} is_vintage() - Expected {}. Got {}'.format( guitar2.name, False, guitar2.is_vintage()))
def main(): name = "Gibson L-5 CES" year = 1922 cost = 16035.40 guitar = Guitar(name, year, cost) other = Guitar("Another Guitar", 2012, 1512.9) print("{} get_age() - Expected {}. Got {}".format(guitar.name, 97, guitar.get_age())) print("{} get_age() - Expected {}. Got {}".format(other.name, 7, other.get_age())) print("{} is_vintage - Expected {}. Got {}".format(guitar.name, True, guitar.is_vintage())) print("{} is_vintage - Expected {}. Got {}".format(other.name, False, other.is_vintage()))
def run_tests(): """Tests for Guitar class.""" guitar1 = Guitar("Guitar1", 1950, 9999.9) guitar2 = Guitar("Guitar2", 2002, 4999.9) print("{} get_age() - Expected {}. Got {}".format(guitar1.name, 67, guitar1.get_age())) print("{} get_age() - Expected {}. Got {}".format(guitar2.name, 15, guitar2.get_age())) print() print("{} is_vintage() - Expected {}. Got {}".format( guitar1.name, True, guitar1.is_vintage())) print("{} is_vintage() - Expected {}. Got {}".format( guitar2.name, False, guitar2.is_vintage()))
def main(): print("My guitars!") name = input("Name: ") while name != "": while True: try: year = int(input("Year: ")) break except ValueError: print("Invalid year, please try again.") while True: try: cost = float(input("Cost: $")) break except ValueError: print("Invalid cost, please try again.") guitars.append(Guitar(name, year, cost)) print(f"{name} ({year}) : ${cost:.2f} added.") name = input("\nName: ") # guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) # guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) print("\nThese are my guitars:") for i, guitar in enumerate(guitars, 1): is_vintage = " (vintage)" if guitar.is_vintage() else "" print( f"Guitar {i}: {guitar.name} ({guitar.year}), worth $ {guitar.cost:,.2f}{is_vintage}" )
def sample_params_pitch_sf(size): freqs = np.array(utils.compute_freqs(num_frets)) character_variation = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) string_damping = np.array([np.random.uniform(0, 0.7) for _ in range(size)], dtype=np.float32) string_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32) pluck_damping = np.array([np.random.uniform(0, 0.9) for _ in range(size)], dtype=np.float32) pluck_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32) string_tension = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) stereo_spread = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) smoothing_factor = np.array([np.random.uniform(0.5, 1) for _ in range(size)], dtype=np.float32) pitch = np.array([np.random.choice(freqs) for _ in range(size)], dtype=np.float32) # ipdb.set_trace() options = [] guitars = [] audio_buffers = [] cqt_specs = [] for i in range(size): options.append(Options(character_variation[i], string_damping[i], string_damping_variation[i], pluck_damping[i], pluck_damping_variation[i], string_tension[i], stereo_spread[i])) guitars.append(Guitar(options=options[i])) audio_buffers.append(sequencer.play_note(guitars[i], 0, 0, pitch[i], smoothing_factor[i])) # print(audio_buffers[i]) # try: # cqt_spec = compute_cqt_spec(audio_buffers[i]).T # except ParameterError: # print(audio_buffers[i]) cqt_spec = compute_cqt_spec(audio_buffers[i]).T padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1])) cqt_specs.append(padded_cqt) cqt_specs = np.array(cqt_specs, dtype=np.float32) print(cqt_specs.shape) return character_variation, string_damping, string_damping_variation, pluck_damping, pluck_damping_variation, string_tension, stereo_spread, pitch, smoothing_factor, cqt_specs
def save_data_hdf5(fname, size): print('Generating {}...'.format(fname)) freqs = np.array(utils.compute_freqs(num_frets)) character_variation = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) string_damping = np.array([np.random.uniform(0, 0.7) for _ in range(size)], dtype=np.float32) string_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32) pluck_damping = np.array([np.random.uniform(0, 0.9) for _ in range(size)], dtype=np.float32) pluck_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32) string_tension = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) stereo_spread = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32) smoothing_factor = np.array([np.random.uniform(0.5, 1) for _ in range(size)], dtype=np.float32) pitch = np.array([np.random.choice(freqs) for _ in range(size)], dtype=np.float32) with h5py.File(fname, 'w') as f: dset_parameters = f.create_dataset('parameters', (size, 9), maxshape=(None, None), dtype='float32', chunks=(size, 9)) dset_cqt_specs = f.create_dataset('cqt_spec', (size, 336, 336), maxshape=(None, None, None), dtype='float32', chunks=(1000, 336, 336)) dset_parameters[:] = np.array([character_variation, string_damping, string_damping_variation, pluck_damping, pluck_damping_variation, string_tension, stereo_spread, pitch, smoothing_factor]).T for i in range(size): options = Options(character_variation[i], string_damping[i], string_damping_variation[i], pluck_damping[i], pluck_damping_variation[i], string_tension[i], stereo_spread[i]) guitar = Guitar(options=options) audio_buffer = sequencer.play_note(guitar, 0, 0, pitch[i], smoothing_factor[i]) cqt_spec = compute_cqt_spec(audio_buffer).T padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1])) dset_cqt_specs[i, :, :] = padded_cqt print('Finished generating {}!'.format(fname))
def __init__(self, **kwargs): self.frets = kwargs.pop('frets') self.strings = kwargs.pop('strings') self.lefty = kwargs.pop('lefty') super(GuitarScreen, self).__init__(**kwargs) global noteButtons print(self.lefty) print(ORIENTATIONTABLE[0]) if self.lefty == ORIENTATIONTABLE[0]: order = -1 else: order = 1 self.guitar = Guitar(number_of_frets=self.frets, tuning=self.strings, is_lefty=self.lefty) self.cols = self.frets self.rows = len(self.strings) + 2 for string in self.guitar.strings: for note in string.notes[::order]: a = Button(text=str(note[0])) a.bind(on_press=self.callback) noteButtons.append(a) self.add_widget(a) for i in range(self.frets)[::order]: self.add_widget(Label(text=str(i))) for fret_marker in self.guitar.fret_markers: self.add_widget(Label(text=str(fret_marker)))
def main(): done = False guitars = [] print("My guitars!") while not done: name = input("Name: ") if not name: break else: try: year = int(input("Year: ")) if not year: raise Exception except: year = 0 try: cost = float(input("Cost: $")) if not cost: raise Exception except: cost = 0 guitars.append(Guitar(name, year, cost)) print("These are my guitars:") for i, guitar in enumerate(guitars, 1): print( f"Guitar {i:>{math.ceil(math.log(len(guitars),10))}}: {str(guitar): <{len(max(str(guitar) for guitar in guitars))}s}", '(vintage)' if guitar.is_vintage() else '')
def main(): print("My guitars!") guitars = [] guitars.append(Guitar("Fender Stratocaster", 2014, 765.40)) guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40)) guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9)) for i, guitar in enumerate(guitars): print("Name:", guitar.name) print("Year:", guitar.year) print("Cost:", guitar.cost) print("{} ({}) : {} added.".format(guitar.name, guitar.year, guitar.cost)) print("These are my guitars:") for i, guitar in enumerate(guitars): print("Guitar {}: {} ({}), worth ${:10,.2f} ({})".format( i + 1, guitar.name, guitar.year, guitar.cost, guitar.is_vintage()))
def get_new_guitar(): """Get new guitar details from a user.""" name = input("Enter the guitars name: ") year = int(input("What year was it made? ")) cost = float(input("How much does it cost? ")) return Guitar(name, year, cost)
def main(): """ check if get_age() and is_vintage function work properly in Guitar class """ gibson = Guitar("Gibson L-5 CES", 1922, 16035.40) another = Guitar("Another Guitar", 2013, 1000.55) print("{} get_age() - Expected 98. Got {}".format(gibson.name, gibson.get_age())) print("{} get_age() - Expected 7. Got {}".format(another.name, another.get_age())) print("{} is_vintage() - Expected True. Got {}".format( gibson.name, gibson.is_vintage())) print("{} is_vintage() - Expected False. Got {}".format( another.name, another.is_vintage()))
def main(): """Demo a guitar""" guitar_a = Guitar("Gibson L-5 CES", 50, 16035.40) print("{} get age()-Excepted {}.got {}".format(guitar_a.name, guitar_a.get_age(), guitar_a.get_age())) print("{} get is vintage()-Excepted {}.Got {}".format( guitar_a.name, guitar_a.is_vintage(), not (guitar_a.is_vintage())))
def guitartest(): """Tests for Guitar class.""" name = "Gibson L-5 CES" year = 1911 cost = 20000 guitar = Guitar(name, year, cost) another = Guitar("Another Guitar", 2000, 6400) print("{} get_age() - Expected {}. Got {}".format(guitar.name, 107, guitar.get_age())) print("{} get_age() - Expected {}. Got {}".format(another.name, 18, another.get_age())) print("{} is_vintage() - Expected {}. Got {}".format( guitar.name, True, guitar.is_vintage())) print("{} is_vintage() - Expected {}. Got {}".format( another.name, False, another.is_vintage()))
def test_guitars(): name1 = "Gibson L-5 CES" year1 = 1922 cost1 = 16035.40 name2 = "Other guitar" year2 = 2010 cost2 = 1000.00 guitar1 = Guitar(name1, year1, cost1) guitar2 = Guitar(name2, year2, cost2) print("{} get_age() - Expected 98. Got {}".format(guitar1.name, guitar1.get_age())) print("{} get_age() - Expected 10. Got {}".format(guitar2.name, guitar2.get_age())) print("{} is_vintage() - Expected True. Got {}".format( guitar1.name, guitar1.is_vintage())) print("{} is_vintage() - Expected False. Got {}".format( guitar2.name, guitar2.is_vintage()))
def main(): gibson = Guitar("Gibson L-5 CES", 1922, 16035.40) another_guitar = ( "Another Guitar", 2013, ) print(gibson.get_age()) print(gibson.is_vintage())
def run_tests(): """Tests for Guitar class.""" name = "Gibson L-5 CES" year = 1922 cost = 16035.40 guitar = Guitar(name, year, cost) other = Guitar("Another Guitar", 2012, 1512.9) print("{} get_age() - Expected {}. Got {}".format(guitar.name, 95, guitar.get_age())) print("{} get_age() - Expected {}. Got {}".format(other.name, 5, other.get_age())) print() print("{} is_vintage() - Expected {}. Got {}".format( guitar.name, True, guitar.is_vintage())) print("{} is_vintage() - Expected {}. Got {}".format( other.name, False, other.is_vintage()))