rpa-suite 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

rpa_suite/clock/exec_at.py

@@ -0,0 +1,118 @@
+import time
+from typing import Callable, Any
+from datetime import datetime as dt
+from rpa_suite.log.printer import error_print, success_print
+
+def exec_at_hour(
+                hour_to_exec: str,
+                fn_to_exec: Callable[..., Any],
+                *args,
+                **kwargs,
+                ) -> dict:
+    
+    """
+    Timed function, executes the function at the specified time, by ``default`` it executes at runtime, optionally you can choose the time for execution.
+    
+    Parameters:
+    ----------
+        `hour_to_exec: 'xx:xx'` - time for function execution, if not passed the value will be by ``default`` at runtime at the time of this function call by the main code.
+    
+        ``fn_to_exec: function`` - (function) to be called by the handler, if there are parameters in this function they can be passed as next arguments in ``*args`` and ``**kwargs``
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'tried': bool - represents if it tried to execute the function passed in the argument
+        * 'success': bool - represents if there was success in trying to execute the requested function
+        
+    Example:
+    ---------
+    Let's execute the function ``sum`` responsible for adding the values of a and b and return x``sum(a, b) -> x`` and we want the code to wait for the specific time to be executed at ``11:00``
+    >>> exec_at_hour("11:00", sum, 10, 5) -> 15 \n
+        * NOTE:  `exec_at_hour` receives as first parameter the function that should be executed, then it can receive the arguments of the function, and explicitly we can define the time for execution.
+        
+    Description: pt-br
+    ----------    
+    Função temporizada, executa a função no horário especificado, por ``default`` executa no momento da chamada em tempo de execução, opcionalmente pode escolher o horário para execução.
+    
+    Parâmetros:
+    ----------
+        `hour_to_exec: 'xx:xx'` - horário para execução da função, se não for passado o valor será por ``default`` em tempo de execução no momento da chamada desta função pelo cógido principal.
+    
+        ``fn_to_exec: function`` - (função) a ser chamada pelo handler, se houver parâmetros nessa função podem ser passados como próximos argumentos em ``*args`` e ``**kwargs``
+    
+    Retorno:
+    ----------
+    >>> type:dict
+        * 'tried': bool - representa se tentou executar a função passada no argumento
+        * 'success': bool - representa se houve sucesso ao tentar executar a função solicitada
+        
+    Exemplo:
+    ---------
+    Vamos executar a função ``soma`` responsável por somar os valores de a e b e retornar x``soma(a, b) -> x`` e queremos que o código aguarde o horário especifico para ser executado de ``11:00``
+    >>> exec_at_hour("11:00", sum, 10, 5) -> 15 \n
+        * OBS.:  `exec_at_hour` recebe como primeiro parâmetro a função que deve ser executada, em seguida pode receber os argumentos da função, e de forma explicitada podemos definir o horário para execução.
+    """
+    
+    # Local Variables
+    result: dict = {
+        'tried': bool,
+        'successs': bool
+    }
+    run: bool
+    now: dt
+    hours: str
+    minutes: str
+    moment_now: str
+    
+    # Preprocessing
+    run = True
+    now = dt.now()
+    hours = str(now.hour) if now.hour > 10 else f"0{now.hour}"
+    minutes = str(now.minute) if now.minute > 10 else f"0{now.minute}"
+    moment_now = f'{hours}:{minutes}'
+    
+    if hour_to_exec == None:
+        
+        # Process
+        while run:
+            try:
+                fn_to_exec(*args, **kwargs)
+                run = False
+                result['tried'] = not run
+                result['success'] = True
+                success_print(f'{fn_to_exec.__name__}: Successfully executed!')
+                break
+                
+            except Exception as e:
+                run = False
+                result['tried'] = not run
+                result['success'] = False
+                error_print(f'An error occurred that prevented the function from executing: {fn_to_exec.__name__} correctly. Error: {str(e)}')
+                break
+    else:
+        # Executes the function call only at the time provided in the argument.
+        while run:
+            if moment_now == hour_to_exec:
+                try:
+                    fn_to_exec(*args, **kwargs)
+                    run = False
+                    result['tried'] = not run
+                    result['success'] = True
+                    success_print(f'{fn_to_exec.__name__}: Successfully executed!')
+                    break
+                    
+                except Exception as e:
+                    run = False
+                    result['tried'] = not run
+                    result['success'] = False
+                    error_print(f'An error occurred that prevented the function from executing: {fn_to_exec.__name__} correctly. Error: {str(e)}')
+                    break
+            else:
+                time.sleep(30)
+                now = dt.now()
+                hours = str(now.hour) if now.hour > 10 else f"0{now.hour}"
+                minutes = str(now.minute) if now.minute > 10 else f"0{now.minute}"
+                moment_now = f'{hours}:{minutes}'
+
+    return result

rpa_suite/clock/waiter.py

@@ -1,5 +1,5 @@
-from typing import Callable, Any
 import time
