waldur-site-agent-cscs-dwdi 0.1.0__py3-none-any.whl

waldur_site_agent_cscs_dwdi/__init__.py

@@ -0,0 +1 @@
+"""CSCS-DWDI reporting plugin for Waldur Site Agent."""

waldur_site_agent_cscs_dwdi/backend.py

@@ -0,0 +1,362 @@
+"""CSCS-DWDI backend implementation for usage reporting."""
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from waldur_api_client.models.resource import Resource as WaldurResource
+
+from waldur_site_agent.backend.backends import BaseBackend
+
+from .client import CSCSDWDIClient
+
+logger = logging.getLogger(__name__)
+
+
+class CSCSDWDIBackend(BaseBackend):
+    """Backend for reporting usage from CSCS-DWDI API."""
+
+    def __init__(
+        self, backend_settings: dict[str, Any], backend_components: dict[str, dict]
+    ) -> None:
+        """Initialize CSCS-DWDI backend.
+
+        Args:
+            backend_settings: Backend-specific settings from the offering
+            backend_components: Component configuration from the offering
+        """
+        super().__init__(backend_settings, backend_components)
+        self.backend_type = "cscs-dwdi"
+
+        # Extract CSCS-DWDI specific configuration
+        self.api_url = backend_settings.get("cscs_dwdi_api_url", "")
+        self.client_id = backend_settings.get("cscs_dwdi_client_id", "")
+        self.client_secret = backend_settings.get("cscs_dwdi_client_secret", "")
+
+        # Required OIDC configuration
+        self.oidc_token_url = backend_settings.get("cscs_dwdi_oidc_token_url", "")
+        self.oidc_scope = backend_settings.get("cscs_dwdi_oidc_scope")
+
+        if not all([self.api_url, self.client_id, self.client_secret, self.oidc_token_url]):
+            msg = (
+                "CSCS-DWDI backend requires cscs_dwdi_api_url, cscs_dwdi_client_id, "
+                "cscs_dwdi_client_secret, and cscs_dwdi_oidc_token_url in backend_settings"
+            )
+            raise ValueError(msg)
+
+        self.cscs_client = CSCSDWDIClient(
+            api_url=self.api_url,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            oidc_token_url=self.oidc_token_url,
+            oidc_scope=self.oidc_scope,
+        )
+
+    def ping(self, raise_exception: bool = False) -> bool:  # noqa: ARG002
+        """Check if CSCS-DWDI API is accessible.
+
+        Args:
+            raise_exception: Whether to raise an exception on failure
+
+        Returns:
+            True if API is accessible, False otherwise
+        """
+        return self.cscs_client.ping()
+
+    def _get_usage_report(
+        self, resource_backend_ids: list[str]
+    ) -> dict[str, dict[str, dict[str, float]]]:
+        """Get usage report for specified resources.
+
+        This method queries the CSCS-DWDI API for the current month's usage
+        and formats it according to Waldur's expected structure.
+
+        Args:
+            resource_backend_ids: List of account identifiers to report on
+
+        Returns:
+            Dictionary mapping account names to usage data:
+            {
+                "account1": {
+                    "TOTAL_ACCOUNT_USAGE": {
+                        "nodeHours": 1234.56
+                    },
+                    "user1": {
+                        "nodeHours": 500.00
+                    },
+                    "user2": {
+                        "nodeHours": 734.56
+                    }
+                },
+                ...
+            }
+        """
+        if not resource_backend_ids:
+            logger.warning("No resource backend IDs provided for usage report")
+            return {}
+
+        # Get current month's date range
+        today = datetime.now(tz=timezone.utc).date()
+        from_date = today.replace(day=1)
+        to_date = today
+
+        logger.info(
+            "Fetching usage report for %d accounts from %s to %s",
+            len(resource_backend_ids),
+            from_date,
+            to_date,
+        )
+
+        try:
+            # Query CSCS-DWDI API for usage data
+            response = self.cscs_client.get_usage_for_month(
+                accounts=resource_backend_ids,
+                from_date=from_date,
+                to_date=to_date,
+            )
+
+            # Process the response
+            usage_report = self._process_api_response(response)
+
+            # Filter to only include requested accounts
+            filtered_report = {
+                account: data
+                for account, data in usage_report.items()
+                if account in resource_backend_ids
+            }
+
+            logger.info(
+                "Successfully retrieved usage for %d accounts",
+                len(filtered_report),
+            )
+
+            return filtered_report
+
+        except Exception:
+            logger.exception("Failed to get usage report from CSCS-DWDI")
+            raise
+
+    def _process_api_response(
+        self, response: dict[str, Any]
+    ) -> dict[str, dict[str, dict[str, float]]]:
+        """Process CSCS-DWDI API response into Waldur format.
+
+        Args:
+            response: Raw API response from CSCS-DWDI
+
+        Returns:
+            Formatted usage report for Waldur with configured component mappings
+        """
+        usage_report = {}
+
+        # The response has a "compute" field with list of account data
+        compute_data = response.get("compute", [])
+
+        for account_data in compute_data:
+            account_name = account_data.get("account")
+            if not account_name:
+                logger.warning("Account data missing account name, skipping")
+                continue
+
+            # Extract total account usage for all configured components
+            total_usage = self._extract_component_usage_from_account_data(account_data)
+
+            # Initialize account entry
+            usage_report[account_name] = {"TOTAL_ACCOUNT_USAGE": total_usage}
+
+            # Process per-user usage
+            users = account_data.get("users", [])
+            user_usage: dict[str, dict[str, float]] = {}
+
+            for user_data in users:
+                username = user_data.get("username")
+                if not username:
+                    continue
+
+                # Extract user component usage
+                user_component_usage = self._extract_component_usage_from_user_data(user_data)
+
+                if username in user_usage:
+                    # Aggregate usage for same user across different dates/clusters
+                    for component_name, value in user_component_usage.items():
+                        user_usage[username][component_name] = (
+                            user_usage[username].get(component_name, 0.0) + value
+                        )
+                else:
+                    user_usage[username] = user_component_usage
+
+            # Add rounded user usage to report
+            for username, component_usage in user_usage.items():
+                rounded_usage = {comp: round(value, 2) for comp, value in component_usage.items()}
+                usage_report[account_name][username] = rounded_usage
+
+        return usage_report
+
+    def _extract_component_usage_from_account_data(
+        self, account_data: dict[str, Any]
+    ) -> dict[str, float]:
+        """Extract component usage from account-level data.
+
+        Args:
+            account_data: Account data from CSCS-DWDI API response
+
+        Returns:
+            Dictionary mapping component names to usage values
+        """
+        usage = {}
+
+        for component_name, component_config in self.backend_components.items():
+            # Look for component usage in account data
+            # Try multiple naming patterns to match API response fields to component names
+            raw_value = 0.0
+
+            # Try exact match first (e.g., nodeHours -> nodeHours)
+            if component_name in account_data:
+                raw_value = account_data[component_name]
+            # Try account prefix preserving case (e.g., nodeHours -> accountNodeHours)
+            elif f"account{component_name[0].upper()}{component_name[1:]}" in account_data:
+                raw_value = account_data[f"account{component_name[0].upper()}{component_name[1:]}"]
+            # Try total prefix (e.g., nodeHours -> totalNodeHours)
+            elif f"total{component_name[0].upper()}{component_name[1:]}" in account_data:
+                raw_value = account_data[f"total{component_name[0].upper()}{component_name[1:]}"]
+            # Try lowercase with account prefix
+            elif f"account{component_name}" in account_data:
+                raw_value = account_data[f"account{component_name}"]
+
+            # Apply unit factor conversion
+            unit_factor = component_config.get("unit_factor", 1)
+            converted_value = raw_value * unit_factor
+            usage[component_name] = round(converted_value, 2)
+
+        return usage
+
+    def _extract_component_usage_from_user_data(
+        self, user_data: dict[str, Any]
+    ) -> dict[str, float]:
+        """Extract component usage from user-level data.
+
+        Args:
+            user_data: User data from CSCS-DWDI API response
+
+        Returns:
+            Dictionary mapping component names to usage values
+        """
+        usage = {}
+
+        for component_name, component_config in self.backend_components.items():
+            # Look for component usage in user data
+            # The API should return fields that match component names
+            raw_value = user_data.get(component_name, 0.0)
+
+            # Apply unit factor conversion
+            unit_factor = component_config.get("unit_factor", 1)
+            converted_value = raw_value * unit_factor
+            usage[component_name] = converted_value
+
+        return usage
+
+    # Methods not implemented for reporting-only backend
+    def get_account(self, account_name: str) -> Optional[dict[str, Any]]:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support account management"
+        raise NotImplementedError(msg)
+
+    def create_account(self, account_data: dict) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support account creation"
+        raise NotImplementedError(msg)
+
+    def delete_account(self, account_name: str) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support account deletion"
+        raise NotImplementedError(msg)
+
+    def update_account_limit_deposit(
+        self,
+        account_name: str,
+        component_type: str,
+        component_amount: float,
+        offering_component_data: dict,
+    ) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support limit updates"
+        raise NotImplementedError(msg)
+
+    def reset_account_limit_deposit(
+        self,
+        account_name: str,
+        component_type: str,
+        offering_component_data: dict,
+    ) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support limit resets"
+        raise NotImplementedError(msg)
+
+    def add_account_users(self, account_name: str, user_backend_ids: list[str]) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support user management"
+        raise NotImplementedError(msg)
+
+    def delete_account_users(self, account_name: str, user_backend_ids: list[str]) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support user management"
+        raise NotImplementedError(msg)
+
+    def list_accounts(self) -> list[dict[str, Any]]:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support account listing"
+        raise NotImplementedError(msg)
+
+    def set_resource_limits(self, resource_backend_id: str, limits: dict[str, int]) -> None:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource limits"
+        raise NotImplementedError(msg)
+
+    def diagnostics(self) -> bool:
+        """Get diagnostic information for the backend."""
+        logger.info(
+            "CSCS-DWDI Backend Diagnostics - Type: %s, API: %s, Components: %s, Ping: %s",
+            self.backend_type,
+            self.api_url,
+            list(self.backend_components.keys()),
+            self.ping(),
+        )
+        return self.ping()
+
+    def get_resource_metadata(self, resource_backend_id: str) -> dict[str, Any]:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource metadata"
+        raise NotImplementedError(msg)
+
+    def list_components(self) -> list[str]:
+        """List configured components for this backend."""
+        return list(self.backend_components.keys())
+
+    def _collect_resource_limits(
+        self, waldur_resource: WaldurResource
+    ) -> tuple[dict[str, int], dict[str, int]]:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource limits"
+        raise NotImplementedError(msg)
+
+    def _pre_create_resource(
+        self, waldur_resource: WaldurResource, user_context: Optional[dict] = None
+    ) -> None:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource creation"
+        raise NotImplementedError(msg)
+
+    def pause_resource(self, resource_backend_id: str) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource pausing"
+        raise NotImplementedError(msg)
+
+    def restore_resource(self, resource_backend_id: str) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource restoration"
+        raise NotImplementedError(msg)
+
+    def downscale_resource(self, resource_backend_id: str) -> bool:
+        """Not implemented for reporting-only backend."""
+        msg = "CSCS-DWDI backend is reporting-only and does not support resource downscaling"
+        raise NotImplementedError(msg)

