### Install Test Dependencies

Source: https://github.com/datadog/datadog-api-client-python/blob/master/DEVELOPMENT.md

Run this command in the root directory to install the necessary dependencies for running tests.

```bash
pip install .[tests]
```

--------------------------------

### Install datadog-api-client

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Install the Datadog API client library using pip.

```shell
pip install datadog-api-client
```

--------------------------------

### Create a Monitor

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Example of creating a monitor using the Datadog API client. Ensure you have the necessary imports and model definitions.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi
from datadog_api_client.v1.model.monitor import Monitor
from datadog_api_client.v1.model.monitor_type import MonitorType

body = Monitor(
    name="example",
    type=MonitorType("log alert"),
    query='logs("service:foo AND type:error").index("main").rollup("count").by("source").last("5m") > 2',
    message="some message Notify: @hipchat-channel",
    tags=["test:example", "env:ci"],
    priority=3,
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.create_monitor(body=body)
    print(response)
```

--------------------------------

### Create Synthetic API Test

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Set up synthetic monitoring to proactively test API endpoints. This example configures an HTTP GET request with assertions for status code and response time.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.synthetics_api import SyntheticsApi
from datadog_api_client.v1.model.synthetics_api_test import SyntheticsAPITest
from datadog_api_client.v1.model.synthetics_api_test_config import SyntheticsAPITestConfig
from datadog_api_client.v1.model.synthetics_api_test_type import SyntheticsAPITestType
from datadog_api_client.v1.model.synthetics_assertion_target import SyntheticsAssertionTarget
from datadog_api_client.v1.model.synthetics_assertion_operator import SyntheticsAssertionOperator
from datadog_api_client.v1.model.synthetics_assertion_type import SyntheticsAssertionType
from datadog_api_client.v1.model.synthetics_test_details_sub_type import SyntheticsTestDetailsSubType
from datadog_api_client.v1.model.synthetics_test_options import SyntheticsTestOptions
from datadog_api_client.v1.model.synthetics_test_pause_status import SyntheticsTestPauseStatus
from datadog_api_client.v1.model.synthetics_test_request import SyntheticsTestRequest

body = SyntheticsAPITest(
    name="API Health Check",
    type=SyntheticsAPITestType.API,
    subtype=SyntheticsTestDetailsSubType.HTTP,
    config=SyntheticsAPITestConfig(
        request=SyntheticsTestRequest(
            method="GET",
            url="https://api.example.com/health",
            headers={"Authorization": "Bearer ${API_TOKEN}"},
        ),
        assertions=[
            SyntheticsAssertionTarget(
                type=SyntheticsAssertionType.STATUS_CODE,
                operator=SyntheticsAssertionOperator.IS,
                target=200,
            ),
            SyntheticsAssertionTarget(
                type=SyntheticsAssertionType.RESPONSE_TIME,
                operator=SyntheticsAssertionOperator.LESS_THAN,
                target=2000,
            ),
        ],
    ),
    locations=["aws:us-east-1", "aws:eu-west-1"],
    options=SyntheticsTestOptions(
        tick_every=60,
        min_failure_duration=300,
        min_location_failed=1,
    ),
    message="API health check failed! @slack-oncall",
    tags=["env:production", "service:api"],
    status=SyntheticsTestPauseStatus.LIVE,
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = SyntheticsApi(api_client)
    response = api_instance.create_synthetics_api_test(body=body)
    print(f"Synthetics test created: {response.public_id}")
```

--------------------------------

### Use AsyncApiClient for Asynchronous Operations

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Install with `pip install datadog-api-client[async]`. This example shows how to use `AsyncApiClient` to perform asynchronous API calls, returning coroutines that can be awaited.

```python
import asyncio

from datadog_api_client import Configuration, AsyncApiClient
from datadog_api_client.v1.api.dashboards_api import DashboardsApi

async def main():
    configuration = Configuration()
    async with AsyncApiClient(configuration) as api_client:
        api_instance = DashboardsApi(api_client)
        dashboards = await api_instance.list_dashboards()
        print(dashboards)

asyncio.run(main())
```

--------------------------------

### List and Get Monitors

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Retrieves a list of all monitors or fetches details for a specific monitor by its ID. The `get_monitor` method can optionally include downtime information.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)

    # List all monitors
    monitors = api_instance.list_monitors()
    for monitor in monitors:
        print(f"Monitor: {monitor.name} (ID: {monitor.id})")

    # Get specific monitor with downtimes
    monitor_id = 12345
    monitor = api_instance.get_monitor(
        monitor_id=monitor_id,
        with_downtimes=True
    )
    print(f"Monitor details: {monitor}")
