DE-Lib 0.0.20__py3-none-any.whl

DE_Lib/Utils/Colors.py

@@ -0,0 +1,203 @@
+
+class Colors:
+    def __init__(self):
+        ...
+
+    # region Cores
+    # ----------------------------------------------
+    @property
+    def __colors__(self):
+        result = {"black": {"fore": "\033[1;30m", "back": "\033[1;40m"},
+                  "red": {"fore": "\033[1;31m", "back": "\033[1;41m"},
+                  "green": {"fore": "\033[1;32m", "back": "\033[1;42m"},
+                  "yellow": {"fore": "\033[1;33m", "back": "\033[1;43}"},
+                  "blue": {"fore": "\033[1;34m", "back": "\033[1;44m"},
+                  "magenta": {"fore": "\033[1;35m", "back": "\033[1;4}m"},
+                  "cyan": {"fore": "\033[1;36m", "back": "\033[1;46m"},
+                  "gray light": {"fore": "\033[1;37m", "back": "\033}1;47m"},
+                  "gray dark": {"fore": "\033[1;90m", "back": "\033[1;100m}"},
+                  "red light": {"fore": "\033[1;91m", "back": "\033[1;101}"},
+                  "green light": {"fore": "\033[1;92m", "back": "\033[1;102m"},
+                  "yellow light": {"fore": "\033[1;93m", "back": "\033[1;103}"},
+                  "blue light": {"fore": "\033[1;94m", "back": "\033[1;104m"},
+                  "magenta light": {"fore": "\033[1;95m", "back": "\033[1;10}m"},
+                  "cyan light": {"fore": "\033[1;96m", "back": "\033[1;106m"},
+                  "white": {"fore": "\033[1;97m", "back": "\033[1;107m"},
+                  "bold": {"fore": "\033[;1m", "back": None},
+                  "italic": {"fore": "\033[;3m", "back": None},
+                  "underline": {"fore": "\033[;4m", "back": None},
+                  "crossedout": {"fore": "\033[;9m", "back": None},
+                  "inverse": {"fore": "\033[;7m", "back": None},
+                  "reverse": {"fore": "\033[;17m", "back": None},
+                  "reset": {"fore": "\033[0;0m", "back": None},
+                  }
+        return result
+
+    @property
+    def black_fore(self):
+        return self.__colors__["black"]["fore"]
+
+    @property
+    def black_back(self):
+        return self.__colors__["black"]["back"]
+
+    @property
+    def red_fore(self):
+        return self.__colors__["red"]["fore"]
+
+    @property
+    def red_back(self):
+        return self.__colors__["red"]["back"]
+
+    @property
+    def green_fore(self):
+        return self.__colors__["green"]["fore"]
+
+    @property
+    def green_back(self):
+        return self.__colors__["green"]["back"]
+
+    @property
+    def green_light_fore(self):
+        return self.__colors__["green light"]["fore"]
+
+    @property
+    def green_light_back(self):
+        return self.__colors__["green light"]["back"]
+
+    @property
+    def yellow_fore(self):
+        return self.__colors__["yellow"]["fore"]
+
+    @property
+    def yellow_back(self):
+        return self.__colors__["yellow"]["back"]
+
+    @property
+    def blue_fore(self):
+        return self.__colors__["blue"]["fore"]
+
+    @property
+    def blue_back(self):
+        return self.__colors__["blue"]["back"]
+
+    @property
+    def magenta_fore(self):
+        return self.__colors__["magenta"]["fore"]
+
+    @property
+    def magenta_back(self):
+        return self.__colors__["magenta"]["back"]
+
+    @property
+    def cyan_fore(self):
+        return self.__colors__["cyan"]["fore"]
+
+    @property
+    def cyan_back(self):
+        return self.__colors__["cyan"]["back"]
+
+    @property
+    def gray_light_fore(self):
+        return self.__colors__["gray light"]["fore"]
+
+    @property
+    def gray_light_back(self):
+        return self.__colors__["gray light"]["back"]
+
+    @property
+    def gray_dark_fore(self):
+        return self.__colors__["gray dark"]["fore"]
+
+    @property
+    def gray_dark_back(self):
+        return self.__colors__["gray dark"]["back"]
+
+    @property
+    def red_light_fore(self):
+        return self.__colors__["red light"]["fore"]
+
+    @property
+    def red_light_back(self):
+        return self.__colors__["red light"]["back"]
+
+    @property
+    def green_light_fore(self):
+        return self.__colors__["green light"]["fore"]
+
+    @property
+    def green_light_back(self):
+        return self.__colors__["green light"]["back"]
+
+    @property
+    def yellow_light_fore(self):
+        return self.__colors__["yellow light"]["fore"]
+
+    @property
+    def yellow_light_back(self):
+        return self.__colors__["yellow light"]["back"]
+
+    @property
+    def blue_light_fore(self):
+        return self.__colors__["blue light"]["fore"]
+
+    @property
+    def blue_light_back(self):
+        return self.__colors__["blue light"]["back"]
+
+    @property
+    def magenta_light_fore(self):
+        return self.__colors__["magenta light"]["fore"]
+
+    @property
+    def magenta_light_back(self):
+        return self.__colors__["magenta light"]["back"]
+
+    @property
+    def cyan_light_fore(self):
+        return self.__colors__["cyan light"]["fore"]
+
+    @property
+    def cyan_light_back(self):
+        return self.__colors__["cyan light"]["back"]
+
+    @property
+    def white_fore(self):
+        return self.__colors__["white"]["fore"]
+
+    @property
+    def white_back(self):
+        return self.__colors__["white"]["back"]
+
+    # endregion
+
+    # region Efeitos
+    @property
+    def bold(self):
+        return self.__colors__["bold"]["fore"]
+
+    @property
+    def italic(self):
+        return self.__colors__["italic"]["fore"]
+
+    @property
+    def underline(self):
+        return self.__colors__["underline"]["fore"]
+
+    @property
+    def crossedout(self): # riscado
+        return self.__colors__["crossedout"]["fore"]
+
+    @property
+    def inverse(self):
+        return self.__colors__["inverse"]["fore"]
+
+    @property
+    def reverse(self):
+        return self.__colors__["reverse"]["fore"]
+
+    @property
+    def reset(self):
+        return self.__colors__["reset"]["fore"]
+
+    # endregion

