Python, y problema de ejecucion!

[korg1988]

Aca paso el codigo de la clase "Rastrillador" que es la clase encargada de realizar el proceso..

Quiero aclarar algo antes... y que no se olvide... TODO EL RESTO DEL SISTEMA funciona OK.. Solo falla en este momento, y no arroja NINGUNA clase de error o excepcion...

El bucle en cuestion donde la aplicacion muere es el siguiente, y se encuentra en el metodo "run" (que sobreescribe al metodo run de la clase Thread) ya que ejecuto el proceso como un hilo aparte

Código:

for asociado, total_asociados in Asociado.factory():

Código Python:

class Rastrillador(threading.Thread, QtCore.QObject):
    "Clase que se encarga de revisar asociado por asociado. Es un thread independiente"
    confirmado = QtCore.Signal() # sucede cuando todo esta ok, y se inicia el bucle de rastrillaje
    actual = QtCore.Signal((Asociado, tuple))
    terminado = QtCore.Signal()
    error = QtCore.Signal((unicode,))
    
    def __init__(self, fecha_periodo):
        threading.Thread.__init__(self)
        QtCore.QObject.__init__(self)
        
        self.fecha_periodo = fecha_periodo
 
    def periodo_fue_rastrillado(self, fecha_periodo):
        tabla = abrir_tabla(Config.config.get("db_paths", "uif_periodos"))
        for registro in tabla:
            if str(registro.periodo).zfill(6) == fecha_periodo.strftime("%m%Y"):
                return True
        return False
    
    def __registrar_rastrillaje(self, operador, asoc_r, asoc_e):
        a = abrir_tabla(Config.config.get("db_paths", "uif_periodos"))
        a.append((self.fecha_periodo.strftime("%m%Y"), datetime.date.today(), operador, asoc_r, asoc_e))
    
    def run_dbf_filter(self):
        """Llama a una rutina externa encargada de filtrar las tablas de movimientos correspondiendo al periodo dado.
        A partir de aqui toda operación sobre estas tablas asume que los datos son del período en cuestión"""
        cmd = Config.config.get("engines", "uif_filter").format(periodo=self.fecha_periodo.strftime("%m%Y"))
        return subprocess.call(cmd, shell=True)
    
    def run(self):
        index = 0
        total_excedidos = 0
        
        try:
            if self.periodo_fue_rastrillado(self.fecha_periodo):
                raise Exception(u"El período ya fue rastrillado")
            
            if sys.platform == "win32":
                if self.run_dbf_filter() != 0:
                    raise Exception(u"No se ha podido ejecutar la rutina de filtrado.\nVerifique la misma en el archivo uif.cfg > engines > uif_filter.")
        except dbf.DbfError:
            print "error en dbf iniciando rastrillaje"
        except Exception, e:
            self.error.emit(e.message)
        else:
            self.confirmado.emit()
 
            for asociado, total_asociados in Asociado.factory():
                index += 1
                self.actual.emit(asociado, (index, total_asociados)) # Asociado, tupla_porcentaje
                
                asociado.calcular_totales()
                tope_asociado = asociado.obtener_tope_uif()
                
                total_asociado = asociado.total_amt + asociado.total_cac + asociado.total_cae
                
                valor_tope_general = Parametros().valoruif
                try:
                    """ Si no existe tope personal, entonces la expresion arroja un error, y caigo en el except, utilizando el tope general.
                    Si existe un tope personal, lo comparo al general, y utilizo el de mayor valor"""
                    valor_tope, tipo_tope = ((valor_tope_general, "generico")
                                             if valor_tope_general > tope_asociado.valor else 
                                             (tope_asociado.valor, "personal"))
                except:
                    valor_tope, tipo_tope = valor_tope_general, "generico"
 
                esta_excedido = total_asociado > valor_tope
 
                if esta_excedido:
                    total_excedidos += 1
                    exceso = total_asociado - valor_tope
                    asociado.informar_exceso(fecha_periodo=self.fecha_periodo, exceso=exceso, tipo_tope=tipo_tope, 
                                             valor_tope=valor_tope, generar_documento=True)
            
            self.__registrar_rastrillaje(operador=obtener_nombre_operador(), 
                                         asoc_r=total_asociados, asoc_e=total_excedidos)
            self.terminado.emit()
 

Aca te pongo la clase "Asociado"

Código Python:

