Python utils.float2str函数代码示例

 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 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 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 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, 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 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):
     """
     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 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, 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 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))