""" app.py — HuggingFace Spaces entry point. Architecture: Python : Gradio UI, Claude API calls, HF I/O, PDF processing Julia : Indicators, BacktestEngine, WalkForwardOptimizer, SignalCompiler Python NEVER does numerical computation. It only: 1. Calls Claude API (extraction + strategy code generation) 2. Calls Julia via juliacall for all math 3. Reads/writes HuggingFace datasets 4. Renders Gradio UI """ import io, json, zipfile, tempfile from pathlib import Path from datetime import datetime import gradio as gr from loguru import logger import utils.config as cfg import utils.hf_io as hf from pipeline.pdf_processor import PDFProcessor from pipeline.extractor import AIExtractor, Deduplicator from pipeline.julia_bridge import full_backtest_pipeline, julia_available from pipeline.exporter import ( slugify, strategy_md, formula_md, backtest_report_md, optimal_json, mt5_set, julia_config, index_md, ) # ── Lazy KB ─────────────────────────────────────────── _kb = None def get_kb(): global _kb if _kb is None: _kb = hf.kb_load() return _kb def reset_kb(): global _kb; _kb = hf.kb_load() # ═══════════════════════════════════════════════════ # TAB 1 — UPLOAD & EXTRACT # ═══════════════════════════════════════════════════ def _save_and_resolve_pdfs(pdf_files) -> list: """ Gradio 6 passes uploaded files as plain string paths into a temp dir that may be cleaned up before or during processing. This function: 1. Immediately copies every uploaded file to /tmp/quant/pdfs/ (persistent for session) 2. Uploads each to HuggingFace dataset pdfs/ folder (persistent across restarts) 3. Returns stable local Path objects ready for processing """ import shutil PDF_DIR = cfg.TMP / "pdfs" PDF_DIR.mkdir(parents=True, exist_ok=True) resolved = [] for f in (pdf_files or []): try: # Gradio 6: f is a str path; Gradio 5: f has .name attribute src = Path(f.name if hasattr(f, "name") else f) if not src.exists(): logger.warning(f"Uploaded path does not exist: {src}") continue dst = PDF_DIR / src.name if not dst.exists(): shutil.copy2(str(src), str(dst)) resolved.append(dst) # Persist to HuggingFace if cfg.HF_TOKEN and cfg.HF_DATASET_REPO: hf.pdf_upload(dst) except Exception as e: logger.error(f"Failed to resolve upload {f}: {e}") return resolved def load_pdfs_from_hf() -> list: """List PDFs previously uploaded to HuggingFace dataset.""" try: from huggingface_hub import list_repo_files files = list(list_repo_files( repo_id=cfg.HF_DATASET_REPO, repo_type="dataset", token=cfg.HF_TOKEN, )) return sorted([f for f in files if f.startswith("pdfs/") and f.endswith(".pdf")]) except Exception as e: logger.warning(f"Could not list HF PDFs: {e}") return [] def download_pdf_from_hf(remote_path: str) -> Path | None: """Download a PDF from HuggingFace to local cache.""" try: from huggingface_hub import hf_hub_download PDF_DIR = cfg.TMP / "pdfs" PDF_DIR.mkdir(parents=True, exist_ok=True) local = hf_hub_download( repo_id=cfg.HF_DATASET_REPO, filename=remote_path, repo_type="dataset", token=cfg.HF_TOKEN, local_dir=str(PDF_DIR), force_download=False, ) return Path(local) except Exception as e: logger.warning(f"Failed to download {remote_path}: {e}") return None def _extract_paths(paths: list, log: list, totals: dict, progress, kb: dict): """Core extraction loop — shared by new upload and re-process from HF.""" proc = PDFProcessor() ai = AIExtractor() dedup = Deduplicator() hf_files = [] for i, path in enumerate(paths): progress((i + 1) / max(len(paths), 1), desc=f"{path.name}") log.append(f"\n📖 [{i+1}/{len(paths)}] {path.name}") try: chunks = list(proc.process(path)) log.append(f" → {len(chunks)} chunks extracted") except Exception as e: log.append(f" ❌ PDF read error: {e}") continue for chunk in chunks: try: extracted = ai.extract(chunk) stats = dedup.process(extracted, kb) for kind in ("strategies", "formulas", "systems"): for act in ("added", "merged", "skipped"): totals[kind][act] += stats[kind][act] except Exception as e: log.append(f" ⚠️ Chunk error: {e}") log.append(f" → New: {totals['strategies']['added']} strats, " f"{totals['formulas']['added']} formulas") for cid, rec in kb["strategies"].items(): hf_files.append((f"extracted/strategies/{slugify(rec.get('name',''))}.md", strategy_md(rec).encode())) for cid, rec in kb["formulas"].items(): hf_files.append((f"extracted/formulas/{slugify(rec.get('name',''))}.md", formula_md(rec).encode())) progress(0.95, desc="Saving to HuggingFace…") hf.kb_save(kb) if hf_files and cfg.HF_TOKEN: pushed = hf.push_batch(hf_files, "Update extracted knowledge") log.append(f"\n☁️ Pushed {pushed} markdown files to HuggingFace") reset_kb() return ai.tokens_used def run_extraction(pdf_files, progress=gr.Progress()): if not cfg.ANTHROPIC_API_KEY: return "❌ ANTHROPIC_API_KEY secret not set.", "" if not cfg.HF_DATASET_REPO: return "❌ HF_DATASET_REPO secret not set.", "" # Step 1: resolve uploads → stable local paths + upload to HF progress(0.0, desc="Saving uploads to HuggingFace…") paths = _save_and_resolve_pdfs(pdf_files) if not paths: return ("⚠️ No valid PDFs found. Upload files above, " "or use 'Re-process from HF' to reprocess previously uploaded PDFs."), "" kb = get_kb() log = [] totals = {k: {"added":0,"merged":0,"skipped":0} for k in ("strategies","formulas","systems")} tokens = _extract_paths(paths, log, totals, progress, kb) counts = {k: len(kb[k]) for k in kb} summary = f"""✅ Extraction Complete PDFs processed : {len(paths)} Strategies — added: {totals['strategies']['added']} merged: {totals['strategies']['merged']} skipped: {totals['strategies']['skipped']} Formulas — added: {totals['formulas']['added']} merged: {totals['formulas']['merged']} skipped: {totals['formulas']['skipped']} Systems — added: {totals['systems']['added']} merged: {totals['systems']['merged']} skipped: {totals['systems']['skipped']} KB totals : {counts['strategies']} strategies · {counts['formulas']} formulas · {counts['systems']} systems Tokens used : {tokens:,} PDFs stored : HuggingFace → {cfg.HF_DATASET_REPO}/pdfs/""" return summary, "\n".join(log[-50:]) def reprocess_from_hf(selected_pdfs, progress=gr.Progress()): """Download selected PDFs from HF and re-extract.""" if not cfg.ANTHROPIC_API_KEY: return "❌ ANTHROPIC_API_KEY secret not set.", "" if not cfg.HF_DATASET_REPO: return "❌ HF_DATASET_REPO secret not set.", "" if not selected_pdfs: return "⚠️ No PDFs selected.", "" progress(0.0, desc="Downloading from HuggingFace…") paths = [] for remote in selected_pdfs: p = download_pdf_from_hf(remote) if p: paths.append(p) if not paths: return "❌ Could not download any PDFs from HuggingFace.", "" kb = get_kb() log = [f"Re-processing {len(paths)} PDF(s) from HuggingFace\n"] totals = {k: {"added":0,"merged":0,"skipped":0} for k in ("strategies","formulas","systems")} tokens = _extract_paths(paths, log, totals, progress, kb) counts = {k: len(kb[k]) for k in kb} return (f"✅ Re-extraction complete\n" f"PDFs: {len(paths)} · " f"Strategies: +{totals['strategies']['added']} · " f"Formulas: +{totals['formulas']['added']}\n" f"KB totals: {counts['strategies']} strategies · " f"{counts['formulas']} formulas\n" f"Tokens: {tokens:,}"), "\n".join(log[-50:]) def refresh_hf_pdf_list(): pdfs = load_pdfs_from_hf() return gr.update(choices=pdfs, value=[]) # ═══════════════════════════════════════════════════ # TAB 2 — BROWSE KB # ═══════════════════════════════════════════════════ def search_strategies(query, category): kb = get_kb(); items = list(kb["strategies"].values()) if category and category != "All": items = [x for x in items if x.get("category") == category] if query: q = query.lower() items = [x for x in items if q in x.get("name","").lower() or q in x.get("description","").lower()] rows = [[x.get("name","")[:50], x.get("category",""), x.get("description","")[:100], ", ".join(x.get("sources",[]))[:40], len(x.get("layers",[]))] for x in items[:100]] return rows, f"{len(items)} strategies" def search_formulas(query): kb = get_kb(); items = list(kb["formulas"].values()) if query: q = query.lower() items = [x for x in items if q in x.get("name","").lower() or q in x.get("purpose","").lower()] return [[x.get("name","")[:50], x.get("category",""), x.get("purpose","")[:80], "✅" if x.get("latex") else "—", ", ".join(x.get("sources",[]))[:40]] for x in items[:100]] def dl_strategy(name): kb = get_kb() for rec in kb["strategies"].values(): if rec.get("name","").lower() == name.strip().lower(): tmp = tempfile.mktemp(suffix=".md") Path(tmp).write_text(strategy_md(rec), encoding="utf-8") return tmp return None def dl_all_strategies_zip(category): kb = get_kb(); items = list(kb["strategies"].values()) if category and category != "All": items = [x for x in items if x.get("category") == category] tmp = tempfile.mktemp(suffix=".zip") with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED) as zf: for rec in items: zf.writestr(f"{slugify(rec.get('name','unknown'))}.md", strategy_md(rec)) return tmp # ═══════════════════════════════════════════════════ # TAB 3 — BACKTEST (Julia Engine) # ═══════════════════════════════════════════════════ def load_symbols(): syms = hf.tick_list_symbols() return gr.update(choices=syms, value=syms[:2] if len(syms)>=2 else syms) def run_backtests(selected_symbols, selected_timeframes, strategy_filter, max_strategies, viable_only, progress=gr.Progress()): if not cfg.HF_TICK_REPO: return "❌ HF_TICK_REPO not set.", "" if not cfg.ANTHROPIC_API_KEY: return "❌ ANTHROPIC_API_KEY not set.", "" if not julia_available(): return "❌ Julia runtime not available. Check build logs.", "" ai = AIExtractor() kb = get_kb() strats = list(kb["strategies"].values()) if strategy_filter: strats = [s for s in strats if strategy_filter.lower() in s.get("name","").lower()] if max_strategies > 0: strats = strats[:int(max_strategies)] if not strats: return "⚠️ No strategies. Run extraction first.", "" symbols = selected_symbols or hf.tick_list_symbols()[:2] timeframes = selected_timeframes or ["1h"] log, all_results, viable_count = [], [], 0 for si, rec in enumerate(strats): name = rec.get("name","?") progress(si/len(strats), desc=f"[{si+1}/{len(strats)}] {name[:35]}") # 1. Generate Julia signal code via Claude jl_code = ai.compile_strategy_code(rec) if not jl_code: log.append(f"❌ Code gen failed: {name[:40]}"); continue log.append(f"✅ Julia code generated: {name[:40]}") for sym in symbols: for tf in timeframes: df = hf.tick_load(sym, tf) if df is None or len(df) < 200: log.append(f" ⚠️ {sym} {tf}: no data"); continue # 2. Full Julia pipeline (compile → optimize → backtest) result = full_backtest_pipeline( strategy_code = jl_code, strategy_name = name, open_p = df["open"].values, high = df["high"].values, low = df["low"].values, close = df["close"].values, volume = df["volume"].values, timeframe = tf, symbol = sym, n_windows = cfg.WF_WINDOWS, is_ratio = cfg.WF_IS_RATIO, min_trades = cfg.MIN_TRADES, min_sharpe = cfg.MIN_SHARPE, max_combos = cfg.MAX_PARAM_COMBOS, initial_equity = cfg.INITIAL_EQUITY, commission_pct = cfg.COMMISSION_PCT, risk_per_trade = cfg.RISK_PER_TRADE, ) all_results.append(result) # 3. Build + push output files if cfg.HF_TOKEN and cfg.HF_DATASET_REPO: if not viable_only or result.get("is_viable"): hf.push_result( name, sym, tf, backtest_report_md(result, rec), optimal_json(result, rec), mt5_set(result, rec), julia_config(result), ) status = "✅" if result.get("is_viable") else "❌" log.append( f" {status} {sym} {tf}: " f"Sharpe={result.get('oos_sharpe_mean',0):.2f} " f"DD={result.get('oos_max_dd',0):.1f}% " f"Score={result.get('robustness',0):.0f}") if result.get("is_viable"): viable_count += 1 # 4. Push master index if all_results and cfg.HF_TOKEN: hf.push_index(index_md(all_results), { "generated": datetime.now().isoformat(), "engine": "Julia 1.11", "total_strategies": len(all_results), "viable_count": viable_count, "strategies": all_results, }) summary = f"""🏁 Julia Backtest Complete Engine: Julia 1.11 BacktestEngine.jl Strategies compiled: {len(strats)} Combinations tested: {len(all_results)} Viable strategies: {viable_count} Pass rate: {viable_count/max(len(all_results),1)*100:.1f}% Results on HuggingFace: {cfg.HF_DATASET_REPO}/optimal_sets/BACKTEST_INDEX.md""" return summary, "\n".join(log[-60:]) # ═══════════════════════════════════════════════════ # TAB 4 — RESULTS # ═══════════════════════════════════════════════════ def load_results(): data = hf.fetch_index() if not data: return [], "No results yet." strats = data.get("strategies",[]) viable = sorted([s for s in strats if s.get("is_viable")], key=lambda x: x.get("oos_sharpe_mean",0), reverse=True) rows = [[s.get("strategy","")[:45], s.get("symbol",""), s.get("timeframe",""), f'{s.get("oos_sharpe_mean",0):.2f}', f'{s.get("oos_max_dd",0):.1f}%', f'{s.get("oos_win_rate",0):.1f}%', f'{s.get("oos_pf_mean",0):.2f}', f'{s.get("robustness",0):.0f}'] for s in viable] count = (f"✅ {len(viable)} viable / {len(strats)} tested | " f"Engine: Julia | {data.get('generated','')[:16]}") return rows, count def dl_result_file(name, symbol, tf, ftype): sl = slugify(name); sym = symbol.upper().strip() pre = f"{sl}_{sym}_{tf}" ext_map = {"MT5 .set file": f"optimal_sets/{pre}.set", "Optimal JSON": f"optimal_sets/{pre}_optimal.json", "Julia config": f"optimal_sets/{pre}_config.jl", "Full report": f"backtests/{sl}/{pre}_report.md"} remote = ext_map.get(ftype,"") if not remote: return None data = hf.fetch_file(remote) if not data: return None tmp = tempfile.mktemp(suffix=Path(remote).suffix) Path(tmp).write_bytes(data) return tmp def dl_all_sets(): data = hf.fetch_index() if not data: return None tmp = tempfile.mktemp(suffix=".zip") with zipfile.ZipFile(tmp,"w",zipfile.ZIP_DEFLATED) as zf: for s in data.get("strategies",[]): if not s.get("is_viable"): continue sl = slugify(s["strategy"]); sym = s["symbol"]; tf = s["timeframe"] content = hf.fetch_file(f"optimal_sets/{sl}_{sym}_{tf}.set") if content: zf.writestr(f"{sl}_{sym}_{tf}.set", content) return tmp # ═══════════════════════════════════════════════════ # TAB 5 — SETUP # ═══════════════════════════════════════════════════ def check_config(): checks = [ ("ANTHROPIC_API_KEY", cfg.ANTHROPIC_API_KEY, "Claude API"), ("HF_TOKEN", cfg.HF_TOKEN, "HF write access"), ("HF_DATASET_REPO", cfg.HF_DATASET_REPO, "Results storage"), ("HF_TICK_REPO", cfg.HF_TICK_REPO, "Tick data source"), ] kb = get_kb() symbols = hf.tick_list_symbols() if cfg.HF_TICK_REPO else [] jl_ok = julia_available() lines = ["## Configuration Status", ""] for name, val, desc in checks: icon = "✅" if val else "❌" lines.append(f"{icon} `{name}` — {desc}") lines += ["", "## Julia Engine", "", f"{'✅' if jl_ok else '❌'} Julia runtime: {'available' if jl_ok else 'not available (check build logs)'}", "", "## Data Status", "", f"- Tick symbols: **{len(symbols)}** — {', '.join(symbols[:8])}", f"- Strategies in KB: **{len(kb['strategies'])}**", f"- Formulas in KB: **{len(kb['formulas'])}**", "", "## Backtest Settings", "", f"- WF Windows: `{cfg.WF_WINDOWS}` · IS Ratio: `{cfg.WF_IS_RATIO}`", f"- Min Trades: `{cfg.MIN_TRADES}` · Min Sharpe: `{cfg.MIN_SHARPE}`", f"- Commission: `{cfg.COMMISSION_PCT*100:.3f}%` · Risk/trade: `{cfg.RISK_PER_TRADE*100:.1f}%`", f"- Timeframes: `{', '.join(cfg.BACKTEST_TFS)}`"] return "\n".join(lines) # ═══════════════════════════════════════════════════ # BUILD APP # ═══════════════════════════════════════════════════ CATS = ["All"] + cfg.CATEGORIES CSS = ".status-box{font-family:monospace;font-size:.82em}" with gr.Blocks(title="Quant Knowledge Extractor — Julia Engine") as demo: gr.HTML("""

