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

rpa_suite/__init__.py

@@ -1,4 +1,5 @@
 # rpa_suite/__init__.py
+
 """
     RPA Suite is a Python module that provides a set of tools for process automation.
     
@@ -59,5 +60,6 @@
         ``Browser``: Objeto de Automação de Navegadores (necessario Selenium e Webdriver_Manager)
 """
 
+# allows importing the rpa_suite module without the package name
 from .suite import rpa
 rpa

rpa_suite/core/__init__.py

@@ -32,6 +32,8 @@ from .log import Log
 from .print import Print
 from .regex import Regex
 from .validate import Validate
+from .parallel import ParallelRunner
+from .asyncrun import AsyncRunner
 
 
 

rpa_suite/core/asyncrun.py

@@ -0,0 +1,140 @@
+# rpa_suite/core/asyncrun.py
+
+# imports third-party
+from typing import Any, Callable, Dict, Optional, TypeVar, Generic
+import asyncio
+import time
+import traceback
+from functools import wraps
+
+
+T = TypeVar('T')
+
+
+class AsyncRunner(Generic[T]):
+    """
+    Class to execute asynchronous functions while maintaining the main application flow.
+    
+    Allows executing asynchronous functions and retrieving their results later.
+    Optimized for I/O bound operations (network, files, etc).
+    """
+    
+    def __init__(self):
+        """Start AsyncRunner."""
+        self._task = None
+        self._start_time = None
+        self._result = {}
+
+    @staticmethod
+    def _to_async(func: Callable) -> Callable:
+        """
+        Converts a synchronous function into an asynchronous one if necessary.
+        
+        Args:
+            func: The function to be converted.
+        
+        Returns:
+            A callable that is asynchronous.
+        """
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if asyncio.iscoroutinefunction(func):
+                return await func(*args, **kwargs)
+            return await asyncio.to_thread(func, *args, **kwargs)
+        return wrapper
+
+    async def _execute_function(self, function, args, kwargs):
+        """
+        Executes the function and manages results/errors.
+        
+        Args:
+            function: The function to be executed.
+            args: Positional arguments for the function.
+            kwargs: Keyword arguments for the function.
+        """
+        try:
+            async_func = self._to_async(function)
+            result = await async_func(*args, **kwargs)
+            
+            self._result = {
+                'status': 'success',
+                'result': result,
+                'success': True
+            }
+            
+        except Exception as e:
+            self._result = {
+                'status': 'error',
+                'error': str(e),
+                'traceback': traceback.format_exc(),
+                'success': False
+            }
+
+    def run(self, function: Callable[..., T], *args, **kwargs) -> 'AsyncRunner[T]':
+        """
+        Starts the execution of the function asynchronously.
+        
+        Args:
+            function: The function to be executed.
+            *args: Positional arguments for the function.
+            **kwargs: Keyword arguments for the function.
+        
+        Returns:
+            self: Returns the instance itself.
+        """
+        self._result.clear()
+        self._start_time = time.time()
+        
+        # Creates and schedules the asynchronous task
+        loop = asyncio.get_event_loop()
+        self._task = loop.create_task(self._execute_function(function, args, kwargs))
+        
+        return self
+
+    def is_running(self) -> bool:
+        """
+        Checks if the task is still running.
+        
+        Returns:
+            True if the task is running, False otherwise.
+        """
+        return self._task is not None and not self._task.done()
+
+    async def get_result(self, timeout: Optional[float] = None) -> Dict[str, Any]:
+        """
+        Retrieves the result of the asynchronous execution.
+        
+        Args:
+            timeout: Maximum time (in seconds) to wait.
+        
+        Returns:
+            A dictionary with the result or error information.
+        """
+        if self._task is None:
+            return {
+                'success': False,
+                'error': 'No task has been started',
+                'execution_time': 0
+            }
+
+        try:
+            await asyncio.wait_for(self._task, timeout=timeout)
+            
+        except asyncio.TimeoutError:
+            self._task.cancel()
+            return {
+                'success': False,
+                'error': f'Operation canceled due to timeout after {time.time() - self._start_time:.2f} seconds',
+                'execution_time': time.time() - self._start_time
+            }
+
+        result = dict(self._result)
+        result['execution_time'] = time.time() - self._start_time
+        return result
+
+    def cancel(self) -> None:
+        """
+        Cancels the running task.
+        """
+        if self.is_running():
+            self._task.cancel()

rpa_suite/core/browser.py

@@ -1,16 +1,19 @@
-# default import
-import os, requests
+# rpa_suite/core/browser.py
 
-# imports
+# imports internal
 from rpa_suite.functions._printer import error_print, alert_print, success_print
 
+# imports external
 from selenium import webdriver
 from selenium.webdriver.common.by import By
 from selenium.webdriver.chrome.options import Options
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from webdriver_manager.chrome import ChromeDriverManager
+
+# imports third-party
 from time import sleep
+import os, requests
 
 
 class Browser():
