rpa-suite 1.5.3__py3-none-any.whl → 1.5.4__py3-none-any.whl

rpa_suite/core/clock.py

@@ -9,19 +9,18 @@ from typing import Callable, Any
 from datetime import datetime as dt
 
 
-class Clock():
-    
+class Clock:
     """
     Class that provides utilities for time manipulation and stopwatch.
-    
+
     This class offers functionalities for:
         - Timed function execution
         - Execution time control
         - Task scheduling
-        
+
     Methods:
         exec_at_hour: Executes a function at a specific time
-        
+
     The Clock class is part of RPA Suite and can be accessed through the rpa object:
         >>> from rpa_suite import rpa
         >>> rpa.clock.exec_at_hour("14:30", my_function)
@@ -29,110 +28,108 @@ class Clock():
     pt-br
     ----------
     Classe que fornece utilitários para manipulação de tempo e cronômetro.
-    
+
     Esta classe oferece funcionalidades para:
         - Execução temporizada de funções
         - Controle de tempo de execução
         - Agendamento de tarefas
-        
+
     Métodos:
         exec_at_hour: Executa uma função em um horário específico
-        
+
     A classe Clock é parte do RPA Suite e pode ser acessada através do objeto rpa:
         >>> from rpa_suite import rpa
         >>> rpa.clock.exec_at_hour("14:30", minha_funcao)
     """
 
-    def __init__(self):
-        ...
-        
-    def exec_at_hour(self,
-                hour_to_exec: str | None,
-                fn_to_exec: Callable[..., Any],
-                *args,
-                **kwargs,
-                ) -> dict[str, bool]:
-    
+    def __init__(self): ...
+
+    def exec_at_hour(
+        self,
+        hour_to_exec: str | None,
+        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
-        }
+        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}'
-            
+            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!')
+                        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)}')
+                        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.
@@ -141,168 +138,168 @@ class Clock():
                         try:
                             fn_to_exec(*args, **kwargs)
                             run = False
-                            result['tried'] = not run
-                            result['success'] = True
-                            success_print(f'{fn_to_exec.__name__}: Successfully executed!')
+                            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)}')
+                            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}'
+                        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
 
+            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]:
-    
+    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.
-            
-        
+
+
         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
-        }
-        
+        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__}.')
-            
+            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
+            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]:
-        
+    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.
-        
-        
+
+
         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
-        }
-        
+        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
+            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/core/date.py

@@ -9,19 +9,18 @@ from typing import Optional as Op
 from typing import Tuple
 
 
-class Date():
-    
+class Date:
     """
     Class that provides utilities for date manipulation and formatting.
-    
+
     This class offers functionalities for:
         - Getting current time components (hours, minutes, seconds)
         - Date formatting and manipulation
         - Date validation and conversion
-        
+
     Methods:
         get_hms: Returns current time as tuple of hour, minute, second
-        
+
     The Date class is part of RPA Suite and can be accessed through the rpa object:
         >>> from rpa_suite import rpa
         >>> hour, minute, second = rpa.date.get_hms()
@@ -29,72 +28,71 @@ class Date():
     pt-br
     ----------
     Classe que fornece utilitários para manipulação e formatação de datas.
-    
+
     Esta classe oferece funcionalidades para:
         - Obtenção de componentes do tempo atual (horas, minutos, segundos)
         - Formatação e manipulação de datas
         - Validação e conversão de datas
-        
+
     Métodos:
         get_hms: Retorna o horário atual como tupla de hora, minuto, segundo
-        
+
     A classe Date é parte do RPA Suite e pode ser acessada através do objeto rpa:
         >>> from rpa_suite import rpa
         >>> hora, minuto, segundo = rpa.date.get_hms()
     """
-    def __init__(self):
-        ...
+
+    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:
@@ -104,42 +102,41 @@ class Date():
                         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)}')
+                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)}.')
+            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
@@ -150,24 +147,23 @@ class Date():
             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)}')
+                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)}.')
+            error_print(f"Erro function: {self.get_dmy.__name__}! Error: {str(e)}.")
             return None, None, None
-