Deploy v1.37

Dockerfile

@@ -1,6 +1,6 @@
-# [Forge Log #75] Build v1.36 - Isolated Crepe Installation
-# Isolating 'crepe' to bypass network timeouts during requirement sweeps.
-ARG CACHE_BUSTER=20251219082000
+# [Forge Log #76] Build v1.37 - Purged Crepe Recursion
+# Refreshed cache and synchronized numpy version in the isolated layer.
+ARG CACHE_BUSTER=20251219114500
 
 FROM python:3.8-slim-bullseye
 
@@ -13,15 +13,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends     libsndfile-
 
 RUN mkdir -p /tmp/.crepe
 
-RUN mkdir /models /models_tmp &&     echo "--- [1/6] Downloading Model ---" &&     wget -O /models/model.zip https://storage.googleapis.com/ddsp-inv/ckpts/synthetic_pretrained_ckpt.zip &&     echo "--- [2/6] Unzipping Model ---" &&     unzip /models/model.zip -d /models_tmp &&     echo "--- [3/6] Moving model files to root directory ---" &&     mv /models_tmp/usr/local/google/home/jesseengel/Desktop/pretrained_ckpt/* /models/ &&     echo "--- [4/6] Cleaning up temporary files ---" &&     rm -rf /models_tmp &&     rm /models/model.zip &&     echo "--- [5/6] Verifying Final Model Files ---" &&     ls -lR /models &&     echo "--- [6/6] Model setup complete. ---"
+RUN mkdir /models /models_tmp &&     wget -O /models/model.zip https://storage.googleapis.com/ddsp-inv/ckpts/synthetic_pretrained_ckpt.zip &&     unzip /models/model.zip -d /models_tmp &&     mv /models_tmp/usr/local/google/home/jesseengel/Desktop/pretrained_ckpt/* /models/ &&     rm -rf /models_tmp &&     rm /models/model.zip
 
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel &&     pip install --no-cache-dir crepe==0.0.16 resampy==0.2.2
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel &&     pip install --no-cache-dir numpy<1.24 crepe==0.0.16 resampy==0.2.2
 
 COPY requirements.txt requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY app.py /code/app.py
-RUN echo "--- Verifying App Code ---" &&     ls -l /code
 
 EXPOSE 7860
 

app.py

@@ -1,13 +1,11 @@
-# [Forge Log #75] The Canary Banner v1.36
-# 'Vanguard Iota' Protocol - Deep-Path Synthesis Targeting.
-# Specifically hunts for .ae.decoder and .ae.processor_group sub-objects.
-print("--- [CANARY] DecentSampler DDSP Server v1.36 ---")
+# [Forge Log #76] The Canary Banner v1.37
+# 'Vanguard Kappa' Protocol - Atomic Synthesis Discovery.
+# Final brute-force probe to locate synthesis paths in MidiAutoencoder.
+print("--- [CANARY] DecentSampler DDSP Server v1.37 ---")
 print("--- [CANARY] Executing Verified Production App ---")
 
 import os
-# CRITICAL: This must be run BEFORE any other imports that might use numba.
 os.environ['NUMBA_DISABLE_JIT_CACHE'] = '1'
-print("--- [CANARY] Numba JIT Cache programmatically disabled. ---")
 
 import logging
 import importlib
@@ -16,13 +14,10 @@ import importlib_metadata
 import types
 import sys
 
-# [Forge Log #47] Monkey-patch missing attribute in Python 3.8
 if not hasattr(importlib.metadata, 'packages_distributions'):
     try:
         importlib.metadata.packages_distributions = importlib_metadata.packages_distributions
-        print("--- [CANARY] importlib.metadata monkey-patched for Python 3.8 compatibility. ---")
-    except Exception as e:
-        print(f"--- [CANARY] Metadata patch failed: {e} ---")
+    except: pass
 
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import Response
@@ -35,47 +30,31 @@ import ddsp.training
 from scipy.io.wavfile import write as write_wav
 import io
 
-# --- Version Diagnostics ---
-try:
-    print(f"DDSP Version: {ddsp.__version__}")
-    print(f"TensorFlow Version: {tf.__version__}")
-except Exception as e:
-    print(f"Error during version printing: {e}")
-
-# --- TAE Identification Ladder ---
-TAE_CLASS = None
-
+# --- TAE Identification ---
 def find_tae():
     try:
         import ddsp.training.models.midi_autoencoder as ma
