dfd

API/HydrusNetwork.py

@@ -151,10 +151,75 @@ class HydrusNetwork:
                     
                     logger.debug(f"{self._log_prefix()} Uploading file {file_path.name} ({file_size} bytes)")
 
+                    # Stream upload body with a stderr progress bar (pipeline-safe).
+                    try:
+                        from models import ProgressBar
+                    except Exception:
+                        ProgressBar = None  # type: ignore[assignment]
+
+                    bar = ProgressBar() if ProgressBar is not None else None
+                    label = f"{self._log_prefix().strip('[]')} upload"
+                    start_t = time.time()
+                    last_render_t = [start_t]
+                    last_log_t = [start_t]
+                    sent = [0]
+                    tty = bool(getattr(sys.stderr, "isatty", lambda: False)())
+
+                    def _render_progress(final: bool = False) -> None:
+                        if bar is None:
+                            return
+                        if file_size <= 0:
+                            return
+                        now = time.time()
+                        if not final and (now - float(last_render_t[0])) < 0.25:
+                            return
+                        last_render_t[0] = now
+                        elapsed = max(0.001, now - start_t)
+                        speed = float(sent[0]) / elapsed
+                        eta_s = (float(file_size) - float(sent[0])) / speed if speed > 0 else 0.0
+                        minutes, seconds = divmod(int(max(0.0, eta_s)), 60)
+                        hours, minutes = divmod(minutes, 60)
+                        eta_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+                        speed_str = bar.format_bytes(speed) + "/s"
+
+                        line = bar.format_progress(
+                            percent_str=None,
+                            downloaded=int(sent[0]),
+                            total=int(file_size),
+                            speed_str=speed_str,
+                            eta_str=eta_str,
+                        )
+
+                        try:
+                            if tty:
+                                sys.stderr.write("\r" + f"[{label}] " + line + "   ")
+                                sys.stderr.flush()
+                            else:
+                                # Non-interactive: keep it quiet-ish.
+                                if final or (now - float(last_log_t[0])) >= 2.0:
+                                    log(f"[{label}] {line}", file=sys.stderr)
+                                    last_log_t[0] = now
+                        except Exception:
+                            pass
+
                     def file_gen():
-                        with file_path.open("rb") as handle:
-                            while chunk := handle.read(65536):
-                                yield chunk
+                        try:
+                            with file_path.open("rb") as handle:
+                                while True:
+                                    chunk = handle.read(256 * 1024)
+                                    if not chunk:
+                                        break
+                                    sent[0] += len(chunk)
+                                    _render_progress(final=False)
+                                    yield chunk
+                        finally:
+                            _render_progress(final=True)
+                            if tty:
+                                try:
+                                    sys.stderr.write("\n")
+                                    sys.stderr.flush()
+                                except Exception:
+                                    pass
 
                     response = client.request(
                         spec.method,