rpa-suite 1.5.3__py3-none-any.whl → 1.5.4__py3-none-any.whl

rpa_suite/core/parallel.py

@@ -7,25 +7,24 @@ import time
 import traceback
 
 # Define a generic type for the function return
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class ParallelRunner(Generic[T]):
-    
     """
     Class to execute functions in parallel while maintaining the main application flow.
-    
+
     Allows starting a function in a separate process and retrieving its result later.
-    
+
     pt-br
     ------
     Classe para executar funções em paralelo mantendo o fluxo principal da aplicação.
-    
+
     Permite iniciar uma função em um processo separado e obter seu resultado posteriormente.
     """
-    
+
     display_message = None
-    
+
     def __init__(self, display_message: bool = False):
         """
         Initializes the ParallelRunner.
@@ -40,13 +39,13 @@ class ParallelRunner(Generic[T]):
         Args:
             display_message (bool): Se True, exibe mensagens de debug durante a execução.
         """
-        
+
         self._manager = Manager()
         self._result_dict = self._manager.dict()
         self._process = None
         self._start_time = None
         self.display_message = display_message
-        
+
     @staticmethod
     def _execute_function(function, args, kwargs, result_dict):
         """
@@ -61,24 +60,24 @@ class ParallelRunner(Generic[T]):
         try:
             # Executa a função do usuário com os argumentos fornecidos
             result = function(*args, **kwargs)
-            
+
             # Armazena o resultado no dicionário compartilhado
-            result_dict['status'] = 'success'
-            result_dict['result'] = result
-            
+            result_dict["status"] = "success"
+            result_dict["result"] = result
+
             # Para debug
-            #print(f"[Processo Filho] Resultado calculado: {result}")
-            #print(f"[Processo Filho] Dicionário de resultados: {dict(result_dict)}")
-            
+            # print(f"[Processo Filho] Resultado calculado: {result}")
+            # print(f"[Processo Filho] Dicionário de resultados: {dict(result_dict)}")
+
         except Exception as e:
             # Em caso de erro, armazena informações sobre o erro
-            result_dict['status'] = 'error'
-            result_dict['error'] = str(e)
-            result_dict['traceback'] = traceback.format_exc()
-            
+            result_dict["status"] = "error"
+            result_dict["error"] = str(e)
+            result_dict["traceback"] = traceback.format_exc()
+
             # Para debug
             print(f"[Processo Filho] Erro ocorrido: {str(e)}")
-        
+
     @staticmethod
     def _execute_function_w_disp_msg(function, args, kwargs, result_dict):
         """
@@ -93,101 +92,102 @@ class ParallelRunner(Generic[T]):
         try:
             # Executa a função do usuário com os argumentos fornecidos
             result = function(*args, **kwargs)
-            
+
             # Armazena o resultado no dicionário compartilhado
-            result_dict['status'] = 'success'
-            result_dict['result'] = result
-            
+            result_dict["status"] = "success"
+            result_dict["result"] = result
+
             # Para debug
             print(f"[Processo Filho] Resultado calculado: {result}")
             print(f"[Processo Filho] Dicionário de resultados: {dict(result_dict)}")
-            
+
         except Exception as e:
             # Em caso de erro, armazena informações sobre o erro
-            result_dict['status'] = 'error'
-            result_dict['error'] = str(e)
-            result_dict['traceback'] = traceback.format_exc()
-            
+            result_dict["status"] = "error"
+            result_dict["error"] = str(e)
+            result_dict["traceback"] = traceback.format_exc()
+
             # Para debug
