DE-Lib 0.0.20__py3-none-any.whl → 0.0.36__py3-none-any.whl

DE_Lib/DataBase/SQCipher.py

@@ -1,29 +1,33 @@
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class SQCipher:
+gen = Generic.GENERIC()
+
+class SQCIPHER:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
-    def Connect(self, database, password):
+    def Connect(self, string_connect:dict, password):
         DATABASE_NAME, result, msg, conn = None, False, None, None
         try:
-            if os.path.isfile(database):
+            if os.path.isfile(os.path.join(string_connect["host"], string_connect["instance"])):
                 #conn = sqch.connect(database, password=password)
                 self._connection_is_valid = True
-                self._nome_database = 'SQLCIPHER'
-                self._cnn = conn
-            else:
-                msg = f"""SQLITE [{database}]- Não existe no local informado!"""
-                raise Exception(msg)
+                self._nome_database = gen.nvl(string_connect["database"], "")
+                self._cnn = result
+                self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
-            conn = error
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = True
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/SQLite.py

@@ -1,33 +1,49 @@
 import sqlite3 as sq3
+import sqlalchemy as sqa
 import os
+import json
 
-class SQLite:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class SQLITE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
-    def Connect(self, database, **kwargs):
-        result, msg, conn = False, None, None
+    def Connect(self, conn: dict, **kwargs):
+        msg, result = None, True
         try:
-            if os.path.isfile(database):
+            __file = os.path.join(conn["host"], conn["instance"])
+            if os.path.isfile(__file):
                 if "check_same_thread" in kwargs.keys():
                     __check_same_thread = kwargs.get("check_same_thread")
                 else:
                     __check_same_thread = True
-                result = sq3.connect(database, check_same_thread=__check_same_thread)
-                self._connection_is_valid = True
-                self._cnn = result
-                self.__database_error = f"""SQLITE database: {database}\nConexao bem sucedida!"""
-            else:
-                raise Exception("File NOT FOUND!")
-            self._nome_database = 'SQLITE'
+
+                __conn = None
+                if not conn["driver_conexao"]:
+                    __conn = sq3.connect(__file, check_same_thread=__check_same_thread)
+                elif conn["driver_conexao"].upper() == "SQLALCHEMY":
+                    engine = sqa.create_engine(f"""sqlite:///{__file}""")
+                    __conn = engine.connect()
+                else:
+                    ...
+                    # driver nativo sqlite
+
+            self._connection_is_valid = True
+            self._cnn = __conn
+            self._nome_database = gen.nvl(conn["database"], "SQLite")
+            self.__database_driver = conn["driver_conexao"]
+            self.__database_error = result
         except Exception as error:
