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

rpa_suite/suite.py

@@ -1,149 +1,239 @@
-# suite.py
-
-"""
-This file is the heart of the library, acting as a central access point to all available submodules. It imports and instantiates all functions from the submodules into a single object, `Rpa_suite`, allowing users to access all functionalities of the library by importing just this object.
-
-The structure of the library has been designed to be modular and organized, with each submodule dedicated to a specific type of functionality. Each submodule is contained in its own folder, making the code easier to navigate and maintain.
-
-Upon installing the library, users only need to import the `Rpa_suite` object to have access to all available functions. This is done through the `invoke` function, which returns an instance of the `Rpa_suite` object.
-
-Here is an overview of the available submodules:
-
-- **CLOCK**: Functions related to time, such as waiting for an execution or executing at a specific hour.
-- **DATE**: Functions for working with dates.
-- **EMAIL**: Functions for sending emails.
-- **FILE**: Functions for working with files, such as counting files or creating temporary directories and screenshot too.
-- **LOG**: Functions for logging events and printing messages.
-- **REGEX**: Functions for working with regular expressions.
-- **VALIDATE**: Functions for validating inputs, such as emails or strings.
-
-Remember, to use the library, just do the following:
-
-    # On your project
-        from rpa_suite import suite as rpa
-
-    # call functions
-        rpa.success_print(f'This work!')
-
-"""
-
-"""MODULE CLOCK"""
-from .clock.waiter import wait_for_exec, exec_and_wait
-from .clock.exec_at import exec_at_hour
-
-
-"""MODULE DATE"""
-from .date.date import get_hms, get_dmy
-
-
-"""MODULE EMAIL"""
-from .email.sender_smtp import send_email
-
-
-"""MODULE FILE"""
-from .file.counter import count_files
-from .file.temp_dir import create_temp_dir, delete_temp_dir
-from .file.screen_shot import screen_shot
-from .file.file_flag import file_flag_create, file_flag_delete
-
-"""MODULE LOG"""
-# from .log.loggin import logging_decorator
-from .log.printer import alert_print, success_print, error_print, info_print, print_call_fn, print_retur_fn, magenta_print, blue_print
-
-from .log.logger_uru import config_logger
-from .log.functions_logger_uru import log_start_run_debug, log_debug, log_info, log_warning, log_error, log_critical
-
-
-"""MODULE REGEX"""
-from .regex.pattern_in_text import check_pattern_in_text
-
-
-"""MODULE VALIDATE"""
-from .validate.mail_validator import valid_emails
-from .validate.string_validator import search_str_in
-
-
-class Rpa_suite():
-
-    """
-    The ``Rpa_suite`` class is a generic representation of the modules, with the aim of centralizing all submodules for access through an instance of this representational Object. It contains variables pointed to the functions of the submodules present in the rpa-site.
-
-    Call
-    ----------
-    When calling the maintainer file of this class, an instance of this object will be invoked to be used or reused through another variable
-
-    Objective
-    ----------
-    Flexibility being able to call each submodule individually or by importing the representational object of all submodules.
-
-    Description: pt-br
-    ----------
-    Classe ``Rpa_suite`` é uma representação genérica do dos módulos, com objetivo de centralizar todos submódulos para acesso através de uma instância deste Objeto representacional. Ele contem variaveis apontadas para as funções dos submódulos presentes no rpa-site.
-
-    Chamada
-    ----------
-    Ao chamar o arquivo mantenedor desta classe, sera invocada uma instancia deste objeto para poder ser utilziado ou reutilizado através de outra variável
-
-    Objetivo
-    ----------
-    Flexibilidade podendo chamar cada submódulo de forma individual ou fazendo a importação do objeto representacional de todos submódulos.
-    """
-
-    # clock
-    wait_for_exec = wait_for_exec
-    exec_and_wait = exec_and_wait
-    exec_at_hour = exec_at_hour
-
-    # date
-    get_hms = get_hms
-    get_dmy = get_dmy
-
-    # email
-    send_email = send_email
-
-    # file
-    count_files = count_files
-    create_temp_dir = create_temp_dir
-    delete_temp_dir = delete_temp_dir
-    screen_shot = screen_shot
-    file_flag_create = file_flag_create
-    file_flag_delete = file_flag_delete
-    #clear_temp_dir = clear_temp_dir
-
-    # log - printer
-    alert_print = alert_print
-    success_print = success_print
-    error_print = error_print
-    info_print = info_print
-    print_call_fn = print_call_fn
-    print_retur_fn = print_retur_fn
-    magenta_print = magenta_print
-    blue_print = blue_print
+from .core.clock import Clock
+from .core.date import Date
+from .core.email import Email
+from .core.dir import Directory
+from .core.file import File
+from .core.log import Log
+from .core.print import Print
+from .core.regex import Regex
+from .core.validate import Validate
+from colorama import Fore
+
+# Windows bash colors
+class Colors():
+    black     = f'{Fore.BLACK}'
+    blue      = f'{Fore.BLUE}'
+    green     = f'{Fore.GREEN}'
+    cyan      = f'{Fore.CYAN}'
+    red       = f'{Fore.RED}'
+    magenta   = f'{Fore.MAGENTA}'
+    yellow    = f'{Fore.YELLOW}'
+    white     = f'{Fore.WHITE}'
+    default   = f'{Fore.WHITE}'
+    call_fn   = f'{Fore.LIGHTMAGENTA_EX}'
+    retur_fn  = f'{Fore.LIGHTYELLOW_EX}'
+
+class Suite():
     
