Dataverse Python Production Code

Dataverse Python production code

Generate production-ready Python for the PowerPlatform-Dataverse-Client SDK by using typed service classes, singleton client management, Dataverse exception handling, retryable transient errors, server-side OData filtering, and structured logging instead of throwaway snippets.

When to invoke

• "Generate production Python for Dataverse."
• "Write PowerPlatform-Dataverse-Client SDK code with retries."
• "Show Dataverse error handling and logging patterns."
• "Create a singleton Dataverse client service."
• "Optimize this Dataverse query with OData select and filter."

Code generation criteria

Error handling pattern

from PowerPlatform.Dataverse.core.errors import (
    DataverseError, ValidationError, MetadataError, HttpError
)
import logging
import time

logger = logging.getLogger(__name__)

def operation_with_retry(max_retries=3):
    """Function with retry logic."""
    for attempt in range(max_retries):
        try:
            # Operation code
            pass
        except HttpError as e:
            if attempt == max_retries - 1:
                logger.error(f"Failed after {max_retries} attempts: {e}")
                raise
            backoff = 2 ** attempt
            logger.warning(f"Attempt {attempt + 1} failed. Retrying in {backoff}s")
            time.sleep(backoff)

Client management pattern

class DataverseService:
    _instance = None
    _client = None
    
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self, org_url, credential):
        if self._client is None:
            self._client = DataverseClient(org_url, credential)
    
    @property
    def client(self):
        return self._client

Logging pattern

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

logger.info(f"Created {count} records")
logger.warning(f"Record {id} not found")
logger.error(f"Operation failed: {error}")

OData optimization rules

User request processing

When generating code, include these sections:

1. Imports with all required modules.
2. Configuration section with constants/enums.
3. Main implementation with proper error handling.
4. Docstrings explaining parameters and return values.
5. Type hints for all functions.
6. Usage example showing how to call the code.
7. Error scenarios with exception handling.
8. Logging statements for debugging.

Output template

## Dataverse Python implementation

**Status:** generated | needs details | blocked
**SDK:** `PowerPlatform-Dataverse-Client`
**Python:** `3.10+`

### Code
```python
from PowerPlatform.Dataverse.core.errors import DataverseError, ValidationError, MetadataError, HttpError

# stdlib imports, configuration, logging, singleton DataverseService,
# OData-optimized operation, retry handling, usage example
```

### Error scenarios
| Scenario | Exception | Handling |
| --- | --- | --- |
| Validation failure | `ValidationError` | fail fast with clear message |
| Metadata issue | `MetadataError` | log and raise |
| HTTP 429/timeout | `HttpError` | retry with exponential backoff |
| Other Dataverse failure | `DataverseError` | log with context and raise |

### OData query choices
- `select`: <columns>
- `filter`: <server-side filter>
- `orderby`: <ordering>
- `top`: <limit>
- `expand`: <related records if used>

Quality gate

• Code is valid Python 3.10+ and follows PEP 8.
• API calls are inside try/except blocks using DataverseError, ValidationError, MetadataError, and HttpError where applicable.
• Retry logic with exponential backoff covers transient 429 and timeout errors.
• Client creation follows the singleton DataverseService pattern.
• OData queries use select, server-side filter, lowercase logical names, and orderby/top/expand when appropriate.
• All public functions include type hints and docstrings.
• Logging uses logger and never print() for operational messages.
• Secrets, URLs, and credentials are configuration-driven, not hardcoded.
• The answer includes imports, configuration, main implementation, usage example, error scenarios, and logging statements.