@@ -166,7 +169,7 @@ class Browser():
             error_print(f'Erro ao iniciar navegador: {str(e)}.')
 
 
-    def find_ele(self, value, by=By.XPATH, timeout=12, display_message=True):
+    def find_ele(self, value: str, by:By=By.XPATH, timeout=12, display_message=True):
         """
         Locate and return a web element on the page using the specified locator strategy.
         Args:

rpa_suite/core/clock.py

@@ -1,8 +1,12 @@
+# rpa_suite/core/clock.py
 
+# imports internal
+from rpa_suite.functions._printer import error_print, success_print
+
+# imports third-party
 import time
 from typing import Callable, Any
 from datetime import datetime as dt
-from rpa_suite.functions._printer import error_print, success_print
 from typing import Callable, Any
 
 

rpa_suite/core/date.py

@@ -1,11 +1,16 @@
-# /date.py
+# rpa_suite/core/date.py
 
+# imports internal
+from rpa_suite.functions._printer import error_print
+
+# imports third-party
 import datetime as dt
 from typing import Optional as Op
 from typing import Tuple
-from rpa_suite.functions._printer import error_print
+
 
 class Date():
+    
     """
     Class that provides utilities for date manipulation and formatting.
     

rpa_suite/core/dir.py

@@ -1,7 +1,12 @@
+# rpa_suite/core/dir.py
 
+# imports internal
+from rpa_suite.functions._printer import error_print, alert_print, success_print
+
+# imports third-party
 import os, shutil
 from typing import Union
-from rpa_suite.functions._printer import error_print, alert_print, success_print
+
 
 
 class Directory():

rpa_suite/core/email.py

@@ -1,13 +1,15 @@
-# /sender_smtp.py
+# rpa_suite/core/email.py
 
-import smtplib, os
+# imports internal
+from rpa_suite.functions._printer import alert_print, error_print, success_print
+
+# imports third-party
+import smtplib
 from email.mime.image import MIMEImage
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from email.mime.base import MIMEBase
 from email import encoders
-from rpa_suite.functions._printer import alert_print, error_print, success_print
-from rpa_suite.core.validate import email_validator
 
 
 class Email():

rpa_suite/core/file.py

@@ -1,10 +1,18 @@
-import os, time
-from datetime import datetime
+# rpa_suite/core/file.py
+
+# imports internal
 from rpa_suite.functions._printer import error_print, success_print, alert_print
 from rpa_suite.functions.__create_ss_dir import __create_ss_dir as create_ss_dir
+
+# imports external
 from colorama import Fore
+
+# imports third-party
+import os, time
+from datetime import datetime
 from typing import Dict, List, Union
 
+
 class File():
     """
     Class that provides utilities for file management, including creation, deletion, and manipulation of files.

rpa_suite/core/log.py

@@ -1,6 +1,13 @@
-from typing import Optional as Op
+# rpa_suite/core/log.py
+
+# imports internal
 from rpa_suite.functions._printer import error_print, alert_print, success_print
+
+# imports external
 from loguru import logger
+
+# imports third-party
+from typing import Optional as Op
 import sys, os, inspect
 
 

rpa_suite/core/parallel.py

@@ -0,0 +1,313 @@
+# rpa_suite/core/parallel.py
+
+# imports third-party
+from multiprocessing import Process, Manager
+from typing import Any, Callable, Dict, Optional, TypeVar, Generic
+import time
+import traceback
+
+# Define a generic type for the function return
+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.
+
+        Args:
+            display_message (bool): If True, displays debug messages during execution.
+
+        pt-br
+        ------
+        Inicializa o ParallelRunner.
+
+        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):
+        """
+        Static method that executes the target function and stores the result.
+        This function needs to be defined at the module level to be "picklable".
+
+        pt-br
+        ------
+        Função estática que executa a função alvo e armazena o resultado.
+        Esta função precisa ser definida no nível do módulo para ser "picklable".
+        """
+        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
+            
+            # 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()
+            
+            # Para debug
+            print(f"[Processo Filho] Erro ocorrido: {str(e)}")
+        
+    @staticmethod
+    def _execute_function_w_disp_msg(function, args, kwargs, result_dict):
+        """
+        Static method that executes the target function and stores the result.
+        This function needs to be defined at the module level to be "picklable".
+
+        pt-br
+        ------
+        Função estática que executa a função alvo e armazena o resultado.
+        Esta função precisa ser definida no nível do módulo para ser "picklable".
+        """
+        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
+            
+            # 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()
+            
+            # Para debug
+            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'
+        
+        # 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)
+            )
+        else:
+            self._process = Process(
+                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]:
+        """
+        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.
+            - result: result of the function (if successful).
+            - error: error message (if any).
+            - 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.
+            - result: resultado da função (se bem-sucedida).
+            - error: mensagem de erro (se houver).
+            - traceback: rastreamento completo da pilha (se ocorreu um erro).
+            - 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
+            }
+        
+        # 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
+        }
+        
+        # Debug - mostra o dicionário compartilhado
+        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'
+            else:
+                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
+                # Garantimos que o resultado está sendo copiado corretamente
+                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'
+            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']
+        
+        # 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)):
+            self._cleanup()
+        
+        return result
+    
+    def terminate(self) -> None:
+        """
+        Terminates the running process.
+
+        pt-br
+        ------
+        Termina o processo em execução.
+        """
+        if self._process and self._process.is_alive():
+            self._process.terminate()
+            self._process.join(timeout=1)
+            self._cleanup()
+    
+    def _cleanup(self) -> None:
+        """
+        Cleans up resources used by the process.
+
+        pt-br
+        ------
+        Limpa os recursos utilizados pelo processo.
+        """
+        if hasattr(self, '_manager') and self._manager is not None:
+            try:
+                self._manager.shutdown()
+            except Exception:
+                pass
+            self._manager = None
+        self._process = None
+
+    def __del__(self):
+        """
+        Destructor of the class, ensures resources are released.
+
+        pt-br
+        ------
+        Destrutor da classe, garante que recursos sejam liberados.
+        """
+        self.terminate()