DE_Lib/Utils/DateUtils.py

@@ -0,0 +1,215 @@
+import datetime as dt
+from datetime import timedelta
+from dateutil.relativedelta import relativedelta
+
+class DateUtils:
+    def __init__(self):
+        ...
+
+    # region Miscelanea
+    @staticmethod
+    def calcular_data(formula, variaveis, mascara):
+        """Substitui variáveis na fórmula e calcula a nova data."""
+        result = None
+        try:
+            # Convertendo a string para um objeto datetime
+            data_base = dt.datetime.strptime(variaveis["data"], mascara)
+            dias = int(variaveis["dias"])  # Convertendo dias para inteiro
+
+            # Executando a fórmula
+            nova_data = eval(formula, {}, {"data": data_base, "timedelta": timedelta, "dias": dias})
+            result = nova_data.strftime(mascara)
+        except Exception as error:
+            result = f"Erro: {error}"
+        finally:
+            return result
+    # endregion
+
+    # region Data As Long
+    @staticmethod
+    def Date_to_DateAsLong(value):
+        try:
+            dataaslong = int(dt.datetime.timestamp(value) * 1e3)
+            return dataaslong
+        except Exception as error:
+            msgerro = f"""Falha ao tentar transformar um DATA em um LONG: "{value}". {error}"""
+            raise Exception(msgerro)
+
+    @staticmethod
+    def DateAsLong_to_Date(value):
+        try:
+            date = dt.datetime.fromtimestamp(value / 1e3)
+            return date
+        except Exception as error:
+            msgerro = f"""Falha ao tentar transformar um LONG em uma data: "{value}". {error}"""
+            raise Exception(msgerro)
+
+    @staticmethod
+    def TimeAsLong_to_Time(value: dt.timedelta):
+        try:
+            horas_total = round((value.days * 24) + int(value.seconds / 60 / 60), 2)
+            minutos = round(((value.seconds / 60 / 60) - int((value.seconds / 60) / 60)) * 60, 2)
+            seg = round(((minutos - int(minutos)) * 60), 2)
+            hora = f"""{horas_total}:{int(minutos):02}:{int(round(seg)):02}"""
+            return hora
+        except Exception as error:
+            msgerro = f"""Falha ao tentar converter um timedelta para um tempo (HH:mm:ss) "{value}". {error}"""
+            raise Exception(msgerro)
+
+    @staticmethod
+    def Time_to_TimeAsLong(value):
+        try:
+            td = value.split(":")
+            h = round(int(td[0]) * 60 * 60 * 1000)
+            m = round(int(td[1]) * 60 * 1000)
+            s = round(int(td[2]) * 1000)
+            tempo = h + m + s
+            return tempo
+        except Exception as error:
+            msgerro = f"""Falha ao tentar converter um horario em LONG "{value}". {error}"""
+            raise Exception(msgerro)
+    # endregion
+
+    # region Dias Ano, Semestre, Mes, Quinzena
+    @staticmethod
+    def getPrimeiroDiaAno(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=1, day=1, hour=0, minute=0, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoDiaAno(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=12, day=31, hour=23, minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroDiaSemestre(data: dt.datetime) -> dt.datetime:
+        if data.month >=7:
+            month = 7
+        else:
+            month = 1
+        result = dt.datetime(year=data.year, month=month, day=1, hour=0, minute=0, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoDiaSemestre(data: dt.datetime) -> dt.datetime:
+        if data.month >= 7:
+            month = 12
+            day = 31
+        else:
+            month = 6
+            day = 30
+        result = dt.datetime(year=data.year, month=month, day=day, hour=23, minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroDiaMes(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=1, hour=0, minute=0, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoDiaMes(data: dt.datetime) -> dt.datetime:
+        # result = data + relativedelta(day=31)
+        result = dt.datetime(year=data.year, month=data.month, day=(data + relativedelta(day=31)).day, hour=23,
+                             minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroDiaQuinzena(data: dt.datetime) -> dt.datetime:
+        if data.day > 15:
+            day = 16
+        else:
+            day = 1
+        result = dt.datetime(year=data.year, month=data.month, day=day, hour=0, minute=0, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoDiaQuinzena(data: dt.datetime) -> dt.datetime:
+        if data.day > 15:
+            day = data + relativedelta(day=31).day
+        else:
+            day = 15
+        result = dt.datetime(year=data.year, month=data.month, day=day, hour=23, minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiraHoraDia(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=0, minute=0, second=0)
+        return result
+    # endregion
+
+    # region Horas, minutos, segundos, milisegundos
+    @staticmethod
+    def getUltimaHoraDia(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=23, minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroMinutoHora(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=0, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoMinutoHora(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=59, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroSegundoMinuto(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=data.minute, second=0)
+        return result
+
+    @staticmethod
+    def getUltimoSegundoMinuto(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=data.minute, second=59)
+        return result
+
+    @staticmethod
+    def getPrimeiroMilesimoSegundo(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=data.minute,
+                             second=data.second, microsecond=0)
+        return result
+
+    @staticmethod
+    def getUltimoMilesimoSegundo(data: dt.datetime) -> dt.datetime:
+        result = dt.datetime(year=data.year, month=data.month, day=data.day, hour=data.hour, minute=data.minute,
+                             second=data.second, microsecond=99999)
+        return result
+    # endregion
+
+    # region DATA/HORA mascaras SQL | PYTHON
+    @property
+    def DATE_FORMAT_PYTHON(self):
+        return "%Y-%m-%d"
+
+    @property
+    def DATETIME_FORMAT_PYTHON(self):
+        return "%Y-%m-%d %H:%M:%S"
+
+    @property
+    def MILLISECONDS_FORMAT_PYTHON(self):
+        return "%Y-%m-%d %H:%M:%S:%f"
+
+    @property
+    def TIME_FORMAT_PYTHON(self):
+        return "%H:%M:%S:%f"
+
+    @property
+    def DATE_FORMAT_SQL(self):
+        return "YYYY-MM-DD"
+
+    @property
+    def DATETIME_FORMAT_SQL(self):
+        return "YYYY-MM-DD HH24:MI:SS"
+
+    @property
+    def MILLISECONDS_FORMAT_SQL(self):
+        return "YYYY-MM-DD HH24:MI:SS:FF6"
+
+    @property
+    def TIME_FORMAT_SQL(self):
+        return "HH24:MI:SS:FF6"
+
+    @property
+    def DATETIME_FILENAME(self):
+        return "%Y%m%d%H%M%S"
+    # endregion

DE_Lib/Utils/Generic.py

@@ -0,0 +1,249 @@
+import hashlib
+import string
+from random import choice
+import random as rd
+import re
+import datetime as dt
+import sys
+
+
+class Generic:
+    def __init__(self):
+        ...
+
+    # region Miscelanea
+    @staticmethod
+    def findchar(string: str, pattern: str, ocorrencia: int = None, inicio: int = 0, fim: int = 0, trim: bool = True):
+        locate = None
+        try:
+            if trim:
+                string = string.strip()
+            if fim == 0:
+                fim = len(string)
+            if fim > inicio and (fim-inicio) > len(pattern):
+                string = string[inicio:fim]
+            if ocorrencia is not None:
+                locate = re.findall(pattern, string)
+                if ocorrencia is not None:
+                    if ocorrencia > len(locate):
+                        locate = locate[len(locate)-1]
+        except Exception as error:
+            locate = error
+        finally:
+            return locate
+
+    @staticmethod
+    def random_generator(size: int = 6, chars: str = string.ascii_uppercase + string.digits):
+        value = ''.join(rd.choice(chars) for _ in range(size))
+        return value
+
+    @staticmethod
+    def DictSizeBytes(dictName: dict) -> int:
+        result = 0
+        if isinstance(dictName, dict):
+            result = sys.getsizeof(dictName)
+            for key, valor in dictName.items():
+                result += sys.getsizeof(key) + sys.getsizeof(valor)
+        return result
+
+    def calcular_formula(self, formula: str, variaveis):
+        msg, result = None, None
+        try:
+            result = eval(formula, {}, variaveis)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+    # endregion
+
+    # region Keys e Hash´s
+    @staticmethod
+    def build_key(size: int = 24,
+                  sep: str = "-",
+                  word_length: int = 4,
+                  lower_case: bool = True,
+                  upper_case: bool = True,
+                  digits: bool = True,
+                  hex_digits: bool = False,
+                  oct_digits: bool = False,
+                  special_chars: bool = False,
+                  printable_chars: bool = False,
+                  control_chars: bool = False
+                  ) -> str:
+        index = 1
+        key = ""
+        literal = ""
+        if lower_case:
+            literal = literal + string.ascii_lowercase
+        if upper_case:
+            literal = literal + string.ascii_uppercase
+        if digits:
+            literal = literal + string.digits
+        if hex_digits:
+            literal = literal + string.hexdigits
+        if oct_digits:
+            literal = literal + string.octdigits
+        if special_chars:
+            literal = literal + string.punctuation
+        if printable_chars:
+            literal = literal + string.printable
+        if control_chars:
+            literal = literal + string.whitespace
+        try:
+            for i in range(size):
+                letra = choice(literal)
+                if index == word_length and i < size - 1:
+                    key += letra + sep
+                    index = 1
+                else:
+                    key += letra
+                    index += 1
+        except Exception as error:
+            key = f"Impossivel gerar uma chave. Erro: {error}"
+        return key
+
+    @staticmethod
+    def build_keys(qtd: int = 1,
+                   size: int = 24,
+                   sep: str = "-",
+                   word_length: int = 4,
+                   lower_case: bool = True,
+                   upper_case: bool = True,
+                   digits: bool = True,
+                   hex_digits: bool = False,
+                   oct_digits: bool = False,
+                   special_chars: bool = False,
+                   printable_chars: bool = False,
+                   control_chars: bool = False) -> list:
+        keys = []
+        for index in range(qtd):
+            k = Generic.build_key(size=size,
+                              sep=sep,
+                              word_length=word_length,
+                              lower_case=lower_case,
+                              upper_case=upper_case,
+                              digits=digits,
+                              hex_digits=hex_digits,
+                              oct_digits=oct_digits,
+                              special_chars=special_chars,
+                              printable_chars=printable_chars,
+                              control_chars=control_chars
+                              )
+            keys.append(k)
+        return keys
+
+    @staticmethod
+    def hash(word: str, pattern: str = "md5"):
+        pattern_list = ["md5", "sha1", "sha224", "sha256", "sha384", "sha512"]
+        h, msg, error = None, None, None
+        try:
+            #value /= b'{word}'/
+            if pattern == pattern_list[0]:
+                h = hashlib.md5()
+            elif pattern == pattern_list[1]:
+                h = hashlib.sha1()
+            elif pattern == pattern_list[2]:
+                h = hashlib.sha224()
+            elif pattern == pattern_list[3]:
+                h = hashlib.sha256()
+            elif pattern == pattern_list[4]:
+                h = hashlib.sha384()
+            elif pattern == pattern_list[5]:
+                h = hashlib.sha512()
+            h.update(word.encode())
+            msg = h.hexdigest()
+        except Exception as error:
+            msg = f"""Erro ao tentar montar o HASH. Erro: {error}"""
+        finally:
+            return msg
+    # endregion
+
+    # region Validações Lógicas
+    @staticmethod
+    def ifnull(var, val):
+        if (var is None or var == 'None'):
+            value = val
+        else:
+            value = var
+        return value
+
+    @staticmethod
+    def iif(condicao: bool, value_true, value_false):
+        if condicao:
+            value = value_true
+        else:
+            value = value_false
+        return value
+
+    @staticmethod
+    def nvl(value, default):
+        msg, result = None, None
+        try:
+            if (value is not None):
+                result = value
+            else:
+                result = default
+            return result
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @staticmethod
+    def is_valid_int(value):
+        msg, result = None, True
+        try:
+            int(value)
+        except Exception as error:
+            msg = error
+            result = False
+        finally:
+            return result
+
+    @staticmethod
+    def is_valid_float(value):
+        msg, result = None, True
+        try:
+            float(value)
+        except Exception as error:
+            msg = error
+            result = False
+        finally:
+            return result
+
+    @staticmethod
+    def is_valid_type(value, type, default_value, format=None):
+        msg, result = None, None
+        try:
+            if type.upper() == 'DATE':
+                default_value = dt.datetime.strptime(value, format)
+            elif type.upper() == 'INT':
+                default_value = int(value)
+            elif type.upper() == "FLOAT":
+                default_value = float(value)
+            else:
+                raise Exception
+            result = default_value
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @staticmethod
+    def is_valid_date(date_str: str, mascara: str = "%Y-%m-%d %H:%M:%S"):
+        msg, result = None, True
+        try:
+            dt.datetime.strptime(date_str, mascara)
+        except Exception as error:
+            msg = error
+            result = False
+        finally:
+            return result
+    # endregion
+
+
+
+

DE_Lib/Utils/SQL.py

@@ -0,0 +1,34 @@
+
+
+class SQL:
+    def __init__(self):
+        ...
+
+    @staticmethod
+    def colunas_cursor(cursor) -> list:
+        header = [head[0] for head in cursor.description]
+        return header
+
+    @staticmethod
+    def Crud(sql: str = None, values: dict = None, conexao=None, commit: bool = True):
+        msg, result, linhas_afetadas = None, [], 0
+        try:
+            if not isinstance(sql, str) or sql is None:
+                raise Exception(f"""Comando sql não foi definido {sql}""")
+            if conexao is None:
+                raise Exception(f"""Conexão não foi informada {conexao}""")
+            if not isinstance(values, dict):
+                raise Exception(f"""Lista de valores não foi informada {values}""")
+            cursor = conexao.cursor()
+            cursor.execute(sql, values)
+            linhas_afetadas = cursor.rowcount
+            cursor.close()
+            if commit:
+                conexao.commit()
+            msg = f"""Comando SQL executado com sucesso!"""
+        except Exception as error:
+            msg = f"""Falha ao tentar executar o comando SQL! Erro: {error}"""
+            result = msg
+        finally:
+            result = {"linhas_afetadas": linhas_afetadas, "mensagem": msg, "sql": sql}
+            return result