Untitled

from enum import Enum
from datetime import datetime




def int_fix(s: any, default = None):
    """ 
        Función que covierte un valor a un entero, en caso de que no sea un valor valido retorna un caracter vacio
    Args:
        s (any): Valor de tipo no especificado 

    Returns:
        _type_: int or any
    """
    try:
        return int(float(s)) 
    except (ValueError, TypeError):
        return s


def float_fix(n: any):
    """
    Intenta convertir el valor n a un número de punto flotante.
    
    Args:
    n: El valor que se intentará convertir a un número de punto flotante.
    
    Returns:
    Un número de punto flotante que representa el valor de n si es posible convertirlo, de lo contrario devuelve n.
    """
    try: 
        return float(n)
    except: 
        return n


def float_round_fix(n: any, r=2):
    """
    Intenta convertir el valor n a un número de punto flotante con solo r decimales sin aproximar.
    
    Args:
    n (any): El valor que se intentará convertir a un número de punto flotante con solo r decimales.
    r (int): La cantidad de decimales a mantener (por defecto 2).
    
    Returns:
    float: Un número de punto flotante con solo r decimales que representa el valor de n si es posible convertirlo, de lo contrario devuelve n.
    """
    if n:
        try:
            n = str(n)
            if "." in n:     
                integer_part, decimal_part = n.split('.')           
                return float(integer_part + "." + decimal_part[:r])
        except:
            return n
    return n


def text_fix(s: any):
    """
        Función que convierte un valor a String, si el valor es 'null' or 'NULL' retornará None
    Args:
        s (any): Valor de tipo no especificado 

    Returns:
        _type_: str or None
    """
    return str(s) if s is not None and str(s).lower() != 'null' else None

def moneda_fix(numero):
    """
    Funcion para formatear moneda
    """
    partes = str(numero).split('.')
    entero = partes[0]
    decimal = (partes[1] if len(partes) > 1 else '00')[:2]
    if len(decimal) == 1:
        decimal = decimal + '0'
    entero = entero[::-1]
    entero = ','.join(entero[i:i+3] for i in range(0, len(entero), 3))
    entero = entero[::-1]
    # return "RD$ " + entero + "." + decimal
    return entero + "." + decimal
    

#Convierte fecha a formato (01-2023) - (01-11-2023)
def date_fix(value, separator='-'):
    """
    Esta función toma un valor de fecha en formato 'YYYYMM' o 'YYYYMMDD' y un separador opcional,
    y devuelve la fecha en el formato 'DD-MM-YYYY' o 'MM-YYYY' respectivamente.

    Args:
    value (str): El valor de fecha en formato 'YYYYMM' o 'YYYYMMDD'.
    separator (str, opcional): El separador a utilizar en el resultado. Por defecto es '-'.

    Returns:
    str: La fecha formateada en el formato especificado, si no es posible convertir retorna el valor de entrada.
    """
    try:
        if len(value) == 6:
            fecha = datetime.strptime(value, "%Y%m").strftime("%m" + separator + "%Y")
        else:
            fecha = datetime.strptime(value, "%Y%m%d").strftime("%d" + separator + "%m" + separator + "%Y")
    except:
        fecha = value
    return fecha



####################### Funciones PE #######################

# Función para quitar el espacio de nombres de una etiqueta
def remove_namespace(tag):
    if '}' in tag:
        return tag.split('}')[1]
    return tag

# Función para convertir un elemento XML a un diccionario recursivamente
def xml_to_dict(element):
    dict_data = {}
    if element.attrib:
        dict_data.update(element.attrib)
    if element.text and element.text.strip():
        dict_data[remove_namespace(element.tag)] = element.text.strip()
    for child in element:
        if len(child) == 0:
            dict_data[remove_namespace(child.tag)] = child.text.strip() if child.text else None
        else:
            child_dict = xml_to_dict(child)
            child_tag = remove_namespace(child.tag)
            if child_tag in dict_data:
                if not isinstance(dict_data[child_tag], list):
                    dict_data[child_tag] = [dict_data[child_tag]]
                dict_data[child_tag].append(child_dict)
            else:
                dict_data[child_tag] = child_dict
    return dict_data



# Comprueba si un Dict posee KEY 
def default_value(data, keys, default=None):
    try:
        value = data
        for key in keys:
            value = value.get(key)
            if value is None:
                return default
        return value
    except (AttributeError, KeyError):
        return default