rpa-suite 1.4.2__py3-none-any.whl → 1.4.6__py3-none-any.whl

rpa_suite/core/log.py

@@ -1,91 +1,24 @@
 from typing import Optional as Op
-from ..functions.__create_log_dir import _create_log_dir
-from rpa_suite.functions._printer import error_print, alert_print
+from rpa_suite.functions._printer import error_print, alert_print, success_print
 from loguru import logger
 import sys, os, inspect
 
 
-class Filters():
-    """
-    Class that provides utilities for filtering log messages based on specific keywords.
-
-    This class allows you to define a list of words that, if found in a log message, will trigger a modification of that message. 
-    The modified message will indicate that it has been altered due to the presence of a filtered word.
-
-    Methods:
-        __call__: Checks if any of the specified words are present in the log message and alters the message if a match is found.
-
-    Example:
-        >>> filter = Filters()
-        >>> filter.word_filter = ['error', 'warning']
-        >>> record = {"message": "This is an error message."}
-        >>> filter(record)  # This will alter the message to 'Log Alterado devido a palavra Filtrada!'
-
-    pt-br
-    ----------
-    Classe que fornece utilitários para filtrar mensagens de log com base em palavras-chave específicas.
-
-    Esta classe permite que você defina uma lista de palavras que, se encontradas em uma mensagem de log, acionarão uma modificação dessa mensagem. 
-    A mensagem modificada indicará que foi alterada devido à presença de uma palavra filtrada.
-
-    Métodos:
-        __call__: Verifica se alguma das palavras especificadas está presente na mensagem de log e altera a mensagem se uma correspondência for encontrada.
-
-    Exemplo:
-        >>> filtro = Filters()
-        >>> filtro.word_filter = ['erro', 'aviso']
-        >>> registro = {"message": "Esta é uma mensagem de erro."}
-        >>> filtro(registro)  # Isso alterará a mensagem para 'Log Alterado devido a palavra Filtrada!'
-    """
-
+class Filters:
     word_filter: Op[list[str]]
 
     def __call__(self, record):
-
-        if len(self.word_filter) > 0:
-
+        if self.word_filter and len(self.word_filter) > 0:
             for words in self.word_filter:
-
                 string_words: list[str] = [str(word) for word in words]
-
                 for word in string_words:
                     if word in record["message"]:
                         record["message"] = 'Log Alterado devido a palavra Filtrada!'
                         return True
-
         return True
 
 
-class CustomHandler():
-    """
-    Class that provides a custom logging handler to manage log messages.
-    
-    This class allows for the formatting and writing of log messages to a specified output. 
-    It utilizes a custom formatter to structure the log messages, including details such as 
-    the time of logging, log level, and the message itself.
-
-    Methods:
-        write: Writes the formatted log message to the output.
-
-    Example:
-        >>> handler = CustomHandler(formatter=CustomFormatter())
-        >>> handler.write({"time": "12:00", "level": "INFO", "message": "This is a log message."})
-
-    pt-br
-    ----------
-    Classe que fornece um manipulador de log personalizado para gerenciar mensagens de log.
-    
-    Esta classe permite a formatação e escrita de mensagens de log em uma saída especificada. 
-    Ela utiliza um formatador personalizado para estruturar as mensagens de log, incluindo detalhes como 
-    o horário do log, nível de log e a própria mensagem.
-
-    Métodos:
-        write: Escreve a mensagem de log formatada na saída.
-
-    Exemplo:
-        >>> manipulador = CustomHandler(formatter=CustomFormatter())
-        >>> manipulador.write({"time": "12:00", "level": "INFO", "message": "Esta é uma mensagem de log."})
-    """
+class CustomHandler:
     def __init__(self, formatter):
         self.formatter = formatter
 
@@ -96,63 +29,14 @@ class CustomHandler():
 
 
 class CustomFormatter:
