windhover 0.7.0__py3-none-any.whl

windhover/__init__.py

@@ -0,0 +1,5 @@
+"""Windhover — self-hosted LangGraph observability."""
+from .tracer import WindhoverTracer, SpanBuilder
+
+__version__ = "0.3.0"
+__all__ = ["WindhoverTracer", "SpanBuilder", "__version__"]

windhover/config.py

@@ -0,0 +1,32 @@
+"""Windhover configuration — one place, read from the environment."""
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+PKG_DIR = Path(__file__).resolve().parent
+
+
+@dataclass(frozen=True)
+class Config:
+    graph_ref: str            # "module:attr" of a compiled graph ("" = ingest-only)
+    graph_dir: str            # import path for the graph module
+    db_path: str
+    host: str
+    port: int
+    watch: bool               # live-topology file watcher
+    pricing_path: str
+    retention_days: int       # 0 = keep runs forever
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        return cls(
+            graph_ref=os.environ.get("WINDHOVER_GRAPH", ""),
+            graph_dir=os.environ.get("WINDHOVER_GRAPH_DIR", os.getcwd()),
+            db_path=os.environ.get("WINDHOVER_DB", str(PKG_DIR.parent / "windhover.db")),
+            host=os.environ.get("WINDHOVER_HOST", "0.0.0.0"),
+            port=int(os.environ.get("WINDHOVER_PORT", "8090")),
+            watch=os.environ.get("WINDHOVER_WATCH", "1") not in ("0", "false", "no"),
+            pricing_path=os.environ.get("WINDHOVER_PRICING", str(PKG_DIR / "pricing.json")),
+            retention_days=int(os.environ.get("WINDHOVER_RETENTION_DAYS", "0") or 0),
+        )

windhover/demo_graph.py

@@ -0,0 +1,48 @@
+"""Self-contained demo graph so Windhover runs out of the box:
+
+    WINDHOVER_GRAPH=windhover.demo_graph:graph python -m windhover.server
+
+No external services. Edit this file while Windhover runs to watch the topology
+update itself in the UI. Includes a parallel fan-out (grow -> parity/sign/
+magnitude -> summarize) so the graph view and trace show concurrent branches;
+`notes` uses an additive reducer so the branches can write it concurrently.
+"""
+import operator
+import time
+from typing import Annotated, TypedDict
+from langgraph.graph import StateGraph, START, END
+
+
+class State(TypedDict):
+    n: int
+    notes: Annotated[list, operator.add]
+
+
+def seed(s):
+    time.sleep(.2)
+    n = s.get("n", 1)
+    if n < 0:
+        raise ValueError(f"n must be non-negative, got {n} — the demo guard tripped")
+    return {"n": n}
+def grow(s):       time.sleep(.3);  return {"n": s["n"] * 3}
+def parity(s):     time.sleep(.4);  return {"notes": ["even" if s["n"] % 2 == 0 else "odd"]}
+def sign(s):       time.sleep(.25); return {"notes": ["positive" if s["n"] > 0 else "non-positive"]}
+def magnitude(s):  time.sleep(.35); return {"notes": ["big" if abs(s["n"]) > 100 else "small"]}
+def summarize(s):  time.sleep(.2);  return {"notes": [f"n={s['n']}: " + ", ".join(s["notes"])]}
+
+
+_g = StateGraph(State)
+for name, fn in [("seed", seed), ("grow", grow), ("parity", parity),
+                 ("sign", sign), ("magnitude", magnitude), ("summarize", summarize)]:
+    _g.add_node(name, fn)
+_g.add_edge(START, "seed")
+_g.add_edge("seed", "grow")
+_g.add_edge("grow", "parity")
+_g.add_edge("grow", "sign")
+_g.add_edge("grow", "magnitude")
+_g.add_edge("parity", "summarize")
+_g.add_edge("sign", "summarize")
+_g.add_edge("magnitude", "summarize")
+_g.add_edge("summarize", END)
+
+graph = _g.compile()

windhover/extract.py

