lium-core 0.1.0__tar.gz

lium_core-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,56 @@
+name: Build and Publish to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release'
+        required: true
+        type: string
+
+jobs:
+  build:
+    name: Build Python distribution
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+
+    - name: Build package
+      run: python -m build --sdist --wheel --outdir dist/
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: dist
+        path: dist/
+
+  approve-and-publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+    - name: Download artifact
+      uses: actions/download-artifact@v4
+      with:
+        name: dist
+        path: dist/
+
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        verbose: true
+        print-hash: true

lium_core-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.idea/
+.jbeval/
+*.lock

lium_core-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: lium-core
+Version: 0.1.0
+Summary: Shared core library for Lium platform
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.31.0

lium_core-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "lium-core"
+version = "0.1.0"
+description = "Shared core library for Lium platform"
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.0.0",
+    "requests>=2.31.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lium_core"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+]

lium_core-0.1.0/src/lium_core/shared_config/__init__.py

@@ -0,0 +1,9 @@
+from lium_core.shared_config.client import SharedConfigClient
+from lium_core.shared_config.defaults import DEFAULT_SHARED_CONFIG
+from lium_core.shared_config.model import SharedConfig
+
+__all__ = [
+    "SharedConfig",
+    "SharedConfigClient",
+    "DEFAULT_SHARED_CONFIG",
+]

lium_core-0.1.0/src/lium_core/shared_config/client.py

@@ -0,0 +1,54 @@
+import logging
+import threading
+import time
+
+import requests
+
+from lium_core.shared_config.defaults import DEFAULT_SHARED_CONFIG
+from lium_core.shared_config.model import SharedConfig
+from lium_core.shared_config.utils import dict_diff
+
+logger = logging.getLogger(__name__)
+
+
+class SharedConfigClient:
+    def __init__(self, api_url: str, refresh_interval: int = 60):
+        self._api_url = api_url
+        self._refresh_interval = refresh_interval
+        self._lock = threading.Lock()
+        self._config: SharedConfig = self._fetch() or DEFAULT_SHARED_CONFIG
+        self._running = True
+        self._thread = threading.Thread(target=self._refresh_loop, daemon=True)
+        self._thread.start()
+
+    def __getattr__(self, name: str):
+        """Delegate attribute access to the underlying frozen SharedConfig."""
+        return getattr(self._config, name)
+
+    def _fetch(self) -> SharedConfig | None:
+        """Fetch config from API, return None on failure."""
+        try:
+            response = requests.get(self._api_url, timeout=10)
+            response.raise_for_status()
+            return SharedConfig.model_validate(response.json())
+        except Exception:
+            logger.warning("Failed to fetch shared config from %s", self._api_url, exc_info=True)
+            return None
+
+    def _refresh_loop(self) -> None:
+        """Background daemon thread: sleep + fetch."""
+        logger.info("Started shared config refresh loop")
+        while self._running:
+            time.sleep(self._refresh_interval)
+            new_config = self._fetch()
+            with self._lock:
+                if new_config and self._config != new_config:
+                    for change in dict_diff(self._config.model_dump(), new_config.model_dump()):
+                        logger.info("Config changed %s", change)
+                    self._config = new_config
+                else:
+                    logger.debug("Shared config unchanged")
+
+    def stop(self) -> None:
+        """Stop background refresh."""
+        self._running = False

lium_core-0.1.0/src/lium_core/shared_config/defaults.py