-    # log - logger with file and prints
-    config_logger = config_logger
-    log_start_run_debug = log_start_run_debug
-    log_debug = log_debug
-    log_info = log_info
-    log_warning = log_warning
-    log_error = log_error
-    log_critical = log_critical
-
-    # regex
-    check_pattern_in_text = check_pattern_in_text
-
-    # validate
-    valid_emails = valid_emails
-    search_str_in = search_str_in
-
-# Create a instance of Rpa_suite
-
-# Define function to return this instance
-def invoke() -> Rpa_suite:
-
-    """
-    Function responsible for return a object Rpa_suite with access all modules by .name_module or use 'from rpa_suite import suite' to >>> suite.functions_avaliable()
-    """
-
-    suite = Rpa_suite()
-    return suite
+    clock: Clock = Clock()
+    date: Date = Date()
+    email: Email = Email()
+    directory: Directory = Directory()
+    file: File = File()
+    log: Log = Log()
+    printer: Print = Print()
+    regex: Regex = Regex()
+    validate: Validate = Validate()
+    
+    def __init__(self):
+        ...
+
+    def success_print(self,
+                        string_text: str,
+                        color=Colors.green,
+                        ending="\n") -> None:
+            """
+            Print that indicates ``SUCCESS``. Customized with the color Green \n
+
+            Return:
+            ----------
+                >>> type:None
+
+            pt-br
+            ----------
+            Print  que indica ``SUCESSO``. Personalizado com a cor Verde \n
+
+            Retorno:
+            ----------
+                >>> type:None
+            """
+            print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def alert_print(self,
+                    string_text: str,
+                    color=Colors.yellow,
+                    ending="\n") -> None:
+        """
+        Print that indicates ``ALERT``. Customized with the color Yellow \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``ALERTA``. Personalizado com a cor Amarelo \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def info_print(self,
+                    string_text: str,
+                    color=Colors.cyan,
+                    ending="\n") -> None:
+        """
+        Print that indicates ``INFORMATION``. Customized with the color Cyan \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``INFORMATIVO``. Personalizado com a cor Ciano \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def error_print(self, 
+                    string_text: str, 
+                    color=Colors.red, 
+                    ending="\n") -> None:
+        """
+        Print that indicates ``ERROR``. Customized with the color Red \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print que indica ``ERRO``. Personalizado com a cor Vermelho \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def magenta_print(self, 
+                        string_text: str,
+                        color=Colors.magenta,
+                        ending="\n") -> None:
+        """
+        Print customized with the color Magenta \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado com a cor Magenta \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending) 
+
+
+    def blue_print(self,
+                    string_text: str, 
+                    color=Colors.blue, 
+                    ending="\n") -> None:
+        """
+        Print customized with the color Blue \n
+
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado com a cor Azul \n
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+
+
+    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
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado para log de chamada de função. \n
+        Cor: Magenta Light
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+
+
+    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
+        Return:
+        ----------
+            >>> type:None
+
+        pt-br
+        ----------
+        Print personalizado para log de chamada de função. \n
+        Cor: Yellow Light
+        Retorno:
+        ----------
+            >>> type:None
+        """
+        print(f'{color}{string_text}{Colors.default}', end=ending)
+
+
+    def __install_all_libs(self):
+        """
+        Metodo responsavel por instalar todas libs para uso avançado do RPA-Suite com todas funcionalidades incluindo OCR e agente de IA
+        """
+
+        import subprocess
+        import sys
+
+        libs = [
+            'colorama',
+            'colorlog', 
+            'email_validator',
+            'loguru',
+            'openpyxl',
+            'pandas',
+            'pyautogui',
+            'selenium',
+            'typing',
+            'webdriver_manager'
+        ]
+
+        for lib in libs:
+            try:
+                subprocess.check_call([sys.executable, '-m', 'pip', 'install', lib])
+                self.success_print(f'Biblioteca {lib} instalada com sucesso!')
+
+            except subprocess.CalledProcessError:
+                self.error_print(f'Erro ao instalar biblioteca {lib}')