rpa_suite/core/print.py

@@ -1,8 +1,9 @@
+# rpa_suite/core/print.py
 
-# /printer.py
-
+# imports external
 from colorama import Fore
 
+
 # Windows bash colors
 class Colors():
     black     = f'{Fore.BLACK}'
@@ -17,6 +18,7 @@ class Colors():
     call_fn   = f'{Fore.LIGHTMAGENTA_EX}'
     retur_fn  = f'{Fore.LIGHTYELLOW_EX}'
 
+
 class Print():
     
     """

rpa_suite/core/regex.py

@@ -1,7 +1,12 @@
+# rpa_suite/core/regex.py
 
-import re
+# imports internal
 from rpa_suite.functions._printer import error_print, success_print
 
+# imports third-party
+import re
+
+
 class Regex():
     """
     Class that provides utilities for working with regular expressions.

rpa_suite/core/validate.py

@@ -1,8 +1,11 @@
-# /mail_validator.py
+# rpa_suite/core/mail_validator.py
 
-import email_validator
+# imports internal
 from rpa_suite.functions._printer import error_print, success_print
 
+# imports external
+import email_validator
+
 
 class Validate():
 

rpa_suite/functions/__create_ss_dir.py

@@ -1,8 +1,12 @@
-# /_create_ss_dir.py
+# rpa_suite/functions/__create_ss_dir.py
 
+# imports internal
+from rpa_suite.functions._printer import error_print, alert_print, success_print
+
+# imports third-party
 import os
 from typing import Union
-from rpa_suite.functions._printer import error_print, alert_print, success_print
+
 
 
 def __create_ss_dir(path_to_create: str = 'default', name_ss_dir: str='screenshots') -> dict[str, Union[bool, str, None]]:

rpa_suite/functions/_printer.py

@@ -1,7 +1,9 @@
-# /printer.py
+# rpa_suite/functions/_printer.py
 
+# imports external
 from colorama import Fore
 
+
 # Windows bash colors
 class Colors():
     black     = f'{Fore.BLACK}'

rpa_suite/suite.py

@@ -1,5 +1,6 @@
 # rpa_suite/suite.py
 
+# imports internal
 from .core.clock import Clock
 from .core.date import Date
 from .core.email import Email
@@ -9,13 +10,21 @@ from .core.log import Log
 from .core.print import Print
 from .core.regex import Regex
 from .core.validate import Validate
+from .core.parallel import ParallelRunner
+from .core.asyncrun import AsyncRunner
 
+
+# imports external
 from colorama import Fore
+import pkg_resources
 
+# imports third-party
 import subprocess
 import sys
 import hashlib
 
+
+
 # Windows bash colors
 class Colors():
 
@@ -68,6 +77,7 @@ class Colors():
     call_fn   = f'{Fore.LIGHTMAGENTA_EX}'
     retur_fn  = f'{Fore.LIGHTYELLOW_EX}'
 
+
 class Suite():
 
     """
@@ -138,15 +148,30 @@ class Suite():
     printer: Print = Print()
     regex: Regex = Regex()
     validate: Validate = Validate()
-
+    Parallel: ParallelRunner = ParallelRunner
+    Asyn: AsyncRunner = AsyncRunner
+    
+    # On this case, we are importing the Browser class only if the selenium and webdriver_manager modules are installed.
+    # This is useful to avoid unnecessary imports and dependencies if the user does not need the Browser functionality.
+    import importlib.util
+
+    # from .browser import Browser
+    if importlib.util.find_spec("selenium") and importlib.util.find_spec("webdriver_manager"):
+        from .core.browser import Browser
+        browser: Browser = Browser
     
     
     # VARIABLES INTERNAL
-    __version__ = '1.4.5'
+    try:
+        __version__ = pkg_resources.get_distribution("rpa_suite").version
+    except Exception:
+        __version__ = 'unknown'
+    
     __id_hash__ = 'rpa_suite'
     
     
     def __init__(self):
+        self.__id_hash__ = 'rpa_suite'
         self.__id_hash__ = hashlib.sha256(self.__version__.encode()).hexdigest()
     
     def success_print(self,

rpa_suite/utils/__init__.py

@@ -1,4 +1,5 @@
 # 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.
 

rpa_suite/utils/system.py

@@ -1,7 +1,14 @@
+# rpa_suite/utils/system.py
+
+# imports internal
 from rpa_suite.functions._printer import error_print, success_print
+
+# imports third-party
 import sys, os
 
+
 def set_importable_dir(display_message: bool = False):
+    
     """
     Sets the directory to be importable by appending it to the system path.
 
