def buscar(self):
     """
     Inicia la consulta para el año indicado en el widget y 
     rellena las tablas con la información obtenida.
     """
     #import time
     #antes = time.time()
     cuantas = int(self.wids['sp_ver'].get_value())
     balas = []
     n = 0
     qbalas = pclases.BalaCable.select(orderBy = "-id")
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     if cuantas == 0:
         tot = qbalas.count() * 1.0
     else:
         tot = cuantas * 1.0
     for b in qbalas:
         b.sync()        
             # Con 999 balas se gana únicamente 1 segundo si omito 
             # la sincronización.
         try:
             balas.insert(0, (b, b.productoVenta))       
                 # Para optimizar los accesos a la BD cacheo los datos aquí.
         except:     # ¿Bala sin producto de venta? Mal asunto
             balas.insert(0, (b, None))
         vpro.set_valor(n/tot, 'Recuperando bala %s' % (b.codigo))
         n += 1
         if n == cuantas:
             break
     vpro.set_valor(1, 'Actualizando ventana...')
     vpro.ocultar()
     #print time.time() - antes
     return balas

 def leer_datos_cargas_descargas(self, silo):
     """
     Devuelve las cargas y descargas (consumo) del silo 
     agrupadas por fecha en un diccionario de la forma:
     {fecha1: {'cargas': [cargaSilo1, cargaSilo2...], 
               'descargas': [consumo1, consumo2...]}, 
      fecha2: {'cargas': [], 
               'descargas': [consumo3, ...]}
     }
     """
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     tot = len(silo.cargasSilo) + len(silo.consumos)
     datos = {}
     for carga in silo.cargasSilo:
         vpro.set_valor(i/tot, 'Analizando cargas...')
         i += 1
         if carga.fechaCarga not in datos:
             datos[carga.fechaCarga] = {'cargas': [carga, ], 'descargas': []}
         else:
             datos[carga.fechaCarga]['cargas'].append(carga)
     for descarga in silo.consumos:
         vpro.set_valor(i/tot, 'Analizando consumos...')
         i += 1
         if descarga.parteDeProduccionID != None:
             fecha = descarga.parteDeProduccion.fecha
         else:
             fecha = None
         if fecha not in datos:
             datos[fecha] = {'cargas': [], 'descargas': [descarga, ]}
         else:
             datos[fecha]['descargas'].append(descarga)
     vpro.ocultar()
     return datos

 def buscar(self, boton):
     """
     Dadas fecha de inicio y de fin, devuelve todos los vencimientos 
     no pagados al completo.
     """
     vpro = VentanaProgreso(padre=self.wids["ventana"])
     vpro.mostrar()
     if not self.inicio:
         pagos = pclases.Pago.select(pclases.Pago.q.fecha <= self.fin, orderBy="fecha")
         pagares = pclases.PagarePago.select(pclases.PagarePago.q.fechaEmision <= self.fin, orderBy="fechaEmision")
     else:
         pagos = pclases.Pago.select(
             pclases.AND(pclases.Pago.q.fecha >= self.inicio, pclases.Pago.q.fecha <= self.fin), orderBy="fecha"
         )
         pagares = pclases.PagarePago.select(
             pclases.AND(
                 pclases.PagarePago.q.fechaEmision >= self.inicio, pclases.PagarePago.q.fechaEmision <= self.fin
             ),
             orderBy="fechaEmision",
         )
     i = 0.0
     tot = pagos.count() + pagares.count()
     proveedor = None
     idproveedor = utils.combo_get_value(self.wids["cmbe_proveedor"])
     if idproveedor != None:
         idproveedor = utils.combo_get_value(self.wids["cmbe_proveedor"])
         proveedor = pclases.Proveedor.get(idproveedor)
     self.resultado = []
     filtrar_por_formapago = self.wids["ch_formapago"].get_active()
     formapago = utils.combo_get_value(self.wids["cb_formapago"])
     for pago in pagos:
         i += 1
         vpro.set_valor(i / tot, "Buscando pagos... (%d/%d)" % (i, tot))
         # Si es un pagaré, se trata en el siguiente bucle.
         if pago.pagarePago:
             continue
         if not proveedor or (proveedor and pago.facturaCompra and pago.facturaCompra.proveedor == proveedor):
             try:
                 txtformapago = self.formaspago[formapago][1]
             except TypeError:  # formapago es None. No se está filtrando
                 # por forma de pago.
                 filtrar_por_formapago = False
                 self.wids["ch_formapago"].set_active(False)
             if not filtrar_por_formapago or (txtformapago in utils.filtrar_tildes(pago.observaciones).lower()):
                 self.resultado.append(pago)
     for pagare in pagares:
         i += 1
         vpro.set_valor(i / tot, "Buscando pagos... (%d/%d)" % (i, tot))
         for pago in pagare.pagos:
             if not proveedor or (proveedor and pago.facturaCompra and pago.facturaCompra.proveedor == proveedor):
                 try:
                     txtformapago = self.formaspago[formapago][1]
                 except TypeError:  # formapago es None. No se está
                     # filtrando por forma de pago.
                     filtrar_por_formapago = False
                     self.wids["ch_formapago"].set_active(False)
                 if not filtrar_por_formapago or (txtformapago in utils.filtrar_tildes(pago.observaciones).lower()):
                     self.resultado.append(pago)
     vpro.ocultar()
     self.rellenar_tabla(self.resultado)

 def rellenar_tabla(self, filtro = None, campo_orden = "id", padre = None,
                    sumatorios = [], limpiar_model = True,
                    objetos = None, *args, **kw):
     """
     A partir de todos los objetos de la clase rellena la tabla, mostrando 
     una ventana de progreso durante el proceso. Si filtro != None, debe 
     ser una función que sirva para DESCARTAR los objetos que no se 
     mostrarán. La función debe evaluarse a True con el objeto que se esté 
     tratando para que se añada al model ListView del TreeView.
     «padre» es la ventana padre para la de progreso.
     Las columnas (sus nombres en realidad) que vengan en «sumatorios» se 
     sumarán y se devolverán en el mismo orden.
     *args y **kw son parámetros adicionales que se pasarán al filtro.
     Hay otra opción para que en lugar de buscar los objetos a mostrar en
     el TreeView, los reciba en el parámetro «objetos». A esta lista
     se le pasaría también el filtro, pero no se le aplica el campo_orden.
     «objetos» debe ser un SelectResult o un SQLlist/SQLtuple.
     """
     # PLAN: Esto se podría optimizar según esta receta:
     # http://www.sqlobject.org/FAQ.html#efficient
     res = []
     for colsum in sumatorios:  # @UnusedVariable
         res.append(0.0)
     if objetos is None:
         objetos = self.clase.select(orderBy=campo_orden)
     model = self.tv.get_model()
     self.tv.freeze_child_notify()
     self.tv.set_model(None)
     if not filtro:
         filtro = self.filtro
     from ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre=padre)
     txtpro = "Mostrando %s (%%d/%%d)..." % self.clase.__name__
     vpro.mostrar()
     if limpiar_model:
         model.clear()
     total = objetos.count()
     if not total:
         total = 1.0
     i = 0.0
     vpro.set_valor(i / total, txtpro % (i, total))
     for objeto in objetos:
         i += 1
         if filtro(objeto, *args, **kw):
             fila = []
             for col in self.__columnas:
                 if col.name in self.cols_a_ignorar:
                     continue
                 if col.name in sumatorios:
                     res[sumatorios.index(col.name)] += getattr(objeto,
                                                                col.name)
                 valor = col2value(objeto, col)
                 fila.append(valor)
             fila.append(objeto.id)
             model.append(fila)
         vpro.set_valor(i / total, txtpro % (i, total))
     self.tv.set_model(model)
     self.tv.thaw_child_notify()
     vpro.ocultar()
     return res

 def rellenar_tabla(self):
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     model = self.wids['tv_datos'].get_model()
     model.clear()
     padres = self.cargar_conceptos(vpro, model)
     mes_actual, mes_final, filas = self.cargar_subconceptos(vpro)
     filas = self.cargar_valores(mes_actual, mes_final, filas, vpro)
     self.volcar_a_tv(filas, vpro, padres, model)
     # Ahora toca pasar el mes que se ha ido al final del año actual
     #self.ciclar_mes(vpro)
     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
     """
     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 rellenar_tabla(self, fib, gtx, cem, otros):
        """
        Rellena el model con los items de la consulta.
        Recibe cuatro diccionarios dependiendo del tipo de producto que habrá
        que introducir en los cuatro treeviews correspondientes.
        Los diccionarios se organizan:
        {'producto1': {'albarán1': {'m2': {'a': 0.0, 'b': 0.0, 'c': 0.0},
                                    'kg': {'a': 0.0, 'b': 0.0, 'c': 0.0},
                                    '#': {'a': 0, 'b': 0, 'c': 0}},
         'producto2': {'albarán1': {'cantidad': 0.0},
         'producto3': {'albarán2': {'kg': {'a': 0.0, 'b': 0.0, 'c': 0.0},
                                    '#': {'a': 0, 'b': 0, 'c': 0}},
        ...}
        """
        tot_fibra = {"kg": {"a": 0.0, "b": 0.0, "c": 0.0}, "#": {"a": 0, "b": 0, "c": 0}}
        tot_gtx = {
            "kg": {"a": 0.0, "b": 0.0, "c": 0.0},
            "#": {"a": 0, "b": 0, "c": 0},
            "m2": {"a": 0.0, "b": 0.0, "c": 0.0},
        }
        tot_cem = {"kg": {"a": 0.0, "b": 0.0, "c": 0.0}, "#": {"a": 0, "b": 0, "c": 0}}
        from ventana_progreso import VentanaProgreso

        vpro = VentanaProgreso(padre=self.wids["ventana"])
        vpro.mostrar()
        i = 0.0
        tot = len(fib) + len(gtx) + len(cem) + len(otros)
        try:
            vpro.set_valor(i / tot, "Mostrando %s..." % (""))
        except ZeroDivisionError:
            pass  # It's Easier to Ask Forgiveness than Permission (EAFP)
        for tv, dic, dic_tot in (
            (self.wids["tv_fibra"], fib, tot_fibra),
            (self.wids["tv_gtx"], gtx, tot_gtx),
            (self.wids["tv_cem"], cem, tot_cem),
            (self.wids["tv_otros"], otros, None),
        ):
            # "Otros" no lleva totales porque son unidades diferentes.
            model = tv.get_model()
            model.clear()
            for producto in dic:
                i += 1
                vpro.set_valor(i / tot, "Mostrando %s..." % (producto))
                fila_producto = build_fila(dic, producto)
                producto_padre = model.append(None, fila_producto)
                if dic_tot:
                    # PLAN: OPTIMIZAR: Estúpido, podrías aprovechar el bucle
                    # de los albaranes de abajo y no repetirlo en el
                    # update_total.
                    update_total(dic_tot, dic[producto])
                for albaran in dic[producto]:
                    fila_albaran = build_fila(dic[producto], albaran)
                    model.append(producto_padre, fila_albaran)
        vpro.ocultar()
        return tot_fibra, tot_gtx, tot_cem

 def rellenar_tabla(self, filtro = None, campo_orden = "id", padre = None,
                    sumatorios = [], limpiar_model = True, *args, **kw):
     """
     A partir de todos los objetos de la clase rellena la tabla, mostrando 
     una ventana de progreso durante el proceso. Si filtro != None, debe 
     ser una función que sirva para DESCARTAR los objetos que no se 
     mostrarán. La función debe evaluarse a True con el objeto que se esté 
     tratando para que se añada al model ListView del TreeView.
     «padre» es la ventana padre para la de progreso.
     Las columnas (sus nombres en realidad) que vengan en «sumatorios» se 
     sumarán y se devolverán en el mismo orden.
     *args y **kw son parámetros adicionales que se pasarán al filtro.
     """
     res = []
     for colsum in sumatorios:
         res.append(0.0)
     objetos = self.clase.select(orderBy = campo_orden)
     model = self.tv.get_model()
     self.tv.freeze_child_notify()
     self.tv.set_model(None)
     if not filtro:
         filtro = self.filtro 
     from ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre = padre)
     txtpro = "Mostrando %s (%%d/%%d)..." % self.clase.__name__
     vpro.mostrar()
     if limpiar_model:
         model.clear()
     total = objetos.count()
     if not total:
         total = 1.0
     i = 0.0
     vpro.set_valor(i / total, txtpro % (i, total)) 
     for objeto in objetos:
         i += 1
         if filtro(objeto, *args, **kw):
             fila = []
             for col in objeto.sqlmeta.columnList:
                 if col.name in self.cols_a_ignorar:
                     continue
                 if col.name in sumatorios:
                     res[sumatorios.index(col.name)] += getattr(objeto, 
                                                                col.name)
                 valor = col2value(objeto, col)
                 fila.append(valor)
             fila.append(objeto.id)
             model.append(fila)
         vpro.set_valor(i / total, txtpro % (i, total)) 
     self.tv.set_model(model)
     self.tv.thaw_child_notify()
     vpro.ocultar()
     return res

 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...).
     """
     tipo = utils.combo_get_value(self.wids['cbe_tipo'])
     from ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     txtvpro = "Recuperando existencias por almacén..."
     i = 0.0
     vpro.set_valor(i, txtvpro)
     almacenes = pclases.Almacen.select(orderBy = "id")
     itotal = pclases.ProductoCompra.select().count() 
     model = self.wids['tv_por_producto'].get_model()
     model.clear()
     for a in almacenes:
         self.wids['tv_%d' % a.id].get_model().clear()
     if tipo in (0, -2) or tipo > 0:
         for pc in pclases.ProductoCompra.select():
             if ((tipo > 0 and pc.tipoDeMaterialID == tipo) 
                 or tipo in (0, -2)):
                 fila = [pc.codigo, pc.descripcion]
                 total = pc.existencias
                 for a in almacenes:
                     existencias_almacen = a.get_existencias(pc)
                     if existencias_almacen == None:
                         existencias_almacen = 0
                     fila.append(utils.float2str(existencias_almacen))
                     if existencias_almacen != 0:
                         self.wids['tv_%d' % a.id].get_model().append(
                             (pc.codigo, pc.descripcion, 
                              utils.float2str(existencias_almacen), 
                              pc.get_puid()))
                 fila.append(utils.float2str(total))
                 fila.append(pc.get_puid())
                 model.append(fila)
             txtvpro = "Recuperando existencias por almacén... (%s)" % (
                 pc.get_puid())
             i += 1
             vpro.set_valor(i/itotal, txtvpro)
     else:
         i += pclases.ProductoCompra.select().count()
     txtvpro = "Recuperando existencias por almacén..."
     vpro.ocultar()

 def leer_datos_cargas_descargas(self, silo):
     """
     Devuelve las cargas y descargas (consumo) del silo 
     agrupadas por fecha en un diccionario de la forma:
     {fecha1: {'cargas': [cargaSilo1, cargaSilo2...], 
               'descargas': [consumo1, consumo2...]}, 
      fecha2: {'cargas': [], 
               'descargas': [consumo3, ...]}
     }
     """
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     tot = len(silo.cargasSilo) + len(silo.consumos)
     datos = {}
     for carga in silo.cargasSilo:
         vpro.set_valor(i/tot, 'Analizando cargas...')
         i += 1
         fechaCarga = utils.convertir_a_fechahora(carga.fechaCarga)
         if not fechaCarga:
             self.logger.error("silos::leer_datos_cargas_descargas -> "
                 "La carga %s tiene una fecha no válida: %s" % (
                     carga.puid, carga.fechaCarga))
             continue
         if fechaCarga not in datos:
             datos[fechaCarga] = {'cargas': [carga, ], 'descargas': []}
         else:
             datos[fechaCarga]['cargas'].append(carga)
     for descarga in silo.consumos:
         vpro.set_valor(i/tot, 'Analizando consumos...')
         i += 1
         if descarga.parteDeProduccionID != None:
             fecha = utils.convertir_a_fechahora(
                         descarga.parteDeProduccion.fecha)
         else:
             #fecha = None
             self.logger.error("silos::leer_datos_cargas_descargas -> "
                 "La descarga %s no tiene fecha porque no tiene parte"
                 "de producción." % (descarga.puid))
             continue
         if fecha not in datos:
             datos[fecha] = {'cargas': [], 'descargas': [descarga, ]}
         else:
             datos[fecha]['descargas'].append(descarga)
     vpro.ocultar()
     return datos

 def graficar_por_producto(self, partes):
     """
     Construye un gráfico de rendimiento por producto. Agrupa los partes
     de un mismo producto y calcula su productividad conjunta. Esos datos
     los envía a un gráfico para ver los productos que mejor le van
     a la línea.
     """
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     tot = len(partes)
     productos = defaultdict(lambda: [])
     for pdp in partes:
         i += 1
         vpro.set_valor(i / tot, "Analizando rendimiento por producto...")
         producto = pdp.productoVenta
         if not producto:
             txterr = "consulta_productividad.py::graficar_por_producto ->"\
                      " %s:%s sin producto de venta." % (pdp.puid,
                                                         pdp.get_info())
             myprint(txterr)
             self.logger.warning(txterr)
         else:
             productos[producto].append(pdp)
     data = OrderedDict()
     tot += len(productos)
     productos_ordenados = productos.keys()
     productos_ordenados.sort(key = lambda prod: prod.descripcion)
     for producto in productos_ordenados:
         i += 1
         vpro.set_valor(i / tot, "Analizando rendimiento por producto...")
         pdps = productos[producto]
         data[producto.descripcion] = calcular_productividad_conjunta(
                                                             tuple(pdps))
     try:
         plot = GtkCairoPlot(HORIZONTAL, data, self.wids['ventana'])
     except ValueError:
         plot = gtk.Label("<big>No hay datos suficientes.</big>")
         plot.set_use_markup(True)
     parent = self.wids['grafico'].parent
     parent.add(plot)
     parent.remove(self.wids['grafico'])
     self.wids['grafico'] = plot
     parent.show_all()
     vpro.ocultar()

 def muestra_stock(self, boton = None):
     """
     Escribe el stock del producto en el widget.
     """
     producto = self.objeto
     from ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     vpro.set_valor(0.9, 'Contando existencias en almacén...')
     while gtk.events_pending(): gtk.main_iteration(False)
     self.wids['e_stock'].set_text("%s Kg" 
         % utils.float2str(round(producto.get_stock(),2)))
     vpro.ocultar()

 def rellenar_widgets(self, boton = None):
     """
     Busca los productos coincidentes con la cadena del entry y los muestra en el TreeView.
     """
     from ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     a_buscar = self.wids['e_a_buscar'].get_text()
     pcs = pclases.ProductoCompra.select(
        pclases.OR(pclases.ProductoCompra.q.codigo.contains(a_buscar), 
                   pclases.ProductoCompra.q.descripcion.contains(a_buscar)), 
        orderBy = "descripcion")
     resultados = []
     i = 0.0
     tot = pcs.count() * len(self.__tarifas)
     for pc in pcs:
         vpro.set_valor(i/tot, 'Recuperando %s...' % pc.descripcion)
         fila = ["PC:%d" % pc.id, 
                 pc.codigo, 
                 pc.descripcion, 
                 utils.float2str(pc.existencias), 
                 utils.float2str(pc.precioDefecto)]
         for tarifa in self.__tarifas:
             if tarifa.esta_en_tarifa(pc):
                 porcentaje = tarifa.get_porcentaje(pc)
                 precio = tarifa.obtener_precio(pc)
                 fila.append("%s (%s %%)" % (utils.float2str(precio * 1.18), 
                                             utils.float2str(porcentaje, 1)))
             else:
                 fila.append("-")
             i += 1
         fila.append(pc.id)
         resultados.append(fila)
     resultados.sort(func_por_descripcion)
     model = self.wids['tv_datos'].get_model()
     self.wids['tv_datos'].freeze_child_notify()
     self.wids['tv_datos'].set_model(None)
     model.clear()
     for e in resultados:
         model.append(e)
     self.wids['tv_datos'].set_model(model)
     self.wids['tv_datos'].thaw_child_notify()
     vpro.ocultar()

 def mostrar_silo(self, boton, silo):
     """
     Recibe el silo del que hay que mostrar el detalle de 
     cargas y descargas (consumos) y muestra una ventana con las 
     mismas ordenadas por fecha.
     """
     cd_fechas = self.leer_datos_cargas_descargas(silo)
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     tot = len(cd_fechas)
     datos = []
     fechas = cd_fechas.keys()
     fechas.sort()
     total_cargado = 0
     total_descargado = 0
     for fecha in fechas:
         vpro.set_valor(i/tot, 'Analizando movimientos...')
         i = i+1
         str_fecha = utils.str_fecha(fecha)
         for carga in cd_fechas[fecha]['cargas']:
             datos.append((str_fecha, carga.productoCompra.descripcion, 
                           utils.float2str(carga.cantidad), "", "", ""))
             total_cargado += carga.cantidad
         for descarga in cd_fechas[fecha]['descargas']: 
             producto_fabricado = "CLIC PARA VER [%d]" % (descarga.id)
             datos.append((str_fecha, "", "", 
                           descarga.productoCompra.descripcion, 
                           utils.float2str(descarga.cantidad), 
                           producto_fabricado))
             total_descargado += descarga.cantidad
     datos.append(("", "TOTAL CARGAS: ", utils.float2str(total_cargado), 
                   "TOTAL CONSUMOS: ", utils.float2str(total_descargado), 
                   ""))
     vpro.ocultar()
     utils.dialogo_resultado(datos, 
         titulo = "DETALLE DE CARGAS Y CONSUMOS DEL SILO", 
         padre = self.wids['ventana'], 
         cabeceras = ("Fecha", "Producto cargado", "Cantidad cargada", 
                      "Producto consumido", "Cantidad consumida", 
                      "Producto fabricado"), 
         func_change = self.mostrar_info_producto_fabricado)

 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...).
     """
     # DONE: Faltan los abonos por descontar.
     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
         VC = pclases.VencimientoCobro   # Para asegurarme de 
                                         # que tiene vencimientos.
         FDA = pclases.FacturaDeAbono
         C = pclases.Cobro
         if fechaini:
             facturas = FV.select(pclases.AND(
                                     FV.q.fecha >= fechaini, 
                                     FV.q.fecha <= fechafin, 
                                     VC.q.facturaVentaID == FV.q.id))
             # Busco los abonos (facturas de abono, en realidad, que no 
             # tienen por qué tener la misma fecha) que no hayan sido 
             # incluidos en facturas (porque si no el importe ya se habría 
             # contado en la factura anterior) ni en pagarés (porque 
             # entonces ya estarían en un documento de pago y por tanto 
             # no deberían aparecer en esta consulta)
             abonos = FDA.select(pclases.AND(
                 FDA.q.fecha >= fechaini, 
                 FDA.q.fecha <= fechafin))
         else:
             facturas = FV.select(pclases.AND(
                                     FV.q.fecha <= fechafin, 
                                     VC.q.facturaVentaID == FV.q.id))
             abonos = FDA.select(FDA.q.fecha <= fechafin)
         # No me queda otra que filtrar así aunque sea lento:
         abonos_pendientes = []
         for a in abonos:
             if not a.abono:
                 continue # ¿Error de borrado de un abono? Mmm... mal rollo.
             if a.abono.facturasVenta:
                 continue
             if a.cobros or a.pagosDeAbono:    
                             # Cada cobro de abono está relacionado 
                             # con un pagaré (o con lo que sea en un 
                             # posible futuro, el caso es que no 
                             # estaría pendiente).
                 continue
             abonos_pendientes.append(a)
         from ventana_progreso import VentanaProgreso
         vpro = VentanaProgreso(padre = self.wids['ventana'])
         vpro.mostrar()
         txtvpro = "Buscando facturas sin documento de pago..."
         nodos_clientes = {}
         total = 0.0
         i = 0.0
         vpro.set_valor(i, txtvpro)
         model = self.wids['tv_datos'].get_model()
         model.clear()
         facturas_tratadas = []  # Porque la consulta duplica facturas si 
             # tienen 2 vencimientos. Triplica si 3, etc.
         for f in facturas:
             i += 1
             vpro.set_valor(i/(facturas.count() + len(abonos_pendientes)), 
                            txtvpro)
             if f in facturas_tratadas:
                 continue
             facturas_tratadas.append(f)
             # Aquí voy a hacer un segundo filtro usando la cantidad 
             # pendiente de cobro de cada factura.
             #pendiente = f.calcular_pendiente_cobro()
             pendiente = f.calcular_pendiente_de_documento_de_pago()
             pendiente = round(pendiente, 2)
             if pendiente: 
                 #cliente = f.cliente
                 #if cliente not in nodos_clientes:
                 #    nodos_clientes[cliente] = model.append(None, 
                 #        (cliente.nombre, "", "", "", "0", 
                 #         -cliente.id))
                 total += pendiente
                 fechas_vto = f.vencimientosCobro[:]
                 fechas_vto.sort(lambda v1, v2: (v1.fecha < v2.fecha and -1)
                                             or (v1.fecha > v2.fecha and 1)
                                             or 0)
#.........这里部分代码省略.........

    def buscar(self, boton):
        """
        A partir de las fechas de inicio y fin de la ventana busca los
        artículos con trazabilidad y los clasifica por A, B y C en metros,
        kilos reales CON embalaje y bultos. También busca los productos de
        compra con las cantidades que salieron o entraron.
        """
        from ventana_progreso import VentanaProgreso

        vpro = VentanaProgreso(padre=self.wids["ventana"])
        vpro.mostrar()
        fini = utils.parse_fecha(self.wids["e_fechainicio"].get_text())
        ffin = utils.parse_fecha(self.wids["e_fechafin"].get_text())
        vpro.set_valor(0.0, "Buscando albaranes de salida...")
        self.albs = pclases.AlbaranSalida.select(
            pclases.AND(pclases.AlbaranSalida.q.fecha >= fini, pclases.AlbaranSalida.q.fecha < ffin), orderBy="fecha"
        )
        fib = {}
        gtx = {}
        cem = {}
        otros = {}
        i = 0.0
        tot = self.albs.count()
        for a in self.albs:
            i += 1
            vpro.set_valor(i / tot, "Analizando albarán %s..." % a.numalbaran)
            if a.es_de_movimiento():
                continue  # No cuento los interalmacenes porque me falsean
                # los totales ya que en realidad la mercancía no se ha movido
                # a ningún sitio todavía. Simplemente se han mandado a otro
                # almacén en espera de ser vendidos definitivamente al cliente.
                # Esa venta, aunque no se facture, es la que debe contar. Da
                # igual que sea venta a cliente o salida por consumo propio.
                # Los interalmacenes no implican salida real de mercancía,
                # solo movimiento.
            extract_data_from_albaran(a, fib, gtx, cem, otros)
        # Abonos
        vpro.set_valor(0.0, "Buscando abonos...")
        self.adedas = pclases.AlbaranDeEntradaDeAbono.select(
            pclases.AND(
                pclases.AlbaranDeEntradaDeAbono.q.fecha >= fini, pclases.AlbaranDeEntradaDeAbono.q.fecha < ffin
            ),
            orderBy="fecha",
        )
        i = 0.0
        tot = self.adedas.count()
        for a in self.adedas:
            i += 1
            vpro.set_valor(i / tot, "Analizando abono %s..." % a.numalbaran)
            extract_data_from_abono(a, fib, gtx, cem, otros)
        vpro.ocultar()
        tot_fib, tot_gtx, tot_cem = self.rellenar_tabla(fib, gtx, cem, otros)
        self.rellenar_totales(tot_fib, "fibra")
        self.rellenar_totales(tot_gtx, "gtx")
        self.rellenar_totales(tot_cem, "cem")

 def preparar_datos_recuperacion(self, empleados, partes_result, fecha, aux):
     """
     A partir de los partes de producción recibidos genera una lista de diccionarios
     del tipo {'nombre': , 'horas': , 'extra': , 'noche': , 'extra_n': , 'total': , 'id': } donde se 
     guarda una entrada por empleado que contiene el nombre completo, las horas 
     "normales" trabajadas, las horas extras (día y noche), las que entran en franja nocturna 
     (de 22:00 a 6:00) y el total de horas entre todos los partes en los que trabajó.
     El id no se usará, pero es el del empleado.
     Todas las horas se devolverán en formato HH:MM
     """
     res = empleados
     # aux = {}
     try:
         turnonoche = pclases.Turno.select(pclases.Turno.q.noche == True)[0] 
     except IndexError:
         utils.dialogo_info(titulo = "TURNO DE NOCHE NO ENCONTRADO",
                            texto = "No se encontró un turno de noche definido.\nDebe configurar uno.",
                            padre = self.wids['ventana'])
         return
     ininoche = mx.DateTime.DateTimeDeltaFrom(hours = turnonoche.horainicio.hour, 
                                              minutes = turnonoche.horainicio.minute)
     finnoche = mx.DateTime.DateTimeDeltaFrom(hours = turnonoche.horafin.hour, 
                                              minutes = turnonoche.horafin.minute)
     # Hay que ordenar los partes por fecha y hora para que se contabilicen 
     # bien las horas extras.
     from ven