cadlag-sdk 1.0.4__tar.gz

cadlag_sdk-1.0.4/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright (c) 2026 Cadlag
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

cadlag_sdk-1.0.4/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: cadlag-sdk
+Version: 1.0.4
+Summary: Cadlag SDK — Base classes, utilities, platform client, CLI, and testing fixtures
+Maintainer-email: Cadlag <info@cadlag.pro>
+License: Apache-2.0
+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: pydantic>=2.5
+Requires-Dist: polars>=0.20
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyarrow>=14.0
+Requires-Dist: httpx>=0.26
+Requires-Dist: websockets>=12.0
+Requires-Dist: structlog>=24.1
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.11
+Requires-Dist: joblib>=1.3
+Requires-Dist: TA-Lib>=0.4
+Provides-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: ruff>=0.3; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Dynamic: license-file
+
+# Cadlag SDK
+
+Base classes, utilities, platform client, CLI and testing fixtures for Cadlag.
+Requires Python 3.11 or later. Licensed under Apache-2.0.
+
+```bash
+python -m pip install cadlag-sdk
+cadlag --help
+```
+
+```python
+from cadlag_sdk import CadlagClient, AsyncCadlagClient
+
+with CadlagClient(base_url="http://localhost:8000") as client:
+    print(client.health())
+```
+
+The SDK connects to a running Cadlag CE server. Install `cadlag-quant` to include the
+server package and Starter examples. Import the SDK as `cadlag_sdk`.

cadlag_sdk-1.0.4/README.md

@@ -0,0 +1,19 @@
+# Cadlag SDK
+
+Base classes, utilities, platform client, CLI and testing fixtures for Cadlag.
+Requires Python 3.11 or later. Licensed under Apache-2.0.
+
+```bash
+python -m pip install cadlag-sdk
+cadlag --help
+```
+
+```python
+from cadlag_sdk import CadlagClient, AsyncCadlagClient
+
+with CadlagClient(base_url="http://localhost:8000") as client:
+    print(client.health())
+```
+
+The SDK connects to a running Cadlag CE server. Install `cadlag-quant` to include the
+server package and Starter examples. Import the SDK as `cadlag_sdk`.