-            print(f"[Processo Filho] Erro ocorrido: {str(e)}")   
-    
-    
-    def run(self, function: Callable[..., T], *args, **kwargs) -> 'ParallelRunner[T]':
+            print(f"[Processo Filho] Erro ocorrido: {str(e)}")
+
+    def run(self, function: Callable[..., T], *args, **kwargs) -> "ParallelRunner[T]":
         """
         Starts the execution of the function in a parallel process.
-        
+
         Args:
             function: Function to be executed in parallel
             *args: Positional arguments for the function
             **kwargs: Keyword arguments for the function
-            
+
         Returns:
             self: Returns the instance itself to allow chained calls
 
         pt-br
         ------
         Inicia a execução da função em um processo paralelo.
-        
+
         Args:
             function: Função a ser executada em paralelo
             *args: Argumentos posicionais para a função
             **kwargs: Argumentos nomeados para a função
-            
+
         Returns:
             self: Retorna a própria instância para permitir chamadas encadeadas
         """
         # Limpar resultado anterior, se houver
         if self._result_dict:
             self._result_dict.clear()
-        
+
         # Configura valores iniciais no dicionário compartilhado
-        self._result_dict['status'] = 'running'
-        
+        self._result_dict["status"] = "running"
+
         # Inicia o processo com a função auxiliar estática
         if self.display_message:
             self._process = Process(
-                target=ParallelRunner._execute_function_w_disp_msg, 
-                args=(function, args, kwargs, self._result_dict)
+                target=ParallelRunner._execute_function_w_disp_msg,
+                args=(function, args, kwargs, self._result_dict),
             )
         else:
             self._process = Process(
-                target=ParallelRunner._execute_function, 
-                args=(function, args, kwargs, self._result_dict)
+                target=ParallelRunner._execute_function,
+                args=(function, args, kwargs, self._result_dict),
             )
-        
+
         self._process.daemon = True  # Processo filho termina quando o principal termina
         self._process.start()
         self._start_time = time.time()
-        
+
         return self
 
     def is_running(self) -> bool:
         """
         Checks if the process is still running.
-        
+
         Returns:
             bool: True if the process is still running, False otherwise
-        
+
         pt-br
         ------
         Verifica se o processo ainda está em execução.
-        
+
         Retorna:
             bool: True se o processo ainda estiver em execução, False caso contrário
         """
         if self._process is None:
             return False
         return self._process.is_alive()
-    
-    def get_result(self, timeout: Optional[float] = 60, terminate_on_timeout: bool = True) -> Dict[str, Any]:
+
+    def get_result(
+        self, timeout: Optional[float] = 60, terminate_on_timeout: bool = True
+    ) -> Dict[str, Any]:
         """
         Retrieves the result of the parallel execution.
-        
+
         Args:
             timeout: Maximum time (in seconds) to wait for the process to finish.
             None means wait indefinitely.
             terminate_on_timeout: If True, terminates the process if the timeout is reached.
-            
+
         Returns:
             - Dict containing:
             - success: bool indicating if the operation was successful.
@@ -196,17 +196,17 @@ class ParallelRunner(Generic[T]):
             - traceback: full stack trace (if an error occurred).
             - execution_time: execution time in seconds.
             - terminated: True if the process was terminated due to timeout.
-        
+
         pt-br
         ------
-        
+
         Recupera o resultado da execução paralela.
-        
+
         Args:
             timeout: Tempo máximo (em segundos) para aguardar o término do processo.
             None significa aguardar indefinidamente.
             terminate_on_timeout: Se True, termina o processo se o tempo limite for atingido.
-            
+
         Retorna:
             - Dicionário contendo:
             - success: bool indicando se a operação foi bem-sucedida.
@@ -216,63 +216,73 @@ class ParallelRunner(Generic[T]):
             - execution_time: tempo de execução em segundos.
             - terminated: True se o processo foi terminado devido ao tempo limite.
         """
-        
+
         if self._process is None:
             return {
-                'success': False, 
-                'error': 'Nenhum processo foi iniciado',
-                'execution_time': 0,
-                'terminated': False
+                "success": False,
+                "error": "Nenhum processo foi iniciado",
+                "execution_time": 0,
+                "terminated": False,
             }
-        
+
         # Aguarda o processo terminar com tempo limite
         self._process.join(timeout=timeout)
         execution_time = time.time() - self._start_time
