rpa-suite 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

rpa_suite/core/email.py

@@ -9,8 +9,12 @@ from email.mime.base import MIMEBase
 from email import encoders
 
 # imports internal
-from rpa_suite.functions._printer import alert_print, error_print, success_print
+from rpa_suite.functions._printer import success_print
 
+class EmailError(Exception):
+    """Custom exception for Email errors."""
+    def __init__(self, message):
+        super().__init__(f'EmailError: {message}')
 
 class Email:
     """
@@ -80,7 +84,14 @@ class Email:
     body_message: str = "<p>Testing message body</p>"
     auth_tls: bool = (False,)
 
-    def __init__(self): ...
+    def __init__(self) -> None: 
+        """
+        Constructor function for the Email class that provides utilities for email management.
+        
+        This class offers functionalities for sending emails via SMTP protocol with support
+        for attachments, HTML formatting, and various SMTP server configurations.
+        """
+        pass
 
     def send_smtp(
         self,
@@ -93,7 +104,7 @@ class Email:
         smtp_server: str = "smtp.hostinger.com",
         smtp_port: str = 465,
         auth_tls: bool = False,
-        display_message: bool = True,
+        verbose: bool = True,
     ):
         """
         Sends an email using the specified SMTP server.
@@ -158,17 +169,17 @@ class Email:
             self.attachments = attachments
             self.auth_tls = auth_tls
 
-            # Criando a mensagem
+            # Creating the message
             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
+            # Email body
             body = str(self.body_message)
             msg.attach(MIMEText(body, "html"))
 
-            # Anexos (opcional)
+            # Attachments (optional)
             if self.attachments:
                 for attachment_path in self.attachments:
                     try:
@@ -183,29 +194,29 @@ class Email:
                             msg.attach(part)
 
                     except Exception as e:
-                        error_print(f"Erro ao anexar o arquivo {attachment_path}: {str(e)}")
+                        EmailError(f"Error attaching file {attachment_path}: {str(e)}")
 
             try:
                 if self.auth_tls:
-                    # Conectando ao servidor SMTP com TLS
+                    # Connecting to SMTP server with 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
+                    # Connecting to SMTP server with SSL
                     server = smtplib.SMTP_SSL(self.smtp_server, self.smtp_port)
                     server.login(self.email_user, self.email_password)
 
-                # Enviando o e-mail
+                # Sending the email
                 server.sendmail(self.email_user, self.email_to, msg.as_string())
-                if display_message:
-                    success_print("E-mail enviado com sucesso!")
+                if verbose:
+                    success_print("Email sent successfully!")
 
-                # Encerrando a conexão
+                # Closing the connection
                 server.quit()
 
             except Exception as e:
-                alert_print(f"Falha ao enviar o e-mail: {str(e)}")
+                EmailError(f"Failed to send email: {str(e)}")
 
         except Exception as e:
-            error_print(f"Ocorreu um erro geral na função sendmail: {str(e)}")
+            EmailError(f"A general error occurred in the sendmail function: {str(e)}")

rpa_suite/core/file.py

@@ -9,9 +9,13 @@ from typing import Dict, List, Union
 from colorama import Fore
 
 # imports internal
-from rpa_suite.functions._printer import error_print, success_print, alert_print
+from rpa_suite.functions._printer import success_print, alert_print
 from rpa_suite.functions.__create_ss_dir import __create_ss_dir as create_ss_dir
 
+class FileError(Exception):
+    """Custom exception for File errors."""
+    def __init__(self, message):
+        super().__init__(f'FileError: {message}')
 
 class File:
     """
@@ -65,7 +69,11 @@ class File:
     """
 
     def __init__(self):
