rpa-suite 1.5.8__py3-none-any.whl → 1.6.0__py3-none-any.whl

rpa_suite/core/iris.py

@@ -0,0 +1,327 @@
+# rpa_suite/core/iris.py
+"""
+Iris (OCR-IA) module for document conversion using DocLing.
+
+This module provides a simplified interface for converting documents
+into various formats, optimized for RPA automation use.
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+# imports internal
+from rpa_suite.functions._printer import alert_print, error_print, success_print
+
+
+class ExportFormat(Enum):
+    """Supported export formats for document conversion."""
+    
+    MARKDOWN = "markdown"
+    DICT = "dict"
+    DOCTAGS = "doctags"
+    HTML = "html"
+    TEXT = "text"
+
+
+class IrisError(Exception):
+    """Custom exception for Iris class errors."""
+    
+    pass
+
+
+class Iris:
+    """
+    Iris (OCR-IA)
+    Document converter using the DocLing library.
+    
+    This class provides a simplified interface for converting documents
+    in various formats (PDF, images, text) to structured formats such as
+    Markdown, HTML, plain text, among others.
+    
+    Attributes:
+        engine: Instance of DocLing's DocumentConverter.
+        last_result: Last processed conversion result.
+        
+    Example:
+        >>> iris = Iris()
+        >>> content = iris.read_document("document.pdf", ExportFormat.MARKDOWN)
+        >>> print(content)
+    """
+    
+    # Supported file extensions
+    SUPPORTED_EXTENSIONS = {
+        '.pdf', '.txt', '.docx', '.doc', '.png', '.jpg', '.jpeg', 
+        '.tiff', '.bmp', '.webp', '.pptx', '.xlsx'
+    }
+    
+    def __init__(self, display_message: bool = False) -> None:
+        """
+        Initializes the Iris class with the document converter.
+        
+        Raises:
+            IrisError: If the DocLing library is not installed.
+        """
+        self._engine: Optional[Any] = None
+        self._last_result: Optional[Any] = None
+        self.display_message: bool = display_message
+        self._initialize_engine()
+    
+    def _initialize_engine(self) -> None:
+        """
+        Initializes the DocumentConverter engine.
+        
+        Raises:
+            IrisError: If the DocLing library is not available.
+        """
+        try:
+            from docling.document_converter import DocumentConverter
+            self._engine = DocumentConverter()
+            if self.display_message: success_print("Iris engine initialized successfully")
+        except ImportError as e:
+            error_msg = (
+                "The 'docling' library is not installed. "
+                "Run: python -m pip install docling"
+            )
+            error_print(f"Iris - {error_msg}")
+            error_print(f"Error importing DocLing: {e}")
+            raise IrisError(error_msg) from e
+    
+    @property
+    def engine(self) -> Any:
+        """Returns the DocumentConverter engine instance."""
+        return self._engine
+    
+    @property
+    def last_result(self) -> Optional[Any]:
+        """Returns the last processed conversion result."""
+        return self._last_result
+    
+    def _validate_file_path(self, file_path: Union[str, Path]) -> Path:
+        """
+        Validates the file path and returns a Path object.
+        
+        Args:
+            file_path: Path to the file.
+            
+        Returns:
+            Path: Validated Path object.
+            
+        Raises:
+            IrisError: If the file does not exist or is not supported.
+        """
+        path_obj = Path(file_path)
+        
+        if not path_obj.exists():
+            raise IrisError(f"File not found: {file_path}")
+        
+        if not path_obj.is_file():
+            raise IrisError(f"Path does not point to a file: {file_path}")
+        
+        if path_obj.suffix.lower() not in self.SUPPORTED_EXTENSIONS:
+            supported = ", ".join(sorted(self.SUPPORTED_EXTENSIONS))
+            raise IrisError(
+                f"Extension '{path_obj.suffix}' is not supported. "
+                f"Supported extensions: {supported}"
+            )
+        
+        return path_obj
+    
+    def _convert_document(self, file_path: Path) -> Any:
+        """
+        Converts the document using DocumentConverter.
+        
+        Args:
+            file_path: Path to the file.
+            
+        Returns:
+            Result of the DocLing conversion.
+            
+        Raises:
+            IrisError: If the conversion fails.
+        """
+        try:
+            if self.display_message: success_print(f"Starting conversion of file: {file_path}")
+            result = self._engine.convert(str(file_path))
+            self._last_result = result
+            if self.display_message: success_print("Conversion completed successfully")
+            return result
+        except Exception as e:
+            error_msg = f"Error converting document '{file_path}': {e}"
+            error_print(f"Iris - {error_msg}")
+            error_print(error_msg)
+            raise IrisError(error_msg) from e
+    
+    def _export_to_format(self, document: Any, export_format: ExportFormat) -> Any:
+        """
+        Exports the document to the specified format.
+        
+        Args:
+            document: Document converted by DocLing.
+            export_format: Desired export format.
+            
+        Returns:
+            Document in the specified format.
+            
+        Raises:
+            IrisError: If the export fails.
+        """
+        export_methods = {
+            ExportFormat.MARKDOWN: document.export_to_markdown,
+            ExportFormat.DICT: document.export_to_dict,
+            ExportFormat.DOCTAGS: document.export_to_doctags,
+            ExportFormat.HTML: document.export_to_html,
+            ExportFormat.TEXT: document.export_to_text,
+        }
+        
+        try:
+            export_method = export_methods[export_format]
+            return export_method()
+        except KeyError:
+            available_formats = ", ".join([fmt.value for fmt in ExportFormat])
+            raise IrisError(
+                f"Format '{export_format.value}' is not supported. "
+                f"Available formats: {available_formats}"
+            )
+        except Exception as e:
+            error_msg = f"Error exporting to format '{export_format.value}': {e}"
+            error_print(error_msg)
+            raise IrisError(error_msg) from e
+    
+    def read_document(
+        self,
+        file_path: Union[str, Path],
+        export_format: ExportFormat = ExportFormat.MARKDOWN,
+        verbose: bool = False,
+    ) -> Optional[Any]:
+        """
+        Reads and converts a document to the specified format.
+        
+        Args:
+            file_path: Path to the document file.
+            export_format: Desired export format.
+            verbose: If True, displays success messages.
+            
+        Returns:
+            Document converted to the specified format, or None if it fails.
+            
+        Raises:
+            IrisError: If an error occurs during validation, conversion, or export.
+            
+        Example:
+            >>> iris = Iris()
+            >>> content = iris.read_document("doc.pdf", ExportFormat.TEXT)
+            >>> print(content)
+        """
+        try:
+            # File validation
+            validated_path = self._validate_file_path(file_path)
+            
+            # Document conversion
+            conversion_result = self._convert_document(validated_path)
+            
+            # Conversion result check
+            if not conversion_result or not hasattr(conversion_result, 'document'):
+                raise IrisError("Invalid conversion result or document not found")
+            
+            # Export to desired format
+            formatted_result = self._export_to_format(
+                conversion_result.document, 
+                export_format
+            )
+            
+            if verbose:
+                success_print("Iris - Conversion completed successfully")
+            
+            success_print(
+                f"Document '{validated_path.name}' converted to '{export_format.value}'"
+            )
+            
+            return formatted_result
+            
+        except IrisError:
+            # Re-raise exceptions from the class itself
+            raise
+        except Exception as e:
+            error_msg = f"Unexpected error while processing document: {e}"
+            error_print(f"Iris - {error_msg}")
+            error_print(error_msg)
+            raise IrisError(error_msg) from e
+    
+    def read_multiple_documents(
+        self,
+        file_paths: List[Union[str, Path]],
+        export_format: ExportFormat = ExportFormat.MARKDOWN,
+        verbose: bool = False,
+    ) -> Dict[str, Optional[Any]]:
+        """
+        Reads and converts multiple documents.
+        
+        Args:
+            file_paths: List of file paths.
+            export_format: Desired export format.
+            verbose: If True, displays detailed messages.
+            
+        Returns:
+            Dictionary with the file name as key and converted content as value.
+            
+        Example:
+            >>> iris = Iris()
+            >>> files = ["doc1.pdf", "doc2.txt"]
+            >>> results = iris.read_multiple_documents(files, ExportFormat.TEXT)
+            >>> for filename, content in results.items():
+            ...     print(f"{filename}: {len(content) if content else 0} characters")
+        """
+        results = {}
+        successful_conversions = 0
+        
+        for file_path in file_paths:
+            try:
+                content = self.read_document(file_path, export_format, verbose=False)
+                filename = Path(file_path).name
+                results[filename] = content
+                successful_conversions += 1
+                
+                if verbose:
+                    if self.display_message: success_print(f"Iris - '{filename}' converted successfully")
+                    
+            except IrisError as e:
+                filename = Path(file_path).name
+                results[filename] = None
+                if verbose:
+                    error_print(f"Iris - Error converting '{filename}': {e}")
+                alert_print(f"Failed to convert '{filename}': {e}")
+        
+        if verbose:
+            total_files = len(file_paths)
+            if self.display_message: success_print(
+                f"Iris - Processing completed: {successful_conversions}/{total_files} "
+                f"files converted successfully"
+            )
+        
+        return results
+    
+    def get_supported_extensions(self) -> List[str]:
+        """
+        Returns the list of supported file extensions.
+        
+        Returns:
+            Sorted list of supported extensions.
+        """
+        return sorted(list(self.SUPPORTED_EXTENSIONS))
+    
+    def is_file_supported(self, file_path: Union[str, Path]) -> bool:
+        """
+        Checks if a file is supported by the class.
+        
+        Args:
+            file_path: Path to the file.
+            
+        Returns:
+            True if the file is supported, False otherwise.
+        """
+        try:
+            path_obj = Path(file_path)
+            return path_obj.suffix.lower() in self.SUPPORTED_EXTENSIONS
+        except Exception:
+            return False

rpa_suite/core/log.py

@@ -3,12 +3,14 @@
 # imports internal
 from rpa_suite.functions._printer import error_print, alert_print, success_print
 
-# imports external
+# imports third party
 from loguru import logger
 
-# imports third-party
+# imports standard
 from typing import Optional as Op
-import sys, os, inspect
+import sys
+import os
+import inspect
 
 
 class Filters:
@@ -83,13 +85,13 @@ class Log:
 
             try:
                 os.makedirs(self.full_path, exist_ok=True)
-                if display_message: success_print(f"Diretório:'{self.full_path}' foi criado com sucesso.")
+                if display_message:
+                    success_print(f"Diretório:'{self.full_path}' foi criado com sucesso.")
             except FileExistsError:
-                if display_message: alert_print(f"Diretório:'{self.full_path}' já existe.")
+                if display_message:
+                    alert_print(f"Diretório:'{self.full_path}' já existe.")
             except PermissionError:
-                alert_print(
-                    f"Permissão negada: não é possível criar o diretório '{self.full_path}'."
-                )
+                alert_print(f"Permissão negada: não é possível criar o diretório '{self.full_path}'.")
 
             new_filter = None
             if filter_words is not None:
@@ -104,9 +106,7 @@ class Log:
             formatter = CustomFormatter()
 
             if new_filter:
-                self.logger.add(
-                    file_handler, filter=new_filter, level="DEBUG", format=log_format
-                )
+                self.logger.add(file_handler, filter=new_filter, level="DEBUG", format=log_format)
             else:
                 self.logger.add(file_handler, level="DEBUG", format=log_format)
 
@@ -115,9 +115,7 @@ class Log:
             return file_handler
 
         except Exception as e:
-            error_print(
-                f"Houve um erro durante a execução da função: {self.config_logger.__name__}! Error: {str(e)}."
-            )
+            error_print(f"Houve um erro durante a execução da função: {self.config_logger.__name__}! Error: {str(e)}.")
             return None
 
     def _log(self, level: str, msg: str):
@@ -128,16 +126,16 @@ class Log:
             # Find the first frame that's not from this log.py file
             frame = inspect.currentframe()
             current_file = os.path.normpath(__file__)
-            
+
             while frame:
                 frame = frame.f_back
                 if frame and os.path.normpath(frame.f_code.co_filename) != current_file:
                     break
-            
+
             if not frame:
                 # Fallback if we can't find external caller
                 frame = inspect.currentframe().f_back.f_back
-                
+
             full_path_filename = frame.f_code.co_filename
 
             # Normalize path to use os.sep
@@ -157,9 +155,7 @@ class Log:
     def log_start_run_debug(self, msg_start_loggin: str) -> None:
         try:
             with open(self.file_handler, "a") as log_file:
-                log_file.write(
-                    "\n"
-                )  # Add a blank line before logging the start message
+                log_file.write("\n")  # Add a blank line before logging the start message
             self._log("DEBUG", msg_start_loggin)
         except Exception as e:
             error_print(

rpa_suite/core/parallel.py

@@ -1,6 +1,6 @@
 # rpa_suite/core/parallel.py
 
-# imports third-party
+# imports standard
 from multiprocessing import Process, Manager
 from typing import Any, Callable, Dict, Optional, TypeVar, Generic
 import time
@@ -177,9 +177,7 @@ class ParallelRunner(Generic[T]):
             return False
         return self._process.is_alive()
 
-    def get_result(
-        self, timeout: Optional[float] = 60, terminate_on_timeout: bool = True
-    ) -> Dict[str, Any]:
+    def get_result(self, timeout: Optional[float] = 60, terminate_on_timeout: bool = True) -> Dict[str, Any]:
         """
         Retrieves the result of the parallel execution.
 
