rpa-suite 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

rpa_suite/clock/waiter.py

@@ -1,139 +0,0 @@
-# /waiter.py
-
-import time
-from typing import Callable, Any
-from rpa_suite.log.printer import error_print, success_print
-
-def wait_for_exec(
-                wait_time: int,
-                fn_to_exec: Callable[..., Any],
-                *args,
-                **kwargs
-                ) -> dict[str, bool]:
-    
-    """
-    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:
-    ----------
-        `wait_time: int` - (segundos) representa o tempo que deve aguardar antes de executar a função passada como argumento.
-    
-        ``fn_to_exec: function`` - (função) a ser chamada depois do tempo aguardado, 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. Queremos aguardar `30 segundos` para executar essa função, logo:
-    >>> 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.
-    """
-    
-    # Local Variables
-    result: dict = {
-        'success': bool
-    }
-    
-    # Process
-    try:
-        time.sleep(wait_time)
-        fn_to_exec(*args, **kwargs)
-        result['success'] = True
-        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'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
-    
-    return result
-
-def exec_and_wait(
-                wait_time: int,
-                fn_to_exec: Callable[..., Any],
-                *args,
-                **kwargs
-                ) -> dict[str, bool]:
-    
-    """
-    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:
-    ----------
-        `wait_time: int` - (segundos) representa o tempo que deve aguardar após executar a função solicitada
-    
-        ``fn_to_exec: function`` - (função) a ser chamada antes do tempo para aguardar, se houver parametros nessa função podem ser passados como argumento depois da função, sendo: ``*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. Queremos executar a soma e então aguardar `30 segundos` para continuar o código principal:
-    >>> 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.
-    """
-    
-    # Local Variables
-    result: dict = {
-        'success': bool
-    }
-    
-    # Process
-    try:
-        fn_to_exec(*args, **kwargs)
-        time.sleep(wait_time)
-        result['success'] = True
-        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'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
-    
-    return result

rpa_suite/date/__init__.py

@@ -1 +0,0 @@
-# /__init__.py

rpa_suite/date/date.py

@@ -1,124 +0,0 @@
-# /date.py
-
-import datetime as dt
-from typing import Optional as Op
-from typing import Tuple
-from rpa_suite.log.printer import error_print
-
-
-def get_hms() -> Tuple[Op[str], Op[str], Op[str]]:
-    
-    """
-    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:
-    ----------
-    A função já faz o tratamento para valores abaixo de 10 mantendo sempre 2 casas decimais em todos resultados, os valores individuais são sempre em formato string
-    
-    Retorno:
-    ----------
-    >>> type:tuple
-        * tuple('hh', 'mm', 'ss') - tupla com os valores de hora, minuto e segundo podendo ser armazenados individualmente, os valores são em string
-        
-    Exemplo:
-    ---------
-    >>> hora, minuto, segundo = get_hms() \n
-        * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
-    """
-    
-    # Local Variables
-    hours: str
-    minutes: str
-    seconds: str
-    
-    # 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}"
-    
-    # Process
-    try:
-        if len(hours) == 3 or len(minutes) == 3 or len(seconds) == 3:
-            if len(seconds) == 3:
-                seconds[1:]
-            elif len(minutes) == 3:
-                minutes[1:]
-            elif len(hours) == 3:
-                hours[1:]
-                
-        return hours, minutes, seconds
-    
-    except Exception as e:
-
-        error_print(f'Unable to capture the time. Error: {str(e)}')
-        return None, None, None
-
-
-def get_dmy() -> Tuple[Op[str], Op[str], Op[str]]:
-    """
-    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_dmy() \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:
-    ----------
-    >>> type:tuple
-        * tuple('dd', 'mm', 'yy') - tupla com os valores de dia, mes e ano podendo ser armazenados individualmente
-        
-    Exemplo:
-    ---------
-    >>> dia, mes, ano = get_dmy() \n
-        * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
-    """
-    
-    # Local Variables
-    day_got: str
-    month_got: str
-    year_got: str
-    
-    # Preprocessing
-    now = dt.datetime.now()
-    
-    # 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}"
-        year_got: str = str(now.year) if now.year >= 10 else f"0{now.year}"
-    
-        return day_got, month_got, year_got
-    
-    except Exception as e:
-
-        error_print(f'Unable to capture the time. Error: {str(e)}')
-        return None, None, None