@@ -0,0 +1,103 @@
+"""Extract a compiled graph's topology, input schema, and per-node source as
+JSON. Run as a subprocess so the live watcher always sees current-on-disk code
+without importlib.reload fragility.
+
+    python -m windhover.extract "module:attr" "/graph/dir"
+"""
+import sys, json, importlib, inspect, functools
+
+
+def topology(graph, xray: bool = False) -> dict:
+    g = graph.get_graph(xray=True) if xray else graph.get_graph()
+    nodes = [{"id": nid, "label": str(getattr(n, "name", nid)).replace("__", ""),
+              "terminal": nid.endswith(("__start__", "__end__"))}
+             for nid, n in g.nodes.items()]
+    edges = [{"id": f"e{i}", "source": e.source, "target": e.target,
+              "conditional": bool(getattr(e, "conditional", False))}
+             for i, e in enumerate(g.edges)]
+    return {"nodes": nodes, "edges": edges}
+
+
+def input_schema(graph) -> dict:
+    for meth in ("get_input_jsonschema", "get_input_schema"):
+        try:
+            s = getattr(graph, meth)()
+            return s if isinstance(s, dict) else s.model_json_schema()
+        except Exception:
+            continue
+    return {}
+
+
+def _unwrap(fn):
+    """Peel partials, decorators, and bound methods down to the user function."""
+    seen = set()
+    while id(fn) not in seen:
+        seen.add(id(fn))
+        if isinstance(fn, functools.partial):
+            fn = fn.func
+        elif hasattr(fn, "__wrapped__"):
+            fn = fn.__wrapped__
+        elif inspect.ismethod(fn):
+            fn = fn.__func__
+        else:
+            break
+    return fn
+
+
+def _node_callable(graph, name):
+    """Best-effort: the user callable backing a LangGraph node. The compiled
+    graph keeps the builder's node specs; RunnableCallable exposes .func/.afunc."""
+    candidates = (
+        lambda: graph.builder.nodes[name].runnable.func,
+        lambda: graph.builder.nodes[name].runnable.afunc,
+        lambda: graph.builder.nodes[name].runnable,
+    )
+    for get in candidates:
+        try:
+            fn = get()
+        except Exception:
+            continue
+        if fn is not None:
+            return _unwrap(fn)
+    return None
+
+
+def sources(graph) -> dict:
+    """{node: {file, line_start, line_end, code}} for every node we can trace
+    to real source. Missing nodes simply aren't in the map — never an error."""
+    out = {}
+    builder = getattr(graph, "builder", None)
+    for name in (getattr(builder, "nodes", None) or {}):
+        fn = _node_callable(graph, name)
+        if fn is None:
+            continue
+        for target in (fn, type(fn)):  # class-based runnables: show the class
+            try:
+                lines, start = inspect.getsourcelines(target)
+                out[name] = {"file": inspect.getsourcefile(target) or "",
+                             "line_start": start,
+                             "line_end": start + len(lines) - 1,
+                             "code": "".join(lines)[:20000]}
+                break
+            except Exception:
+                continue
+    return out
+
+
+def load(ref: str, dir_: str):
+    sys.path.insert(0, dir_)
+    mod, attr = ref.split(":")
+    return getattr(importlib.import_module(mod), attr)
+
+
+if __name__ == "__main__":
+    ref, dir_ = sys.argv[1], sys.argv[2]
+    g = load(ref, dir_)
+    out = {"topology": topology(g), "schema": input_schema(g), "sources": sources(g)}
+    try:  # subgraph x-ray view, only when it actually differs
+        tx = topology(g, xray=True)
+        if tx != out["topology"]:
+            out["topology_xray"] = tx
+    except Exception:
+        pass
+    print(json.dumps(out))

windhover/pricing.json