```

--------------------------------

### Create Security Monitoring Rule using Datadog API Client

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Configure security monitoring rules to detect threats and suspicious activities. This example demonstrates creating a rule for brute force login detection.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.security_monitoring_api import SecurityMonitoringApi
from datadog_api_client.v2.model.security_monitoring_standard_rule_create_payload import (
    SecurityMonitoringStandardRuleCreatePayload,
)
from datadog_api_client.v2.model.security_monitoring_standard_rule_query import SecurityMonitoringStandardRuleQuery
from datadog_api_client.v2.model.security_monitoring_rule_case_create import SecurityMonitoringRuleCaseCreate
from datadog_api_client.v2.model.security_monitoring_rule_options import SecurityMonitoringRuleOptions
from datadog_api_client.v2.model.security_monitoring_rule_severity import SecurityMonitoringRuleSeverity
from datadog_api_client.v2.model.security_monitoring_rule_query_aggregation import (
    SecurityMonitoringRuleQueryAggregation,
)
from datadog_api_client.v2.model.security_monitoring_rule_evaluation_window import (
    SecurityMonitoringRuleEvaluationWindow,
)
from datadog_api_client.v2.model.security_monitoring_rule_keep_alive import SecurityMonitoringRuleKeepAlive
from datadog_api_client.v2.model.security_monitoring_rule_max_signal_duration import (
    SecurityMonitoringRuleMaxSignalDuration,
)
from datadog_api_client.v2.model.security_monitoring_rule_type_create import SecurityMonitoringRuleTypeCreate

body = SecurityMonitoringStandardRuleCreatePayload(
    name="Brute Force Login Detection",
    type=SecurityMonitoringRuleTypeCreate.LOG_DETECTION,
    queries=[
        SecurityMonitoringStandardRuleQuery(
            query="@evt.name:authentication @evt.outcome:failure",
            aggregation=SecurityMonitoringRuleQueryAggregation.COUNT,
            group_by_fields=["@usr.id"],
        ),
    ],
    cases=[
        SecurityMonitoringRuleCaseCreate(
            name="High",
            status=SecurityMonitoringRuleSeverity.HIGH,
            condition="a > 10",
            notifications=["@slack-security"],
        ),
    ],
    options=SecurityMonitoringRuleOptions(
        evaluation_window=SecurityMonitoringRuleEvaluationWindow.FIVE_MINUTES,
        keep_alive=SecurityMonitoringRuleKeepAlive.ONE_HOUR,
        max_signal_duration=SecurityMonitoringRuleMaxSignalDuration.ONE_DAY,
    ),
    message="Potential brute force attack detected for user {{@usr.id}}",
    tags=["security:authentication", "severity:high"],
    is_enabled=True,
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = SecurityMonitoringApi(api_client)
    response = api_instance.create_security_monitoring_rule(body=body)
    print(f"Security rule created: {response.id}")
```

--------------------------------

### Consume Paginated API Results

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

This example demonstrates how to use the `list_incidents_with_pagination` method to iterate through all available items, such as incidents, when dealing with paginated API endpoints.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.incidents_api import IncidentsApi

configuration = Configuration()
configuration.unstable_operations["list_incidents"] = True
with ApiClient(configuration) as api_client:
    api_instance = IncidentsApi(api_client)
    for incident in api_instance.list_incidents_with_pagination():
        print(incident.id)
```

--------------------------------

### Run tox tests for Python 3.9

Source: https://github.com/datadog/datadog-api-client-python/blob/master/TESTING.md

Use this command to execute tests for a specific Python version using tox. Ensure you have tox installed and configured.

```shell
tox -epy39
```

--------------------------------

### Submit Datadog Metrics

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Submit custom metrics to Datadog, such as counts or gauges. This example shows submitting two series with different metrics and tags.

```python
from datetime import datetime
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.metrics_api import MetricsApi
from datadog_api_client.v1.model.metrics_payload import MetricsPayload
from datadog_api_client.v1.model.point import Point
from datadog_api_client.v1.model.series import Series