rpa_suite/email/__init__.py

@@ -1 +0,0 @@
-# /__init__.py

rpa_suite/email/sender_smtp.py

@@ -1,203 +0,0 @@
-# /sender_smtp.py
-
-import smtplib, os
-from email.mime.image import MIMEImage
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-from email.mime.base import MIMEBase
-from email import encoders
-from rpa_suite.log.printer import alert_print, error_print, success_print
-from rpa_suite.validate.mail_validator import email_validator
-
-def send_email(
-                email_from: str,
-                pass_from: str,
-                email_to: list[str],
-                subject_title: str,
-                body_message: str,
-                image_footer: str = None,
-                attachments: list[str] = None,
-                type_content: str = 'html',
-                smtp_server: str = 'smtp.office365.com',
-                smtp_port: int = 587,
-                authentication_tls: bool = True, 
-                ) -> 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.
-    ``image_footer: str`` - image footer of 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 - TLS), commum use 465 for SSL authentication 
-    ``authentication_tls: bool`` - authentication method (default True), if False use SSL authentication
-    
-    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
-    
-    Parametros:
-    ----------
-    ``email_from: str`` - email de quem ira enviar o email.
-    ``pass_from: str`` - senha da conta utilizada, aconselhado isolar a senha em outro local.
-    ``email_to: list[str]`` - lista de emails para os quais serão enviados os emails.
-    ``subject_title: str`` - titulo do email.
-    ``body_message: str``- mensagem do corpo do email.
-    ``image_footer: str`` - imagem de rodapé do corpo do email.
-    ``attachments: list[str]`` - lista com caminho de anexos se houver. (default None).
-    ``type_content: str`` - tipo de conteudo da mensagem pode ser 'plain' ou 'html' (default 'html').
-    ``smtp_server: str`` - servidor a ser utilizado para conectar com a conta de email (default 'smtp.office365.com')
-    ``smtp_port: int`` - porta a ser utilizada nesse servidor (default 587 - TLS), comum usar 465 para autenticação por SSL 
-    ``authentication_tls: bool`` - metódo de autenticação (default True), caso Falso usa autenticação por SSL
-    
-    Retorno:
-    ----------
-    >>> type:dict
-    um dicionário com todas informações que podem ser necessarias sobre os emails.
-    Sendo respectivamente:
-        * 'success': bool -  se houve pelo menos um envio com sucesso
-        * 'all_mails': list - lista de todos emails parametrizados para envio
-        * 'valid_mails': list - lista de todos emails validos para envio
-        * 'invalid_mails': list - lista de todos emails invalidos para envio
-        * 'qt_mails_sent': int - quantidade efetiva que foi realizado envio
-        * 'attchament': bool - se há anexos
-        * 'qt_attach': int - quantos anexos foram inseridos
-    """
-
-    # Local Variables
-    result: dict = {
-        'success': bool,
-        'all_mails': list,
-        'valid_mails': list,
-        'invalid_mails': list,
-        'qt_mails_sent': int,
-        'attchament': bool,
-        'qt_attach': int
-    }
-    email_valido = []
-    email_invalido = []
-    
-    # Preprocessing
-    result['success'] = False
-    result['qt_mails_sent'] = 0
-    result['attchament'] = False
-
-    msg = MIMEMultipart()
-    msg['From'] = email_from
-    msg['Subject'] = subject_title
-
-    # Email Body Content
-    msg.attach(MIMEText(body_message, type_content))
-    
-    # Add image Footer 
-    if image_footer:
-        try:
-            with open(image_footer, 'rb') as img:
-                msg_image = MIMEImage(img.read())
-                msg_image.add_header('Content-ID', '<logo>')
-                # Notice: Content-ID correlact at "cid" on tag <img> at body mail
-                msg.attach(msg_image)
-        except FileNotFoundError as e:
-            alert_print(f'File Not Found! Error: {str(e)}')
-        except Exception as e:
-            error_print(f'An Error ocurred, during set image: <{image_footer}> as MIMEImage! Error: {str(e)}')
-            
-    # Add Attachment
-    if attachments:
-        result['qt_attach'] = 0
-        result['attchament'] = True
-        for path_to_attach in attachments:
-            file_name = os.path.basename(path_to_attach)
-            attachs = open(path_to_attach, 'rb')
-            part = MIMEBase('application', 'octet-stream')
-            part.set_payload((attachs).read())
-            encoders.encode_base64(part)
-            part.add_header('Content-Disposition', "attachment; filename= %s" % file_name)
-            msg.attach(part)
-            result['qt_attach'] += 1
-    else:
-        result['attchament'] = False
-        result['qt_attach'] = 0
-
-    # SMTP server config
-    try:
-        
-        # authentication TLS True -> Using TLS
-        if authentication_tls:
-            
-            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()
-            
-        else: # authentication TLS False -> Using SSL
-            
-            # connect SMTP server using SSL
-            server_by_smtp = smtplib.SMTP_SSL(smtp_server, smtp_port)
-            server_by_smtp.login(email_from, pass_from)
-            email_content = msg.as_string()
-            
-        # Treats the email list before trying to send, keeping only valid emails
-        try:  
-            for emails in email_to:
-                try:
-                    v = email_validator.validate_email(emails)
-                    email_valido.append(emails)
-
-                except email_validator.EmailNotValidError:
-                    email_invalido.append(emails)
-
-        except Exception as e:
-            error_print(f'Error while trying to validate email list: {str(e)}')
-
-        # Attaches the treated email list to perform the sending
-        msg['To'] = ', '.join(email_valido)
-        for email in email_valido:
-            try:
-                server_by_smtp.sendmail(email_from, email, email_content)
-                result['qt_mails_sent'] += 1
-                result['all_mails'] = email_to
-
-            except smtplib.SMTPException as 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) Sent!')
-
-
-    except smtplib.SMTPException as e:
-        result['success'] = False
-        error_print(f'Error while trying sent Email: {str(e)}')
-        
-    finally:
-        server_by_smtp.quit()
-
-    # Postprocessing
-    result['valid_mails'] = email_valido
-    result['invalid_mails'] = email_invalido
-
-    return result

rpa_suite/file/__init__.py

@@ -1 +0,0 @@
-# /__init__.py

rpa_suite/file/counter.py

@@ -1,69 +0,0 @@
-# /counter.py
-
-import os
-from typing import Dict, List, Union
-from rpa_suite.log.printer import error_print, success_print
-
-
-def count_files(
-    dir_to_count: List[str] = ['.'], 
-    type_extension: str = '*',
-    display_message: bool = False,
-) -> Dict[str, Union[bool, int]]:
-
-    """
-    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:
-    ----------
-    ``dir_to_count: list`` - deve ser uma lista, aceita mais de um caminho para contar arquivos.
-    ``type_extension: str`` - deve ser uma string com o formato/extensão do tipo de arquivo que deseja ser buscado para contagem, se vazio por default sera usado ``*`` que contará todos arquivos.
-
-    Retorno:
-    ----------
-    >>> type:dict
-        * 'success': bool - representa se ação foi realizada com sucesso
-        * 'qt': int - numero que representa a quantidade de arquivos que foram contados
-    """
-
-
-    # Local Variables
-    result: dict = {
-        'success': False,
-        'qt': 0
-    }
-
-
-    # Process
-    try:
-        for dir in dir_to_count:
-            for current_dir, sub_dir, files in os.walk(dir):
-                for file in files:
-                    if type_extension == '*' or file.endswith(f'.{type_extension}'):
-                        result['qt'] += 1
-        result['success'] = True
-        
-        if display_message:
-            success_print(f'Function: {count_files.__name__} counted {result["qt"]} files.')
-
-    except Exception as e:
-        result['success'] = False
-        error_print(f'Error when trying to count files! Error: {str(e)}')
-
-    finally:
-        return result

rpa_suite/file/file_flag.py

@@ -1,103 +0,0 @@
-# /file_flag.py
-
-import os, time
-from rpa_suite import suite as rpa
-
-
-def file_flag_create(display_message: bool = True, path_to_create: str = None, name_file: str = 'running.flag') -> None:
-    """
-    Function responsible for create a file flag on root directory by default. Path, name file and display message was optional. \n
-
-    Parameters:
-    ----------
-    ``display_message: bool`` - should be boolean, True prints message on console.
-    ``path_to_create: str`` - should be a string, by default use root dir with "os.getcwd()".
-    ``name_file: str`` - should be a string, by default "running.flag".
-
-    Return:
-    ----------
-    >>> type:bool
-        * 'bool' - represents the result of performance this action
-
-    Description: pt-br
-    ----------
-    Função responsável por criar um arquivo de flag na raiz do projeto por padrão. O diretório, o nome do arquivo e a possibilidade de imprimir no console a mensagem de sucesso, são opcionais.
-
-    Parâmetros:
-    ----------
-    ``display_message: bool`` - deve ser booleano, True para o caso de imprimir no console a mensagem de resultado.
-    ``path_to_create: str`` - deve ser string, por padrão usa como raiz do projeto o comando "os.getcwd()".
-    ``name_file: str`` - deve ser string, por padrão "running.flag".
-    
-    Retorno:
-    ----------
-    >>> tipo: bool
-        * 'bool' - representa o resultado performado da ação
-    """
-    
-    try:
-        if path_to_create == None:
-            path_origin: str = os.getcwd()
-            full_path_with_name = fr'{path_origin}/{name_file}'
-        else:
-            full_path_with_name = fr'{path_to_create}/{name_file}'
-            
-        with open(full_path_with_name, 'w', encoding='utf-8') as file:
-            file.write('[T-BOT Crédit Simulation] running in realtime, waiting finish to new execution')
-            
-        if display_message: rpa.success_print("Flag file created.")
-        return True
-    
-    except Exception as e:
-        rpa.error_print(f'Erro na função file_scheduling_create: {str(e)}')
-        return False
-
-
-def file_flag_delete(display_message: bool = True, path_to_delete: str = None, name_file: str = 'running.flag') -> None:
-    """
-    Function responsible for delete a file flag on root directory by default. Path, name file and display message was optional. \n
-
-    Parameters:
-    ----------
-    ``display_message: bool`` - should be boolean, True prints message on console.
-    ``path_to_delete: str`` - should be a string, by default use root dir with "os.getcwd()".
-    ``name_file: str`` - should be a string, by default "running.flag".
-
-    Return:
-    ----------
-    >>> type:bool
-        * 'bool' - represents the result of performance this action
-
-    Description: pt-br
-    ----------
-    Função responsável por deletar um arquivo de flag na raiz do projeto por padrão. O diretório, o nome do arquivo e a possibilidade de imprimir no console a mensagem de sucesso, são opcionais.
-
-    Parâmetros:
-    ----------
-    ``display_message: bool`` - deve ser booleano, True para o caso de imprimir no console a mensagem de resultado.
-    ``path_to_delete: str`` - deve ser string, por padrão usa como raiz do projeto o comando "os.getcwd()".
-    ``name_file: str`` - deve ser string, por padrão "running.flag".
-    
-    Retorno:
-    ----------
-    >>> tipo: bool
-        * 'bool' - representa o resultado performado da ação
-    """
-    
-    try:
-
-        if path_to_delete == None:
-            path_origin: str = os.getcwd()
-            full_path_with_name = fr'{path_origin}/{name_file}'
-        else:
-            full_path_with_name = fr'{path_to_delete}/{name_file}'
-            
-        if os.path.exists(full_path_with_name):
-            os.remove(full_path_with_name)
-            if display_message: print("Flag file deleted.")
-        else:
-            rpa.alert_print("Flag file not found.")
-
-    except Exception as e:
-        rpa.error_print(f'Erro na função file_scheduling_delete: {str(e)}')
-        time.sleep(1)