def rellenar_cobros(self):
model = self.wids['tv_cobros'].get_model()
model.clear()
if self.objeto.cobros != []:
utils.combo_set_from_db(self.wids['cbe_cliente'],
self.objeto.cobros[0].cliente.id)
for c in self.objeto.cobros:
if c.facturaVentaID != None:
importe_factura = c.facturaVenta.importeTotal
vencimientos = "(%d) " % len(c.facturaVenta.vencimientosCobro)
vencimientos += "; ".join(
["%s: %s €" % (utils.str_fecha(v.fecha),
utils.float2str(v.importe))
for v in c.facturaVenta.vencimientosCobro])
elif c.prefacturaID != None:
importe_factura = c.prefactura.importeTotal
vencimientos = "(%d) " % (len(c.prefactura.vencimientosCobro))
vencimientos += "; ".join(
["%s: %s €" % (utils.str_fecha(v.fecha),
utils.float2str(v.importe))
for v in c.prefactura.vencimientosCobro])
model.append((c.numfactura,
"%s €" % (utils.float2str(c.importe)),
utils.str_fecha(c.fecha),
"%s €" % (utils.float2str(importe_factura)),
vencimientos,
c.id))
def rellenar_pies(self,
total, pendiente, cobrado,
total_pagares, pendiente_pagares, cobrado_pagares,
total_otros, pendiente_otros, cobrado_otros,
total_vencimientos, cobrado_strict):
"""
Rellena los entries del pie del formulario con los totales recibidos.
CWT: Al pendiente de cobro hay que restarle lo negociado en pagaré,
aunque no hayan vencido o estén marcados como pendiente.
Por tanto, el
pendiente = total (facturado) - total_pagares - cobrado_otros
y (lo mismo pero jugando con las incóginitas) el
cobrado = total_pagares + cobrado_otros = total - pendiente
"""
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
# self.wids['e_pendiente'].set_text("%s €" % utils.float2str(pendiente))
self.wids['e_pendiente'].set_text("%s €" % utils.float2str(total_vencimientos - total_pagares - cobrado_otros))
self.wids['e_cobrado_strict'].set_text("%s €" % utils.float2str(cobrado_strict))
# self.wids['e_cobrado'].set_text("%s €" % utils.float2str(cobrado))
self.wids['e_cobrado'].set_text("%s €" % utils.float2str(total_pagares + cobrado_otros))
self.wids['e_total_pagares'].set_text("%s €" % utils.float2str(total_pagares))
self.wids['e_pendiente_pagares'].set_text("%s €" % utils.float2str(pendiente_pagares))
self.wids['e_cobrado_pagares'].set_text("%s €" % utils.float2str(cobrado_pagares))
self.wids['e_total_otros'].set_text("%s €" % utils.float2str(total_otros))
self.wids['e_pendiente_otros'].set_text("%s €" % utils.float2str(pendiente_otros))
self.wids['e_cobrado_otros'].set_text("%s €" % utils.float2str(cobrado_otros))
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
total = 0
self.resultados.sort(self.por_fecha_ldc)
for ldc in self.resultados:
subtotal = ldc.cantidad * ldc.precio
datos.append((ldc.nombre_proveedor,
ldc.albaranEntrada.numalbaran,
utils.str_fecha(ldc.albaranEntrada.fecha),
ldc.descripcion_productoCompra,
utils.float2str(ldc.cantidad),
utils.float2str(ldc.precio),
utils.float2str(subtotal)
))
total += subtotal
if len(self.resultados) > 0:
datos.append(("", "", "", "", "", "", "-"*20))
datos.append(("", "", "", "", "", "", utils.float2str(total)))
if (self.inicio) == None:
fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
else:
fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
if datos != []:
informes.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))
def valorar_a_precio_valoracion(tv):
"""
Valora todos los productos de compra con existencias distintas a cero
(OJO: Incluye existencias negativas) según el precio de valoración
definido (precio por defecto, precio medio ponderado, etc.).
"""
pcs = pclases.ProductoCompra.select(pclases.AND(
pclases.ProductoCompra.q.controlExistencias == True,
pclases.ProductoCompra.q.existencias != 0))
model = tv.get_model()
tv.freeze_child_notify()
tv.set_model(None)
model.clear()
suma = 0.0
for pc in pcs:
precio_valoracion = pc.get_precio_valoracion()
valoracion = precio_valoracion * pc.existencias
model.append((pc.codigo,
pc.descripcion,
utils.float2str(pc.existencias,precision=2,autodec=True),
utils.float2str(precio_valoracion, precision = 2),
utils.float2str(valoracion, precision = 2),
pc.id))
suma += valoracion
tv.set_model(model)
tv.thaw_child_notify()
return suma
def rellenar_widgets(self):
"""
Introduce la información del producto actual
en los widgets.
No se chequea que sea != None, así que
hay que tener cuidado de no llamar a
esta función en ese caso.
"""
producto = self.objeto
self.wids['i_barcode'].set_from_file(EanBarCode().getImage(producto.codigo))
self.wids['e_codigo'].set_text(producto.codigo)
self.wids['e_descripcion'].set_text(producto.descripcion)
self.wids['e_nombre'].set_text(producto.nombre)
self.wids['e_precio'].set_text(str(producto.preciopordefecto))
self.wids['e_minimo'].set_text(str(producto.minimo))
self.wids['e_arancel'].set_text(str(producto.arancel))
self.wids['e_prodestandar'].set_text(utils.float2str(producto.prodestandar))
campos = producto.camposEspecificosEspecial
self.wids['e_stock'].set_text(utils.float2str(campos.stock))
self.wids['e_existencias'].set_text(str(campos.existencias))
try:
pesobulto = utils.float2str(producto.calcular_razon_bultos())
except (ValueError, TypeError):
pesobulto = "N/A"
self.wids['e_razon'].set_text(pesobulto)
self.wids['e_unidad'].set_text(campos.unidad)
self.wids['e_observaciones'].set_text(campos.observaciones)
# Datos no modificables:
self.wids['e_idproducto'].set_text(`producto.id`)
self.mostrar_especificos()
self.rellenar_tabla_tarifas()
self.rellenar_existencias_almacen(producto)
self.objeto.make_swap()
self.objeto.camposEspecificosEspecial.make_swap()
def rellenar_tabla(self, facturas):
"""
Rellena el model con los items de la consulta
"""
model = self.wids['tv_datos'].get_model()
model.clear()
self.wids['tv_datos'].freeze_child_notify()
self.wids['tv_datos'].set_model(None)
for cliente in facturas:
padre = model.append(None, (cliente and cliente.nombre
or "Sin cliente",
"0.00",
"",
"0.00",
cliente and cliente.get_puid() or ""))
for factura in facturas[cliente]:
formapago = factura.get_forma_de_pago()
importe = factura.calcular_total()
pdte = factura.calcular_pendiente_de_documento_de_pago()
model[padre][1] = utils.float2str(utils._float(model[padre][1])
+ importe)
model[padre][3] = utils.float2str(utils._float(model[padre][3])
+ pdte)
model.append(padre, (factura.numfactura,
utils.float2str(importe),
utils.str_fecha(factura.fecha),
utils.float2str(pdte),
factura.get_puid()))
self.wids['tv_datos'].set_model(model)
self.wids['tv_datos'].thaw_child_notify()
def build_tabla_contenido(data):
"""
Construye la tabla del contenido del albaranSalida.
Los datos deben venir en listas. Cada línea de la tabla, una tupla o lista
con el código, descripción, cantidad, precio unitario (con dto. si lo
lleva e IVA) y número de pedido.
El precio y cantidad deben ser flotantes para poder calcular el subtotal.
"""
estilo_cabecera_tabla = ParagraphStyle("Cabecera tabla",
parent=estilos["Heading3"])
estilo_cabecera_tabla.fontName = "Times-Bold"
estilo_cabecera_tabla.alignment = enums.TA_CENTER
estilo_numeros_tabla = ParagraphStyle("Números tabla",
parent=estilos["Normal"])
estilo_numeros_tabla.alignment = enums.TA_RIGHT
datos = [(Paragraph(escribe("Código"), estilo_cabecera_tabla),
Paragraph(escribe("Descripción"), estilo_cabecera_tabla),
Paragraph("Cantidad", estilo_cabecera_tabla),
Paragraph("Precio/U", estilo_cabecera_tabla),
#Paragraph("Total c/IVA", estilo_cabecera_tabla),
# CWT: Prefiere la carta de portes sin IVA.
Paragraph("Total", estilo_cabecera_tabla),
Paragraph(escribe("Nº Pedido"), estilo_cabecera_tabla))
]
for d in data:
fila = (escribe(d[0]),
Paragraph(escribe(d[1]),estilos["Normal"]),
Paragraph(escribe(utils.float2str(d[2])),estilo_numeros_tabla),
Paragraph(escribe(utils.float2str(d[3])),estilo_numeros_tabla),
Paragraph(escribe(utils.float2str(d[2] * d[3])),
estilo_numeros_tabla),
escribe(d[4])
)
datos.append(fila)
tabla = Table(datos,
colWidths = (PAGE_WIDTH * 0.13,
PAGE_WIDTH * 0.35,
PAGE_WIDTH * 0.09,
PAGE_WIDTH * 0.09,
PAGE_WIDTH * 0.13,
PAGE_WIDTH * 0.11),
repeatRows = 1)
tabla.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), colors.lightgrey),
("LINEBEFORE", (0, 0), (-1, -1), 0.25, colors.black),
("LINEBELOW", (0, 0), (-1, 0), 1.0, colors.black),
("LINEBELOW", (0, "splitlast"), (-1, "splitlast"), 1.0, colors.black),
("BOX", (0, 0), (-1, -1), 1.0, colors.black),
("INNERGRID", (0, 0), (-1, -1), 0.25, colors.black),
("VALIGN", (0, 0), (-1, 0), "CENTER"),
("VALIGN", (0, 0), (0, -1), "TOP"),
("ALIGN", (0, 0), (-1, 0), "CENTER"),
("ALIGN", (-3, 1), (-1, -1), "RIGHT"),
#("ALIGN", (0, 1), (0, -1), "DECIMAL"), <- No puedo cambiar
# el pivotChar de "." a ",". No me vale.
("ALIGN", (-1, 1), (-1, -1), "CENTER"),
("ALIGN", (0, 1), (0, -1), "CENTER"),
#("RIGHTPADDING", (0, 1), (0, -1), 0.75 * cm),
]))
return tabla
def rellenar_tabla(self, tabla):
"""
Rellena el model con las ldc existentes
"""
albaran = self.objeto
if albaran != None:
lineas = albaran.lineasDeCompra
try:
lineas.sort(lambda l1, l2: l1.id - l2.id)
except:
pass
model = self.wids['tv_ldvs'].get_model()
model.clear()
for l in lineas:
model.append((l.productoCompra.codigo,
l.productoCompra.descripcion,
utils.float2str(l.cantidad, 2),
utils.float2str(l.precio, 4, autodec = True),
"%s %%" % (utils.float2str(l.iva * 100, 0)),
"%s %%" % (utils.float2str(l.descuento * 100, 0)),
utils.float2str(l.get_subtotal(iva = True)),
#l.silo and l.silo.nombre or "",
l.pedidoCompra
and l.pedidoCompra.numpedido or "",
l.pedidoCompra
and utils.str_fecha(l.pedidoCompra.fecha)
or "",
l.id))
def setter_textview(objeto, col, w):
"""
Muestra el valor del atributo "col" del objeto
"objeto" en el textview "w".
"""
valor = getattr(objeto, col.name)
if isinstance(col, sqlobject.col.SODateCol):
valor = str_fecha(valor)
elif isinstance(col, sqlobject.col.SODateTimeCol):
valor = str_fechahoralarga(valor)
elif isinstance(col, sqlobject.col.SOTimeCol):
valor = str_hora(valor)
elif isinstance(col, sqlobject.col.SOFloatCol):
# XXX
# HACK: Workaround. Los valores que son porcentaje (descuentos e IVA)
# se deben mostrar con el símbolo "%", pero la única manera de
# distinguir esas columnas es mirar el nombre.
if col.name in NOMBRES_COLUMNAS_PORCENTAJE:
valor = "%s %%" % float2str(valor * 100,
precision = 5,
autodec = True)
# XXX
else:
valor = float2str(valor, autodec = False)
# Si autodec=True y es número redondo > 1000 escribe 1.000 y el
# getter lo interpreta como flotante.
if not isinstance(valor, str):
valor = str(valor)
buf = w.get_buffer()
buf.set_text(valor)
def GET(self, id=None):
#if id is None, email every active user with his balance
if id is not None:
users = [get_object_or_404(User, id=id)]
else:
users = User.filter(active=True)
default_tpl = settings.MAIL_DEFAULT_TEMPLATE
try:
f = open(settings.MAIL_FILE_TEMPLATE, 'rb')
tpl = pickle.load(f)
f.close()
except (IOError, pickle.PickleError):
tpl = default_tpl
userside = web.input(
u=0).u != 0 # used to check if the mail is coming from a QR scan
for u in users:
utpl = default_tpl
if u.balance < 0 and not userside:
utpl = tpl
body = utpl.format(
apayer=float2str(-u.balance if u.balance < 0 else 0),
solde=float2str(u.balance),
prenom=u.firstname,
nom=u.lastname)
web.sendmail(settings.MAIL_ADDRESS, u.email,
'Your INGI cafetaria balance', body)
if userside:
return render_no_layout.consume('BALANCE', u)
raise web.seeother('/')
def GET(self, id=None):
#if id is None, email every active user with his balance
if id is not None:
users = [get_object_or_404(User, id=id)]
else:
users = User.filter(active=True)
default_tpl = settings.MAIL_DEFAULT_TEMPLATE
try:
f = open(settings.MAIL_FILE_TEMPLATE, 'rb')
tpl = pickle.load(f)
f.close()
except (IOError, pickle.PickleError):
tpl = default_tpl
userside = web.input(u=0).u != 0 # used to check if the mail is coming from a QR scan
for u in users:
utpl = default_tpl
if u.balance < 0 and not userside:
utpl = tpl
body = utpl.format(apayer = float2str(-u.balance if u.balance <0 else 0),
solde = float2str(u.balance),
prenom = u.firstname,
nom = u.lastname)
web.sendmail(settings.MAIL_ADDRESS, u.email, 'Your INGI cafetaria balance', body)
if userside:
return render_no_layout.consume('BALANCE', u)
raise web.seeother('/')
def imprimir(self, boton):
"""
Imprime la tarifa en pantalla.
"""
import informes
datos = []
model = self.wids['tabla_productos'].get_model()
for iter in model:
datos.append((iter[0],
iter[1],
"%s €" % (utils.float2str(iter[2], 3)),
"%s €" % (utils.float2str(iter[3], 3))
))
def cmp_func(x, y):
"""
Para ordenar por nombre de producto.
"""
if x[1] < y[1]:
return -1
if x[1] > y[1]:
return 1
return 0
datos.sort(cmp_func)
if datos != []:
nombre_tarifa = self.wids['cb_nombre_tarifa'].child.get_text()
informes.abrir_pdf(geninformes.imprimir_tarifa(datos, nombre_tarifa, utils.str_fecha(mx.DateTime.localtime())))
def mostrar_totales(self, devengado, soportado, base_devengado):
"""
Muestra los totales, la diferencia de ambos y colorea los Entries.
"""
# Base imponible de las facturas de venta. (Si trabajara con más IVAs debería haber una línea por cada tipo de IVA)
self.wids['e_base_devengado'].set_text("%s €" % (utils.float2str(base_devengado, 2)))
# Devengado
self.wids['e_devengado'].set_text("%s €" % utils.float2str(devengado, 2))
self.wids['e_devengado'].set_tooltip_text(str(devengado))
self.wids['e_devengado'].modify_text(gtk.STATE_NORMAL,
self.wids['e_devengado'].get_colormap().alloc_color("red"))
# Soportado
self.wids['e_soportado'].set_text(
"%s €" % utils.float2str(soportado, 2))
self.wids['e_soportado'].set_tooltip_text(str(soportado))
self.wids['e_soportado'].modify_text(gtk.STATE_NORMAL,
self.wids['e_soportado'].get_colormap().alloc_color("blue"))
# Diferencia
diferencia = devengado - soportado
self.wids['e_diferencia'].set_text(
"%s €" % utils.float2str(diferencia, 2))
self.wids['e_diferencia'].set_tooltip_text(str(diferencia))
if diferencia > 0:
self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL,
self.wids['e_diferencia'].get_colormap().alloc_color("red"))
else:
self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL,
self.wids['e_diferencia'].get_colormap().alloc_color("blue"))
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
model = self.wids['tv_datos'].get_model()
for i in model:
datos.append((i[0],
i[1],
i[2]))
if self.balas != 0:
datos.append(("", "", ""))
datos.append(("", "-" * 30 , "-" * 30))
datos.append(("", "", ""))
datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.kilos)), self.balas))
if self.rollos != 0:
datos.append(("", "", ""))
datos.append(("", "-" * 30 , "-" * 30))
datos.append(("", "", ""))
datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.metros)), self.rollos))
if (self.inicio) == None:
fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
if datos != []:
informes.abrir_pdf(geninformes.producido_produccion(datos, fechaInforme, self.grafico))
def rellenar_tabla(self, items):
"""
Rellena el model con los items de la consulta
"""
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
vpro.set_valor(0.0, "Contando existencias...")
act = 0.0
tot = len(items) * len(self.tvs)
try:
fecha = utils.parse_fecha(self.wids['e_fecha'].get_text())
except (TypeError, ValueError, AttributeError):
fecha = mx.DateTime.today()
self.wids['e_fecha'].set_text(utils.str_fecha(fecha))
# XXX: Optimización (cosas de cómo están hechas las funciones de get_*
# por dentro en pclases):
if fecha >= mx.DateTime.today():
fecha = None
for tv, kg, bultos, a in self.tvs:
model = tv.get_model()
model.clear()
totalkgs = 0.0
totalbultos = 0
for pv in items:
vpro.set_valor(act/tot,
"Contando existencias...\t[%s]" % pv.get_puid())
stock = pv.get_stock(hasta = fecha, almacen = a)
totalkgs += stock
existencias = pv.get_existencias(hasta=fecha, almacen = a)
totalbultos += existencias
stock_A = pv.get_stock_A(hasta = fecha, almacen = a)
existencias_A = pv.get_existencias_A(hasta=fecha, almacen = a)
stock_B = pv.get_stock_B(hasta = fecha, almacen = a)
existencias_B = pv.get_existencias_B(hasta=fecha, almacen = a)
stock_C = pv.get_stock_C(hasta = fecha, almacen = a)
existencias_C = pv.get_existencias_C(hasta=fecha, almacen = a)
model.append((pv.codigo,
pv.descripcion,
utils.float2str(stock),
utils.float2str(existencias, autodec = True),
utils.float2str(stock_A!=None and stock_A or 0),
utils.float2str(existencias_A != None and
existencias_A or 0,
autodec = True),
utils.float2str(stock_B!=None and stock_B or 0),
utils.float2str(existencias_B != None and
existencias_B or 0,
autodec = True),
utils.float2str(stock_C!=None and stock_C or 0),
utils.float2str(existencias_C != None and
existencias_C or 0,
autodec = True),
pv.get_puid()))
act += 1
kg.set_text(utils.float2str(totalkgs))
bultos.set_text(utils.float2str(totalbultos, autodec = True))
vpro.ocultar()
def buscar(self, boton):
"""
Busca todos los productos e introduce en los TreeViews las existencias
de los mismos. En total y por almacén.
El total no lo calcula, se obtiene del total global (que debería
coincidir con el sumatorio de...).
"""
fechaini = self.wids['e_fechaini'].get_text().strip()
if fechaini:
try:
fechaini = utils.parse_fecha(fechaini)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR EN FECHA INICIAL",
texto = "El texto «%s» no es una fecha correcta." % fechaini,
padre = self.wids['ventana'])
fechaini = None
fechafin = self.wids['e_fechafin'].get_text().strip()
if fechafin:
try:
fechafin = utils.parse_fecha(fechafin)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR EN FECHA FINAL",
texto = "El texto «%s» no es una fecha correcta." % fechafin,
padre = self.wids['ventana'])
fechafin = None
if fechafin:
FV = pclases.FacturaVenta
if fechaini:
facturas = FV.select(pclases.AND(
FV.q.fecha >= fechaini,
FV.q.fecha <= fechafin))
else:
facturas = FV.select(FV.q.fecha <= fechafin)
from ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
txtvpro = "Buscando facturas..."
total = 0.0
i = 0.0
vpro.set_valor(i, txtvpro)
model = self.wids['tv_datos'].get_model()
model.clear()
for f in facturas:
i += 1
vpro.set_valor(i/facturas.count(),
txtvpro)
model.append((f.numfactura,
utils.str_fecha(f.fecha),
f.cliente and f.cliente.cif or "¡Sin cliente!",
f.cliente and f.cliente.nombre or "¡Sin cliente!",
utils.float2str(f.calcular_base_imponible()),
utils.float2str(f.calcular_total_iva()),
utils.float2str(f.calcular_importe_total()),
f.get_puid()))
total += f.calcular_importe_total()
vpro.ocultar()
self.wids['e_total'].set_text(utils.float2str(total))
def rellenar_tabla(self, items):
"""
Rellena el model con los items de la consulta
"""
model = self.wids['tv_datos'].get_model()
model.clear()
total = 0
vencido = 0
hoy = datetime.date.today()
por_fecha = {}
for i in items:
if not i[2]: # i[2] = False cuando es vencimiento normal de la BD
total += i[1].importe
importe = i[1].importe
anno = i[1].fecha.year
mes = i[1].fecha.month
if i[1].fecha < hoy:
vencido += i[1].importe
fra = i[1].facturaVenta or i[1].prefactura
model.append((fra.numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(importe),
i[1].observaciones,
fra.cliente.nombre,
"V:" + `i[1].id`))
else: # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
importe = i[1]['importe']
anno = i[1]['fecha'].year
mes = i[1]['fecha'].month
total += i[1]['importe']
if i[1]['fecha'] < hoy:
vencido += i[1]['importe']
model.append(("LOGIC", # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
utils.str_fecha(i[1]['fecha']),
utils.float2str(i[1]['importe']),
i[1]['comentario'],
i[1]['cuenta'],
"L:" + i[1]['id']))
if anno not in por_fecha:
por_fecha[anno] = {}
if mes not in por_fecha[anno]:
por_fecha[anno][mes] = 0.0
por_fecha[anno][mes] += importe
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
self.wids['e_vencido'].set_text("%s €" % utils.float2str(vencido))
# Relleno el model de totales.
annos = por_fecha.keys()
annos.sort()
model = self.wids['tv_totales'].get_model()
model.clear()
for anno in annos:
total_anno = sum([por_fecha[anno][mes] for mes in por_fecha[anno]])
anno_padre = model.append(None, (`anno`,
utils.float2str(total_anno),
""))
meses = por_fecha[anno].keys()
def rellenar_tabla_XXX(self):
model = self.wids['XXXtv_treeview'].get_model()
model.clear()
total = 0.0
for p in self.objeto.XXXunoamuchos:
total += p.XXXcampoacumulable
model.append((p.XXXcampo1,
utils.float2str(p.XXXcampoacumulable),
p.id))
self.wids['XXXe_total_si_lo_hay'].set_text(utils.float2str(total))
def rellenar_totales(self, totf, tots, totb):
"""
Introduce los totales en los "entries".
"""
self.wids['e_total'].set_text(utils.float2str(totf))
self.wids['e_siniva'].set_text(utils.float2str(tots))
try:
beneficio = totb * 100.0 / tots
except ZeroDivisionError:
beneficio = 0
self.wids['e_beneficio'].set_text("%s (%s %%)" % (utils.float2str(totb), utils.float2str(beneficio, 4, autodec = True)))
def rellenar_facturas(self):
"""
Rellena el model con las facturas no bloqueadas.
"""
model = self.wids['tv_facturas'].get_model()
model.clear()
self.wids['tv_facturas'].freeze_child_notify()
self.wids['tv_facturas'].set_model(None)
vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
i = 0.0
facturas = pclases.FacturaVenta.select(pclases.FacturaVenta.q.bloqueada == False, orderBy = "id")
prefacturas = pclases.Prefactura.select(pclases.Prefactura.q.bloqueada == False, orderBy = "id")
tot = facturas.count() + prefacturas.count()
for factura in facturas:
vpro.set_valor(i/tot, 'Recuperando factura %s...' % (factura.numfactura))
i += 1
if factura.vencimientosCobro == []:
motivo = "Sin vencimientos."
elif factura.cliente.cif == None or factura.cliente.cif.strip() == "":
motivo = "Cliente sin CIF."
else:
motivo = "Factura no bloqueada."
model.append((factura.numfactura,
utils.str_fecha(factura.fecha),
factura.cliente and factura.cliente.nombre or "-",
"%s €" % (utils.float2str(factura.calcular_total())),
", ".join([a.numalbaran for a in factura.get_albaranes()]),
factura.bloqueada,
motivo,
factura.id))
for factura in prefacturas:
vpro.set_valor(i/tot, 'Recuperando factura %s...' % (factura.numfactura))
i += 1
if factura.vencimientosCobro == []:
motivo = "Sin vencimientos."
elif factura.cliente.cif == None or factura.cliente.cif.strip() == "":
motivo = "Cliente sin CIF."
else:
motivo = "Factura no bloqueada."
model.append((factura.numfactura,
utils.str_fecha(factura.fecha),
factura.cliente and factura.cliente.nombre or "-",
"%s €" % (utils.float2str(factura.calcular_total())),
", ".join([a.numalbaran for a in factura.get_albaranes()]),
factura.bloqueada,
motivo,
factura.id))
self.wids['tv_facturas'].set_model(model)
self.wids['tv_facturas'].thaw_child_notify()
vpro.ocultar()
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
for i in self.resultado:
if not i[2]: # i[2] = False cuando es vencimiento normal de la BD
if isinstance(i[1], pclases.FacturaDeAbono):
importe = i[1].calcular_importe_total()
datos.append((i[1].numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(importe),
"",
i[1].cliente and i[1].cliente.nombre or ""))
else:
fra = i[1].facturaVenta or i[1].prefactura
datos.append((fra.numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(i[1].importe),
i[1].observaciones,
fra.cliente.nombre))
else: # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
datos.append(("LOGIC", # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
utils.str_fecha(i[1]['fecha']),
utils.float2str(i[1]['importe']),
i[1]['comentario'],
i[1]['cuenta']))
if (self.inicio) == None:
fechaInforme = 'Hasta %s' % (utils.str_fecha(self.fin))
else:
fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
if datos != []:
model = self.wids['tv_totales'].get_model()
datos.append(("---", )*5)
datos.append(("TOTALES POR MES Y AÑO", ">->", ">->", ">->", ">->"))
for fila in model:
datos.append((fila[0], "", fila[1], "", ""))
iter_filames = model.iter_children(fila.iter)
while iter_filames:
filames = model[iter_filames]
datos.append(("", filames[0], filames[1], "", ""))
iter_filames = model.iter_next(iter_filames)
datos.append(("---", )*5)
datos.append(("",
"Total",
self.wids['e_total'].get_text(),
"Vencido a la fecha",
self.wids['e_vencido'].get_text()))
informes.abrir_pdf(geninformes.vencimientosCobro(datos,fechaInforme))
def rellenar_tabla_transferencias(self):
model = self.wids['tv_transferencias'].get_model()
model.clear()
total = 0.0
for p in self.objeto.pagos:
total += p.importe
model.append((p.proveedor and p.proveedor.nombre,
p.cuentaOrigen and p.cuentaOrigen.nombre,
utils.float2str(p.importe),
utils.str_fecha(p.fecha),
p.observaciones,
p.concepto,
p.id))
self.wids['e_total'].set_text(utils.float2str(total))
def rellenar_tabla(self,lista = []):
"""
Rellena el model con los resultados de la búsqueda almacenados
en una lista de lotes.
"""
model = self.wids['tv_resultado'].get_model()
model.clear()
for elem in lista:
model.append((elem.numlote,
elem.codigo,
"%s (%s)" % (str(elem.tenacidad), utils.float2str(elem.calcular_tenacidad_media())),
"%s (%s)" % (str(elem.elongacion), utils.float2str(elem.calcular_elongacion_media())),
"%s (%s)" % (elem.rizo, utils.float2str(elem.calcular_rizo_medio())),
"%s (%s)" % (elem.encogimiento, utils.float2str(elem.calcular_encogimiento_medio())),
elem.id))
def rellenar_tabla(self, fras):
"""
Introduce las facturas recibidas en el TreeView y
calcula el total de IVA para las facturas de compra
y de venta por separado.
"""
tv = self.wids['tv_datos']
model = tv.get_model()
tv.freeze_child_notify()
tv.set_model(None)
model.clear()
devengado = 0.0
soportado = 0.0
base_devengado = 0.0
for fra in fras:
if isinstance(fra, pclases.FacturaVenta):
iva = fra.calcular_total_iva()
base_devengado += fra.calcular_base_imponible()
devengado += iva
fila = [utils.str_fecha(fra.fecha),
"%s (%s)" % (fra.numfactura,
fra.cliente and fra.cliente.nombre or ""),
"%s €" % utils.float2str(fra.calcular_importe_total()),
"%s €" % utils.float2str(iva),
"",
"",
"",
"FV:%d" % fra.id
]
elif isinstance(fra, pclases.FacturaCompra):
iva = fra.calcular_importe_iva()
soportado += iva
fila = [utils.str_fecha(fra.fecha),
"",
"",
"",
"%s (%s)" % (fra.numfactura, fra.proveedor and fra.proveedor.nombre or ""),
"%s €" % utils.float2str(fra.calcular_importe_total()),
"%s €" % utils.float2str(iva),
"FC:%d" % fra.id
]
else:
self.logger.error("iva::rellenar_tabla -> Factura %s no es FacturaVenta ni FacturaCompra." % fra)
continue
model.append(fila)
tv.set_model(model)
tv.thaw_child_notify()
self.mostrar_totales(devengado, soportado, base_devengado)
def es_diferente(self):
"""
Devuelve True si algún valor en ventana difiere de
los del objeto.
"""
if self.objeto == None:
igual = True
else:
self.wids['sp_validez'].update() # Por si ha tecleado en vez
# de usar los botones de incremento y decremento.
igual = self.objeto != None
for colname in self.dic_campos:
col = self.clase._SO_columnDict[colname]
try:
valor_ventana = self.leer_valor(col, self.dic_campos[colname])
except (ValueError, mx.DateTime.RangeError, TypeError):
if colname == "numpresupuesto":
valor_ventana = None
else:
igual = False
valor_objeto = getattr(self.objeto, col.name)
if colname == "comercialID" and valor_ventana == -1:
valor_ventana = None
if isinstance(col, pclases.SODateCol):
valor_objeto = utils.abs_mxfecha(valor_objeto)
igual = igual and (valor_ventana == valor_objeto)
if not igual:
break
igual = (igual
and "%s %%" % utils.float2str(self.objeto.descuento*100,
autodec = True)
== self.wids['e_descuento'].get_text())
return not igual
def rellenar_tabla(self, items):
"""
Rellena el model con los items de la consulta (objetos LDC).
"""
model = self.wids['tv_datos'].get_model()
model.clear()
self.wids['tv_datos'].freeze_child_notify()
self.wids['tv_datos'].set_model(None)
vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
i = 0.0
try:
tot = len(items)
except TypeError: # len() of unsized object. Es un SelectResults
tot = items.count()
total = 0
# Albarán tienen todas las LDC porque las LDC se han obtenido a partir de albaranes.
for ldc in items:
i+=1
vpro.set_valor(i/tot, 'Mostrando %d...' % (ldc.id))
subtotal = ldc.cantidad * ldc.precio
model.append((ldc.nombre_proveedor,
ldc.albaranEntrada.numalbaran,
utils.str_fecha(ldc.albaranEntrada.fecha),
ldc.descripcion_productoCompra,
ldc.cantidad,
ldc.precio,
subtotal,
ldc.id))
total += subtotal
self.wids['tv_datos'].set_model(model)
self.wids['tv_datos'].thaw_child_notify()
vpro.ocultar()
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
self.wids['e_entradas'].set_text("%d" % tot)
def imprimir(self, boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
for i in self.resultado:
datos.append((i.cliente.nombre,
utils.str_fecha(i.fecha),
i.numpedido,
"%s €" % (utils.float2str(i.calcular_importe_total())),
i.bloqueado and "Sí" or "No",
i.cerrado and "Sí" or "No"))
datos.append(("", "", "", "---", "", ""))
datos.append(("%s pedidos listados." % (self.wids['e_total'].get_text()),
"",
"Importe total:",
self.wids['e_importe_total'].get_text(),
"",
""))
if (self.inicio) == None:
fechaInforme = 'Hasta ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio, "%Y/%m/%d")) + ' - ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
if datos != []:
informes.abrir_pdf(geninformes.pedidosCliente(datos, self.cliente and self.cliente.nombre or "?", fechaInforme))
def cambiar_existencias(self, cell, path, texto):
# Chequeo permiso de escritura para camibar precios, existencias y demás:
try:
ventana = pclases.Ventana.select(pclases.Ventana.q.fichero == "productos.py")[0]
if self.usuario and (not self.usuario.get_permiso(ventana).escritura or self.usuario.nivel >= 2):
utils.dialogo_info(titulo = "USUARIO SIN PRIVILEGIOS",
texto = "Necesita permiso de escritura para modificar las existencias.",
padre = self.wids['ventana'])
return
except IndexError:
if self.usuario and self.usuario.nivel >= 2:
utils.dialogo_info(titulo = "USUARIO SIN PRIVILEGIOS",
texto = "No tiene permisos suficientes para modificar las existencias.",
padre = self.wids['ventana'])
return
model = self.wids['tv_datos'].get_model()
id = model[path][-1]
try:
existencias = utils._float(texto)
except ValueError:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es correcto." % (texto),
padre = self.wids['ventana'])
else:
if "PC" in model[path][0]:
producto = pclases.ProductoCompra.get(id)
producto.sync()
producto.existencias = existencias
producto.syncUpdate()
model[path][3] = utils.float2str(producto.existencias)
def generator(self, alpha, link):
alpha_string = float2str(alpha)
link_file_name = link + ".link"
with open(self.generator_tempelete,"r") as fin,\
open(link_file_name,"w") as fout:
for line in fin:
fout.write(line.replace(self.sentinel,alpha_string))
def generator(self, alpha, link):
alpha_string = float2str(alpha)
link_file_name = link + ".link"
with open(self.generator_tempelete,"r") as fin,\
open(link_file_name,"w") as fout:
for line in fin:
fout.write(line.replace(self.sentinel, alpha_string))
def set_valor(self, w, nombrecampo, tipocampo):
# valor = self.objeto._SO_getValue(nombrecampo)
get_valor = getattr(self.objeto, '_SO_get_%s' % (nombrecampo))
valor = get_valor()
if isinstance(tipocampo, sqlobject.SOStringCol): # Cadena: el widget es un entry
if valor != None:
w.set_text(valor)
else:
w.set_text("")
elif isinstance(tipocampo, sqlobject.SOIntCol): # Entero: el widget es un entry
try:
w.set_text("%d" % valor)
except TypeError:
w.set_text("0")
elif isinstance(tipocampo, sqlobject.SOBoolCol): # Boolean: el widget es un checkbox
w.set_active(valor)
elif isinstance(tipocampo, sqlobject.SOForeignKey): # Entero-clave ajena: el widget es un comboboxentry
utils.combo_set_from_db(w, valor)
elif isinstance(tipocampo, sqlobject.SOCol): # Clase base, casi seguro Float: el widget es un entry
if valor != None:
try:
w.set_text(utils.float2str(valor))
except ValueError:
w.set_text('0')
else:
txt = "categorias_laborales.py: No se pudo establecer el valor %s para %s." % (valor, w)
print txt
self.logger.error(txt)
def refinar_resultados_busqueda(self, resultados):
"""
Muestra en una ventana de resultados todos los
registros de "resultados".
Devuelve el id (primera columna de la ventana
de resultados) de la fila seleccionada o None
si se canceló.
"""
filas_res = []
for r in resultados:
if r.es_transferencia():
filas_res.append((r.id,
utils.str_fecha(r.fecha),
r.proveedor and r.proveedor.nombre or "-",
r.cuentaOrigen and r.cuentaOrigen.nombre or "-",
r.cuentaDestino and r.cuentaDestino.nombre or "-",
utils.float2str(r.importe)))
idcuenta = utils.dialogo_resultado(filas_res,
titulo = 'SELECCIONE TRANSFERENCIA',
cabeceras = ('ID', 'Fecha', 'Proveedor', 'Cuenta', 'Destino', "Importe"),
padre = self.wids['ventana'])
if idcuenta < 0:
return None
else:
return idcuenta
def _to_link(self):
linkfile = self.link + '.link'
with open(linkfile, 'r') as f:
content = f.readlines()
with open(linkfile, 'w') as f:
f.write(
self.link_header_format.format(float2str(self.alpha), self.mni,
self.ekin, self.mass, self.zone,
self.mpist))
for i, line in enumerate(content):
if not line.startswith('c #'):
break
if line.startswith(self.header_end):
del content[0:i + 1]
break
for line in content:
f.write(line)
def main(args):
print('=' * 10, 'Starting', '=' * 10, '\n')
print(device)
# Set the seed for reproducing the results
random.seed(args.manual_seed)
np.random.seed(args.manual_seed)
torch.manual_seed(args.manual_seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(args.manual_seed)
cudnn.benchmark = True
# Set up results folder
if not os.path.exists(os.path.join(ROOT, RESULT, 'saved_val_images')):
os.makedirs(os.path.join(ROOT, RESULT, 'saved_val_images'))
if not os.path.exists(os.path.join(ROOT, RESULT, 'saved_train_images')):
os.makedirs(os.path.join(ROOT, RESULT, 'saved_train_images'))
# Setup Dataloader
data_loader = get_loader(args.dataset)
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
target_transform = extended_transforms.MaskToTensor()
traindata = data_loader('train',
n_classes=args.n_classes,
transform=input_transform,
target_transform=target_transform,
do_transform=True,
portion=args.data_portion)
trainloader = data.DataLoader(traindata,
batch_size=args.batch_size,
num_workers=1,
shuffle=True)
valdata = data_loader('val',
n_classes=args.n_classes,
transform=input_transform,
target_transform=target_transform)
valloader = data.DataLoader(valdata,
batch_size=args.batch_size,
num_workers=1,
shuffle=False)
n_classes = traindata.n_classes
n_trainsamples = len(traindata)
n_iters_per_epoch = np.ceil(n_trainsamples /
float(args.batch_size * args.iter_size))
print('#Training data = {}'.format(n_trainsamples))
# Setup Model
model = get_model(name=args.arch,
n_classes=n_classes,
ignore_index=traindata.ignore_index,
output_stride=args.output_stride,
pretrained=args.pretrained,
momentum_bn=args.momentum_bn,
dprob=args.dprob).to(device)
epochs_done = 0
X = []
Y = []
Y_test = []
avg_pixel_acc = 0
mean_class_acc = 0
mIoU = 0
avg_pixel_acc_test = 0
mean_class_acc_test = 0
mIoU_test = 0
best_mIoU = 0
best_epoch = 0
if args.model_path:
model_name = args.model_path.split('.')
checkpoint_name = model_name[0] + '_optimizer.pkl'
checkpoint = torch.load(os.path.join(ROOT, RESULT, checkpoint_name))
optm = checkpoint['optimizer']
model.load_state_dict(checkpoint['state_dict'])
split_str = model_name[0].split('_')
epochs_done = int(split_str[-1])
saved_loss = pickle.load(
open(os.path.join(ROOT, RESULT, "saved_loss.p"), "rb"))
saved_accuracy = pickle.load(
open(os.path.join(ROOT, RESULT, "saved_accuracy.p"), "rb"))
X = saved_loss["X"][:epochs_done]
Y = saved_loss["Y"][:epochs_done]
Y_test = saved_loss["Y_test"][:epochs_done]
avg_pixel_acc = saved_accuracy["P"][:epochs_done, :]
mean_class_acc = saved_accuracy["M"][:epochs_done, :]
mIoU = saved_accuracy["I"][:epochs_done, :]
avg_pixel_acc_test = saved_accuracy["P_test"][:epochs_done, :]
mean_class_acc_test = saved_accuracy["M_test"][:epochs_done, :]
mIoU_test = saved_accuracy["I_test"][:epochs_done, :]
if args.best_model_path:
best_model_name = args.best_model_path.split('_')
best_mIoU = float(best_model_name[-2])
best_epoch = int(best_model_name[-3])
# Learning rates: For new layers (such as final layer), we set lr to be 10x the learning rate of layers already trained
bias_10x_params = filter(
lambda x: ('bias' in x[0]) and ('final' in x[0]) and ('conv' in x[0]),
model.named_parameters())
bias_10x_params = list(map(lambda x: x[1], bias_10x_params))
bias_params = filter(lambda x: ('bias' in x[0]) and ('final' not in x[0]),
model.named_parameters())
bias_params = list(map(lambda x: x[1], bias_params))
nonbias_10x_params = filter(
lambda x:
(('bias' not in x[0]) or ('bn' in x[0])) and ('final' in x[0]),
model.named_parameters())
nonbias_10x_params = list(map(lambda x: x[1], nonbias_10x_params))
nonbias_params = filter(
lambda x: ('bias' not in x[0]) and ('final' not in x[0]),
model.named_parameters())
nonbias_params = list(map(lambda x: x[1], nonbias_params))
optimizer = torch.optim.SGD([
{
'params': bias_params,
'lr': args.lr
},
{
'params': bias_10x_params,
'lr': 20 * args.lr if args.pretrained else args.lr
},
{
'params': nonbias_10x_params,
'lr': 10 * args.lr if args.pretrained else args.lr
},
{
'params': nonbias_params,
'lr': args.lr
},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=(args.optim == 'Nesterov'))
num_param_groups = 4
# optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
# Setting up scheduler
if args.model_path and args.restore:
# Here we restore all states of optimizer
optimizer.load_state_dict(optm)
total_iters = n_iters_per_epoch * args.epochs
lambda1 = lambda step: 0.5 + 0.5 * math.cos(np.pi * step / total_iters)
scheduler = lr_scheduler.LambdaLR(
optimizer,
lr_lambda=[lambda1] * num_param_groups,
last_epoch=epochs_done * n_iters_per_epoch)
# scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1, last_epoch=epochs_done)
else:
# scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)
# Here we simply restart the training
# if args.T0:
# total_iters = args.T0 * n_iters_per_epoch
# else:
total_iters = ((args.epochs - epochs_done) * n_iters_per_epoch)
lambda1 = lambda step: 0.5 + 0.5 * math.cos(np.pi * step / total_iters)
scheduler = lr_scheduler.LambdaLR(optimizer,
lr_lambda=[lambda1] *
num_param_groups)
global l_avg, totalclasswise_pixel_acc, totalclasswise_gtpixels, totalclasswise_predpixels
global l_avg_test, totalclasswise_pixel_acc_test, totalclasswise_gtpixels_test, totalclasswise_predpixels_test
global steps, steps_test
scheduler.step()
criterion = nn.CrossEntropyLoss(size_average=False,
ignore_index=traindata.ignore_index)
for epoch in range(epochs_done, args.epochs):
print('=' * 10, 'Epoch %d' % (epoch + 1), '=' * 10)
l_avg = 0
totalclasswise_pixel_acc = 0
totalclasswise_gtpixels = 0
totalclasswise_predpixels = 0
l_avg_test = 0
totalclasswise_pixel_acc_test = 0
totalclasswise_gtpixels_test = 0
totalclasswise_predpixels_test = 0
steps = 0
steps_test = 0
# scheduler.step()
train(model, optimizer, criterion, trainloader, epoch, scheduler,
traindata)
val(model, criterion, valloader, epoch, valdata)
# save the model every 5 epochs
if (epoch + 1) % 5 == 0 or epoch == args.epochs - 1:
if (epoch + 1) > 5:
os.remove(
os.path.join(
ROOT, RESULT,
"{}_{}_{}.pkl".format(args.arch, args.dataset,
epoch - 4)))
os.remove(
os.path.join(
ROOT, RESULT, "{}_{}_{}_optimizer.pkl".format(
args.arch, args.dataset, epoch - 4)))
torch.save(
model,
os.path.join(
ROOT, RESULT,
"{}_{}_{}.pkl".format(args.arch, args.dataset, epoch + 1)))
torch.save(
{
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
os.path.join(
ROOT, RESULT,
"{}_{}_{}_optimizer.pkl".format(args.arch, args.dataset,
epoch + 1)))
# remove old loss & accuracy files
if os.path.isfile(os.path.join(ROOT, RESULT, "saved_loss.p")):
os.remove(os.path.join(ROOT, RESULT, "saved_loss.p"))
if os.path.isfile(os.path.join(ROOT, RESULT, "saved_accuracy.p")):
os.remove(os.path.join(ROOT, RESULT, "saved_accuracy.p"))
# save train and validation loss
X.append(epoch + 1)
Y.append(l_avg / steps)
Y_test.append(l_avg_test / steps_test)
saved_loss = {"X": X, "Y": Y, "Y_test": Y_test}
pickle.dump(saved_loss,
open(os.path.join(ROOT, RESULT, "saved_loss.p"), "wb"))
# pixel accuracy
totalclasswise_pixel_acc = totalclasswise_pixel_acc.reshape(
(-1, n_classes)).astype(np.float32)
totalclasswise_gtpixels = totalclasswise_gtpixels.reshape(
(-1, n_classes))
totalclasswise_predpixels = totalclasswise_predpixels.reshape(
(-1, n_classes))
totalclasswise_pixel_acc_test = totalclasswise_pixel_acc_test.reshape(
(-1, n_classes)).astype(np.float32)
totalclasswise_gtpixels_test = totalclasswise_gtpixels_test.reshape(
(-1, n_classes))
totalclasswise_predpixels_test = totalclasswise_predpixels_test.reshape(
(-1, n_classes))
if isinstance(avg_pixel_acc, np.ndarray):
avg_pixel_acc = np.vstack(
(avg_pixel_acc, np.sum(totalclasswise_pixel_acc, axis=1) /
np.sum(totalclasswise_gtpixels, axis=1)))
mean_class_acc = np.vstack(
(mean_class_acc,
np.mean(totalclasswise_pixel_acc / totalclasswise_gtpixels,
axis=1)))
mIoU = np.vstack(
(mIoU,
np.mean(totalclasswise_pixel_acc /
(totalclasswise_gtpixels + totalclasswise_predpixels -
totalclasswise_pixel_acc),
axis=1)))
avg_pixel_acc_test = np.vstack(
(avg_pixel_acc_test,
np.sum(totalclasswise_pixel_acc_test, axis=1) /
np.sum(totalclasswise_gtpixels_test, axis=1)))
mean_class_acc_test = np.vstack(
(mean_class_acc_test,
np.mean(totalclasswise_pixel_acc_test /
totalclasswise_gtpixels_test,
axis=1)))
mIoU_test = np.vstack((mIoU_test,
np.mean(totalclasswise_pixel_acc_test /
(totalclasswise_gtpixels_test +
totalclasswise_predpixels_test -
totalclasswise_pixel_acc_test),
axis=1)))
else:
avg_pixel_acc = np.sum(totalclasswise_pixel_acc, axis=1) / np.sum(
totalclasswise_gtpixels, axis=1)
mean_class_acc = np.mean(totalclasswise_pixel_acc /
totalclasswise_gtpixels,
axis=1)
mIoU = np.mean(
totalclasswise_pixel_acc /
(totalclasswise_gtpixels + totalclasswise_predpixels -
totalclasswise_pixel_acc),
axis=1)
avg_pixel_acc_test = np.sum(
totalclasswise_pixel_acc_test, axis=1) / np.sum(
totalclasswise_gtpixels_test, axis=1)
mean_class_acc_test = np.mean(totalclasswise_pixel_acc_test /
totalclasswise_gtpixels_test,
axis=1)
mIoU_test = np.mean(
totalclasswise_pixel_acc_test /
(totalclasswise_gtpixels_test + totalclasswise_predpixels_test
- totalclasswise_pixel_acc_test),
axis=1)
saved_accuracy = {
"X": X,
"P": avg_pixel_acc,
"M": mean_class_acc,
"I": mIoU,
"P_test": avg_pixel_acc_test,
"M_test": mean_class_acc_test,
"I_test": mIoU_test
}
pickle.dump(saved_accuracy,
open(os.path.join(ROOT, RESULT, "saved_accuracy.p"), "wb"))
# save the best model
this_mIoU = np.mean(
totalclasswise_pixel_acc_test /
(totalclasswise_gtpixels_test + totalclasswise_predpixels_test -
totalclasswise_pixel_acc_test),
axis=1)[0]
if this_mIoU > best_mIoU:
if best_mIoU > 0:
os.remove(
os.path.join(
ROOT, RESULT,
"{}_{}_{}_{}_best.pkl".format(args.arch, args.dataset,
best_epoch,
float2str(best_mIoU))))
os.remove(
os.path.join(
ROOT, RESULT, "{}_{}_{}_{}_optimizer_best.pkl".format(
args.arch, args.dataset, best_epoch,
float2str(best_mIoU))))
best_mIoU = this_mIoU
best_epoch = epoch + 1
torch.save(
model,
os.path.join(
ROOT, RESULT,
"{}_{}_{}_{}_best.pkl".format(args.arch, args.dataset,
best_epoch,
float2str(best_mIoU))))
torch.save(
{
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
os.path.join(
ROOT, RESULT, "{}_{}_{}_{}_optimizer_best.pkl".format(
args.arch, args.dataset, best_epoch,
float2str(best_mIoU))))
train_mIoU = np.mean(
totalclasswise_pixel_acc /
(totalclasswise_gtpixels + totalclasswise_predpixels -
totalclasswise_pixel_acc),
axis=1)[0]
print('Train mIoU = {}, Val mIoU = {}'.format(train_mIoU, this_mIoU))
def __init__(self, config_file='explosion.cfg'):
"""
Initialize explosion from config file explosion.cfg.
Actual values need to be in the [explosion] section, the
[DEFAULT] section is a backup. It is also hard-coded, so you
don't need to overwrite it unless it is being changed. The
current defaults are in this class in attribute
'default_config'.
[DEFAULT]
program = ../k
ext = #presn
dump = ../%(base)s%(ext)s
template = explosion.link
logfile = explosion.log
cmdfile = explosion.cmd
logall = True
verbose = True
alpha = 1.0
precision = 2
force = False
run = True
[Here is what you *have* to add:]
link = <link sentinal like "Da">
ekin_or_mni = <value>
base = <run name>
[example]
link = Da
alpha = 1.0
ekin = 1.2e+51
base = s25
[explosion]
link = Pa
alpha = 1.0
ekin = 1.2e+51
base = u25
======
So, with the defaults, the files that you need in the
explosion directory are just
explosion.link
explosion.cmd
explosion.cfg
"""
start_time = datetime.datetime.now()
config = Config(self.default_config)
# config.readfp(io.BytesIO(self.default_config))
config.read(config_file)
section = 'explosion'
run = config.getboolean(section, 'run')
force = config.getboolean(section, 'force')
kepler = config.get(section, 'program')
presn_dump_name = config.get(section, 'dump')
self.base_name = config.get(section, 'base')
self.generator_tempelete = config.get(section, 'template')
generator_start = config.get(section, 'link')
logfile = config.get(section, 'logfile')
self.exp_cmd_file = config.get(section, 'cmdfile')
verbose = config.getboolean(section, 'verbose')
logall = config.getboolean(section, 'logall')
# set up log output
# maybe this this be replaced by
# deriving class from Logged and
# self.setup_logger(silent = not verbose, logfile=logfile, format='UTC')
# and at the end: self.close_logger()
self.logger = logging.getLogger(self.__class__.__name__)
self.logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(logfile, 'w')
if verbose:
level = logging.DEBUG
else:
level = logging.WARNING
fh.setLevel(level)
formatter = utils.UTCFormatter(
'%(asctime)s%(msecs)03d %(nameb)-12s %(levelname)s: %(message)s',
datefmt='%Y%m%d%H%M%S')
fh.setFormatter(formatter)
root_logger = logging.getLogger('')
if logall and len(root_logger.handlers) == 0:
root_logger.addHandler(fh)
root_logger.setLevel(level)
else:
self.logger.addHandler(fh)
# set up state for explosion
state = State(config=config)
link = Link(generator_start)
self.logger.info("{:s}: first alpha = {:g}".format(link, state.alpha))
while state.best is None:
if run:
finished = True
dump_file_name = self.base_name + link + "#final"
if not os.path.exists(dump_file_name):
finished = False
dump_file_name = self.base_name + link + "#envel"
if not os.path.exists(dump_file_name):
finished = False
# check if run parameters are identical
if finished and not force:
if not state.eq_alpha(self.existing_alpha(link)):
self.logger.warning(
'Previous run ' + link +
' had different alpha. RERUNNING.')
finished = False
force = True
os.remove(self.base_name + link + "#final")
os.remove(self.base_name + link + "#envel")
os.remove(self.base_name + link + "z")
os.remove(link + ".link")
if (not finished) or force:
# call_string = "{} {}{} ".format(kepler, self.base_name, link)
# # look if a restart (z) dump is present
# dump_file_name = self.base_name + link + "z"
# if (not os.path.exists(dump_file_name)) or force:
# self.logger.info("RUN")
# self.generator(state.alpha, link)
# self.make_cmd(link);
# call_string += presn_dump_name
# else:
# self.logger.info("CONTINUE")
# call_string += "z"
# call_string += " k </dev/null >/dev/null"
# self.logger.info("CALL: {}".format(call_string))
# os.system(call_string)
args = [kepler, self.base_name + link]
# look if a restart (z) dump is present
dump_file_name = self.base_name + link + "z"
if (not os.path.exists(dump_file_name)) or force:
self.logger.info("RUN")
self.generator(state.alpha, link)
self.make_cmd(link)
args += [presn_dump_name]
else:
self.logger.info("CONTINUE")
args += ['z']
args += ['k']
self.logger.info("CALL: {}".format(' '.join(args)))
with open(os.devnull, 'r') as null_in:
with open(os.devnull, 'w') as null_out:
subprocess.call(args,
shell=False,
stdin=null_in,
stdout=null_out,
stderr=subprocess.STDOUT)
else:
self.logger.info("FINISHED")
state.update(link)
if state.best is None:
link += 1
self.logger.info("{}: new alpha = {} ({},{})".format(
link, state.alpha, state.lo_val(), state.hi_val()))
end_time = datetime.datetime.now()
load_time = end_time - start_time
self.logger.info('finished in ' +
time2human(load_time.total_seconds()))
self.logger.critical(
self.out_format.format(state.flag, state.goal,
state.val(state.best),
abs(state.goal - state.val(state.best)),
float2str(state.best.alpha),
state.best.link, state.best.mass,
state.best.zone))
state.save('explosion.res')
# clean up
for filename in glob.iglob("xxx*"):
os.remove(filename)
