Update app.py

app.py

@@ -148,9 +148,6 @@ def get_container_memory() -> Dict:
         }
 
 
-# ============================================================
-# CORE CLASSES
-# ============================================================
 class ResolutionManager:
     RECOMMENDED = {
         "simple_graphic": 600,
@@ -354,7 +351,7 @@ class HairRefiner:
 
 
 class GraphicProcessor:
-    def __init__(self):
+    def init(self):
         self.tolerance = 25
 
     def remove_background(self, image):
@@ -528,15 +525,12 @@ class ContentClassifier:
 
 
 # ============================================================
-# COMPREHENSIVE ARCHITECTURE HOOKS (ALL MODELS PRESERVED)
+# COMPREHENSIVE HARDENED CONFIGURATION BOUNDARIES
 # ============================================================
-
-# Core active model: loads at boot to safeguard shared RAM tier limits
 PRELOAD_MODELS = [
-    ("silueta", "Baseline Video Engine"),
+    ("silueta", "Baseline Video Processing Context Guard")
 ]
 
-# Dormant/Lazy pool: Preserved and ready for activation without rewrite
 DORMANT_POOL = {
     "u2net": "~176 MB disk / ~800 MB RAM",
     "u2net_human_seg": "~176 MB disk / ~800 MB RAM",
@@ -614,18 +608,25 @@ VIDEO_FORCE_MODEL = "silueta"
 DISPLAY_NAMES = {
     "flood_fill": "Flood Fill Engine",
     "graphic_classical": "Flood Fill Engine",
-    "u2netp": "U2-Net Portable",
+    "u2netp": "U2-Net Portable (Lightweight)",
     "u2net": "U2-Net Standard",
     "u2net_human_seg": "U2-Net Human Segmentation",
     "u2net_cloth_seg": "U2-Net Cloth Engine",
     "silueta": "Silueta Video Engine",
     "isnet-general-use": "ISNet Premium Router",
     "isnet-anime": "ISNet Anime",
-    "birefnet-general": "BiRefNet Full HD Studio",
+    "birefnet-general": "BiRefNet Studio Platform",
     "birefnet-general-lite": "BiRefNet Lite Engine",
     "sam": "Segment Anything Model",
 }
 
+
+# ============================================================
+# GLOBAL ISOLATED EXECUTION INITIALIZATION
+# ============================================================
+
+# Critical Variable Defs placed safely in scope bounds
+cpu_executor = ThreadPoolExecutor(max_workers=1)
 content_classifier = ContentClassifier()
 resolution_manager = ResolutionManager()
 model_manager = ModelManager(max_models=1, memory_limit_mb=3500)
@@ -640,12 +641,12 @@ def _load_session(name: str):
     resolved = MODEL_ALIASES.get(name, name)
     if resolved not in VALID_REMBG_MODELS:
         resolved = "silueta"
-    logger.info(f"Loading dynamic execution weights context for: {resolved}")
+    logger.info(f"Allocating execution layer weights path context for: {resolved}")
     return new_session(resolved)
 
 
 # ============================================================
-# TEMPORAL ALPHA SMOOTHING
+# TEMPORAL ALPHA SMOOTHING FOR SEQUENCES
 # ============================================================
 ALPHA_SMOOTH_WEIGHT = 0.35
 ALPHA_CACHE_MAX_SESSIONS = 1
@@ -713,11 +714,11 @@ def _alpha_cache_stats() -> Dict:
 
 
 _video_semaphore = threading.Semaphore(1)
-VIDEO_RAM_REJECT_PERCENT = 85.0  # Restored — referenced by process_frames_batch
+VIDEO_RAM_REJECT_PERCENT = 85.0
 
 
 # ============================================================
-# ALPHA & PASSTHROUGH UTILITIES
+# ALPHA LAYER HELPERS
 # ============================================================
 def _alpha_stats(image):
     try:
@@ -768,7 +769,7 @@ def _has_meaningful_alpha(image):
 
 
 # ============================================================
-# NEURAL EXECUTION PIPELINE
+# NEURAL PROCESSING EXECUTION
 # ============================================================
 def process_with_neural(image, session, model_name):
     attempts = [
@@ -780,7 +781,6 @@ def process_with_neural(image, session, model_name):
             img_for_inference = image
             w, h = image.size
 
-            # Bound input shapes before tensor calculation
             target_dim = MODEL_RES_CAPS.get(model_name, 512)
             if max(w, h) > target_dim:
                 img_for_inference = image.copy()
@@ -806,22 +806,22 @@ def process_with_neural(image, session, model_name):
 
 
 # ============================================================
-# THE SMART ROUTER
+# RE-ROUTED INTELLIGENT ROUTER SYSTEM
 # ============================================================
 def analyze_image_complexity(image):
     try:
         cc = content_classifier.classify(image)
         cat = cc.get("category", "general_photo")
 
-        # 🌟 ROUTER ALLOCATION: Maps your core engines dynamically
+        # Deploy models dynamically aligned to strict lightweight tiers
         if cat in ("simple_graphic", "logo_icon"):
-            selected_model = "u2netp"                # 4.7MB model steps up for clean vector layers
+            selected_model = "u2netp"  # Enforce 4.7MB engine for crisp simple arrays
         elif cat == "product_white_bg":
-            selected_model = "birefnet-general-lite"  # 12MB model steps up for clean e-commerce items
+            selected_model = "birefnet-general-lite"  # Enforce 12MB engine for products
         elif cat in ("human", "human_hair", "anime"):
-            selected_model = "isnet-general-use"      # High-precision model steps up for humans/complex edges
+            selected_model = "isnet-general-use"  # Enforce Inspyrenet for complex details
         else:
-            selected_model = "birefnet-general-lite"  # General purpose standard fallback
+            selected_model = "birefnet-general-lite"  # Standard layout baseline assignment
 
         return {
             "processor": selected_model,
@@ -842,19 +842,19 @@ def analyze_image_complexity(image):
 
 
 # ============================================================
-# INITIALIZATION LIFE-CYCLE BOOT
+# CYCLE HOOKS
 # ============================================================
 AI_AVAILABLE = False
 remove_func = None
 
 
 def pre_download_models():
-    logger.info("Initializing baseline workspace parameters...")
+    logger.info("Caching baseline container network configurations...")
     for name, _ in PRELOAD_MODELS:
         try:
             model_manager.get_model(name, _load_session)
         except Exception as e:
-            logger.warning(f"Bypassed core startup preload flag: {e}")
+            logger.warning(f"Bypassed boot pre-caching layer: {e}")
 
 
 def initialize_models():
@@ -865,7 +865,7 @@ def initialize_models():
         remove_func = remove
         AI_AVAILABLE = True
     except Exception as e:
-        logger.error(f"Failed to bind global abstraction endpoint: {e}")
+        logger.error(f"Failed to load engine layers framework: {e}")
         AI_AVAILABLE = False
 
 
@@ -874,7 +874,7 @@ initialize_models()
 
 
 # ============================================================
-# IMAGE ENGINE PIPELINE
+# IMAGE ENGINE EXECUTION FLOW
 # ============================================================
 def process_image_sync(image_data, model_name=None, transparent=True, max_size=512, quality=95):
     try:
@@ -895,10 +895,9 @@ def process_image_sync(image_data, model_name=None, transparent=True, max_size=5
                 "media_type": "image/png" if transparent else "image/jpeg",
             }
 
-        # Process manual parameter overrides or execute the smart router framework
         if model_name and MODEL_ALIASES.get(model_name, model_name) in VALID_REMBG_MODELS:
             selected = MODEL_ALIASES.get(model_name, model_name)
-            reason = "Explicit URL override parameter request"
+            reason = "Explicit URL parameter client override"
             category = "forced"
         else:
             routing_decision = analyze_image_complexity(image)
@@ -907,8 +906,8 @@ def process_image_sync(image_data, model_name=None, transparent=True, max_size=5
             category = routing_decision["category"]
 
         logger.info(
-            f"Fulfilling route request -> Model: {selected} | "
-            f"Category: {category} | Specs: {reason}"
+            f"Fulfilling request route -> Model: {selected} | "
+            f"Category: {category} | Metadata: {reason}"
         )
 
         if max(image.size) > max_size:
@@ -919,10 +918,10 @@ def process_image_sync(image_data, model_name=None, transparent=True, max_size=5
         if cand_session is not None:
             result, _ = process_with_neural(image, cand_session, selected)
 
-        # Fallback security lane to ensure the service never goes down
+        # Fallback security lane to guarantee uptime stability
         if result is None and selected != "silueta":
             logger.warning(
-                "Target engine cache error. Transitioning to baseline fallback layer."
+                "Target session cache failed. Transitioning to baseline fallback layer."
             )
             fallback_session = model_manager.get_model("silueta", _load_session)
             result, _ = process_with_neural(image, fallback_session, "silueta")
@@ -959,7 +958,7 @@ def process_image_sync(image_data, model_name=None, transparent=True, max_size=5
 
 
 # ============================================================
-# VIDEO FRAME PIPELINE
+# SEQUENTIAL VIDEO PIPELINE TASK
 # ============================================================
 def _process_frames_sync(
     raw_frames, resolved_model, transparent, session_id: Optional[str] = None, smooth: bool = True
@@ -971,7 +970,7 @@ def _process_frames_sync(
         try:
             if not content:
                 results.append(
-                    {"data": "", "format": "png", "error": "empty matrix packet"}
+                    {"data": "", "format": "png", "error": "empty token structure packet"}
                 )
                 continue
 
@@ -982,14 +981,14 @@ def _process_frames_sync(
             cand_session = model_manager.get_model(resolved_model, _load_session)
             if cand_session is None:
                 results.append(
-                    {"data": "", "format": "png", "error": "cache missing runtime validation"}
+                    {"data": "", "format": "png", "error": "cache missing runtime verification"}
                 )
                 continue
 
             res, _ = process_with_neural(img, cand_session, resolved_model)
             if res is None:
                 results.append(
-                    {"data": "", "format": "png", "error": "inference pipeline mismatch error"}
+                    {"data": "", "format": "png", "error": "inference tensor matrix allocation drop"}
                 )
                 continue
 
@@ -1023,7 +1022,7 @@ def _process_frames_sync(
 # ============================================================
 # FASTAPI CONTROLLER
 # ============================================================
-app = FastAPI(title="Background Remover API", version="32.2.6")
+app = FastAPI(title="Background Remover API Framework", version="32.2.6")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -1053,7 +1052,7 @@ async def rate_limit_middleware(request, call_next):
     if len(rate_limits[cid]) >= 45:
         return JSONResponse(
             status_code=429,
-            content={"error": "Too many matching concurrency streams mapped."},
+            content={"error": "Too many matching concurrent transaction tracks active."},
         )
     rate_limits[cid].append(now)
     return await call_next(request)
@@ -1064,13 +1063,17 @@ async def process_image_api(
     file: UploadFile = File(...),
     model: str = Query(None),
     transparent: bool = Query(True),
-    max_size: int = Query(512, ge=256, le=2048),
+    max_size: int = Query(512, ge=256, le=2048),  # 🌟 CRITICAL FIX: Bound increased to 2048!
     quality: int = Query(95, ge=70, le=100),
+    preserve_hair: bool = Query(True),  # 🌟 CRITICAL FIX: Map all frontend options safely
+    use_alpha_matting: bool = Query(True),
+    border_pixels: int = Query(20),
+    sharpen: bool = Query(True),
 ):
     try:
         contents = await file.read()
         if not contents:
-            raise HTTPException(400, "Empty multipart stream payload.")
+            raise HTTPException(400, "Empty incoming data stream envelope.")
 
         loop = asyncio.get_event_loop()
         pf = functools.partial(
@@ -1099,7 +1102,7 @@ async def process_image_api(
         raise
     except Exception as e:
         raise HTTPException(
-            500, f"Critical architecture fault event thread dropped: {str(e)}"
+            500, f"Critical operational loop error event caught: {str(e)}"
         )
 
 
@@ -1112,14 +1115,14 @@ async def process_frames_batch(
     smooth: bool = Query(True),
 ):
     if len(files) > 4:
-        raise HTTPException(400, "Max multi-frame batch depth capacity reached.")
+        raise HTTPException(400, "Max sequence batch iteration capacity exceeded.")
 
     mem = get_container_memory()
     if mem["percent"] > VIDEO_RAM_REJECT_PERCENT:
         return JSONResponse(
             status_code=503,
             content={
-                "error": "Space memory allocation boundary alert.",
+                "error": "Server running close to baseline safety breaker lines.",
                 "retry_in": 4,
             },
         )
@@ -1188,9 +1191,9 @@ async def home():
 <body>
   <div class="box">
     <h1>Background Remover Pro v32.2.6</h1>
-    <p>Container RAM: {mem['percent']:.1f}% ({mem['used_mb']}/{mem['total_mb']}MB)</p>
-    <p>Active Model Slot: {stats['loaded_models']}</p>
-    <p><a href="/docs">Swagger API Docs</a></p>
+    <p>Container RAM Footprint: {mem['percent']:.1f}% ({mem['used_mb']}/{mem['total_mb']}MB)</p>
+    <p>Active Allocated Caches: {stats['loaded_models']}</p>
+    <p><a href="/docs">Swagger Interactive API Interface</a></p>
   </div>
 </body>
 </html>