rpa-suite 1.4.8__py3-none-any.whl → 1.4.9__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.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpa_suite
-Version: 1.4.8
+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
@@ -65,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.8](#notas-da-atualização-148)
+  - [Notas da atualização: 1.4.9](#notas-da-atualização-149)
 - [Mais Sobre](#mais-sobre)
 
 ## Destaque
@@ -156,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:
 
@@ -226,9 +227,15 @@ 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".
 
+  - **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.8**
+Versão: **Beta 1.4.9**
 
 Lançamento: *20/02/2024*
 
@@ -236,11 +243,12 @@ Lançamento: *20/02/2024*
 
 Status: Em desenvolvimento.
 
-### Notas da atualização: 1.4.8
+### 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 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.8.dist-info → rpa_suite-1.4.9.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.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,,