+from typing import Callable, Any
 from rpa_suite.log.printer import error_print, success_print
 
 def wait_for_exec(
@@ -10,6 +10,27 @@ def wait_for_exec(
                 ) -> dict:
     
     """
+    Timer function, wait for a value in ``seconds`` to execute the function of the argument.
+    
+    Parameters:
+    ----------
+        `wait_time: int` - (seconds) represents the time that should wait before executing the function passed as an argument.
+    
+        ``fn_to_exec: function`` - (function) to be called after the waiting time, if there are parameters in this function they can be passed as next arguments of this function in ``*args`` and ``**kwargs``
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'success': bool - represents if the action was performed successfully
+        
+    Example:
+    ---------
+    We have a sum function in the following format ``sum(a, b) -> return x``, where ``x`` is the result of the sum. We want to wait `30 seconds` to execute this function, so:
+    >>> wait_for_exec(30, sum, 10, 5) -> 15 \n
+        * NOTE:  `wait_for_exec` receives as first argument the time to wait (sec), then the function `sum` and finally the arguments that the function will use.
+        
+    Description: pt-br
+    ----------    
     Função temporizadora, aguardar um valor em ``segundos`` para executar a função do argumento.
     
     Parametros:
@@ -26,25 +47,25 @@ def wait_for_exec(
     Exemplo:
     ---------
     Temos uma função de soma no seguinte formato ``soma(a, b) -> return x``, onde ``x`` é o resultado da soma. Queremos aguardar `30 segundos` para executar essa função, logo:
-    >>> wait_for_exec(30, soma, a, b) -> x \n
+    >>> wait_for_exec(30, soma, 10, 5) -> 15 \n
         * OBS.:  `wait_for_exec` recebe como primeiro argumento o tempo a aguardar (seg), depois a função `soma` e por fim os argumentos que a função ira usar.
     """
     
-    # Variáveis locais
+    # Local Variables
     result: dict = {
         'success': bool
     }
     
-    # Processo
+    # Process
     try:
         time.sleep(wait_time)
         fn_to_exec(*args, **kwargs)
         result['success'] = True
-        success_print(f'A função:: {wait_for_exec.__name__} executou a função: {fn_to_exec.__name__}.')
+        success_print(f'Function: {wait_for_exec.__name__} executed the function: {fn_to_exec.__name__}.')
         
     except Exception as e:
         result['success'] = False
-        error_print(f'Erro ao tentar aguardar para executar a função: {fn_to_exec.__name__} \nMensagem: {str(e)}')
+        error_print(f'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
     
     return result
 
@@ -56,6 +77,27 @@ def exec_and_wait(
                 ) -> dict:
     
     """
+    Timer function, executes a function and waits for the time in ``seconds``
+    
+    Parameters:
+    ----------
+        `wait_time: int` - (seconds) represents the time that should wait after executing the requested function
+    
+        ``fn_to_exec: function`` - (function) to be called before the time to wait, if there are parameters in this function they can be passed as an argument after the function, being: ``*args`` and ``**kwargs``
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'success': bool - represents if the action was performed successfully
+        
+    Example:
+    ---------
+    We have a sum function in the following format ``sum(a, b) -> return x``, where ``x`` is the result of the sum. We want to execute the sum and then wait `30 seconds` to continue the main code:
+    >>> wait_for_exec(30, sum, 10, 5) -> 15 \n
+        * NOTE:  `wait_for_exec` receives as first argument the time to wait (sec), then the function `sum` and finally the arguments that the function will use.
+        
+    Description: pt-br
+    ----------
     Função temporizadora, executa uma função e aguarda o tempo em ``segundos``
     
     Parametros:
@@ -72,24 +114,24 @@ def exec_and_wait(
     Exemplo:
     ---------
     Temos uma função de soma no seguinte formato ``soma(a, b) -> return x``, onde ``x`` é o resultado da soma. Queremos executar a soma e então aguardar `30 segundos` para continuar o código principal:
-    >>> wait_for_exec(30, soma, a, b) -> x \n
+    >>> wait_for_exec(30, soma, 10, 5) -> 15 \n
         * OBS.:  `wait_for_exec` recebe como primeiro argumento o tempo a aguardar (seg), depois a função `soma` e por fim os argumentos que a função ira usar.
     """
     
-    # Variáveis locais
+    # Local Variables
     result: dict = {
         'success': bool
     }
     
-    # Processo
+    # Process
     try:
         fn_to_exec(*args, **kwargs)
         time.sleep(wait_time)
         result['success'] = True
-        success_print(f'A função:: {wait_for_exec.__name__} executou a função: {fn_to_exec.__name__}.')
+        success_print(f'Function: {wait_for_exec.__name__} executed the function: {fn_to_exec.__name__}.')
         
     except Exception as e:
         result['success'] = False
-        error_print(f'Erro ao tentar aguardar para executar a função: {fn_to_exec.__name__} \nMensagem: {str(e)}')
+        error_print(f'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
     
     return result

rpa_suite/date/date.py

@@ -4,7 +4,26 @@ from rpa_suite.log.printer import error_print
 
         
 def get_hms() -> tuple:
+    
     """
+    Function to return hour, minute and second. The return is in the form of a tuple with strings being able to store and use the values individually.
+    
+    Treatment:
+    ----------
+    The function already does the treatment for values below 10 always keeping 2 decimal places in all results, the individual values are always in string format
+    
+    Return:
+    ----------
+    >>> type:tuple
+        * tuple('hh', 'mm', 'ss') - tuple with the values of hour, minute and second being able to be stored individually, the values are in string
+        
+    Example:
+    ---------
+    >>> hour, minute, second = get_hms() \n
+        * NOTE:  Note that it is possible to destructure the return to store simultaneously.
+        
+    Description: pt-br
+    ----------
     Função para retornar hora, minuto e segundo. O retorno é em forma de tupla com strings podendo armazenar e usar os valores de forma individual.
     
     Tratamento:
@@ -22,18 +41,18 @@ def get_hms() -> tuple:
         * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
     """
     
-    # Variáiveis locais
+    # Local Variables
     hours: str
     minutes: str
     seconds: str
     
-    # Pré tratamento
+    # Preprocessing
     now = dt.datetime.now()
     hours: str = str(now.hour) if now.hour > 10 else f"0{now.hour}"
     minutes: str = str(now.minute) if now.minute > 10 else f"0{now.minute}"
     seconds: str = str(now.second) if now.second > 10 else f"0{now.second}"
     
-    # Processo
+    # Process
     try:
         if len(hours) == 3 or len(minutes) == 3 or len(seconds) == 3:
             if len(seconds) == 3:
@@ -45,10 +64,24 @@ def get_hms() -> tuple:
                 
         return hours, minutes, seconds
     except Exception as e:
-        return error_print(f'Não foi possivel capturar o horário. Erro: {str(e)}')
+        return error_print(f'Unable to capture the time. Error: {str(e)}')
 
 def get_dma() -> tuple:
     """
+    Function to return day, month and year. The return is in the form of a tuple with strings being able to store and use the values individually.
+    
+    Return:
+    ----------
+    >>> type:tuple
+        * tuple('dd', 'mm', 'yy') - tuple with the values of day, month and year being able to be stored individually
+        
+    Example:
+    ---------
+    >>> day, month, year = get_hms() \n
+        * NOTE:  Note that it is possible to destructure the return to store simultaneously.
+        
+    Description: pt-br
+    ----------
     Função para retornar dia, mes e ano. O retorno é em forma de tupla com strings podendo armazenar e usar os valores de forma individual.
     
     Retorno:
@@ -62,15 +95,15 @@ def get_dma() -> tuple:
         * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
     """
     
-    # Variáiveis locais
+    # Local Variables
     day_got: str
     month_got: str
     year_got: str
     
-    # Pré tratamento
+    # Preprocessing
     now = dt.datetime.now()
     
-    # Processo
+    # Process
     try:
         day_got: str = str(now.day) if now.day > 10 else f"0{now.day}"
         month_got: str = str(now.month) if now.month > 10 else f"0{now.month}"
@@ -79,4 +112,4 @@ def get_dma() -> tuple:
         return day_got, month_got, year_got
     
     except Exception as e:
-        return error_print(f'Não foi possivel capturar o horário. Erro: {str(e)}')
+        return error_print(f'Unable to capture the time. Error: {str(e)}')

rpa_suite/email/sender_smtp.py

@@ -19,6 +19,36 @@ def send_email(
                 ) -> dict:
 
     """
+    Function responsible for sending emails ``(SMTP)``, accepts ``list of recipients`` and possibility
+    of ``attaching files``. \n
+    
+    Parameters:
+    ----------
+    ``email_from: str`` - email from who will send the email.
+    ``pass_from: str`` - password of the account used, advised to isolate the password elsewhere.
+    ``email_to: list[str]`` - list of emails to which the emails will be sent.
+    ``subject_title: str`` - email title.
+    ``body_message: str``- body message of the email.
+    ``attachments: list[str]`` - list with path of attachments if any. (default None).
+    ``type_content: str`` - type of message content can be 'plain' or 'html' (default 'html').
+    ``smtp_server: str`` - server to be used to connect with the email account (default 'smtp.office365.com')
+    ``smtp_port: int`` - port to be used on this server (default 587) 
+    
+    Return:
+    ----------
+    >>> type:dict
+    a dictionary with all information that may be necessary about the emails.
+    Respectively being:
+        * 'success': bool -  if there was at least one successful shipment
+        * 'all_mails': list - list of all emails parameterized for sending
+        * 'valid_mails': list - list of all valid emails for sending
+        * 'invalid_mails': list - list of all invalid emails for sending
+        * 'qt_mails_sent': int - effective quantity that was sent
+        * 'attchament': bool - if there are attachments
+        * 'qt_attach': int - how many attachments were inserted
+        
+    Description: pt-br
+    ----------
     Função responsavel por enviar emails ``(SMTP)``, aceita ``lista de destinatários`` e possibilidade
     de ``anexar arquivos``. \n
     
@@ -48,7 +78,7 @@ def send_email(
         * 'qt_attach': int - quantos anexos foram inseridos
     """
 
-    # Variáveis locais
+    # Local Variables
     result: dict = {
         'success': bool,
         'all_mails': list,
@@ -61,20 +91,19 @@ def send_email(
     email_valido = []
     email_invalido = []
     
-    # Pré Tratamentos
+    # Preprocessing
     result['success'] = False
     result['qt_mails_sent'] = 0
     result['attchament'] = False
 
-    # Configuração inicial basica.
     msg = MIMEMultipart()
     msg['From'] = email_from
     msg['Subject'] = subject_title
 
-    # Adicionar corpo da mensagem
+    # Email Body Content
     msg.attach(MIMEText(body_message, type_content))
 
-    # Adicionar anexos, se houver
+    # Add Attachment
     if attachments:
         result['attchament'] = True
         for path_to_attach in attachments:
@@ -90,14 +119,14 @@ def send_email(
         result['attchament'] = False
         result['qt_attach'] = 0
 
-    # Conectar ao servidor SMTP e enviar email
+    # SMTP server config
     try:
         server_by_smtp = smtplib.SMTP(smtp_server, smtp_port)
         server_by_smtp.starttls()
         server_by_smtp.login(email_from, pass_from)
         email_content = msg.as_string()
 
-        # Trata a lista de emails antes de tentar realizar o envio, mantendo apenas emails validos
+        # Treats the email list before trying to send, keeping only valid emails
         try:  
             for emails in email_to:
                 try:
@@ -108,9 +137,9 @@ def send_email(
                     email_invalido.append(emails)
 
         except Exception as e:
-            error_print(f'Erro ao tentar validar lista de emails: {str(e)}')
+            error_print(f'Error while trying to validate email list: {str(e)}')
 
-        # anexa a lista de emails tratada para realizar o envio
+        # Attaches the treated email list to perform the sending
         msg['To'] = ', '.join(email_valido)
         for email in email_valido:
             try:
@@ -119,18 +148,18 @@ def send_email(
                 result['all_mails'] = email_to
 
             except smtplib.SMTPException as e:
-                error_print(f'O email: {email} não foi enviado, por causa do erro: {str(e)}')
+                error_print(f"The email: {email} don't sent, caused by error: {str(e)}")
 
         server_by_smtp.quit()
         result['success'] = True
-        success_print(f'Email(s) enviado(s) com sucesso!')
+        success_print(f'Email(s) Sent!')
         
 
     except smtplib.SMTPException as e:
         result['success'] = False
-        error_print(f'Erro ao enviar email(s): {str(e)}')
+        error_print(f'Error while trying sent Email: {str(e)}')
 
-    # Pós Tratamento
+    # Postprocessing
     result['valid_mails'] = email_valido
     result['invalid_mails'] = email_invalido
 

rpa_suite/file/counter.py

@@ -7,6 +7,22 @@ def count_files(
                 ) -> dict:
     
     """
+    Function responsible for counting files within a folder, considers subfolders to do the count, searches by file type, being all files by default. \n
+    
+    Parameters:
+    ----------
+    ``dir_to_count: list`` - should be a list, accepts more than one path to count files.
+    ``type_extension: str`` - should be a string with the format/extension of the type of file you want to be searched for counting, if empty by default will be used ``*`` which will count all files.
+
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'success': bool - represents if the action was performed successfully
+        * 'qt': int - number that represents the quantity of files that were counted
+        
+    Description: pt-br
+    ----------
     Função responsavel por fazer a contagem de arquivos dentro de uma pasta, considera subpastas para fazer a contagem, busca por tipo de arquivo, sendo todos arquivos por default. \n
     
     Parametros:
@@ -22,17 +38,17 @@ def count_files(
         * 'qt': int - numero que representa a quantidade de arquivos que foram contados
     """
     
-    # Variáveis locais
+    # Local Variables
     result: dict = {
         'success': bool,
         'qt': int
     }
     
-    # Pré tratamento
+    # Preprocessing
     result['qt'] = 0
     result['success'] = False
     
-    # Processo
+    # Process
     try:
         for dir in dir_to_count:
             for current_dir, sub_dir, files in os.walk(dir):
@@ -40,10 +56,10 @@ def count_files(
                     if file.endswith(f'.{type_extension}'):
                         result['qt'] += 1
         result['success'] = True
-        success_print(f'Função: {count_files.__name__} encontrou {result['qt']} arquivos.')
+        success_print(f'Function: {count_files.__name__} counted {result['qt']} files.')
         
     except Exception as e:
         result['success'] = False
-        error_print(f'Erro ao tentar fazer contagem de arquivos! Erro: {str(e)}')
+        error_print(f'Error when trying to count files! Error: {str(e)}')
         
     return result

rpa_suite/file/temp_dir.py

@@ -4,6 +4,20 @@ from rpa_suite.log.printer import error_print, alert_print, success_print
 def create_temp_dir(path_to_create: str = 'default') -> dict:
     
     """
+    Function responsible for creating a temporary directory to work with files and etc. \n
+    
+    Parameters:
+    ----------
+    ``path_to_create: str`` - should be a string with the full path pointing to the folder where the temporary 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.
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'success': bool - represents if the action was performed successfully
+        * 'path_created': str - path of the directory that was created in the process
+        
+    Description: pt-br
+    ----------
     Função responsavel por criar diretório temporário para trabalhar com arquivos e etc. \n
     
     Parametros:
@@ -15,16 +29,15 @@ def create_temp_dir(path_to_create: str = 'default') -> dict:
     >>> type:dict
         * 'success': bool - representa se ação foi realizada com sucesso
         * 'path_created': str - path do diretório que foi criado no processo
-    
     """
     
-    # Variáveis Locais
+    # Local Variables
     result: dict = {
         'success': bool,
         'path_created': str
     }
     
-    # Pré tratamento
+    # Preprocessing
     default_dir: str
     try:
         if path_to_create == 'default':
@@ -33,37 +46,50 @@ def create_temp_dir(path_to_create: str = 'default') -> dict:
             default_dir = path_to_create
     except Exception as e:
         result['success'] = False
-        error_print(f'Erro ao capturar caminho atual para criar diretório temporária! Erro: {str(e)}')
+        error_print(f'Error capturing current path to create temporary directory! Error: {str(e)}')
         
-    # Processo
+    # Process
     try:
         if not os.path.exists(fr'{default_dir}\temp'):
             try:
                 os.mkdir(fr'{default_dir}\temp')
                 if os.path.exists(fr'{default_dir}\temp'):
                     result['success'] = True
-                    success_print(fr'Diretório criado em: {default_dir}\temp')
+                    success_print(fr'Directory created in: {default_dir}\temp')
                 else:
                     result['success'] = False
                     raise Exception
             except Exception as e:
-                error_print(f'Não foi possivel criar diretório temporario! Erro: {str(e)}')
+                error_print(f'Unable to create temporary directory! Error: {str(e)}')
         else:
             result['success'] = True
-            alert_print(fr'AVISO! diretório já existe em: {default_dir}\temp ')
+            alert_print(fr'NOTICE! directory already exists in: {default_dir}\temp ')
     except Exception as e:
-        error_print(f'Erro ao tentar criar diretório temporaria em: {default_dir} - Erro: {str(e)}')
+        error_print(f'Error when trying to create temporary directory in: {default_dir} - Error: {str(e)}')
         
-    # Pós tratamento
+    # Postprocessing
     result['path_created'] = fr'{default_dir}\temp'
     
-    # Retorno
     return result
 
 
 def delete_temp_dir(path_to_delete: str = 'default') -> dict:
     
     """
+    Function responsible for deleting temporary directory at the specified path. \n
+    
+    Parameters:
+    ----------
+    ``path_to_delete: str`` - should be a string with the full path pointing to the folder where the temporary folder should be deleted, if it is empty the ``default`` value will be used which will search for a folder in the current directory where the file containing this function was called.
+    
+    Return:
+    ----------
+    >>> type:dict
+        * 'success': bool - represents if the action was performed successfully
+        * 'path_deleted': str - path of the directory that was deleted in the process
+        
+    Description: pt-br
+    ----------
     Função responsavel por deletar diretório temporário no caminho especificado. \n
     
     Parametros:
@@ -75,16 +101,15 @@ def delete_temp_dir(path_to_delete: str = 'default') -> dict:
     >>> type:dict
         * 'success': bool - representa se ação foi realizada com sucesso
         * 'path_deleted': str - path do diretório que foi excluido no processo
-    
     """
     
-    # Variáveis Locais
+    # Local Variables
     temp_dir_result: dict = {
         'success': bool,
         'path_deleted': str
     }
     
-    # Pré tratamento
+    # Preprocessing
     default_dir: str
     try:
         if path_to_delete == 'default':
@@ -93,29 +118,29 @@ def delete_temp_dir(path_to_delete: str = 'default') -> dict:
             default_dir = path_to_delete
     except Exception as e:
         temp_dir_result['success'] = False
-        error_print(f'Não foi possivel capturar caminho atual para deletar pasta temporária! Erro: {str(e)}')
+        error_print(f'Unable to capture current path to delete temporary folder! Error: {str(e)}')
         
-    # Processo
+    # Process
     try:
         if os.path.exists(fr'{default_dir}\temp'):
             try:
                 shutil.rmtree(fr'{default_dir}\temp')
                 if not os.path.exists(fr'{default_dir}\temp'):
                     temp_dir_result['success'] = True
-                    success_print(fr'Diretório excluido em: {default_dir}\temp')
+                    success_print(fr'Directory deleted in: {default_dir}\temp')
                 else:
                     temp_dir_result['success'] = False
                     raise Exception
             except Exception as e:
-                error_print(f'Não foi possivel excluir diretório temporario! Erro {str(e)}')
+                error_print(f'Unable to delete temporary directory! Error: {str(e)}')
         else:
             temp_dir_result['success'] = True
-            alert_print(fr'Diretório não existe em: {default_dir}\temp. ')
+            alert_print(fr'Directory does not exist in: {default_dir}\temp. ')
             
     except Exception as e:
-        error_print(fr'Erro ao tentar deletar diretório temporária em: {default_dir}\temp - Erro: {str(e)}')
+        error_print(fr'Error when trying to delete temporary directory in: {default_dir}\temp - Error: {str(e)}')
         
-    # Pós tratamento
+    # Postprocessing
     temp_dir_result['path_deleted'] = fr'{default_dir}\temp'
     
     return temp_dir_result

rpa_suite/log/loggin.py

@@ -6,6 +6,16 @@ def logging_decorator(
                     ) -> Callable:
     
     """
+    Function responsible for displaying log message in the console for functions that are called. \n
+    Displays function name, and the result of the function in case of return, without return returns None.
+    
+    Return:
+    ----------
+    A ``wrapper`` function with python decoration ``@logger.catch`` that received:
+        * ``*args and **kwargs`` in the call parameters as an argument to result in the Log.
+        
+    Description: pt-br
+    ----------
     Função responsavel por exibir mensagem de log no console para funções que são chamadas. \n
     Exibe nome da função, e o resultado da função em caso de retorno, sem retorno devolve None.
     
@@ -17,9 +27,9 @@ def logging_decorator(
     
     @logger.catch
     def wrapper(*args, **kwargs):
-        logger.info('Chamando função: {}', fn.__name__)
+        logger.info('Function Called: {}', fn.__name__)
         result = fn(*args, **kwargs)
-        logger.info('Função {} retornou: {}', fn.__name__, result)
+        logger.info('Function {} returned: {}', fn.__name__, result)
         return result
     
     return wrapper

rpa_suite/log/printer.py

@@ -17,6 +17,14 @@ class Colors():
 
 def success_print(string_text: str, color=Colors.green, ending="\n") -> None:
     """
+    Print that indicates ``SUCCESS``. Customized with the color Green \n
+    
+    Return:
+    ----------
+        >>> type:None
+        
+    pt-br
+    ----------
     Print  que indica ``SUCESSO``. Personalizado com a cor Verde \n
     
     Retorno:
@@ -27,6 +35,14 @@ def success_print(string_text: str, color=Colors.green, ending="\n") -> None:
 
 def alert_print(string_text: str, color=Colors.yellow, ending="\n") -> None:
     """
+    Print that indicates ``ALERT``. Customized with the color Yellow \n
+    
+    Return:
+    ----------
+        >>> type:None
+    
+    pt-br
+    ----------
     Print que indica ``ALERTA``. Personalizado com a cor Amarelo \n
     Retorno:
     ----------
@@ -36,6 +52,14 @@ def alert_print(string_text: str, color=Colors.yellow, ending="\n") -> None:
 
 def info_print(string_text: str, color=Colors.cyan, ending="\n") -> None:
     """
+    Print that indicates ``INFORMATION``. Customized with the color Cyan \n
+    
+    Return:
+    ----------
+        >>> type:None
+        
+    pt-br
+    ----------
     Print que indica ``INFORMATIVO``. Personalizado com a cor Ciano \n
     Retorno:
     ----------
@@ -45,6 +69,14 @@ def info_print(string_text: str, color=Colors.cyan, ending="\n") -> None:
 
 def error_print(string_text: str, color=Colors.red, ending="\n") -> None:
     """
+    Print that indicates ``ERROR``. Customized with the color Red \n
+    
+    Return:
+    ----------
+        >>> type:None
+        
+    pt-br
+    ----------
     Print que indica ``ERRO``. Personalizado com a cor Vermelho \n
     Retorno:
     ----------
@@ -54,6 +86,14 @@ def error_print(string_text: str, color=Colors.red, ending="\n") -> None:
 
 def magenta_print(string_text: str, color=Colors.magenta, ending="\n") -> None:
     """
+    Print customized with the color Magenta \n
+    
+    Return:
+    ----------
+        >>> type:None
+    
+    pt-br
+    ----------
     Print personalizado com a cor Magenta \n
     Retorno:
     ----------
@@ -63,6 +103,14 @@ def magenta_print(string_text: str, color=Colors.magenta, ending="\n") -> None:
 
 def blue_print(string_text: str, color=Colors.blue, ending="\n") -> None:
     """
+    Print customized with the color Blue \n
+    
+    Return:
+    ----------
+        >>> type:None
+    
+    pt-br
+    ----------
     Print personalizado com a cor Azul \n
     Retorno:
     ----------
@@ -72,6 +120,14 @@ def blue_print(string_text: str, color=Colors.blue, ending="\n") -> None:
 
 def print_call_fn(string_text: str, color=Colors.call_fn, ending="\n") -> None:
     """
+    Print customized for function called (log) \n
+    Color: Magenta Light
+    Return:
+    ----------
+        >>> type:None
+    
+    pt-br
+    ----------
     Print personalizado para log de chamada de função. \n
     Cor: Magenta Light
     Retorno:
@@ -82,6 +138,14 @@ def print_call_fn(string_text: str, color=Colors.call_fn, ending="\n") -> None:
 
 def print_retur_fn(string_text: str, color=Colors.retur_fn, ending="\n") -> None:
     """
+    Print customized for function return (log) \n
+    Color: Yellow Light
+    Return:
+    ----------
+        >>> type:None
+    
+    pt-br
+    ----------
     Print personalizado para log de chamada de função. \n
     Cor: Yellow Light
     Retorno:

rpa_suite/suite.py

@@ -1,17 +1,42 @@
-from .clock.waiter import wait_for_exec
-from .clock.exec_while import exec_wtime
+"""MODULE CLOCK"""
+from .clock.waiter import wait_for_exec, exec_and_wait
+from .clock.exec_at import exec_at_hour
+
+"""MODULE DATE"""
 from .date.date import get_hms, get_dma
+
+"""MODULE EMAIL"""
 from .email.sender_smtp import send_email
+
+"""MODULE FILE"""
 from .file.counter import count_files
 from .file.temp_dir import create_temp_dir, delete_temp_dir
+
+"""MODULE LOG"""
 from .log.loggin import logging_decorator
 from .log.printer import alert_print, success_print, error_print, info_print, print_call_fn, print_retur_fn, magenta_print, blue_print
+
+"""MODULE REGEX"""
 from .regex.list_from_text import create_list_using_regex
+
+"""MODULE VALIDATE"""
 from .validate.mail_validator import valid_emails
 from .validate.string_validator import search_in
 
 class Rpa_suite():
     """
+    The ``Rpa_suite`` class is a generic representation of the modules, with the aim of centralizing all submodules for access through an instance of this representational Object. It contains variables pointed to the functions of the submodules present in the rpa-site.
+    
+    Call
+    ----------
+    When calling the maintainer file of this class, an instance of this object will be invoked to be used or reused through another variable
+    
+    Objective
+    ----------
+    Flexibility being able to call each submodule individually or by importing the representational object of all submodules.
+    
+    Description: pt-br
+    ----------
     Classe ``Rpa_suite`` é uma representação genérica do dos módulos, com objetivo de centralizar todos submódulos para acesso através de uma instância deste Objeto representacional. Ele contem variaveis apontadas para as funções dos submódulos presentes no rpa-site.
     
     Chamada
@@ -25,7 +50,8 @@ class Rpa_suite():
     
     # clock
     wait_for_exec = wait_for_exec
-    exec_wtime = exec_wtime
+    exec_and_wait = exec_and_wait
+    exec_at_hour = exec_at_hour
     
     # date
     get_hms = get_hms

rpa_suite/validate/mail_validator.py

@@ -6,6 +6,25 @@ def valid_emails(
                 ) -> dict:
     
     """
+    Function responsible for rigorously validating a list of emails using the email_validator library. \n
+    
+    Parameters:
+    ------------
+    ``email_list: list`` a list of strings containing the emails to be validated
+    
+    Return:
+    ------------
+    >>> type: dict
+    Returns a dictionary with the respective data:
+        * 'success': bool - represents if the list is 100% valid
+        * 'valid_emails': list - list of valid emails
+        * 'invalid_emails': list - list of invalid emails
+        * 'qt_valids': int - number of valid emails
+        * 'qt_invalids': int - number of invalid emails
+        * 'map_validation' - map of the validation of each email
+        
+    Description: pt-br
+    ----------
     Função responsavel por validar de forma rigorosa lista de emails usando a biblioteca email_validator. \n
     
     Paramentros:
@@ -24,7 +43,7 @@ def valid_emails(
         * 'map_validation' - mapa da validação de cada email
     """
     
-    # Variáveis locais
+    # Local Variables
     result: dict = {
         'success': bool,
         'valid_emails': list,
@@ -35,12 +54,12 @@ def valid_emails(
     }
 
     
-    # Pré Tratamento
+    # Preprocessing
     validated_emails: list = []
     invalid_emails: list = []
     map_validation: list[dict] = []
     
-    # Processo
+    # Process
     try:
         for email in email_list:
             try:
@@ -50,12 +69,12 @@ def valid_emails(
                 
             except email_validator.EmailNotValidError:
                 invalid_emails.append(email)
-        success_print(f'Função: {valid_emails.__name__} executada.')
+        success_print(f'Function: {valid_emails.__name__} executed.')
     except Exception as e:
-        error_print(f'Erro ao tentar validar lista de emails: {str(e)}')
+        error_print(f'Error when trying to validate email list: {str(e)}')
 
     
-    # Pós Tratamento
+    # Postprocessing
     result = {
         'valid_emails': validated_emails,
         'invalid_emails': invalid_emails,

rpa_suite/validate/string_validator.py

@@ -8,6 +8,36 @@ def search_in(
             ) -> dict:
     
     """
+    Function responsible for searching for a string, substring or word within a provided text. \n
+    
+    Parameters:
+    -----------
+    ``origin_text: str`` \n
+        
+        * It is the text where the search should be made, in string format. \n
+        
+    ``search_by: str`` accepts the values: \n
+        
+        * 'string' - can find a requested writing excerpt. (default) \n
+        * 'word' - finds only the word written out exclusively. \n
+        * 'regex' - find regex patterns, [ UNDER DEVELOPMENT ...] \n
+    
+    Return:
+    -----------
+    >>> type:dict
+    a dictionary with all information that may be necessary about the validation.
+    Respectively being:
+        * 'is_found': bool -  if the pattern was found in at least one case
+        * 'number_occurrences': int - represents the number of times this pattern was found
+        * 'positions': list[set(int, int), ...] - represents all positions where the pattern appeared in the original text
+        
+    About `Positions`:
+    -----------
+    >>> type: list[set(int, int), ...]
+        * at `index = 0` we find the first occurrence of the text, and the occurrence is composed of a PAIR of numbers in a set, the other indexes represent other positions where occurrences were found if any.
+        
+    Description: pt-br
+    ----------
     Função responsavel por fazer busca de uma string, sbustring ou palavra dentro de um texto fornecido. \n
     
     Parametros:
@@ -34,22 +64,21 @@ def search_in(
     Sobre o `Positions`:
     -----------
     >>> type: list[set(int, int), ...]
-        * no `index = 0` encontramos a primeira ocorrência do texto, e a ocorrência é composta por um PAR de números em um set, os demais indexes representam outras posições onde foram encontradas ocorrências caso hajam. 
-    
+        * no `index = 0` encontramos a primeira ocorrência do texto, e a ocorrência é composta por um PAR de números em um set, os demais indexes representam outras posições onde foram encontradas ocorrências caso hajam.
     """
     
-    # Variaveis locais
+    # Local Variables
     result: dict = {
         'is_found': bool,
         'number_occurrences': int,
         'positions': list[set]
     }
     
-    # Pré tratamento
+    # Preprocessing
     result['is_found'] = False
     result['number_occurrences'] = 0
     
-    # Processo
+    # Process
     try:
         if search_by == 'word':
             origin_words = origin_text.split()
@@ -61,7 +90,7 @@ def search_in(
                     searched_word = searched_word.lower()
                     result['is_found'] = searched_word in words_lowercase
             except Exception as e:
-                return error_print(f'Não foi possivel concluir a busca de: {searched_word}. Erro: {str(e)}')
+                return error_print(f'Unable to complete the search: {searched_word}. Error: {str(e)}')
                 
         elif search_by == 'string':
             try:
@@ -72,7 +101,7 @@ def search_in(
                     searched_word_lower: str = searched_word.lower()
                     result['is_found'] = origin_text_lower.__contains__(searched_word_lower)
             except Exception as e:
-                return error_print(f'Não foi possivel concluir a busca de: {searched_word}. Erro: {str(e)}')
+                return error_print(f'Unable to complete the search: {searched_word}. Error: {str(e)}')
             
         elif search_by == 'regex':
             pass
@@ -82,15 +111,15 @@ def search_in(
                 else:
                     print(f'metodo para buscar sem sensitive...')
             except Exception as e:
-                return print(f'Não foi possivel concluir a busca de: {searched_word}. Erro: {str(e)}')"""
+                return print(f'Não foi possivel concluir a busca de: {searched_word}. Error: {str(e)}')"""
             
     except Exception as e:
-        return error_print(f'Não foi possivel realizar a busca por: {searched_word}. Erro: {str(e)}')
+        return error_print(f'Unable to search for: {searched_word}. Error: {str(e)}')
     
-    # Pós tratamento
+    # Postprocessing
     if result['is_found']:
-        success_print(f'Função: {search_in.__name__} encontrou: {result["number_occurrences"]} ocorrências para "{searched_word}".')
+        success_print(f'Function: {search_in.__name__} found: {result["number_occurrences"]} occurrences for "{searched_word}".')
     else:
-        success_print(f'Função: {search_in.__name__} não encontrou ocorrências de "{searched_word}" durante a busca.')
+        success_print(f'Function: {search_in.__name__} found no occurrences of "{searched_word}" during the search.')
     
     return result

{rpa_suite-0.8.1.dist-info → rpa_suite-0.8.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: rpa-suite
-Version: 0.8.1
+Version: 0.8.2
 Summary: Conjunto de ferramentas essenciais para 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
+Keywords: basic-tools,email-tools,email-validation,file-tools,simple-functions,rpa-tools,rpa-functions,RPA,Automação,Python,Ferramentas de RPA,Automação de Processos,Biblioteca Python para RPA
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -18,7 +18,7 @@ Requires-Dist: loguru
 Requires-Dist: colorama
 Requires-Dist: email-validator
 
-![RPA Suite](https://raw.githubusercontent.com/CamiloCCarvalho/rpa_suite/ca3820365ae7658ea8a2e801070f4f3b955b3ea6/logo-rpa-suite.svg)
+![RPA Suite](https://raw.githubusercontent.com/CamiloCCarvalho/rpa_suite/3e1ccd0acad654916466f03c2b8f166dc8d360d4/logo-rpa-suite.svg)
 
 
 <h1 align="left">
@@ -32,7 +32,7 @@ Requires-Dist: email-validator
 -----------------
 
 ## O que é?
-**RPA Suite:** um conjunto abrangente de ferramentas projetadas para simplificar e otimizar o desenvolvimento de projetos de automação RPA. Embora nossa suíte seja especializada em RPA, sua versatilidade a torna igualmente útil para uma ampla gama de projetos de desenvolvimento. Experimente a RPA Suite e descubra como podemos facilitar seu próximo projeto.
+**RPA Suite:** um conjunto abrangente de ferramentas projetadas para simplificar e otimizar o desenvolvimento de projetos de automação RPA com Python. Embora nossa suíte seja um conjunto de Ferramentas de RPA especializado, sua versatilidade a torna igualmente útil para uma ampla gama de projetos de desenvolvimento. Esta desenvolvendo com Selenium, Botcity ou Playwright? Experimente a RPA Suite e descubra como podemos facilitar seu projeto, ou qualquer projeto de Robôs de Software.
 
 ## Sumário do conteudo
 
@@ -47,13 +47,13 @@ Requires-Dist: email-validator
 
 ## Destaque
 
-**Versátil**: Embora tenha sido criado com foco no desenvolvimento de BOTs em RPA, as ferramentas são de uso geral e podem ser aplicadas em outros tipos de projetos, *além do RPA*.
+**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*.
 
 **Simples**: Construímos as ferramentas de maneira mais direta e assertiva possível, utilizando apenas bibliotecas conhecidas no mercado para garantir o melhor desempenho possível.
 
 ## Objetivo
 
-Nosso objetivo é tornar o desenvolvimento de RPAs mais produtivo, oferecendo funções prontas para usos comuns, como:
+Nosso objetivo é se tornar a Biblioteca Python para RPA referência. Tornando o desenvolvimento de RPAs mais produtivo, oferecendo uma gama de funções para tal:
 
 - Envio de emails (já configurado e personalizavel)
 - Validação de emails (limpeza e tratamento)
@@ -116,7 +116,8 @@ No setup do nosso projeto já estão inclusas as dependências, só será necess
 O módulo principal do rpa-suite é dividido em categorias. Cada categoria contém módulos com funções destinadas a cada tipo de tarefa
 - **rpa_suite**
     - **clock**
-        - **waiter** - Funções para aguardar execução
+        - **waiter** - Funções para aguardar em relação a execução de uma função, podendo ser antes ou depois
+        - **exec_at** - Funções para executar em momentos pré determinados
     - **date**
         - **date** - Funções para capturar data, mes, ano, hora, minutos de forma individual em apenas uma linha
     - **email**
@@ -134,9 +135,9 @@ O módulo principal do rpa-suite é dividido em categorias. Cada categoria cont
         - **string_validator** - Funções para validação/varredura (strings, substrings, palavras)
 
 ## Release
-Versão: **Alpha 0.8.1**
+Versão: **Alpha 0.8.2**
 
-Lançamento: *04/12/2023*
+Lançamento: *05/12/2023*
 
 Status: Em desenvolvimento.
 

rpa_suite-0.8.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+rpa_suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/suite.py,sha256=HVCk50YoVsx4knFKGg5G7YZV5RAwi29P-2gy9dray-I,3011
+rpa_suite/clock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/clock/exec_at.py,sha256=Se10YYKLHjYsqMHuxdxwY6YoB4Aqri1kAnbMGAf6BjM,5376
+rpa_suite/clock/waiter.py,sha256=ogFTQkBNGAB_K013155PtySXpuMszTsrrTz0p56Yaxg,5878
+rpa_suite/date/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/date/date.py,sha256=0-YsoCTnMY9NdVV8oZBEZ8AtpkE21cwqi7WjZhhN6fg,4133
+rpa_suite/email/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/email/sender_smtp.py,sha256=S7Far3fewuFRVPMWYPTIJSPRq89AZVbu2odX9a0QmZQ,6708
+rpa_suite/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/file/counter.py,sha256=MVyt7I-r23S5znHFk2Z4UbgoX0kD04YFsl4V5GOYcDU,2485
+rpa_suite/file/temp_dir.py,sha256=Al1j2654fIDgqTZvuBSo1WcjCVg-xbN_K-z-jnuzxGg,5904
+rpa_suite/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/log/loggin.py,sha256=sJCkKXZPsjhLJz7gKAmLQuMcvQkefvBlVl3nlhxVUXA,1343
+rpa_suite/log/printer.py,sha256=P3chs13qBnd7tvZEJSCQ39Kj8wZ2BmYNHOTJm3Unf6M,4073
+rpa_suite/validate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpa_suite/validate/mail_validator.py,sha256=PEa_-bON7BYnpaz-p5aEZkpza7qsoBBFKv6GwsjdjCU,2906
+rpa_suite/validate/string_validator.py,sha256=7eJVTCmzVwgM513NqAAjqvo9iqHmsWQ-6LQ8-oOh_0s,5344
+rpa_suite-0.8.2.dist-info/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
+rpa_suite-0.8.2.dist-info/METADATA,sha256=JUXRa-BLFoGWSZQb4nppF9jwy2TtLhKyFXHV0pU4EQw,5994
+rpa_suite-0.8.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+rpa_suite-0.8.2.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
+rpa_suite-0.8.2.dist-info/RECORD,,

rpa_suite/clock/exec_while.py

@@ -1,64 +0,0 @@
-import re
-from typing import Callable, Any
-from rpa_suite.date.date import get_hms
-from rpa_suite.log.printer import error_print, success_print
-
-def exec_wtime(
-                while_time: int,
-                fn_to_exec: Callable[..., Any],
-                *args,
-                **kwargs
-                ) -> dict:
-    
-    """
-    Função temporizada, executa uma função enquanto o tempo (em segundos) da condição não foi atendido.
-    
-    Parametros:
-    ----------
-        `while_time: int` - (segundos) representa o tempo que deve persistir a execução da função passada no argumento ``fn_to_exec``
-    
-        ``fn_to_exec: function`` - (função) a ser chamada (repetidas vezes) durante o temporizador, se houver parametros nessa função podem ser passados como próximos argumentos desta função em ``*args`` e ``**kwargs``
-    
-    Retorno:
-    ----------
-    >>> type:dict
-        * 'success': bool - representa se ação foi realizada com sucesso
-        
-    Exemplo:
-    ---------
-    Temos uma função de soma no seguinte formato ``soma(a, b) -> return x``, onde ``x`` é o resultado da soma. Supondo que temos o valor de `a` mas não de `b` podemos executar a função por um tempo `y` até obtermos valor de `b` para saber o resultado da soma:
-    >>> exec_wtime(60, soma, a, b) -> x \n
-        * OBS.:  `exec_wtime` recebe como primeiro argumento o tempo a aguardar (seg), depois a função `soma` e por fim os argumentos que a função ira usar.
-    """
-    
-    # Variáveis locais
-    result: dict = {
-        'success': bool
-    }
-    run: bool
-    timmer: int
-    
-    # Pré Tratamento
-    timmer = while_time
-    
-    # Processo
-    try:
-        run = True
-        hour, minute, second = get_hms()
-        while run and timmer > 0:
-            fn_to_exec(*args, **kwargs)
-            hour_now, minute_now, second_now = get_hms()
-            if second_now != second:
-                second = second_now
-                timmer =- 1
-                if timmer <= 0:
-                    run = False
-                    break
-        result['success'] = True
-        success_print(f'Função {fn_to_exec.__name__} foi executada durante: {while_time} seg(s).')
-        
-    except Exception as e:
-        result['success'] = False
-        error_print(f'Ocorreu algum erro que impediu a execução da função: {exec_wtime.__name__} corretamente. Erro: {str(e)}')
-        
-    return result

rpa_suite-0.8.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-rpa_suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/suite.py,sha256=QvPL_2bWW-XcbfstLZREXZAqT32aM-SD38x7jxpvyfs,2152
-rpa_suite/clock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/clock/exec_while.py,sha256=FjgpXZ4Dkzy5EEQPudVKt5aaYFTLEDQJRSqnNvNnbR0,2486
-rpa_suite/clock/waiter.py,sha256=z_5_QLYYztUo5-nbLp465OsY_lk6mR4z9-u6qNzDosM,3704
-rpa_suite/date/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/date/date.py,sha256=Kwowe997R0ml70M78zafgXrwwXiRqdhUATyHduTF8R0,2828
-rpa_suite/email/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/email/sender_smtp.py,sha256=Nn61OFP3-0LoiQ9DgkQYrJpIWFIxbPI6ua0ER7UHTWk,5253
-rpa_suite/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/file/counter.py,sha256=yx_ecoJkc3zxVF4UgYUI2tua4ziW0jYe6vFxTyIfnOw,1745
-rpa_suite/file/temp_dir.py,sha256=oZmfpC6utUcpaUnQI8j16NcgFDISmp5f5yXAwTevntY,4578
-rpa_suite/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/log/loggin.py,sha256=3f7JdA2zp6mTperx406zbud8v0miwhHLTkT2sxMy63M,872
-rpa_suite/log/printer.py,sha256=yzFO6MBgbsbaFzEnq9l0PcUTgb9fjQiPMAYDV20lhEA,2805
-rpa_suite/validate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rpa_suite/validate/mail_validator.py,sha256=9Ezyf8iopKsYQpNFK6hVs4REzR9wGGXRKGnrRXxV8Hw,2166
-rpa_suite/validate/string_validator.py,sha256=wvgh9ZRl6P62W-kNII3heKXhbYaZUoIOOnWkOFO1PH0,4052
-rpa_suite-0.8.1.dist-info/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
-rpa_suite-0.8.1.dist-info/METADATA,sha256=rzZgk3TUp-6cx5l22R636uKGpIvOC1WPuScVYElhLhU,5601
-rpa_suite-0.8.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-rpa_suite-0.8.1.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
-rpa_suite-0.8.1.dist-info/RECORD,,