Spaces:
Sleeping
Sleeping
Download deploy/hf/app.py from dellweb3/VibeCoding: direct link, hf CLI and curl.
- Browser
- Download file 7.04 kB
-
https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/deploy/hf/app.py
- Command line
-
hf download hf://spaces/dellweb3/VibeCoding/deploy/hf/app.py
-
curl -L -o app.py https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/deploy/hf/app.py
7.04 kB
| """HF-owned Docker Space bootstrap; secrets stay in process memory, never in the image.""" | |
| import os | |
| import sqlite3 | |
| import time | |
| import json | |
| import hashlib | |
| import threading | |
| from pathlib import Path | |
| from urllib.parse import urlsplit | |
| from src.adapters.llm.chat_completion import ChatCompletionProvider | |
| from src.modules.llm_gateway.service import ProviderFailure | |
| from src.modules.llm_gateway.routing import PROFILES,VERSION | |
| from src.apps.workbench.engine import LocalWorkbench | |
| from src.apps.workbench.web import create_web | |
| from deploy.hf.adapter import SpaceIngress | |
| from deploy.hf.preview_bridge import PreviewBridge | |
| ROOT=Path(__file__).resolve().parents[2] | |
| ORIGIN='https://dellweb3-vibecoding.hf.space' | |
| class DemoCallBudget: | |
| def __init__(self,path,limit=20): | |
| if not 0<=limit<=100:raise ValueError('INVALID_DEMO_CALL_LIMIT') | |
| self.path,self.limit=Path(path),limit;self.path.parent.mkdir(parents=True,exist_ok=True) | |
| with sqlite3.connect(self.path) as db:db.execute('CREATE TABLE IF NOT EXISTS physical_calls(id INTEGER PRIMARY KEY,created REAL,model TEXT)') | |
| def claim(self,model): | |
| with sqlite3.connect(self.path,timeout=30) as db: | |
| db.execute('BEGIN IMMEDIATE') | |
| if self.limit and db.execute('SELECT count(*) FROM physical_calls').fetchone()[0]>=self.limit: | |
| raise ProviderFailure('MODEL_DEMO_CALL_LIMIT',rejected=True,retryable=False) | |
| db.execute('INSERT INTO physical_calls(created,model) VALUES(?,?)',(time.time(),model)) | |
| class LimitedProvider: | |
| def __init__(self,provider,budget):self.provider,self.budget=provider,budget | |
| def __getattr__(self,key):return getattr(self.provider,key) | |
| def complete(self,messages,max_tokens,cancelled): | |
| if cancelled():raise ProviderFailure('RUN_CANCELLED',rejected=True) | |
| self.budget.claim(self.model) | |
| return self.provider.complete(messages,max_tokens,cancelled) | |
| def initialize_model_health(providers,path): | |
| """Real, budgeted probes inside the Space; uncertain attempts are never replayed.""" | |
| path=Path(path);path.parent.mkdir(parents=True,exist_ok=True) | |
| selected=[p for p in providers if p.selectable] | |
| if not selected:return | |
| binding=hashlib.sha256((VERSION+'\0'+selected[0].endpoint+'\0'+selected[0]._token).encode()).hexdigest() | |
| report={'binding':binding,'models':{}} | |
| if path.is_file(): | |
| previous=json.loads(path.read_text(encoding='utf-8')) | |
| if previous.get('binding')==binding:report=previous | |
| def save(): | |
| pending=path.with_suffix('.tmp');pending.write_text(json.dumps(report),encoding='utf-8');pending.replace(path) | |
| for provider in selected: | |
| provider_binding=hashlib.sha256((VERSION+'\0'+provider.endpoint+'\0'+provider._token).encode()).hexdigest() | |
| old=report['models'].get(provider.model) | |
| if old and old.get('binding',report['binding'])==provider_binding: | |
| provider.health={**old,'status':'unknown' if old['status']=='reserved' else old['status']};continue | |
| row={'status':'reserved','checked_at':time.time(),'binding':provider_binding};report['models'][provider.model]=row;save() | |
| try: | |
| reply=provider.complete([{'role':'system','content':'Return JSON only.'}, | |
| {'role':'user','content':'Return exactly {"summary":"ok"}.'}],512 if getattr(provider,'provider_family',None)=='openai' else 64,lambda:False) | |
| row.update(status='healthy' if reply.content=={'summary':'ok'} else 'rejected', | |
| request_id=reply.request_id,input_tokens=reply.input_tokens,output_tokens=reply.output_tokens) | |
| if row['status']!='healthy':row['code']='PROBE_CONTRACT_INVALID' | |
| except ProviderFailure as exc: | |
| row.update(status='rejected' if exc.rejected else 'unknown',code=exc.code, | |
| input_tokens=exc.input_tokens,output_tokens=exc.output_tokens) | |
| except Exception: | |
| row.update(status='unknown',code='PROBE_RESULT_UNKNOWN') | |
| provider.health=dict(row);save() | |
| def providers_from_environment(root): | |
| # Remove the provider secret before spawning trusted tools/VM emulators. | |
| token=os.environ.pop('DASHSCOPE_API_KEY',None) | |
| openai_token=os.environ.pop('OPENAI_API_KEY',None) | |
| if not token and not openai_token:return [] | |
| budget=DemoCallBudget(Path(root)/'model-demo-budget.sqlite',int(os.environ.get('ZKCODING_MODEL_CALL_LIMIT','20'))) | |
| result=[] | |
| if openai_token: | |
| if not 8<=len(openai_token)<=8192 or any(not 33<=ord(c)<=126 for c in openai_token):raise ValueError('INVALID_MODEL_SECRET') | |
| from src.adapters.llm.openai_code import OpenAICodeProvider,MODELS | |
| result.extend(LimitedProvider(OpenAICodeProvider(model=model,token=openai_token),budget) for model in MODELS) | |
| if not token:return result | |
| if not 8<=len(token)<=8192 or any(not 33<=ord(c)<=126 for c in token):raise ValueError('INVALID_MODEL_SECRET') | |
| base=os.environ.get('DASHSCOPE_BASE_URL','https://dashscope.aliyuncs.com/compatible-mode/v1').rstrip('/') | |
| url=urlsplit(base) | |
| if (url.scheme!='https' or url.hostname not in {'dashscope.aliyuncs.com','dashscope-intl.aliyuncs.com','dashscope-us.aliyuncs.com','cn-hongkong.dashscope.aliyuncs.com'} | |
| or url.path!='/compatible-mode/v1' or url.port not in {None,443} or url.username or url.password or url.query or url.fragment): | |
| raise ValueError('INVALID_MODEL_ENDPOINT') | |
| for model,profile in PROFILES.items(): | |
| provider=ChatCompletionProvider(name='bailian-'+model,endpoint=base+'/chat/completions',model=model,token=token,timeout=120, | |
| enable_thinking=profile['thinking'],json_mode=profile['json_mode']) | |
| provider.routing_version=VERSION;provider.task_roles=profile['roles'] | |
| provider.selectable=profile.get('selectable',False);provider.health={'status':'not_probed'} | |
| result.append(LimitedProvider(provider,budget)) | |
| return result | |
| def create_app(): | |
| data=ROOT/'.local/hf-runtime';data.mkdir(parents=True,exist_ok=True) | |
| providers=providers_from_environment(data) | |
| preferred=os.environ.get('ZKCODING_DEFAULT_MODEL','') | |
| if preferred: | |
| if not any(p.model==preferred and p.selectable for p in providers): | |
| raise ValueError('INVALID_DEFAULT_MODEL') | |
| for provider in providers:provider.automatic_preference=preferred | |
| engine=LocalWorkbench(data,providers,sandbox_capacity=int(os.environ.get('ZKCODING_SANDBOX_CAPACITY','3'))) | |
| engine.identity.seed_demo_users();engine.preview_origin=ORIGIN | |
| threading.Thread(target=initialize_model_health,args=(providers,data/'model-health.json'),daemon=True,name='space-model-health').start() | |
| web=create_web(engine,7860) | |
| release_path=ROOT/'deploy/hf/release.json' | |
| if release_path.is_file(): | |
| release=json.loads(release_path.read_text(encoding='utf-8')) | |
| def release_info():return release | |
| return SpaceIngress(web,ORIGIN,bridge=PreviewBridge(engine)) | |