cadlag-ce 1.0.4__tar.gz

cadlag_ce-1.0.4/LICENSE

@@ -0,0 +1,17 @@
+Business Source License 1.1
+
+Copyright (c) 2026 Cadlag
+
+Parameters
+
+Licensor:             Cadlag
+Licensed Work:        Cadlag CE v1.0
+Additional Use Grant: You may use the Licensed Work for any purpose,
+                      including production use, provided that you do not
+                      offer the Licensed Work as a hosted service to third
+                      parties.
+Change Date:          Four years from first public release
+Change License:       Apache License, Version 2.0
+
+The full text of the Business Source License 1.1 is available at:
+https://mariadb.com/bsl11/

cadlag_ce-1.0.4/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: cadlag-ce
+Version: 1.0.4
+Summary: Cadlag CE — Source-available algorithmic trading platform
+Maintainer-email: Cadlag <info@cadlag.pro>
+License: BSL-1.1
+Project-URL: Homepage, https://cadlag.pro
+Project-URL: Repository, https://github.com/cadlag-quant/cadlag
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cadlag-sdk<2.0,>=1.0.4
+Requires-Dist: fastapi>=0.109
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: asyncpg>=0.29
+Requires-Dist: alembic>=1.13
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: psycopg2-binary>=2.9
+Requires-Dist: questdb>=1.1
+Requires-Dist: pydantic>=2.5
+Requires-Dist: structlog>=24.1
+Requires-Dist: uuid-utils<1,>=0.14
+Requires-Dist: polars>=0.20
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyarrow>=14.0
+Requires-Dist: duckdb>=0.9
+Requires-Dist: watchdog>=3.0
+Requires-Dist: pydantic-settings>=2.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: packaging>=21.0
+Requires-Dist: httpx>=0.26
+Requires-Dist: pytz>=2023.3
+Provides-Extra: dev
+Requires-Dist: httpx2>=2.0.0; extra == "dev"
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0; extra == "dev"
+Dynamic: license-file
+
+# Cadlag CE
+
+Source-available algorithmic trading platform for traceable, reproducible
+quantitative research. Requires Python 3.11 or later.
+
+```bash
+python -m pip install cadlag-ce
+```
+
+Import the server as `cadlag_ce.server:app`. A running deployment also needs
+PostgreSQL, QuestDB, runtime configuration and database migrations. The public
+repository includes `cadlag-docker/` for an evaluation deployment and `docs/` for
+configuration and API documentation. Installing `cadlag-quant` includes the SDK and
+Starter examples as well.
+
+CE is licensed under BSL-1.1. The additional use grant excludes offering the
+software as a hosted service to third parties. See `LICENSE` for the terms.

cadlag_ce-1.0.4/README.md

@@ -0,0 +1,17 @@
+# Cadlag CE
+
+Source-available algorithmic trading platform for traceable, reproducible
+quantitative research. Requires Python 3.11 or later.
+
+```bash
+python -m pip install cadlag-ce
+```
+
+Import the server as `cadlag_ce.server:app`. A running deployment also needs
+PostgreSQL, QuestDB, runtime configuration and database migrations. The public
+repository includes `cadlag-docker/` for an evaluation deployment and `docs/` for
+configuration and API documentation. Installing `cadlag-quant` includes the SDK and
+Starter examples as well.
+
+CE is licensed under BSL-1.1. The additional use grant excludes offering the
+software as a hosted service to third parties. See `LICENSE` for the terms.

cadlag_ce-1.0.4/cadlag_ce/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("cadlag-ce")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+__all__ = ["__version__"]

cadlag_ce-1.0.4/cadlag_ce/api/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.

