rpa-suite 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

rpa_suite/core/__init__.py

@@ -33,6 +33,7 @@ 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

@@ -16,7 +16,6 @@ from time import sleep
 import os, requests
 
 
-
 class Browser():
     
     """

rpa_suite/core/date.py

@@ -10,6 +10,7 @@ from typing import Tuple
 
 
 class Date():
+    
     """
     Class that provides utilities for date manipulation and formatting.
     

rpa_suite/core/file.py

@@ -13,7 +13,6 @@ 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/parallel.py

@@ -1,31 +1,60 @@
 # 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
 
-# Definir tipo genérico para o retorno da função
+# 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.
     """
     
-    def __init__(self):
-        """Inicializa o ParallelRunner."""
+    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".
         """
@@ -38,8 +67,8 @@ class ParallelRunner(Generic[T]):
             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
@@ -50,8 +79,53 @@ class ParallelRunner(Generic[T]):
             # 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:
@@ -70,10 +144,17 @@ class ParallelRunner(Generic[T]):
         self._result_dict['status'] = 'running'
         
         # Inicia o processo com a função auxiliar estática
-        self._process = Process(
-            target=ParallelRunner._execute_function, 
-            args=(function, args, kwargs, self._result_dict)
-        )
+        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()
@@ -82,33 +163,60 @@ class ParallelRunner(Generic[T]):
 
     def is_running(self) -> bool:
         """
-        Verifica se o processo ainda está em execução.
+        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] = None, terminate_on_timeout: bool = True) -> Dict[str, Any]:
+    def get_result(self, timeout: Optional[float] = 60, terminate_on_timeout: bool = True) -> Dict[str, Any]:
         """
-        Obtém o resultado da execução paralela.
+        Retrieves the result of the parallel execution.
         
         Args:
-            timeout: Tempo máximo (em segundos) para aguardar o término do processo
-                    None significa esperar indefinidamente
-            terminate_on_timeout: Se True, termina o processo caso o timeout seja atingido
+            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 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: stack trace completo (se houver erro)
-                - execution_time: tempo de execução em segundos
-                - terminated: True se o processo foi terminado por timeout
+            - 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, 
@@ -128,7 +236,7 @@ class ParallelRunner(Generic[T]):
         }
         
         # Debug - mostra o dicionário compartilhado
-        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():
@@ -167,6 +275,10 @@ class ParallelRunner(Generic[T]):
     
     def terminate(self) -> None:
         """
+        Terminates the running process.
+
+        pt-br
+        ------
         Termina o processo em execução.
         """
         if self._process and self._process.is_alive():
@@ -176,6 +288,10 @@ class ParallelRunner(Generic[T]):
     
     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:
@@ -188,6 +304,10 @@ class ParallelRunner(Generic[T]):
 
     def __del__(self):
         """
+        Destructor of the class, ensures resources are released.
+
+        pt-br
+        ------
         Destrutor da classe, garante que recursos sejam liberados.
         """
-        self.terminate()
+        self.terminate()

rpa_suite/suite.py

@@ -11,6 +11,7 @@ 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
@@ -148,6 +149,7 @@ class Suite():
     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.