-        self.__create_ss_dir = create_ss_dir
+        """Initialize the File class."""
+        try:
+            self.__create_ss_dir = create_ss_dir
+        except Exception as e:
+            raise FileError(f"Error trying execute: {self.__init__.__name__}! {str(e)}.")
 
     def screen_shot(
         self,
@@ -75,7 +83,7 @@ class File:
         delay: int = 1,
         use_default_path_and_name: bool = True,
         name_ss_dir: str | None = None,
-        display_message: bool = False,
+        verbose: 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
@@ -88,7 +96,7 @@ class File:
         ``delay: int`` - should be a int, by default 1 (represents seconds).
         ``use_default_path_and_name: bool`` - should be a boolean, by default `True`
         ``name_ss_dir: str`` - should be a string, by default type `None`
-        ``display_message`` - should be a boolean, by default `False`
+        ``verbose`` - should be a boolean, by default `False`
 
         Return:
         ----------
@@ -97,22 +105,22 @@ class 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.
+        Function responsible for creating a screenshot directory, and screenshot file and saving it in the directory to be created, if the directory exists, save it in the original directory. By default, uses date in the file name.
 
-        Parâmetros:
+        Parameters:
         ----------
-        ``file_name: str`` - deve ser uma string, por padrão o nome é `screenshot`.
-        ``file_path: str`` - deve ser uma string, não tem um caminho padrão.
-        ``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).
-        ``use_default_path_and_name: bool`` - deve ser um booleano, por padrão `True`
-        ``name_ss_dir: str`` - deve ser uma string, por padrão do tipo `None`
-        ``display_message`` - deve ser um booleano, por padrão `False`
-
-        Retorno:
+        ``file_name: str`` - should be a string, by default the name is `screenshot`.
+        ``file_path: str`` - should be a string, has no default path.
+        ``save_with_date: bool`` - should be a boolean, by default `True` saves the file name with date `foo_dd_mm_yyyy-hh_mm_ss.png`.
+        ``delay: int`` - should be an int, by default 1 represented in second(s).
+        ``use_default_path_and_name: bool`` - should be a boolean, by default `True`
+        ``name_ss_dir: str`` - should be a string, by default of type `None`
+        ``verbose`` - should be a boolean, by default `False`
+
+        Return:
         ----------
-        >>> tipo: str
-            * 'screenshot_path': str - representa o caminho absoluto do arquivo criado
+        >>> type: str
+            * 'screenshot_path': str - represents the absolute path of the created file
         """
 
         # proccess
@@ -143,9 +151,8 @@ class File:
 
                 image.save(path_file_screenshoted)
 
-                if display_message:
+                if verbose:
                     success_print(path_file_screenshoted)
-
                 return path_file_screenshoted
 
             else:  # not use date on file name
@@ -155,24 +162,21 @@ class File:
 
                 image.save(path_file_screenshoted)
 
-                if display_message:
+                if verbose:
                     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
+            FileError(f"Error to execute function:{self.screen_shot.__name__}! Error: {str(e)}")
 
     def flag_create(
         self,
         name_file: str = "running.flag",
         path_to_create: str | None = None,
-        display_message: bool = True,
+        verbose: bool = True,
     ) -> None:
         """
-        Cria um arquivo de sinalização indicando que o robô está em execução.
+        Creates a flag file indicating that the robot is running.
         """
 
         try:
@@ -184,20 +188,20 @@ class File:
 
             with open(full_path_with_name, "w", encoding="utf-8") as file:
                 file.write("[RPA Suite] - Running Flag File")
-            if display_message:
+            if verbose:
                 success_print("Flag file created.")
 
         except Exception as e:
-            error_print(f"Erro na função file_scheduling_create: {str(e)}")
+            FileError(f"Error in function file_scheduling_create: {str(e)}")
 
     def flag_delete(
         self,
         name_file: str = "running.flag",
         path_to_delete: str | None = None,
-        display_message: bool = True,
+        verbose: bool = True,
     ) -> None:
         """