-        
+
         # Preparamos o dicionário de resposta
-        result = {
-            'execution_time': execution_time,
-            'terminated': False
-        }
-        
+        result = {"execution_time": execution_time, "terminated": False}
+
         # Debug - mostra o dicionário compartilhado
-        if self.display_message: print(f"[Processo Principal] Dicionário compartilhado: {dict(self._result_dict)}")
-        
+        if self.display_message:
+            print(
+                f"[Processo Principal] Dicionário compartilhado: {dict(self._result_dict)}"
+            )
+
         # Verifica se o processo terminou ou se atingiu o timeout
         if self._process.is_alive():
             if terminate_on_timeout:
                 self._process.terminate()
-                self._process.join(timeout=1)  # Pequeno timeout para garantir que o processo termine
-                result['terminated'] = True
-                result['success'] = False
-                result['error'] = f'Operação cancelada por timeout após {execution_time:.2f} segundos'
+                self._process.join(
+                    timeout=1
+                )  # Pequeno timeout para garantir que o processo termine
+                result["terminated"] = True
+                result["success"] = False
+                result["error"] = (
+                    f"Operação cancelada por timeout após {execution_time:.2f} segundos"
+                )
             else:
-                result['success'] = False
-                result['error'] = f'Operação ainda em execução após {execution_time:.2f} segundos'
+                result["success"] = False
+                result["error"] = (
+                    f"Operação ainda em execução após {execution_time:.2f} segundos"
+                )
         else:
             # Processo terminou normalmente - verificamos o status
-            status = self._result_dict.get('status', 'unknown')
-            
-            if status == 'success':
-                result['success'] = True
+            status = self._result_dict.get("status", "unknown")
+
+            if status == "success":
+                result["success"] = True
                 # Garantimos que o resultado está sendo copiado corretamente
-                if 'result' in self._result_dict:
-                    result['result'] = self._result_dict['result']
+                if "result" in self._result_dict:
+                    result["result"] = self._result_dict["result"]
                 else:
-                    result['success'] = False
-                    result['error'] = 'Resultado não encontrado no dicionário compartilhado'
+                    result["success"] = False
+                    result["error"] = (
+                        "Resultado não encontrado no dicionário compartilhado"
+                    )
             else:
-                result['success'] = False
-                result['error'] = self._result_dict.get('error', 'Erro desconhecido')
-                if 'traceback' in self._result_dict:
-                    result['traceback'] = self._result_dict['traceback']
-        
+                result["success"] = False
+                result["error"] = self._result_dict.get("error", "Erro desconhecido")
+                if "traceback" in self._result_dict:
+                    result["traceback"] = self._result_dict["traceback"]
+
         # Finaliza o Manager se o processo terminou e não estamos mais esperando resultado
-        if not self._process.is_alive() and (result.get('success', False) or result.get('terminated', False)):
+        if not self._process.is_alive() and (
+            result.get("success", False) or result.get("terminated", False)
+        ):
             self._cleanup()
-        
+
         return result
-    
+
     def terminate(self) -> None:
         """
         Terminates the running process.
@@ -285,7 +295,7 @@ class ParallelRunner(Generic[T]):
             self._process.terminate()
             self._process.join(timeout=1)
             self._cleanup()
-    
+
     def _cleanup(self) -> None:
         """
         Cleans up resources used by the process.
@@ -294,7 +304,7 @@ class ParallelRunner(Generic[T]):
         ------
         Limpa os recursos utilizados pelo processo.
         """
-        if hasattr(self, '_manager') and self._manager is not None:
+        if hasattr(self, "_manager") and self._manager is not None:
             try:
                 self._manager.shutdown()
             except Exception:

rpa_suite/core/print.py

@@ -5,22 +5,21 @@ 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():
-    
+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:
     """
     Class that provides methods for formatted printing in the console, allowing for different types of messages to be displayed with specific colors.
 