-        if hasattr(ma, 'MidiAutoencoder'):
-            print("--- [CANARY] TAE Ladder 1: Found MidiAutoencoder")
-            return ma.MidiAutoencoder
+        return ma.MidiAutoencoder
     except: pass
     try:
         import ddsp.training.models as m
-        if hasattr(m, 'TranscribingAutoencoder'):
-            print("--- [CANARY] TAE Ladder 2: Found in ddsp.training.models")
-            return m.TranscribingAutoencoder
+        return m.TranscribingAutoencoder
     except: pass
     return None
 
 TAE_CLASS = find_tae()
 
-# --- Note Synth 'Vanguard' Ladder [Forge Log #75] ---
-NOTE_SYNTH_FN = None
-
+# --- Atomic Synth 'Vanguard' Ladder [Forge Log #76] ---
 def find_note_synth():
     target = 'note_expression_synthesis'
     try:
         import ddsp.training.models.midi_autoencoder as ma
         if hasattr(ma, target):
-            print(f"--- [CANARY] Synth Ladder 1: Found functional '{target}'")
             return lambda model, pitches, note_lengths, **kwargs: getattr(ma, target)(model, pitches, note_lengths, **kwargs)
     except: pass
 
-    def vanguard_synth_wrapper(model, pitches, note_lengths, **kwargs):
-        """Iota Protocol: Deep-path targeting for 1.6.5 Gin proxies."""
+    def atomic_synth_wrapper(model, pitches, note_lengths, **kwargs):
+        """Kappa Protocol: Multi-tier brute force probe."""
         p_tensor = tf.convert_to_tensor(pitches, dtype=tf.float32)
         l_tensor = tf.convert_to_tensor(note_lengths, dtype=tf.float32)
         midi_dicts = [
@@ -83,20 +62,13 @@ def find_note_synth():
             {'midi': {'pitch': p_tensor, 'duration': l_tensor}},
             {'inputs': {'pitch': p_tensor, 'duration': l_tensor}}
         ]
-        methods_to_try = ['midi_to_audio', 'decode', 'synthesize_audio', 'synthesize', 'call', '__call__']
-        objects_to_probe = []
-        if model:
-            objects_to_probe.append(model)
-            for layer1 in ['ae', 'decoder', 'processor_group', 'nn']:
-                if hasattr(model, layer1):
-                    obj1 = getattr(model, layer1)
-                    objects_to_probe.append(obj1)
-                    for layer2 in ['decoder', 'processor_group', 'ae']:
-                        if hasattr(obj1, layer2):
-                            obj2 = getattr(obj1, layer2)
-                            objects_to_probe.append(obj2)
-
-        for obj in objects_to_probe:
+        methods_to_try = ['midi_to_audio', 'decode', 'synthesize', 'synthesize_audio', 'call', '__call__', 'predict']
+        objs = [model]
+        for sub in ['ae', 'decoder', 'processor_group', 'nn']:
+            if hasattr(model, sub):
+                objs.append(getattr(model, sub))
+
+        for obj in objs:
             for name in methods_to_try:
                 method = getattr(obj, name, None)
                 if method and callable(method):
@@ -109,18 +81,17 @@ def find_note_synth():
                     except:
                         try: return method(p_tensor, l_tensor)
                         except: pass
-        if callable(model):
-            for m_dict in midi_dicts:
-                try: return model(m_dict, training=False)
-                except: pass
-        print(f"--- [CANARY] CRITICAL: Discovery failed. Type: {type(model)}")
-        print(f"Model Attributes: {dir(model)}")
-        raise AttributeError(f"Vanguard Iota failure: No synthesis path found.")
-
-    print("--- [CANARY] Vanguard: Discovery initialized via Vanguard V11 (Iota).")
-    return vanguard_synth_wrapper
-
-print("--- [CANARY] Initiating Vanguard discovery... ---")
+        for obj in objs:
+            for attr_name in dir(obj):
+                attr = getattr(obj, attr_name)
+                if callable(attr) and not attr_name.startswith('_'):
+                    for m_dict in midi_dicts:
+                        try: return attr(m_dict)
+                        except: pass
+        raise AttributeError(f"Vanguard Kappa Failure: No synthesis entry point in {type(model)}")
+
+    return atomic_synth_wrapper
+
 NOTE_SYNTH_FN = find_note_synth()
 
 # --- Global Setup ---
@@ -128,60 +99,44 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 app = FastAPI()
 