@@ -25,9 +32,11 @@ def set_importable_dir(display_message: bool = False):
     ----------
         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)}.')
+        error_print(f'An error occurred while executing the function: {set_importable_dir.__name__}! Error: {str(e)}.')

{rpa_suite-1.4.6.dist-info → rpa_suite-1.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpa_suite
-Version: 1.4.6
+Version: 1.4.9
 Summary: Conjunto de ferramentas essenciais para Automação RPA com Python, que facilitam o dia a dia de desenvolvimento.
 Author: Camilo Costa de Carvalho
 Author-email: camilo.carvalho@triasoftware.com.br
@@ -26,6 +26,7 @@ Requires-Dist: typing
 Requires-Dist: pillow
 Requires-Dist: pyautogui
 Requires-Dist: requests
+Requires-Dist: setuptools
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -64,7 +65,7 @@ Dynamic: summary
 - [Dependências](#dependências)
 - [Estrutura do módulo](#estrutura-do-módulo)
 - [Release](#release)
-  - [Notas da atualização: 1.4.6](#notas-da-atualização-146)
+  - [Notas da atualização: 1.4.9](#notas-da-atualização-149)
 - [Mais Sobre](#mais-sobre)
 
 ## Destaque
@@ -155,6 +156,7 @@ No setup do nosso projeto já estão inclusas as dependências, só será necess
 - pillow
 - pyautogui
 - typing
+- setuptools
 
   opcionalmente para automação de navegador:
 
@@ -169,23 +171,29 @@ No caso da função de screenshot é necessario ter as libs 'pyautogui' 'pillow'
 O módulo principal do rpa-suite é dividido em categorias. Cada categoria contém módulos com funções destinadas a categoria:
 
 - **rpa_suite**
+  
   - **clock**
     - **exec_at_hour** - Função que executa uma função no horário especificado "xx:yy", permitindo agendamento de tarefas com precisão.
     - **wait_for_exec** - Função que aguarda um tempo em segundos antes de executar a função passada como argumento.
     - **exec_and_wait** - Função que executa uma função e, em seguida, aguarda um tempo em segundos antes de continuar.
+  
   - **date**
     - **get_hms** - Função que retorna hora, minuto e segundo formatados como strings.
     - **get_dmy** - Função que retorna dia, mês e ano formatados como strings.
+  
   - **email**
     - **send_smtp** - Função para envio de emails via SMTP com suporte a anexos e mensagens HTML, configurável e personalizável.
+
   - **file**
     - **screen_shot** - Função para capturar screenshots, criando diretórios e arquivos com nomes e caminhos personalizáveis.
     - **flag_create** - Função para criar arquivos de flag indicando execução de processos.
     - **flag_delete** - Função para deletar arquivos de flag após a execução de processos.
     - **count_files** - Função para contar arquivos em diretórios, com suporte a extensões específicas.
+
   - **directory**
     - **create_temp_dir** - Função para criar diretórios temporários com nomes e caminhos personalizáveis.
     - **delete_temp_dir** - Função para deletar diretórios temporários, com opção de remover arquivos contidos.
+
   - **log**
     - **config_logger** - Função para configurar logs com suporte a arquivos e streams, utilizando a biblioteca Loguru.
     - **log_start_run_debug** - Função para registrar logs de início de execução em nível de depuração.
@@ -194,6 +202,7 @@ O módulo principal do rpa-suite é dividido em categorias. Cada categoria cont
     - **log_warning** - Função para registrar logs em nível de aviso.
     - **log_error** - Função para registrar logs em nível de erro.
     - **log_critical** - Função para registrar logs em nível crítico.
+
   - **printer**
     - **success_print** - Função para imprimir mensagens de sucesso com destaque em verde.
     - **alert_print** - Função para imprimir mensagens de alerta com destaque em amarelo.
@@ -201,18 +210,32 @@ O módulo principal do rpa-suite é dividido em categorias. Cada categoria cont
     - **error_print** - Função para imprimir mensagens de erro com destaque em vermelho.
   - **regex**
     - **check_pattern_in_text** - Função para verificar a presença de padrões em textos, com suporte a case-sensitive.
+  
   - **validate**
     - **emails** - Função para validar listas de emails, retornando listas de emails válidos e inválidos.
     - **word** - Função para buscar palavras ou padrões específicos em textos, com suporte a contagem de ocorrências.
+  
   - **browser**
     - **start_browser** - Função para iniciar o navegador Chrome com suporte a depuração remota.
     - **find_ele** - Função para localizar elementos na página utilizando estratégias de localização do Selenium.
     - **get** - Função para navegar para URLs específicas.
     - **close_browser** - Função para fechar o navegador e encerrar processos relacionados.
 
+  - **parallel**
+    - **run** - Função para iniciar um processo em paralelo.
+    - **is_running** - Função para capturar o status atual do processo que esta rodando em paralelo.
+    - **get_result** - Função para coletar o retorno da execução em paralelo junto com resultado da função ou funções que foram enviadas a este processo com retorno em forma de dict.
+    - **terminate** - Função para finalizar o processo paralelo mantendo apenas o processo principal do seu código, também é chamada de forma automatica esta função ao final de um procesos paralelo ou no final da função "get_result".
+
+  - **async**
+    - **run** - Função para iniciar a execução assíncrona de uma função mantendo o fluxo principal da aplicação.
+    - **is_running** - Função para verificar se a tarefa assíncrona ainda está em execução.
+    - **get_result** - Função para obter o resultado da execução assíncrona, incluindo tempo de execução e status, com suporte a timeout.
+    - **cancel** - Função para cancelar a tarefa assíncrona em execução.
+
 ## Release
 
-Versão: **Beta 1.4.6**
+Versão: **Beta 1.4.9**
 
 Lançamento: *20/02/2024*
 
@@ -220,10 +243,12 @@ Lançamento: *20/02/2024*
 
 Status: Em desenvolvimento.
 
-### Notas da atualização: 1.4.6
+### Notas da atualização: 1.4.9
 
 - Mudança dos submodulos para Objetos, agora Rpa_suite é um Objeto de Suite que compoe diversos sub-objetos separados pelas mesmas categorias anteriormente ja definidas
 - Reformulada a arquitetura do projeto para melhor coeção e menos subpastas e arquivos, agora a estrutura é mais simples e de melhor manutenção contendo apenas uma pasta core para o nucleo de nossos modulos, e uma pasta utils com ferramentas utilitarias que vamos adicionar varias novidades
+- Adicionado SubModulo Parallel com função dedicada a rodar um processo em paralelo com seu fluxo principal podendo recuperar o resultado da execução em paralelo a qualquer momento e setando timeout ou deixando o tempo indefinido para aguardar a resposta.
+- Adicionado SubModulo AsyncRunnner com função dedicada a facilitar uso de funções assincronas podendo recuperar seus resultados usando menos código, é um modulo simples porem poupa-nos tempo. 
 - Adicionado setor utils com funcionalidade de tornar o diretorio atual em um importavel relativo para o python
 - Adicionado Automação de Navegadores! Sim estamos devendo esta feature a bastante tempo, porem estamos com a primeira versão disponivel, em breve teremos mais recursos e disponibilidade para outros navegadores, atualmente suporte apenas para *Chrome.*
 - Mantemos o alerta! **get_dma** atualizada e **renomeada** para **get_dmy** para manter o padrão em ingles

rpa_suite-1.4.9.dist-info/RECORD

@@ -0,0 +1,25 @@
+rpa_suite/__init__.py,sha256=KO6GC2XbZUO56SAOgKxIkycHFEy6oeWPSswd8-B5IP4,2562
+rpa_suite/suite.py,sha256=1lsdFLz44gh7y3leOR5BCsx1dEKam5cm1g7l5RCFsYc,11187
+rpa_suite/core/__init__.py,sha256=oGQiEtmgR9fBHgcAKYsl5eZsS2_SbRZnlhzOgRqXrAM,1713
+rpa_suite/core/asyncrun.py,sha256=S5b-ueG4oJmupBZLsfYqcyTA5k5SaAi8j3KU8NnTOMg,4378
+rpa_suite/core/browser.py,sha256=h1sMERkEw8y8zfQs2hdv2VbBNt3pQlVkMlkQOTKpaKQ,14755
+rpa_suite/core/clock.py,sha256=-ZEEaTYzwoYk9Bw1K6K1RN4s7O21uEhTg2hgBmdYLtQ,13880
+rpa_suite/core/date.py,sha256=0dqkP7zVjWeMmZA5xDZuvin97yYPMl1p0bCfLmtXdlM,6635
+rpa_suite/core/dir.py,sha256=sc_mJGrjo520cmNyC_HZo3YKEbORkBDfD3bCLaQ7U2o,9855
+rpa_suite/core/email.py,sha256=CUqhW8-BF0XS7vFeZieQ13VywEg1TQZVoicEexSQCPE,8671
+rpa_suite/core/file.py,sha256=8eKlOSRptCYDJ-zRrHYK7tnmxR-JjQ55U47BRRdMGRE,11621
+rpa_suite/core/log.py,sha256=7VTPKXzVkWMg1W5bBO6BM3XDihKqNOcB4D-d6ytDbts,5631
+rpa_suite/core/parallel.py,sha256=p5jM7UwLWGYoYuQoUo659469nsuvy9QEkzVhXqu-GnU,11876
+rpa_suite/core/print.py,sha256=jhCNdid67dtVE6cCgRnWjqUrmsJcAr1hN38MHVupgfo,6423
+rpa_suite/core/regex.py,sha256=gh3dlV29chepdoaWsl5yW9Db6MHQTGJeWstm0mD9zKU,3377
+rpa_suite/core/validate.py,sha256=vKpl4u7f8CM30e_1rS6sqUqePy0ga51HHGn1cgent1o,11032
+rpa_suite/functions/__create_ss_dir.py,sha256=FWLglWEYFCZUd_t-Peph1_ktfoH0fskkcfwxgU_pyks,3444
+rpa_suite/functions/__init__.py,sha256=aa0jejVvnghufR50owKcKpmYit7XVAliyN9gn9JkdLE,33
+rpa_suite/functions/_printer.py,sha256=51Xbqr0Ck7HHOrhJCxhMxdCKrF_kQ5AsKZN5SZQPwpk,3991
+rpa_suite/utils/__init__.py,sha256=RQ-m9QNbaByek25moxx9ajpuxjPAEdjoMu69ReLBCWY,675
+rpa_suite/utils/system.py,sha256=fQ9BAWxVETrFUeZJlfhN3cLzToU3XDQYqvDS9W0hWgY,1157
+rpa_suite-1.4.9.dist-info/licenses/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
+rpa_suite-1.4.9.dist-info/METADATA,sha256=_Sb_Dl_nnF0kJYHsP0HGAQITOOWFvlndupMsQq9M47Y,13447
+rpa_suite-1.4.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rpa_suite-1.4.9.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
+rpa_suite-1.4.9.dist-info/RECORD,,

rpa_suite/functions/__create_log_dir.py

@@ -1,83 +0,0 @@
-# /_create_log_dir.py
-
-import os
-from typing import Union
-from rpa_suite.functions._printer import error_print, alert_print, success_print
-
-
-def _create_log_dir(path_to_create: str = 'default', name_log_dir: str='logs') -> dict[str, Union[bool, str, None]]:
-
-    """
-    Function responsible for creating a logger directory to work with files ``.log``. \n
-
-    Parameters:
-    ----------
-    ``path_to_create: str`` - should be a string with the full path pointing to the folder where the logger folder should be created, if it is empty the ``default`` value will be used which will create a folder in the current directory where the file containing this function was called.
-
-    ``name_log_dir: str`` - should be a string representing the name of the logger directory to be created. If it is empty, the ``temp`` value will be used as the default directory name.
-
-    Return:
-    ----------
-    >>> type:dict
-        * 'success': bool - represents case the action was performed successfully
-        * 'path_created': str - path of the directory that was created on the process
-        
-    Description: pt-br
-    ----------
-    Função responsavel por criar diretório de logger para trabalhar com arquivos de log. \n
-
-    Parametros:
-    ----------
-    ``path_to_create: str`` - deve ser uma string com o path completo apontando para a pasta onde deve ser criada a pasta temporaria, se estiver vazio sera usado valor ``default`` que criará pasta no diretório atual onde o arquivo contendo esta função foi chamada.
-
-    ``name_log_dir: str`` - deve ser uma string representando o nome do diretório de logger a ser criado. Se estiver vazio, o valor ``temp`` será usado como o nome padrão do diretório.
-
-    Retorno:
-    ----------
-    >>> type:dict
-        * 'success': bool - representa se ação foi realizada com sucesso
-        * 'path_created': str - path do diretório que foi criado no processo
-    """
-    
-    # Local Variables
-    result: dict = {
-        'success': bool,
-        'path_created': str,
-    }
-    
-    try:
-        # by 'default', defines path to local script execution path
-        if path_to_create == 'default':
-            path_to_create: str = os.getcwd()
-
-        # Build path to new dir
-        full_path: str = os.path.join(path_to_create, name_log_dir)
-
-        # Create dir in this block
-        try:
-
-            # Successefully created
-            os.makedirs(full_path, exist_ok=False)
-
-            result['success'] = True
-            result['path_created'] = fr'{full_path}'
-
-            success_print(f"Diretório:'{full_path}' foi criado com sucesso.")
-
-        except FileExistsError:
-            result['success'] = False
-            result['path_created'] = full_path
-            # alert_print(f"Diretório:'{full_path}' já existe.")
-
-        except PermissionError:
-            result['success'] = False
-            result['path_created'] = None
-            alert_print(f"Permissão negada: não é possível criar o diretório '{full_path}'.")
-
-    except Exception as e:
-        result['success'] = False
-        result['path_created'] = None
-        error_print(f'Error capturing current path to create logger directory! Error: {str(e)}')
-        
-    finally:
-        return result

rpa_suite/functions/_functions_logger.py

@@ -1,96 +0,0 @@
-# /_functions_logger.py
-
-import logging
-from ._logger import file_handler
-from rpa_suite.functions._printer import error_print, success_print
-
-
-def log_start_run_debug(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.
-    """
-
-    try:
-        global file_handler
-        file_handler.stream.write(f'\n{msg_start_loggin}\n')
-        success_print(f'{msg_start_loggin}')
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_start_run_debug.__name__}! Error: {str(e)}')
-
-
-def log_debug(msg) -> None:
-
-    """
-    Function responsable to generate log level ``debug``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.debug(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_debug.__name__}! Error: {str(e)}')
-
-def log_info(msg) -> None:
-
-    """
-    Function responsable to generate log level ``info``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.info(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_debug.__name__}! Error: {str(e)}')
-        
-def log_info(msg) -> None:
-
-    """
-    Function responsable to generate log level ``info``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.info(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_info.__name__}! Error: {str(e)}')
-
-
-def log_warning(msg) -> None:
-
-    """
-    Function responsable to generate log level ``warning``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.warning(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_warning.__name__}! Error: {str(e)}')
-
-
-def log_error(msg) -> None:
-
-    """
-    Function responsable to generate log level ``error``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.error(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_error.__name__}! Error: {str(e)}')
-
-
-def log_critical(msg) -> None:
-
-    """
-    Function responsable to generate log level ``critical``, in file and print on terminal the same log captured on this call.
-    """
-
-    try:
-        logging.critical(msg)
-
-    except Exception as e:
-        error_print(f'Erro durante a função: {log_critical.__name__}! Error: {str(e)}')

rpa_suite/functions/_logger.py

@@ -1,113 +0,0 @@
-# /_logger.py
-
-import logging
-from logging import DEBUG
-from logging import FileHandler, StreamHandler, Filter
-from colorlog import ColoredFormatter
-from typing import Optional as Op
-from ._variables import file_handler, stream_handler
-from .__create_log_dir import _create_log_dir
-from rpa_suite.functions._printer import error_print
-
-
-class Filters(Filter):
-
-    word_filter: Op[list[str]]
-
-    def filter(self, record):
-
-        if len(self.word_filter) > 0:
-
-            for words in self.word_filter:
-
-
-                string_words: list[str] = [str(word) for word in words]
-                """print(words)
-                print(type(words))
-                print(string_words)
-                print(type(string_words))
-                input()"""
-                for word in string_words:
-                    if word in record.msg:
-                        record.msg = 'Log Alterado devido a palavra Filtrada!'
-                        return True
-
-        return True
-
-
-def config_logger(name_app:str = 'Logger', 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) -> Op[FileHandler]:
-
-    """
-    Function responsible for create a object logger with fileHandler and streamHandler
-    """
-
-    global file_handler, stream_handler
-
-    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']
-
-
-        # configuração de objetos logger
-        file_handler = FileHandler(
-            filename=fr'{path_dir}\{name_file_log}.log',
-            mode='a',
-            encoding='utf-8'
-        )
-        stream_handler = StreamHandler()
-
-        # Crie um formatador
-        formatter = ColoredFormatter(
-            "%(log_color)s%(levelname)s ->%(reset)s %(log_color)s%(message)s%(reset)s",
-            datefmt=None,
-            reset=True,
-            log_colors={
-                'DEBUG':    'cyan',
-                'INFO':     'green',
-                'WARNING':  'yellow',
-                'ERROR':    'red',
-                'CRITICAL': 'red',
-            },
-            force_color=True
-        )
-        stream_handler.setFormatter(formatter)
-
-        # ATRIBUIÇÕES
-        new_filter: Op[Filters] = None
-        if filter_words is not None:
-            new_filter: Filters = Filters()
-            new_filter.word_filter = [filter_words]
-
-        if new_filter is not None:
-            file_handler.addFilter(new_filter)
-
-        file_handler.setLevel(DEBUG)
-        
-        # Obtenha o logger
-        logger = logging.getLogger(__name__)
-
-        # Adicione o manipulador de stream ao logger
-        logger.addHandler(stream_handler)
-
-        # terminando de inplementar configuração para o logger
-        FORMAT = '%(levelname)s!%(asctime)s: %(message)s'
-        logging.basicConfig(
-            level=DEBUG, # level from stream_handler
-            #format='%(levelname)s - %(asctime)s - %(message)s',
-            format=FORMAT,
-            handlers=[file_handler, stream_handler],
-            datefmt='%d.%m.%y %H:%M',
-        )
-        return file_handler
-
-    except Exception as e:
-
-        error_print(f'Houve um erro durante a execução da função: {config_logger.__name__}! Error: {str(e)}.')
-        return None

rpa_suite/functions/_variables.py

@@ -1,10 +0,0 @@
-# /_variables.py
-
-from logging import FileHandler, StreamHandler
-from typing import Optional
-
-# Variável global para o manipulador de arquivo
-file_handler: Optional[FileHandler] = None
-
-# Variável global para o manipulador de stream stdout/stdin/buffer
-stream_handler: Optional[StreamHandler] = None

rpa_suite/functions/_variables_uru.py

@@ -1,11 +0,0 @@
-# /_variables_uru.py
-
-from loguru import logger
-from typing import Optional
-from typing import Any
-
-# Variável global para o manipulador de arquivo
-file_handler: Optional[str] = None
-
-# Variável global para o manipulador de stream stdout/stdin/buffer
-stream_handler: Optional[Any] = logger

rpa_suite-1.4.6.dist-info/RECORD

@@ -1,28 +0,0 @@
-rpa_suite/__init__.py,sha256=A6Y1CmdmN9ADAgmvhS8FNXmLNP5fQuyUuZBTm9AKdQo,2494
-rpa_suite/suite.py,sha256=pCbceWTf9WM_xt0GSf_k7Xnk4w_qHKS1hLscYqV5Ga0,10280
-rpa_suite/core/__init__.py,sha256=TJ-WlsgWTVQ-jc-n66K5ZrqJJeHfI27jXytQVcVHN3M,1640
-rpa_suite/core/browser.py,sha256=E-yD2LgwaDVOwUBs09BBXQVx5tLZ7DMFee8LYvgLClY,14682
-rpa_suite/core/clock.py,sha256=1QnlOLs9YCRIq-tMFfk9OgaoicKtCL9sBzJmJmz9m_w,13808
-rpa_suite/core/date.py,sha256=PBU999Acxiwoep029ElqKSzK6T4DrF3eIP-LB_J-BbM,6568
-rpa_suite/core/dir.py,sha256=y6YDyRYQdf9Bj0z3Gs6ugNZ0tKWYgWdDI5R5BjjRIEY,9783
-rpa_suite/core/email.py,sha256=kQJAc6Nb9y7jo-oBAo8X1EZS2y-_gTJRoRc9ylS04CE,8675
-rpa_suite/core/file.py,sha256=rgvXqq_uV3D5wsioL4kTy0cbKv0bNO35alSVup6veHk,11524
-rpa_suite/core/log.py,sha256=xCAoXLxnG2bVzXIafULvW45I4-ljo296E4auU1CppYY,5537
-rpa_suite/core/print.py,sha256=tLHIKo6LDTrV91gWKvwlTrxb1idgx3EV_fIRkqtzWBM,6389
-rpa_suite/core/regex.py,sha256=wsTxe8-baKul2Fv1-fycXZ-DVa5krhkc9qMkP04giGs,3303
-rpa_suite/core/validate.py,sha256=0HnCUgT19LPBMhKxIV_hOAoixpqM7TAL9EkC0S56DFc,10976
-rpa_suite/functions/__create_log_dir.py,sha256=-NjH3Mwv8Aa0EgZiD_TcdlSKbsoYl5EoYmPclFwjTKY,3325
-rpa_suite/functions/__create_ss_dir.py,sha256=WMuDDTxM5xWudQjftC7xPr6y3IdiXjVK-GfxkQNIo4c,3377
-rpa_suite/functions/__init__.py,sha256=aa0jejVvnghufR50owKcKpmYit7XVAliyN9gn9JkdLE,33
-rpa_suite/functions/_functions_logger.py,sha256=hlYDEUsmmfwaPlY_YQeNQEFeT_mryHBqgBVyRdxge48,2703
-rpa_suite/functions/_logger.py,sha256=gTYO9JlbX5_jDfu_4FTTajJw3_GotE2BHUbDDB1Hf5g,3643
-rpa_suite/functions/_printer.py,sha256=r72zeobAi2baVbYgbfFH0h5-WMv4tSDGPNlcpZen7O0,3949
-rpa_suite/functions/_variables.py,sha256=vCcktifFUriBQTyUaayZW8BlE8Gr7VP-tFbfomKOS5U,312
-rpa_suite/functions/_variables_uru.py,sha256=xRqYp49l1fFNrHczOmJ6Pqw1PKIWs0f9kxlgvuYGYys,303
-rpa_suite/utils/__init__.py,sha256=f0qiYRZ7VzBarp1yNj91V0UMZG9QY2mgDXEbWvNZDYs,673
-rpa_suite/utils/system.py,sha256=JIONQutSbNBkQIATcN1wC0NUE4ILlgVZ-TOnuoMPxHI,1055
-rpa_suite-1.4.6.dist-info/licenses/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
-rpa_suite-1.4.6.dist-info/METADATA,sha256=N-wf425WMZNyO6PcTVXcHboPh97H4dZNaAgjfijqplI,11828
-rpa_suite-1.4.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-rpa_suite-1.4.6.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
-rpa_suite-1.4.6.dist-info/RECORD,,