-            msg = f"""SQLITE database: {database}\nFalha ao tentar se conectar com o banco de dados SQLITE\nException Error: {error} """
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados SQLite\nException Error: {error} """
             result = msg
             self._connection_is_valid = False
-            self.__database_error = msg + "\n" + error
+            self.__database_error = msg
         finally:
             return result
 
@@ -45,4 +61,12 @@ class SQLite:
 
     @property
     def DATABASE_ERROR(self):
-        return self.__database_error
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value

DE_Lib/Files/Zip.py

@@ -0,0 +1,119 @@
+import zipfile
+from zipfile import ZipFile
+import shutil
+import os
+
+
+class ZIP:
+    def __init__(self):
+        self.__read = ("r")
+        self.__write = "w"
+        self.__append = "a"
+        self.__moving = "MOVING"
+        self.__delete = "DELETE"
+        self.__nothing = "NOTHING"
+        self.__modo = None
+
+    # ---------------------------------
+    def ZipFiles(self):
+        msg, result = None, True
+        try:
+            ...
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    # ---------------------------------
+    def zip(self, files:list, zipfile: str, modo:str="w", action:str="NOTHING", moving:str=""):
+        msg, result = None, True
+        try:
+            # modo
+            with ZipFile(zipfile, modo) as zfh:
+            #zfh = ZipFile(file=zipfile, mode="w")
+                for file in files:
+                    zfh.write(filename=file)
+
+                    # action
+                    if action == self.NOTHING:
+                        pass
+                    elif action == self.DELETE:
+                        for file in files:
+                            os.remove(file)
+                    elif action == self.MOVING:
+                        if os.path.isdir(moving):
+                            shutil.move(file, moving)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ---------------------------------
+    def unzip(self, zipfile:str, outputfolder:str):
+        msg, result = None, True
+        try:
+            zfh = ZipFile(zipfile, self.READ)
+            zfh.extractall(outputfolder)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    @property
+    def NOTHING(self):
+        return self.__nothing
+
+    @NOTHING.setter
+    def NOTHING(self, value):
+        self.__nothing = value
+
+
+    @property
+    def DELETE(self):
+        return self.__delete
+
+    @DELETE.setter
+    def DELETE(self, value):
+        self.__delete = value
+
+    @property
+    def MOVING(self):
+        return self.__moving
+
+    @MOVING.setter
+    def MOVING(self, value):
+        self.__moving = value
+
+
+    @property
+    def APPEND(self):
+        return self.__append
+
+    @APPEND.setter
+    def APPEND(self, value):
+        self.__append = value
+
+
+    @property
+    def WRITE(self):
+        return self.__write
+
+    @WRITE.setter
+    def WRITE(self, value):
+        self.__write = value
+
+
+    @property
+    def READ(self):
+        return self.__read
+
+    @READ.setter
+    def READ(self, value):
+        self.__read = value
+
+

DE_Lib/Log/Level.py

@@ -1,9 +1,9 @@
-from source.Utils import Colors as COR
+from DE_Lib.Utils import Colors
 
-cor = COR.Colors()
+colors = Colors.COLORS()
 
 
-class Level:
+class LEVEL:
     def __init__(self):
         self.__log__level__ = {"code":None, "name": None, "color": None}
         self.__logEvent = {}
@@ -13,56 +13,56 @@ class Level:
     def NOTSET(self):
         self.__log__level__["code"] = 0
         self.__log__level__["name"] = "NOTSET"
-        self.__log__level__["color"] = cor.green_light_fore
+        self.__log__level__["color"] = colors.green_light_fore
         return self.__log__level__
 
     @property
     def WARNING(self):
         self.__log__level__["code"] = 10
         self.__log__level__["name"] = "WARNING"
-        self.__log__level__["color"] = cor.yellow_light_fore
+        self.__log__level__["color"] = colors.yellow_light_fore
         return self.__log__level__
 
     @property
     def DEBUG(self):
         self.__log__level__["code"] = 20
         self.__log__level__["name"] = "DEBUG"
-        self.__log__level__["color"] = cor.green_light_fore
+        self.__log__level__["color"] = colors.green_light_fore
         return self.__log__level__
 
     @property
     def ERROR(self):
         self.__log__level__["code"] = 30
         self.__log__level__["name"] = "ERROR"
-        self.__log__level__["color"] = cor.red_light_fore
+        self.__log__level__["color"] = colors.red_light_fore
         return self.__log__level__
 
     @property
     def INFO(self):
         self.__log__level__["code"] = 40
         self.__log__level__["name"] = "INFO"
-        self.__log__level__["color"] = cor.gray_light_fore
+        self.__log__level__["color"] = colors.gray_light_fore
         return self.__log__level__
 
     @property
     def CRITICAL(self):
         self.__log__level__["code"] = 50
         self.__log__level__["name"] = "CRITICAL"
-        self.__log__level__["color"] = cor.red_fore + cor.white_back
+        self.__log__level__["color"] = colors.red_fore + colors.white_back
         return self.__log__level__
 
     @property
     def DESTAQUE(self):
-        self.__log__level__["code"] = 50
+        self.__log__level__["code"] = 60
         self.__log__level__["name"] = "DESTAQUE"
-        self.__log__level__["color"] = cor.cyan_fore
+        self.__log__level__["color"] = colors.cyan_fore
         return self.__log__level__
 
     @property
     def ENFASE(self):
-        self.__log__level__["code"] = 50
+        self.__log__level__["code"] = 70
         self.__log__level__["name"] = "ENFASE"
-        self.__log__level__["color"] = cor.white_fore + cor.bold + cor.underline
+        self.__log__level__["color"] = colors.white_fore + colors.bold + colors.underline
         return self.__log__level__
 
     @property

DE_Lib/Log/Log.py

@@ -1,29 +1,25 @@
 #region Imports
-import sys
-
-from source.Log import Level as LVL
-from source.DataBase import SQLite as SLT
-from source.Utils import DateUtils as DTU
-from source.Utils import Generic as GEN
-from source.Utils import System as SOP
-from source.Utils import Colors as COR
 import inspect
 import os
 import json
 import datetime as dt
+
+from DE_Lib.Log import Level
+from DE_Lib.DataBase import SQLite as SLT
+from DE_Lib.Utils import DateUtils, Generic, System, Colors
 #endregion
 
 #region Instancias
-lvl = LVL.Level() # biblioteca LOG - Trata os niveis do log
-slt = SLT.SQLite() # biblioteca DataBase - Driver SQLite
-dtu = DTU.DateUtils() # bibliotaca Utils.DateUtils - Tratamento de dadas
-gen = GEN.Generic() # biblioteda Utils.Generic - diversas funcionalidades
-sop = SOP.SO() # biblioteca Utils.SO - Diversar funcoes do sistema operacional
-cor = COR.Colors() # biblioteca Utils.Colors - represantação de cores (utilizada na LOG)
+lvl = Level.LEVEL() # biblioteca LOG - Trata os niveis do log
+slt = SLT.SQLITE() # biblioteca DataBase - Driver SQLite
+dtu = DateUtils.DATEUTILS() # bibliotaca Utils.DateUtils - Tratamento de dadas
+gen = Generic.GENERIC() # biblioteda Utils.Generic - diversas funcionalidades
+sop = System.SO() # biblioteca Utils.SO - Diversar funcoes do sistema operacional
+cor = Colors.COLORS() # biblioteca Utils.Colors - represantação de cores (utilizada na LOG)
 #endregion
 
 
-class Log:
+class LOG:
     def __init__(self):
         self.__processo = None
         self.__list_log_detail = []
@@ -33,6 +29,8 @@ class Log:
     def setInit(self, processo: dict):
         msg, result = None, True
         try:
+            self.TABLE_LOG = processo["table"]
+            self.TABLE_EVENT = processo["event"]
             self.__processo = processo
             self.__call_origin = self.__getCALLFUNCTION()
             self.__log_header = self.__setLogHeader()
@@ -70,9 +68,9 @@ class Log:
             print(self.__setPrintFinalizacao())
 
             rst = self.setInsertLOG()
-            print(rst)
+            #print(rst)
             rst = self.setInsertEVENT()
-            print(rst)
+            #print(rst)
 
             #print(json.dumps(__log, indent=4))
         except Exception as error:
@@ -91,16 +89,16 @@ class Log:
                         "nom_rotina": self.PROCESSO["processo"],
                         "nom_subrotina": self.CALL_FUNCTION,
                         "descricao": self.PROCESSO["descricao"],
-                        "file": self.FILELOG,
-                        "user_db": "",
+                        "filename": self.FILELOG,
                         "os_user": sop.OSINFO["os_user"],
+                        "user_db": "",
                         "local_ip": sop.OSINFO["local_ip"],
                         "local_name": sop.OSINFO["local_name"],
                         "processor": sop.OSINFO["processor"],
                         "so_platform": sop.OSINFO["so_platform"],
                         "so_system": sop.OSINFO["so_system"],
                         "so_version": sop.OSINFO["so_version"],
-                        "timestamp": dt.datetime.now().strftime(dtu.MILLISECONDS_FORMAT_PYTHON),
+                        "datahoralog": dt.datetime.now().strftime(dtu.MILLISECONDS_FORMAT_PYTHON),
                         "versao": sop.OSINFO["so_version"]
                         }
             result = __header
@@ -115,7 +113,7 @@ class Log:
         try:
             __detail = {"hash": gen.build_key(),
                        "hash_parent": self.LOG_HEADER["hash"],
-                       "timestamp": dt.datetime.now().strftime(dtu.MILLISECONDS_FORMAT_PYTHON),
+                       "datahoralog": dt.datetime.now().strftime(dtu.MILLISECONDS_FORMAT_PYTHON),
                        "level_code": level["code"],
                        "level_name": level["name"],
                        "function_name": self.CALL_FUNCTION,
@@ -178,7 +176,7 @@ class Log:
     def __setPrintScreen(self, level, lf: bool = True, onscreen: bool = True):
         if onscreen:
             __log = self.LOG_DETAIL[-1]
-            __text = f"""{cor.reset}{__log["timestamp"]}-{level["color"]}{__log["level_name"].ljust(10)}{cor.reset}: {level["color"]}{__log["event_content"]}{cor.reset}"""
+            __text = f"""{cor.reset}{__log["datahoralog"]}-{level["color"]}{__log["level_name"].ljust(10)}{cor.reset}: {level["color"]}{__log["event_content"]}{cor.reset}"""
             if lf:
                 print(__text)
             else:
@@ -193,7 +191,7 @@ class Log:
         msg, result = None, True
         try:
             # Foi passado um nome de arquivo de log
-            if self.PROCESSO["file"] is None:
+            if self.PROCESSO["filename"] is None:
                 if not os.path.isdir(os.path.dirname(self.FILELOG)):
                     # se o diretorio informado não existir sera utilizado o diretorio local
                     if os.path.basename(self.FILELOG) is None:
@@ -211,7 +209,7 @@ class Log:
     def __getCALLFUNCTION(self, value = inspect.stack()):
         msg, result = None, True
         try:
-            result = {"file":value[1].filename,
+            result = {"filename":value[1].filename,
                       "line": value[1].lineno,
                       "function": value[1].function,
                       "code_context": value[1].code_context[0].strip(),
@@ -226,7 +224,7 @@ class Log:
     def __setFileName(self, value):
         msg, result = None, True
         try:
-            self.__processo["file"] = value
+            self.__processo["filename"] = value
         except Exception as error:
             msg = error
             result = msg
@@ -255,7 +253,7 @@ class Log:
 
     @property
     def CALL_FILE(self):
-        return self.__call_origin["file"]
+        return self.__call_origin["filename"]
 
     @property
     def CALL_CONTEXT(self):
@@ -287,28 +285,28 @@ class Log:
         try:
             owner = ""
             stmt = f"""
