def main():
global filelist
noIntro = False
while True:
if len(filelist) == 0:
ui.throw('没有提供任何文件！', True)
if filelist[0] == '-s':
noIntro = True
del filelist[0]
elif filelist[0] == '-c':
del filelist[0]
if len(filelist) == 0:
ui.throw('错误的参数：-c。', True)
ui.g.cText = filelist[0]
del filelist[0]
elif filelist[0] == '--help':
ui.showCmdHelp()
exit()
else:
break
if not noIntro:
ui.showIntro()
while True:
for f in filelist:
player.play(f)
ui.showRoll()
def get_mood(scene, mood):
player.play(CONFIG[scene]['moods'][mood]['music'])
toadd = [SCENE_PAGE_HEADER.format(scene)]
for title in CONFIG[scene]['moods']:
toadd.append(SCENE_PAGE_ELEMENT.format(title, scene))
toadd.append(SCENE_PAGE_FOOTER)
return ''.join(toadd)
def PlaySong(self, event):
if self.Songs != None:
Player = self.ASH_Frame.Tools.Player
if Player != None:
Player.Stop()
Player = None
SongIndex = self.SongList.GetSelections()[0]
SongName = self.Songs.keys()[SongIndex]
SongPath = self.Songs[SongName]
ServerUrl = self.ASH_Frame.Search.LastSearchServer + "songs/"
RequestUrl = ServerUrl+SongPath
SongFile = open("saves/.temp.wav", "wb")
import urllib
Song = urllib.urlopen(ServerUrl+SongPath)
SongFile.writelines(Song.read())
SongFile.close()
import player
player.play(self.ASH_Frame)
self.ASH_Frame.Tune.TkRoot = Tkinter.Tk()
tkSnack.initializeSnack(self.ASH_Frame.Tune.TkRoot)
self.ASH_Frame.Tune.SnackSound.write(".tempfile.wav")
self.ASH_Frame.Tune.SnackSound = tkSnack.Sound(load=".tempfile.wav")
def get_mood(scene, mood):
player.play(CONFIG[scene]['moods'][mood]['music'])
toadd = [SCENE_PAGE_HEADER.format(scene)]
for title in CONFIG[scene]['moods']:
toadd.append(SCENE_PAGE_ELEMENT.format(title, scene))
toadd.append(SCENE_PAGE_FOOTER)
return ''.join(toadd)
def sync_play_time(self, pitch_timestamp, old_time):
# sleep
deta_time = time.time() - old_time
deta_timestamp = pitch_timestamp - self.last_timestamp
wait_time = int(deta_timestamp * parse_midi.g_mseconds_per_quarter / parse_midi.g_ticks_per_quarter )
# print "---- midi need wait:", wait_time
## show before play
deta_time = time.time() - old_time
if wait_time - deta_time*1000 > 10:
self.gl_screen_blit()
pygame.display.flip()
deta_time = time.time() - old_time
# print "after pygame:", int(deta_time*1000)
for cmd, pitch, volecity in self.play_commands:
if cmd == "NOTE_ON":
player.play(pitch, volecity, self.sounds)
elif cmd == "NOTE_OFF":
player.stop(pitch, volecity, self.sounds)
elif cmd == "METRO_ON" and player.g_metronome_volume > 0:
player.play(pitch, volecity, self.sounds)
deta_time = time.time() - old_time
# print "after play:", int(deta_time*1000)
player.real_stop(self.sounds, wait_time/1000.0 - deta_time - 0.03)
deta_time = time.time() - old_time
# print "after stop:", int(deta_time*1000)
if wait_time/1000.0 - deta_time > 0:
time.sleep((wait_time/1000.0 - deta_time))
def main():
global filelist
noIntro = False
while True:
if len(filelist) == 0:
ui.throw('没有提供任何文件！', True)
if filelist[0] == '-s':
noIntro = True
del filelist[0]
elif filelist[0] == '-c':
del filelist[0]
if len(filelist) == 0:
ui.throw('错误的参数：-c。', True)
ui.g.cText = filelist[0]
del filelist[0]
elif filelist[0] == '--osd':
ui.g.enable_osd = True
del filelist[0]
elif filelist[0] == '--help':
ui.showCmdHelp()
exit()
else:
break
if not noIntro:
ui.showIntro()
while True:
ui.g.step = 0
for f in filelist:
player.play(f)
ui.g.step = 1
ui.showRoll()
def on_partial_transcription(self, text):
self.listening = False
led.on()
try:
if text.find('开灯') >= 0:
lamp.turn_on()
elif text.find('关灯') >= 0:
lamp.turn_off()
elif text.find('几点了') >= 0 or text.find('现在几点') >= 0:
now = datetime.datetime.now()
player.play(
self.synthesize('现在是{}点{}分'.format(now.hour, now.minute)))
elif text.find('今天星期几') >= 0 or text.find('今天几号') >= 0:
now = datetime.datetime.now()
player.play(
self.synthesize('今天是{}月{}号，星期{}'.format(
now.month, now.day, weekday[now.weekday()])))
elif text.find('小呆') >= 0:
alexa.listen()
time.sleep(3)
#else:
# player.play(self.synthesize(text))
# time.sleep(1)
except Exception as e:
print(e)
led.off()
self.listening = True
print('on_partial_transcription: {}'.format(text))
def main():
args = parse_args()
print('This is srpi v{0}'.format(config.VERSION))
live_audio_url = channels.get_live_audio_url(132)
player.play(live_audio_url)
def test2():
a = seq.build(seq.track1, player.bitRate)
screen.init()
screen.draw(a, player.bitRate / seq.track1[0]["frequency"])
b = gen.sin(440, player.bitRate, 10, 0)
player.play(a)
player.play(b)
def second_phase(model, player, games, phases, train_args):
for i in range(phases):
print('Starting phase ', i, 'of ', phases)
for game in games:
game.open_zero()
player.play(game)
model.fit(games, **train_args)
for game in games:
game.reset()
def api_play(request, n):
"""Handle API request to Play Song n-> [int|"all"|"shuffle"]."""
if n not in player.get_collection() and n not in ["all", "shuffle"]:
request.api_error(json.dumps(dict(error=True)))
return
request.send_response(202, 'API', "Requesting playing %r" % n)
request.send_header('Content-Type', 'application/json')
request.end_headers()
request.wfile.write(json.dumps(dict(playing=True)))
player.play(n)
def onDetection(self, data, start, end):
name = "{0}-{1}".format(start, end) + '.wav'
print(name)
filename = self.savefile(data, start, end)
print('current mode', self.MODE)
if self.MODE == 'RANDOM':
randomfile = player.getRandomFile(play_folder)
player.play(randomfile)
if self.MODE == 'ECHO':
player.play(filename)
self.display.display_image()
print("finished playing")
def start_play():
"""
function to read the listbox selection
and put the result in a label widget
"""
# get selected line index
index = listbox.curselection()[0]
print(index)
player.play(jinglelink[index])
#t = Thread(target=player.play(jinglelink[index]), args=(True,))
#t.start()
# get the line's text
seltext = listbox.get(index)
# put the selected text in the label
label['text'] = seltext
def player_view(request):
if request.method == "POST":
if request.POST.get("file"):
fname = request.POST["file"]
if not os.path.exists(fname):
pass
#request.session.flash(u"Файл '%s' не найден :("%fname)
else:
player.play(fname)
return {"file":os.path.basename(fname),
"pos":player.get_pos(),
"media":media.get()}
else:
request.session.flash(u"А что играть то?")
return {"media": media.get()}
def pressed(channel):
global start
global time0
if start:
time0 = time.time()
GPIO.output(lightList, 1)
else:
GPIO.output(lightList, 0)
response_time = 1000 * (time.time() - time0)
print("Your time is {} ms".format(int(response_time)))
turn_on_n_leds(map_ms_to_n(response_time))
if response_time < 150:
player.play(buzzer, [("C", 0.5), ("C", 0.5), ("G", 2)])
else:
player.play(buzzer, [("G", 0.5), ("F", 0.5), ("E", 0.5), ("C", 2)])
start = not start
def play(self, index: QtCore.QModelIndex = None):
if not index:
return print('No item selected')
track = player.play(index.row(), self.tableModel.tracks[index.row()])
if track:
self.selectCurrentTrack()
self.updatePlayStatus()
self.lyricsTxt.setText(self.lyrics.find())
def main():
import argparse
CLI_DESC = "It is a simple python package to play videos in the terminal using colored characters as pixels or other usefull outputs"
EPILOG = ("\033[1;37mThanks for trying video-to-ascii!\033[0m")
PARSER = argparse.ArgumentParser(prog='video-to-ascii',
description=CLI_DESC,
epilog=EPILOG)
PARSER.add_argument('-f',
'--file',
type=str,
dest='file',
help='input video file',
action='store',
required=True)
PARSER.add_argument(
'--strategy',
default='ascii-color',
type=str,
dest='strategy',
choices=["ascii-color", "just-ascii", "filled-ascii", "reverse-ascii"],
help='choose an strategy to render the output',
action='store')
PARSER.add_argument('-o',
'--output',
type=str,
dest='output',
help='output file to export',
action='store')
PARSER.add_argument('-a',
'--with-audio',
dest='with_audio',
help='play audio track',
action='store_true')
ARGS = PARSER.parse_args()
player.play(ARGS.file,
strategy=ARGS.strategy,
output=ARGS.output,
play_audio=ARGS.with_audio)
def button1Pressed(channel1):
song_A= [('C', 0.5), ('C', 0.5), ('G', 0.5), ('G', 0.5),
('A', 0.5), ('A', 0.5), ('G', 1),
('F', 0.5), ('F', 0.5), ('E', 0.5), ('E', 0.5),
('D', 0.5), ('D', 0.5), ('C', 1),
('G', 0.5), ('G', 0.5), ('F', 0.5), ('F', 0.5),
('E', 0.5), ('E', 0.5), ('D', 1),
('G', 0.5), ('G', 0.5), ('F', 0.5), ('F', 0.5),
('E', 0.5), ('E', 0.5), ('D', 1),
('C', 0.5), ('C', 0.5), ('G', 0.5), ('G', 0.5),
('A', 0.5), ('A', 0.5), ('G', 1),
('F', 0.5), ('F', 0.5), ('E', 0.5), ('E', 0.5),
('D', 0.5), ('D', 0.5), ('C', 1)]
song_B=[('C', 0.5), ('C', 0.5), ('D', 0.5), ('E', 0.5), ('C', 0.5), ('E', 0.5), ('D', 0.5),
('C', 0.5), ('C', 0.5), ('D', 0.5), ('E', 0.5), ('C',1), ('B2',1)]
allSongs=[song_A,song_B]
print("button pressed", selectedSong)
GPIO.output(lightList[0], 1)
player.play(buzzer, allSongs[selectedSong], tempo=120)
def natural_selection(population, path, env, generations, games, ram_obs, mutate_man, mutate_prob, crossover_prob):
# GENERATE INITIAL POPULATION (ADD SOME VARIATIONS)
models = []
for _ in range(population):
model = nn.NeuralNetwork()
model.load(path)
model.genetic_weights_admixture(GeneticAdmixture.MUTATION, mutate_prob, magnitude = mutate_man)
models.append(model)
# FOR EACH GENERATION
for generation in range(generations):
# PLAY
best_score = 0
models_scores_mean = []
for model in range(population):
models_scores_mean.append(player.play(models[model], env, games, ram_obs, False, False, True))
print(f"* Generation: {generation}, Model: {model}, Score: {models_scores_mean[-1]}")
best_score = max(models_scores_mean)
# NEW POPULATION
new_models = []
# SELECT THE 2 BEST
for _ in range(2):
best = np.argmax(models_scores_mean)
models_scores_mean[best] = 0
new_models.append(models[best])
# CROSSOVER BETWEEN THE 2 BEST FOR THE FOLLOWING 2
for two_next in range(2):
other = np.argmax(models_scores_mean)
models_scores_mean[other] = 0
model = models[other]
model.copy_dna_weights(new_models[two_next].model)
model.genetic_weights_admixture(GeneticAdmixture.CROSSOVER, crossover_prob, model = new_models[1 if two_next == 0 else 0].model)
new_models.append(model)
# REPRODUCE BEST
for _ in range(2):
new_models.append(new_models[0])
# SAVE BEST MODEL
new_path = path+"_"+"darwin"+"_"+str(generation)+"_"+str(best_score)
print(f"--> Save model: {new_path}")
new_models[0].save(new_path)
# MUTATE POPULATION
for candidate in range(2,len(new_models)):
new_models[candidate].genetic_weights_admixture(GeneticAdmixture.MUTATION, mutate_prob, magnitude=mutate_man)
# SAVE NEW POPULATION
models = new_models
def make_a_move(player, game_history):
have_played = False
# last_play = -1 if (len(game_history) == 0) else game_history[-1]
while (have_played == False):
if (IN_REPLAY_MODE):
col = replay_list.pop(0)
else:
col = player.play()
have_played = b.move_piece(player.piece, col)
player.last_move = col
# print(player.name, player.last_move)
game_history.append(col)
eog = b.check_eog(col)
if (TOUR_BY_TOUR):
clear()
b.print_board()
input()
return eog
def _alarm(stop_event):
import manager
from mydatetime import getNow
import player
import time
prev = getNow()
minGap = datetime.timedelta(0, 300) # 超过300秒，认为是睡眠/待机唤醒
count = 0
alarm = False # “闹铃”提醒状态
while 1:
if stop_event.is_set():
break
cur = getNow()
if (cur - prev >= minGap):
manager.refreshWeekly()
manager.resortAndSave()
refresh()
prev = cur
reminds = manager.getReminds() # 获取需要闹铃提醒的闹钟
length = len(reminds)
player.play(reminds[0]['sound'] if length else None)
if not alarm and length:
alarm = True
_taskbarThread.start()
_screenThread.start()
on()
count = 0
if alarm and not len(reminds):
alarm = False
player.play(None)
_taskbarThread.stop()
_screenThread.stop()
off()
if alarm and count > 10 * alarmLast:
alarm = False
player.play(None)
_taskbarThread.stop()
_screenThread.stop()
manager.later(getNow() + alarmInterval) # 推迟提醒
off()
count += 1
time.sleep(0.1)
return
def ws_play(connection, n):
"""Handle WS request to Play Song n-> [int|"all"|"shuffle"]."""
# connection.sendMessage(json.dumps(dict(playing=True)))
player.play(n)
import time
import sys
import config
import player
import wx
app = wx.App(redirect=False)
from gui import interface
config.setup()
interface.window.Show()
if config.appconfig['general']['resumelastsong'] == True and config.appconfig[
'general']['lastsong'] != "":
try:
player.open_file(config.appconfig['general']['lastsong'])
player.p.stream.set_position(
int(config.appconfig['general']['lastsongposition']))
player.play()
except:
config.appconfig['general']['lastsong'] = ""
config.appconfig['general']['lastsongposition'] = 0
app.MainLoop()
try:
# Read rfid code or manual input
if (keyboard_input_handler.can_read()):
code = keyboard_input_handler.read()
print("Scanned code: " + code)
logger.info("Scanned code: " + code)
print("last code:" + shared.last_code)
if (code == shared.last_code):
continue
interpreted = interpreter.interpret(code)
if (interpreted.action == interpreter.Action.play):
player.play(interpreted.arg)
if (interpreted.action == interpreter.Action.play_mpd):
card = interpreted.arg
print(card)
player.play_mpd(card["uri"], card["index"], card["kind"] == "playlist")
elif (interpreted.action == interpreter.Action.text2speech):
card = interpreted.arg
print("Speek to file:")
print(card)
speek.to_file(card["desc"])
player.play_mpd(card["uri"])
elif (interpreted.action == interpreter.Action.terminate):
break
except Exception as error:
logger.exception("Unexpected error occured")
code = ""
doRefresh = selectChannel(weight)
except:
doRefresh = False
if mode == _PLAY:
doRefresh = False
try:
stream = urllib.unquote_plus(params['stream'])
#ottAddon = xbmcaddon.Addon(id = 'script.tvguidedixie')
#path = ottAddon.getAddonInfo('path')
#sys.path.insert(0, path)
import player
player.play(stream, False)
except Exception, e:
pass
if mode == _CANCELSELECT:
doRefresh = cancelSelection()
if mode == _INSERTABOVE:
try:
weight = int(params['weight'])
doRefresh = insertSelection(above=True, theWeight=weight)
except:
pass
if mode == _INSERTBELOW:
try:
def playfile1(self):
player.play(self.filepath1)
doRefresh = selectChannel(weight)
except:
doRefresh = False
if mode == _PLAY:
doRefresh = False
try:
stream = urllib.unquote_plus(params['stream'])
#tvpAddon = xbmcaddon.Addon(id = 'script.tvportal')
#path = tvpAddon.getAddonInfo('path')
#sys.path.insert(0, path)
import player
player.play(stream, False)
except Exception, e:
pass
if mode == _CANCELSELECT:
doRefresh = cancelSelection()
if mode == _INSERTABOVE:
try:
weight = int(params['weight'])
doRefresh = insertSelection(above=True, theWeight=weight)
except:
pass
def play(self):
"""
Play the item.
"""
videoplayer.play(self)
for j in tqdm(range(ROUND_NO)):
players=[]
winner=set()
loser=set()
for i in range(PLAYER_NO):
players.append(player.player(i))
#while not len(winner)+len(loser)>=PLAYER_NO-1:
while not len(players)<=1:
a,b=random.sample(players,2)
players.remove(a)
players.remove(b)
if a.isAvailable() and b.isAvailable():
player.play(a,b)
if a.isWin():
winner.add(a.getNo())
all_player.add(a)
elif a.isDead():
loser.add(a.getNo())
all_player.add(a)
else:
pass
players.append(a)
if b.isWin():
winner.add(b.getNo())
all_player.add(b)
elif b.isDead():
loser.add(b.getNo())
all_player.add(b)
import check import cli import player import computer import numpy as np game = False p_coor = np.zeros((3,3)) c_coor = np.zeros((3,3)) cli.intro() while not game: c_coor = computer.play(p_coor, c_coor) cli.render(p_coor, c_coor) if check.check(c_coor): game = True print "Computer wins" break p_coor = player.play(p_coor, c_coor) if check.check(p_coor): game = True print "Player wins"
def play(self):
"""
Start playing the item
"""
audioplayer.play(self)
def makeAbeat(beatsPerMeasure, tempo):
global previousBeat, beatsPerMIDI, modus
while main:
kickKansList = []
SnareKansList = []
kick = []
snare = []
snareDef = []
#makes a list with "building blocks" --> 5/4 is list with 3 elements and a list with 2 elements.
#7/4 is list with 2*list of 2 elements en 1* list of 3 elements. All the elements contain numbers define the chance
kansPMListKick = ba.kansPerMaatsoort(beatsPerMeasure, kickKansList,
"kick")
kansPMListSnare = ba.kansPerMaatsoort(beatsPerMeasure, SnareKansList,
"snare")
#rotates list with building blocks, so 5/4 can be 3+2 or 2+3 etc..
NewkickKansList = ba.transformKansList(kansPMListKick)
NewSnareKansList = ba.transformKansList(kansPMListSnare)
#generate a random list to compare with the chances defined in new<>KansList
uitkomst = ba.makeRandomList(beatsPerMeasure)
#generate kickList
newKick = ba.generateList(NewkickKansList, kick, uitkomst,
beatsPerMeasure)
#generate snareList
newSnare = ba.generateList(NewSnareKansList, snare, uitkomst,
beatsPerMeasure)
#looks for similarity in the kick and snare lists, if there is kick the snare is removed
newSnares = ba.checkList(newSnare, newKick, snareDef, beatsPerMeasure)
# sums all snares
sumSnare = sum(newSnares)
if sumSnare == 0: #checks if there are snares in the generated beat
newSnares = ba.addASnare(newKick, newSnares, beatsPerMeasure)
newSnares = ba.checkList(newSnare, newKick, snareDef,
beatsPerMeasure)
else:
beat = newSnares + newKick
if beat == previousBeat: #check if the new beat is the same as te last beat
makeAbeat(beatsPerMeasure,
tempo) #generate a new Beat if they are the same
else: #play the beat and covert list to a "midiList" with time events
global midiKick, midiSnare, midiHihat, midiTempo
#stores previousBeat to compare with the most recent beat, if they are the same a new beat is generated
previousBeat = newSnare + newKick
# print("beatsPerMeasure : ", beatsPerMeasure)
midiTempo = tempo
if beatsPerMeasure == 7: #because 7/8 counts in 8th notes the tempo is twice is fast as 5/4
tempo = tempo * 2
h = [1] * beatsPerMeasure
if modus == 1:
#double note function doubles the note depth, in modus 1 the 8th notes are not used
newKick = ba.doubleNotes(newKick, beatsPerMeasure, 2)
newSnares = ba.doubleNotes(newSnares, beatsPerMeasure, 2)
h = ba.doubleNotes(
h, beatsPerMeasure, 2
) #because the note depth is twice as high te tempo and beatsPerMeasure is * 2
beatsPerMeasure = beatsPerMeasure * 2
tempo = tempo * 2
if modus == 2: #note depth is set to eighth notes
newKick = ba.doubleNotes(newKick, beatsPerMeasure, 2)
newSnares = ba.doubleNotes(newSnares, beatsPerMeasure, 2)
h = ba.doubleNotes(h, beatsPerMeasure, 2)
#generate a hihat pattern with 8th notes
h = ba.countTriggers(newKick, newSnares, h,
beatsPerMeasure)
beatsPerMeasure = beatsPerMeasure * 2
tempo = tempo * 2
#checks where there is no snare and if there is a snare it adds none to the list.
# for example [0,1,2,3,none,5,6,none] etc..
notSnare = ba.searchForNotSnare(newSnares)
#splits list for example [0,1,2,3] [5,6] etc..
splitNotSnare = ba.split(notSnare, None)
#generate a kick pattern with 8th notes, choses from the splitted lists
kick = ba.getKickPosition(splitNotSnare)
#from timestamp to a list with 1 and 0
newKick = ba.eventsToIndex(kick, beatsPerMeasure)
#if there is no snare on the first beat, kick is add on index 0
if newSnares[0] == 0:
newKick[0] = 1
if beatsPerMeasure == 14:
if sum(newSnares) == 1 and newSnares[
10] == 1: #add some snares if there is only 1 snare on index 10
moreSnares = ba.addMoreSnares(
newKick, newSnares, beatsPerMeasure)
newSnares = ba.eventsToIndex(
moreSnares, beatsPerMeasure)
#print generated beat
print(" ")
print("===================================================")
print(" ")
print("HIHAT : ", h)
print("SNARE : ", newSnares)
print("KICK : ", newKick)
print(" ")
print("===================================================")
print(" ")
print(
colors.bcolors.WELKOM +
"if you like this beat, press 'y' to export or PRESS 'enter' for a new beat or 'q' to quit"
+ colors.bcolors.ENDC)
#convert list from 1 and 0 to timestamps
beatsPerMIDI = beatsPerMeasure
midiKick = midi.convertListForMidi(newKick, midiKick,
beatsPerMeasure)
midiSnare = midi.convertListForMidi(newSnares, midiSnare,
beatsPerMeasure)
midiHihat = midi.convertListForMidi(h, midiHihat,
beatsPerMeasure)
tempo = 60 / tempo #form BPM to time millis
player.play(newKick, newSnares, h, beatsPerMeasure, tempo)
def play(self, event):
if player.p.loaded == True and player.p.streaming == False:
if player.p.stream.is_playing == False:
player.play()
else:
player.pause()
def play(args):
log.info('play')
player.play()
def play(self):
"""
Start playing the item
"""
audioplayer.play(self)
import time import sys import config import player import wx app = wx.App(redirect=False) from gui import interface config.setup() interface.window.Show() if config.appconfig['general']['resumelastsong']==True and config.appconfig['general']['lastsong']!="": try: player.open_file(config.appconfig['general']['lastsong']) player.p.stream.set_position(int(config.appconfig['general']['lastsongposition'])) player.play() except: config.appconfig['general']['lastsong']="" config.appconfig['general']['lastsongposition']=0 app.MainLoop()
for i in range(winSize):
R[i]=N.exp(j*N.pi*i)
yChunk=s.tVect()
y=N.zeros(samples,N.float)
player= player.Player()
nChunks = int(samples/chunkSize)
w=s.hanning()
W=P.fft(w)
P.plot(abs(W))
P.show()
for i in range(nChunks-1):
i1=i*chunkSize
i2=i1+winSize
z=N.double(P.ifft(X1))
y[i1:i2] += z*w
X1 *= R
player.play(y)
def update(self):
global mousex, mousey
if self.state == states["START"]:
initial_hand_size = 5
self.player1.draw_cards(initial_hand_size)
self.player2.draw_cards(initial_hand_size)
self.set_state(states["PICK_MOVE"])
for event in pygame.event.get():
if event.type == pygame.locals.QUIT:
pygame.quit()
elif event.type == pygame.locals.KEYDOWN:
if event.key == pygame.locals.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.locals.QUIT))
elif event.key == 13 and not self.state == 5:
self.end_turn()
#self.set_state(states["PICK_MOVE"])
elif event.type == pygame.locals.MOUSEMOTION:
mousex, mousey = event.pos
#check end turn
#(1041,363), (1131,405)
elif event.type == pygame.locals.MOUSEBUTTONDOWN and event.button == 1:
if 1024 <= mousex <= 1131 and 363 <= mousey <= 405 and not self.state == 5:
self.end_turn()
if game.state == states['WIN']:
if event.type == pygame.locals.MOUSEBUTTONDOWN:
self.reinit()
self.state = states["PICK_MOVE"]
if game.state == states['PICK_TARGET_CARD']:
if event.type == pygame.locals.MOUSEBUTTONDOWN:
if event.button == 3:
game.state = states["PICK_MOVE"]
else:
hand = game.get_current_player().hand
for i in range(0, len(hand)):
# if the click was within the boundary of a card, play that card
if hand[i].posx <= mousex <= hand[i].posx + screen.CARD_WIDTH and hand[i].posy <= mousey <= hand[i].posy + screen.CARD_HEIGHT:
game.state = states['PICK_MOVE']
return i if hand[i].isFunction else None
# if the player is picking a card to play
if game.state == states["PICK_MOVE"]:
# if the player left clicks,
if event.type == pygame.locals.MOUSEBUTTONDOWN and event.button == 1:
player = game.player1
if game.current_player == 1:
hand = game.player1.hand
else:
hand = game.player2.hand
player = game.player2
# check move
#(763, 372), (820,399)
if 763 <= mousex <= 820 and 372 <= mousey <= 399:
p = game.get_current_player()
if p.current_cycles >= 1 and not p.moved_this_turn:
po = game.get_inactive_player()
game.state = states["PICK_TARGET_MEMORY"]
i = game.update()
while i is None and game.state == states["PICK_TARGET_MEMORY"]:
i = game.update()
if i is not None:
m = p.get_memory(i)
if m.value is not None:
moved = False
for j in range(0, len(po.memory)):
n = po.get_memory(j)
if n.value is None and m.get_color() == game.current_player and po.put_memory(j, m.value, m.length):
po.get_memory(j).color(game.current_player)
p.current_cycles -= 1
p.moved_this_turn = True
game.state = states["PICK_MOVE"]
moved = True
break
if not moved and m.get_color() == game.current_player:
game.win('Player ' + str(self.current_player) + ' has won by overflowing his opponent\'s memory.\nClick to restart.')
# check push
#(928,162), (987, 190)
if 928 <= mousex <= 987 and 162 <= mousey <= 190:
game.state = states["PICK_TARGET_MEMORY"]
i = game.update()
while i is None and game.state == states["PICK_TARGET_MEMORY"]:
i = game.update()
if i is not None:
v = player.get_memory(i).value
if v is not None:
game.stack.append(player.get_memory(i).value)
if len(game.stack) > 25:
game.win('Player ' + str(game.get_inactive_player().number) + 'has won the game after Player ' + str(game.current_player) + ' overflowed the stack.\nClick to restart.' )
elif game.state != 5:
game.state = states["PICK_MOVE"]
for i in range(0, len(hand)):
# if the click was within the boundary of a card, play that card
if hand[i].posx <= mousex <= hand[i].posx + screen.CARD_WIDTH and hand[i].posy <= mousey <= hand[i].posy + screen.CARD_HEIGHT:
player.play(i, game)
break
elif game.state == states["PICK_TARGET_MEMORY"] or game.state == states["PICK_EITHER_MEMORY"]:
p = None
l1 = None
if game.state == states["PICK_TARGET_MEMORY"]:
p = game.get_current_player().memory
else:
l1 = len(game.get_current_player().memory)
p = game.get_current_player().memory[:]
p.extend(game.get_inactive_player().memory)
if event.type == pygame.locals.MOUSEBUTTONDOWN and event.button ==1:
for i in range(0, len(p)):
m = p[i]
if m.posx <= mousex <= m.posx + 2*m.width and m.posy <= mousey <= m.posy + 2*m.height:
game.state = states["PICK_MOVE"]
return i
if event.type == pygame.locals.MOUSEBUTTONDOWN and event.button == 3:
game.state = states["PICK_MOVE"]
return None
def playfile2(self):
player.play(self.filepath2)
songsmith.Note(songsmith.nametofreq("E4"), 0.5, 8000)
]),
songsmith.Chord(notes=[
songsmith.Note(songsmith.nametofreq("C4"), 0.5, 8000),
songsmith.Note(songsmith.nametofreq("E4"), 0.5, 8000),
songsmith.Note(songsmith.nametofreq("G4"), 0.5, 8000)
]),
songsmith.Chord(notes=[
songsmith.Note(songsmith.nametofreq("C4"), 1.5, 8000),
songsmith.Note(songsmith.nametofreq("E4"), 1.5, 8000),
songsmith.Note(songsmith.nametofreq("G4"), 1.5, 8000),
songsmith.Note(songsmith.nametofreq("C5"), 1.5, 8000)
])
])
song.addovertones(5)
return str(song)
def TEST3():
""" Returns a 16-bit string audio waveform to test musical beats"""
return str(songsmith.Phrase(chords=[
songsmith.Chord(notes=[
songsmith.Note(220, 20.0, 16000),
songsmith.Note(220.2, 20.0, 16000)
])
]))
if __name__=="__main__":
player.play(waveform.from_string(TEST1()))
player.play(waveform.from_string(TEST2()))
player.play(waveform.from_string(TEST3()))
if order == 'a':
manager.cancel(None)
return 1
# switch
if order == 's':
manager.switch([])
return 1
return -1
listenThread.on = lambda :append(AlarmPage())
listenThread.off = pop
listenThread.refresh = lambda :stack[-1].reprint()
try:
# 模块初始化
import manager
if data['config']['warning_pause']:
initUtil.warning_pause()
append(MainPage())
listenThread.start()
while (1):
order = raw_input()
stack[-1].do(order)
if len(stack) == 0:
break
finally:
player.play(None)
listenThread.stop()
def _start_playing():
player.play(state.playing.path, lambda: next())
_after_movement()
def pomodoro_termino(tarea):
player.play(sonido)
mensaje3 = "Ya pasaron 25 minutos"
mensaje4 = "Ya debió terminar: %s" % tarea
notify.create_icon(mensaje3,mensaje4)
gtk.main()
import parser
import player
STORY_FILE = 'scripts/sf_adventure.txt'
if __name__ == '__main__':
with open(STORY_FILE) as f:
player.play(parser.parse_script(f.read()))
def main():
print((sys.version))
#get presets
getPresets()
writePresets()
inp = inputs.inputs()
stations = radioTime.Stations()
menuList = ("Radio", "USB", "Settings")
menuListSel = "Radio"
stationListSel = ""
activeStation = player.getInformation()["Station"]
activePage = "Menu"
activePageLast = "Menu"
#init done, fade to main prog
visu.explosion()
#update screen and handle events
running = True
while running:
action = inp.getInput()
#Menu ----------------------------------------------------------------
if activePage == "Menu":
activeItem = menuList.index(menuListSel)
if action == "up":
activeItem -= 1
if activeItem < 0: activeItem = 0
elif action == "down":
activeItem += 1
if activeItem >= len(menuList): activeItem = len(menuList) - 1
elif action == "enter":
if menuListSel == "Radio":
activePage = "StationSelect" if activeStation == "" else "Radio"
else:
activePage = menuListSel
elif action == "back":
activePage = activePageLast
menuListSel = menuList[activeItem]
visu.menu1(menuList, activeItem)
#Radio ---------------------------------------------------------------
elif activePage == "Radio":
if action == "up":
player.volume(2)
elif action == "down":
player.volume(-2)
elif action == "enter":
activePage = "StationSelect"
elif action == "back":
activePage = "Menu"
info = player.getInformation()
if info["Station"] == "":
info["Station"] = activeStation
if info["Station"] != activeStation:
try:
url = stations.stations[activeStation]
del stations.stations[activeStation]
stations.stations[info["Station"]] = url
activeStation = info["Station"]
stationListSel = activeStation
except:
pass
visu.radio(activeStation, info["Text"], info["Volume"], info["WLAN"])
#StationSelect -------------------------------------------------------
elif activePage == "StationSelect":
nameList = list(stations.stations.keys())
nameList.sort(key=lambda x: x.lower()) #Case In-sensitive
try:
activeItem = nameList.index(stationListSel)
except:
activeItem = 0
if action == "up":
activeItem -= 1
if activeItem < 0: activeItem = 0
elif action == "down":
activeItem += 1
if activeItem >= len(stations.stations): activeItem = len(stations.stations) - 1
elif action == "enter":
if activeStation != stationListSel:
activeStation = stationListSel
stations.updateUrl(activeStation)
player.play(stations.stations[activeStation])
activePage = "Radio"
elif action == "back":
activePage = "Menu" if activeStation == "" else "Radio"
stationListSel = nameList[activeItem]
visu.menu2(nameList, activeItem)
#USB -----------------------------------------------------------------
elif activePage == "USB":
if action == "up":
x = 0
#volume up
elif action == "down":
x = 0
#volume down
elif action == "enter":
activePage = "SongSelect"
elif action == "back":
activePage = "Menu"
if action == "none":
visu.usb()
#Settings ------------------------------------------------------------
elif activePage == "Settings":
if action == "up":
x = 0
#foo
elif action == "down":
x = 0
#foo
elif action == "enter":
x = 0
#foo
elif action == "back":
activePage = "Menu"
if action == "none":
visu.settings()
# Removes partition without any note
_song.partitions = filter(lambda partition: partition.notes, _song.partitions)
# Start the song at time == 0
start = min(map(lambda partition: min([sys.maxint] + map(lambda note: note.time, partition.notes)), _song.partitions))
for partition in _song.partitions:
for note in partition.notes:
note.time = note.time - start
return _song
if __name__ == "__main__":
import sys, globdef
file = open(sys.argv[1])
s = parse(file)
#print len(s.partitions)
#sys.exit()
#print s
import player
player.play(s)
import time
while 1:
time.sleep(1000)
def playfile1(self): player.play(self.filepath1)
def playfile2(self): player.play(self.filepath2)
def play(self, menuFactory):
return player.play(menuFactory)
def playaudio(self, index):
s = headsets[index]
player.play(s)
def on_partial_transcription(self, text):
print('on_partial_transcription: {}'.format(text))
self.listening = False
player.play(self.synthesize(text))
self.listening = True
def main(self):
"""Play a midi file with sound samples
"""
player.init()
clock = pygame.time.Clock()
old_time = 0
p_done = False
pitch_offset = 60
need_update_display = True
while not p_done:
# events
for ev in pygame.event.get():
need_update_display = True
menu_bar_screen = self.menu_bar.update(ev)
if self.menu_bar:
self.menu_bar_info.set(self.get_menus_info_bar())
# self.menu_bar_info.update(ev)
if self.menu_bar.choice:
try:
self.load_resource(self.menu_bar.choice_label[-1])
except Exception, e:
print "menu error:", e
# if have choice, continue event
continue
if ev.type == MOUSEBUTTONUP:
if ev.pos[1] > 60:
continue
# enable/disable tracks
for track_idx in self.enabled_tracks:
sw = self.enabled_tracks_switch[track_idx]
if sw.collidepoint(ev.pos):
self.enabled_tracks[track_idx] = not self.enabled_tracks[track_idx]
idx = self.tracks_order_idx[track_idx]
note_color = self.piano.TRACK_COLORS[idx % len(self.piano.TRACK_COLORS)]
if self.enabled_tracks[track_idx]:
self.piano.screen.fill(note_color, sw)
else:
self.piano.screen.fill(self.piano.color_lines, sw)
elif ev.type == MOUSEBUTTONDOWN:
if ev.button == 5: # scroll down
self.staff_offset_x += 40
elif ev.button == 4: # scroll up
self.staff_offset_x -= 40
if self.staff_offset_x < 0:
self.staff_offset_x = 0
elif ev.button == 3: # right button
self.is_pause = not self.is_pause
elif ev.button == 1: # left button
if ev.pos[1] < 60: # progress bar can not click
continue
clicked_staff_number = int((ev.pos[1] - self.staff_top) / (self.piano.staff_total_lines * self.piano.staff_space_height))
wraped_staff_offset = 0
if clicked_staff_number > 0:
wraped_staff_offset += self.piano.lastbar_pos_in_line1
if clicked_staff_number > 1:
wraped_staff_offset += self.piano.lastbar_pos_in_line2 * (clicked_staff_number-1)
timestamp_offset_x = (
self.staff_offset_x +
ev.pos[0] +
wraped_staff_offset
) * self.piano.timestamp_range / self.screen_rect.width
self.last_timestamp = -1
for idx, midi_line in enumerate(self.all_midi_lines):
cmd, pitch, volecity_data, track_idx, pitch_timestamp = midi_line[:5]
if timestamp_offset_x > pitch_timestamp:
if self.last_timestamp != pitch_timestamp:
self.midi_cmd_idx = idx
self.last_timestamp = pitch_timestamp
elif timestamp_offset_x < pitch_timestamp:
break
self.play_one_timestamp_while_paused = True
self.piano.reset_piano()
elif ev.type == KEYUP:
if ev.key == K_ESCAPE:
p_done = True
break
# MENU Reload
elif ev.key == K_RETURN:
menus_in_bar, self.midi_filename_data = get_menu_data()
self.menu_bar.set(menus_in_bar)
# Stop
elif ev.key == K_s:
self.piano.reset_piano()
self.staff_offset_x = 0
self.midi_cmd_idx = 0
self.last_timestamp = -1
self.is_pause = True
# Pause/Play
elif ev.key == K_SPACE:
self.is_pause = not self.is_pause
# is_longbar_show
elif ev.key == K_c:
self.piano.is_longbar_show = not self.piano.is_longbar_show
elif ev.key == K_COMMA:
# Slower
parse_midi.g_mseconds_per_quarter = int(60000 / (
60000 / parse_midi.g_mseconds_per_quarter - 10))
if parse_midi.g_mseconds_per_quarter > 2000:
parse_midi.g_mseconds_per_quarter = 2000
self.menu_bar_info.set(self.get_menus_info_bar())
elif ev.key == K_PERIOD:
# Faster
parse_midi.g_mseconds_per_quarter = int(60000 / (
60000 / parse_midi.g_mseconds_per_quarter + 10))
if parse_midi.g_mseconds_per_quarter <= 200:
parse_midi.g_mseconds_per_quarter = 200
self.menu_bar_info.set(self.get_menus_info_bar())
#Page_Up/Page_Down
elif ev.key == K_DOWN:
self.staff_offset_x += self.piano.lastbar_pos_in_line1
elif ev.key == K_UP:
self.staff_offset_x -= self.piano.lastbar_pos_in_line1
if self.staff_offset_x < 0:
self.staff_offset_x = 0
# Previous/Next MIDI
elif ev.key in [K_LEFT, K_RIGHT]:
need_reload = False
if ev.key == K_LEFT:
if self.midi_filename_idx > 0:
self.midi_filename_idx -= 1
need_reload = True
elif ev.key == K_RIGHT:
if self.midi_filename_idx+1 < len(self.midi_filename_data):
self.midi_filename_idx += 1
need_reload = True
if need_reload:
midi_filename = self.midi_filename_data[self.midi_filename_idx]
self.load_resource(midi_filename)
# Metronome
elif ev.key == K_m:
if (1.0 - player.g_metronome_volume) / 2 < 0.1:
player.g_metronome_volume += 0.1
else:
player.g_metronome_volume += (1.0 - player.g_metronome_volume) / 2
# # Set Progress Percent
# elif ev.key in [K_0, K_1, K_2, K_3, K_4, K_5, K_6, K_7, K_8, K_9]:
# self.piano.reset_piano()
# self.midi_cmd_idx = self.all_midi_lines_length * (ev.key - 48) / 10
# self.last_timestamp = -1
# Set Pitch Offset
elif ev.key in [K_v, K_b, K_n]:
pitch_offset = {K_v: 36, K_b: 60, K_n: 84}[ev.key]
elif ev.key == K_f:
player.g_volecity_adjust = (player.g_volecity_adjust+1) % len(player.g_volecity_list)
player.load_sounds([(midi_data[1], midi_data[2]) for midi_data in self.all_midi_lines],
self.sounds)
elif ev.key == K_z:
if self.piano.staff_space_height > 2:
self.piano.staff_space_height /= 2
self.piano.timestamp_range = TIMESTAMP_RANGE * parse_midi.g_ticks_per_quarter / parse_midi.g_mseconds_per_quarter
self.piano.timestamp_range = self.piano.timestamp_range * self.piano.staff_space_height_base / self.piano.staff_space_height
elif ev.key == K_x:
if self.piano.staff_space_height < 128:
self.piano.staff_space_height *= 2
self.piano.timestamp_range = TIMESTAMP_RANGE * parse_midi.g_ticks_per_quarter / parse_midi.g_mseconds_per_quarter
self.piano.timestamp_range = self.piano.timestamp_range * self.piano.staff_space_height_base / self.piano.staff_space_height
# Play Piano with keys
elif ev.key in PITCH_OF_KEY_ON_KEYBOARD:
pitch = pitch_offset + PITCH_OF_KEY_ON_KEYBOARD.index(ev.key)
player.stop(pitch, 100, self.sounds)
player.load_sounds([(pitch, 100)], self.sounds)
cmd = "NOTE_OFF"
self.piano.show_keys_press(cmd, pitch)
elif ev.type == KEYDOWN:
if ev.key in PITCH_OF_KEY_ON_KEYBOARD:
pitch = pitch_offset + PITCH_OF_KEY_ON_KEYBOARD.index(ev.key)
player.load_sounds([(pitch, 100)], self.sounds)
player.play(pitch, 100, self.sounds)
cmd = "NOTE_ON"
self.piano.show_keys_press(cmd, pitch)
# must out of events loop
if self.menu_bar or self.menu_bar.choice:
self.gl_screen_blit()
pygame.display.flip()
clock.tick(10)
continue
# get cmd
try:
if (self.is_pause and not self.play_one_timestamp_while_paused):
raise Exception("paused")
# repeat
if self.midi_cmd_idx >= self.all_midi_lines_length:
raise Exception("repeat")
midi_line = self.all_midi_lines[self.midi_cmd_idx]
self.midi_cmd_idx += 1
cmd, pitch, volecity_data, track_idx, pitch_timestamp = midi_line[:5]
volecity = player.get_volecity(volecity_data)
if pitch not in [0, 1] + player.g_grand_pitch_range:
continue
if track_idx >= 0 and not self.enabled_tracks.get(track_idx, False):
continue
if self.last_timestamp == -1:
# init last timestamp
self.last_timestamp = pitch_timestamp - 1
except Exception, e:
if need_update_display:
self.piano.show_notes_staff_in_page(self.enabled_tracks, self.tracks_order_idx,
self.notes_in_all_staff, self.last_timestamp,
self.staff_top,
parse_midi.g_bar_duration,
parse_midi.g_time_signature_n,
self.staff_offset_x, self.is_pause)
has_stoped = player.real_stop(self.sounds)
self.gl_screen_blit()
pygame.display.flip()
need_update_display = False
if self.midi_cmd_idx >= self.all_midi_lines_length:
if self.midi_repeat_count < TRAINING_REPEAT_TIMES:
self.midi_repeat_count += 1
self.staff_offset_x = 0
self.midi_cmd_idx = 0
self.last_timestamp = -1
else:
if self.midi_filename_idx+1 < len(self.midi_filename_data):
self.midi_filename_idx += 1
else:
self.midi_filename_idx = 0
midi_filename = self.midi_filename_data[self.midi_filename_idx]
self.load_resource(midi_filename)
self.is_pause = False
clock.tick(40)
continue
from music import Note
from player import play
from music import notes, Semitones, Reference
from exercise import IntervalIdentificationMelodicExercise
intervals = [Semitones(i) for i in range(2, 9)]
exercise = IntervalIdentificationMelodicExercise(intervals=intervals,
repetition=5)
for (a, b, c) in exercise.generate_exercises():
print('-' * 50)
print(a, b, c)
play(a)
play(b)
def play(self, event): if player.p.loaded==True and player.p.streaming==False: if player.p.stream.is_playing==False: player.play() else: player.pause()
def play(id):
resource = Station()
station = resource.get(id)
player.play(station)
publisher.publishStatus(station)
return jsonify(station)
def buttonPressed(channel):
song1 = [
("C", 0.5),
("C", 0.5),
("G", 0.5),
("G", 0.5),
("A", 0.5),
("A", 0.5),
("G", 1),
("F", 0.5),
("F", 0.5),
("E", 0.5),
("E", 0.5),
("D", 0.5),
("D", 0.5),
("C", 1),
("G", 0.5),
("G", 0.5),
("F", 0.5),
("F", 0.5),
("E", 0.5),
("E", 0.5),
("D", 1),
("G", 0.5),
("G", 0.5),
("F", 0.5),
("F", 0.5),
("E", 0.5),
("E", 0.5),
("D", 1),
("C", 0.5),
("C", 0.5),
("G", 0.5),
("G", 0.5),
("A", 0.5),
("A", 0.5),
("G", 1),
("F", 0.5),
("F", 0.5),
("E", 0.5),
("E", 0.5),
("D", 0.5),
("D", 0.5),
("C", 1),
]
song2 = [
("E", 0.5),
("lB", 0.5),
("C", 1),
("E", 0.5),
("lB", 0.5),
("C", 1),
("C", 0.25),
("C", 0.25),
("C", 0.25),
("C", 0.25),
("D", 0.25),
("D", 0.25),
("D", 0.25),
("D", 0.25),
("E", 0.5),
("lB", 0.5),
("C", 2),
]
song3 = [
("E", 1),
("E", 1),
("F", 1),
("G", 1),
("G", 1),
("F", 1),
("E", 1),
("D", 1),
("C", 1),
("C", 1),
("D", 1),
("E", 1),
("E", 1.25),
("D", 0.25),
("D", 1),
("E", 1),
("E", 1),
("F", 1),
("G", 1),
("G", 1),
("F", 1),
("E", 1),
("D", 1),
("C", 1),
("C", 1),
("D", 1),
("E", 1),
("E", 1.25),
("C", 0.25),
("C", 1),
]
song4 = [
("G", 1),
("E", 1),
("G", 1.5),
("E", 1),
("C", 1.5),
("D", 1),
("E", 1),
("F", 1.25),
("D", 1.25),
("G", 1.25),
("C", 1),
("B", 2),
]
song5 = []
song6 = []
song7 = []
song8 = []
songList = [song1, song2, song3, song4, song5, song6, song7, song8]
print("button pressed")
GPIO.output(lightList[0], 1)
player.play(buzzer, songList[currLight], tempo=120)
