rpa-suite 1.3.4__tar.gz → 1.3.5__tar.gz

{rpa_suite-1.3.4 → rpa_suite-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpa_suite
-Version: 1.3.4
+Version: 1.3.5
 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.5
 
 - 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.4 → rpa_suite-1.3.5}/README.md

@@ -148,7 +148,7 @@ Lançamento: *20/02/2024*
 
 Status: Em desenvolvimento.
 
-### Notas da atualização: 1.3.2
+### Notas da atualização: 1.3.5
 
 - 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.5/rpa_suite/__init__.py

@@ -0,0 +1,4 @@
+# rpa_suite/__init__.py
+
+from .suite import Suite as rpa
+rpa = rpa()

rpa_suite-1.3.5/rpa_suite/core/__init__.py

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

rpa_suite-1.3.5/rpa_suite/core/clock.py

@@ -0,0 +1,271 @@
+
+import time
+from typing import Callable, Any
+from datetime import datetime as dt
+from rpa_suite.functions._printer import error_print, success_print
+from typing import Callable, Any
+
+
+class Clock():
+
+    def __init__(self):
+        ...
+    
+    def exec_at_hour(self,
+                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:
+                        time.sleep(30)
+                        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: {self.exec_at_hour.__name__}. Error: {str(e)}')
+            return result
+
+
+    def wait_for_exec(self,
+                wait_time: int,
+                fn_to_exec: Callable[..., Any],
+                *args,
+                **kwargs
+                ) -> dict[str, bool]:
+    
+        """
+        Timer function, wait for a value in ``seconds`` to execute the function of the argument.
+        
+        Parameters:
+        ----------
+            `wait_time: int` - (seconds) represents the time that should wait before executing the function passed as an argument.
+        
+            ``fn_to_exec: function`` - (function) to be called after the waiting time, if there are parameters in this function they can be passed as next arguments of this function in ``*args`` and ``**kwargs``
+        
+        Return:
+        ----------
+        >>> type:dict
+            * 'success': bool - represents if the action was performed successfully
+            
+        Example:
+        ---------
+        We have a sum function in the following format ``sum(a, b) -> return x``, where ``x`` is the result of the sum. We want to wait `30 seconds` to execute this function, so:
+        >>> wait_for_exec(30, sum, 10, 5) -> 15 \n
+            * NOTE:  `wait_for_exec` receives as first argument the time to wait (sec), then the function `sum` and finally the arguments that the function will use.
+            
+        Description: pt-br
+        ----------    
+        Função temporizadora, aguardar um valor em ``segundos`` para executar a função do argumento.
+        
+        Parametros:
+        ----------
+            `wait_time: int` - (segundos) representa o tempo que deve aguardar antes de executar a função passada como argumento.
+        
+            ``fn_to_exec: function`` - (função) a ser chamada depois do tempo aguardado, se houver parametros nessa função podem ser passados como próximos argumentos desta função em ``*args`` e ``**kwargs``
+        
+        Retorno:
+        ----------
+        >>> type:dict
+            * 'success': bool - representa se ação foi realizada com sucesso
+            
+        Exemplo:
+        ---------
+        Temos uma função de soma no seguinte formato ``soma(a, b) -> return x``, onde ``x`` é o resultado da soma. Queremos aguardar `30 segundos` para executar essa função, logo:
+        >>> wait_for_exec(30, soma, 10, 5) -> 15 \n
+            * OBS.:  `wait_for_exec` recebe como primeiro argumento o tempo a aguardar (seg), depois a função `soma` e por fim os argumentos que a função ira usar.
+        """
+        
+        # Local Variables
+        result: dict = {
+            'success': bool
+        }
+        
+        # Process
+        try:
+            time.sleep(wait_time)
+            fn_to_exec(*args, **kwargs)
+            result['success'] = True
+            success_print(f'Function: {self.wait_for_exec.__name__} executed the function: {fn_to_exec.__name__}.')
+            
+        except Exception as e:
+            result['success'] = False
+            error_print(f'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
+        
+        return result
+
+
+    def exec_and_wait(self,
+                    wait_time: int,
+                    fn_to_exec: Callable[..., Any],
+                    *args,
+                    **kwargs
+                    ) -> dict[str, bool]:
+        
+        """
+        Timer function, executes a function and waits for the time in ``seconds``
+        
+        Parameters:
+        ----------
+            `wait_time: int` - (seconds) represents the time that should wait after executing the requested function
+        
+            ``fn_to_exec: function`` - (function) to be called before the time to wait, if there are parameters in this function they can be passed as an argument after the function, being: ``*args`` and ``**kwargs``
+        
+        Return:
+        ----------
+        >>> type:dict
+            * 'success': bool - represents if the action was performed successfully
+            
+        Example:
+        ---------
+        We have a sum function in the following format ``sum(a, b) -> return x``, where ``x`` is the result of the sum. We want to execute the sum and then wait `30 seconds` to continue the main code:
+        >>> wait_for_exec(30, sum, 10, 5) -> 15 \n
+            * NOTE:  `wait_for_exec` receives as first argument the time to wait (sec), then the function `sum` and finally the arguments that the function will use.
+            
+        Description: pt-br
+        ----------
+        Função temporizadora, executa uma função e aguarda o tempo em ``segundos``
+        
+        Parametros:
+        ----------
+            `wait_time: int` - (segundos) representa o tempo que deve aguardar após executar a função solicitada
+        
+            ``fn_to_exec: function`` - (função) a ser chamada antes do tempo para aguardar, se houver parametros nessa função podem ser passados como argumento depois da função, sendo: ``*args`` e ``**kwargs``
+        
+        Retorno:
+        ----------
+        >>> type:dict
+            * 'success': bool - representa se ação foi realizada com sucesso
+            
+        Exemplo:
+        ---------
+        Temos uma função de soma no seguinte formato ``soma(a, b) -> return x``, onde ``x`` é o resultado da soma. Queremos executar a soma e então aguardar `30 segundos` para continuar o código principal:
+        >>> wait_for_exec(30, soma, 10, 5) -> 15 \n
+            * OBS.:  `wait_for_exec` recebe como primeiro argumento o tempo a aguardar (seg), depois a função `soma` e por fim os argumentos que a função ira usar.
+        """
+        
+        # Local Variables
+        result: dict = {
+            'success': bool
+        }
+        
+        # Process
+        try:
+            fn_to_exec(*args, **kwargs)
+            time.sleep(wait_time)
+            result['success'] = True
+            success_print(f'Function: {self.wait_for_exec.__name__} executed the function: {fn_to_exec.__name__}.')
+            
+        except Exception as e:
+            result['success'] = False
+            error_print(f'Error while trying to wait to execute the function: {fn_to_exec.__name__} \nMessage: {str(e)}')
+        
+        return result
+
+

rpa_suite-1.3.5/rpa_suite/core/date.py

@@ -0,0 +1,138 @@
+# /date.py
+
+import datetime as dt
+from typing import Optional as Op
+from typing import Tuple
+from rpa_suite.functions._printer import error_print
+
+class Date():
+    
+    def __init__(self):
+        ...
+
+    def get_hms(self) -> Tuple[Op[str], Op[str], Op[str]]:
+        
+        """
+        Function to return hour, minute and second. The return is in the form of a tuple with strings being able to store and use the values individually.
+        
+        Treatment:
+        ----------
+        The function already does the treatment for values below 10 always keeping 2 decimal places in all results, the individual values are always in string format
+        
+        Return:
+        ----------
+        >>> type:tuple
+            * tuple('hh', 'mm', 'ss') - tuple with the values of hour, minute and second being able to be stored individually, the values are in string
+            
+        Example:
+        ---------
+        >>> hour, minute, second = get_hms() \n
+            * NOTE:  Note that it is possible to destructure the return to store simultaneously.
+            
+        Description: pt-br
+        ----------
+        Função para retornar hora, minuto e segundo. O retorno é em forma de tupla com strings podendo armazenar e usar os valores de forma individual.
+        
+        Tratamento:
+        ----------
+        A função já faz o tratamento para valores abaixo de 10 mantendo sempre 2 casas decimais em todos resultados, os valores individuais são sempre em formato string
+        
+        Retorno:
+        ----------
+        >>> type:tuple
+            * tuple('hh', 'mm', 'ss') - tupla com os valores de hora, minuto e segundo podendo ser armazenados individualmente, os valores são em string
+            
+        Exemplo:
+        ---------
+        >>> hora, minuto, segundo = get_hms() \n
+            * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
+        """
+        
+        # Local Variables
+        hours: str
+        minutes: str
+        seconds: str
+        
+        try:
+            # Preprocessing
+            now = dt.datetime.now()
+            hours: str = str(now.hour) if now.hour >= 10 else f"0{now.hour}"
+            minutes: str = str(now.minute) if now.minute >= 10 else f"0{now.minute}"
+            seconds: str = str(now.second) if now.second >= 10 else f"0{now.second}"
+            
+            # Process
+            try:
+                if len(hours) == 3 or len(minutes) == 3 or len(seconds) == 3:
+                    if len(seconds) == 3:
+                        seconds[1:]
+                    elif len(minutes) == 3:
+                        minutes[1:]
+                    elif len(hours) == 3:
+                        hours[1:]
+                        
+                return hours, minutes, seconds
+            
+            except Exception as e:
+
+                error_print(f'Unable to capture the time. Error: {str(e)}')
+                return None, None, None
+            
+        except Exception as e:
+            error_print(f'Error function: {self.get_hms.__name__}! Error: {str(e)}.')
+            return None, None, None
+
+
+    def get_dmy(self) -> Tuple[Op[str], Op[str], Op[str]]:
+        """
+        Function to return day, month and year. The return is in the form of a tuple with strings being able to store and use the values individually.
+        
+        Return:
+        ----------
+        >>> type:tuple
+            * tuple('dd', 'mm', 'yy') - tuple with the values of day, month and year being able to be stored individually
+            
+        Example:
+        ---------
+        >>> day, month, year = get_dmy() \n
+            * NOTE:  Note that it is possible to destructure the return to store simultaneously.
+            
+        Description: pt-br
+        ----------
+        Função para retornar dia, mes e ano. O retorno é em forma de tupla com strings podendo armazenar e usar os valores de forma individual.
+        
+        Retorno:
+        ----------
+        >>> type:tuple
+            * tuple('dd', 'mm', 'yy') - tupla com os valores de dia, mes e ano podendo ser armazenados individualmente
+            
+        Exemplo:
+        ---------
+        >>> dia, mes, ano = get_dmy() \n
+            * OBS.:  Note que é possivel desestruturar o retorno para armazenar de forma simultânea.
+        """
+        try:
+            # Local Variables
+            day_got: str
+            month_got: str
+            year_got: str
+            
+            # Preprocessing
+            now = dt.datetime.now()
+            
+            # Process
+            try:
+                day_got: str = str(now.day) if now.day >= 10 else f"0{now.day}"
+                month_got: str = str(now.month) if now.month >= 10 else f"0{now.month}"
+                year_got: str = str(now.year) if now.year >= 10 else f"0{now.year}"
+            
+                return day_got, month_got, year_got
+            
+            except Exception as e:
+
+                error_print(f'Unable to capture the time. Error: {str(e)}')
+                return None, None, None
+            
+        except Exception as e:
+            error_print(f'Erro function: {self.get_dmy.__name__}! Error: {str(e)}.')
+            return None, None, None
+

rpa_suite-1.3.5/rpa_suite/core/dir.py

@@ -0,0 +1,182 @@
+
+import os, shutil
+from typing import Union
+from rpa_suite.functions._printer import error_print, alert_print, success_print
+
+
+class Directory():
+    
+    def __init__(self):
+        ...
+
+    def create_temp_dir(self,
+                        path_to_create: str = 'default',
+                        name_temp_dir: str='temp') -> dict[str, Union[bool, str, None]]:
+
+        """
+        Function responsible for creating a temporary directory to work with files and etc. \n
+
+        Parameters:
+        ----------
+        ``path_to_create: str`` - should be a string with the full path pointing to the folder where the temporary folder should be created, if it is empty the ``default`` value will be used which will create a folder in the current directory where the file containing this function was called.
+
+        ``name_temp_dir: str`` - should be a string representing the name of the temporary directory to be created. If it is empty, the ``temp`` value will be used as the default directory name.
+
+        Return:
+        ----------
+        >>> type:dict
+            * 'success': bool - represents case the action was performed successfully
+            * 'path_created': str - path of the directory that was created on the process
+            
+        Description: pt-br
+        ----------
+        Função responsavel por criar diretório temporário para trabalhar com arquivos e etc. \n
+
+        Parametros:
+        ----------
+        ``path_to_create: str`` - deve ser uma string com o path completo apontando para a pasta onde deve ser criada a pasta temporaria, se estiver vazio sera usado valor ``default`` que criará pasta no diretório atual onde o arquivo contendo esta função foi chamada.
+
+        ``name_temp_dir: str`` - deve ser uma string representando o nome do diretório temporário a ser criado. Se estiver vazio, o valor ``temp`` será usado como o nome padrão do diretório.
+
+        Retorno:
+        ----------
+        >>> type:dict
+            * 'success': bool - representa se ação foi realizada com sucesso
+            * 'path_created': str - path do diretório que foi criado no processo
+        """
+        
+        # Local Variables
+        result: dict = {
+            'success': bool,
+            'path_created': str,
+        }
+        
+        try:
+            # by 'default', defines path to local script execution path
+            if path_to_create == 'default':
+                path_to_create: str = os.getcwd()
+
+            # Build path to new dir
+            full_path: str = os.path.join(path_to_create, name_temp_dir)
+
+            # Create dir in this block
+            try:
+
+                # Successefully created
+                os.makedirs(full_path, exist_ok=False)
+
+                result['success'] = True
+                result['path_created'] = fr'{full_path}'
+
+                success_print(f"Diretório:'{full_path}' foi criado com sucesso.")
+
+            except FileExistsError:
+                result['success'] = False
+                result['path_created'] = None
+                alert_print(f"Diretório:'{full_path}' já existe.")
+
+            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}'.")
+
+        except Exception as e:
+            result['success'] = False
+            result['path_created'] = None
+            error_print(f'Error capturing current path to create temporary directory! Error: {str(e)}')
+            
+        finally:
+            return result
+
+
+    def delete_temp_dir(self,
+                        path_to_delete: str = 'default',
+                        name_temp_dir: str='temp',
+                        delete_files: bool = False) -> dict[str, Union[bool, str, None]]:
+
+        """
+        Function responsible for deleting a temporary directory. \n
+        
+        Parameters:
+        ----------
+        ``path_to_delete: str`` - should be a string with the full path pointing to the folder where the temporary folder should be deleted, if it is empty the ``default`` value will be used which will delete a folder in the current directory where the file containing this function was called.
+
+        ``name_temp_dir: str`` - should be a string representing the name of the temporary directory to be deleted. If it is empty, the ``temp`` value will be used as the default directory name.
+
+        ``delete_files: bool`` - should be a boolean indicating whether to delete files in the directory. If it is False, files in the directory will not be deleted.
+
+        Return:
+        ----------
+        >>> type:dict
+            * 'success': bool - represents case the action was performed successfully
+            * 'path_deleted': str - path of the directory that was deleted on the process
+            
+        Description: pt-br
+        ----------
+        Função responsavel por deletar diretório temporário. \n
+
+        Parametros:
+        ----------
+        ``path_to_delete: str`` - deve ser uma string com o path completo apontando para a pasta onde deve ser deletada a pasta temporaria, se estiver vazio sera usado valor ``default`` que deletará pasta no diretório atual onde o arquivo contendo esta função foi chamada.
+
+        ``name_temp_dir: str`` - deve ser uma string representando o nome do diretório temporário a ser deletado. Se estiver vazio, o valor ``temp`` será usado como o nome padrão do diretório.
+
+        ``delete_files: bool`` - deve ser um booleano indicando se deve deletar arquivos no diretório. Se for False, arquivos no diretório não serão deletados.
+
+        Retorno:
+        ----------
+        >>> type:dict
+            * 'success': bool - representa se ação foi realizada com sucesso
+            * 'path_deleted': str - path do diretório que foi deletado no processo
+        """
+
+        # Local Variables
+        result: dict = {
+            'success': bool,
+            'path_deleted': str,
+        }
+
+        try:
+            # by 'default', defines path to local script execution path
+            if path_to_delete == 'default':
+                path_to_delete: str = os.getcwd()
+
+            # Build path to new dir
+            full_path: str = os.path.join(path_to_delete, name_temp_dir)
+
+            # Delete dir in this block
+            try:
+
+                # Check if directory exists
+                if os.path.exists(full_path):
+
+                    # Check if delete_files is True
+                    if delete_files:
+                        # Delete all files in the directory
+                        shutil.rmtree(full_path)
+
+                    else:
+                        # Delete the directory only
+                        os.rmdir(full_path)
+
+                    result['success'] = True
+                    result['path_deleted'] = fr'{full_path}'
+
+                    success_print(f"Diretório:'{full_path}' foi deletado com sucesso.")
+                else:
+                    result['success'] = False
+                    result['path_deleted'] = None
+                    alert_print(f"Diretório:'{full_path}' não existe.")
+
+            except PermissionError:
+                result['success'] = False
+                result['path_deleted'] = None
+                alert_print(f"Permissão negada: não é possível deletar o diretório '{full_path}'.")
+
+        except Exception as e:
+            result['success'] = False
+            result['path_deleted'] = None
+            error_print(f'Error capturing current path to delete temporary directory! Error: {str(e)}')
+            
+        finally:
+            return result