@@ -234,27 +232,19 @@ class ParallelRunner(Generic[T]):
 
         # Debug - mostra o dicionário compartilhado
         if self.display_message:
-            print(
-                f"[Processo Principal] Dicionário compartilhado: {dict(self._result_dict)}"
-            )
+            print(f"[Processo Principal] Dicionário compartilhado: {dict(self._result_dict)}")
 
         # Verifica se o processo terminou ou se atingiu o timeout
         if self._process.is_alive():
             if terminate_on_timeout:
                 self._process.terminate()
-                self._process.join(
-                    timeout=1
-                )  # Pequeno timeout para garantir que o processo termine
+                self._process.join(timeout=1)  # Pequeno timeout para garantir que o processo termine
                 result["terminated"] = True
                 result["success"] = False
-                result["error"] = (
-                    f"Operação cancelada por timeout após {execution_time:.2f} segundos"
-                )
+                result["error"] = f"Operação cancelada por timeout após {execution_time:.2f} segundos"
             else:
                 result["success"] = False
-                result["error"] = (
-                    f"Operação ainda em execução após {execution_time:.2f} segundos"
-                )
+                result["error"] = f"Operação ainda em execução após {execution_time:.2f} segundos"
         else:
             # Processo terminou normalmente - verificamos o status
             status = self._result_dict.get("status", "unknown")
