fix(time): substitui time.time() por time.monotonic() para medições mais precisas

Author: jlsneto

cereja/concurrently/process.py

@@ -292,7 +292,7 @@ def _process(self, func, item, *args, **kwargs):
             self._failure_data.append(item)
 
     def get_status(self):
-        return f"{round(self.total_processed / (time.time() - self._started_at), 2)} cpf/s " \
+        return f"{round(self.total_processed / (time.monotonic() - self._started_at), 2)} cpf/s " \
                f"- processing: {self.in_progress_count} " \
                f"- success: {self._total_success} " \
                f"- fail: {len(self._failure_data)} "
@@ -305,7 +305,7 @@ def process(self, func, data, *args, **kwargs):
         self._stopped = False
         # inicia thread para atualizar o banco com o resultado da validação.
         self._create_process_result_service().start()
-        self._started_at = time.time()
+        self._started_at = time.monotonic()
 
         if self._progress is not None:
             self._progress.update_max_value(len(data))
@@ -314,12 +314,12 @@ def process(self, func, data, *args, **kwargs):
         with ThreadPoolExecutor(max_workers=self._num_workers,
                                 thread_name_prefix="CPF_PROCESS_WORKER") as self._executor:
             for item in data:
-                start_time = time.time()
+                start_time = time.monotonic()
 
                 future = self._executor.submit(self._process, func, item, *args, **kwargs)
                 self._future_to_data.add(future)
 
-                elapsed_time = time.time() - start_time
+                elapsed_time = time.monotonic() - start_time
                 # Verifica quanto tempo passou após enviar um dado, caso o tempo for menor que o intervalo
                 # configurado espera a diferença antes de enviar o próximo lote
                 if elapsed_time < self.interval_seconds:
@@ -346,7 +346,7 @@ def stop_process(self):
     def restart_process(self):
         self.stop_process()  # espera terminar execução do processo anterior
         self._stopped = False
-        self._started_at = time.time()
+        self._started_at = time.monotonic()
         self._failure_data = []
         self._total_success = 0
         self._create_process_result_service().start()

cereja/display/_display.py

@@ -1068,7 +1068,7 @@ def _get_state(self,
 
     @property
     def time_it(self):
-        return time.time() - (self._started_time or time.time())
+        return time.monotonic() - (self._started_time or time.monotonic())
 
     @property
     def total_completed(self):
@@ -1240,7 +1240,7 @@ def start(self):
         self._console.set_prefix(self._name)
         if self._started:
             return
-        self._started_time = time.time()
+        self._started_time = time.monotonic()
         self._started = True
         try:
             self._th_root.start()
@@ -1306,7 +1306,7 @@ def __call__(self,
             self._console.set_prefix(f"{self.name}({name})")
         if self._with_context and name is None:
             self._console.set_prefix(f"{self.name}(iter-{self._task_count})")
-        self._started_time = time.time()
+        self._started_time = time.monotonic()
         self._task_count += 1
         return self
 

cereja/system/_win32.py

@@ -135,23 +135,23 @@ def t0(self):
     def time(self):
         if self._t0 is None:
             self.start()
-        self._last_time_check = time.time()
+        self._last_time_check = time.monotonic()
         if self._stopped_on:
             return self._stopped_on - self._t0
-        return time.time() - self._t0
+        return time.monotonic() - self._t0
 
     @property
     def last_check_time(self):
-        return time.time() - self._last_time_check
+        return time.monotonic() - self._last_time_check
 
     def start(self):
         self._stopped_on = None
-        self._t0 = time.time()
+        self._t0 = time.monotonic()
         self._last_time_check = self._t0
 
     def stop(self):
         if self._started:
-            self._stopped_on = time.time()
+            self._stopped_on = time.monotonic()
             return
         raise Exception("Time counting has not started. Use Time.start method.")
 

cereja/utils/decorators.py

@@ -241,9 +241,9 @@ def time_exec(func: Callable[[Any], Any]) -> Callable:
     def wrapper(*args,
                 **kwargs) -> Any:
         from cereja import console
-        first_time = time.time()
+        first_time = time.monotonic()
         result = func(*args, **kwargs)
-        console.log(f"[{func.__name__}] performed {time.time() - first_time}")
+        console.log(f"[{func.__name__}] performed {time.monotonic() - first_time}")
         return result
 
     return wrapper
@@ -282,7 +282,7 @@ def wrapper(*args,
                 def run():
                     nonlocal last_time
                     while True:
-                        current_time = time.time()
+                        current_time = time.monotonic()
                         if current_time - last_time >= interval:
                             if verbose:
                                 print(f"Running {func.__name__}")
@@ -300,7 +300,7 @@ def run():
                 def run():
                     nonlocal last_time
                     nonlocal last_result
-                    current_time = time.time()
+                    current_time = time.monotonic()
                     if current_time - last_time >= interval:
                         if verbose:
                             print(f"Running {func.__name__}")

cereja/utils/git/runner.py

@@ -1,24 +1,32 @@
 import subprocess
 from .exceptions import GitCommandError
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class GitCommandRunner:
     """Strategy para execução de comandos Git via subprocess."""
 
     def __init__(self,
-                 repo_path="."):
+                 repo_path=".",
+                 verbose: bool = True):
         self.repo_path = repo_path
 
     def run(self,
             args: list[str]) -> str:
         try:
+            import sys
             result = subprocess.run(
                     ["git"] + args,
                     cwd=self.repo_path,
-                    capture_output=True,
+                    # capture_output=True,
                     text=True,
-                    check=True
+                    check=True,
+                    stdout=sys.stdout
             )
-            return result.stdout.strip()
+            return result.stdout
+
+
         except subprocess.CalledProcessError as e:
             raise GitCommandError(f"Erro ao executar git {' '.join(args)}: {e.stderr.strip()}")

cereja/utils/time.py

@@ -73,7 +73,7 @@ def start(self):
         """
         Start the timer by setting the start time to the current time.
         """
-        self._start = _time.time()
+        self._start = time.monotonic()
 
     @property
     def started(self) -> bool:
@@ -87,7 +87,7 @@ def elapsed(self):
         Returns:
             float: The elapsed time in seconds.
         """
-        return _time.time() - self._start if self.started else 0
+        return time.monotonic() - self._start if self.started else 0
 
     @property
     def remaining(self):