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

rpa_suite/core/email.py

@@ -0,0 +1,343 @@
+# /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.functions._printer import alert_print, error_print, success_print
+from rpa_suite.core.validate import email_validator
+
+
+"""
+    smtp_server:str = "smtp.hostinger.com",
+    smtp_port:str = 465,
+    email_user:str = "bot@vettracode.com",
+    email_password:str = "Bot@#2025",
+    email_to: str = "camilo.costa1993@gmail.com",
+    attachments: list[str] = [],
+    subject_title: str = 'titulo teste',
+    body_message: str = '<p>mensagem de teste</p>'
+"""
+
+class Email():
+    
+    smtp_server:str = "smtp.hostinger.com",
+    smtp_port:str = 465,
+    email_user:str = "your_email@email.com",
+    email_password:str = "password",
+    email_to: str = "to@email.com",
+    attachments: list[str] = [],
+    subject_title: str = 'Test title',
+    body_message: str = '<p>Testing message body</p>'
+    auth_tls: bool = False,
+
+    def __init__(self):
+        ...
+
+    def send_smtp(
+        self,
+        email_user:str,
+        email_password:str,
+        email_to: str,
+        subject_title: str = 'Test title',
+        body_message: str = '<p>Testing message body</p>',
+        attachments: list[str] = [],
+        smtp_server:str = "smtp.hostinger.com",
+        smtp_port:str = 465,
+        auth_tls: bool = False,
+        display_message: bool = True,
+        ):
+
+        """
+        Envia um e-mail utilizando o servidor SMTP especificado.
+
+        Args:
+            smtp_server (str, optional): Endereço do servidor SMTP. 
+                Padrão: "smtp.hostinger.com".
+            smtp_port (str, optional): Porta do servidor SMTP. 
+                Padrão: 465.
+            email_user (str, optional): Usuário (e-mail) para autenticação no servidor SMTP. 
+                Padrão: "bot@vettracode.com".
+            email_password (str, optional): Senha para autenticação no servidor SMTP. 
+                Padrão: "Bot@#2025".
+            email_to (str, optional): Endereço de e-mail do destinatário. 
+                Padrão: "camilo.costa1993@gmail.com".
+            attachments (list[str], optional): Lista de caminhos de arquivos para anexar ao e-mail. 
+                Padrão: [].
+            subject_title (str, optional): Título (assunto) do e-mail. 
+                Padrão: 'titulo teste'.
+            body_message (str, optional): Corpo da mensagem do e-mail, em formato HTML. 
+                Padrão: '<p>mensagem de teste</p>'.
+
+        Returns:
+            None: Esta função não retorna nenhum valor explicitamente, mas imprime mensagens de sucesso ou falha no envio do e-mail.
+        """
+
+        try:
+            self.smtp_server = smtp_server
+            self.smtp_port = smtp_port
+            self.email_user = email_user
+            self.email_password = email_password
+            self.email_to = email_to
+            self.subject_title = subject_title
+            self.body_message = body_message
+            self.attachments = attachments
+            self.auth_tls = auth_tls
+
+            # Criando a mensagem
+            msg = MIMEMultipart()
+            msg['From'] = self.email_user
+            msg['To'] = ', '.join(self.email_to) if isinstance(self.email_to, list) else self.email_to
+            msg['Subject'] = str(self.subject_title)
+
+            # Corpo do e-mail
+            body = str(self.body_message)
+            msg.attach(MIMEText(body, 'html'))
+
+            # Anexos (opcional)
+            if self.attachments:
+                from email.mime.base import MIMEBase
+                from email import encoders
+                import os
+
+                for attachment_path in self.attachments:
+                    try:
+                        with open(attachment_path, "rb") as attachment:
+                            part = MIMEBase("application", "octet-stream")
+                            part.set_payload(attachment.read())
+                            encoders.encode_base64(part)
+                            part.add_header(
+                                "Content-Disposition",
+                                f"attachment; filename= {os.path.basename(attachment_path)}",
+                            )
+                            msg.attach(part)
+
+                    except Exception as e:
+                        error_print(f"Erro ao anexar o arquivo {attachment_path}: {str(e)}")
+
+            try:
+                if self.auth_tls:
+                    # Conectando ao servidor SMTP com TLS
+                    server = smtplib.SMTP(self.smtp_server, self.smtp_port)
+                    server.starttls()
+                    server.login(self.email_user, self.email_password)
+                else:
+                    # Conectando ao servidor SMTP com SSL
+                    server = smtplib.SMTP_SSL(self.smtp_server, self.smtp_port)
+                    server.login(self.email_user, self.email_password)
+
+                # Enviando o e-mail
+                server.sendmail(self.email_user, self.email_to, msg.as_string())
+                if display_message: success_print("E-mail enviado com sucesso!")
+
+                # Encerrando a conexão
+                server.quit()
+
+            except Exception as e:
+                alert_print(f"Falha ao enviar o e-mail: {str(e)}")
+
+        except Exception as e:
+            error_print(f"Ocorreu um erro geral na função sendmail: {str(e)}")
+
+
+
+    def send_by_smtp( self,
+                    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, 
+                    display_message: 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
+        """
+
+        try:
+            # 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 False -> Using SSL authentication
+                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: # auth with SSL
+                    
+                    # Conexão com o servidor SMTP usando 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
+                if display_message: 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
+        
+        except Exception as e:
+            error_print(f'Error function: {self.send_email.__name__}! Error: {str(e)}.')
+            return None

rpa_suite/core/file.py

@@ -0,0 +1,209 @@
+import os, time
+from datetime import datetime
+from rpa_suite.functions._printer import error_print, success_print, alert_print
+from rpa_suite.functions.__create_ss_dir import __create_ss_dir as create_ss_dir
+from colorama import Fore
+from typing import Dict, List, Union
+
+class File():
+    
+    def __init__(self):
+        self.__create_ss_dir = create_ss_dir
+
+    def screen_shot(self,
+                    file_name: str = 'screenshot',
+                    path_dir:str = None,
+                    save_with_date: bool = True,
+                    delay: int = 1, 
+                    use_default_path_and_name: bool = True,
+                    name_ss_dir:str = None,
+                    display_message: bool = False) -> str | None:
+
+        """
+        Function responsible for create a dir for screenshot, and file screenshot and save this in dir to create, if dir exists save it on original dir. By default uses date on file name. \n
+
+        Parameters:
+        ----------
+        ``file_path: str`` - should be a string, not have a default path.
+        ``file_name: str`` - should be a string, by default name is `screenshot`.
+        ``save_with_date: bool`` - should be a boolean, by default `True` save namefile with date `foo_dd_mm_yyyy-hh_mm_ss.png`.
+        ``delay: int`` - should be a int, by default 1 (represents seconds).
+
+        Return:
+        ----------
+        >>> type:str
+            * 'screenshot_path': str - represents the absulute path created for this file
+
+        Description: pt-br
+        ----------
+        Função responsável por criar um diretório para captura de tela, e arquivo de captura de tela e salvar isso no diretório a ser criado, se o diretório existir, salve-o no diretório original. Por padrão, usa a data no nome do arquivo.
+
+        Parâmetros:
+        ----------
+        ``file_path: str`` - deve ser uma string, não tem um caminho padrão.
+        ``file_name: str`` - deve ser uma string, por padrão o nome é `screenshot`.
+        ``save_with_date: bool`` - deve ser um booleano, por padrão `True` salva o nome do arquivo com a data `foo_dd_mm_yyyy-hh_mm_ss.png`.
+        ``delay: int`` - deve ser um int, por padrão 1 representado em segundo(s).
+        
+        Retorno:
+        ----------
+        >>> tipo: str
+            * 'screenshot_path': str - representa o caminho absoluto do arquivo criado
+        """
+
+        # proccess
+        try:
+            
+            try:
+                import pyautogui
+                import pyscreeze
+                
+            except ImportError:
+                raise ImportError(f"\nThe 'pyautogui' e 'Pillow' libraries are necessary to use this module. {Fore.YELLOW}Please install them with: 'pip install pyautogui pillow'{Fore.WHITE}")
+            
+            time.sleep(delay)
+
+            if not use_default_path_and_name:
+                result_tryed: dict = self.__create_ss_dir(path_dir, name_ss_dir)
+                path_dir = result_tryed['path_created']
+            else:
+                result_tryed: dict = self.__create_ss_dir()
+                path_dir = result_tryed['path_created']
+
+            
+            if save_with_date: # use date on file name
+                image = pyautogui.screenshot()
+                file_name = f'{file_name}_{datetime.today().strftime("%d_%m_%Y-%H_%M_%S")}.png'
+                path_file_screenshoted = os.path.join(path_dir, file_name)
+                
+                image.save(path_file_screenshoted)
+                
+                if display_message: success_print(path_file_screenshoted)
+                    
+                return path_file_screenshoted
+            
+            else: # not use date on file name
+                image = pyautogui.screenshot()
+                file_name = f'{file_name}.png'
+                path_file_screenshoted = os.path.join(path_dir, file_name)
+                
+                image.save(path_file_screenshoted)
+                
+                if display_message: success_print(path_file_screenshoted)
+                    
+                return path_file_screenshoted
+        
+        except Exception as e:
+
+            error_print(f'Error to execute function:{self.screen_shot.__name__}! Error: {str(e)}')
+            return None
+
+
+    def flag_create(self,
+                    name_file: str = 'running.flag',
+                    path_to_create: str = None,
+                    display_message: bool = True) -> None:
+        """
+        Cria um arquivo de sinalização indicando que o robô está em execuçã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: success_print("Flag file created.")
+
+        except Exception as e:
+            error_print(f'Erro na função file_scheduling_create: {str(e)}')
+
+
+    def flag_delete(self,
+                    name_file: str = 'running.flag',
+                    path_to_delete: str = None,
+                    display_message: bool = True,) -> None:
+        
+        """
+        Deleta o arquivo de sinalização indicando que o robô terminou a execuçã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: success_print("Flag file deleted.")
+            else:
+                alert_print("Flag file not found.")
+
+        except Exception as e:
+            error_print(f'Erro na função file_scheduling_delete: {str(e)}')
+            time.sleep(1)
+
+    def count_files(self,
+                    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: {self.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