-                    Insert into {owner}LOG
+                    Insert into {self.TABLE_LOG}
                                  (HASH
                                  ,NOM_ROTINA
                                  ,NOM_SUBROTINA
                                  ,DESCRICAO
-                                 ,FILE
-                                 ,OS_USER
-                                 ,USER_DB
+                                 ,"FILE"
+                                 ,"OS_USER"
+                                 ,"USER_DB"
                                  ,LOCAL_IP
                                  ,LOCAL_NAME
                                  ,PROCESSOR
                                  ,SO_PLATFORM
                                  ,SO_SYSTEM
                                  ,SO_VERSION
-                                 ,TIMESTAMP
+                                 ,"TIMESTAMP"
                                  ,VERSAO
                                  )
                            VALUES(:hash
                                  ,:nom_rotina
                                  ,:nom_subrotina
                                  ,:descricao
-                                 ,:file
+                                 ,:filename
                                  ,:os_user
                                  ,:user_db                                 
                                  ,:local_ip
@@ -317,18 +315,22 @@ class Log:
                                  ,:so_platform
                                  ,:so_system
                                  ,:so_version
-                                 ,:timestamp
+                                 ,to_timestamp(:datahoralog, '{dtu.MILLISECONDS_FORMAT_SQL}')
                                  ,:versao
                                  )                                 
                     """
             if self.CONN is not None:
                 __head = self.LOG_HEADER
                 del(__head["event_content"])
-                self.CONN.execute(stmt, __head)
+                cur = self.CONN.cursor()
+                cur.execute(stmt, __head)
                 self.CONN.commit()
+                cur.close()
+                #self.CONN.close()
                 result = "Log HEADER criado!"
             else:
-                raise Exception("Não foi fornecido uma conexao com banco de dados!")
+                ...
+                #raise Exception("Não foi fornecido uma conexao com banco de dados!")
         except Exception as error:
             msg = error
             result = msg
@@ -341,10 +343,10 @@ class Log:
         try:
             owner = ""
             stmt = f"""