-    """
-    Class that provides a custom formatter for log messages.
-    
-    This class is responsible for formatting log messages in a structured way, 
-    allowing for easy readability and understanding of log entries. It formats 
-    the log messages to include details such as the time of logging, log level, 
-    the filename, line number, and the actual log message.
-
-    Methods:
-        format: Formats the log message based on the provided record.
-
-    Example:
-        >>> formatter = CustomFormatter()
-        >>> log_message = formatter.format({
-        ...     "time": "12:00",
-        ...     "level": "INFO",
-        ...     "message": "This is a log message."
-        ... })
-        >>> print(log_message)
-
-    pt-br
-    ----------
-    Classe que fornece um formatador personalizado para mensagens de log.
-    
-    Esta classe é responsável por formatar mensagens de log de maneira estruturada, 
-    permitindo fácil leitura e compreensão das entradas de log. Ela formata 
-    as mensagens de log para incluir detalhes como o horário do log, nível de log, 
-    o nome do arquivo, número da linha e a mensagem de log real.
-
-    Métodos:
-        format: Formata a mensagem de log com base no registro fornecido.
-
-    Exemplo:
-        >>> formatador = CustomFormatter()
-        >>> mensagem_log = formatador.format({
-        ...     "time": "12:00",
-        ...     "level": "INFO",
-        ...     "message": "Esta é uma mensagem de log."
-        ... })
-        >>> print(mensagem_log)
-    """
     def format(self, record):
-
         frame = inspect.currentframe().f_back
         full_path_filename = frame.f_code.co_filename
-
-        # Obtenha o nome do arquivo e o nome da pasta
         filename = os.path.basename(full_path_filename)
         foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-        # Combine o nome da pasta e o nome do arquivo
         filename = os.path.join(foldername, filename)
         lineno = frame.f_lineno
-
-        # Formate a mensagem de log TERMINAL
         format_string = "<green>{time:DD.MM.YY.HH:mm}</green> <level>{level: <8}</level> <level>{message}</level>\n"