{rpa_suite-1.4.8.dist-info → rpa_suite-1.5.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rpa_suite
-Version: 1.4.8
+Version: 1.5.0
 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
 License: MIT
-Keywords: basic-tools,email-tools,email-validation,file-tools,simple-functions,rpa-tools,rpa-functions,Tools,Rpa,Automation,RPA,Automação,Python,Ferramentas de RPA,Automação de Processos,Biblioteca Python para RPA,Bot,Robô,Ferramentas de automação
+Keywords: basic-tools,email-tools,email-validation,file-tools,simple-functions,rpa-tools,rpa-functions,Tools,Rpa,Automation,RPA,Automação,Python,Ferramentas de RPA,Automação de Processos,Biblioteca Python para RPA,Bot,Robô,Ferramentas de automação,automation-tools,workflow-automation,rpa-framework,python-bots,automation-library,rpa-development,python-automation-tools
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -46,9 +46,16 @@ Dynamic: summary
 <br>
 
 ![PyPI Latest Release](https://img.shields.io/pypi/v/rpa-suite.svg)
+[![PyPI Downloads](https://static.pepy.tech/badge/rpa-suite/month)](https://pepy.tech/projects/rpa_suite)
 ![PyPI Downloads](https://img.shields.io/pypi/dm/rpa-suite.svg?label=PyPI%20downloads)
+[![PyPI version](https://img.shields.io/pypi/v/rpa-suite)](https://pypi.org/project/rpa-suite/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/rpa-suite)](https://pypi.org/project/rpa-suite/)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Imports: pyautogui](https://img.shields.io/badge/%20imports-pyautogui-%231674b1?style=flat&labelColor=ef8336)](https://github.com/asweigart/pyautogui)
+[![Imports: loguru](https://img.shields.io/badge/%20imports-loguru-%231674b1?style=flat&labelColor=ef8336)](https://github.com/Delgan/loguru)
+[![License MIT](https://img.shields.io/github/license/docling-project/docling)](https://opensource.org/licenses/MIT)
+[![rpa-suite Actor](https://apify.com/actor-badge?actor=camiloccarvalho/rpasuite?fpr=rpa-suite)](https://apify.com/camiloccarvalho/rpasuite)
 
----
 
 ## O que é?
 
@@ -65,9 +72,11 @@ Dynamic: summary
 - [Dependências](#dependências)
 - [Estrutura do módulo](#estrutura-do-módulo)
 - [Release](#release)
-  - [Notas da atualização: 1.4.8](#notas-da-atualização-148)
 - [Mais Sobre](#mais-sobre)
 
+- [Notas da atualização: 1.4.9](#notas-da-atualização-149)
+
+
 ## Destaque
 
 **Versátil**: Além da Automação de Processos e criação de BOT em RPA, mas também para uso geral podendo  ser aplicadas em outros modelos de projeto, *além do RPA*.
@@ -114,36 +123,38 @@ rpa.email.send_mail(...)
 
 > [!NOTE]
 >
-> Para **desinstalar** o projeto, utilize o comando abaixo.
-> **Obs.:** como usamos algumas libs no projeto, lembre-se de desinstar elas caso necessário.
-
-```python
->>> python -m pip uninstall rpa-suite
-```
-
-> [!IMPORTANT]
+> Para **desinstalar** o projeto, utilize o comando abaixo:
+>
+> ```python
+> python -m pip uninstall rpa-suite
+> ```
 >
-> Opcionalmente você pode querer desinstalar as libs que foram inclusas no projeto, sendo assim:
+> **Observação:** Caso necessário, desinstale também as bibliotecas utilizadas no projeto, como `loguru`, `mail_validator`, `colorama`, `pillow`, e `pyautogui`.
 
-```python
->>> python -m pip uninstall loguru mail_validator colorama pillow pyautogui
-```
+> **⚠️ IMPORTANTE:**  
+> Opcionalmente, você pode querer desinstalar as bibliotecas que foram incluídas no projeto. Para isso, utilize o seguinte comando:  
+>
+> ```python
+> python -m pip uninstall loguru mail_validator colorama pillow pyautogui
+> ```
 
 ## Exemplo
 
 Do módulo principal, importe a suite. Ela retorna uma instância do Objeto de classe Rpa_suite, onde possui variáveis apontando para todas funções dos submódulos:
 
-    from rpa_suite import rpa
+```python
+from rpa_suite import rpa
 
-    # Exemplo com função de execução em horario especifico
-    rpa.clock.exec_at_hour('13:53', my_function, param_a, param_b)
+# Exemplo com função de execução em horário específico
+rpa.clock.exec_at_hour('13:53', my_function, param_a, param_b)
 
-    # Usando submódulo clock para aguardar 30(seg) para executar minha função
-    time = 30
-    rpa.clock.wait_for_exec(time, my_function, param1, param2)
+# Usando submódulo clock para aguardar 30(seg) para executar minha função
+time = 30
+rpa.clock.wait_for_exec(time, my_function, param1, param2)
 
-    # Usando submódulo email para envio de email por smtp comum
-    rpa.email.send_smtp(...)
+# Usando submódulo email para envio de email por SMTP comum
+rpa.email.send_smtp(...)
+```
 
 ## Dependências
 
@@ -156,14 +167,19 @@ 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:
 
   - selenium
   - webdriver_manager
 
-[!IMPORTANT]
-No caso da função de screenshot é necessario ter as libs 'pyautogui' 'pillow' e 'pyscreeze' instalados, geralmente a instalação de pyautogui já instala as demais dependências deste caso.
+<br>
+<hr>
+<br>
+
+> **⚠️ IMPORTANTE:**  
+> No caso da função de screenshot, é necessário ter as bibliotecas `pyautogui`, `pillow` e `pyscreeze` instaladas. Geralmente, a instalação de `pyautogui` já inclui as demais dependências necessárias.
 
 ## Estrutura do módulo
 
@@ -226,36 +242,46 @@ O módulo principal do rpa-suite é dividido em categorias. Cada categoria cont
     - **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".
 
-## Release
+  - **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 Notes
 
-Versão: **Beta 1.4.8**
+### Versão: **Beta 1.5.0**
 
-Lançamento: *20/02/2024*
+- **Data de Lançamento:** *20/02/2024*  
+- **Última Atualização:** *15/04/2025*  
+- **Status:** Em desenvolvimento  
 
-Última atualização: *12/04/2025*
+Esta versão marca um grande avanço no desenvolvimento da RPA Suite, trazendo melhorias significativas na arquitetura, novas funcionalidades e maior simplicidade no uso. Confira as principais mudanças na seção [Notas da atualização: 1.5.0](#notas-da-atualização-150).
 
-Status: Em desenvolvimento.
+### Notas da atualização: 1.5.0
 
-### Notas da atualização: 1.4.8
+- Submódulos agora são objetos internos do objeto principal `Suite`, acessíveis via `rpa.modulo.function()` ou diretamente pelo submódulo.
+- Estrutura reformulada para maior simplicidade, com pastas `core` (núcleo) e `utils` (ferramentas utilitárias).
+- Novo submódulo `Parallel` para execução de processos em paralelo com suporte a timeout e recuperação de resultados.
+- Novo submódulo `AsyncRunner` para facilitar o uso de funções assíncronas com menos código.
+- Adicionado suporte à automação de navegadores (inicialmente apenas Chrome).
+- Função `get_dma` renomeada para `get_dmy` para padronização em inglês.
+- Função `send_email` simplificada para maior compatibilidade.
+- Melhorias nas descrições e adição de docstrings em todas as funções e objetos.
+- Submódulo de logs unificado com Loguru, agora com suporte a configuração de diretórios, nomes de arquivos e streams para console e arquivo.
+- Regex e busca em textos simplificados, com novas funcionalidades planejadas.
+- Melhorias gerais na arquitetura e correções de bugs.
 
-- 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 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
-- Função *send_email* atualizada para simplificar seu uso e funcionalidade em uma maior variedade de maquinas
-- Melhoria nas descrições das funções e adicionado docstring (documentação explicativa) de todos Objetos e respectivas funções
-- Sub-modulos agora como são Objetos internos do Objeto principal Suite pode ser acessado de duas formas, ex1: " from rpa_suite import rpa ; rpa.modulo.function() " ou então ex2: "from rpa_suite.core.Submodulo import NomeModulo ; meu_obj = NomeModulo() ; meu_obj.function()",
-- Funções de regex e busca em textos foi simplificada e em breve estaremos adicionando funcionalidades mais interessantes.
-- Correção e melhoria do Submodulo de Log. Tinhamos dois formatos de Log com duas bibliotecas e decidimos optar apenas pela Loguru para podermos dedicar mais atenção e fornecer recursos de Log mais completos, agora possui funcionalidade para indicar o caminho da pasta, nome da pasta, e também nome do arquivo, realizando stream tanto para o console (terminal) como também para o arquivo com todos levels já configurados e personalizados para ter distinção e facilitar o reconhecimento visual do que esta acontecendo no seu projeto.
 
 ## Mais Sobre
 
-Para mais informações, visite nosso projeto no Github ou PyPi:
+Para mais informações, visite os links abaixo:
 
-[Ver no GitHub](https://github.com/CamiloCCarvalho/rpa_suite)
+- **[Repositório no GitHub](https://github.com/CamiloCCarvalho/rpa_suite)**  
+  Explore o código-fonte, contribua com melhorias e acompanhe o desenvolvimento do projeto.
 
-[Ver projeto publicado no PyPI](https://pypi.org/project/rpa-suite/)
+- **[Página no PyPI](https://pypi.org/project/rpa-suite/)**  
+  Confira a documentação oficial, instale a biblioteca e veja as versões disponíveis.
+
+---
 
-<hr>

{rpa_suite-1.4.8.dist-info → rpa_suite-1.5.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
 rpa_suite/__init__.py,sha256=KO6GC2XbZUO56SAOgKxIkycHFEy6oeWPSswd8-B5IP4,2562
-rpa_suite/suite.py,sha256=4aKwFsIz4YuDuKD41o2ws5bRkmt11uDblymCarYHHUw,11110
-rpa_suite/core/__init__.py,sha256=27hq1brv83Kf89xtk-VVQx2etUWWBnVoZMgbgKI7Ac0,1678
-rpa_suite/core/browser.py,sha256=XgUoOc6pcFwnSQxSlcOF0x8JjlUmj7gw3OvSJ_EoQns,14757
+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=4T8_JKWBcYh4klQBAYx4RrmsKqz7uUb8wD5UtgCueeg,6629
+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=9Psho6n9eqfLu3aA3XW43LzXefEJnAgIentFyopOpxQ,11623
+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=Pftz5cC-3jJLlprLjjSYadc6A9omBBmziCmeUcvNKh4,7668
+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
@@ -17,8 +18,8 @@ rpa_suite/functions/__init__.py,sha256=aa0jejVvnghufR50owKcKpmYit7XVAliyN9gn9Jkd
 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.8.dist-info/licenses/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
-rpa_suite-1.4.8.dist-info/METADATA,sha256=N6Yo_DNSgM__jAR4X1SUULETkDQZRSnG-bcciOxkOXQ,12769
-rpa_suite-1.4.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-rpa_suite-1.4.8.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
-rpa_suite-1.4.8.dist-info/RECORD,,
+rpa_suite-1.5.0.dist-info/licenses/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
+rpa_suite-1.5.0.dist-info/METADATA,sha256=jbmz5bzFrjkmQfoB1LnP8Tzr1eFVjj9So0p62iK8gLg,13693
+rpa_suite-1.5.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rpa_suite-1.5.0.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
+rpa_suite-1.5.0.dist-info/RECORD,,