-        Deleta o arquivo de sinalização indicando que o robô terminou a execução.
+        Deletes the flag file indicating that the robot has finished execution.
         """
 
         try:
@@ -210,20 +214,19 @@ class File:
 
             if os.path.exists(full_path_with_name):
                 os.remove(full_path_with_name)
-                if display_message:
+                if verbose:
                     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)
+            FileError(f"Error in function file_scheduling_delete: {str(e)}") from e
 
     def count_files(
         self,
         dir_to_count: List[str] = ["."],
         type_extension: str = "*",
-        display_message: bool = False,
+        verbose: 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
@@ -241,18 +244,18 @@ class File:
 
         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
+        Function responsible for counting files within a folder, considers subfolders to do the count, searches by file type, being all files by default. \n
 
-        Parametros:
+        Parameters:
         ----------
-        ``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.
+        ``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.
 
-        Retorno:
+        Return:
         ----------
         >>> type:dict
-            * 'success': bool - representa se ação foi realizada com sucesso
-            * 'qt': int - numero que representa a quantidade de arquivos que foram contados
+            * 'success': bool - represents if the action was performed successfully
+            * 'qt': int - number that represents the quantity of files that were counted
         """
 
         # Local Variables
@@ -267,11 +270,11 @@ class File:
                             result["qt"] += 1
             result["success"] = True
 
-            if display_message:
+            if verbose:
                 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)}")
+            FileError(f"Error when trying to count files! Error: {str(e)}")
 
         return result

rpa_suite/core/iris.py

@@ -1,108 +1,131 @@
 # rpa_suite/core/iris.py
 
 """
-Iris (OCR-IA) módulo para conversão de documentos usando DocLing.
+Iris (OCR-AI) module for document conversion using DocLing.
 
-Este módulo fornece uma interface simplificada para converter documentos
-em vários formatos, otimizado para uso em automação RPA.
+This module provides a simplified interface for converting documents
+in various formats, optimized for use in RPA automation.
 """
 
-# imports externos
+# external imports
 try:
-    from docling.document_converter import DocumentConverter
+    from docling.document_converter import DocumentConverter as IrisEngine
 except ImportError as e:
-    raise ImportError("Iris - Error: Não foi possível importar 'docling.document_converter'. Certifique-se de que a biblioteca 'docling' está instalada.") from e
+    raise ImportError("Iris - Error: Could not import 'docling.document_converter'. Make sure the 'docling' library is installed.") from e
 
-# imports de terceiros
+# third party imports
 from enum import Enum
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Optional, Union
 
-# imports internos
-from rpa_suite.functions._printer import alert_print, error_print, success_print
+# internal imports
+from rpa_suite.functions._printer import success_print
 
 class IrisError(Exception):
-    """Exceção personalizada para erros do Iris."""
+    """Custom exception for Iris errors."""
     def __init__(self, message):
-        super().__init__(f'Iris - Error: {message}')
+        # Remove "Iris Error:" from message if it already exists, as it will be added by default
+        clean_message = message.replace("Iris Error:", "").strip()
+        super().__init__(f'Iris Error: {clean_message}')
 
 class ExportFormats(Enum):
-    """Formatos de exportação suportados para conversão de documentos."""
+    """Supported export formats for document conversion."""
     MARKDOWN = "markdown"
     DICT = "dict"
     DOCTAGS = "doctags"
     HTML = "html"
     TEXT = "text"
+    INDENTEDTEXT = "indented_text"
 
 class Iris:
     """
-    Iris (OCR-IA)
-    Conversor de documentos usando a biblioteca DocLing.
-
-    Esta classe fornece uma interface simplificada para converter documentos
-    em vários formatos (PDF, imagens, texto) para formatos estruturados como
-    Markdown, HTML, texto simples, entre outros.
-
-    Atributos:
-        engine: Instância do DocumentConverter do DocLing.
-        last_result: Último resultado de conversão processado.
-
-    Exemplo:
+    Iris (OCR-AI)
+    Document converter with support for multiple extensions.
+
+    This class provides a simplified interface to convert documents
+    in various formats (PDF, images, text) to structured formats like
+    Markdown, HTML, plain text, among others.
+
+    Attributes:
+        ``engine:`` IrisEngine instance.
+        ``last_result:`` Last processed conversion result.
+        ``list_results:`` List of results generated by batch processing with: ``read_documents``
+    
+    On Error:
+        Raise ``IrisError``: If the document conversion fails.
+
+    Example:
+        >>> from rpa_suite.core import ExportFormats
         >>> iris = Iris()
         >>> content = iris.read_document("document.pdf", ExportFormats.MARKDOWN)
         >>> print(content)
     """
 