-
         log_msg = format_string.format(
             time=record["time"],
             level=record["level"].name,
@@ -163,303 +47,93 @@ class CustomFormatter:
         return log_msg
 
 
-
-
-class Log():
-
-    """
-    Class that provides utilities for logging messages in a structured manner.
-    
-    This class is responsible for managing log entries, allowing for easy tracking 
-    and debugging of application behavior. It supports various logging levels and 
-    can be configured to log messages to different outputs, such as files or the console.
-
-    Methods:
-        config_logger: Configures the logger with specified parameters.
-        
-    Example:
-        >>> logger = Log()
-        >>> logger.config_logger(path_dir='logs', name_log_dir='my_logs', name_file_log='app_log')
-    
-    pt-br
-    ----------
-    Classe que fornece utilitários para registrar mensagens de forma estruturada.
-    
-    Esta classe é responsável por gerenciar entradas de log, permitindo fácil rastreamento 
-    e depuração do comportamento da aplicação. Suporta vários níveis de log e 
-    pode ser configurada para registrar mensagens em diferentes saídas, como arquivos ou console.
-
-    Métodos:
-        config_logger: Configura o logger com parâmetros especificados.
-        
-    Exemplo:
-        >>> logger = Log()
-        >>> logger.config_logger(path_dir='logs', name_log_dir='meus_logs', name_file_log='log_app')
-    """
-    
+class Log:
     filters: Filters
     custom_handler: CustomHandler
     custom_formatter: CustomFormatter
-    
-    
-    def __init__(self):
-        ...
-    
-    def config_logger(self,
-                        path_dir:str = None, 
-                        name_log_dir:str = None, 
-                        name_file_log: str = 'log', 
-                        use_default_path_and_name: bool = True, 
-                        filter_words: list[str] = None):
+    path_dir: str | None = None
+    name_file_log: str | None = None
+    full_path: str | None = None
+    file_handler = None
 
-        """
-        Função responsável por criar um objeto logger com fileHandler e streamHandler
-        
-        pt-br
-        ----------
-        Function responsible for create a object logger with fileHandler and streamHandler
-        """
+    def __init__(self):
+        self.logger = logger
 
+    def config_logger(self, path_dir: str = 'default', name_log_dir: str = 'Logs', name_file_log: str = 'log', filter_words: list[str] = None):
         try:
+            self.path_dir = path_dir
+            self.name_file_log = name_file_log
 
-            if not use_default_path_and_name:
-                result_tryed: dict = _create_log_dir(path_dir, name_log_dir)
-                path_dir = result_tryed['path_created']
-            else:
-                if path_dir == None and name_log_dir == None:
-                    result_tryed: dict = _create_log_dir()
-                    path_dir = result_tryed['path_created']
+            if self.path_dir == 'default':
+                self.path_dir = os.getcwd()
 
+            full_path = os.path.join(self.path_dir, name_log_dir)
+            self.full_path = full_path
 
-            # ATRIBUIÇÕES
-            new_filter: Op[Filters] = None
+            try:
+                os.makedirs(self.full_path, exist_ok=True)
+                success_print(f"Diretório:'{self.full_path}' foi criado com sucesso.")
+            except FileExistsError:
+                alert_print(f"Diretório:'{self.full_path}' já existe.")
+            except PermissionError:
+                alert_print(f"Permissão negada: não é possível criar o diretório '{self.full_path}'.")
+
+            new_filter = None
             if filter_words is not None:
-                new_filter: Filters = Filters()
+                new_filter = Filters()
                 new_filter.word_filter = [filter_words]
 
+            file_handler = os.path.join(self.full_path, f"{self.name_file_log}.log")
+            self.logger.remove()
 
-            # configuração de objetos logger
-            file_handler = fr'{path_dir}\{name_file_log}.log'
-            logger.remove()
-
-            # Formate a mensagem de log FILE
-            log_format: str = "<green>{time:DD.MM.YY.HH:mm}</green> <level>{level: <8}</level> <green>{extra[filename]}</green>:{extra[lineno]: <4} <level>{message}</level>"
-
+            log_format = "<green>{time:DD.MM.YY.HH:mm}</green> <level>{level: <8}</level> <green>{extra[filename]}</green>:{extra[lineno]: <4} <level>{message}</level>"
 
             formatter = CustomFormatter()
-            if new_filter is not None:
-                logger.add(file_handler, filter=new_filter, level="DEBUG", format=log_format)
-            else:
-                logger.add(file_handler, level="DEBUG", format=log_format)
 
-            # Adicione sys.stderr como um manipulador
-            logger.add(sys.stderr, level="DEBUG", format=formatter.format)
+            if new_filter:
+                self.logger.add(file_handler, filter=new_filter, level="DEBUG", format=log_format)
+            else:
+                self.logger.add(file_handler, level="DEBUG", format=log_format)
 
+            self.logger.add(sys.stderr, level="DEBUG", format=formatter.format)
+            self.file_handler = file_handler
             return file_handler
 
         except Exception as e:
-
             error_print(f'Houve um erro durante a execução da função: {self.config_logger.__name__}! Error: {str(e)}.')
             return None
-    
-
-
-    def log_start_run_debug(self,
-                            msg_start_loggin: str) -> None: # represent start application
-
-        """
-        Function responsable to generate ``start run log level debug``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        ----------
-        Função responsável por gerar o nível de log ``início execução nível debug``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
-
-        file_h: False
-
-        try:
-            file_h = self.config_logger()
-
-        except Exception as e:
-
-            error_print(f'Para usar o log_start_run_debug é necessario instanciar file_handler usando o arquivo "logger_uru" em algum arquivo de configuração do seu projeto primeiramente! Error: {str(e)}')
 
+    def _log(self, level: str, msg: str):
         try:
-            try:
-                if file_h:
-                    with open(file_h, 'a') as f:
-                        f.write('\n')
-
-            except Exception as e:
-                alert_print(f'Não foi possivel gerar break_row para log inicial!')
-
-            # logger.debug(f'{msg_start_loggin}')
             frame = inspect.currentframe().f_back
             full_path_filename = frame.f_code.co_filename
-
-            # Obtenha o nome do arquivo e o nome da pasta
             filename = os.path.basename(full_path_filename)
             foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-            # Combine o nome da pasta e o nome do arquivo
             filename = os.path.join(foldername, filename)
             lineno = frame.f_lineno
-
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).debug(f'{msg_start_loggin}')
-
+            self.logger.bind(filename=filename, lineno=lineno).log(level, msg)
         except Exception as e:
-            error_print(f'Erro durante a função: {self.log_start_run_debug.__name__}! Error: {str(e)}')
-
-
-    def log_debug(
-                self,
-                msg: str) -> None:
-
-        """
-        Function responsable to generate log level ``debug``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        -----
-        Função responsável por gerar o nível de log ``debug``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
+            error_print(f'Erro durante a função de log! Error: {str(e)}')
 
+    def log_start_run_debug(self, msg_start_loggin: str) -> None:
         try:
-            frame = inspect.currentframe().f_back
-            full_path_filename = frame.f_code.co_filename
-
-            # Obtenha o nome do arquivo e o nome da pasta
-            filename = os.path.basename(full_path_filename)
-            foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-            # Combine o nome da pasta e o nome do arquivo
-            filename = os.path.join(foldername, filename)
-            lineno = frame.f_lineno
-
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).debug(msg)
-
-        except Exception as e:
-            error_print(f'Erro durante a função: {self.log_debug.__name__}! Error: {str(e)}')
-
-    def log_info(
-                self,
-                msg: str) -> None:
-
-        """
-        Function responsable to generate log level ``info``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        -----
-        Função responsável por gerar o nível de log ``info``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
-
-        try:
-            frame = inspect.currentframe().f_back
-            full_path_filename = frame.f_code.co_filename
-
-            # Obtenha o nome do arquivo e o nome da pasta
-            filename = os.path.basename(full_path_filename)
-            foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-            # Combine o nome da pasta e o nome do arquivo
-            filename = os.path.join(foldername, filename)
-            lineno = frame.f_lineno
-
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).info(msg)
-
-        except Exception as e:
-            error_print(f'Erro durante a função: {self.log_info.__name__}! Error: {str(e)}')
-
-    def log_warning(self, 
-                    msg: str) -> None:
-
-        """
-        Function responsable to generate log level ``warning``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        -----
-        Função responsável por gerar o nível de log ``aviso``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
-
-        try:
-            frame = inspect.currentframe().f_back
-            full_path_filename = frame.f_code.co_filename
-
-            # Obtenha o nome do arquivo e o nome da pasta
-            filename = os.path.basename(full_path_filename)
-            foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-            # Combine o nome da pasta e o nome do arquivo
-            filename = os.path.join(foldername, filename)
-            lineno = frame.f_lineno
-
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).warning(msg)
-
-        except Exception as e:
-            error_print(f'Erro durante a função: {self.log_warning.__name__}! Error: {str(e)}')
-
-
-    def log_error(
-                self, 
-                msg: str) -> None:
-
-        """
-        Function responsable to generate log level ``error``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        -----
-        Função responsável por gerar o nível de log ``erro``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
-
-        try:
-            frame = inspect.currentframe().f_back
-            full_path_filename = frame.f_code.co_filename
-
-            # Obtenha o nome do arquivo e o nome da pasta
-            filename = os.path.basename(full_path_filename)
-            foldername = os.path.basename(os.path.dirname(full_path_filename))
-
-            # Combine o nome da pasta e o nome do arquivo
-            filename = os.path.join(foldername, filename)
-            lineno = frame.f_lineno
-
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).error(msg)
-
+            with open(self.file_handler, "a") as log_file:
+                log_file.write("\n")  # Add a blank line before logging the start message
+            self._log("DEBUG", msg_start_loggin)
         except Exception as e:
-            error_print(f'Erro durante a função: {self.log_error.__name__}! Error: {str(e)}')
-
-
-    def log_critical(self, 
-                    msg: str) -> None:
-
-        """
-        Function responsable to generate log level ``critical``, in file and print on terminal the same log captured on this call.
-        
-        pt-br
-        ----------
-        
-        Função responsável por gerar o nível de log ``crítico``, em arquivo e imprimir no terminal o mesmo log capturado nesta chamada.
-        """
-
-        try:
-            frame = inspect.currentframe().f_back
-            full_path_filename = frame.f_code.co_filename
+            error_print(f'Erro fn: {self.log_start_run_debug.__name__} ao tentar acessar o arquivo de log Confira se foi criado a configuração de log correta com a função config_logger e se a pasta e arquivo estão nos diretório desejado! Error: {str(e)}.')
 
-            # Obtenha o nome do arquivo e o nome da pasta
-            filename = os.path.basename(full_path_filename)
-            foldername = os.path.basename(os.path.dirname(full_path_filename))
+    def log_debug(self, msg: str) -> None:
+        self._log("DEBUG", msg)
 
-            # Combine o nome da pasta e o nome do arquivo
-            filename = os.path.join(foldername, filename)
-            lineno = frame.f_lineno
+    def log_info(self, msg: str) -> None:
+        self._log("INFO", msg)
 
-            # Vincule o nome do arquivo e a linha à mensagem de log
-            logger.bind(filename=filename, lineno=lineno).critical(msg)
+    def log_warning(self, msg: str) -> None:
+        self._log("WARNING", msg)
 
-        except Exception as e:
-            error_print(f'Erro durante a função: {self.log_critical.__name__}! Error: {str(e)}')
+    def log_error(self, msg: str) -> None:
+        self._log("ERROR", msg)
 
+    def log_critical(self, msg: str) -> None:
+        self._log("CRITICAL", msg)

rpa_suite/suite.py

@@ -1,3 +1,5 @@
+# rpa_suite/suite.py
+
 from .core.clock import Clock
 from .core.date import Date
 from .core.email import Email
@@ -7,8 +9,12 @@ from .core.log import Log
 from .core.print import Print
 from .core.regex import Regex
 from .core.validate import Validate
+
 from colorama import Fore
 
+import subprocess
+import sys
+import hashlib
 
 # Windows bash colors
 class Colors():
@@ -122,6 +128,7 @@ class Suite():
         ``validate``: Funções de validação de dados
     """
     
