272 lines
10 KiB
Python
272 lines
10 KiB
Python
import json
|
|
import mimetypes
|
|
from pathlib import Path
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from typing import Optional
|
|
from urllib.parse import parse_qs, urlparse
|
|
|
|
from src.api.backtest import get_recent_backtest_summaries
|
|
from src.api.candles import get_recent_candles
|
|
from src.api.health import get_health
|
|
from src.api.sessions import get_recent_sessions
|
|
from src.api.signals import get_recent_signals
|
|
from src.api.training import (
|
|
add_training_annotation,
|
|
create_training_attempt,
|
|
get_training_case,
|
|
get_training_cases,
|
|
get_training_progress,
|
|
submit_training_attempt,
|
|
)
|
|
from src.services.execution import ExecutionService
|
|
|
|
|
|
def build_api_dependencies() -> dict:
|
|
execution_service = ExecutionService()
|
|
return {
|
|
"health": get_health,
|
|
"candles": get_recent_candles,
|
|
"sessions": get_recent_sessions,
|
|
"signals": get_recent_signals,
|
|
"backtests": get_recent_backtest_summaries,
|
|
"executions": execution_service.build_execution_dashboard_items,
|
|
"training_cases": get_training_cases,
|
|
"training_case": get_training_case,
|
|
"training_create_attempt": create_training_attempt,
|
|
"training_add_annotation": add_training_annotation,
|
|
"training_submit_attempt": submit_training_attempt,
|
|
"training_progress": get_training_progress,
|
|
}
|
|
|
|
|
|
STATIC_DIR = Path(__file__).resolve().parents[1] / "web"
|
|
MAX_TRAINING_LIMIT = 100
|
|
|
|
|
|
def route_request(
|
|
path: str,
|
|
query: dict,
|
|
dependencies: Optional[dict] = None,
|
|
method: str = "GET",
|
|
body: Optional[dict] = None,
|
|
) -> tuple[int, dict]:
|
|
deps = dependencies or build_api_dependencies()
|
|
method = method.upper()
|
|
path_parts = _path_parts(path)
|
|
|
|
if method == "GET" and path == "/health":
|
|
return 200, deps["health"]()
|
|
if method == "GET" and path == "/candles":
|
|
instrument_id = _require_int(query, "instrument_id")
|
|
timeframe = _get_single(query, "timeframe", "1m")
|
|
limit = _get_int(query, "limit", 100)
|
|
return 200, {"items": deps["candles"](instrument_id=instrument_id, timeframe=timeframe, limit=limit)}
|
|
if method == "GET" and path == "/sessions":
|
|
instrument_id = _require_int(query, "instrument_id")
|
|
limit = _get_int(query, "limit", 20)
|
|
return 200, {"items": deps["sessions"](instrument_id=instrument_id, limit=limit)}
|
|
if method == "GET" and path == "/signals":
|
|
instrument_id = _require_int(query, "instrument_id")
|
|
limit = _get_int(query, "limit", 20)
|
|
return 200, {"items": deps["signals"](instrument_id=instrument_id, limit=limit)}
|
|
if method == "GET" and path == "/backtests":
|
|
instrument_id = _get_optional_int(query, "instrument_id")
|
|
limit = _get_int(query, "limit", 10)
|
|
return 200, {"items": deps["backtests"](instrument_id=instrument_id, limit=limit)}
|
|
if method == "GET" and path == "/executions":
|
|
instrument_id = _require_int(query, "instrument_id")
|
|
limit = _get_int(query, "limit", 20)
|
|
return 200, {"items": deps["executions"](instrument_id=instrument_id, limit=limit)}
|
|
if method == "GET" and path == "/training/cases":
|
|
status = _get_single(query, "status")
|
|
skill_tag = _get_single(query, "skill_tag")
|
|
instrument_id = _get_optional_int(query, "instrument_id")
|
|
limit = _get_limit(query, "limit", 100, max_value=MAX_TRAINING_LIMIT)
|
|
return 200, {
|
|
"items": deps["training_cases"](
|
|
status=status,
|
|
skill_tag=skill_tag,
|
|
instrument_id=instrument_id,
|
|
limit=limit,
|
|
)
|
|
}
|
|
if method == "GET" and len(path_parts) == 3 and path_parts[:2] == ["training", "cases"]:
|
|
case_id = _parse_path_int(path_parts[2], "case_id")
|
|
case = deps["training_case"](case_id=case_id)
|
|
if case is None:
|
|
return 404, {"error": "not_found"}
|
|
return 200, case
|
|
if method == "POST" and path == "/training/attempts":
|
|
return 201, deps["training_create_attempt"](body or {})
|
|
if method == "POST" and len(path_parts) == 4 and path_parts[:2] == ["training", "attempts"] and path_parts[3] == "annotations":
|
|
attempt_id = _parse_path_int(path_parts[2], "attempt_id")
|
|
return 201, deps["training_add_annotation"](attempt_id, body or {})
|
|
if method == "POST" and len(path_parts) == 4 and path_parts[:2] == ["training", "attempts"] and path_parts[3] == "submit":
|
|
attempt_id = _parse_path_int(path_parts[2], "attempt_id")
|
|
return 200, deps["training_submit_attempt"](attempt_id, body or {})
|
|
if method == "GET" and path == "/training/progress":
|
|
user_id = _get_single(query, "user_id", "local")
|
|
skill_tag = _get_single(query, "skill_tag")
|
|
limit = _get_limit(query, "limit", 100, max_value=MAX_TRAINING_LIMIT)
|
|
return 200, {"items": deps["training_progress"](user_id=user_id, skill_tag=skill_tag, limit=limit)}
|
|
return 404, {"error": "not_found"}
|
|
|
|
|
|
class APIRequestHandler(BaseHTTPRequestHandler):
|
|
dependencies = build_api_dependencies()
|
|
|
|
def do_GET(self) -> None:
|
|
parsed = urlparse(self.path)
|
|
if _should_serve_static(parsed.path):
|
|
self._serve_static(parsed.path)
|
|
return
|
|
try:
|
|
status, payload = route_request(parsed.path, parse_qs(parsed.query, keep_blank_values=True), dependencies=self.dependencies)
|
|
except ValueError as exc:
|
|
status, payload = 400, {"error": str(exc)}
|
|
except Exception:
|
|
status, payload = 500, {"error": "internal_server_error"}
|
|
self._send_json(status, payload)
|
|
|
|
def do_POST(self) -> None:
|
|
parsed = urlparse(self.path)
|
|
try:
|
|
body = _read_json_body(self)
|
|
status, payload = route_request(
|
|
parsed.path,
|
|
parse_qs(parsed.query),
|
|
dependencies=self.dependencies,
|
|
method="POST",
|
|
body=body,
|
|
)
|
|
except ValueError as exc:
|
|
status, payload = 400, {"error": str(exc)}
|
|
except Exception:
|
|
status, payload = 500, {"error": "internal_server_error"}
|
|
self._send_json(status, payload)
|
|
|
|
def _send_json(self, status: int, payload: dict) -> None:
|
|
body = json.dumps(payload, default=str, ensure_ascii=False).encode("utf-8")
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", "application/json; charset=utf-8")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def _serve_static(self, path: str) -> None:
|
|
file_path = _resolve_static_file(path)
|
|
if file_path is None or not file_path.exists() or not file_path.is_file():
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
return
|
|
body = file_path.read_bytes()
|
|
mime_type = mimetypes.guess_type(str(file_path))[0] or "application/octet-stream"
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", f"{mime_type}; charset=utf-8" if mime_type.startswith("text/") or mime_type == "application/javascript" else mime_type)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def log_message(self, format: str, *args) -> None:
|
|
return
|
|
|
|
|
|
def serve_api(host: str = "127.0.0.1", port: int = 8000) -> None:
|
|
server = ThreadingHTTPServer((host, port), APIRequestHandler)
|
|
print(f"AI ICT API listening on http://{host}:{port}")
|
|
server.serve_forever()
|
|
|
|
|
|
def _require_int(query: dict, key: str) -> int:
|
|
value = _get_single(query, key)
|
|
if value is None:
|
|
raise ValueError(f"missing_required_query_param:{key}")
|
|
try:
|
|
return int(value)
|
|
except ValueError as exc:
|
|
raise ValueError(f"invalid_int_query_param:{key}") from exc
|
|
|
|
|
|
def _get_optional_int(query: dict, key: str) -> Optional[int]:
|
|
value = _get_single(query, key)
|
|
if value is None:
|
|
return None
|
|
try:
|
|
return int(value)
|
|
except ValueError as exc:
|
|
raise ValueError(f"invalid_int_query_param:{key}") from exc
|
|
|
|
|
|
def _get_int(query: dict, key: str, default: int) -> int:
|
|
value = _get_single(query, key)
|
|
if value is None:
|
|
return default
|
|
try:
|
|
return int(value)
|
|
except ValueError as exc:
|
|
raise ValueError(f"invalid_int_query_param:{key}") from exc
|
|
|
|
|
|
def _get_limit(query: dict, key: str, default: int, max_value: int) -> int:
|
|
value = _get_single(query, key)
|
|
if value is None:
|
|
return default
|
|
try:
|
|
parsed = int(value)
|
|
except ValueError as exc:
|
|
raise ValueError(f"invalid_limit_query_param:{key}") from exc
|
|
if parsed < 1 or parsed > max_value:
|
|
raise ValueError(f"invalid_limit_query_param:{key}")
|
|
return parsed
|
|
|
|
|
|
def _get_single(query: dict, key: str, default: Optional[str] = None) -> Optional[str]:
|
|
values = query.get(key)
|
|
if not values:
|
|
return default
|
|
return values[0]
|
|
|
|
|
|
def _path_parts(path: str) -> list[str]:
|
|
return [part for part in path.strip("/").split("/") if part]
|
|
|
|
|
|
def _parse_path_int(value: str, key: str) -> int:
|
|
try:
|
|
return int(value)
|
|
except ValueError as exc:
|
|
raise ValueError(f"invalid_path_param:{key}") from exc
|
|
|
|
|
|
def _read_json_body(handler: BaseHTTPRequestHandler) -> dict:
|
|
try:
|
|
length = int(handler.headers.get("Content-Length", "0"))
|
|
except ValueError as exc:
|
|
raise ValueError("invalid_content_length") from exc
|
|
raw_body = handler.rfile.read(length) if length else b""
|
|
if not raw_body:
|
|
return {}
|
|
try:
|
|
payload = json.loads(raw_body.decode("utf-8"))
|
|
except (json.JSONDecodeError, UnicodeDecodeError) as exc:
|
|
raise ValueError("invalid_json_body") from exc
|
|
if not isinstance(payload, dict):
|
|
raise ValueError("invalid_json_body")
|
|
return payload
|
|
|
|
|
|
def _should_serve_static(path: str) -> bool:
|
|
return path == "/" or path.startswith("/static/")
|
|
|
|
|
|
def _resolve_static_file(path: str) -> Optional[Path]:
|
|
if path == "/":
|
|
return STATIC_DIR / "index.html"
|
|
relative = path.removeprefix("/static/")
|
|
resolved = (STATIC_DIR / relative).resolve()
|
|
try:
|
|
resolved.relative_to(STATIC_DIR.resolve())
|
|
except ValueError:
|
|
return None
|
|
return resolved
|