@@ -0,0 +1,124 @@
+from lium_core.shared_config.model import SharedConfig
+
+DEFAULT_SHARED_CONFIG = SharedConfig(
+    machine_prices={
+        "NVIDIA B300 SXM6 AC": 3.67,
+        "NVIDIA B200": 2.99,
+        "NVIDIA H200": 1.90,
+        "NVIDIA H200 NVL": 1.67,
+        "NVIDIA H100 80GB HBM3": 1.26,
+        "NVIDIA H100 NVL": 1.11,
+        "NVIDIA H100 PCIe": 1.11,
+        "NVIDIA H800 80GB HBM3": 0.88,
+        "NVIDIA H800 NVL": 0.80,
+        "NVIDIA H800 PCIe": 0.80,
+        "NVIDIA GeForce RTX 5090": 0.17,
+        "NVIDIA GeForce RTX 4090": 0.14,
+        "NVIDIA GeForce RTX 4090 D": 0.11,
+        "NVIDIA RTX 4000 Ada Generation": 0.16,
+        "NVIDIA RTX 6000 Ada Generation": 0.31,
+        "NVIDIA RTX PRO 6000 Blackwell Server Edition": 0.77,
+        "NVIDIA RTX PRO 6000 Blackwell Workstation Edition": 0.84,
+        "NVIDIA L4": 0.11,
+        "NVIDIA L40S": 0.34,
+        "NVIDIA L40": 0.29,
+        "NVIDIA RTX 2000 Ada Generation": 0.07,
+        "NVIDIA A100 80GB PCIe": 0.36,
+        "NVIDIA A100-SXM4-80GB": 0.43,
+        "NVIDIA RTX A6000": 0.24,
+        "NVIDIA RTX A5000": 0.16,
+        "NVIDIA RTX A4500": 0.13,
+        "NVIDIA RTX A4000": 0.12,
+        "NVIDIA A40": 0.12,
+        "NVIDIA A30": 0.10,
+        "NVIDIA GeForce RTX 3090": 0.13,
+    },
+    required_deposit_amount={
+        "NVIDIA B300 SXM6 AC": 0.274,
+        "NVIDIA B200": 0.223,
+        "NVIDIA H200": 0.158,
+        "NVIDIA H200 NVL": 0.131,
+        "NVIDIA H100 80GB HBM3": 0.103,
+        "NVIDIA H100 NVL": 0.086,
+        "NVIDIA H100 PCIe": 0.086,
+        "NVIDIA H800 80GB HBM3": 0.051,
+        "NVIDIA H800 NVL": 0.045,
+        "NVIDIA H800 PCIe": 0.045,
+        "NVIDIA GeForce RTX 5090": 0.014,
+        "NVIDIA GeForce RTX 4090": 0.010,
+        "NVIDIA GeForce RTX 4090 D": 0.008,
+        "NVIDIA RTX PRO 6000 Blackwell Server Edition": 0.0425,
+        "NVIDIA RTX PRO 6000 Blackwell Workstation Edition": 0.0459,
+        "NVIDIA RTX 6000 Ada Generation": 0.017,
+        "NVIDIA L4": 0.008,
+        "NVIDIA L40S": 0.027,
+        "NVIDIA L40": 0.024,
+        "NVIDIA A100 80GB PCIe": 0.027,
+        "NVIDIA A100-SXM4-80GB": 0.031,
+        "NVIDIA RTX A6000": 0.018,
+        "NVIDIA RTX A5000": 0.009,
+        "NVIDIA RTX A4500": 0.008,
+        "NVIDIA RTX A4000": 0.008,
+        "NVIDIA GeForce RTX 3090": 0.008,
+    },
+    gpu_architectures={
+        # Blackwell (sm_100/120)
+        "NVIDIA B200": {"arch": "blackwell", "min_cuda": 12.8, "compute_cap": "sm_100"},
+        "NVIDIA GeForce RTX 5090": {"arch": "blackwell", "min_cuda": 12.8, "compute_cap": "sm_120"},
+        # Hopper (sm_90)
+        "NVIDIA H100 80GB HBM3": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H100 NVL": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H100 PCIe": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H200": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H800 80GB HBM3": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H800 NVL": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        "NVIDIA H800 PCIe": {"arch": "hopper", "min_cuda": 11.8, "optimal_cuda": 12.2, "compute_cap": "sm_90"},
+        # Ada Lovelace (sm_89)
+        "NVIDIA GeForce RTX 4090": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA GeForce RTX 4090 D": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA L4": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA L40": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA L40S": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA RTX 2000 Ada Generation": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA RTX 4000 Ada Generation": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        "NVIDIA RTX 6000 Ada Generation": {"arch": "ada", "min_cuda": 11.8, "compute_cap": "sm_89"},
+        # Ampere (sm_86)
+        "NVIDIA A100 80GB PCIe": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA A100-SXM4-80GB": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA A30": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA A40": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA RTX A4000": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA RTX A4500": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA RTX A5000": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA RTX A6000": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+        "NVIDIA GeForce RTX 3090": {"arch": "ampere", "min_cuda": 11.0, "compute_cap": "sm_86"},
+    },
+    driver_cuda_map={
+        450: 11.0,
+        470: 11.4,
+        495: 11.5,
+        510: 11.6,
+        515: 11.7,
+        525: 12.0,
+        530: 12.1,
+        535: 12.2,
+        545: 12.3,
+        550: 12.4,
+        555: 12.5,
+        560: 12.6,
+        565: 12.7,
+        570: 12.8,
+        575: 12.8,
+        580: 13.0,
+        590: 13.1,
+    },
+    machine_max_price_rate=3.0,
+    machine_min_price_rate=0.5,
+    rental_fees_rate=0.9,
+    collateral_days=7,
+    collateral_contract_address="0x7DCCb5659c70Ce2104A9bb79E9E257473ECbe628",
+    bittensor_netuid=51,
+    volume_gb_hour_price_usd=0.00005,
+    max_initial_port_count=200,
+    total_burn_emission=0.91,
+)

