Spaces:
Sleeping
Sleeping
| """Streamlit runtime helpers for long-running jobs on Hugging Face Spaces.""" | |
| from __future__ import annotations | |
| import os | |
| import time | |
| from typing import Any, Callable, Optional | |
| def is_huggingface_space() -> bool: | |
| """Detect Hugging Face Spaces runtime.""" | |
| return bool( | |
| os.getenv("SPACE_ID") | |
| or os.getenv("HF_HOME") | |
| or os.getenv("SYSTEM") | |
| ) | |
| def embed_html(content: str, height: int = 0) -> Any: | |
| """Render raw HTML/JS in an iframe. | |
| Uses ``st.iframe`` (Streamlit >= 1.5x) and falls back to the deprecated | |
| ``st.components.v1.html`` on older versions. ``st.iframe`` rejects a height | |
| of 0, so script-only snippets get a 1px frame instead. | |
| """ | |
| import streamlit as st | |
| if hasattr(st, "iframe"): | |
| size = height if isinstance(height, int) and height > 0 else 1 | |
| return st.iframe(content, height=size) | |
| from streamlit.components.v1 import html as _components_html | |
| return _components_html(content, height=height) | |
| class AnalysisProgressReporter: | |
| """Keeps the Streamlit websocket alive during long Gemini calls.""" | |
| def __init__( | |
| self, | |
| progress_bar: Any = None, | |
| status_text: Any = None, | |
| time_estimate: Any = None, | |
| step_indicator: Any = None, | |
| working_indicator: Any = None, | |
| stream_indicator: Any = None, | |
| base_progress: float = 70.0, | |
| progress_span: float = 25.0, | |
| ): | |
| self.progress_bar = progress_bar | |
| self.status_text = status_text | |
| self.time_estimate = time_estimate | |
| self.step_indicator = step_indicator | |
| self.working_indicator = working_indicator | |
| self.stream_indicator = stream_indicator | |
| self.base_progress = base_progress | |
| self.progress_span = progress_span | |
| self._last_flush = 0.0 | |
| self._total_steps = 1 | |
| def on_phase(self, message: str, fraction: float = 0.0) -> None: | |
| self._update( | |
| progress=self.base_progress + (self.progress_span * fraction), | |
| status=message, | |
| working=message, | |
| ) | |
| def on_step_start(self, step_number: int, step_title: str, total_steps: int) -> None: | |
| self._total_steps = max(total_steps, 1) | |
| fraction = max(0.0, (step_number - 1) / self._total_steps) | |
| self.on_phase( | |
| f"🤖 **AI Step {step_number}/{total_steps}:** {step_title}...", | |
| fraction=fraction, | |
| ) | |
| def on_stream_chunk(self, step_number: int, chars_received: int) -> None: | |
| now = time.time() | |
| if now - self._last_flush < 0.75: | |
| return | |
| self._last_flush = now | |
| fraction = min(0.99, ((step_number - 1) + min(chars_received / 4000.0, 0.95)) / self._total_steps) | |
| progress = int(self.base_progress + (self.progress_span * fraction)) | |
| stream_msg = f"Receiving AI output... {chars_received:,} characters" | |
| self._update( | |
| progress=progress, | |
| status=f"🤖 **AI Step {step_number}/{self._total_steps}:** {stream_msg}", | |
| working=stream_msg, | |
| stream=stream_msg, | |
| ) | |
| def on_step_complete(self, step_number: int) -> None: | |
| fraction = min(1.0, step_number / self._total_steps) | |
| self.on_phase( | |
| f"✅ **AI Step {step_number}/{self._total_steps}** complete", | |
| fraction=fraction, | |
| ) | |
| def _update( | |
| self, | |
| progress: float, | |
| status: str, | |
| working: Optional[str] = None, | |
| stream: Optional[str] = None, | |
| ) -> None: | |
| try: | |
| if self.progress_bar is not None: | |
| self.progress_bar.progress(min(max(int(progress), 0), 100)) | |
| if self.status_text is not None: | |
| self.status_text.markdown(status) | |
| if self.working_indicator is not None and working: | |
| self.working_indicator.markdown(f"🔄 **Processing:** {working}") | |
| if self.stream_indicator is not None and stream: | |
| self.stream_indicator.caption(stream) | |
| if self.time_estimate is not None: | |
| self.time_estimate.markdown( | |
| "⏱️ Analysis is still running — keep this tab open." | |
| ) | |
| if self.step_indicator is not None: | |
| self.step_indicator.markdown("📋 AI analysis in progress") | |
| except Exception: | |
| pass | |
| def make_progress_callback( | |
| progress_bar: Any = None, | |
| status_text: Any = None, | |
| time_estimate: Any = None, | |
| step_indicator: Any = None, | |
| working_indicator: Any = None, | |
| stream_indicator: Any = None, | |
| ) -> AnalysisProgressReporter: | |
| return AnalysisProgressReporter( | |
| progress_bar=progress_bar, | |
| status_text=status_text, | |
| time_estimate=time_estimate, | |
| step_indicator=step_indicator, | |
| working_indicator=working_indicator, | |
| stream_indicator=stream_indicator, | |
| ) | |
| def is_connection_abort_error(error: Exception | str) -> bool: | |
| message = str(error).lower() | |
| return any( | |
| token in message | |
| for token in ( | |
| "bodystreambuffer", | |
| "aborted", | |
| "connection reset", | |
| "connection interrupted", | |
| "client disconnected", | |
| "stream closed", | |
| ) | |
| ) |