DevCycle Python Server SDK

Common errors

• RuntimeError: DevCycleClient not initialized.

  cause Attempting to evaluate variables or perform other operations before the SDK has finished its asynchronous initialization process (fetching initial configurations).
  fix Ensure you `await client.on_initialized()` before making any calls to `client.variable()` or other evaluation methods. Handle potential exceptions during initialization.

• AttributeError: 'DevCycle' object has no attribute 'variable'

  cause This error often occurs when upgrading from pre-v3.0.0 SDK versions without updating client initialization and method calls. The `DevCycle` class no longer exists; it's `DevCycleClient`.
  fix Refactor your code to use `DevCycleClient` and its `async` methods. For example, replace `client.variable()` with `await client.variable()` on the new `DevCycleClient` instance.

• RuntimeWarning: Enable tracemalloc to get the object allocation traceback

  cause This warning, often accompanied by `ResourceWarning: unclosed client session`, indicates that SDK resources (like HTTP sessions or background tasks) were not properly shut down before the application exited.
  fix Ensure `await client.close()` is called before your application's `asyncio` event loop terminates. This cleans up internal resources and prevents warnings related to unclosed connections.

• TypeError: object DevCycleClient can't be used in 'await' expression

  cause This occurs when you try to `await` the `DevCycleClient` instance itself, rather than one of its asynchronous methods (e.g., `on_initialized()`, `variable()`, `close()`).
  fix Only `await` specific asynchronous methods of the `DevCycleClient` object, such as `await client.on_initialized()` or `await client.variable(user, 'key', default_value)`.

Warnings

• breaking Version 3.0.0 introduced significant breaking changes, including a complete rewrite of the SDK. The `DevCycle` class was replaced with `DevCycleClient`, and the SDK shifted to an asynchronous (`asyncio`) programming model. Method signatures for initialization and variable evaluation changed substantially.
  Fix: Migrate existing code to use `DevCycleClient` and adapt to the `async`/`await` pattern. Ensure all SDK operations are awaited and handled within an `asyncio` event loop. Consult the official v3 migration guide if available or the latest README.
• gotcha The SDK is built on `asyncio`. Attempting to use `DevCycleClient` methods without `await` or outside a running `asyncio` event loop will lead to `RuntimeError` or unexpected behavior (e.g., tasks not completing).
  Fix: Always `await` calls to `client.on_initialized()`, `client.variable()`, `client.close()`, and other asynchronous methods. Ensure your application's entry point correctly uses `asyncio.run()` or manages the event loop for SDK operations.
• gotcha Incorrect or expired DevCycle Server SDK keys can lead to the SDK failing to fetch configurations or stopping polling for updates. This often results in default variable values being used or evaluation errors, without clear immediate indication in variable calls.
  Fix: Double-check that your `DEVCYCLE_SERVER_SDK_KEY` is valid, has the correct permissions (server-side, not client-side), and is passed correctly during `DevCycleClient` initialization. Monitor application logs for HTTP 401/403 errors from the DevCycle API that indicate an invalid key.
• gotcha The SDK offers both local bucketing (WASM) and cloud bucketing modes, controlled by `DevCycleOptions`. The default behavior for `enable_cloud_bucketing` can affect performance, network usage, and consistency if not explicitly configured.
  Fix: Explicitly set `enable_cloud_bucketing` in `DevCycleOptions` based on your requirements. For optimal performance and offline capabilities, set `enable_cloud_bucketing=False` and consider `DevCycleLocalBucketingOptions`. For simpler server-side integration that relies on DevCycle's cloud, set `enable_cloud_bucketing=True`.

Install

• pip install devcycle-python-server-sdk Install latest version

Imports

• DevCycleClient

  from devcycle_python_sdk import DevCycleClient

• DevCycleOptions

  from devcycle_python_sdk import DevCycleOptions

• DevCycleUser

  from devcycle_python_sdk import DevCycleUser

• DevCycleLocalBucketingOptions

  from devcycle_python_sdk import DevCycleLocalBucketingOptions

  Required for local bucketing (WASM) mode, instead of cloud bucketing.

Quickstart

Initializes the DevCycle client, waits for it to fetch configurations, defines a user, and evaluates a boolean and a string variable. It uses an environment variable for the SDK key and demonstrates asynchronous usage, which is mandatory for this SDK.

import os
import asyncio
from devcycle_python_sdk import DevCycleClient, DevCycleOptions, DevCycleUser

DEVCYCLE_SERVER_SDK_KEY = os.environ.get('DEVCYCLE_SERVER_SDK_KEY', '')

async def main():
    if not DEVCYCLE_SERVER_SDK_KEY:
        print("Error: DEVCYCLE_SERVER_SDK_KEY environment variable not set.")
        return

    # Configure options, e.g., enable cloud bucketing for server-side evaluation
    # By default, local bucketing (WASM) is used if not specified
    options = DevCycleOptions(enable_cloud_bucketing=True)
    client = DevCycleClient(DEVCYCLE_SERVER_SDK_KEY, options)

    try:
        # Wait for the client to be initialized and fetch configurations
        await client.on_initialized()
        print("DevCycle client initialized.")

        # Define a user for feature evaluation
        user = DevCycleUser(
            user_id="example-user",
            email="test@example.com",
            country="US"
        )

        # Evaluate a boolean variable
        feature_enabled = await client.variable(user, "my-feature", False)
        if feature_enabled.value:
            print("Feature 'my-feature' is ON for the user.")
        else:
            print("Feature 'my-feature' is OFF for the user.")

        # Evaluate a string variable
        welcome_message = await client.variable(user, "welcome-text", "Hello!")
        print(f"Welcome message for user: {welcome_message.value}")

    except Exception as e:
        print(f"An error occurred during DevCycle operations: {e}")
    finally:
        # Ensure the client is closed to release resources
        await client.close()
        print("DevCycle client closed.")

if __name__ == '__main__':
    asyncio.run(main())