rpa-suite 0.8.1__tar.gz → 0.8.3__tar.gz

{rpa_suite-0.8.1 → rpa_suite-0.8.3}/PKG-INFO

@@ -1,24 +1,29 @@
 Metadata-Version: 2.1
 Name: rpa_suite
-Version: 0.8.1
-Summary: Conjunto de ferramentas essenciais para RPA com Python, que facilitam o dia a dia de desenvolvimento.
+Version: 0.8.3
+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
+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
 Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE
 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 +37,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 +52,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 +121,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 +140,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.3**
 
-Lançamento: *04/12/2023*
+Lançamento: *05/12/2023*
 
 Status: Em desenvolvimento.
 

{rpa_suite-0.8.1 → rpa_suite-0.8.3}/README.md

@@ -1,4 +1,4 @@
-![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">
@@ -12,7 +12,7 @@
 -----------------
 
 ## 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
 
@@ -27,13 +27,13 @@
 
 ## 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)
@@ -96,7 +96,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**
@@ -114,9 +115,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.3**
 
-Lançamento: *04/12/2023*
+Lançamento: *05/12/2023*
 
 Status: Em desenvolvimento.
 

rpa_suite-0.8.3/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-0.8.1 → rpa_suite-0.8.3}/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-0.8.1 → rpa_suite-0.8.3}/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-0.8.1 → rpa_suite-0.8.3}/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-0.8.1 → rpa_suite-0.8.3}/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