109 lines
6.7 KiB
Python
109 lines
6.7 KiB
Python
"""Owned audio-separator environment and explicitly supported model packages."""
|
|
import hashlib,json,os,shutil,sys,time
|
|
from pathlib import Path
|
|
from ltx_original_runtime import LTXOriginalRuntime
|
|
VERSION='0.47.0'
|
|
SOURCES=json.loads(Path(__file__).with_name('separator_sources.json').read_text())
|
|
def package_files(name):return [x['file'] for x in SOURCES[name]['files']]
|
|
def verify_package(directory,name):
|
|
for item in SOURCES[name]['files']:
|
|
path=Path(directory)/item['file']
|
|
if not path.is_file() or path.is_symlink():return False
|
|
digest=hashlib.sha256()
|
|
with path.open('rb') as stream:
|
|
for chunk in iter(lambda:stream.read(1024**2),b''):digest.update(chunk)
|
|
if digest.hexdigest()!=item['sha256']:return False
|
|
return True
|
|
MODELS={
|
|
'vocals_mel_band_roformer.ckpt':('MelBand RoFormer · Gesang / Instrumental','vocals_mel_band_roformer.yaml'),
|
|
'model_bs_roformer_ep_317_sdr_12.9755.ckpt':('BS-RoFormer · Gesang / Instrumental','model_bs_roformer_ep_317_sdr_12.9755.yaml'),
|
|
'htdemucs_ft.yaml':('Demucs FT · Gesang / Schlagzeug / Bass / Rest','htdemucs_ft.yaml'),
|
|
'htdemucs_6s.yaml':('Demucs 6s · zusätzlich Gitarre / Piano','htdemucs_6s.yaml')}
|
|
class SeparatorRuntime(LTXOriginalRuntime):
|
|
name='Audio Separator'
|
|
def __init__(self,root):super().__init__(root,None)
|
|
def paths(self):
|
|
marker=self.root/'active.json'
|
|
if marker.is_file():
|
|
ident=json.loads(marker.read_text()).get('id','')
|
|
if len(ident)==32 and all(c in '0123456789abcdef' for c in ident):
|
|
base=self.root/ident
|
|
if (base/'ready').is_file():return base/'python/bin/python',base
|
|
return self.root/'missing-python',self.root/'missing-runtime'
|
|
def status(self):
|
|
python,base=self.paths()
|
|
return dict(installed=python.is_file() and (base/'ready').is_file(),version=VERSION,required_disk_gib=15,job=dict(self.job) if self.job else None,models=[dict(id=name,name=label,configuration=config,source=SOURCES[name],installed=self.model_ready(name)) for name,(label,config) in MODELS.items()])
|
|
def model_ready(self,name):
|
|
if name not in MODELS:return False
|
|
directory=self.root/'models';marker=directory/(name+'.ready')
|
|
try:
|
|
recorded=json.loads(marker.read_text())
|
|
return recorded=={x['file']:x['sha256'] for x in SOURCES[name]['files']} and all((directory/f).is_file() and not (directory/f).is_symlink() and (directory/f).stat().st_size>0 for f in package_files(name))
|
|
except (OSError,ValueError):return False
|
|
|
|
def start(self):
|
|
if not shutil.which('ffmpeg'):raise ValueError('FFmpeg fehlt. Deck-Systemvoraussetzungen installieren.')
|
|
with self.lock:
|
|
if self.job and self.job['state']=='running':raise ValueError('Einrichtungsauftrag läuft bereits.')
|
|
self.requested_model=None
|
|
return super().start()
|
|
def download(self,name):
|
|
import threading,uuid
|
|
if not isinstance(name,str) or name not in MODELS:raise ValueError('Dieses Modellpaket ist nicht unterstützt.')
|
|
with self.lock:
|
|
if not self.status()['installed']:raise ValueError('Zuerst Audio Separator installieren.')
|
|
if self.job and self.job['state']=='running':raise ValueError('Einrichtungsauftrag läuft bereits.')
|
|
if shutil.disk_usage(self.root).free<3*1024**3:raise ValueError('Mindestens 3 GiB freier Speicher erforderlich.')
|
|
self.cancel.clear();self.requested_model=name;self.job=dict(id=uuid.uuid4().hex,state='running',phase='Modellpaket herunterladen',started_at=time.time());self._save()
|
|
self.worker=threading.Thread(target=self._run,daemon=True);self.worker.start();return self.status()
|
|
def _run(self):
|
|
base=self.root/self.job['id'];state='failed';phase='Einrichtung fehlgeschlagen.';model=getattr(self,'requested_model',None)
|
|
try:
|
|
if model:
|
|
directory=base;directory.mkdir(mode=0o700)
|
|
import urllib.request
|
|
for item in SOURCES[model]['files']:
|
|
self._phase('Modellpaket: '+item['file'])
|
|
succeeded=False
|
|
for url in item['urls']:
|
|
try:
|
|
digest=hashlib.sha256();size=0
|
|
with urllib.request.urlopen(url,timeout=60) as response,(directory/item['file']).open('wb') as out:
|
|
while chunk:=response.read(1024**2):
|
|
if self.cancel.is_set():raise InterruptedError()
|
|
size+=len(chunk)
|
|
if size>2*1024**3:raise ValueError('Quelldatei zu groß.')
|
|
digest.update(chunk);out.write(chunk)
|
|
if digest.hexdigest()!=item['sha256']:raise ValueError('Quelldatei stimmt nicht mit dem geprüften Rezept überein.')
|
|
succeeded=True;break
|
|
except InterruptedError:raise
|
|
except Exception:continue
|
|
if not succeeded:raise ValueError('Geprüfte Quelle nicht verfügbar: '+item['file'])
|
|
filenames=package_files(model)
|
|
if not verify_package(directory,model):raise ValueError('Modellpaket-Prüfsumme stimmt nicht.')
|
|
if self.cancel.is_set():raise InterruptedError()
|
|
destination=self.root/'models';destination.mkdir(exist_ok=True);hashes={}
|
|
for f in filenames:
|
|
digest=hashlib.sha256()
|
|
with (directory/f).open('rb') as source:
|
|
for chunk in iter(lambda:source.read(1024**2),b''):digest.update(chunk)
|
|
hashes[f]=digest.hexdigest();(directory/f).replace(destination/f)
|
|
(destination/(model+'.ready')).write_text(json.dumps(hashes))
|
|
state='complete';phase='Modell und passende Konfiguration heruntergeladen. Kein Modell geladen.'
|
|
else:
|
|
base.mkdir(mode=0o700);tmp=base/'tmp';tmp.mkdir()
|
|
env=dict(os.environ,TMPDIR=str(tmp),PIP_NO_INPUT='1',PIP_DISABLE_PIP_VERSION_CHECK='1')
|
|
python=base/'python/bin/python';self._phase('Eigene Python-Umgebung erstellen');self._command([sys.executable,'-m','venv',base/'python'],env)
|
|
self._phase('CUDA-PyTorch herunterladen · mehrere GiB');self._command([python,'-m','pip','install','--no-cache-dir','torch==2.11.0','torchaudio==2.11.0','--index-url','https://download.pytorch.org/whl/cu128'],env)
|
|
self._phase('Audio Separator und GPU-Abhängigkeiten installieren');self._command([python,'-m','pip','install','--no-cache-dir',f'audio-separator[gpu]=={VERSION}','onnxruntime-gpu==1.22.0','audioread==3.1.0'],env)
|
|
self._phase('Paketkonsistenz und CUDA-Unterstützung prüfen');self._command([python,'-m','pip','check'],env)
|
|
self._command([python,'-c','import torch; from audio_separator.separator import Separator; assert torch.version.cuda'],env)
|
|
if self.cancel.is_set():raise InterruptedError()
|
|
(base/'ready').write_text(VERSION);marker=self.root/'active.tmp';marker.write_text(json.dumps({'id':base.name}));marker.replace(self.root/'active.json')
|
|
state='complete';phase='Audio Separator installiert. Jetzt Modellpaket auswählen.'
|
|
except InterruptedError:state='cancelled';phase='Einrichtung abgebrochen.'
|
|
except Exception as exc:phase=str(exc)
|
|
finally:
|
|
if model or state!='complete':shutil.rmtree(base,ignore_errors=True)
|
|
with self.lock:self.process=None;self.job.update(state=state,phase=phase,finished_at=time.time());self._save()
|