lium_core-0.1.0/src/lium_core/shared_config/model.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class SharedConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    # Dicts
+    machine_prices: dict[str, float]
+    required_deposit_amount: dict[str, float]
+    gpu_architectures: dict[str, dict]
+    driver_cuda_map: dict[int, float]
+
+    # Scalars
+    machine_max_price_rate: float
+    machine_min_price_rate: float
+    rental_fees_rate: float
+    collateral_days: int
+    collateral_contract_address: str
+    bittensor_netuid: int
+    volume_gb_hour_price_usd: float
+    max_initial_port_count: int
+    total_burn_emission: float

lium_core-0.1.0/src/lium_core/shared_config/utils.py

@@ -0,0 +1,13 @@
+def dict_diff(old: dict, new: dict, prefix: str = "") -> list[str]:
+    """Return list of human-readable strings describing differences."""
+    changes: list[str] = []
+    all_keys = old.keys() | new.keys()
+    for key in sorted(all_keys):
+        path = f"{prefix}.{key}" if prefix else key
+        old_val = old.get(key)
+        new_val = new.get(key)
+        if isinstance(old_val, dict) and isinstance(new_val, dict):
+            changes.extend(dict_diff(old_val, new_val, path))
+        elif old_val != new_val:
+            changes.append(f"[{path}]: {old_val} -> {new_val}")
+    return changes

lium_core-0.1.0/tests/test_shared_config.py

