def erp_invoice_callback(ch, method, properties, body):
body = json.loads(body)
print(body, method.routing_key)
if method.routing_key == 'new_receipt_queue':
products = body.pop('products', None)
invo = Invoice(**body)
for prod in products:
product = Product.get_by_id(session, prod['id'])
invo.products.append(product)
session.add(invo)
invoices = Invoice.get_all(session)
for invoice in invoices:
Funciones.agregarFactura(invoice)
# TODO
recomendations = Funciones.generar_recomnedacion()
sales = Funciones.generar_oferta()
client_channel.basic_publish(exchange='',
routing_key='recomendation',
body=json.dumps(recomendations))
client_channel.basic_publish(exchange='',
routing_key='sales',
body=json.dumps(sales))
return recomendations, sales
def graficar(columna, opcion):
columna = [x for x in columna]
if isinstance(opcion, list):
# Si es una lista, entonces uso eso como eje x
opc = opcion
elif opcion == 'numerico':
opc = f.numerico(columna)
elif opcion == 'normalizado':
opc = f.normalizado(columna)
elif ':' in opcion:
opc = f.rango(opcion)
if not len(columna) == len(opc):
raise ex.ImposibleProcesar('Graficar')
plt.close()
plt.rcParams['agg.path.chunksize'] = 10000
y = np.array(columna)
x = np.array(opc)
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('grafica')
plt.grid(True)
plt.show()
return 'Graficar'
def leer_recursos(self):
orden_datos = Funciones.orden('recursos.csv')
pos_rec_id = orden_datos.index('id')
pos_tipo = orden_datos.index('tipo')
pos_lat = orden_datos.index('lat')
pos_lon = orden_datos.index('lon')
pos_vel = orden_datos.index('velocidad')
pos_aut = orden_datos.index('autonomia')
pos_del = orden_datos.index('delay')
pos_tas = orden_datos.index('tasa_extincion')
pos_cos = orden_datos.index('costo')
recursos = Funciones.read_file('recursos.csv')
while True:
id = str(input('\nIngresa el ID del recurso al cual estas asociado: '))
if self.recurso_id == id:
for linea in recursos:
if linea[pos_rec_id] == id:
print('\n ID: ' + linea[pos_rec_id], 'Tipo: ' + linea[pos_tipo], 'Velocidad: ' + linea[pos_vel],
'Lat: ' + linea[pos_lat], 'Lon: ' + linea[pos_lon], 'Autonomia: ' + linea[pos_aut],
'Delay: ' +
linea[pos_del], 'Tasa extincion: ' + linea[pos_tas], 'Costo: ' + linea[pos_cos],
sep=', ')
break
break
else:
continue
def erp_product_callback(ch, method, properties, body):
body = json.loads(body)
print(body, method.routing_key)
# Segun que tipo de mensaje se reciba se decide que hacer con cada uno
if method.routing_key == 'new_product_queue':
prod = Product(**body)
session.add(prod)
session.commit()
elif method.routing_key == 'updated_product_queue' or method.routing_key == 'update_stock_queue':
id = body.pop('id', None)
session.query(Product).filter(Product.id == id).update(**body)
session.commit()
elif method.routing_key == 'delete_product_queue':
session.query(Product).filter(Product.id == body['id']).delete()
session.commit()
products = Product.get_all(session)
for product in products:
Funciones.agregarProducto(product)
# TODO
recomendations = Funciones.generar_recomnedacion()
sales = Funciones.generar_oferta()
client_channel.basic_publish(exchange='',
routing_key='recomendation',
body=json.dumps(recomendations))
client_channel.basic_publish(exchange='',
routing_key='sales',
body=json.dumps(sales))
return recomendations, sales
def simular(fecha_actual):
# Esta funcion simula el programa cruzando los incendios con la meteorologia y el avance del fuego.
pos_inc_id, pos_lat, pos_lon, pos_pot, pos_fecha = Funciones.orden_incendios()
incendios = Funciones.read_file('incendios.csv')
i = 0
print('Simulando...\n')
list = pronosticos_lista()
# Con este sorted, ordeno la lista de objetos Meteorologia, en base a su atributo fecha_i.
lista = sorted(list, key=lambda objeto: objeto.minutos_inicio, reverse=True)
incendios_listo = []
informes = Funciones.ls(os.getcwd() + '/Reportes Estrategias de extincion')
for linea in incendios:
if i == 0:
i += 1
continue
else:
incendio = Incendio(linea[pos_inc_id], linea[pos_lat], linea[pos_lon], linea[pos_pot], linea[pos_fecha])
min_actual = Funciones.contar_minutos(fecha_actual)
# Analizo los archivos de estrategias para cada incendio correspondiente
'''for archivo in informes:
id = archivo.split('_')
id = id[0]
if incendio.id == id:
pass'''
incendio.cruzar_metereo_y_recursos(min_actual, lista)
incendios_listo.append(incendio)
return incendios_listo
def testShow(db, tabla):
print("\nImprimiento DB")
print(j.showDatabases())
print("\nImprimiento Tablas", db)
print(j.showTables(db))
print("\nImprimiento Tuplas", db)
print(j.extractTable(db, tabla))
def test_1():
resp_1 = Funciones.funcion_1("abc")
resp_2 = Funciones.funcion_2("abcwxyz")
resp_3 = Funciones.funcion_3(10, 5)
assert resp_1 == "ABC"
assert resp_2 == True
assert resp_3 == 5
def test_recommendations():
print("=========================================================")
Funciones.ordenarProductos()
resultado1 = Funciones.obtenerProductoconMasStock()
resultado2 = Funciones.obtenerProductoconMenosStock()
assert resultado1.nombre == 'Galleta' and resultado1.stock == 4
assert resultado2.nombre == 'FiestaSnax' and resultado2.stock == 1
def evolution_chart(param_data):
"""
Parameters
----------
param_data
Returns
-------
plot
"""
param_data = fn.f_columnas_pips(param_data)
param_data= fn.cumulative_capital(param_data)
param_data["Máximo profit acumulado movil"] = param_data["capital_acm"].cummax() # maximo capital acumulado en cada momento de tiempo
param_data["drawdown"] = param_data["Máximo profit acumulado movil"] - param_data["capital_acm"]
max_drawdown = np.argmax(param_data["drawdown"]) # me regresa el índice de la minusvalía máxima
#plt.plot(data["capital_acm"])
#plt.plot(data["capital_acm"][:max_drawdown], 'o', color="green")
#plt.plot(max_drawdown, data["capital_acm"][max_drawdown], 'o', color="red")
param_data["auxiliar_column"] =None
param_data["auxiliar_column"][:max_drawdown]=param_data["capital_acm"][:max_drawdown]
param_data["auxiliar_column"][max_drawdown]=param_data["capital_acm"][max_drawdown]
capital_acm = param_data["capital_acm"]
fig = go.Figure()
fig.add_trace(go.Scatter(y=param_data["capital_acm"],mode="lines",name="Capital"))
fig.add_trace(go.Scatter(y=param_data["auxiliar_column"],name="Dradown",line=dict(color="red",width=3,dash="dash")))
fig.update_layout(title="Drawdown",
xaxis_title="Operaciones",
yaxis_title="Capital",
)
fig.show()
def botonAlmacenarProductos():
nombreDatabase = "TEMAS.db"
enlace = "https://foros.derecho.com/foro/20-Derecho-Civil-General"
Funciones.crearDatabase(nombreDatabase)
Funciones.obtenDatosDePagina(enlace, nombreDatabase)
print "DB creada correctamente"
def incendios_activos(self, fecha_actual):
incendios = Funciones.read_file('incendios.csv')
orden_datos = Funciones.orden('incendios.csv')
pos_inc_id = orden_datos.index('id')
pos_fecha = orden_datos.index('fecha_inicio')
print('Los incendios activos actualmente son:\n')
incendios = simular(fecha_actual)
for incendio in incendios:
if incendio.estado == 'Prendido' and incendio.minutos <= Funciones.contar_minutos(fecha_actual):
print('ID: ' + incendio.id + ' - Fecha inicio: ' + incendio.fecha, ' - IDs recursos utilizados: ')
def __init__(self, id, fecha_i, fecha_t, tipo, valor, lat, lon, radio):
self.id = id
self.fecha_i = fecha_i
self.fecha_t = fecha_t
self.lat = float(lat)
self.lon = float(lon)
self.tipo = tipo
self.valor = float(valor)
self.radio = float(radio)
self.minutos_inicio = Funciones.contar_minutos(self.fecha_i)
self.minutos_termino = Funciones.contar_minutos(self.fecha_t)
def opt_uno():
"""Crea una lista de diccionarios(cada alumno), calcula la suma
de notas individuales,suma total de notas finales y promedio.
Luego imprime en pantalla.
"""
#Funciones opcion 1
global l_alum
l_alum = Func.cargar_estructura(list) # crear lista diccionarios = OK
Func.print_info(l_alum) #imprimir lista de diccionarios = OK
print(
Func.prom_gral(l_alum)) # imprimir suma notas finales y prom gral = OK
def leer_usuarios(self):
orden_datos = Funciones.orden('usuarios.csv')
pos_id = orden_datos.index('id')
pos_nombre = orden_datos.index('nombre')
pos_contrasena = orden_datos.index('contraseña')
pos_recurso_id = orden_datos.index('recurso_id')
usuarios = Funciones.read_file('usuarios.csv')
for linea in usuarios:
print('ID: ' + linea[pos_id], 'Nombre usuario: ' + linea[pos_nombre],
'Contrasena: ' + linea[pos_contrasena],
'ID recurso asociado: ' + linea[pos_recurso_id], sep=', ')
def nuevoMapa(self, mapa):
mapaFinal = []
for i in range(len(mapa)):
mapaFinal.append(mapa[i])
posAgente = Funciones.buscarPos(5, mapaFinal)
while (posAgente != 0):
mapaFinal[posAgente[0]][posAgente[1]] = 0
posAgente = Funciones.buscarPos(5, mapaFinal)
return mapaFinal
def visualizar_recurso(self, archivo=None):
columnarecurso = recursos.encontrar_indice("id:string")
nombre = self.encontrar_indice("nombre:string")
columnausuarios = super().encontrar_indice("recurso_id:string")
filausuarios = (self.buscafilas(self.nombre, nombre))
for item in recursos.lista:
if item[columnarecurso] == self.lista[filausuarios][
columnausuarios]:
aux = []
aux.append(recursos.lista[0])
aux.append(item)
fx.printer(aux)
def addCubo():
id = Funciones.escribeEntero("¿A que contenedor deseas añadir el cubo?: ")
if existeContenedor(id):
lado = Funciones.escribeEntero("Lado del cubo: ")
cubo = Cubo(lado)
for contenedor in contenedores:
if contenedor.identificador == id:
contenedor.abrirContenedor()
contenedor.addMercancia(cubo)
contenedor.cerrarContenedor()
else:
print("El contenedor introducido no existe")
def aniadirCliente():
fichero = open("clientes.txt", "a+")
print("\nNUEVO CLIENTE\n")
dni = Funciones.escribeNIE()
nombre = Funciones.escribeCadena("Nombre: ")
apellidos = Funciones.escribeCadena("Apellidos: ")
direccion = Funciones.escribeCadena("Direccion: ")
opcion = Funciones.lee_opcion("Tipo (N - Normal / P - Preferente): ",
["N", "P"])
fichero.write("\n" + dni + ":" + nombre + ":" + apellidos + ":" +
direccion + ":" + "N")
fichero.close()
def addMaterial():
id = Funciones.escribeEntero("Id de la caseta que deseas obtener el informe de un barometro: ")
if existeId(id):
opcion = Funciones.lee_opcion("T - Termometro\nH - Barometro\n", ["T","H"])
for caseta in casetas:
if opcion == "T":
aparato = Termometro(caseta.mayorId())
caseta.addAparato(aparato)
else:
aparato = Barometro(caseta.mayorId())
caseta.addAparato(aparato)
else:
print("El id no existe")
def addCaja():
id = Funciones.escribeEntero("¿A que contenedor deseas añadir el cubo?: ")
if existeContenedor(id):
ancho = Funciones.escribeEntero("Ancho de la Caja: ")
alto = Funciones.escribeEntero("Alto de la Caja: ")
fondo = Funciones.escribeEntero("Fono de la Caja: ")
caja = Caja(ancho, alto, fondo)
for contenedor in contenedores:
if contenedor.identificador == id:
contenedor.abrirContenedor()
contenedor.addMercancia(caja)
contenedor.cerrarContenedor()
else:
print("El contenedor introducido no existe")
def __init__(self, id, lat=0, lon=0, potencia=0, fecha=''):
self.id = id
self.lat = float(lat)
self.lon = float(lon)
self.potencia = potencia
self.fecha = fecha
self.ano, self.mes, self.dia, self.hora, self.minuto = Funciones.fecha_lista(fecha)
self.radio = 1
self.puntos_apagados = 0
self.minutos = Funciones.contar_minutos(fecha)
self.recursos_utilizados = []
self.estado = 'Prendido'
self.fecha_apagado = ''
self.minutos_usar = Funciones.contar_minutos(fecha)
def __init__(self, mapa):
self.mapa = mapa
self.contador = 0
# Nodos de inicio
pos_inicial = Funciones.buscarPos(6, mapa)
self.inicio = Nodo("Camino", pos_inicial, None, [], mapa)
# Crea las listas abierta y cerrada.
self.abierta = []
self.cerrada = []
if (globals()["algoritmo"] == "A*"):
self.temp = []
# Añade el nodo inicial a la lista cerrada.
self.cerrada.append(self.inicio)
#print(self.inicio.mapa)
# Añade vecinos a la lista abierta
self.abierta += self.vecinos(self.inicio)
if (globals()["algoritmo"] == "pU"):
self.temp = []
self.cerrada.append(self.inicio)
self.abierta += self.vecinos(self.inicio)
# Buscar mientras meta no este en la lista cerrada.
while self.meta():
self.contador += 1
if (self.abierta == []):
self.abierta = Funciones.llenarLista(self.temp, self.abierta)
#self.buscar()
e = True
if (self.contador <= 1000):
self.buscar()
else:
punto = self.abierta[0]
for i in range(1, len(self.abierta)):
if (punto.g > self.abierta[i].g):
punto = self.abierta[i]
self.abierta = Funciones.vaciarLista(self.abierta)
punto.posFinal = punto
self.abierta.append(punto)
e = False
break
self.caminata = self.camino(e)
def sesion(self, user):
self.user = user
self.cambios = {}
columnas = list(fun.lista_juegos(con))
juegos = fun.listar_nuevos(con, fun.traer_nuevos(con))
calif = fun.calificados(self.user[0], con)
for columna in columnas:
# print(columna)
self.list.AppendColumn(columna)
self.list.AppendColumn('Calificacion')
self.list.AppendColumn('Calificacion_Sistema')
# print(len(columna))
lista_calif = fun.cal_global(con)
for item in juegos:
aux = item
row = []
for i in aux:
if i == None or i == 'None':
row += [""]
else:
row += [i]
try:
puntaje = calif[aux[0]]
except:
puntaje = ""
try:
cal_g = lista_calif[aux[0]]
except KeyError:
cal_g = ""
row += [puntaje]
row += [cal_g]
# print(row,len(row))
# puntaje = calif[juegos.loc[item][1]][0]
# if puntaje == None:
# row += []
# else:
# row += [int(puntaje)]
#
self.list.Append(row)
def opt_dos():
"""Muestra los valores dentro de un rango seleccionado de 'X' valor."""
opc = select_opc(cad.submenu_a).lower()
while opc != 'd':
if opc in ['a', 'b', 'c']:
#funciones opcion 2
nota = Func.definir_clave(
opc) #definir key segun char ingresado = OK
rango = Func.definir_rango(opc) #definir rango valido = OK
if not rango:
print(cad.error)
else:
Func.print_info(Func.lista_filter(
nota, rango, l_alum)) #Crear filter e imprimir = OK
opc = select_opc(cad.submenu_a).lower()
def pronosticos_lista():
cruzar = []
# Esta funcion crea una lista con objetos los Meteorologia correspondiente del archivo
pos_id, pos_fecha_i, pos_fecha_t, pos_tipo, pos_valor, pos_lat, pos_lon, pos_radio = Funciones.orden_pronosticos()
pronosticos = Funciones.read_file('meteorologia.csv')
i = 0
with open('meteorologia.csv', 'r', encoding='utf8') as arch:
ultimo_id = arch.readlines()[-1]
ultimo_id = ultimo_id.strip('\n')
ultimo_id = ultimo_id.split(',')
for linea in pronosticos: # creo una lista con los objetos Meteorologia del archivo Meteorologia.csv
if i != 0:
meteorologia = Metereologia(linea[pos_id], linea[pos_fecha_i], linea[pos_fecha_t], linea[pos_tipo],
linea[pos_valor], linea[pos_lat], linea[pos_lon], linea[pos_radio])
cruzar.append(meteorologia)
if i == 0:
i += 1
continue
if str(meteorologia.id) == str(ultimo_id[pos_id]):
break
return cruzar
def menu ():
salir = False
while (not salir):
print("MENU PRINCIPAL: ")
print("1. Agregar una caseta")
print("2. Recoger datos casetas")
print("3. Probabilidades de lluvia")
print("4. Agregar material")
print("5. Salir")
opcion = Funciones.escribeEntero("Introduce una opcion (1 - 5): ")
if opcion < 1 or opcion > 5:
print("ERROR: No has introducido un valor valido")
else:
if opcion == 1:
addCaseta()
if opcion == 2:
obtenerInforme()
if opcion == 3:
probabilidadLluvia()
if opcion == 4:
addMaterial()
if opcion == 5:
salir = True
print("Fin del programa.")
print("\n\n")
def generarInformeGeneral():
fichero = open("clientes.txt", "rt")
fichero.seek(0)
clientes = []
totalMensual = 0
it = (linea for i, linea in enumerate(fichero))
for linea in it:
clientes.append(linea.split(":"))
for i in range(0, len(clientes)):
totalMensual = totalMensual + generarInforme(clientes[i][0], False)
print("Total mensual: " + str(totalMensual))
fichero.close()
guardar = Funciones.lee_opcion(
"¿Quieres guardar el total mensual? (SI / NO)", ["SI", "NO"])
if guardar == "SI":
fichero = open("balanceMensual.txt", "w+")
fichero.write(str(totalMensual))
fichero.close()
def leer_recursos(self):
pos_rec_id, pos_tipo, pos_lat, pos_lon, pos_vel, pos_aut, pos_del, pos_tas, pos_cos = Funciones.orden_recursos()
recursos_lista = Funciones.read_file('recursos.csv')
for linea in recursos_lista:
print('\n ID: ' + linea[pos_rec_id], 'Tipo: ' + linea[pos_tipo], 'Velocidad: ' + linea[pos_vel],
'Lat: ' + linea[pos_lat], 'Lon: ' + linea[pos_lon], 'Autonomia: ' + linea[pos_aut], 'Delay: ' +
linea[pos_del], 'Tasa extincion: ' + linea[pos_tas], 'Costo: ' + linea[pos_cos], sep=', ')
def identify_object(frame):
"""
Esta función nos permite encontrar en que punto de la pantalla se encuentra
el objeto con el que estamos pintanto el lienzo. Para realizar este proceso
primero se extrae el componente R_LAB de la imagén (Este es el que mejor se
adapta al objeto en cuestion), luego se binariza la imagen y posteriormente
se encuentra el área y las coordendas del área mayor, finalmente se retorna
las coordenas de este objeto.
Input:
- frame: Imagen donde se quiere encontrar el área.
Output:
- point_one: Coordenada del primero punto.
- point_two: Coordenada del segundo punto.
- half_point: Coordena del punto medio.
"""
point_one = tuple()
point_two = tuple()
half_point = tuple()
height, width, chanels = frame.shape
_, _, _, _, _, red_LAB = fun.componentes(frame)
bin_frame = _binarize_frame(frame, red_LAB, height, width)
area, fit_idx = _compute_frame_area(bin_frame)
if area >= 1090:
point_one, point_two = _find_object_coordinates(bin_frame, fit_idx)
x_half = int((point_one[0] + point_two[0]) / 2)
y_half = int((point_one[1] + point_two[1]) / 2)
half_point = (x_half, y_half)
return point_one, point_two, half_point
def aniadirFactura():
import time
fichero = open("facturas.txt", "a+")
print("\nNUEVA FACTURA\n")
dni = ""
while not existeCliente(dni):
dni = Funciones.escribeNIE()
fecha = time.strftime("%d/%m/%y")
concepto = Funciones.escribeCadena("Concepto de la factura: ")
importe = Funciones.escribeEntero("Importe(sin decimales): ")
fichero.write("\n" + str(ultimaFactura() + 1) + ":" + dni + ":" + fecha +
":" + concepto + ":" + str(importe))
fichero.close()
def mostrarpuntajes(nom, screen):
nombre= nombre= "puntajes/"+nom
lista=Funciones.abrirarchivo(nombre)
fon = pygame.font.SysFont(None, 40)
listo=Option("Volver", (340,285))
band = False
try:
fondo = pygame.image.load("image/mapa-mundi.jpg")
except pygame.error:
band = True
done=False
while not done:
x=250
y=50
cont=0
pygame.event.pump()
confondo(screen, band, fondo)
for puntajes in lista:
cont+=1
if cont == 6:
x=450
y=50
texto = fon.render(str(puntajes[0])+' '+str(puntajes[1]), True, (0,0,0))
screen.blit(texto, (x, y))
y+=50
if listo.rect.collidepoint(pygame.mouse.get_pos()):
listo.hovered = True
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
break
if(event.type == pygame.MOUSEBUTTONDOWN):
done=True
listo.draw()
pygame.display.update()
def compararpuntaje(punt, nom): nombre= "puntajes/"+nom lista=Funciones.abrirarchivo(nombre) for obj in lista: if obj[1] < punt: return True return False
def guardarpuntaje(obj, punt, nombre):
nom=[obj[0].getletra()+obj[1].getletra()+obj[2].getletra(),punt]
lista=[]
lista=Funciones.abrirarchivo('puntajes/'+nombre)
aux=[]
for obj in lista:
if obj[1]< nom[1]:
aux=nom[:]
nom[0]=obj[0]
nom[1]=obj[1]
obj[0]=aux[0]
obj[1]=aux[1]
guardararchivo(lista,nombre)
import Funciones # Importar clase
hombremujerempresa = "" # Limpiar hombremujerempresa
codident = 0 # Limpiar codigo de identificador
verempresa = 1 # Codigo para verificar si es cuil o cuit
print "Hola..."
while True: # Se verifica si lo que se
# ingreso es valido y de un solo caracter
hombremujerempresa = raw_input("Ingrese:\
\nM si es mujer\nV si es varon\nE si es empresa")
if len(hombremujerempresa) == 1:
if hombremujerempresa.lower() == "m":
codident = "27"
elif hombremujerempresa.lower() == "v":
codident = "20"
elif hombremujerempresa.lower() == "e":
codident = "30"
verempresa = 0
elif hombremujerempresa >= 0:
print "Error, ingrese lo pedido"
continue
break
print "Error, ingrese lo pedido"
Funciones.averiguaciondelcuil(codident, verempresa) # Se le pasa el valor
# de los 2 primeros numeros de identificacion
if letras[cont2] == patente[cont]:
veriftotal = veriftotal + 1
if cont < 3: # Verifica los primeros 3 numeros
verificacion = verificacion + 1
if verificacion == 1 and cont == 0:
verificacion2 = 1
# Cambia los valores de letras a numeros
coleccion = coleccion + diccionario[letras[cont2]]
cont2 = cont2 + 1
cont = cont + 1
cont2 = 0
# Verifica que la patente obtenida sea valida
if verificacion == 3 and veriftotal == 3 and len(patente) == 6:
verificacion2 = 0
print "Patente Valida"
patente = str(coleccion) + str(patente[3:6])
Funciones.calculocod(patente, coleccion)
break
# Verifica que la patente obtenida sea valida
elif verificacion2 == 1 and verificacion == 1 and veriftotal == 1:
print "Patente Valida"
patente = str(coleccion) + str(patente[1:len(patente)])
Funciones.calculocod(patente, coleccion)
break
else:
print "Patente Invalida"
continue
else:
print "Patente Invalida"
continue