@@ -0,0 +1,16 @@
+{
+  "_comment": "USD per 1M tokens {input,output}. Longest-prefix match on model name. Miss -> cost null. Add your own.",
+  "gpt-5": {"input": 1.25, "output": 10},
+  "gpt-5-mini": {"input": 0.25, "output": 2},
+  "gpt-4o": {"input": 2.5, "output": 10},
+  "gpt-4o-mini": {"input": 0.15, "output": 0.6},
+  "o1": {"input": 15, "output": 60},
+  "o3-mini": {"input": 1.1, "output": 4.4},
+  "claude-opus-4": {"input": 15, "output": 75},
+  "claude-sonnet-4": {"input": 3, "output": 15},
+  "claude-3-5-haiku": {"input": 0.8, "output": 4},
+  "claude-3-5-sonnet": {"input": 3, "output": 15},
+  "gemini-2.5-pro": {"input": 1.25, "output": 10},
+  "gemini-2.5-flash": {"input": 0.3, "output": 2.5},
+  "deepseek-chat": {"input": 0.27, "output": 1.1}
+}

windhover/server.py

@@ -0,0 +1,333 @@
+"""Windhover HTTP server — observes a LangGraph graph and any app that traces to it.
+
+Runs execute on a worker thread with a DB-sink tracer, so a full span tree
+(nodes -> LLM/tool children, tokens, cost) persists even if the browser leaves.
+A background watcher re-extracts topology in a subprocess when the graph's source
+changes and pushes it to the UI (the "living graph"). Runs use the imported graph
+(restart to run new code); the *view* always reflects current-on-disk topology.
+"""
+from __future__ import annotations
+import sys, json, time, hashlib, threading, queue, subprocess, importlib, traceback
+from pathlib import Path
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from .config import Config
+from .store import Store
+from .tracer import SpanBuilder, db_sink, apply_to_store
+
+cfg = Config.from_env()
+store = Store(cfg.db_path)
+STATIC = Path(__file__).parent / "static"
+
+graph = None
+if cfg.graph_ref:
+    sys.path.insert(0, cfg.graph_dir)
+    _m, _a = cfg.graph_ref.split(":")
+    graph = getattr(importlib.import_module(_m), _a)
+
+app = FastAPI(title="Windhover")
+
+
+# ---- topology manager (subprocess extraction, mtime-cached) ---------------
+class Topo:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.sig = None
+        self.data = {"topology": {"nodes": [], "edges": []}, "schema": {}, "sources": {}}
+        self.hash = ""
+        self.version = 0
+
+    def _signature(self) -> float:
+        if not cfg.graph_ref:
+            return 0.0
+        try:
+            return max((p.stat().st_mtime for p in Path(cfg.graph_dir).glob("*.py")),
+                       default=0.0)
+        except Exception:
+            return 0.0
+
+    def refresh(self, force=False) -> None:
+        if not cfg.graph_ref:
+            return
+        sig = self._signature()
+        with self.lock:
+            if not force and sig == self.sig:
+                return
+            self.sig = sig
+        try:
+            out = subprocess.run(
+                [sys.executable, "-m", "windhover.extract", cfg.graph_ref, cfg.graph_dir],
+                capture_output=True, text=True, timeout=20,
+                cwd=str(Path(__file__).parent.parent))
+            data = json.loads(out.stdout)
+        except Exception:
+            return
+        h = hashlib.sha1(json.dumps(data["topology"], sort_keys=True).encode()).hexdigest()[:12]
+        with self.lock:
+            changed = h != self.hash
+            self.data, self.hash = data, h
+            if changed:
+                self.version += 1
+
+    def get(self) -> dict:
+        with self.lock:
+            return {**self.data["topology"], "graph": cfg.graph_ref, "hash": self.hash,
+                    "version": self.version, "xray": self.data.get("topology_xray")}
+
+    def schema(self) -> dict:
+        with self.lock:
+            return self.data.get("schema", {})
+
+    def sources(self) -> dict:
+        with self.lock:
+            return self.data.get("sources", {})
+
+
+TOPO = Topo()
+TOPO.refresh(force=True)
+
+
+def _watch_loop():
+    while cfg.watch and cfg.graph_ref:
+        time.sleep(2)
+        try:
+            TOPO.refresh()
+        except Exception:
+            pass
+
+
+if cfg.watch and cfg.graph_ref:
+    threading.Thread(target=_watch_loop, daemon=True).start()
+
+
+def _retention_loop():
+    while True:
+        try:
+            res = store.prune(cfg.retention_days)
+            if res["pruned_runs"]:
+                print(f"[windhover] retention: pruned {res['pruned_runs']} runs "
+                      f"older than {cfg.retention_days}d")
+        except Exception as e:
+            print(f"[windhover] retention error: {e}")
+        time.sleep(6 * 3600)
+
+
+if cfg.retention_days > 0:
+    threading.Thread(target=_retention_loop, daemon=True).start()
+
+
+def _template(schema: dict) -> dict:
+    out = {}
+    for k, p in (schema.get("properties") or {}).items():
+        out[k] = {"array": [], "object": {}, "string": "", "integer": 0,
+                  "number": 0, "boolean": False}.get(p.get("type"))
+    return out
+
+
+# ---- endpoints ------------------------------------------------------------
+@app.get("/api/graph")
+def api_graph():
+    return JSONResponse(TOPO.get())
+
+
+@app.get("/api/schema")
+def api_schema():
+    s = TOPO.schema()
+    return JSONResponse({"schema": s, "template": _template(s)})
+
+
+def _sse(ev: str, data: dict) -> str:
+    return f"event: {ev}\ndata: {json.dumps(data)}\n\n"
+
+
+@app.post("/api/run")
+async def api_run(request: Request):
+    if graph is None:
+        return JSONResponse({"error": "no local graph (WINDHOVER_GRAPH unset)"}, 400)
+    try:
+        payload = await request.json()
+    except Exception:
+        payload = {}
+    session = payload.pop("_session", None)
+    tags = payload.pop("_tags", None)
+    tracer = SpanBuilder(db_sink(store), run_name=cfg.graph_ref, session=session, tags=tags)
+    run_id = tracer.run_id
+    q: "queue.Queue" = queue.Queue()
+
+    def worker():
+        try:
+            interrupted = False
+            for update in graph.stream(payload, config={"callbacks": [tracer]},
+                                       stream_mode="updates"):
+                for node in update:
+                    if node == "__interrupt__":
+                        interrupted = True
+                        q.put(("interrupt", {"run_id": run_id}))
+                    else:
+                        q.put(("node", {"node": node}))
+            q.put(("interrupted" if interrupted else "done", {"run_id": run_id}))
+        except Exception as e:
+            # tracer already recorded the error span/close; surface to the client too
+            q.put(("error", {"message": str(e), "trace": traceback.format_exc()[-600:]}))
+        q.put((None, None))
+
+    threading.Thread(target=worker, daemon=True).start()
+
+    def stream():
+        yield _sse("start", {"run_id": run_id})
+        while True:
+            ev, data = q.get()
+            if ev is None:
+                break
+            yield _sse(ev, data)
+    return StreamingResponse(stream(), media_type="text/event-stream")
+
+
+@app.post("/api/ingest")
+async def api_ingest(request: Request):
+    ev = await request.json()
+    apply_to_store(store, ev, source="ingest")
+    return {"ok": True, "run_id": ev.get("run_id")}
+
+
+def _run_filters(limit: int, offset: int, q, status, graph, session, tag,
+                 bookmarked, since_ms, until_ms) -> dict:
+    return dict(limit=max(1, min(limit, 500)), offset=max(0, offset),
+                q=q or None, status=status or None, graph=graph or None,
+                session=session or None, tag=tag or None,
+                bookmarked=bool(bookmarked) or None,
+                since_ms=since_ms, until_ms=until_ms)
+
+
+@app.get("/api/runs")
+def api_runs(limit: int = 50, offset: int = 0, q: str = None, status: str = None,
+             graph: str = None, session: str = None, tag: str = None,
+             bookmarked: int = 0, since_ms: int = None, until_ms: int = None):
+    return JSONResponse(store.runs(**_run_filters(
+        limit, offset, q, status, graph, session, tag, bookmarked, since_ms, until_ms)))
+
+
+@app.get("/api/sessions")
+def api_sessions(limit: int = 100):
+    return JSONResponse(store.sessions(limit=limit))
+
+
+@app.get("/api/runs/{run_id}")
+def api_run_detail(run_id: str):
+    d = store.run_detail(run_id)
+    return JSONResponse(d) if d else JSONResponse({"error": "not found"}, 404)
+
+
+@app.patch("/api/runs/{run_id}")
+async def api_run_patch(request: Request, run_id: str):
+    body = await request.json()
+    tags = body.get("tags")
+    if tags is not None and not isinstance(tags, list):
+        return JSONResponse({"error": "tags must be a list"}, 400)
+    ok = store.update_run_meta(run_id, tags=tags, bookmarked=body.get("bookmarked"))
+    return JSONResponse({"ok": ok}) if ok else JSONResponse({"error": "not found"}, 404)
+
+
+@app.post("/api/runs/{run_id}/scores")
+async def api_score_add(request: Request, run_id: str):
+    body = await request.json()
+    try:
+        name, value = str(body["name"]).strip(), float(body["value"])
+    except (KeyError, TypeError, ValueError):
+        return JSONResponse({"error": "requires name (str) and value (number)"}, 400)
+    if not name:
+        return JSONResponse({"error": "name must be non-empty"}, 400)
+    sc = store.add_score(run_id, name, value, comment=body.get("comment"),
+                         source=body.get("source", "api"))
+    return JSONResponse(sc) if sc else JSONResponse({"error": "run not found"}, 404)
+
+
+@app.delete("/api/scores/{score_id}")
+def api_score_delete(score_id: str):
+    return JSONResponse({"ok": store.delete_score(score_id)})
+
+
+@app.get("/api/export")
+def api_export(format: str = "json", limit: int = 10000, q: str = None,
+               status: str = None, graph: str = None, session: str = None,
+               tag: str = None, bookmarked: int = 0,
+               since_ms: int = None, until_ms: int = None):
+    data = store.runs(**{**_run_filters(limit, 0, q, status, graph, session, tag,
+                                        bookmarked, since_ms, until_ms),
+                         "limit": max(1, min(limit, 100_000))})["runs"]
+    if format == "csv":
+        import csv, io
+        cols = ["id", "graph", "source", "status", "session", "tags", "started_ms",
+                "duration_ms", "node_count", "llm_calls", "prompt_tokens",
+                "completion_tokens", "total_tokens", "cost_usd", "error"]
+        buf = io.StringIO()
+        w = csv.writer(buf)
+        w.writerow(cols)
+        for r in data:
+            w.writerow([json.dumps(r[k]) if isinstance(r.get(k), (list, dict))
+                        else r.get(k) for k in cols])
+        return StreamingResponse(iter([buf.getvalue()]), media_type="text/csv",
+            headers={"Content-Disposition": "attachment; filename=windhover-runs.csv"})
+    return JSONResponse(data)
+
+
+@app.get("/api/nodes/{name}")
+def api_node(name: str, limit: int = 25):
+    return JSONResponse(store.node_history(name, limit))
+
+
+@app.get("/api/nodes/{name}/source")
+def api_node_source(name: str):
+    src = TOPO.sources().get(name)
+    if src:
+        return JSONResponse(src)
+    return JSONResponse({"error": "no source available for this node "
+                        "(external-only run, or a runnable inspect can't trace)"}, 404)
+
+
+@app.get("/api/stats")
+def api_stats(days: int = 30):
+    return JSONResponse(store.stats(days=max(1, min(days, 365))))
+
+
+@app.get("/api/events")
+async def api_events(request: Request):
+    async def gen():
+        import asyncio
+        seen = -1
+        yield _sse("hello", {"version": TOPO.version})
+        while True:
+            if await request.is_disconnected():
+                break
+            if TOPO.version != seen:
+                seen = TOPO.version
+                yield _sse("topology", {"version": seen})
+            else:
+                yield ": ping\n\n"
+            await asyncio.sleep(2)
+    return StreamingResponse(gen(), media_type="text/event-stream")
+
+
+@app.get("/manifest.json")
+def manifest():
+    return FileResponse(STATIC / "manifest.json")
+
+
+@app.get("/")
+def index():
+    # no-cache so UI upgrades take effect on next load (vendor assets still cache)
+    return FileResponse(STATIC / "index.html", headers={"Cache-Control": "no-cache"})
+
+
+app.mount("/static", StaticFiles(directory=STATIC), name="static")
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host=cfg.host, port=cfg.port)
+
+
+if __name__ == "__main__":
+    main()