@@ -266,9 +256,7 @@ class ParallelRunner(Generic[T]):
                     result["result"] = self._result_dict["result"]
                 else:
                     result["success"] = False
-                    result["error"] = (
-                        "Resultado não encontrado no dicionário compartilhado"
-                    )
+                    result["error"] = "Resultado não encontrado no dicionário compartilhado"
             else:
                 result["success"] = False
                 result["error"] = self._result_dict.get("error", "Erro desconhecido")
@@ -276,9 +264,7 @@ class ParallelRunner(Generic[T]):
                     result["traceback"] = self._result_dict["traceback"]
 
         # Finaliza o Manager se o processo terminou e não estamos mais esperando resultado
-        if not self._process.is_alive() and (
-            result.get("success", False) or result.get("terminated", False)
-        ):
+        if not self._process.is_alive() and (result.get("success", False) or result.get("terminated", False)):
             self._cleanup()
 
         return result

rpa_suite/core/print.py

@@ -1,6 +1,6 @@
 # rpa_suite/core/print.py
 
-# imports external
+# imports third party
 from colorama import Fore
 
 
@@ -126,9 +126,7 @@ class Print:
         """
         print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def magenta_print(
-        self, string_text: str, color=Colors.magenta, ending="\n"
-    ) -> None:
+    def magenta_print(self, string_text: str, color=Colors.magenta, ending="\n") -> None:
         """
         Print customized with the color Magenta \n
 