-# --- Model Loading ---
 MODEL_DIR = '/models'
 LATEST_CHECKPOINT = tf.train.latest_checkpoint(MODEL_DIR)
 
-if not LATEST_CHECKPOINT:
-    raise RuntimeError(f"Could not find model checkpoint in {MODEL_DIR}")
-
 try:
-    logger.info(f"Loading DDSP model from: {LATEST_CHECKPOINT}...")
     try:
         gin.register(TAE_CLASS, 'TranscribingAutoencoder', namespace='models')
-    except TypeError:
+    except:
         gin.register(TAE_CLASS, 'models.TranscribingAutoencoder')
     gin_file = os.path.join(MODEL_DIR, 'operative_config-0.gin')
     gin.parse_config_file(gin_file, skip_unknown=True)
     model = TAE_CLASS()
     model.restore(LATEST_CHECKPOINT)
-    logger.info(f"DDSP model restored. Class: {model.__class__.__name__}")
 except Exception as e:
-    logger.error(f"!!! CRITICAL: Model Load Failure: {e}", exc_info=True)
+    logger.error(f"Model Load Failure: {e}", exc_info=True)
     raise
 
-# --- API Data Models ---
 class NoteRequest(BaseModel):
     instrument: str = "DDSP_Synth"
     note: str 
     duration: float = 2.0
     seed: int = -1
 
-# --- Helper Functions ---
 def note_to_midi(note_name: str) -> float:
     note_names = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
     try:
         note = note_name[:-1].upper()
         octave = int(note_name[-1])
-        if '#' in note:
-            base_note = note.replace('#', '')
-            semitone = note_names.index(base_note) + 1
-        else:
-            semitone = note_names.index(note)
-        midi_pitch = semitone + (octave + 1) * 12
+        midi_pitch = note_names.index(note) + (octave + 1) * 12
         return float(midi_pitch)
-    except Exception:
-        raise ValueError(f"Invalid note format: '{note_name}'")
+    except: raise ValueError(f"Invalid note: '{note_name}'")
 
-# --- API Endpoints ---
 @app.get("/")
 def read_root():
-    return {"message": "DDSP Server Online", "canary": "v1.36"}
+    return {"message": "DDSP Server Online", "canary": "v1.37"}
 
 @app.post("/generate-note")
 async def generate_note(request: NoteRequest):
     try:
-        logger.info(f"Generating note: {request.note}")
         pitch = note_to_midi(request.note)
         audio = NOTE_SYNTH_FN(
             model=model,
@@ -194,18 +149,12 @@ async def generate_note(request: NoteRequest):
                 if key in audio:
                     audio = audio[key]
                     break
-        if hasattr(audio, 'numpy'):
-            audio = audio.numpy()
+        if hasattr(audio, 'numpy'): audio = audio.numpy()
         audio_squeeze = audio.squeeze()
         audio_int16 = np.int16(audio_squeeze * 32767)
         wav_io = io.BytesIO()
         write_wav(wav_io, 16000, audio_int16)
         wav_io.seek(0)
-        return Response(
-            content=wav_io.getvalue(),
-            media_type="audio/wav",
-            headers={"Content-Disposition": f'attachment; filename="{request.instrument}_{request.note}.wav"'}
-        )
+        return Response(content=wav_io.getvalue(), media_type="audio/wav")
     except Exception as e:
-        logger.error(f"Synthesis error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"[Vanguard V1.36] {str(e)}")
+        raise HTTPException(status_code=500, detail=f"[Vanguard V1.37] {str(e)}")

requirements.txt

@@ -1,19 +1,19 @@
-# [Forge Log #46] Golden Set Requirements v1.3
-# Added importlib-metadata to resolve Python 3.8 compatibility warning.
+# [Forge Log #76] Requirements v1.4
+# CRITICAL: 'crepe' REMOVED to prevent backtracking build errors.
+# 'crepe' is now handled exclusively in the isolated Docker layer.
 
 fastapi
 uvicorn[standard]
 
-# The "golden set" that resolves the installation issues.
+# The "golden set" for DDSP 1.6.5
 ddsp==1.6.5
 hmmlearn==0.2.7
-crepe
 
-# Other critical dependencies identified during server debugging.
+# Core dependencies
 numpy<1.24
 librosa==0.8.0
 numba==0.49.1
 tensorflow-cpu==2.12.0
 tensorflow-probability==0.19.0
 scipy
-importlib-metadata # [Forge Log #46] Fix metadata attribute error
+importlib-metadata