@@ -35,7 +34,7 @@ class Print():
     ----------
         >>> from rpa_suite import rpa
         >>> rpa.alert_print('Hello World')
-    
+
     pt-br
     ----
 
@@ -53,16 +52,12 @@ class Print():
     >>> from rpa_suite import rpa
     >>> rpa.alert_print('Hello World')
     """
+
     colors: Colors = Colors
-    
-    def __init__(self):
-        ...
-    
-    
-    def success_print(self,
-                    string_text: str,
-                    color=Colors.green,
-                    ending="\n") -> None:
+
+    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
 
@@ -78,13 +73,9 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending) 
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def alert_print(self,
-                    string_text: str,
-                    color=Colors.yellow,
-                    ending="\n") -> None:
+    def alert_print(self, string_text: str, color=Colors.yellow, ending="\n") -> None:
         """
         Print that indicates ``ALERT``. Customized with the color Yellow \n
 
@@ -99,13 +90,9 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending) 
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def info_print(self,
-                    string_text: str,
-                    color=Colors.cyan,
-                    ending="\n") -> None:
+    def info_print(self, string_text: str, color=Colors.cyan, ending="\n") -> None:
         """
         Print that indicates ``INFORMATION``. Customized with the color Cyan \n
 
@@ -120,13 +107,9 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending) 
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-
-    def error_print(self, 
-                    string_text: str, 
-                    color=Colors.red, 
-                    ending="\n") -> None:
+    def error_print(self, string_text: str, color=Colors.red, ending="\n") -> None:
         """
         Print that indicates ``ERROR``. Customized with the color Red \n
 
@@ -141,13 +124,11 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending) 
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def magenta_print(self, 
-                        string_text: str,
-                        color=Colors.magenta,
-                        ending="\n") -> None:
+    def magenta_print(
+        self, string_text: str, color=Colors.magenta, ending="\n"
+    ) -> None:
         """
         Print customized with the color Magenta \n
 
@@ -162,13 +143,9 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending) 
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def blue_print(self,
-                    string_text: str, 
-                    color=Colors.blue, 
-                    ending="\n") -> None:
+    def blue_print(self, string_text: str, color=Colors.blue, ending="\n") -> None:
         """
         Print customized with the color Blue \n
 
@@ -183,13 +160,11 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending)
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-
-    def print_call_fn(self, 
-                        string_text: str, 
-                        color=Colors.call_fn, 
-                        ending="\n") -> None:
+    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
@@ -205,13 +180,11 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending)
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def print_retur_fn(self, 
-                        string_text: str, 
-                        color=Colors.retur_fn, 
-                        ending="\n") -> None:
+    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
@@ -227,5 +200,4 @@ class Print():
         ----------
             >>> type:None
         """
-        print(f'{color}{string_text}{Colors.default}', end=ending)
-
+        print(f"{color}{string_text}{Colors.default}", end=ending)

rpa_suite/core/regex.py

@@ -7,7 +7,7 @@ from rpa_suite.functions._printer import error_print, success_print
 import re
 
 
-class Regex():
+class Regex:
     """
     Class that provides utilities for working with regular expressions.
 
@@ -27,15 +27,16 @@ class Regex():
 
     A classe Regex é parte do RPA Suite e pode ser usada para aprimorar as capacidades de processamento de texto.
     """
-    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:
 
+    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
 
@@ -55,31 +56,37 @@ class Regex():
         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!')
+                    if display_message:
+                        success_print(f"Pattern found successfully!")
                     return True
-                
+
                 else:
-                    if display_message: success_print(f'Pattern not found.')
+                    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!')
+                    if display_message:
+                        success_print(f"Pattern found successfully!")
                     return True
-                
+
                 else:
-                    if display_message: success_print(f'Pattern not found.')
+                    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
+
+            error_print(
+                f"Error function: {self.check_pattern_in_text.__name__} when trying to check pattern in text. Error: {str(e)}"
+            )
+            return False