@@ -162,9 +160,7 @@ class Print:
         """
         print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def print_call_fn(
-        self, string_text: str, color=Colors.call_fn, ending="\n"
-    ) -> None:
+    def print_call_fn(self, string_text: str, color=Colors.call_fn, ending="\n") -> None:
         """
         Print customized for function called (log) \n
         Color: Magenta Light
@@ -182,9 +178,7 @@ class Print:
         """
         print(f"{color}{string_text}{Colors.default}", end=ending)
 
-    def print_retur_fn(
-        self, string_text: str, color=Colors.retur_fn, ending="\n"
-    ) -> None:
+    def print_retur_fn(self, string_text: str, color=Colors.retur_fn, ending="\n") -> None:
         """
         Print customized for function return (log) \n
         Color: Yellow Light

rpa_suite/core/regex.py

@@ -1,11 +1,11 @@
 # rpa_suite/core/regex.py
 
+# imports standard
+import re
+
 # imports internal
 from rpa_suite.functions._printer import error_print, success_print
 
-# imports third-party
-import re
-
 
 class Regex:
     """

rpa_suite/core/validate.py

@@ -1,11 +1,11 @@
 # rpa_suite/core/mail_validator.py
 
+# imports third party
+import email_validator
+
 # imports internal
 from rpa_suite.functions._printer import error_print, success_print
 
-# imports external
-import email_validator
-
 
 class Validate:
     """