-    engine: Optional[DocumentConverter]
+    engine: Optional[IrisEngine]
+    last_result = None
+    list_results = list | None
 
     def __init__(self) -> None:
         """
-        Inicializa a classe Iris com o conversor de documentos.
-
-        Levanta:
-            IrisError: Se a biblioteca DocLing não estiver instalada.
+        Iris (OCR-AI)
+        Document converter with support for multiple extensions.
+
+        This class provides a simplified interface to convert documents
+        in various formats (PDF, images, text) to structured formats like
+        Markdown, HTML, plain text, among others.
+
+        Attributes:
+            ``engine:`` IrisEngine instance.
+            ``last_result:`` Last processed conversion result.
+            ``list_results:`` List of results generated by batch processing with: ``read_documents``
+        
+        On Error:
+            Raise ``IrisError``: If the document conversion fails.
+
+        Example:
+            >>> from rpa_suite.core import ExportFormats
+            >>> iris = Iris()
+            >>> content = iris.read_document("document.pdf", ExportFormats.MARKDOWN)
+            >>> print(content)
         """
         try:
-            self.iris_converter = DocumentConverter()
-            self.engine = self.iris_converter
-            self.path_file = None
+            self.engine = IrisEngine()
             self.result_converted = None
-            self.result_formatted = None
+            self.last_result = None
+            self.list_results = []
+            
         except Exception as e:
-            error_print("Iris - Error: Falha ao inicializar o DocumentConverter.")
-            raise IrisError(f"Falha ao inicializar o DocumentConverter: {e}")
+            raise IrisError(f"Failed to initialize DocumentConverter: {str(e)}.")
 
     def __convert_document(self, path_file: str = None):
         """
-        Converte o documento informado pelo caminho.
+        Converts the document specified by the path.
 
-        Levanta:
-            IrisError: Se ocorrer erro na conversão do documento.
+        Raises:
+            ``IrisError:`` If an error occurs during document conversion.
         """
         try:
             if not path_file:
-                raise IrisError("Caminho do arquivo não informado para conversão.")
-            self.result_converted = self.iris_converter.convert(path_file)
+                raise IrisError("Specify the file path for conversion.")
+            self.result_converted = self.engine.convert(path_file)
         except Exception as e:
-            error_print(f"Iris - Error: Falha ao converter o documento: {e}")
-            raise IrisError(f"Falha ao converter o documento: {e}")
+            raise IrisError(f"Error trying to convert document! {str(e)}.")
 
     def read_document(self, file_path: str = None, result_format=ExportFormats.MARKDOWN, verbose: bool = False) -> Optional[Union[str, dict]]:
         """
-        Lê e converte um documento para o formato especificado.
+        Reads and converts a document to the specified format.
 
         Args:
-            file_path: Caminho para o arquivo do documento.
-            result_format: Formato de exportação desejado.
-            verbose: Se True, exibe mensagens de sucesso.
+            ``file_path:`` Path to the document file.
+            ``result_format:`` Desired export format.
+            ``verbose:`` If True, displays success messages.
 
-        Retorna:
-            Documento convertido para o formato especificado, ou None se falhar.
+        Returns:
+            Document converted to the specified format, or None if it fails.
 
-        Levanta:
-            IrisError: Se ocorrer erro durante validação, conversão ou exportação.
+        Raises:
+            ``IrisError:`` If an error occurs during validation, conversion or export.
 
-        Exemplo:
+        Example:
             >>> iris = Iris()
             >>> content = iris.read_document("doc.pdf", ExportFormats.TEXT)
             >>> print(content)
@@ -111,30 +134,83 @@ class Iris:
             self.__convert_document(file_path)
 
             if not self.result_converted or not hasattr(self.result_converted, 'document'):
-                raise IrisError("Conversão falhou ou objeto retornado inválido.")
+                raise IrisError("Failed to convert file or invalid object resulted.")
 
             if result_format == ExportFormats.MARKDOWN:
-                self.result_formatted = self.result_converted.document.export_to_markdown()
+                self.last_result = self.result_converted.document.export_to_markdown()
             elif result_format == ExportFormats.DICT:
-                self.result_formatted = self.result_converted.document.export_to_dict()
+                self.last_result = self.result_converted.document.export_to_dict()
             elif result_format == ExportFormats.DOCTAGS:
-                self.result_formatted = self.result_converted.document.export_to_doctags()
+                self.last_result = self.result_converted.document.export_to_doctags()
             elif result_format == ExportFormats.HTML:
-                self.result_formatted = self.result_converted.document.export_to_html()
+                self.last_result = self.result_converted.document.export_to_html()
             elif result_format == ExportFormats.TEXT:
-                self.result_formatted = self.result_converted.document.export_to_text()
+                self.last_result = self.result_converted.document.export_to_text()
+            elif result_format == ExportFormats.INDENTEDTEXT:
+                self.last_result = self.result_converted.document._export_to_indented_text()
             else:
-                alert_print(f'Iris - Error: Formato não suportado: {result_format}.')
-                raise IrisError(f"Formato não suportado: {result_format}.")
-
+                raise IrisError(f"Not supported format: {result_format}.")
             if verbose:
-                success_print('Irir - Convertido com sucesso!')
+                success_print('Iris: Successfully converted!')
 
-            return self.result_formatted
-
-        except IrisError as ie:
-            error_print(str(ie))
-            return None
+            return self.last_result
         except Exception as e:
-            error_print(f"Iris - Error: Erro inesperado ao ler o documento: {e}")
-            raise IrisError(f"Erro inesperado ao ler o documento: {e}")
+            raise IrisError(f"Error trying to read document: {str(e)}.")
+
+    def read_documents(self, list_file_path: list[str] = None, result_format=ExportFormats.MARKDOWN, verbose: bool = False) -> Optional[list]:
+        """
+        Reads and converts multiple documents to the specified format.
+
+        Args:
+            ``list_file_path:`` List of documents in path format.
+            ``result_format:`` Desired export format.
+            ``verbose:`` If True, displays success messages.
+
+        Returns:
+            ``List`` of documents converted to the specified format, or None if it fails.
+
+        Raises:
+            ``IrisError:`` If an error occurs during validation, conversion or export.
+
+        Example:
+            >>> iris = Iris()
+            >>> contents = iris.read_documents(["doc.pdf", "doc2.docx"], ExportFormats.TEXT)
+            >>> print(contents)
+        """
+        self.list_results = []
+        
+        for file_path in list_file_path:
+            try:
+                self.__convert_document(file_path)
+
+                if not self.result_converted or not hasattr(self.result_converted, 'document'):
+                    raise IrisError("Failed to convert file or invalid object resulted.")
+
+                if result_format == ExportFormats.MARKDOWN:
+                    self.last_result = self.result_converted.document.export_to_markdown()
+                    self.list_results.append(self.last_result)
+                elif result_format == ExportFormats.DICT:
+                    self.last_result = self.result_converted.document.export_to_dict()
+                    self.list_results.append(self.last_result)
+                elif result_format == ExportFormats.DOCTAGS:
+                    self.last_result = self.result_converted.document.export_to_doctags()
+                    self.list_results.append(self.last_result)
+                elif result_format == ExportFormats.HTML:
+                    self.last_result = self.result_converted.document.export_to_html()
+                    self.list_results.append(self.last_result)
+                elif result_format == ExportFormats.TEXT:
+                    self.last_result = self.result_converted.document.export_to_text()
+                    self.list_results.append(self.last_result)
+                elif result_format == ExportFormats.INDENTEDTEXT:
+                    self.last_result = self.result_converted.document._export_to_indented_text()
+                    self.list_results.append(self.last_result)
+                else:
+                    raise IrisError(f"Not supported format: {result_format}.")
+                if verbose:
+                    success_print('Iris: Successfully converted!')
+            except IrisError as ie:
+                raise ie from ie
+            except Exception as e:
+                raise IrisError(f"Error trying to read documents: {str(e)}.")
+
+        return self.list_results