{rpa_suite-1.3.4.dist-info → rpa_suite-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpa_suite
-Version: 1.3.4
+Version: 1.3.6
 Summary: Conjunto de ferramentas essenciais para Automação RPA com Python, que facilitam o dia a dia de desenvolvimento.
 Author: Camilo Costa de Carvalho
 Author-email: camilo.carvalho@triasoftware.com.br
@@ -18,10 +18,13 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: loguru
 Requires-Dist: colorama
-Requires-Dist: email_validator
 Requires-Dist: colorlog
+Requires-Dist: email_validator
+Requires-Dist: loguru
+Requires-Dist: typing
+Requires-Dist: pillow
+Requires-Dist: openCV
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -183,7 +186,7 @@ Lançamento: *20/02/2024*
 
 Status: Em desenvolvimento.
 
-### Notas da atualização: 1.3.2
+### Notas da atualização: 1.3.6
 
 - Correções de bugs em diversas funções relacionadas a tempo: *exec_at_hour* , *wait_for_exec* , *exec_and_wait*
 - Correções de bugs com tempo superior a 10 minutos nas funções de data: *get_hms* e *get_dma*

rpa_suite-1.3.6.dist-info/RECORD

@@ -0,0 +1,25 @@
+rpa_suite/__init__.py,sha256=a01Ua3RpUt57HOYjAoBdjOhnnGIexnVxDrBmRLWgJvo,71
+rpa_suite/suite.py,sha256=o5xxt4oIJhKFnFeeFnf-Lue19KZlBUcMRA_9Dyc615w,6550
+rpa_suite/core/__init__.py,sha256=VROMsrhKGMqUlstH8cEqp5fwRVC12d3U3_XoxoKOzyg,28
+rpa_suite/core/clock.py,sha256=qGF_fn0_n19WX4GLtzCrwrJmna9HtzfrhLYramOGZm8,12709
+rpa_suite/core/date.py,sha256=dgg-A5GL67MPFP5_0Ie61ymC9pCyDmoVgCJ10zzStrw,5363
+rpa_suite/core/dir.py,sha256=cwwvlPeXFEsoVFdu38Jsfw98t3CbshdS79m5D_y2txQ,7848
+rpa_suite/core/email.py,sha256=zu0G6HEEIocV48RfQKAkwZIyEswwJ40RRSrNh5PEf-8,15098
+rpa_suite/core/file.py,sha256=AgXmlyU_AiJ54sKwa8aTWyCjVUfuFhC9-0_m6U6zS7Y,8916
+rpa_suite/core/log.py,sha256=t5TEMHuWMkx9psbbeIyPy3VHs8MJDaSh1h0rdMaYnro,10841
+rpa_suite/core/print.py,sha256=PvEBm7TNNdZFa_qNX67i1JmPVToTBe7I1tQ73B17Onk,5122
+rpa_suite/core/regex.py,sha256=Q2FRI-aUB6oUXunK_0f9sc5kfbZt1qnZb4w7YbzST2o,2602
+rpa_suite/core/validate.py,sha256=J23xB_nXymPKR8eNJb844LJ2OETSPwFT8m2JawbTVz0,9134
+rpa_suite/functions/__create_log_dir.py,sha256=-NjH3Mwv8Aa0EgZiD_TcdlSKbsoYl5EoYmPclFwjTKY,3325
+rpa_suite/functions/__create_ss_dir.py,sha256=WMuDDTxM5xWudQjftC7xPr6y3IdiXjVK-GfxkQNIo4c,3377
+rpa_suite/functions/__init__.py,sha256=aa0jejVvnghufR50owKcKpmYit7XVAliyN9gn9JkdLE,33
+rpa_suite/functions/_functions_logger.py,sha256=hlYDEUsmmfwaPlY_YQeNQEFeT_mryHBqgBVyRdxge48,2703
+rpa_suite/functions/_logger.py,sha256=gTYO9JlbX5_jDfu_4FTTajJw3_GotE2BHUbDDB1Hf5g,3643
+rpa_suite/functions/_printer.py,sha256=r72zeobAi2baVbYgbfFH0h5-WMv4tSDGPNlcpZen7O0,3949
+rpa_suite/functions/_variables.py,sha256=vCcktifFUriBQTyUaayZW8BlE8Gr7VP-tFbfomKOS5U,312
+rpa_suite/functions/_variables_uru.py,sha256=xRqYp49l1fFNrHczOmJ6Pqw1PKIWs0f9kxlgvuYGYys,303
+rpa_suite-1.3.6.dist-info/licenses/LICENSE,sha256=5D8PIbs31iGd9i1_MDNg4SzaQnp9sEIULALh2y3WyMI,1102
+rpa_suite-1.3.6.dist-info/METADATA,sha256=QoSFZO5O9geMr67jiVDgiq-cz5u4_a0cA9mOwciOR6Q,9348
+rpa_suite-1.3.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rpa_suite-1.3.6.dist-info/top_level.txt,sha256=HYkDtg-kJNAr3F2XAIPyJ-QBbNhk7q6jrqsFt10lz4Y,10
+rpa_suite-1.3.6.dist-info/RECORD,,

rpa_suite/clock/__init__.py

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

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)