@@ -200,15 +200,11 @@ class Validate:
                     else:
                         words_lowercase = [word.lower() for word in origin_words]
                         searched_word_lower = searched_word.lower()
-                        result["number_occurrences"] = words_lowercase.count(
-                            searched_word_lower
-                        )
+                        result["number_occurrences"] = words_lowercase.count(searched_word_lower)
                         result["is_found"] = result["number_occurrences"] > 0
 
                 except Exception as e:
-                    return error_print(
-                        f"Unable to complete the search: {searched_word}. Error: {str(e)}"
-                    )
+                    return error_print(f"Unable to complete the search: {searched_word}. Error: {str(e)}")
 
             elif search_by == "string":
                 try:
@@ -218,20 +214,14 @@ class Validate:
                     else:
                         origin_text_lower = origin_text.lower()
                         searched_word_lower = searched_word.lower()
-                        result["number_occurrences"] = origin_text_lower.count(
-                            searched_word_lower
-                        )
+                        result["number_occurrences"] = origin_text_lower.count(searched_word_lower)
                         result["is_found"] = result["number_occurrences"] > 0
 
                 except Exception as e:
-                    return error_print(
-                        f"Unable to complete the search: {searched_word}. Error: {str(e)}"
-                    )
+                    return error_print(f"Unable to complete the search: {searched_word}. Error: {str(e)}")
 
         except Exception as e:
-            return error_print(
-                f"Unable to search for: {searched_word}. Error: {str(e)}"
-            )
+            return error_print(f"Unable to search for: {searched_word}. Error: {str(e)}")
 
         # Postprocessing
         if result["is_found"]:

rpa_suite/functions/__create_ss_dir.py

@@ -76,16 +76,12 @@ def __create_ss_dir(
         except PermissionError:
             result["success"] = False
             result["path_created"] = None
-            alert_print(
-                f"Permissão negada: não é possível criar o diretório '{full_path}'."
-            )
+            alert_print(f"Permissão negada: não é possível criar o diretório '{full_path}'.")
 
     except Exception as e:
         result["success"] = False
         result["path_created"] = None
-        error_print(
-            f"Error capturing current path to create screenshots directory! Error: {str(e)}"
-        )
+        error_print(f"Error capturing current path to create screenshots directory! Error: {str(e)}")
 
     finally:
         return result

rpa_suite/functions/__init__.py

@@ -1,3 +1,3 @@
 # rpa_suite/functions/__init__.py
 
-__version__ = '1.5.5'
+__version__ = "1.5.5"