@@ -0,0 +1,248 @@
+import logging
+from unittest.mock import MagicMock, patch
+
+import pydantic
+import pytest
+import requests
+
+from lium_core.shared_config.client import SharedConfigClient
+from lium_core.shared_config.defaults import DEFAULT_SHARED_CONFIG
+from lium_core.shared_config.model import SharedConfig
+from lium_core.shared_config.utils import dict_diff
+
+API_URL = "http://fake-api/config"
+
+SAMPLE_CONFIG_DATA = DEFAULT_SHARED_CONFIG.model_dump()
+
+ALTERED_CONFIG_DATA = {
+    **SAMPLE_CONFIG_DATA,
+    "rental_fees_rate": 0.75,
+    "collateral_days": 14,
+}
+
+
+def _make_response(json_data: dict, status_code: int = 200) -> MagicMock:
+    resp = MagicMock(spec=requests.Response)
+    resp.status_code = status_code
+    resp.json.return_value = json_data
+    resp.raise_for_status.return_value = None
+    if status_code >= 400:
+        resp.raise_for_status.side_effect = requests.HTTPError(response=resp)
+    return resp
+
+
+def _build_client(mock_get: MagicMock) -> SharedConfigClient:
+    """Create client with patched threading so no background loop runs."""
+    with patch("lium_core.shared_config.client.threading"):
+        client = SharedConfigClient(api_url=API_URL, refresh_interval=60)
+    return client
+
+
+# ==================== Model tests ====================
+
+
+def test_shared_config_is_frozen() -> None:
+    with pytest.raises(pydantic.ValidationError):
+        DEFAULT_SHARED_CONFIG.rental_fees_rate = 0.5
+
+
+def test_default_shared_config_has_all_fields() -> None:
+    assert len(DEFAULT_SHARED_CONFIG.machine_prices) > 0
+    assert len(DEFAULT_SHARED_CONFIG.required_deposit_amount) > 0
+    assert len(DEFAULT_SHARED_CONFIG.gpu_architectures) > 0
+    assert len(DEFAULT_SHARED_CONFIG.driver_cuda_map) > 0
+    assert DEFAULT_SHARED_CONFIG.machine_max_price_rate == 3.0
+    assert DEFAULT_SHARED_CONFIG.machine_min_price_rate == 0.5
+    assert DEFAULT_SHARED_CONFIG.rental_fees_rate == 0.9
+    assert DEFAULT_SHARED_CONFIG.collateral_days == 7
+    assert DEFAULT_SHARED_CONFIG.collateral_contract_address == "0x7DCCb5659c70Ce2104A9bb79E9E257473ECbe628"
+    assert DEFAULT_SHARED_CONFIG.bittensor_netuid == 51
+    assert DEFAULT_SHARED_CONFIG.volume_gb_hour_price_usd == 0.00005
+    assert DEFAULT_SHARED_CONFIG.max_initial_port_count == 200
+    assert DEFAULT_SHARED_CONFIG.total_burn_emission == 0.91
+
+
+def test_shared_config_serializes_to_json() -> None:
+    data = DEFAULT_SHARED_CONFIG.model_dump()
+    assert isinstance(data, dict)
+    assert "machine_prices" in data
+    assert "gpu_architectures" in data
+    assert isinstance(data["gpu_architectures"]["NVIDIA B200"]["arch"], str)
+
+
+# ==================== Utils tests (dict_diff) ====================
+
+
+@pytest.mark.parametrize(
+    "old, new, expected",
+    [
+        pytest.param({}, {}, [], id="both_empty"),
+        pytest.param({"a": 1}, {"a": 1}, [], id="no_changes"),
+        pytest.param(
+            {"a": 1},
+            {"a": 2},
+            ["[a]: 1 -> 2"],
+            id="top_level_change",
+        ),
+        pytest.param(
+            {"a": {"b": 1}},
+            {"a": {"b": 2}},
+            ["[a.b]: 1 -> 2"],
+            id="nested_change",
+        ),
+        pytest.param(
+            {"a": {"b": {"c": 1}}},
+            {"a": {"b": {"c": 99}}},
+            ["[a.b.c]: 1 -> 99"],
+            id="deep_nested_change",
+        ),
+        pytest.param(
+            {},
+            {"a": 1},
+            ["[a]: None -> 1"],
+            id="key_added",
+        ),
+        pytest.param(
+            {"a": 1},
+            {},
+            ["[a]: 1 -> None"],
+            id="key_removed",
+        ),
+        pytest.param(
+            {"a": 1, "b": 2, "c": 3},
+            {"a": 10, "b": 20, "c": 30},
+            ["[a]: 1 -> 10", "[b]: 2 -> 20", "[c]: 3 -> 30"],
+            id="multiple_changes_sorted",
+        ),
+        pytest.param(
+            {"a": {"nested": 1}},
+            {"a": "flat"},
+            ["[a]: {'nested': 1} -> flat"],
+            id="dict_becomes_scalar",
+        ),
+    ],
+)
+def test_dict_diff(old: dict, new: dict, expected: list[str]) -> None:
+    assert dict_diff(old, new) == expected
+
+
+# ==================== Client tests: _fetch ====================
+
+
+def test_fetch_success() -> None:
+    with patch("lium_core.shared_config.client.requests.get", return_value=_make_response(SAMPLE_CONFIG_DATA)):
+        client = _build_client(MagicMock())
+
+    assert isinstance(client._config, SharedConfig)
+    assert client._config == DEFAULT_SHARED_CONFIG
+
+
+def test_fetch_http_error() -> None:
+    with patch("lium_core.shared_config.client.requests.get", return_value=_make_response({}, status_code=500)):
+        client = _build_client(MagicMock())
+
+    assert client._config == DEFAULT_SHARED_CONFIG
+
+
+def test_fetch_network_error() -> None:
+    with patch("lium_core.shared_config.client.requests.get", side_effect=requests.ConnectionError("no network")):
+        client = _build_client(MagicMock())
+
+    assert client._config == DEFAULT_SHARED_CONFIG
+
+
+# ==================== Client tests: __init__ ====================
+
+
+def test_init_with_successful_fetch() -> None:
+    with patch("lium_core.shared_config.client.requests.get", return_value=_make_response(ALTERED_CONFIG_DATA)):
+        client = _build_client(MagicMock())
+
+    assert client._config.rental_fees_rate == 0.75
+    assert client._config.collateral_days == 14
+
+
+def test_init_fallback_to_default() -> None:
+    with patch("lium_core.shared_config.client.requests.get", side_effect=Exception("boom")):
+        client = _build_client(MagicMock())
+
+    assert client._config is DEFAULT_SHARED_CONFIG
+
+
+# ==================== Client tests: _refresh_loop ====================
+
+
+def test_refresh_updates_config_on_change() -> None:
+    mock_get = MagicMock(return_value=_make_response(SAMPLE_CONFIG_DATA))
+    with patch("lium_core.shared_config.client.requests.get", mock_get):
+        client = _build_client(mock_get)
+
+    assert client._config == DEFAULT_SHARED_CONFIG
+
+    mock_get.return_value = _make_response(ALTERED_CONFIG_DATA)
+
+    def _stop_after_one_iteration(_interval: int) -> None:
+        client._running = False
+
+    with (
+        patch("lium_core.shared_config.client.requests.get", mock_get),
+        patch("lium_core.shared_config.client.time.sleep", side_effect=_stop_after_one_iteration),
+    ):
+        client._running = True
+        client._refresh_loop()
+
+    assert client._config.rental_fees_rate == 0.75
+    assert client._config.collateral_days == 14
+
+
+def test_refresh_skips_on_same_config(caplog: pytest.LogCaptureFixture) -> None:
+    mock_get = MagicMock(return_value=_make_response(SAMPLE_CONFIG_DATA))
+    with patch("lium_core.shared_config.client.requests.get", mock_get):
+        client = _build_client(mock_get)
+
+    def _stop_after_one_iteration(_interval: int) -> None:
+        client._running = False
+
+    with (
+        patch("lium_core.shared_config.client.requests.get", mock_get),
+        patch("lium_core.shared_config.client.time.sleep", side_effect=_stop_after_one_iteration),
+        caplog.at_level(logging.DEBUG, logger="lium_core.shared_config.client"),
+    ):
+        client._running = True
+        client._refresh_loop()
+
+    assert "unchanged" in caplog.text
+
+
+def test_refresh_skips_on_fetch_failure() -> None:
+    mock_get = MagicMock(return_value=_make_response(SAMPLE_CONFIG_DATA))
+    with patch("lium_core.shared_config.client.requests.get", mock_get):
+        client = _build_client(mock_get)
+
+    original_config = client._config
+    mock_get.side_effect = requests.ConnectionError("down")
+
+    def _stop_after_one_iteration(_interval: int) -> None:
+        client._running = False
+
+    with (
+        patch("lium_core.shared_config.client.requests.get", mock_get),
+        patch("lium_core.shared_config.client.time.sleep", side_effect=_stop_after_one_iteration),
+    ):
+        client._running = True
+        client._refresh_loop()
+
+    assert client._config is original_config
+
+
+# ==================== Client tests: __getattr__ ====================
+
+
+def test_getattr_delegates_to_config() -> None:
+    mock_get = MagicMock(return_value=_make_response(SAMPLE_CONFIG_DATA))
+    with patch("lium_core.shared_config.client.requests.get", mock_get):
+        client = _build_client(mock_get)
+
+    assert client.bittensor_netuid == DEFAULT_SHARED_CONFIG.bittensor_netuid
+    assert client.rental_fees_rate == DEFAULT_SHARED_CONFIG.rental_fees_rate
+    assert client.machine_prices == DEFAULT_SHARED_CONFIG.machine_prices