-                    Insert into {owner}LOG_EVENT
+                    Insert into {self.TABLE_EVENT}
                                  (HASH
                                  ,HASH_PARENT
-                                 ,TIMESTAMP
+                                 ,"TIMESTAMP"
                                  ,LEVEL_CODE
                                  ,LEVEL_NAME
                                  ,FUNCTION_NAME
@@ -356,7 +358,7 @@ class Log:
                                  )
                            VALUES(:hash
                                  ,:hash_parent
-                                 ,:timestamp
+                                 ,to_timestamp(:datahoralog, '{dtu.MILLISECONDS_FORMAT_SQL}')
                                  ,:level_code
                                  ,:level_name
                                  ,:function_name
@@ -369,11 +371,15 @@ class Log:
                     """
             if self.CONN is not None:
                 __detail = self.LOG_DETAIL
-                self.CONN.executemany(stmt, __detail)
+                cur = self.CONN.cursor()
+                cur.executemany(stmt, (__detail))
                 self.CONN.commit()
+                cur.close()
+                #self.CONN.close()
                 result = "Log DETAIL criado!"
             else:
-                raise Exception("Não foi fornecido uma conexao com banco de dados!")
+                ...
+                #raise Exception("Não foi fornecido uma conexao com banco de dados!")
         except Exception as error:
             msg = error
             result = msg
@@ -468,3 +474,18 @@ class Log:
             return result
     #endregion
 
+    @property
+    def TABLE_LOG(self):
+        return self.__TABLE_LOG
+
+    @TABLE_LOG.setter
+    def TABLE_LOG(self, value):
+        self.__TABLE_LOG = value
+
+    @property
+    def TABLE_EVENT(self):
+        return self.__TABLE_EVENT
+
+    @TABLE_EVENT.setter
+    def TABLE_EVENT(self, value):
+        self.__TABLE_EVENT = value

DE_Lib/Utils/Cipher/Fernet.py

@@ -8,11 +8,11 @@ class FERNET:
         self.__cipher = None
 
     # -----------------------------------
-    def encrypt(self, word:str, token: str):
+    def encrypt(self, word:str):
         msg, result = None, None
         try:
             #x = Fernet(key)
-            result = self.CIPHER.encrypt(word.encode())
+            result = self.CIPHER.encrypt(word.encode()).hex()
         except Exception as error:
             msg = error
             result = msg
@@ -23,7 +23,8 @@ class FERNET:
     def decrypt(self, word):
         msg, result = None, True
         try:
-            result = self.CIPHER.decrypt(word).decode()
+            bytes_word = bytes.fromhex(word).decode()
+            result = self.CIPHER.decrypt(bytes_word).decode()
         except Exception as error:
             msg = error
             result = msg
@@ -39,7 +40,7 @@ class FERNET:
         # serao perdidas.
         msg, result = None, True
         try:
-            self.__token = Fernet.generate_key()
+            self.__token = Fernet.generate_key().hex()
             result = self.TOKEN
         except Exception as error:
             msg = error
@@ -51,7 +52,7 @@ class FERNET:
     def setToken(self, token):
         msg, result = None, True
         try:
-            self.__token = token
+            self.__token = bytes.fromhex(token)
         except Exception as error:
             msg = error
             result = msg
@@ -79,3 +80,23 @@ class FERNET:
     def CIPHER(self):
         return Fernet(self.TOKEN)
 
+
+if __name__ == "__main__":
+    x = FERNET()
+    token = x.setBuildToken()
+
+    # __token =  "cXBRJulOb_arFkWjsOZF0JprhAb0FjsC5xRTcn63WQE="
+    # x.setToken(__token)
+    # print("Token: ",x.TOKEN)
+    #
+    # __root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..",".."))
+    # __file = os.path.join(__root, "config", "tokens", "base_conexao.json")
+    # __buffer = open(__file, "r").read()
+    # __word = __buffer
+    #
+    # #__word = "teste "*1000
+    # print("__word:" ,__word)
+    # __ENCRYPT = x.encrypt(word=__word)
+    # print("Encrypt: ",__ENCRYPT)
+    # __DECRYPT = x.decrypt(__ENCRYPT)
+    # print("Decrypt: ", __DECRYPT)

DE_Lib/Utils/Colors.py

@@ -1,5 +1,5 @@
 
-class Colors:
+class COLORS:
     def __init__(self):
         ...
 

DE_Lib/Utils/DateUtils.py

@@ -2,7 +2,7 @@ import datetime as dt
 from datetime import timedelta
 from dateutil.relativedelta import relativedelta
 
-class DateUtils:
+class DATEUTILS:
     def __init__(self):
         ...
 
@@ -187,7 +187,7 @@ class DateUtils:
 
     @property
     def MILLISECONDS_FORMAT_PYTHON(self):
-        return "%Y-%m-%d %H:%M:%S:%f"
+        return "%Y-%m-%d %H:%M:%S.%f"
 
     @property
     def TIME_FORMAT_PYTHON(self):
@@ -203,7 +203,7 @@ class DateUtils:
 
     @property
     def MILLISECONDS_FORMAT_SQL(self):
-        return "YYYY-MM-DD HH24:MI:SS:FF6"
+        return "YYYY-MM-DD HH24:MI:SS.FF6"
 
     @property
     def TIME_FORMAT_SQL(self):