+    # SUBMODULES
     clock: Clock = Clock()
     date: Date = Date()
     email: Email = Email()
@@ -131,30 +138,36 @@ class Suite():
     printer: Print = Print()
     regex: Regex = Regex()
     validate: Validate = Validate()
+
+    
+    
+    # VARIABLES INTERNAL
+    __version__ = '1.4.5'
+    __id_hash__ = 'rpa_suite'
+    
     
     def __init__(self):
-        ...
+        self.__id_hash__ = hashlib.sha256(self.__version__.encode()).hexdigest()
     
     def success_print(self,
-                        string_text: str,
-                        color=Colors.green,
-                        ending="\n") -> None:
-            """
-            Print that indicates ``SUCCESS``. Customized with the color Green \n
-
-            Return:
-            ----------
-                >>> type:None
-
-            pt-br
-            ----------
-            Print  que indica ``SUCESSO``. Personalizado com a cor Verde \n
-
-            Retorno:
-            ----------
-                >>> type:None
-            """
-            print(f'{color}{string_text}{Colors.default}', end=ending) 
+            string_text: str,
+            color=Colors.green,
+            ending="\n") -> None:
+        
+        """
+        Print that indicates ``SUCCESS``. Customized with the color Green \n
+        Return:
+        ----------
+            >>> type:None
+        pt-br
+        ----------
+        Print  que indica ``SUCESSO``. Personalizado com a cor Verde \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
 
 
     def alert_print(self,
@@ -311,8 +324,7 @@ class Suite():
         Metodo responsavel por instalar todas libs para uso avançado do RPA-Suite com todas funcionalidades incluindo OCR e agente de IA
         """
 