waldur_site_agent_cscs_dwdi/client.py

@@ -0,0 +1,239 @@
+"""CSCS-DWDI API client implementation."""
+
+import logging
+from datetime import date, datetime, timedelta, timezone
+from typing import Any, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+HTTP_OK = 200
+
+
+class CSCSDWDIClient:
+    """Client for interacting with CSCS-DWDI API."""
+
+    def __init__(
+        self,
+        api_url: str,
+        client_id: str,
+        client_secret: str,
+        oidc_token_url: Optional[str] = None,
+        oidc_scope: Optional[str] = None,
+    ) -> None:
+        """Initialize CSCS-DWDI client.
+
+        Args:
+            api_url: Base URL for the CSCS-DWDI API
+            client_id: OIDC client ID for authentication
+            client_secret: OIDC client secret for authentication
+            oidc_token_url: OIDC token endpoint URL (required for authentication)
+            oidc_scope: OIDC scope to request (optional)
+        """
+        self.api_url = api_url.rstrip("/")
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.oidc_token_url = oidc_token_url
+        self.oidc_scope = oidc_scope or "openid"
+        self._token: Optional[str] = None
+        self._token_expires_at: Optional[datetime] = None
+
+    def _get_auth_token(self) -> str:
+        """Get or refresh OIDC authentication token.
+
+        Returns:
+            Valid authentication token
+
+        Raises:
+            httpx.HTTPError: If token acquisition fails
+        """
+        # Check if we have a valid cached token
+        if (
+            self._token
+            and self._token_expires_at
+            and datetime.now(tz=timezone.utc) < self._token_expires_at
+        ):
+            return self._token
+
+        # Fail if OIDC endpoint not configured
+        if not self.oidc_token_url:
+            error_msg = (
+                "OIDC authentication failed: cscs_dwdi_oidc_token_url not configured. "
+                "Set 'cscs_dwdi_oidc_token_url' in backend_settings for production use."
+            )
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # Request new token from OIDC provider
+        return self._acquire_oidc_token()
+
+    def _acquire_oidc_token(self) -> str:
+        """Acquire a new OIDC token from the configured provider.
+
+        Returns:
+            Valid authentication token
+
+        Raises:
+            httpx.HTTPError: If token acquisition fails
+        """
+        logger.debug("Acquiring new OIDC token from %s", self.oidc_token_url)
+
+        token_data = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        # Add scope if specified
+        if self.oidc_scope:
+            token_data["scope"] = self.oidc_scope
+
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        with httpx.Client() as client:
+            response = client.post(
+                self.oidc_token_url, data=token_data, headers=headers, timeout=30.0
+            )
+            response.raise_for_status()
+            token_response = response.json()
+
+            # Extract token and expiry information
+            access_token = token_response.get("access_token")
+            if not access_token:
+                msg = f"No access_token in OIDC response: {token_response}"
+                raise ValueError(msg)
+
+            # Calculate token expiry time
+            expires_in = token_response.get("expires_in", 3600)  # Default to 1 hour
+            # Subtract 5 minutes from expiry for safety margin
+            safe_expires_in = max(300, expires_in - 300)
+
+            self._token = access_token
+            self._token_expires_at = datetime.now(tz=timezone.utc) + timedelta(
+                seconds=safe_expires_in
+            )
+
+            logger.info("Successfully acquired OIDC token, expires in %d seconds", expires_in)
+
+            return self._token
+
+    def get_usage_for_month(
+        self, accounts: list[str], from_date: date, to_date: date
+    ) -> dict[str, Any]:
+        """Get usage data for multiple accounts for a month range.
+
+        Args:
+            accounts: List of account identifiers to query
+            from_date: Start date (beginning of month)
+            to_date: End date (end of month)
+
+        Returns:
+            API response with usage data grouped by account
+
+        Raises:
+            httpx.HTTPError: If API request fails
+        """
+        token = self._get_auth_token()
+
+        # Format dates as YYYY-MM for month endpoints
+        from_month = from_date.strftime("%Y-%m")
+        to_month = to_date.strftime("%Y-%m")
+
+        params: dict[str, Any] = {
+            "from": from_month,
+            "to": to_month,
+        }
+
+        # Add account filters if provided
+        if accounts:
+            params["account"] = accounts
+
+        headers = {"Authorization": f"Bearer {token}"}
+
+        url = f"{self.api_url}/api/v1/compute/usage-month-multiaccount"
+
+        logger.debug(
+            "Fetching usage for accounts %s from %s to %s",
+            accounts,
+            from_month,
+            to_month,
+        )
+
+        with httpx.Client() as client:
+            response = client.get(url, params=params, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            return response.json()
+
+    def get_usage_for_days(
+        self, accounts: list[str], from_date: date, to_date: date
+    ) -> dict[str, Any]:
+        """Get usage data for multiple accounts for a day range.
+
+        Args:
+            accounts: List of account identifiers to query
+            from_date: Start date
+            to_date: End date
+
+        Returns:
+            API response with usage data grouped by account
+
+        Raises:
+            httpx.HTTPError: If API request fails
+        """
+        token = self._get_auth_token()
+
+        # Format dates as YYYY-MM-DD for day endpoints
+        from_day = from_date.strftime("%Y-%m-%d")
+        to_day = to_date.strftime("%Y-%m-%d")
+
+        params: dict[str, Any] = {
+            "from": from_day,
+            "to": to_day,
+        }
+
+        # Add account filters if provided
+        if accounts:
+            params["account"] = accounts
+
+        headers = {"Authorization": f"Bearer {token}"}
+
+        url = f"{self.api_url}/api/v1/compute/usage-day-multiaccount"
+
+        logger.debug(
+            "Fetching daily usage for accounts %s from %s to %s",
+            accounts,
+            from_day,
+            to_day,
+        )
+
+        with httpx.Client() as client:
+            response = client.get(url, params=params, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            return response.json()
+
+    def ping(self) -> bool:
+        """Check if CSCS-DWDI API is accessible.
+
+        Returns:
+            True if API is accessible, False otherwise
+        """
+        try:
+            token = self._get_auth_token()
+            headers = {"Authorization": f"Bearer {token}"}
+
+            # Use a simple query to test connectivity
+            today = datetime.now(tz=timezone.utc).date()
+            params = {
+                "from": today.strftime("%Y-%m-%d"),
+                "to": today.strftime("%Y-%m-%d"),
+            }
+
+            url = f"{self.api_url}/api/v1/compute/usage-day-multiaccount"
+
+            with httpx.Client() as client:
+                response = client.get(url, params=params, headers=headers, timeout=10.0)
+                return response.status_code == HTTP_OK
+        except Exception:
+            logger.exception("Ping failed")
+            return False

waldur_site_agent_cscs_dwdi-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: waldur-site-agent-cscs-dwdi
+Version: 0.1.0
+Summary: CSCS-DWDI reporting plugin for Waldur Site Agent
+Author-email: OpenNode Team <info@opennodecloud.com>
+Requires-Python: <4,>=3.9
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: waldur-site-agent==0.1.0
+Description-Content-Type: text/markdown
+
+# CSCS-DWDI Plugin for Waldur Site Agent
+
+This plugin provides reporting functionality for Waldur Site Agent by integrating with the CSCS-DWDI
+(Data Warehouse and Data Intelligence) API.
+
+## Overview
+
+The CSCS-DWDI plugin is a **reporting-only backend** that fetches compute usage data from the CSCS-DWDI
+service and reports it to Waldur. It supports node-hour usage tracking for multiple accounts and users.
+
+## Features
+
+- **Monthly Usage Reporting**: Fetches usage data for the current month
+- **Multi-Account Support**: Reports usage for multiple accounts in a single API call
+- **Per-User Usage**: Breaks down usage by individual users within each account
+- **OIDC Authentication**: Uses OAuth2/OIDC for secure API access
+- **Automatic Aggregation**: Combines usage across different clusters and time periods
+
+## Configuration
+
+Add the following configuration to your Waldur Site Agent offering:
+
+```yaml
+offerings:
+  - name: "CSCS HPC Offering"
+    reporting_backend: "cscs-dwdi"
+    backend_settings:
+      cscs_dwdi_api_url: "https://dwdi-api.cscs.ch"
+      cscs_dwdi_client_id: "your-oidc-client-id"
+      cscs_dwdi_client_secret: "your-oidc-client-secret"
+      # Optional OIDC configuration (for production use)
+      cscs_dwdi_oidc_token_url: "https://identity.cscs.ch/realms/cscs/protocol/openid-connect/token"
+      cscs_dwdi_oidc_scope: "cscs-dwdi:read"
+
+    backend_components:
+      nodeHours:
+        measured_unit: "node-hours"
+        unit_factor: 1
+        accounting_type: "usage"
+        label: "Node Hours"
+      storage:
+        measured_unit: "TB"
+        unit_factor: 1
+        accounting_type: "usage"
+        label: "Storage Usage"
+```
+
+### Configuration Parameters
+
+#### Backend Settings
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `cscs_dwdi_api_url` | Yes | Base URL for the CSCS-DWDI API service |
+| `cscs_dwdi_client_id` | Yes | OIDC client ID for authentication |
+| `cscs_dwdi_client_secret` | Yes | OIDC client secret for authentication |
+| `cscs_dwdi_oidc_token_url` | Yes | OIDC token endpoint URL (required for authentication) |
+| `cscs_dwdi_oidc_scope` | No | OIDC scope to request (defaults to "openid") |
+
+#### Backend Components
+
+Components must match the field names returned by the CSCS-DWDI API. For example:
+
+- `nodeHours` - Maps to the `nodeHours` field in API responses
+- `storage` - Maps to the `storage` field in API responses (if available)
+- `gpuHours` - Maps to the `gpuHours` field in API responses (if available)
+
+Each component supports:
+
+| Parameter | Description |
+|-----------|-------------|
+| `measured_unit` | Unit for display in Waldur (e.g., "node-hours", "TB") |
+| `unit_factor` | Conversion factor from API units to measured units |
+| `accounting_type` | Either "usage" for actual usage or "limit" for quotas |
+| `label` | Display label in Waldur interface |
+
+## Usage Data Format
+
+The plugin reports usage for all configured components:
+
+- **Component Types**: Configurable (e.g., `nodeHours`, `storage`, `gpuHours`)
+- **Units**: Based on API response and `unit_factor` configuration
+- **Granularity**: Monthly reporting with current month data
+- **User Attribution**: Individual user usage within each account
+- **Aggregation**: Automatically aggregates across clusters and time periods
+
+## API Integration
+
+The plugin uses the CSCS-DWDI API endpoints:
+
+- `GET /api/v1/compute/usage-month-multiaccount` - Primary endpoint for monthly usage data
+- Authentication via OIDC Bearer tokens
+
+### Authentication
+
+The plugin uses OAuth2/OIDC authentication with the following requirements:
+
+- Requires `cscs_dwdi_oidc_token_url` in backend settings
+- Uses OAuth2 `client_credentials` grant flow
+- Automatically handles token caching and renewal
+- Includes 5-minute safety margin for token expiry
+- Fails with proper error logging if OIDC configuration is missing
+
+### Data Processing
+
+1. **Account Filtering**: Only reports on accounts that match Waldur resource backend IDs
+2. **User Aggregation**: Combines usage for the same user across different dates and clusters
+3. **Time Range**: Automatically queries from the first day of the current month to today
+4. **Precision**: Rounds node-hours to 2 decimal places
+
+## Installation
+
+This plugin is part of the Waldur Site Agent workspace. To install:
+
+```bash
+# Install all workspace packages including cscs-dwdi plugin
+uv sync --all-packages
+
+# Install specific plugin for development
+uv sync --extra cscs-dwdi
+```
+
+## Testing
+
+Run the plugin tests:
+
+```bash
+# Run CSCS-DWDI plugin tests
+uv run pytest plugins/cscs-dwdi/tests/
+
+# Run with coverage
+uv run pytest plugins/cscs-dwdi/tests/ --cov=waldur_site_agent_cscs_dwdi
+```
+
+## Limitations
+
+This is a **reporting-only backend** that does not support:
+
+- Account creation or deletion
+- User management
+- Resource limit management
+- Order processing
+- Membership synchronization
+
+For these operations, use a different backend (e.g., SLURM) in combination with the CSCS-DWDI reporting backend:
+
+```yaml
+offerings:
+  - name: "Mixed Backend Offering"
+    order_processing_backend: "slurm"       # Use SLURM for orders
+    reporting_backend: "cscs-dwdi"          # Use CSCS-DWDI for reporting
+    membership_sync_backend: "slurm"        # Use SLURM for membership
+```
+
+## Error Handling
+
+The plugin includes comprehensive error handling:
+
+- **API Connectivity**: Ping checks verify API availability
+- **Authentication**: Token refresh and error handling
+- **Data Validation**: Validates API responses and filters invalid data
+- **Retry Logic**: Uses the framework's built-in retry mechanisms
+
+## Development
+
+### Project Structure
+
+```text
+plugins/cscs-dwdi/
+├── pyproject.toml                           # Plugin configuration
+├── README.md                               # This documentation
+├── waldur_site_agent_cscs_dwdi/
+│   ├── __init__.py                         # Package init
+│   ├── backend.py                          # Main backend implementation
+│   └── client.py                          # CSCS-DWDI API client
+└── tests/
+    └── test_cscs_dwdi.py                  # Plugin tests
+```
+
+### Key Classes
+
+- **`CSCSDWDIBackend`**: Main backend class implementing reporting functionality
+- **`CSCSDWDIClient`**: HTTP client for CSCS-DWDI API communication
+
+### Extension Points
+
+To extend the plugin:
+
+1. **Additional Endpoints**: Modify `CSCSDWDIClient` to support more API endpoints
+2. **Authentication Methods**: Update authentication logic in `client.py`
+3. **Data Processing**: Enhance `_process_api_response()` for additional data formats
+
+## Troubleshooting
+
+### Common Issues
+
+#### Authentication Failures
+
+- Verify OIDC client credentials
+- Check API URL configuration
+- Ensure proper token scopes
+
+#### Missing Usage Data
+
+- Verify account names match between Waldur and CSCS-DWDI
+- Check date ranges and API response format
+- Review API rate limits and quotas
+
+#### Network Connectivity
+
+- Test API connectivity with ping functionality
+- Verify network access from agent deployment environment
+- Check firewall and proxy settings
+
+### Debugging
+
+Enable debug logging for detailed API interactions:
+
+```python
+import logging
+logging.getLogger('waldur_site_agent_cscs_dwdi').setLevel(logging.DEBUG)
+```
+
+## Support
+
+For issues and questions:
+
+- Check the [Waldur Site Agent documentation](../../docs/)
+- Review plugin test cases for usage examples
+- Create issues in the project repository

waldur_site_agent_cscs_dwdi-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+waldur_site_agent_cscs_dwdi/__init__.py,sha256=OHO1yF5NTGt0otI-GollR_ppPXP--aUZRCdaT5-8IWw,56
+waldur_site_agent_cscs_dwdi/backend.py,sha256=V5T9H5b9utxcD73TmACvrc4dZm-GEORLDI0C0tUD_7s,14251
+waldur_site_agent_cscs_dwdi/client.py,sha256=aAWNqrA0oBknWge_TQIU4u8PQi5YdIZtQTZ2XPREznQ,7555
+waldur_site_agent_cscs_dwdi-0.1.0.dist-info/METADATA,sha256=nTtebzVzy0mWYqZejNICgI5hlHFDxbsPAk0woaSABHM,7772
+waldur_site_agent_cscs_dwdi-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+waldur_site_agent_cscs_dwdi-0.1.0.dist-info/entry_points.txt,sha256=U3odcX7B4NmT9a98ov4uVxlng3JqiCRb5Ux3h4H_ZFE,93
+waldur_site_agent_cscs_dwdi-0.1.0.dist-info/RECORD,,

waldur_site_agent_cscs_dwdi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

waldur_site_agent_cscs_dwdi-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[waldur_site_agent.backends]
+cscs-dwdi = waldur_site_agent_cscs_dwdi.backend:CSCSDWDIBackend