windhover/static/icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <defs><linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+    <stop offset="0" stop-color="#A32C3E"/><stop offset="1" stop-color="#571017"/></linearGradient></defs>
+  <rect width="512" height="512" rx="112" fill="url(#bg)"/>
+  <g transform="translate(56.0 116.7) scale(0.62893)">
+    <path d="M312.90,425.29 C310.64,423.25 306.72,418.86 304.18,415.54 C301.65,412.22 298.88,408.93 298.03,408.23 C295.97,406.53 289.90,407.25 282.33,410.11 C274.09,413.23 271.34,412.33 268.20,405.50 C262.04,392.12 261.63,391.51 258.52,391.16 C256.88,390.98 253.06,391.35 250.02,391.99 C242.01,393.68 239.51,392.45 236.41,385.25 C230.11,370.65 228.49,369.21 220.40,371.02 C217.79,371.61 214.35,371.80 212.76,371.45 C209.08,370.64 206.01,365.75 206.00,360.69 C206.00,357.52 206.81,356.01 210.82,351.69 C213.47,348.84 217.71,343.80 220.23,340.50 C222.75,337.20 226.92,332.48 229.51,330.00 C232.09,327.52 236.81,322.12 240.01,318.00 C243.20,313.88 249.27,307.12 253.49,303.00 C257.72,298.88 263.24,292.80 265.78,289.50 C268.31,286.20 272.76,280.90 275.66,277.73 C282.46,270.28 283.78,266.15 281.64,258.90 C278.68,248.89 277.41,247.67 267.38,245.23 C260.71,243.60 251.53,239.67 230.50,229.45 C215.10,221.96 200.47,214.74 198.00,213.41 C195.53,212.08 184.95,206.76 174.50,201.60 C164.05,196.44 153.25,191.06 150.50,189.65 C147.75,188.24 137.08,182.79 126.78,177.55 C114.19,171.14 107.49,167.16 106.33,165.38 C104.65,162.82 104.67,162.68 106.91,160.87 C108.24,159.80 110.80,159.00 112.91,159.00 C116.69,159.00 119.00,157.60 119.00,155.31 C119.00,154.60 114.84,151.96 109.75,149.44 C99.17,144.20 67.99,123.81 66.21,120.97 C65.56,119.93 65.31,118.35 65.66,117.45 C66.19,116.07 67.32,115.93 73.06,116.51 C81.49,117.35 84.00,116.65 84.00,113.45 C84.00,111.44 81.40,109.29 68.75,100.84 C52.97,90.30 37.70,78.18 35.86,74.74 C35.05,73.23 35.18,72.40 36.40,71.18 C37.85,69.72 38.96,69.82 49.38,72.36 C62.67,75.61 67.35,75.59 67.81,72.29 C68.05,70.60 65.53,67.46 57.31,59.22 C46.57,48.44 41.78,42.47 40.57,38.36 C39.71,35.46 42.49,32.71 45.36,33.60 C46.53,33.97 60.99,41.01 77.47,49.25 C93.96,57.49 112.41,66.03 118.47,68.23 C146.15,78.27 183.73,90.19 202.92,95.00 C219.11,99.06 221.00,99.92 227.79,106.30 C230.93,109.26 235.53,113.06 238.00,114.75 C240.47,116.45 245.43,120.83 249.00,124.50 C252.57,128.17 257.52,132.55 260.00,134.25 C262.48,135.94 267.05,139.73 270.18,142.66 C277.53,149.58 279.88,149.68 287.17,143.41 C290.10,140.89 295.20,137.43 298.50,135.71 C303.95,132.88 305.53,132.56 315.72,132.19 C331.48,131.62 338.30,133.73 347.42,142.00 C356.10,149.87 358.09,149.94 365.82,142.66 C368.95,139.73 373.52,135.94 376.00,134.25 C378.48,132.55 383.43,128.17 387.00,124.49 C390.57,120.82 395.98,116.11 399.00,114.01 C402.02,111.92 406.07,108.54 408.00,106.51 C412.56,101.70 416.56,99.78 427.50,97.09 C442.99,93.30 489.94,78.25 517.53,68.23 C523.59,66.03 542.04,57.49 558.53,49.25 C575.01,41.01 589.47,33.97 590.64,33.60 C592.03,33.17 593.37,33.51 594.43,34.57 C597.63,37.77 594.44,42.92 579.49,58.73 C573.72,64.83 569.00,70.52 569.00,71.38 C569.00,74.33 572.54,75.17 578.74,73.67 C591.83,70.50 597.95,69.72 599.51,71.01 C603.83,74.59 599.88,78.43 573.00,96.80 C566.67,101.12 558.72,106.13 555.32,107.93 C548.71,111.43 547.22,113.35 549.22,115.76 C550.25,117.00 552.19,117.16 560.13,116.64 C568.29,116.10 569.88,116.24 570.38,117.54 C570.70,118.39 570.44,119.93 569.79,120.97 C568.01,123.81 536.83,144.20 526.25,149.44 C521.16,151.96 517.00,154.60 517.00,155.31 C517.00,157.60 519.31,159.00 523.09,159.00 C525.20,159.00 527.76,159.80 529.09,160.87 C533.98,164.83 532.25,165.87 461.87,201.06 C425.53,219.23 394.15,235.20 392.12,236.54 C388.01,239.26 374.07,244.22 365.58,245.98 C361.45,246.84 359.57,247.82 358.19,249.82 C355.43,253.80 353.00,260.60 353.00,264.32 C353.00,267.82 357.09,275.09 360.98,278.50 C362.23,279.60 365.86,283.88 369.04,288.00 C372.21,292.12 378.27,298.88 382.50,303.00 C386.73,307.12 392.80,313.88 396.00,318.00 C399.19,322.12 404.37,327.98 407.50,331.00 C415.03,338.28 427.28,352.69 429.35,356.70 C431.73,361.32 431.39,364.53 428.13,368.18 C425.01,371.67 422.07,372.14 412.93,370.56 C406.63,369.48 403.40,372.27 401.99,380.00 C400.84,386.26 398.56,389.89 394.54,391.86 C392.28,392.97 390.71,393.00 386.11,392.02 C383.00,391.36 379.12,390.98 377.48,391.16 C374.37,391.51 373.96,392.12 367.80,405.50 C364.66,412.33 361.91,413.23 353.67,410.11 C346.10,407.25 340.03,406.53 337.97,408.23 C337.12,408.93 334.35,412.22 331.82,415.54 C326.95,421.91 319.68,429.00 318.00,429.00 C317.45,429.00 315.16,427.33 312.90,425.29 z M323.60,201.25 C329.52,190.76 330.86,189.21 336.20,186.68 C344.02,182.98 348.00,178.02 348.00,172.00 C348.00,168.25 346.43,165.00 344.62,165.00 C343.90,165.00 340.29,167.93 336.61,171.50 C332.93,175.07 329.50,178.00 328.99,178.00 C328.48,178.00 326.47,180.49 324.52,183.54 C322.57,186.58 320.28,189.34 319.42,189.67 C317.02,190.59 313.64,188.28 310.95,183.86 C308.20,179.35 294.66,167.00 292.47,167.00 C289.94,167.00 287.69,171.70 288.33,175.64 C289.11,180.46 291.29,182.65 298.80,186.21 C305.24,189.26 306.28,190.41 312.40,201.25 C314.64,205.22 315.56,206.00 318.00,206.00 C320.44,206.00 321.36,205.22 323.60,201.25 z" fill="#fff"/>
+  </g>
+</svg>