Spaces:
Running on Zero
Running on Zero
Download space_app.py from suplo6669/sharpify-ai-inference: direct link, hf CLI and curl.
- Browser
- Download file 7.51 kB
-
https://huggingface.co/spaces/suplo6669/sharpify-ai-inference/resolve/main/space_app.py
- Command line
-
hf download hf://spaces/suplo6669/sharpify-ai-inference/space_app.py
-
curl -L -o space_app.py https://huggingface.co/spaces/suplo6669/sharpify-ai-inference/resolve/main/space_app.py
7.51 kB
| """Hugging Face ZeroGPU adapter for the verified Sharpify inference service.""" | |
| # Gradio's cache path is set before its first file operation. | |
| # ruff: noqa: I001 | |
| from __future__ import annotations | |
| import logging | |
| import os | |
| import re | |
| import tempfile | |
| import threading | |
| import time | |
| import uuid | |
| from pathlib import Path | |
| from typing import cast | |
| _temp_dir = Path( | |
| os.environ.get( | |
| "GRADIO_TEMP_DIR", str(Path(tempfile.gettempdir()) / "sharpify-gradio") | |
| ) | |
| ).resolve() | |
| os.environ.setdefault("GRADIO_TEMP_DIR", str(_temp_dir)) | |
| _temp_dir.mkdir(parents=True, exist_ok=True) | |
| import spaces | |
| import torch | |
| import gradio as gr | |
| from app.config import Settings | |
| from app.models.contracts import Scale | |
| from app.services.enhancer import ( | |
| EnhancementError, | |
| GPUOutOfMemoryError, | |
| ImageEnhancer, | |
| ) | |
| from app.utils.image_io import ImageInputError, encode_image_bytes | |
| from scripts.download_weights import download | |
| logger = logging.getLogger("sharpify.hosted") | |
| MAX_UPLOAD_BYTES = 20_000_000 | |
| downloaded_weights = download() | |
| hosted_settings = Settings( | |
| device="cuda", | |
| precision="fp16", | |
| model_path=downloaded_weights, | |
| tile_size=128, | |
| tile_pad=32, | |
| pre_pad=10, | |
| cpu_threads=4, | |
| max_upload_bytes=MAX_UPLOAD_BYTES, | |
| max_input_pixels=4_000_000, | |
| max_output_pixels=64_000_000, | |
| ) | |
| # ZeroGPU requires CUDA placement during module initialization. The first real | |
| # CUDA operation is deferred to an allocated call below. | |
| enhancer = ImageEnhancer( | |
| hosted_settings, | |
| warm_up_on_init=False, | |
| device_override="cuda", | |
| ) | |
| _warmed_up = False | |
| _warm_up_lock = threading.Lock() | |
| _transient_cleanup_lock = threading.Lock() | |
| _TRANSIENT_MAX_AGE_SECONDS = 900 | |
| def _cleanup_stale_transients() -> None: | |
| cutoff = time.time() - _TRANSIENT_MAX_AGE_SECONDS | |
| with _transient_cleanup_lock: | |
| for candidate in _temp_dir.glob("sharpify-output-*"): | |
| try: | |
| if candidate.is_file() and candidate.stat().st_mtime < cutoff: | |
| candidate.unlink(missing_ok=True) | |
| except OSError: | |
| logger.warning( | |
| "Could not remove an expired transient image", exc_info=True | |
| ) | |
| def _transient_cleanup_worker() -> None: | |
| while True: | |
| time.sleep(60) | |
| _cleanup_stale_transients() | |
| _cleanup_stale_transients() | |
| threading.Thread(target=_transient_cleanup_worker, daemon=True).start() | |
| def _safe_filename(filename: str, scale: Scale, output_format: str) -> str: | |
| basename = Path(filename.replace("\\", "/")).name | |
| stem = re.sub(r"[^A-Za-z0-9_-]+", "-", Path(basename).stem).strip("-_")[:80] | |
| return f"{stem or 'image'}-enhanced-{scale}x.{output_format}" | |
| def _error(code: str, message: str) -> tuple[None, dict[str, dict[str, str]]]: | |
| return None, {"error": {"code": code, "message": message}} | |
| def _save_transient(data: bytes, filename: str) -> str: | |
| _cleanup_stale_transients() | |
| destination = _temp_dir / f"sharpify-output-{uuid.uuid4().hex}-{filename}" | |
| destination.write_bytes(data) | |
| return str(destination) | |
| def enhance_image( | |
| image_bytes: bytes, | |
| filename: str, | |
| scale_value: str, | |
| output_format: str, | |
| oauth_token: gr.OAuthToken, | |
| ) -> tuple[str | None, dict[str, object]]: | |
| """Enhance one bounded upload and return a transient file plus metadata.""" | |
| if oauth_token is None: # Protect against missing OAuth sessions at runtime. | |
| return _error( | |
| "auth_required", "Sign in with Hugging Face before enhancing images." | |
| ) | |
| if not isinstance(image_bytes, bytes) or not image_bytes: | |
| return _error("invalid_image", "Choose a non-empty JPEG, PNG, or WEBP image.") | |
| if len(image_bytes) > MAX_UPLOAD_BYTES: | |
| return _error("upload_too_large", "The upload exceeds the 20 MB limit.") | |
| if scale_value not in {"2", "4"}: | |
| return _error("invalid_request", "Choose either 2x or 4x upscaling.") | |
| if output_format not in {"png", "jpeg", "webp"}: | |
| return _error("invalid_request", "Choose PNG, JPEG, or WEBP output.") | |
| if not isinstance(filename, str) or not filename.strip(): | |
| filename = "image" | |
| global _warmed_up | |
| try: | |
| if not _warmed_up: | |
| with _warm_up_lock: | |
| if not _warmed_up: | |
| enhancer._warm_up() | |
| _warmed_up = True | |
| scale = cast(Scale, int(scale_value)) | |
| result = enhancer.enhance_bytes(image_bytes, scale) | |
| output = encode_image_bytes(result.image, None, output_format) | |
| safe_name = _safe_filename(filename, scale, output_format) | |
| path = _save_transient(output, safe_name) | |
| metadata: dict[str, object] = { | |
| "original_width": result.original_width, | |
| "original_height": result.original_height, | |
| "enhanced_width": result.enhanced_width, | |
| "enhanced_height": result.enhanced_height, | |
| "scale": scale, | |
| "model": result.model, | |
| "filename": safe_name, | |
| "content_type": { | |
| "png": "image/png", | |
| "jpeg": "image/jpeg", | |
| "webp": "image/webp", | |
| }[output_format], | |
| } | |
| return path, metadata | |
| except ImageInputError as error: | |
| return _error("invalid_image", str(error)) | |
| except (GPUOutOfMemoryError, torch.cuda.OutOfMemoryError): | |
| try: | |
| torch.cuda.empty_cache() | |
| except Exception: | |
| logger.exception("Could not clear CUDA cache after an out-of-memory error") | |
| return _error( | |
| "gpu_out_of_memory", | |
| "The GPU ran out of memory. Try a smaller image.", | |
| ) | |
| except EnhancementError: | |
| logger.exception("Real-ESRGAN could not complete an upload") | |
| return _error( | |
| "enhancement_failed", | |
| "The image could not be enhanced with the available resources.", | |
| ) | |
| except (MemoryError, OSError): | |
| logger.exception("The hosted service could not allocate or save the result") | |
| return _error( | |
| "resource_unavailable", | |
| "The service could not prepare this image. Try a smaller input.", | |
| ) | |
| except Exception: | |
| logger.exception("Unexpected hosted Real-ESRGAN inference failure") | |
| return _error( | |
| "inference_failed", | |
| "Image enhancement failed. Please try again.", | |
| ) | |
| with gr.Blocks(delete_cache=(60, 300), analytics_enabled=False) as demo: | |
| upload = gr.File( | |
| label="Image", | |
| file_count="single", | |
| file_types=[".jpg", ".jpeg", ".png", ".webp"], | |
| type="binary", | |
| ) | |
| filename_input = gr.Textbox(label="Filename", visible=False) | |
| scale_input = gr.Radio( | |
| choices=["2", "4"], value="4", label="Upscale factor", visible=False | |
| ) | |
| format_input = gr.Radio( | |
| choices=["png", "jpeg", "webp"], | |
| value="png", | |
| label="Output format", | |
| visible=False, | |
| ) | |
| enhance_button = gr.Button("Enhance", visible=False) | |
| output_file = gr.File(label="Enhanced image", interactive=False) | |
| output_metadata = gr.JSON(label="Image metadata") | |
| enhance_button.click( | |
| enhance_image, | |
| inputs=[upload, filename_input, scale_input, format_input], | |
| outputs=[output_file, output_metadata], | |
| api_name="enhance", | |
| concurrency_limit=1, | |
| ) | |
| demo.queue(default_concurrency_limit=1, max_size=10) | |
| if __name__ == "__main__": | |
| demo.launch(max_file_size=MAX_UPLOAD_BYTES, show_error=False) | |