body = MetricsPayload(
    series=[
        Series(
            metric="custom.orders.count",
            type="count",
            points=[
                Point([datetime.now().timestamp(), 150]),
            ],
            tags=["env:production", "region:us-east"],
        ),
        Series(
            metric="custom.response.time",
            type="gauge",
            points=[
                Point([datetime.now().timestamp(), 0.245]),
            ],
            tags=["env:production", "endpoint:/api/users"],
        ),
    ],
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    response = api_instance.submit_metrics(body=body)
    print(f"Metrics submitted: {response.status}")
```

--------------------------------

### Submit Logs to Datadog

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Send log entries to Datadog for centralized log management. Ensure the Datadog API client is installed and configured.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.logs_api import LogsApi
from datadog_api_client.v1.model.http_log import HTTPLog
from datadog_api_client.v1.model.http_log_item import HTTPLogItem

body = HTTPLog([
    HTTPLogItem(
        message="User login successful",
        ddsource="python-app",
        ddtags="env:production,service:auth,version:1.0",
        hostname="web-server-01",
        service="authentication-service",
    ),
    HTTPLogItem(
        message='{"event": "order_placed", "order_id": "12345", "amount": 99.99}',
        ddsource="python-app",
        ddtags="env:production,service:orders",
        hostname="api-server-01",
        service="order-service",
    ),
])

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = LogsApi(api_client)
    response = api_instance.submit_log(body=body)
    print("Logs submitted successfully")
```

--------------------------------

### Asyncio Support for Non-blocking Operations

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Use AsyncApiClient for non-blocking asynchronous operations in asyncio applications. Install with `pip install datadog-api-client[async]`.

```python
import asyncio
from datadog_api_client import Configuration, AsyncApiClient
from datadog_api_client.v1.api.dashboards_api import DashboardsApi

async def list_dashboards():
    configuration = Configuration()
    async with AsyncApiClient(configuration) as api_client:
        api_instance = DashboardsApi(api_client)
        dashboards = await api_instance.list_dashboards()

        for dashboard in dashboards.dashboards:
            print(f"Dashboard: {dashboard.title}")

asyncio.run(list_dashboards())
```

--------------------------------

### Run tox tests with pytest arguments

Source: https://github.com/datadog/datadog-api-client-python/blob/master/TESTING.md

Pass additional arguments to pytest through tox by using '--' to separate tox arguments from pytest arguments. This example shows how to filter tests with '-k' and increase verbosity with '-vvv'.

```shell
tox -epy39  -- -k test_get_a_list_of_all_incident_teams_returns_ok_response -vvv
```

--------------------------------

### Threaded Client for Concurrent Operations

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Execute API calls in background threads for concurrent operations without asyncio. The `get()` method blocks until the request is complete.

```python
from datadog_api_client import Configuration, ThreadedApiClient
from datadog_api_client.v1.api.dashboards_api import DashboardsApi
from datadog_api_client.v1.api.monitors_api import MonitorsApi

configuration = Configuration()
with ThreadedApiClient(configuration) as api_client:
    dashboards_api = DashboardsApi(api_client)
    monitors_api = MonitorsApi(api_client)

    # Start async requests
    dashboards_future = dashboards_api.list_dashboards()
    monitors_future = monitors_api.list_monitors()

    # Get results (blocks until complete)
    dashboards = dashboards_future.get()
    monitors = monitors_future.get()

    print(f"Found {len(dashboards.dashboards)} dashboards")
    print(f"Found {len(monitors)} monitors")
```

--------------------------------

### Basic Configuration with Environment Variables

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Automatically loads configuration from DD_API_KEY, DD_APP_KEY, and DD_SITE environment variables. Ensure these are set before running.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi

# Configuration automatically loads from environment variables:
# DD_API_KEY, DD_APP_KEY, DD_SITE
configuration = Configuration()

with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.list_monitors()
    print(response)
```

--------------------------------

### Explicit Configuration with API Keys and Options

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Manually set API keys, regional site, proxy, and retry policies. Useful for environments where environment variables are not preferred or for fine-grained control.

```python
import urllib3
from datadog_api_client import ApiClient, Configuration

configuration = Configuration()

# Set API credentials explicitly
configuration.api_key["apiKeyAuth"] = "YOUR_API_KEY"
configuration.api_key["appKeyAuth"] = "YOUR_APPLICATION_KEY"

# Configure regional site (default: datadoghq.com)
configuration.server_variables["site"] = "datadoghq.eu"  # EU site

# Enable retry on rate limiting (429) and server errors
configuration.enable_retry = True
configuration.max_retries = 5
configuration.retry_backoff_factor = 2

# Configure proxy
configuration.proxy = "http://127.0.0.1:8080"

# Enable debug logging
configuration.debug = True

# Disable GZIP compression
configuration.compress = False

# Custom retry policy with urllib3
custom_retry = urllib3.util.Retry(
    total=5,
    backoff_factor=2,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST", "PUT", "DELETE"]
)
configuration = Configuration(retry_policy=custom_retry)

with ApiClient(configuration) as api_client:
    # Use the configured client
    pass
```

--------------------------------

### Configuration and Authentication

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Demonstrates how to configure the Datadog API client using environment variables or explicit API keys, including regional site and retry settings.

```APIDOC
## Basic Configuration with Environment Variables

The library automatically uses `DD_API_KEY`, `DD_APP_KEY`, and `DD_SITE` environment variables for authentication and regional site configuration.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi

# Configuration automatically loads from environment variables:
# DD_API_KEY, DD_APP_KEY, DD_SITE
configuration = Configuration()

with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.list_monitors()
    print(response)
```

## Explicit Configuration with API Keys

For explicit credential management, you can set API keys directly on the configuration object, configure regional endpoints, proxies, and retry policies.

```python
import urllib3
from datadog_api_client import ApiClient, Configuration

configuration = Configuration()

# Set API credentials explicitly
configuration.api_key["apiKeyAuth"] = "YOUR_API_KEY"
configuration.api_key["appKeyAuth"] = "YOUR_APPLICATION_KEY"

# Configure regional site (default: datadoghq.com)
configuration.server_variables["site"] = "datadoghq.eu"  # EU site

# Enable retry on rate limiting (429) and server errors
configuration.enable_retry = True
configuration.max_retries = 5
configuration.retry_backoff_factor = 2

# Configure proxy
configuration.proxy = "http://127.0.0.1:8080"

# Enable debug logging
configuration.debug = True

# Disable GZIP compression
configuration.compress = False

# Custom retry policy with urllib3
custom_retry = urllib3.util.Retry(
    total=5,
    backoff_factor=2,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST", "PUT", "DELETE"]
)
configuration = Configuration(retry_policy=custom_retry)

with ApiClient(configuration) as api_client:
    # Use the configured client
    pass
```
```

--------------------------------

### Set API and Application Keys

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Configure authentication by setting your API and application keys directly on the configuration object.

```python
configuration.api_key["apiKeyAuth"] = "<API KEY>"
configuration.api_key["appKeyAuth"] = "<APPLICATION KEY>"
```

--------------------------------

### Run All Tests

Source: https://github.com/datadog/datadog-api-client-python/blob/master/DEVELOPMENT.md

Execute this script from the root directory to run the project's test suite. Use the optional -k flag to filter tests by name.

```bash
./run-tests.sh
```

--------------------------------

### Configure Proxy

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Set up a proxy for API requests by specifying the proxy URL in the configuration.

```python
configuration.proxy = "http://127.0.0.1:80"
```

--------------------------------

### Configure API and Application Keys for Authentication

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Authenticate API requests by setting your Datadog API and Application keys in the `configuration.api_key` dictionary.

```python
configuration.api_key["apiKeyAuth"] = "YOUR_API_KEY"
configuration.api_key["appKeyAuth"] = "YOUR_APPLICATION_KEY"
```

--------------------------------

### Create Dashboard API

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Demonstrates how to create a custom dashboard with various widget types for visualizing metrics and logs.

```APIDOC
## POST /api/v1/dashboards

### Description
Creates a new dashboard with a specified title, layout, description, widgets, and tags.

### Method
POST

### Endpoint
/api/v1/dashboards

### Parameters
#### Request Body
- **body** (Dashboard) - Required - The dashboard definition.

### Request Example
```json
{
  "title": "Infrastructure Overview",
  "layout_type": "ordered",
  "description": "Real-time infrastructure monitoring",
  "widgets": [
    {
      "definition": {
        "type": "timeseries",
        "title": "CPU Usage by Host",
        "requests": [
          {
            "q": "avg:system.cpu.user{*} by {host}",
            "display_type": "line"
          }
        ]
      },
      "layout": {"x": 0, "y": 0, "width": 6, "height": 3}
    }
  ],
  "tags": ["team:platform", "env:prod"]
}
```

### Response
#### Success Response (200)
- **url** (string) - The URL of the created dashboard.

#### Response Example
```json
{
  "url": "/dashboard/12345abcde-6789-abcd-ef01-23456789abcd"
}
```
```

--------------------------------

### Create a Metric Alert Monitor

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Creates a new monitor for metric alerts. Requires defining the monitor name, type, query, message, tags, priority, and options like thresholds.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi
from datadog_api_client.v1.model.monitor import Monitor
from datadog_api_client.v1.model.monitor_type import MonitorType

body = Monitor(
    name="High CPU Usage Alert",
    type=MonitorType.METRIC_ALERT,
    query="avg(last_5m):avg:system.cpu.user{*} > 80",
    message="CPU usage is above 80%. Notify: @slack-ops-channel",
    tags=["env:production", "team:infrastructure"],
    priority=2,
    options={
        "thresholds": {"critical": 80, "warning": 70},
        "notify_no_data": True,
        "no_data_timeframe": 10,
        "renotify_interval": 60
    }
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)
    response = api_instance.create_monitor(body=body)
    print(f"Monitor created with ID: {response.id}")
```

--------------------------------

### Create Datadog Team

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Organize users into teams for collaborative monitoring and incident management. Requires specifying team attributes like name, handle, and description.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.teams_api import TeamsApi
from datadog_api_client.v2.model.team_create_request import TeamCreateRequest
from datadog_api_client.v2.model.team_create import TeamCreate
from datadog_api_client.v2.model.team_create_attributes import TeamCreateAttributes
from datadog_api_client.v2.model.team_type import TeamType

body = TeamCreateRequest(
    data=TeamCreate(
        type=TeamType.TEAM,
        attributes=TeamCreateAttributes(
            name="Platform Engineering",
            handle="platform-eng",
            description="Infrastructure and platform services team",
        ),
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = TeamsApi(api_client)
    response = api_instance.create_team(body=body)
    print(f"Team created: {response.data.id}")
```

--------------------------------

### Create API Test

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Set up synthetic monitoring to proactively test API endpoints and web services for availability and performance.

```APIDOC
## POST /api/v1/synthetics/tests/api

### Description
Set up synthetic monitoring to proactively test API endpoints and web services for availability and performance.

### Method
POST

### Endpoint
/api/v1/synthetics/tests/api

### Request Body
- **body** (SyntheticsAPITest) - Required - The API test object.

### Request Example
```json
{
  "name": "API Health Check",
  "type": "api",
  "subtype": "http",
  "config": {
    "request": {
      "method": "GET",
      "url": "https://api.example.com/health",
      "headers": {
        "Authorization": "Bearer ${API_TOKEN}"
      }
    },
    "assertions": [
      {
        "type": "status code",
        "operator": "is",
        "target": 200
      },
      {
        "type": "response time",
        "operator": "less than",
        "target": 2000
      }
    ]
  },
  "locations": [
    "aws:us-east-1",
    "aws:eu-west-1"
  ],
  "options": {
    "tick_every": 60,
    "min_failure_duration": 300,
    "min_location_failed": 1
  },
  "message": "API health check failed! @slack-oncall",
  "tags": [
    "env:production",
    "service:api"
  ],
  "status": "live"
}
```

### Response
#### Success Response (200)
- **public_id** (string) - The unique identifier for the created synthetic API test.

#### Response Example
```json
{
  "public_id": "abcdef12-3456-7890-abcd-ef1234567890"
}
```
```

--------------------------------

### Record Integration Test Cassettes

Source: https://github.com/datadog/datadog-api-client-python/blob/master/DEVELOPMENT.md

Set the RECORD environment variable to 'true' when running tests to record new API responses. This is useful when updating tests or adding new ones.

```bash
RECORD=true ./run-tests.sh
```

--------------------------------

### Run Integration Tests Without Recording

Source: https://github.com/datadog/datadog-api-client-python/blob/master/DEVELOPMENT.md

To run integration tests against the live API without creating or updating cassette files, set the RECORD environment variable to 'none'.

```bash
RECORD=none ./run-tests.sh
```

--------------------------------

### Create SLO with Datadog API Client

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Defines and creates a Service Level Objective (SLO) using the Datadog API client for Python. Ensure necessary imports and model definitions are available.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.service_level_objectives_api import ServiceLevelObjectivesApi
from datadog_api_client.v1.model.service_level_objective_request import ServiceLevelObjectiveRequest
from datadog_api_client.v1.model.service_level_objective_query import ServiceLevelObjectiveQuery
from datadog_api_client.v1.model.slo_threshold import SLOThreshold
from datadog_api_client.v1.model.slo_timeframe import SLOTimeframe
from datadog_api_client.v1.model.slo_type import SLOType

body = ServiceLevelObjectiveRequest(
    name="API Availability SLO",
    type=SLOType.METRIC,
    description="99.9% availability for production API",
    query=ServiceLevelObjectiveQuery(
        numerator="sum:api.requests.success{env:production}.as_count()",
        denominator="sum:api.requests.total{env:production}.as_count()",
    ),
    thresholds=[
        SLOThreshold(
            target=99.9,
            target_display="99.9%",
            timeframe=SLOTimeframe.THIRTY_DAYS,
            warning=99.95,
            warning_display="99.95%",
        ),
        SLOThreshold(
            target=99.5,
            target_display="99.5%",
            timeframe=SLOTimeframe.SEVEN_DAYS,
        ),
    ],
    tags=["service:api", "env:production", "team:platform"],
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = ServiceLevelObjectivesApi(api_client)
    response = api_instance.create_slo(body=body)
    print(f"SLO created: {response.data[0].id}")
```

--------------------------------

### Submit Metrics with Datadog API Client V2

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Submits metrics using the V2 API, supporting enhanced resource metadata and tagging. Requires imports for datetime, ApiClient, and various V2 model definitions.

```python
from datetime import datetime
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.metrics_api import MetricsApi
from datadog_api_client.v2.model.metric_payload import MetricPayload
from datadog_api_client.v2.model.metric_series import MetricSeries
from datadog_api_client.v2.model.metric_point import MetricPoint
from datadog_api_client.v2.model.metric_resource import MetricResource
from datadog_api_client.v2.model.metric_intake_type import MetricIntakeType

body = MetricPayload(
    series=[
        MetricSeries(
            metric="app.request.latency",
            type=MetricIntakeType.GAUGE,
            points=[
                MetricPoint(
                    timestamp=int(datetime.now().timestamp()),
                    value=0.125,
                ),
            ],
            resources=[
                MetricResource(name="web-server-01", type="host"),
                MetricResource(name="us-east-1a", type="availability_zone"),
            ],
            tags=["env:production", "service:api", "endpoint:/users"],
        ),
    ],
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    response = api_instance.submit_metrics(body=body)
    print(f"Metrics accepted: {response}")
```

--------------------------------

### Create Datadog Role

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Define custom roles with specific permissions for fine-grained access control. Ensure the necessary models are imported.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.roles_api import RolesApi
from datadog_api_client.v2.model.role_create_request import RoleCreateRequest
from datadog_api_client.v2.model.role_create_data import RoleCreateData
from datadog_api_client.v2.model.role_create_attributes import RoleCreateAttributes
from datadog_api_client.v2.model.roles_type import RolesType

body = RoleCreateRequest(
    data=RoleCreateData(
        type=RolesType.ROLES,
        attributes=RoleCreateAttributes(
            name="dashboard-editors",
            receives_permissions_from=[],
        ),
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = RolesApi(api_client)
    response = api_instance.create_role(body=body)
    print(f"Role created: {response.data.id}")
```

--------------------------------

### Pagination Support for Large Collections

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Use built-in pagination helpers to iterate through all items in large collections without manual cursor management. Ensure `unstable_operations` is configured if necessary.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.incidents_api import IncidentsApi

configuration = Configuration()
configuration.unstable_operations["list_incidents"] = True

with ApiClient(configuration) as api_client:
    api_instance = IncidentsApi(api_client)

    # Automatically paginate through all incidents
    for incident in api_instance.list_incidents_with_pagination():
        print(f"Incident: {incident.id} - {incident.attributes.title}")
```

--------------------------------

### V1 API - Monitors

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Provides endpoints for managing Datadog monitors, including creating, listing, and retrieving monitor details.

```APIDOC
## POST /api/v1/monitor

### Description
Create alerting monitors to track metrics, logs, or other data sources with customizable thresholds and notification settings.

### Method
POST

### Endpoint
`/api/v1/monitor`

### Parameters
#### Request Body
- **body** (Monitor) - Required - Monitor object to create.

### Request Example
```json
{
  "name": "High CPU Usage Alert",
  "type": "metric alert",
  "query": "avg(last_5m):avg:system.cpu.user{*} > 80",
  "message": "CPU usage is above 80%. Notify: @slack-ops-channel",
  "tags": ["env:production", "team:infrastructure"],
  "priority": 2,
  "options": {
    "thresholds": {"critical": 80, "warning": 70},
    "notify_no_data": true,
    "no_data_timeframe": 10,
    "renotify_interval": 60
  }
}
```

### Response
#### Success Response (200)
- **id** (int) - The ID of the created monitor.

#### Response Example
```json
{
  "id": 123456789
}
```

## GET /api/v1/monitor

### Description
Retrieve all monitors or fetch a specific monitor by its ID with optional parameters like downtime information.

### Method
GET

### Endpoint
`/api/v1/monitor`

### Parameters
#### Query Parameters
- **monitor_id** (int) - Optional - The ID of the monitor to retrieve.
- **with_downtimes** (bool) - Optional - Whether to include downtime information.

### Request Example
```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = MonitorsApi(api_client)

    # List all monitors
    monitors = api_instance.list_monitors()
    for monitor in monitors:
        print(f"Monitor: {monitor.name} (ID: {monitor.id})")

    # Get specific monitor with downtimes
    monitor_id = 12345
    monitor = api_instance.get_monitor(
        monitor_id=monitor_id,
        with_downtimes=True
    )
    print(f"Monitor details: {monitor}")
```

### Response
#### Success Response (200)
- **id** (int) - The ID of the monitor.
- **name** (str) - The name of the monitor.
- **type** (MonitorType) - The type of the monitor.
- **query** (str) - The monitor query.
- **message** (str) - The monitor message.
- **tags** (list[str]) - The monitor tags.
- **priority** (int) - The monitor priority.
- **options** (dict) - The monitor options.

#### Response Example
```json
{
  "id": 12345,
  "name": "High CPU Usage Alert",
  "type": "metric alert",
  "query": "avg(last_5m):avg:system.cpu.user{*} > 80",
  "message": "CPU usage is above 80%. Notify: @slack-ops-channel",
  "tags": ["env:production", "team:infrastructure"],
  "priority": 2,
  "options": {
    "thresholds": {"critical": 80, "warning": 70},
    "notify_no_data": true,
    "no_data_timeframe": 10,
    "renotify_interval": 60
  }
}
```
```

--------------------------------

### Create Datadog Dashboard

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Use this snippet to create a new Datadog dashboard with a timeseries widget. Ensure you have the necessary Datadog API client imports.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.dashboards_api import DashboardsApi
from datadog_api_client.v1.model.dashboard import Dashboard
from datadog_api_client.v1.model.dashboard_layout_type import DashboardLayoutType
from datadog_api_client.v1.model.timeseries_widget_definition import TimeseriesWidgetDefinition
from datadog_api_client.v1.model.timeseries_widget_definition_type import TimeseriesWidgetDefinitionType
from datadog_api_client.v1.model.timeseries_widget_request import TimeseriesWidgetRequest
from datadog_api_client.v1.model.widget import Widget
from datadog_api_client.v1.model.widget_layout import WidgetLayout

body = Dashboard(
    title="Infrastructure Overview",
    layout_type=DashboardLayoutType.ORDERED,
    description="Real-time infrastructure monitoring",
    widgets=[
        Widget(
            definition=TimeseriesWidgetDefinition(
                type=TimeseriesWidgetDefinitionType.TIMESERIES,
                title="CPU Usage by Host",
                requests=[
                    TimeseriesWidgetRequest(
                        q="avg:system.cpu.user{*}" by "{host}",
                        display_type="line",
                    ),
                ],
            ),
            layout=WidgetLayout(x=0, y=0, width=6, height=3),
        ),
    ],
    tags=["team:platform", "env:prod"],
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = DashboardsApi(api_client)
    response = api_instance.create_dashboard(body=body)
    print(f"Dashboard created: {response.url}")
```

--------------------------------

### Search Spans using Datadog API Client

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Query distributed traces and spans for application performance monitoring and debugging. Requires setting up the API client and defining the search query parameters.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.spans_api import SpansApi
from datadog_api_client.v2.model.spans_list_request import SpansListRequest
from datadog_api_client.v2.model.spans_list_request_data import SpansListRequestData
from datadog_api_client.v2.model.spans_list_request_attributes import SpansListRequestAttributes
from datadog_api_client.v2.model.spans_list_request_page import SpansListRequestPage
from datadog_api_client.v2.model.spans_list_request_type import SpansListRequestType
from datadog_api_client.v2.model.spans_query_filter import SpansQueryFilter
from datadog_api_client.v2.model.spans_sort import SpansSort

body = SpansListRequest(
    data=SpansListRequestData(
        type=SpansListRequestType.SEARCH_REQUEST,
        attributes=SpansListRequestAttributes(
            filter=SpansQueryFilter(
                query="service:payment-service @duration:>1s",
                _from="now-15m",
                to="now",
            ),
            page=SpansListRequestPage(limit=25),
            sort=SpansSort.TIMESTAMP_DESCENDING,
        ),
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = SpansApi(api_client)
    response = api_instance.list_spans(body=body)

    for span in response.data:
        print(f"Span: {span.attributes.resource_name} - {span.attributes.duration}ns")
```

--------------------------------

### Search Logs with Datadog API Client V2

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Queries and searches logs using the V2 API, allowing for advanced filtering, sorting, and pagination. Requires specific model imports for request body construction.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.logs_api import LogsApi
from datadog_api_client.v2.model.logs_list_request import LogsListRequest
from datadog_api_client.v2.model.logs_list_request_page import LogsListRequestPage
from datadog_api_client.v2.model.logs_query_filter import LogsQueryFilter
from datadog_api_client.v2.model.logs_query_options import LogsQueryOptions
from datadog_api_client.v2.model.logs_sort import LogsSort
from datadog_api_client.v2.model.logs_storage_tier import LogsStorageTier

body = LogsListRequest(
    filter=LogsQueryFilter(
        query="service:web-api @http.status_code:>=500",
        indexes=["main"],
        _from="now-1h",
        to="now",
        storage_tier=LogsStorageTier.INDEXES,
    ),
    options=LogsQueryOptions(timezone="UTC"),
    page=LogsListRequestPage(limit=50),
    sort=LogsSort.TIMESTAMP_DESCENDING,
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = LogsApi(api_client)
    response = api_instance.list_logs(body=body)

    for log in response.data:
        print(f"[{log.attributes.timestamp}] {log.attributes.message}")
```

--------------------------------

### Enable Request Logging

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Enable detailed logging of API requests by setting the `debug` flag to `True`.

```python
configuration.debug = True
```

--------------------------------

### Submit Metrics (V2)

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Submit metrics using the V2 API with enhanced resource metadata and tagging capabilities.

```APIDOC
## Submit Metrics (V2)

### Description
Submit metrics using the V2 API with enhanced resource metadata and tagging capabilities.

### Method
POST

### Endpoint
/api/v2/metrics

### Request Body
- **body** (MetricPayload) - Required - The request body to submit metrics.

### Request Example
```json
{
  "series": [
    {
      "metric": "app.request.latency",
      "type": "gauge",
      "points": [
        {
          "timestamp": 1678886400,
          "value": 0.125
        }
      ],
      "resources": [
        {
          "name": "web-server-01",
          "type": "host"
        },
        {
          "name": "us-east-1a",
          "type": "availability_zone"
        }
      ],
      "tags": ["env:production", "service:api", "endpoint:/users"]
    }
  ]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the metric submission.

#### Response Example
```json
{
  "status": "accepted"
}
```
```

--------------------------------

### Configure Custom Retry Policy

Source: https://github.com/datadog/datadog-api-client-python/blob/master/README.md

Provide a custom retry policy using `urllib3.util.Retry` for fine-grained control over retries. This overrides other retry settings.

```python
import urllib3
from datadog_api_client import Configuration

# Create a custom retry policy
custom_retry = urllib3.util.Retry(
    total=5,
    backoff_factor=2,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST", "PUT", "DELETE"]
)

configuration = Configuration(retry_policy=custom_retry)
```

--------------------------------

### Create Event API

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Allows sending custom events to Datadog for tracking deployments, alerts, or other significant occurrences.

```APIDOC
## POST /api/v1/events

### Description
Submits a custom event to Datadog.

### Method
POST

### Endpoint
/api/v1/events

### Parameters
#### Request Body
- **body** (EventCreateRequest) - Required - The event payload.
  - **title** (string) - Required - The title of the event.
  - **text** (string) - Required - The detailed text of the event.
  - **tags** (array of strings) - Optional - Tags to apply to the event.
  - **alert_type** (EventAlertType) - Optional - The type of alert (e.g., `success`, `info`, `warning`, `error`).
  - **priority** (EventPriority) - Optional - The priority of the event (e.g., `normal`, `low`).
  - **aggregation_key** (string) - Optional - An identifier to group similar events.
  - **source_type_name** (string) - Optional - The source type of the event.

### Request Example
```json
{
  "title": "Deployment completed",
  "text": "Application v2.1.0 deployed to production successfully",
  "tags": ["env:production", "service:api", "version:2.1.0"],
  "alert_type": "success",
  "priority": "normal",
  "aggregation_key": "deployment-api-prod",
  "source_type_name": "deployment"
}
```

### Response
#### Success Response (200)
- **event** (object) - The created event object.
  - **url** (string) - The URL of the created event.

#### Response Example
```json
{
  "event": {
    "url": "/event/12345abcde-6789-abcd-ef01-23456789abcd"
  }
}
```
```

--------------------------------

### List Datadog Users with Filter

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Query users with filtering capabilities for user management operations. The `filter` parameter accepts a string with query syntax.

```python
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.users_api import UsersApi

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = UsersApi(api_client)

    # List users with filter
    response = api_instance.list_users(
        filter="status:Active",
        page_size=50,
    )

    for user in response.data:
        print(f"User: {user.attributes.email} ({user.attributes.name})")
```

--------------------------------

### Submit Logs

Source: https://context7.com/datadog/datadog-api-client-python/llms.txt

Send log entries to Datadog for centralized log management, searching, and analysis.

```APIDOC
## POST /api/v1/logs

### Description
Send log entries to Datadog for centralized log management, searching, and analysis.

### Method
POST

### Endpoint
/api/v1/logs

### Request Body
- **body** (HTTPLog) - Required - The HTTP log payload.

### Request Example
```json
{
  "logs": [
    {
      "message": "User login successful",
      "ddsource": "python-app",
      "ddtags": "env:production,service:auth,version:1.0",
      "hostname": "web-server-01",
      "service": "authentication-service"
    },
    {
      "message": "{\"event\": \"order_placed\", \"order_id\": \"12345\", \"amount\": 99.99}",
      "ddsource": "python-app",
      "ddtags": "env:production,service:orders",
      "hostname": "api-server-01",
      "service": "order-service"
    }
  ]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the log submission.

#### Response Example
```json
{
  "status": "ok"
}
```
```