rpa-suite 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

rpa_suite/clock/exec_at.py

@@ -1,133 +0,0 @@
-# /exec_at.py
-
-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(
-                time_waiting: int,
-                hour_to_exec: str,
-                fn_to_exec: Callable[..., Any],
-                *args,
-                **kwargs) -> dict[str, bool]:
-    
-    """
-    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
-    
-    try:
-        # 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:
-                    
-                    # interval to new validate hour
-                    if time_waiting:
-                        time.sleep(time_waiting)
-                    else:
-                        time.sleep(9)
-                        
-                    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
-    
-    except Exception as e:
-        
-        result['success'] = False
-        error_print(f'An error occurred on function from executing: {fn_to_exec.__name__}. Error: {str(e)}')
-        return result

rpa_suite/clock/scheduler.py

@@ -1,38 +0,0 @@
-# /scheduler.py
-
-import schedule
-import time
-import subprocess
-
-def run_python_script(script_path):
-    try:
-        subprocess.run(['python', script_path], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Erro ao executar o script {script_path}: {e}")
-
-def batch1():
-    # Substitua 'script1.py' pelo caminho do primeiro script Python que deseja executar
-    run_python_script('script1.py')
-
-def batch2():
-    # Substitua 'script2.py' pelo caminho do segundo script Python que deseja executar
-    run_python_script('script2.py')
-
-def batch3():
-    # Substitua 'script3.py' pelo caminho do terceiro script Python que deseja executar
-    run_python_script('script3.py')
-
-print("Aguardando nova execução...")
-
-# Horário para executar o primeiro batch (substitua com o horário desejado)
-schedule.every().day.at("08:00").do(batch1)
-
-# Horário para executar o segundo batch (substitua com o horário desejado)
-schedule.every().day.at("12:00").do(batch2)
-
-# Horário para executar o terceiro batch (substitua com o horário desejado)
-schedule.every().day.at("16:00").do(batch3)
-
-while True:
-    schedule.run_pending()
-    time.sleep(1)

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