class Asociado(object):
 
    @staticmethod
    def factory(nro_socio=None):
        tabla = abrir_tabla(Config.config.get("db_paths", "asociados"))
        if nro_socio is not None:
            registros = tabla.query("select * where nro_socio == " + str(nro_socio))
        else:
            registros = tabla
        
        total_registros = len(registros)
        for registro in registros:
            yield Asociado(nro_socio=registro.nro_socio, apeynom=registro.apeynom, cuil=registro.cuil), total_registros
            
            """Este modo fue anulado porque el campo fecha de algunos registros tenia un caracter extraño que hacia 
            crashear la libreria al acceder al mismo e intentar transformarlo a datetime"""
            #yield Asociado(**dict(zip(tabla.field_names, registro))), total_registros
            
    def __init__(self, nro_socio, apeynom, cuil, **kwargs):
        self.nro_socio = nro_socio
        self.apeynom = apeynom
        self.cuil = cuil
        
        self.total_amt = None
        self.total_cac = None
        self.total_cae = None
        
    def __calcular_total_amt(self):
        self.total_amt = 0.00
        tabla = abrir_tabla(Config.config.get("db_paths", "amt"))
        
        for registro in tabla.query("select * where nrotit1 == " + str(self.nro_socio)):
            cotiz = registro.cotiz if registro.cotiz else 1
            self.total_amt += round(registro.capital * cotiz, 2)
    
    def __calcular_total_cac(self):
        self.total_cac = 0.00
        tabla = abrir_tabla(Config.config.get("db_paths", "cac"))
        
        for registro in tabla.query("select * where nrocta == " + str(self.nro_socio)):
            self.total_cac += registro.importe
    
    def __calcular_total_cae(self):
        self.total_cae = 0.00
        tabla = abrir_tabla(Config.config.get("db_paths", "cae"))
        
        for registro in tabla.query("select * where nrocta == " + str(self.nro_socio)):
            self.total_cae += registro.importe
    
    def calcular_totales(self):
        self.__calcular_total_amt()
        self.__calcular_total_cac()
        self.__calcular_total_cae()
    
    def obtener_tope_uif(self):
        tabla = abrir_tabla(Config.config.get("db_paths", "uif_asociados"))
        query = tabla.query("select * where nro_socio == " + str(self.nro_socio))
        
        # obtengo el registro con fecha mas actual
        registro_mas_actual = None
        for registro in query:
            if not registro_mas_actual:
                registro_mas_actual = registro
                continue
            
            if registro.fecha >= registro_mas_actual.fecha:
                registro_mas_actual = registro
                
        return registro_mas_actual if registro_mas_actual else None # devuelvo valor de tope personal
    
    def guardar_tope(self, valor, fecha, motivo):
        fecha_dbfdate = dbf.Date(fecha.year,fecha.month,fecha.day)
        
        tabla = abrir_tabla(Config.config.get("db_paths", "uif_asociados"))
        tabla.append((self.nro_socio, fecha_dbfdate, obtener_nombre_operador(), motivo, valor))
    
    def informar_exceso(self, fecha_periodo, exceso, valor_tope, tipo_tope, generar_documento=False):
        hoy = datetime.datetime.today()
        hoy_dbfdate = dbf.Date(hoy.year,hoy.month,hoy.day)
        periodo = fecha_periodo.strftime("%m%Y")
        
        if self.total_cae is None and self.total_cac is None and self.total_amt is None:
            self.calcular_totales()
        
        tabla = abrir_tabla(Config.config.get("db_paths", "uif_registro"))
        tabla.append((self.nro_socio, self.apeynom, hoy_dbfdate, periodo, obtener_nombre_operador(), self.total_cae, self.total_cac, self.total_amt, exceso))
        
        if generar_documento:
            filename = "%s_%s" % (re.sub("[^A-Za-z0-9]", "_", self.apeynom.strip()), self.nro_socio)
            base_dir_path = Config.config.get("documentos", "dir_path").strip("/")
            periodo_dir_path = base_dir_path + "/" + fecha_periodo.strftime("%Y-%m")
            doc_filename = periodo_dir_path + "/" + filename + ".txt"
            
            create_folder(periodo_dir_path)
            
            total = self.total_amt + self.total_cac + self.total_cae
            
            "Patterns"
            lalign = "{:<15}" # alinea a la izquierda
            ralign = "{:>15}" # alinea a la derecha con 15 lugares
            pcurrency = "${:,.2f}" # 2 decimales; la "," separa millares (3,000,000.00)
            
            if self.cuil:
                cuil_text = "%s-%s-%s" % (str(self.cuil)[:2], str(self.cuil)[2:-1], str(self.cuil)[-1:])
            else:
                cuil_text = "Falta"
                
            with open(doc_filename, "w+") as f:
                doc_content = (u"ASOCIACIÓN DE PROTECCIÓN RECIPROCA ENTRE PRODUCTORES AGROPECUARIOS\n"
                u"MODULO DE CONTROL UIF {fecha}\n\n"
                u"{asociado}\n"
                u"{t_nro_socio}{nro_socio}\n"
                u"{t_cuil}{cuil}\n"
                u"{t_periodo}{periodo}\n\n"
                u"{t_amt}{total_amt}\n"
                u"{t_cac}{total_cac}\n"
                u"{t_cae}{total_cae}\n"
                u"{t_total}{total}\n\n"
                u"{t_tope}{valor_tope}\n"
                u"{t_exceso}{exceso}\n\n"
                u"Notas:\n\n\n\n"
                u"Firma ____________________________________"
                .format(t_cuil=lalign.format(u"CUIL:"), t_nro_socio=lalign.format(u"Nro. Socio:"),
                    t_periodo=lalign.format(u"Período"), t_amt=lalign.format(u"Total AMT:"), t_cac=lalign.format(u"Total CAC:"),
                    t_cae=lalign.format(u"Total CAE:"), t_total=lalign.format(u"Total:"), t_exceso=lalign.format(u"Exceso:"),
                    t_tope=lalign.format(u"Tope %s:" % tipo_tope), cuil=ralign.format(cuil_text), 
                    fecha=hoy.strftime("%d/%m/%Y"), asociado=self.apeynom, 
                    nro_socio=ralign.format("%s/%s" % (str(self.nro_socio)[:-1], str(self.nro_socio)[-1:])), 
                    periodo=ralign.format(fecha_periodo.strftime("%m/%Y")), 
                    total_amt=ralign.format(pcurrency.format(self.total_amt)), 
                    total_cac=ralign.format(pcurrency.format(self.total_cac)), 
                    total_cae=ralign.format(pcurrency.format(self.total_cae)), 
                    total=ralign.format(pcurrency.format(total)), exceso=ralign.format(pcurrency.format(exceso)),
                    valor_tope=ralign.format(pcurrency.format(valor_tope))))
                f.write(doc_content.upper())
 

La funcion "abrir_tabla" que veras por todos lados es simplemente un shortcut, y la pongo aca

Código Python:

def abrir_tabla(archivo):
    tabla = dbf.Table(archivo, codepage="\x02", ignore_memos=True)
    tabla.open()
    return tabla