def __init__(self, duracion):
"""Esto no es una documentacion, es solo un comentario sobre
el funcionamiento. La idea es que cada objeto tiempo tenga
como atributo, ademas de su duracion, una lista con los tiempos
en forma de True y False (que sirver para representar la cancion)
y una lista con los objetos a reproducir."""
self.duracion = duracion
self.notas = ListaEnlazada()
self.notas_obj = ListaEnlazada()
def __init__(self, archivo):
'''Toma como parametro un nombre de archivo y crea la instancia inicial
de la clase Editor con sus respectivos atributos'''
self.archivo = archivo
self.tiempos = ListaEnlazada()
self.sonidos_str = [] #Esta variable guarda los parametros del sonidos
#en forma de cadena para poder guardar el archivo.
self.sonidos = ListaEnlazada()
self.leer()
self._conversion_a_sonido()
self.iterador = iter(self.tiempos)
class Tiempo:
def __init__(self,duracion):
"""Esto no es una documentacion, es solo un comentario sobre
el funcionamiento. La idea es que cada objeto tiempo tenga
como atributo, ademas de su duracion, una lista con los tiempos
en forma de True y False (que sirver para representar la cancion)
y una lista con los objetos a reproducir."""
self.duracion=duracion
self.notas=ListaEnlazada()
self.notas_obj=ListaEnlazada()
#--------------------------------------------------------------------#
def agregar_nota(self,nota):
self.notas.append(nota)
#--------------------------------------------------------------------#
def quitar_nota(self,pos):
self.notas.pop(pos)
#--------------------------------------------------------------------#
def obtener_nota(self):
#Hay que implementar la clase iterador para porder convertir
# a la lista enlazada en una lista de python
return list(self.notas)
#--------------------------------------------------------------------#
def agregar_nota_obj(self,nota):
self.notas_obj.append(nota)
#--------------------------------------------------------------------#
def obtener_nota_obj(self):
#Hay que implementar la clase iterador para porder convertir
# a la lista enlazada en una lista de python
return list(self.notas_obj)
#--------------------------------------------------------------------#
def obtener_tiempo(self):
return self.duracion
def __init__(self,archivo):
'''Entra como parametro un nobre de un archivo y crea el estado inicial
de un objeto archivo'''
self.archivo=archivo
self.tiempos=ListaEnlazada()
self.sonidos=ListaEnlazada()
self.canales=0
self.objeto_sonidos=ListaEnlazada()
class MarcaTiempo:
"""Clase que representa una marca de tiempo de una cancion. Contiene
los atributos agregar_nota, quitar_nota, obtener_notas, index_notas y
obtener_tiempo."""
def __init__(self, duracion):
"""Constructor de la clase, inicializa una lista de notas y la duracion
de la marca de tiempo."""
self.duracion = duracion
self.notas = ListaEnlazada()
#-----------------MANEJO DE NOTAS EN FORMATO DE BOOLEANOS----------------#
def agregar_nota(self, nota, pos=-1):
"""El metodo toma como parametro una nota y la agrega a la lista
de notas del objeto tiempo.
Pre: nota (bool) debe ser un booleano que indique con 'True' si
la nota suena o 'False' en caso contrario."""
if pos == -1 or pos == len(self.notas):
self.notas.append(nota)
return
self.notas.insert(pos, nota)
def quitar_nota(self, pos):
"""El metodo toma como parametro una posicion. Quita la nota de la
la lista de notas del objeto tiempo ubicada en esa posicion.
Pre:
pos (int): debe ser un entero indicando la posicion de la nota."""
self.notas.pop(pos)
def obtener_notas(self):
"""El metodo devuelve una lista de notas.
Post:
La lista devuelta contiene booleanos indicando si la nota
correspondienta suena o no."""
return list(self.notas)
def index_notas(self, pos):
"""El metodo devuelve la nota que se encuentre en la posicion
dada como parametro. No elimina la nota de la lista.
Post:
La nota devuelta sera un booleano (bool)"""
return self.notas.devolver_posicion(pos)
def obtener_tiempo(self):
"""El metodo devuelve la duracion de la marca de tiempo."""
return self.duracion
def __str__(self):
return 'Tiempo de duracion: {}'.format(self.duracion)
def __repr__(self):
return 'MarcaTiempo({})'.format(self.duracion)
class Editor:
'''Clase que modifica los objetos archivo. Tiene los atributos archivo, t_act,
pos_t, pila. Posee los metodos representar_cancion, guardar, avanzar, retroceder,
reproducir, agregar_nota, quitar_nota.'''
def __init__(self, archivo):
'''Toma como parametro un nombre de archivo y crea la instancia inicial
de la clase Editor con sus respectivos atributos'''
self.archivo = archivo
self.tiempos = ListaEnlazada()
self.sonidos_str = [] #Esta variable guarda los parametros del sonidos
#en forma de cadena para poder guardar el archivo.
self.sonidos = ListaEnlazada()
self.leer()
self._conversion_a_sonido()
self.iterador = iter(self.tiempos)
#-----------------------ABRIR E INICIALIZAR CANCION------------------------#
def leer(self):
'''El metodo abre el archivo que tiene como atributo el objeto editor.
Lee y guarda los datos del archivo en los atributos correspondientes.'''
with open(self.archivo) as plp:
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
while len(linea) > 1:
if linea[0].upper() == LETRA_SONIDOS:
parametros_sonido = linea[1].split(SEPARADOR_PARAM_SONIDOS)
self.sonidos_str.append(parametros_sonido)
if linea[0].upper() == LETRA_MARCAS:
duracion = float(linea[1])
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
while linea[0].upper() == LETRA_NOTAS:
t = MarcaTiempo(duracion)
for c in linea[1]:
t.agregar_estado(c == NOTA_ACTIVADA)
self.tiempos.append(t)
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
continue
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
def _conversion_a_sonido(self):
'''El metodo llama al metodo "convertir_a_objeto_sonido" para cada uno de los
sonidos obtenidos del archivo a editar.'''
sonidos = self.sonidos_str[:]
for s in sonidos:
self.sonidos.append(self.convertir_a_objeto_sonido(s))
#--------------------------REPRESENTAR Y GUARDAR-------------------------#
def representar_cancion(self):
'''Representa por consola la cancion en edicion, mostrando las marcas
de tiempo con sus respectivos tracks y el estado en que se encuentran.'''
print('↓ Nro de track', end='\t\t\t\t\t')
print('Tiempos (en segundos)')
print(end=' ')
marca_actual = self.iterador.actual()
for t in self.tiempos:
if t is marca_actual:
print('>' + str(t.obtener_tiempo()) + '<', end=' ')
else:
print(t.obtener_tiempo(), end=' ')
print()
for x in range(len(self.sonidos)):
print(x, end=' ')
for t in self.tiempos:
lista_notas = t.obtener_lista_estados()
nota = lista_notas[x]
if nota: #La idea es que el usuario vea que notas estan activas
print(SONIDO_ACTIVADO, end=' ')
else:
print(SONIDO_DESACTIVADO, end=' ')
print()
def guardar(self, archivo):
'''Abre un archivo en modo escritura y guarda la cancion que se encuentra
en edicion.'''
with open(archivo, 'w') as plp:
plp.write('{}\n'.format(CABECERA_ARCHIVO))
plp.write('{},{}\n'.format(LETRA_CANALES, len(self.sonidos)))
for s in self.sonidos_str:
tipo = s[0]
frecuencia = s[1]
volumen = s[2]
plp.write('{},{}|{}|{}\n'.format(LETRA_SONIDOS, tipo,
frecuencia, volumen))
tiempo = 0 #Contador para evitar repetir el tiempo cuando es el mismo
for t in self.tiempos:
tiempo_nuevo = t.obtener_tiempo()
if tiempo != tiempo_nuevo:
plp.write('{},{}\n'.format(LETRA_MARCAS, tiempo_nuevo))
cadena = ''
for elem in t.obtener_lista_estados():
if elem:
cadena += NOTA_ACTIVADA
else:
cadena += NOTA_DESACTIVADA
plp.write('{},{}\n'.format(LETRA_NOTAS, cadena))
tiempo = tiempo_nuevo
print('El archivo se ha guardado con el nombre ', archivo)
def convertir_a_objeto_sonido(self, parametros):
'''El metodo convierte una lista de parametros a un objeto sonido
de la clase SoundFactory.
Pre:
lista (list): Debe contener, en este orden, el tipo de sonido,
la frecuencia y por ultimo el volumen del mismo.'''
frequency = float(parametros[1])
volume = float(parametros[2])
funciones = {
ONDA_SQUARE: pysounds.SoundFactory.get_square_sound,
ONDA_TRIA: pysounds.SoundFactory.get_triangular_sound,
ONDA_SINE: pysounds.SoundFactory.get_sine_sound,
ONDA_NOISE: pysounds.SoundFactory.get_noise_sound
}
return funciones[parametros[0][0:2]](frequency, volume)
#----------------------------REPRODUCCION----------------------------#
def obtener_sonidos(self, marca_tiempo):
"""Dado un objeto de la clase MarcaTiempo, se obtienen las notas
que deben sonar y se devuelve una lista con las mismas.
Pre:
marca_tiempo (MarcaTiempo): debe ser una marca de tiempo de la
clase MarcaTiempo.
Post:
sonidos (list): Es una lista que contiene instancias de sonido
de la clase SoundFactory."""
lista_notas = marca_tiempo.obtener_lista_estados()
sonidos = []
for i in range(len(lista_notas)):
if lista_notas[i]:
sonidos.append(self.sonidos.devolver_posicion(i))
return sonidos
def _reproducir(self, lista_tiempos, segundos=-1):
"""El metodo reproduce una lista de marcas de tiempos por una cantidad
de segundos dada por parametro.
Si la cantidad de segundos no entra como parametro, la misma toma el
valor de '-1', de esta manera no se tiene en cuenta el tiempo de
reproduccion.
Pre:
lista_tiempos (list): Es una lista que contiene objetos de
la clase MarcasTiempo.
segundos (float): Es la cantidad de segundos que deben reproducirce.
Si parametro no es indicado entonces se reproduce toda la lista_tiempos
sin limitacion."""
sp = pysounds.SoundPlayer(len(self.sonidos))
a_reproducir = []
if segundos == -1:
for t in lista_tiempos:
notas = self.obtener_sonidos(t)
tiempo = t.obtener_tiempo()
a_reproducir.append((notas, tiempo))
else:
tiempo_acumulado = 0
for t in lista_tiempos:
notas = self.obtener_sonidos(t)
tiempo = t.obtener_tiempo()
if tiempo_acumulado + tiempo <= segundos:
a_reproducir.append((notas, tiempo))
tiempo_acumulado += tiempo
continue
a_reproducir.append((notas, segundos - tiempo_acumulado))
break
for nota, tiempo in a_reproducir:
sp.play_sounds(nota, tiempo)
sp.close()
def reproducir(self, cant_tiempos=-1, segundos=-1):
'''Toma como parametro una cantidad de marcas de tiempos y una cantidad
de segundos a reproducir, crea una lista de tiempos y con ella
llama a la funcion _reproducir.
Si cantidad de marcas de tiempos no entra como parametro, tomara el
valor '-1' que indica que la cantidad de marcas de tiempos a reproducir
es el total de marcas en la cancion.
Si la cantidad de segundos no entra como parametro, tomara el valor '-1'
indicandole a la funcion _reproducir que no se eligio una cantidad de
segundos para reproducir.'''
segundos = float(segundos)
if cant_tiempos == -1:
self._reproducir(self.tiempos, segundos)
return
lista_tiempos = []
flag = False #El flag permite agregar a lista_tiempos aquellos que estan
# ubicados a partir de la posicion actual del cursor
contador = 0
marca_actual = self.iterador.actual()
for t in self.tiempos:
if t is marca_actual:
lista_tiempos.append(t)
contador += 1
flag = True
continue
if flag and contador < cant_tiempos:
lista_tiempos.append(t)
contador += 1
self._reproducir(lista_tiempos, segundos)
#--------------------MANEJO DE MARCAS DE TIEMPO-------------------------#
def avanzar(self, x=1):
'''Toma como parametro un numero 'x' y avanza 'x' marcas de tiempo
respecto a la posicion actual. En caso que no haya una marca siguiente
a la actual levanta un IndexError.'''
for iteracion in range(int(x)):
self.iterador.next()
def retroceder(self, x=1):
'''Toma como parametro un numero 'x' y retrocede 'x' marcas de tiempo
respecto a la posicion actual. En caso que no haya una marca anterior
a la actual levanta un IndexError.
Pre: x debe ser un numero int'''
for iteracion in range(int(x)):
self.iterador.prev()
def anadir_marca(self, duracion):
"""Añade un tiempo de duracion dada como parametro al atributo
tiempos de la clase.
Pre:
duracion (float): debe indicar la duracion del tiempo a
añadir."""
self.anadir_marca_prev(duracion)
self.retroceder()
def anadir_marca_next(self, duracion):
"""Añade un tiempo de duracion dada como parametro al atributo
tiempos de la clase.
Pre:
duracion (float): debe indicar la duracion del tiempo a
añadir."""
tiempo = MarcaTiempo(duracion)
for iteracion in range(len(self.sonidos)):
tiempo.agregar_estado(False)
self.iterador.insertar_elem_despues(tiempo)
def anadir_marca_prev(self, duracion):
"""Añade un tiempo de duracion dada como parametro al atributo
tiempos de la clase.
Pre:
duracion (float): debe indicar la duracion del tiempo a
añadir."""
tiempo = MarcaTiempo(duracion)
for iteracion in range(len(self.sonidos)):
tiempo.agregar_estado(False)
self.iterador.insertar_elem_antes(tiempo)
posicion = self.tiempos.index(self.iterador.actual())
if self.tiempos.index(self.iterador.actual()) == 0:
self.tiempos.insert(posicion, tiempo)
#-------------------------MANEJO DE NOTAS----------------------------#
def agregar_nota(self, tipo, frecuencia, volumen):
'''Toma como parametro un tipo de onda, una frequencia y un volumen
para crear un nuevo sonido y agregar una nueva nota. Modifica el
objeto_sonido.'''
self.sonidos_str.append([tipo, frecuencia, volumen])
sonido_nuevo = self.convertir_a_objeto_sonido(
[tipo, frecuencia, volumen])
for t in self.tiempos:
if t is self.iterador.actual():
t.agregar_estado(True)
continue
t.agregar_estado(False)
self.sonidos.append(sonido_nuevo)
def quitar_nota(self, pos):
'''Toma como parametro una posicion y quita la nota en dicha posicion.
Pre: pos debe ser un numero int'''
self.sonidos_str.pop(pos)
self.sonidos.pop(pos)
for t in self.tiempos:
t.quitar_estado(pos)
def cambiar_estado(self, pos, estado):
'''Toma como parametro una posicion y un booleano. Cambia el estado de
la nota en dicha posicion al booleano pasado como parametro.'''
marca_actual = self.iterador.actual()
marca_actual.cambiar_estado(pos, estado)
class Cancion():
"""Representa un conjunto de marcas de tiempo y sonidos (tracks)"""
FUNCIONES_DISPONIBLES = ["sine", "triangular",
"square"] # Constante con los tipos de tracks
def __init__(self):
"""Crea una instancia de la clase."""
self.tiempos = ListaEnlazada() # Marcas de tiempo
self.tracks = [] # Lista de tracks
def store(self, name):
"""Guarda la cancion, si no recibe una cadena valida levanta ValueError
Parametros:
name (string) Nombre del archivo sin extension"""
if self.tiempos.esta_vacia():
return
self.tiempos.volver_al_inicio()
with open(name + ".plp", "w") as f:
f.write("C," + str(self.cant_tracks()) + "\n")
for track in self.tracks:
f.write("S,{}|{}|{}\n".format(track.obtener_tipo(),
track.obtener_frecuencia(),
track.obtener_volumen()))
anterior = None
MarcaDeTiempo = self.tiempos.actual()
while True:
try:
if not MarcaDeTiempo.obtener_duracion() == anterior:
f.write("T," + str(MarcaDeTiempo.obtener_duracion()) +
"\n")
anterior = MarcaDeTiempo.obtener_duracion()
cadena = ""
for posicion in range(self.cant_tracks()):
if posicion in MarcaDeTiempo.obtener_habilitados():
cadena += "#"
else:
cadena += "·"
f.write("N," + cadena + "\n")
MarcaDeTiempo = self.tiempos.siguiente()
except StopIteration:
break
def step(self):
"""Avanza a la siguiente marca de tiempo si la hay. Si no, no hace nada."""
try:
self.tiempos.siguiente()
except StopIteration:
return
def stepm(self, numero):
"""Avanza N marcas de tiempo hacia adelante o las que pueda.
Parametros:
numero (int) Numero de marcas a avanzar"""
try:
for x in range(numero):
self.tiempos.siguiente()
except StopIteration:
return
def back(self):
"""Retrocede a la anterior marca de tiempo si puede."""
try:
self.tiempos.anterior()
except StopIteration:
return
def backm(self, numero):
"""Retrocede N marcas de tiempo hacia atras o las que pueda.
Parametros:
numero (int) Numero de marcas a retroceder"""
try:
for x in range(numero):
self.tiempos.anterior()
except StopIteration:
return
def track_add(self, funcion, frecuencia, volumen):
"""Agrega un track con el sonido indicado.
Parametros:
funcion (string) nombre de la funcion
frecuencia (int) frecuencia de onda
volumen (float) volumen del sonido comprendido entre 0 y 1"""
if funcion.lower() not in self.FUNCIONES_DISPONIBLES:
raise ValueError('El sonido introducido no existe')
self.tracks.append(Track(funcion, int(frecuencia), float(volumen)))
def track_del(self, posicion):
"""Elimina un track por numero. Levanta un IndexError si no esta habilitado.
Parametros:
posicion (int) Posicion a quitar"""
self.tracks.pop(posicion)
def mark_add(self, duracion):
"""Agrega una marca de tiempo de la duracion indicada. Originalmente
todos los tracks estan deshabilitados
Parametros:
duracion (float) duracion de la marca de tiempo"""
mark = MarcaDeTiempo(duracion)
self.tiempos.insert(self.tiempos.posicion_actual(), mark)
self.tiempos.actualizar()
def mark_add_next(self, duracion):
"""Igual que MARKADD pero la inserta luego de la marca en la cual esta
actualmente el cursor
Parametros:
duracion (float) duracion de la marca de tiempo"""
mark = MarcaDeTiempo(duracion)
self.tiempos.insert(self.tiempos.posicion_actual() + 1, mark)
self.tiempos.actualizar()
def mark_add_prev(self, duracion):
"""Igual que MARKADD pero la inserta antes de la marca en la cual esta
actualmente el cursor
Parametros:
duracion (float) duracion de la marca de tiempo"""
if not self.tiempos.posicion_actual():
self.mark_add(
duracion
) # Si se encuentra en la posicion inicial no hay marca previa
return
mark = MarcaDeTiempo(duracion)
self.tiempos.insert(self.tiempos.posicion_actual() - 1, mark)
self.tiempos.actualizar()
def track_on(self, numero):
"""Habilita al track durante la marca de tiempo en la cual esta parada el
cursor. Si el track no existe lanza IndexError. Si no hay marca levanta AttributeError.
Parametros:
numero (int) Numero de track (o posicion)"""
track = self.tracks[
numero] #Para levantar una excepcion si no existe el track
if not numero in self.tiempos.actual().obtener_habilitados():
self.tiempos.actual().habilitar_track(numero)
def track_off(self, numero):
"""Deshabilita al track durante la marca de tiempo en la cual esta parada el
cursor. Si el track no estaba habilitado, no hace nada. Si no hay marca levanta AttributeError.
Parametros:
numero (int) Numero de track (o posicion)"""
if numero in self.tiempos.actual().obtener_habilitados():
self.tiempos.actual().deshabilitar_track(numero)
def play(self):
"""Reproduce la marca en la que se encuentra el cursor actualmente. Si no hay marca no hace nada."""
if not self.tiempos.esta_vacia():
self._reproducir(self.tiempos.actual())
def play_all(self):
"""Reproduce la cancion completa desde el inicio. Y vuelve a la posicion actual. Si no hay marca no hace nada."""
posicion_actual = self.tiempos.posicion_actual()
self.tiempos.volver_al_inicio()
while True:
try:
if not self.tiempos.esta_vacia():
self._reproducir(self.tiempos.actual())
self.tiempos.siguiente()
except StopIteration:
self.tiempos.volver_al_inicio()
self.tiempos.actualizar(posicion_actual)
return
def play_marks(self, numero):
"""Reproduce las proximas n marcas desde la posicion actual del cursor. Y vuelve a la posicion actual. Si no hay marca no hace nada.
Parametros:
numero (int) Numero de marcas a reproducir"""
posicion_actual = self.tiempos.posicion_actual()
try:
for i in range(numero):
if not self.tiempos.esta_vacia():
self._reproducir(self.tiempos.actual())
self.tiempos.siguiente()
except StopIteration:
pass
self.tiempos.volver_al_inicio()
self.tiempos.actualizar(posicion_actual)
def play_seconds(self, segundos):
"""Reproduce los proximos segundos la posicion actual del cursor. Y vuelve a la posicion actual. Si no hay marca no hace nada.
Parametros:
segundos (int) Segundos de marcas a reproducir"""
suma_duracion = 0
posicion_actual = self.tiempos.posicion_actual()
while True:
try:
if not self.tiempos.esta_vacia():
self._reproducir(self.tiempos.actual())
suma_duracion += self.tiempos.actual().obtener_duracion()
if suma_duracion >= segundos:
break
self.tiempos.siguiente()
except StopIteration:
break
self.tiempos.volver_al_inicio()
self.tiempos.actualizar(posicion_actual)
def cant_tracks(self):
"""Obtiene la cantidad de tracks cargados"""
return len(self.tracks)
def _reproducir(self, mark):
"""Reproduce una marca de tiempo"""
sp = pysounds.SoundPlayer(self.cant_tracks())
duracion = mark.obtener_duracion()
sonidos_a_reproducir = []
for track_numero in mark.obtener_habilitados():
track = self.tracks[track_numero]
tipo = track.obtener_tipo()
freq = track.obtener_frecuencia()
vol = track.obtener_volumen()
if tipo == "sine":
sonidos_a_reproducir.append(
pysounds.SoundFactory.get_sine_sound(freq, vol))
if tipo == "triangular":
sonidos_a_reproducir.append(
pysounds.SoundFactory.get_triangular_sound(freq, vol))
if tipo == "square":
sonidos_a_reproducir.append(
pysounds.SoundFactory.get_square_sound(freq, vol))
sp.play_sounds(sonidos_a_reproducir, duracion)
def __init__(self):
"""Crea una instancia de la clase."""
self.tiempos = ListaEnlazada() # Marcas de tiempo
self.tracks = [] # Lista de tracks
def __init__(self, archivo):
self.archivo = archivo
self.tiempos = ListaEnlazada()
self.sonidos = ListaEnlazada()
self.canales = 0
self.objeto_sonidos = ListaEnlazada()
class Archivo:
def __init__(self, archivo):
self.archivo = archivo
self.tiempos = ListaEnlazada()
self.sonidos = ListaEnlazada()
self.canales = 0
self.objeto_sonidos = ListaEnlazada()
#---------------------------------------------------------------------#
def leer(self):
with open(self.archivo) as plp:
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
while len(linea) > 1:
if linea[0].upper() == 'C':
self.canales = linea[1]
if linea[0].upper() == 'S':
lista = linea[1].split('|')
self.sonidos.append(lista)
if linea[0].upper() == 'T':
duracion = float(linea[1])
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
while linea[0].upper() == 'N':
t = Tiempo(duracion)
for c in linea[1]:
t.agregar_nota(c == '#')
self.tiempos.append(t)
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
continue
linea = plp.readline()
linea = linea.rstrip('\n').split(',')
#---------------------------------------------------------------------#
def convertir_objeto(self, lista):
frequency = float(lista[1])
volume = float(lista[2])
print(lista)
funciones = {
'SQ': pysounds.SoundFactory.get_square_sound,
'TR': pysounds.SoundFactory.get_square_sound,
'SI': pysounds.SoundFactory.get_square_sound,
'NO': pysounds.SoundFactory.get_square_sound
}
return funciones[lista[0][0:2]](frequency, volume)
#---------------------------------------------------------------------#
def conversion(self):
for s in self.sonidos:
sonido = self.convertir_objeto(s)
self.objeto_sonidos.append(sonido)
#---------------------------------------------------------------------#
def agregar_objeto(self):
lista = list(self.objeto_sonidos)
for t in self.tiempos:
nota = t.obtener_nota()
contador = 0
for n in nota:
if n:
t.agregar_nota_obj(lista[nota.index(n) + contador])
nota.pop(nota.index(n))
contador += 1
#else:
#t.agregar_nota_obj(None) - Este codigo esta comentado porque no se si va
#---------------------------------------------------------------------#
def reproducir(self):
sp = pysounds.SoundPlayer(8)
a_reproducir = []
for t in self.tiempos: #me parece que esta implementacion va a tardar
# Si tarda creamos una funcion que obtenga la nota y el tiempo antes
notas = t.obtener_nota_obj()
tiempo = t.obtener_tiempo()
a_reproducir.append((notas, tiempo))
for nota, tiempo in a_reproducir:
sp.play_sounds(nota, tiempo)
sp.close()
def reproducir_tiempos(self, lista_tiempos=False, segundos=False):
sp = pysounds.SoundPlayer(8)
a_reproducir = []
if not segundos:
for t in lista_tiempos:
notas = t.obtener_nota_obj()
tiempo = t.obtener_tiempo()
a_reproducir.append((notas, tiempo))
if segundos:
tiempo_acumulado = 0
for t in lista_tiempos:
notas = t.obtener_nota_obj()
tiempo = t.obtener_tiempo()
if tiempo_acumulado + tiempo <= segundos:
a_reproducir.append((notas, tiempo))
tiempo_acumulado += tiempo
continue
a_reproducir.append((notas, segundos - tiempo_acumulado))
break
for nota, tiempo in a_reproducir:
sp.play_sounds(nota, tiempo)
sp.close()
#---------------------------------------------------------------------#
def obtener_datos(self):
return self.tiempos, self.sonidos, self.canales
from ListaDobleEnlazada import ListaDobleEnlazada
from ListaDobleEnlazada import NodoDoble
from ArbolAVL import ArbolAVL
from ArbolAVL import NodoAVL
from ListaEnlazada import ListaEnlazada
from ListaEnlazada import Nodo
from ArbolB import NodoB
from ArbolB import ArbolB
from ArbolB import Pagina
app = Flask("server")
##########################################DASHBOARD###################
listaUsuarios = ListaDobleEnlazada()
bitacora = ListaEnlazada()
def jsonDefault(object):
return object.__dict__
@app.route('/insertarUsuario', methods=['POST'])
def insertarUsuario():
parametro = listaUsuarios.validarUser(request.form["user"],
request.form["pass"])
if parametro == "true":
return "false"
else:
listaUsuarios.insertar(
NodoDoble(request.form["user"], request.form["pass"]))
def __init__(self, duracion):
"""Constructor de la clase, inicializa una lista de notas y la duracion
de la marca de tiempo."""
self.duracion = duracion
self.notas = ListaEnlazada()
from ListaEnlazada import ListaEnlazada lista = ListaEnlazada() lista.agregarInicio(1) lista.agregarInicio(40) lista.agregarInicio(3) lista.agregarInicio(10) lista.agregarInicio(3) print(lista.mostrarPromedio(lista))
from ListaEnlazada import ListaEnlazada
from ListaEnlazada import Nodo
from ArbolB import NodoB
from ArbolB import ArbolB
from ArbolB import Pagina
from Matriz import Matriz
from Matriz import NodoMatriz
from TablaHash import TablaHash
app = Flask("server")
##########################################DASHBOARD###################
listaUsuarios = ListaDobleEnlazada()
historial = ArbolB()
habitaciones = ListaEnlazada()
sistemaPago = ArbolAVL()
matriz = Matriz()
def jsonDefault(object):
return object.__dict__
############################## USUARIOS #########################
@app.route('/insertarUsuario', methods=['POST'])
def insertarUsuario():
parametro = listaUsuarios.validarUser(request.form["user"],
request.form["pass"])
if parametro == "true":
return "false"
class Archivo:
'''Clase que maneja los objetos archivos. Posee los atributos archivo, tiempo
sonidos, canales y objeto_sonido. Tiene los metodos leer(),convertir_a_objeto(),
conversion(),agregar_objeto(),reproducir(),reproducir_tiempos(),obtener_datos().'''
#---------------------------------------------------------------------#
def __init__(self,archivo):
'''Entra como parametro un nobre de un archivo y crea el estado inicial
de un objeto archivo'''
self.archivo=archivo
self.tiempos=ListaEnlazada()
self.sonidos=ListaEnlazada()
self.canales=0
self.objeto_sonidos=ListaEnlazada()
#---------------------------------------------------------------------#
def leer(self):
'''Abre el archivo en modo lectura y lee. Modifica los atributos
canales, tiempos y sonido.
Pre: El archivo esta en formato plp'''
with open(self.archivo) as plp:
linea=plp.readline()
linea=linea.rstrip('\n').split(',')
while len(linea)>1:
if linea[0].upper()=='C':
self.canales=linea[1]
if linea[0].upper()=='S':
lista=linea[1].split('|')
self.sonidos.append(lista)
if linea[0].upper()=='T':
duracion= float(linea[1])
linea=plp.readline()
linea=linea.rstrip('\n').split(',')
while linea[0].upper()=='N':
t=Tiempo(duracion)
for c in linea[1]:
t.agregar_nota(c=='#')
self.tiempos.append(t)
linea=plp.readline()
linea=linea.rstrip('\n').split(',')
continue
linea=plp.readline()
linea=linea.rstrip('\n').split(',')
#---------------------------------------------------------------------#
def convertir_objeto(self, lista): #convertir_obj_son(buen nombre?)
'''Entra como parametro una lista y devuelve un objeto sonido sonido
obtenido de la clase ''. #nombre de la clase
Pre: La lista contiene digitos'''
frequency=float(lista[1])
volume=float(lista[2])
funciones={'SQ':pysounds.SoundFactory.get_square_sound,
'TR':pysounds.SoundFactory.get_square_sound,
'SI':pysounds.SoundFactory.get_square_sound,
'NO':pysounds.SoundFactory.get_square_sound}
return funciones[lista[0][0:2]](frequency,volume)
#---------------------------------------------------------------------#
def conversion(self):
'''Modifica el atributo objeto_sonidos agregandole al mismo objetos
de la clase ''.'''
for s in self.sonidos:
sonido=self.convertir_objeto(s)
self.objeto_sonidos.append(sonido)
#---------------------------------------------------------------------#
def agregar_objeto(self):
'''Agrega al atributo tiempos los sonidos correspondientes que son los
que deberan sonar'''
lista=list(self.objeto_sonidos)
for t in self.tiempos:
nota=t.obtener_nota()
contador=0
for n in nota:
if n:
t.agregar_nota_obj(lista[nota.index(n)+contador])
nota.pop(nota.index(n))
contador+=1
#else:
#t.agregar_nota_obj(None) - Este codigo esta comentado porque no se si va
#---------------------------------------------------------------------#
def reproducir(self):
'''Reproduce todas las notas con sus respectivos tiempos'''
sp=pysounds.SoundPlayer(2)
a_reproducir=[]d
for t in self.tiempos: #me parece que esta implementacion va a tardar
# Si tarda creamos una funcion que obtenga la nota y el tiempo antes
notas=t.obtener_nota_obj()
tiempo=t.obtener_tiempo()
a_reproducir.append((notas,tiempo))
for nota,tiempo in a_reproducir:
sp.play_sounds(nota,tiempo)
sp.close()
#---------------------------------------------------------------------#
def reproducir_tiempos(self,lista_tiempos=False,segundos=False):
'''Toma como parametro una lista_tiempos y/o segundos los cuales se
van reproducir'''
sp=pysounds.SoundPlayer(2)
a_reproducir=[]
if not lista_tiempos:
lista_tiempos=self.tiempos
if not segundos:
for t in lista_tiempos:
print('caca') #buena forma de ver donde esta el error jajajajaj
notas=t.obtener_nota_obj()
tiempo=t.obtener_tiempo()
a_reproducir.append((notas,tiempo))
if segundos:
tiempo_acumulado=0
for t in lista_tiempos:
notas=t.obtener_nota_obj()
tiempo=t.obtener_tiempo()
if tiempo_acumulado+tiempo<=segundos:
a_reproducir.append((notas,tiempo))
tiempo_acumulado+=tiempo
continue
a_reproducir.append((notas,segundos-tiempo_acumulado))
break
for nota,tiempo in a_reproducir:
sp.play_sounds(nota,tiempo)
sp.close()
#---------------------------------------------------------------------#
def obtener_datos(self):
'''Devuleve los atributos tiempo, sonidos y canales'''
return self.tiempos,self.sonidos,self.canales
from ListaEnlazada import ListaEnlazada
ListaEstudiantes = ListaEnlazada()
ListaEstudiantes.insertar('Javier', '201612098', 'Industrial')
ListaEstudiantes.insertar('Denis', '201700792', 'Mecanica')
ListaEstudiantes.insertar('Edwar', '201503986 ', 'Industrial')
ListaEstudiantes.insertar('Estuardo', '201612098', 'Ambiental')
ListaEstudiantes.insertar('Alejandro', '201700792', 'Derecho')
ListaEstudiantes.insertar('Jessica', '201503986 ', 'Arquitectura')
ListaEstudiantes.mostrarNodos()