cadlag_ce-1.0.4/cadlag_ce/api/routes/__init__.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+
+from __future__ import annotations
+
+from typing import NoReturn, TypeVar
+
+from cadlag_ce.core.exceptions import ConflictError, ResourceNotFoundError
+
+_T = TypeVar("_T")
+
+ROUTE_MODULES = (
+    "audit",
+    "backtest",
+    "brokers",
+    "capabilities",
+    "config",
+    "data",
+    "datasets",
+    "deployments",
+    "experiments",
+    "feature_sets",
+    "health",
+    "live",
+    "models",
+    "pipeline",
+    "risk",
+    "strategies",
+    "validation",
+)
+
+
+def ensure_module(module: _T | None, name: str) -> _T:
+    if module is None:
+        raise ResourceNotFoundError(f"{name} is not initialized")
+    return module
+
+
+def raise_registry_error(exc: Exception, *, not_found: bool | None = None) -> NoReturn:
+    message = str(exc)
+    message_lower = message.lower()
+    if not_found is True or (not_found is None and "not found" in message_lower):
+        raise ResourceNotFoundError(message) from exc
+    raise ConflictError(message) from exc

cadlag_ce-1.0.4/cadlag_ce/api/routes/audit.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+"""Audit log API routes."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+from uuid import UUID
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel, ConfigDict
+
+from cadlag_ce.api.routes import raise_registry_error
+
+router = APIRouter(tags=["Audit"])
+
+
+class _RouteModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+
+class AuditEventResponse(_RouteModel):
+    id: Any | None = None
+    entity_type: str
+    entity_id: str
+    action: str
+    actor: str
+    old_value: dict[str, Any] | None = None
+    new_value: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = None
+    created_at: Any | None = None
+
+
+def _audit_log(request: Request) -> Any:
+    return request.app.state.registry.audit
+
+
+@router.get("", response_model=list[AuditEventResponse])
+async def query_audit_events(
+    request: Request,
+    entity_type: str | None = None,
+    entity_id: str | None = None,
+    action: str | None = None,
+    since: str | None = None,
+    limit: int = 100,
+) -> list[Any]:
+    return cast(
+        "list[Any]",
+        await _audit_log(request).query(
+            entity_type=entity_type,
+            entity_id=entity_id,
+            action=action,
+            since=since,
+            limit=limit,
+        ),
+    )
+
+
+@router.get("/{event_id}", response_model=AuditEventResponse)
+async def get_audit_event(event_id: str, request: Request) -> Any:
+    try:
+        return await _audit_log(request).get_by_id(UUID(event_id))
+    except ValueError as exc:
+        raise_registry_error(exc, not_found=True)

cadlag_ce-1.0.4/cadlag_ce/api/routes/backtest.py

@@ -0,0 +1,288 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+"""Backtest execution API routes."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+from uuid import UUID
+
+from fastapi import APIRouter, Request, Response, status
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from cadlag_ce.api.routes import raise_registry_error
+from cadlag_ce.core.domain import BacktestResult, ExecutionConfig, FillSimConfig, VersionBindings
+from cadlag_ce.core.exceptions import ConflictError, ResourceNotFoundError
+
+router = APIRouter(tags=["Backtesting"])
+
+
+class _RouteModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+
+class BacktestRequestSchema(_RouteModel):
+    model_config = ConfigDict(extra="forbid")
+
+    mode: Literal["simulation", "research", "sweep", "backtrader"] = "simulation"
+    promotion_grade: bool = False
+    use_ml: bool = True
+    use_fill_simulator: bool = True
+    use_platform_portfolio: bool = False
+    strategy_version_id: UUID | None = None
+    strategy_name: str | None = None
+    model_version_ids: list[str] = Field(default_factory=list)
+    model_version_id: UUID | None = None
+    symbol: str = "EURUSD"
+    interval: str = "D1"
+    start_date: Any | None = None
+    end_date: Any | None = None
+    dataset_version_id: UUID | None = None
+    feature_set_version_id: UUID | None = None
+    initial_cash: float | None = None
+    optimizer_class: str | None = None
+    parameter_search_space: dict[str, Any] | None = None
+    risk_profile_id: UUID | None = None
+    fill_sim_config: FillSimConfig | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _reject_internal_identity(cls, value: Any) -> Any:
+        if isinstance(value, dict) and ({"run_id", "sweep_parent_run_id"} & set(value)):
+            raise ValueError("run_id and sweep_parent_run_id are server-assigned and are not accepted")
+        return value
+
+    def to_config(self) -> ExecutionConfig:
+        return ExecutionConfig(**self.model_dump())
+
+
+class CompareSchema(_RouteModel):
+    run_ids: list[UUID]
+
+
+class BacktestResultResponse(_RouteModel):
+    run_id: UUID | None = None
+    mode: str
+    promotion_grade: bool
+    total_pnl: float
+    sharpe_ratio: float
+    max_drawdown: float
+    profit_factor: float | None = None
+    win_rate: float
+    total_trades: int
+    initial_cash: float
+    symbol: str
+    interval: str
+    start_date: Any
+    end_date: Any
+    use_platform_portfolio: bool
+    bindings: VersionBindings
+    source_providers: list[str] = Field(default_factory=list)
+    orders: list[dict[str, Any]] | None = None
+    fills: list[dict[str, Any]] | None = None
+    equity_curve: list[dict[str, Any]] | None = None
+    artifact_uri: str | None = None
+    artifact_manifest: dict[str, Any] | None = None
+    sweep_metadata: dict[str, Any] | None = None
+    created_at: Any
+    duration_seconds: float
+
+
+class SweepResultResponse(_RouteModel):
+    mode: str = "sweep"
+    parent_run_id: UUID
+    results: list[BacktestResultResponse]
+    best_result: BacktestResultResponse
+    total_combinations: int
+
+
+class SweepHistoryResponse(_RouteModel):
+    parent_run_id: UUID
+    strategy_version_id: UUID | None = None
+    symbol: str
+    interval: str
+    start_date: Any
+    end_date: Any
+    total_combinations: int
+    optimizer_target: str | None = None
+    created_at: Any
+
+
+class SweepSummaryResponse(SweepHistoryResponse):
+    best_run_id: UUID
+    best_metrics: dict[str, Any]
+
+
+class ComparisonResponse(_RouteModel):
+    run_ids: list[UUID]
+    metrics: dict[str, dict[str, float | int | None]]
+    best_run_id: UUID | None = None
+
+
+def _execution_router(request: Request) -> Any:
+    return request.app.state.execution_router
+
+
+def _backtest_repo(request: Request) -> Any:
+    return request.app.state.backtest_result_repository
+
+
+@router.post("/run", response_model=BacktestResultResponse | SweepResultResponse)
+async def run_backtest(schema: BacktestRequestSchema, request: Request) -> BacktestResultResponse | SweepResultResponse:
+    result = await _execution_router(request).run_backtest(schema.to_config())
+    if isinstance(result, list):
+        return await _sweep_response(result, request)
+    return await _result_response(result, request)
+
+
+@router.get("/results", response_model=list[BacktestResultResponse])
+async def list_results(
+    request: Request,
+    strategy_version_id: UUID | None = None,
+    limit: int = 100,
+    offset: int = 0,
+) -> list[BacktestResultResponse]:
+    results = await _backtest_repo(request).list_results(strategy_version_id, limit=limit, offset=offset)
+    return [await _result_response(result, request) for result in results]
+
+
+@router.get("/results/{run_id}", response_model=BacktestResultResponse)
+async def get_result(run_id: UUID, request: Request) -> BacktestResultResponse:
+    result = await _backtest_repo(request).get_by_run_id(run_id)
+    if result is None:
+        raise ResourceNotFoundError(f"Backtest result '{run_id}' not found")
+    return await _result_response(result, request)
+
+
+@router.delete("/results/{run_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_result(run_id: UUID, request: Request) -> Response:
+    try:
+        await _backtest_repo(request).delete_result(run_id)
+    except ValueError as exc:
+        raise_registry_error(exc)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.get("/sweeps", response_model=list[SweepHistoryResponse])
+async def list_sweeps(
+    request: Request,
+    strategy_version_id: UUID | None = None,
+    limit: int = 100,
+    offset: int = 0,
+) -> list[dict[str, Any]]:
+    return cast(
+        "list[dict[str, Any]]",
+        await _backtest_repo(request).list_sweeps(strategy_version_id, limit=limit, offset=offset),
+    )
+
+
+@router.get("/sweeps/{parent_run_id}", response_model=SweepSummaryResponse)
+async def get_sweep_summary(parent_run_id: UUID, request: Request) -> dict[str, Any]:
+    summary = await _backtest_repo(request).sweep_summary(parent_run_id)
+    if summary is None:
+        raise ResourceNotFoundError(f"Sweep parent '{parent_run_id}' not found")
+    return cast("dict[str, Any]", summary)
+
+
+@router.get("/sweeps/{parent_run_id}/results", response_model=SweepResultResponse)
+async def get_sweep_results(
+    parent_run_id: UUID,
+    request: Request,
+    include_artifacts: bool = False,
+) -> SweepResultResponse:
+    results = await _backtest_repo(request).list_sweep_results(parent_run_id, include_artifacts=include_artifacts)
+    if not results:
+        raise ResourceNotFoundError(f"Sweep parent '{parent_run_id}' not found")
+    return await _sweep_response(results, request, parent_run_id=parent_run_id)
+
+
+@router.delete("/sweeps/{parent_run_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_sweep(parent_run_id: UUID, request: Request) -> Response:
+    try:
+        await _backtest_repo(request).delete_sweep(parent_run_id)
+    except ValueError as exc:
+        raise_registry_error(exc)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.post("/compare", response_model=ComparisonResponse)
+async def compare_results(schema: CompareSchema, request: Request) -> ComparisonResponse:
+    metrics: dict[str, dict[str, float | int | None]] = {}
+    best_run_id: UUID | None = None
+    best_sharpe: float | None = None
+    for run_id in schema.run_ids:
+        result = await _backtest_repo(request).get_by_run_id(run_id)
+        if result is None:
+            raise ResourceNotFoundError(f"Backtest result '{run_id}' not found")
+        metrics[str(run_id)] = {
+            "total_pnl": result.total_pnl,
+            "sharpe_ratio": result.sharpe_ratio,
+            "max_drawdown": result.max_drawdown,
+            "profit_factor": result.profit_factor,
+            "win_rate": result.win_rate,
+            "total_trades": result.total_trades,
+        }
+        if best_sharpe is None or result.sharpe_ratio > best_sharpe:
+            best_sharpe = result.sharpe_ratio
+            best_run_id = run_id
+    return ComparisonResponse(run_ids=schema.run_ids, metrics=metrics, best_run_id=best_run_id)
+
+
+async def _result_response(result: BacktestResult, request: Request) -> BacktestResultResponse:
+    source_providers = await _source_providers(result, request)
+    payload = result.model_dump(mode="python")
+    payload["source_providers"] = source_providers
+    payload["orders"] = _dump_model_list(result.orders)
+    payload["fills"] = _dump_model_list(result.fills)
+    payload["equity_curve"] = _dump_model_list(result.equity_curve)
+    return BacktestResultResponse.model_validate(payload)
+
+
+async def _sweep_response(
+    results: list[BacktestResult],
+    request: Request,
+    parent_run_id: UUID | None = None,
+) -> SweepResultResponse:
+    if not results:
+        raise ConflictError("Sweep response requires at least one result")
+    responses = [await _result_response(result, request) for result in results]
+    resolved_parent = parent_run_id or _parent_run_id(results[0])
+    if resolved_parent is None:
+        raise ConflictError("Sweep result is missing parent_run_id metadata")
+    return SweepResultResponse(
+        parent_run_id=resolved_parent,
+        results=responses,
+        best_result=responses[0],
+        total_combinations=len(responses),
+    )
+
+
+async def _source_providers(result: BacktestResult, request: Request) -> list[str]:
+    dataset_version_id = result.bindings.dataset_version_id
+    dataset_registry = getattr(request.app.state.registry, "dataset", None)
+    if dataset_version_id is None or dataset_registry is None:
+        return []
+    try:
+        version = await dataset_registry.resolve_version(str(dataset_version_id))
+    except ValueError:
+        return []
+    return list(version.source_providers)
+
+
+def _parent_run_id(result: BacktestResult) -> UUID | None:
+    metadata = result.sweep_metadata or {}
+    value = metadata.get("parent_run_id")
+    if value is None:
+        return None
+    return value if isinstance(value, UUID) else UUID(str(value))
+
+
+def _dump_model_list(values: list[Any] | None) -> list[dict[str, Any]] | None:
+    if values is None:
+        return None
+    dumped: list[dict[str, Any]] = []
+    for value in values:
+        if hasattr(value, "model_dump"):
+            dumped.append(value.model_dump(mode="python"))
+        elif isinstance(value, dict):
+            dumped.append(value)
+    return dumped

cadlag_ce-1.0.4/cadlag_ce/api/routes/brokers.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+
+"""Broker status API routes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import structlog
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from cadlag_ce.core.broker_types import GatewayCapabilities
+    from cadlag_ce.data.gateway_registry import GatewayRegistry
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(tags=["Brokers"])
+
+
+class BrokerCapabilitiesResponse(BaseModel):
+    """Serialised form of GatewayCapabilities."""
+
+    supports_historical_bars: bool
+    supports_price_snapshot: bool
+    supports_streaming_prices: bool
+    supports_streaming_bars: bool
+    supported_source_types: list[str]
+
+
+class BrokerStatusResponse(BaseModel):
+    """Status of a single registered broker."""
+
+    broker_id: str
+    type: str
+    data_connected: bool
+    order_connected: bool
+    health: dict[str, object] | None = None
+    capabilities: BrokerCapabilitiesResponse | None = None
+
+
+def _serialize_capabilities(caps: GatewayCapabilities) -> BrokerCapabilitiesResponse:
+    return BrokerCapabilitiesResponse(
+        supports_historical_bars=caps.supports_historical_bars,
+        supports_price_snapshot=caps.supports_price_snapshot,
+        supports_streaming_prices=caps.supports_streaming_prices,
+        supports_streaming_bars=caps.supports_streaming_bars,
+        supported_source_types=sorted(caps.supported_source_types),
+    )
+
+
+@router.get("/brokers", response_model=list[BrokerStatusResponse])
+async def list_brokers(request: Request) -> list[BrokerStatusResponse]:
+    """Return the status of all registered brokers."""
+
+    registry: GatewayRegistry = request.app.state.gateway_registry
+    data_gateways = registry.list_data()
+    order_gateways = registry.list_order()
+
+    broker_ids = sorted(set(data_gateways) | set(order_gateways))
+    results: list[BrokerStatusResponse] = []
+    for broker_id in broker_ids:
+        dg = data_gateways.get(broker_id)
+        og = order_gateways.get(broker_id)
+
+        data_connected = False
+        health_dict: dict[str, object] | None = None
+        caps: BrokerCapabilitiesResponse | None = None
+        if dg is not None:
+            try:
+                health = await dg.health_check()
+                data_connected = health.connected
+                health_dict = {
+                    "connected": health.connected,
+                    "trade_allowed": health.trade_allowed,
+                    "latency_ms": health.latency_ms,
+                }
+            except Exception:
+                logger.warning("health_check_failed", broker_id=broker_id)
+            caps = _serialize_capabilities(dg.get_capabilities())
+
+        order_connected = False
+        if og is not None:
+            try:
+                order_connected = True
+            except Exception:
+                logger.warning("order_gateway_check_failed", broker_id=broker_id)
+
+        try:
+            broker_type = registry.get_provider_type(broker_id)
+        except KeyError:
+            broker_type = broker_id
+
+        results.append(
+            BrokerStatusResponse(
+                broker_id=broker_id,
+                type=broker_type,
+                data_connected=data_connected,
+                order_connected=order_connected,
+                health=health_dict,
+                capabilities=caps,
+            )
+        )
+    return results

cadlag_ce-1.0.4/cadlag_ce/api/routes/config.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2026 Cadlag. Licensed under BSL 1.1.
+"""Configuration API routes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel, ConfigDict
+
+from cadlag_ce.api.routes import ensure_module
+
+router = APIRouter(tags=["Config"])
+
+
+class _RouteModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ConfigResponse(_RouteModel):
+    config: dict[str, Any]
+
+
+class ConfigValueResponse(_RouteModel):
+    key_path: str
+    value: Any
+
+
+def _config_service(request: Request) -> Any:
+    return ensure_module(request.app.state.registry.config, "Config service")
+
+
+@router.get("", response_model=ConfigResponse)
+async def get_config(request: Request) -> ConfigResponse:
+    return ConfigResponse(config=await _config_service(request).get_config())
+
+
+@router.get("/{key_path:path}", response_model=ConfigValueResponse)
+async def get_config_value(key_path: str, request: Request) -> ConfigValueResponse:
+    return ConfigValueResponse(key_path=key_path, value=await _config_service(request).get_value(key_path))