-        import subprocess
-        import sys
+        
 
         libs = [
             'colorama',
@@ -334,3 +346,5 @@ class Suite():
 
             except subprocess.CalledProcessError:
                 self.error_print(f'Erro ao instalar biblioteca {lib}')
+
+rpa = Suite()

rpa_suite/utils/__init__.py

@@ -0,0 +1,10 @@
+# rpa_suite/utils/__init__.py
+"""
+The utils module of the rpa-suite provides a collection of utility functions and classes that facilitate various tasks in process automation. It includes helper methods for logging, file handling, and other common operations that enhance the functionality and usability of the RPA Suite.
+
+pt-br
+------
+
+O módulo de utilitários da rpa-suite fornece uma coleção de funções e classes utilitárias que facilitam diversas tarefas na automação de processos. Inclui métodos auxiliares para registro de log, manipulação de arquivos e outras operações comuns que aprimoram a funcionalidade e a usabilidade da RPA Suite.
+
+"""

rpa_suite/utils/system.py

@@ -0,0 +1,33 @@
+from rpa_suite.functions._printer import error_print, success_print
+import sys, os
+
+def set_importable_dir(display_message: bool = False):
+    """
+    Sets the directory to be importable by appending it to the system path.
+
+    Parameters:
+    ----------
+        display_message: bool - If True, displays a success message after setting the directory.
+
+    Returns:
+    ----------
+        None
+
+    pt-br
+    ----------
+    Define o diretório para ser importável, adicionando-o ao caminho do sistema.
+
+    Parâmetros:
+    ----------
+        display_message: bool - Se True, exibe uma mensagem de sucesso após definir o diretório.
+
+    Retornos:
+    ----------
+        Nenhum
+    """
+    try:
+        sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+        if display_message: success_print(f'Successfully set the directory for importation!')
+    except Exception as e:
+        error_print(f'An error occurred while executing the function: {set_importable_dir.__name__}! Error: {str(e)}.')