cadlag_sdk-1.0.4/cadlag_sdk/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Cadlag. Licensed under Apache 2.0.
+"""Cadlag SDK — public surface re-exports."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from cadlag_sdk.client.client import AsyncCadlagClient, CadlagClient
+from cadlag_sdk.losses.base import BaseLoss
+from cadlag_sdk.models.base import BaseModel
+from cadlag_sdk.strategies.base import BaseStrategy
+from cadlag_sdk.trainers.base import BaseTrainer
+
+try:
+    __version__ = version("cadlag-sdk")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+__all__ = [
+    "AsyncCadlagClient",
+    "BaseLoss",
+    "BaseModel",
+    "BaseStrategy",
+    "BaseTrainer",
+    "CadlagClient",
+    "__version__",
+]

cadlag_sdk-1.0.4/cadlag_sdk/cli.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2026 Cadlag. Licensed under Apache 2.0.
+"""Cadlag SDK command-line interface.
+
+Entry point: ``cadlag`` (declared in ``pyproject.toml`` ``[project.scripts]``).
+
+The SDK owns the executable but discovers commands supplied by installed
+Cadlag packages through the ``cadlag.cli`` entry-point group.  This keeps
+the SDK dependency-free with respect to Cadlag CE and optional extensions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from collections.abc import Callable, Sequence
+from importlib import metadata
+from typing import Protocol, cast
+
+CommandHandler = Callable[[argparse.Namespace], int]
+
+
+class CommandRegistrar(Protocol):
+    """Register package-owned commands on the root Cadlag CLI."""
+
+    def __call__(
+        self,
+        subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+    ) -> None: ...
+
+
+def _cmd_test(args: argparse.Namespace) -> int:
+    """Run SDK tests using pytest.
+
+    Args:
+        args: Parsed CLI arguments (``args.markers``, ``args.verbose``).
+
+    Returns:
+        pytest exit code.
+    """
+    cmd = [sys.executable, "-m", "pytest"]
+    if args.verbose:
+        cmd.append("-v")
+    if args.markers:
+        cmd.extend(["-m", args.markers])
+    # Run from the cadlag_sdk package directory so conftest is discovered.
+    import pathlib
+
+    import cadlag_sdk as _sdk
+
+    sdk_root = str(pathlib.Path(_sdk.__file__).parent.parent)
+    cmd.append(sdk_root)
+    result = subprocess.run(cmd, check=False)
+    return result.returncode
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the root parser and load commands from installed packages."""
+    parser = argparse.ArgumentParser(
+        prog="cadlag",
+        description="Cadlag SDK command-line interface.",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    test_parser = sub.add_parser("test", help="Run SDK contract tests via pytest.")
+    test_parser.add_argument("-v", "--verbose", action="store_true", help="Verbose pytest output.")
+    test_parser.add_argument("-m", "--markers", default="", help="pytest marker expression.")
+    test_parser.set_defaults(_cadlag_handler=_cmd_test)
+
+    entry_points = sorted(metadata.entry_points(group="cadlag.cli"), key=lambda entry_point: entry_point.name)
+    for entry_point in entry_points:
+        try:
+            registrar = cast("CommandRegistrar", entry_point.load())
+            registrar(sub)
+        except Exception as exc:
+            raise RuntimeError(
+                f"Unable to register Cadlag CLI provider {entry_point.name!r} ({entry_point.value}): {exc}"
+            ) from exc
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Entry point for the ``cadlag`` CLI."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    handler = cast("CommandHandler | None", getattr(args, "_cadlag_handler", None))
+    if handler is None:
+        parser.print_help()
+        raise SystemExit(0)
+    raise SystemExit(handler(args))
+
+
+if __name__ == "__main__":
+    main()

cadlag_sdk-1.0.4/cadlag_sdk/client/__init__.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2026 Cadlag. Licensed under Apache 2.0.
+from cadlag_sdk.client.client import AsyncCadlagClient, CadlagClient
+from cadlag_sdk.client.config import ClientConfig
+from cadlag_sdk.client.exceptions import (
+    BacktestFailedError,
+    ChainLimitExceededError,
+    ConnectionError,
+    NotFoundError,
+    PipelineFailedError,
+    ProFeatureRequiredError,
+    CadlagError,
+    TimeoutError,
+    ValidationError,
+)
+
+__all__ = [
+    "AsyncCadlagClient",
+    "BacktestFailedError",
+    "ChainLimitExceededError",
+    "ClientConfig",
+    "ConnectionError",
+    "NotFoundError",
+    "PipelineFailedError",
+    "ProFeatureRequiredError",
+    "CadlagClient",
+    "CadlagError",
+    "TimeoutError",
+    "ValidationError",
+]

cadlag_sdk-1.0.4/cadlag_sdk/client/_transport.py

@@ -0,0 +1,213 @@
+# Copyright (c) 2026 Cadlag. Licensed under Apache 2.0.
+"""HTTP transport layers with shared retry and error mapping.
+
+Provides sync and async transports that share timeout construction and
+platform HTTP status-code → SDK exception mapping semantics.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import TYPE_CHECKING, Any
+
+import httpx
+import structlog
+
+if TYPE_CHECKING:
+    from cadlag_sdk.client.config import ClientConfig
+
+from cadlag_sdk.client.exceptions import (
+    ChainLimitExceededError,
+    ConnectionError,
+    NotFoundError,
+    ProFeatureRequiredError,
+    CadlagError,
+    TimeoutError,
+    ValidationError,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+def _build_timeout(config: ClientConfig) -> httpx.Timeout:
+    return httpx.Timeout(
+        connect=config.connect_timeout,
+        read=config.read_timeout,
+        write=config.write_timeout,
+        pool=config.connect_timeout,
+    )
+
+
+class _BaseTransport:
+    """Shared transport behavior for sync and async SDK clients.
+
+    Args:
+        config: :class:`~cadlag_sdk.client.config.ClientConfig` instance.
+    """
+
+    def __init__(self, config: ClientConfig) -> None:
+        self._config = config
+
+    def _map_error(self, response: httpx.Response) -> httpx.Response:
+        """Raise a typed exception for error status codes."""
+        if response.is_success:
+            return response
+
+        body: Any = None
+        try:
+            body = response.json()
+        except Exception:
+            body = response.text
+
+        status = response.status_code
+        if status == 402:
+            capability = body.get("capability", "unknown") if isinstance(body, dict) else "unknown"
+            docs_url_value = body.get("docs_url", body.get("docs", "")) if isinstance(body, dict) else ""
+            docs_url = docs_url_value if isinstance(docs_url_value, str) else ""
+            message = body.get("error", "Pro feature required") if isinstance(body, dict) else str(body)
+            raise ProFeatureRequiredError(
+                message,
+                status_code=status,
+                response=body,
+                capability=capability,
+                docs_url=docs_url,
+            )
+        if status == 404:
+            raise NotFoundError("Resource not found", status_code=status, response=body)
+        if status == 422:
+            if (
+                isinstance(body, dict)
+                and body.get("error") == "chain limit exceeded"
+                and isinstance(body.get("max_chains"), int)
+                and isinstance(body.get("requested"), int)
+            ):
+                raise ChainLimitExceededError(
+                    body.get("detail", "Chain limit exceeded"),
+                    status_code=status,
+                    response=body,
+                    max_chains=body["max_chains"],
+                    requested=body["requested"],
+                )
+            raise ValidationError("Validation error", status_code=status, response=body)
+
+        raise CadlagError(f"Unexpected HTTP {status}", status_code=status, response=body)
+
+
+class SyncTransport(_BaseTransport):
+    """Sync HTTP transport with retry + status-code → exception mapping."""
+
+    def __init__(self, config: ClientConfig) -> None:
+        super().__init__(config)
+        self._client: httpx.Client | None = None
+
+    def _get_client(self) -> httpx.Client:
+        if self._client is None or getattr(self._client, "is_closed", False):
+            self._client = httpx.Client(
+                base_url=self._config.base_url,
+                timeout=_build_timeout(self._config),
+            )
+        return self._client
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """Send a synchronous HTTP request with retry and backoff."""
+        client = self._get_client()
+        last_exc: Exception | None = None
+
+        for attempt in range(self._config.max_retries + 1):
+            if attempt > 0:
+                delay = self._config.backoff_factor * (2 ** (attempt - 1))
+                time.sleep(delay)
+
+            try:
+                response = client.request(method, path, **kwargs)
+                return self._map_error(response)
+            except httpx.TimeoutException as exc:
+                last_exc = exc
+                logger.warning("request_timeout", attempt=attempt, path=path)
+            except httpx.NetworkError as exc:
+                last_exc = exc
+                logger.warning("request_network_error", attempt=attempt, path=path)
+
+        if isinstance(last_exc, httpx.TimeoutException):
+            raise TimeoutError(str(last_exc)) from last_exc
+        raise ConnectionError(str(last_exc)) from last_exc
+
+    def close(self) -> None:
+        """Close the underlying synchronous client."""
+        if self._client and not getattr(self._client, "is_closed", False):
+            self._client.close()
+
+
+class AsyncTransport(_BaseTransport):
+    """Async HTTP transport with retry + status-code → exception mapping."""
+
+    def __init__(self, config: ClientConfig) -> None:
+        super().__init__(config)
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self._config.base_url,
+                timeout=_build_timeout(self._config),
+            )
+        return self._client
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """Send an HTTP request with retry and backoff.
+
+        Args:
+            method: HTTP verb (``"GET"``, ``"POST"``, etc.).
+            path: URL path relative to ``base_url``.
+            **kwargs: Forwarded to :meth:`httpx.AsyncClient.request`.
+
+        Returns:
+            The :class:`httpx.Response` on success.
+
+        Raises:
+            ConnectionError: Network-level failure.
+            TimeoutError: Request exceeded configured timeout.
+            Various :class:`CadlagError` subclasses on HTTP error statuses.
+        """
+        client = await self._get_client()
+        last_exc: Exception | None = None
+
+        for attempt in range(self._config.max_retries + 1):
+            if attempt > 0:
+                delay = self._config.backoff_factor * (2 ** (attempt - 1))
+                await asyncio.sleep(delay)
+
+            try:
+                response = await client.request(method, path, **kwargs)
+                return self._map_error(response)
+            except httpx.TimeoutException as exc:
+                last_exc = exc
+                logger.warning("request_timeout", attempt=attempt, path=path)
+            except httpx.NetworkError as exc:
+                last_exc = exc
+                logger.warning("request_network_error", attempt=attempt, path=path)
+
+        # All retries exhausted
+        if isinstance(last_exc, httpx.TimeoutException):
+            raise TimeoutError(str(last_exc)) from last_exc
+        raise ConnectionError(str(last_exc)) from last_exc
+
+    async def aclose(self) -> None:
+        """Close the underlying ``httpx.AsyncClient``."""
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+
+# Backward-compatible alias for the original async transport symbol.
+Transport = AsyncTransport