📊 Quant Knowledge Extractor

Julia 1.11 Engine · BacktestEngine.jl · WalkForward Optimizer · MT5 .set Output

""") with gr.Tabs(): # Tab 1 — Extract with gr.Tab("📤 Upload & Extract"): gr.Markdown("""### Upload algorithmic trading PDFs PDFs are **saved to HuggingFace** (`pdfs/` folder) so you can re-process them anytime without re-uploading. OCR is applied automatically to scanned pages.""") with gr.Row(): with gr.Column(scale=2): pdf_in = gr.File(label="Drop PDFs here", file_count="multiple", file_types=[".pdf"]) ext_btn = gr.Button("🚀 Upload + Extract", variant="primary", size="lg") with gr.Column(scale=1): ext_out = gr.Textbox(label="Result", lines=14, interactive=False, elem_classes=["status-box"]) ext_log = gr.Textbox(label="Log", lines=8, interactive=False, elem_classes=["status-box"]) gr.Markdown("---\n### Re-process PDFs already on HuggingFace") gr.Markdown("*Use this if the container restarted and lost your session, " "or to re-extract with updated prompts.*") with gr.Row(): hf_refresh = gr.Button("🔄 Refresh HF PDF list") hf_pdf_list = gr.CheckboxGroup(label="PDFs stored on HuggingFace", choices=[], value=[]) rep_btn = gr.Button("♻️ Re-process selected PDFs from HuggingFace", variant="secondary") rep_out = gr.Textbox(label="Re-process result", lines=6, interactive=False, elem_classes=["status-box"]) rep_log = gr.Textbox(label="Re-process log", lines=6, interactive=False, elem_classes=["status-box"]) ext_btn.click(fn=run_extraction, inputs=[pdf_in], outputs=[ext_out, ext_log]) hf_refresh.click(fn=refresh_hf_pdf_list, outputs=[hf_pdf_list]) rep_btn.click(fn=reprocess_from_hf, inputs=[hf_pdf_list], outputs=[rep_out, rep_log]) demo.load(fn=refresh_hf_pdf_list, outputs=[hf_pdf_list]) # Tab 2 — Browse with gr.Tab("📚 Knowledge Base"): with gr.Tabs(): with gr.Tab("📈 Strategies"): with gr.Row(): sq = gr.Textbox(label="Search", placeholder="RSI, breakout, Kelly…") sc = gr.Dropdown(choices=CATS, value="All", label="Category") sb = gr.Button("🔍 Search", variant="primary") st = gr.Dataframe(headers=["Name","Category","Description","Sources","Variants"], datatype=["str"]*4+["number"], interactive=False) sn = gr.Markdown("") with gr.Row(): sni = gr.Textbox(label="Name to download") sdb = gr.Button("⬇️ Download MD"); sdf = gr.File(label="") szb = gr.Button("📦 Category ZIP"); szf = gr.File(label="") sb.click(fn=search_strategies, inputs=[sq,sc], outputs=[st,sn]) sdb.click(fn=dl_strategy, inputs=[sni], outputs=[sdf]) szb.click(fn=dl_all_strategies_zip, inputs=[sc], outputs=[szf]) with gr.Tab("∑ Formulas"): with gr.Row(): fq = gr.Textbox(label="Search", placeholder="Sharpe, Kelly, ATR…") fb = gr.Button("🔍 Search", variant="primary") ft = gr.Dataframe(headers=["Name","Category","Purpose","LaTeX","Sources"], datatype=["str"]*5, interactive=False) fb.click(fn=search_formulas, inputs=[fq], outputs=[ft]) # Tab 3 — Backtest with gr.Tab("🔬 Julia Backtest"): gr.Markdown( "### Walk-Forward Backtest — Julia Engine\n" "Claude generates Julia signal code → Julia compiles + optimizes → " "MT5 `.set` files pushed to HuggingFace." ) with gr.Row(): with gr.Column(scale=2): bt_load = gr.Button("🔄 Load Symbols from HF") bt_syms = gr.CheckboxGroup(label="Symbols", choices=[], value=[]) bt_tfs = gr.CheckboxGroup( label="Timeframes", value=["1h","4h"], choices=["1m","5m","15m","30m","1h","4h","1d"]) bt_filt = gr.Textbox(label="Strategy filter (optional)") bt_max = gr.Slider(0, 500, value=0, step=10, label="Max strategies (0=all)") bt_viable= gr.Checkbox(label="Push only VIABLE to HuggingFace", value=True) bt_run = gr.Button("🚀 Run Julia Backtests", variant="primary", size="lg") with gr.Column(scale=1): bt_out = gr.Textbox(label="Summary", lines=12, interactive=False, elem_classes=["status-box"]) bt_log = gr.Textbox(label="Log", lines=12, interactive=False, elem_classes=["status-box"]) bt_load.click(fn=load_symbols, outputs=[bt_syms]) bt_run.click(fn=run_backtests, inputs=[bt_syms, bt_tfs, bt_filt, bt_max, bt_viable], outputs=[bt_out, bt_log]) # Tab 4 — Results with gr.Tab("🏆 Results"): gr.Markdown("### Viable Strategies — Download MT5 `.set` & Julia Configs") res_ref = gr.Button("🔄 Refresh from HuggingFace", variant="primary") res_tbl = gr.Dataframe( headers=["Strategy","Symbol","TF","Sharpe","Max DD","Win%","PF","Score"], datatype=["str"]*8, interactive=False) res_cnt = gr.Markdown("") gr.Markdown("#### Download individual file") with gr.Row(): rn = gr.Textbox(label="Strategy name"); rs = gr.Textbox(label="Symbol") rt = gr.Textbox(label="Timeframe") rf = gr.Dropdown(choices=["MT5 .set file","Optimal JSON", "Julia config","Full report"], value="MT5 .set file", label="File type") rdb = gr.Button("⬇️ Download", variant="primary"); rdf = gr.File(label="") gr.Markdown("#### Batch download all viable strategies") with gr.Row(): rsb = gr.Button("🎯 All MT5 .set (ZIP)"); rsf = gr.File(label="") res_ref.click(fn=load_results, outputs=[res_tbl, res_cnt]) rdb.click(fn=dl_result_file, inputs=[rn,rs,rt,rf], outputs=[rdf]) rsb.click(fn=dl_all_sets, outputs=[rsf]) demo.load(fn=load_results, outputs=[res_tbl, res_cnt]) # Tab 5 — Setup with gr.Tab("⚙️ Setup & Status"): gr.Markdown("""### Required Secrets (Space Settings → Variables and Secrets) | Secret | Description | |--------|-------------| | `ANTHROPIC_API_KEY` | Claude API key | | `HF_TOKEN` | HuggingFace write token | | `HF_DATASET_REPO` | `your-username/quant-knowledge-base` | | `HF_TICK_REPO` | `your-username/tick-data` | ### Tick Data Format Upload to your `tick-data` dataset: ``` EURUSD/ticks.parquet (columns: timestamp, bid, ask OR open,high,low,close,volume) BTCUSDT/1h.parquet (pre-built OHLCV — faster) ``` """) cfg_ref = gr.Button("🔄 Check Status") cfg_out = gr.Markdown(check_config()) cfg_ref.click(fn=check_config, outputs=[cfg_out]) gr.HTML("""
Quant Knowledge Extractor · Julia 1.11 Engine · HuggingFace Spaces
""") if __name__ == "__main__": demo.launch( theme=gr.themes.Base(primary_hue="green", neutral_hue="gray"), css=CSS, )