rpa-suite 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

rpa_suite/core/log.py

@@ -0,0 +1,304 @@
+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 loguru import logger
+import sys, os, inspect
+
+
+class Filters():
+    word_filter: Op[list[str]]
+
+    def __call__(self, record):
+
+        if 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():
+    def __init__(self, formatter):
+        self.formatter = formatter
+
+    def write(self, message):
+        frame = inspect.currentframe().f_back.f_back
+        log_msg = self.formatter.format(message, frame)
+        sys.stderr.write(log_msg)
+
+
+class CustomFormatter:
+    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,
+            filename=filename,
+            lineno=lineno,
+            message=record["message"]
+        )
+        return log_msg
+
+
+
+
+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):
+
+        """
+        Function responsible for create a object logger with fileHandler and streamHandler
+        """
+
+        try:
+
+            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']
+
+
+            # ATRIBUIÇÕES
+            new_filter: Op[Filters] = None
+            if filter_words is not None:
+                new_filter: Filters = Filters()
+                new_filter.word_filter = [filter_words]
+
+
+            # 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>"
+
+
+            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)
+
+            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.
+        """
+
+        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)}')
+
+        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}')
+
+        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.
+        """
+
+        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.
+        """
+
+        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.
+        """
+
+        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.
+        """
+
+        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)
+
+        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.
+        """
+
+        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).critical(msg)
+
+        except Exception as e:
+            error_print(f'Erro durante a função: {self.log_critical.__name__}! Error: {str(e)}')
+

rpa_suite/core/print.py

@@ -0,0 +1,197 @@
+
+# /printer.py
+
+from colorama import Fore
+
+# Windows bash colors
+class Colors():
+    black     = f'{Fore.BLACK}'
+    blue      = f'{Fore.BLUE}'
+    green     = f'{Fore.GREEN}'
+    cyan      = f'{Fore.CYAN}'
+    red       = f'{Fore.RED}'
+    magenta   = f'{Fore.MAGENTA}'
+    yellow    = f'{Fore.YELLOW}'
+    white     = f'{Fore.WHITE}'
+    default   = f'{Fore.WHITE}'
+    call_fn   = f'{Fore.LIGHTMAGENTA_EX}'
+    retur_fn  = f'{Fore.LIGHTYELLOW_EX}'
+
+class Print():
+    
+    colors: Colors = Colors
+    
+    def __init__(self):
+        ...
+    
+    
+    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) 
+
+
+    def alert_print(self,
+                    string_text: str,
+                    color=Colors.yellow,
+                    ending="\n") -> None:
+        """
+        Print that indicates ``ALERT``. Customized with the color Yellow \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``ALERTA``. Personalizado com a cor Amarelo \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def info_print(self,
+                    string_text: str,
+                    color=Colors.cyan,
+                    ending="\n") -> None:
+        """
+        Print that indicates ``INFORMATION``. Customized with the color Cyan \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``INFORMATIVO``. Personalizado com a cor Ciano \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def error_print(self, 
+                    string_text: str, 
+                    color=Colors.red, 
+                    ending="\n") -> None:
+        """
+        Print that indicates ``ERROR``. Customized with the color Red \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``ERRO``. Personalizado com a cor Vermelho \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def magenta_print(self, 
+                        string_text: str,
+                        color=Colors.magenta,
+                        ending="\n") -> None:
+        """
+        Print customized with the color Magenta \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado com a cor Magenta \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def blue_print(self,
+                    string_text: str, 
+                    color=Colors.blue, 
+                    ending="\n") -> None:
+        """
+        Print customized with the color Blue \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado com a cor Azul \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+
+
+    def print_call_fn(self, 
+                        string_text: str, 
+                        color=Colors.call_fn, 
+                        ending="\n") -> None:
+        """
+        Print customized for function called (log) \n
+        Color: Magenta Light
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado para log de chamada de função. \n
+        Cor: Magenta Light
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+
+
+    def print_retur_fn(self, 
+                        string_text: str, 
+                        color=Colors.retur_fn, 
+                        ending="\n") -> None:
+        """
+        Print customized for function return (log) \n
+        Color: Yellow Light
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado para log de chamada de função. \n
+        Cor: Yellow Light
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+

rpa_suite/core/regex.py

@@ -0,0 +1,62 @@
+
+import re
+from rpa_suite.functions._printer import error_print, success_print
+
+class Regex():
+    
+    def __init__(self):
+        ...
+    
+    def check_pattern_in_text(self,
+                            origin_text: str,
+                            pattern_to_search: str, 
+                            case_sensitive: bool = True,
+                            display_message: bool = False) -> bool:
+
+        """
+        Function responsible for searching in a string ``origin_text`` a pattern ``pattern_to_search`` and returning True if the pattern is found, otherwise False. ``case_sensitive`` used for exact cases or cases with diferencce upper and lower cases
+
+        Return:
+        ----------
+        A boolean indicating whether the pattern was found in the text.
+
+        Description: pt-br
+        ----------
+        Função responsável por buscar em um texto de leitura humana uma string ``origin_text`` por um padrão ``pattern_to_search`` e retornar True se o padrão for encontrado, caso contrário, False. ``case_sensitive`` usado para casos exatos ou casos com diferença entre caixa alta e baixa nos caracteres.
+
+        Retorno:
+        ----------
+        Um booleano indicando se o padrão foi encontrado no texto.
+        """
+
+        try:
+
+            if case_sensitive:
+                
+                # Check if the pattern is found in the text
+                if re.search(pattern_to_search, origin_text):
+                    if display_message: success_print(f'Pattern found successfully!')
+                    return True
+                
+                else:
+                    if display_message: success_print(f'Pattern not found.')
+                    return False
+            else:
+                
+                # normalize text to search without case sensitive
+                origin_text = origin_text.lower()
+                pattern_to_search = pattern_to_search.lower()
+                
+                # Check if the pattern is found in the text
+                if re.search(pattern_to_search, origin_text):
+                    if display_message: success_print(f'Pattern found successfully!')
+                    return True
+                
+                else:
+                    if display_message: success_print(f'Pattern not found.')
+                    return False
+                
+        except Exception as e:
+            
+            error_print(f"Error function: {self.check_pattern_in_text.__name__} when trying to check pattern in text. Error: {str(e)}")
+            return False