Official documentation for Amplitude Experiment's server-side Python SDK implementation.

This documentation has separate sections for remote and local evaluation:

• Remote evaluation
• Local evaluation

Remote evaluation¶

Implements fetching variants for a user via remote evaluation.

Install¶

Install the Python Server SDK with pip.

pip install amplitude-experiment

from amplitude_experiment import Experiment, RemoteEvaluationConfig, RemoteEvaluationClient, User

# (1) Initialize the experiment client
experiment = Experiment.initialize('<DEPLOYMENT_KEY>')

# (2) Fetch variants for a user
user = User(
    device_id="abcdefg",
    user_id="user@company.com",
    user_properties={
        'premium': True
    }
)
variants = experiment.fetch(user)

# (3) Access a flag's variant
variant = variants['YOUR-FLAG-KEY']
if variant:
    if variant.value == 'on':
        # Flag is on
    else:
        # Flag is off

Initialize¶

The SDK client should be initialized in your server on startup. The deployment key argument passed into the api_key parameter must live within the same project that you are sending analytics events to.

Experiment.initialize_remote(api_key, config = None) : RemoteEvaluationClient

experiment = Experiment.initialize_remote('<DEPLOYMENT_KEY>', Config())

Configuration¶

You can configure the SDK client on initialization.

Fetch¶

Fetches variants for a user and returns the results. This function remote evaluates the user for flags associated with the deployment used to initialize the SDK client.

fetch(user: User) : Variants

user = User(
    device_id="abcdefg",
    user_id="user@company.com",
    user_properties={
        'premium': True
    }
)
variants = experiment.fetch(user)

After fetching variants for a user, you may to access the variant for a specific flag.

variant = variants['YOUR-FLAG-KEY']
if variant:
    if variant.value == 'on':
        # Flag is on
    else:
        # Flag is off

Fetch async¶

The fetch method is synchronous. To fetch asynchronously, you can use fetch_async method

fetch_async(user: User, callback)

def fetch_callback(user, variants):
  variant = variants['YOUR-FLAG-KEY']
  if variant:
    if variant.value == 'on':
      # Flag is on
    else:
      # Flag is off

experiment.fetch_async(user, fetch_callback)

Local evaluation¶

Implements evaluating variants for a user via local evaluation. If you plan on using local evaluation, you should understand the tradeoffs.

Install¶

Install the Python Server SDK's local evaluation.

Install the Python Server SDK with pip.

pip install amplitude-experiment

experiment.start()

# (3) Evaluate a user.

user = User( device_id="abcdefg", user_id="user@company.com", user_properties={ 'premium': True } ) variants = experiment.evaluate(user) ```

Initialize¶

Initializes a local evaluation client.

Experiment.initialize_local(api_key, config = None) : LocalEvaluationClient

Configuration¶

You can configure the SDK client on initialization.

Start¶

Start the local evaluation client, pre-fetching local evaluation mode flag configs for evaluation and starting the flag config poller at the configured interval.

start()

You should await the result of start() to ensure that flag configs are ready to be used before calling evaluate()

experiment.start()

Evaluate¶

Executes the evaluation logic using the flags pre-fetched on start(). Evaluate must be given a user object argument and can optionally be passed an array of flag keys if only a specific subset of required flag variants are required.

evaluate(self, user: User, flag_keys: List[str]) : Dict[str, Variant]

# The user to evaluate
user = User(user_id='test_user')

# Evaluate all flag variants
all_variants = experiment.evaluate(user)

# Evaluate a specific subset of flag variants
specific_variants = experiment.evaluate(user, ["<FLAG_KEY_1>", "<FLAG_KEY_2>"])

# Access a variant
variant = all_variants["<FLAG_KEY>"]
if variant.value == 'on':
    # Flag is on
else:
    # Flag is off

Access Amplitude cookies¶

If you're using the Amplitude Analytics SDK on the client-side, the Python server SDK provides an AmplitudeCookie class with convenience functions for parsing and interacting with the Amplitude identity cookie. This is useful for ensuring that the Device ID on the server matches the Device ID set on the client, especially if the client hasn't yet generated a Device ID.

import uuid
from amplitude_experiment import AmplitudeCookie

# grab amp device id if present
amp_cookie_name = AmplitudeCookie.cookie_name('amplitude-api-key')
device_id = nil
if request.cookies.get(amp_cookie_name):
  device_id = AmplitudeCookie.parse(request.cookies.get(amp_cookie_name)).device_id

if device_id is None:
  # deviceId doesn't exist, set the Amplitude Cookie
  device_id = str(uuid.uuid4())
  amp_cookie_value = AmplitudeCookie.generate(device_id)
  resp.set_cookie(amp_cookie_name, {
    "value": amp_cookie_value,
    "domain": ".yourdomain.com",  # this should be the same domain used by the Amplitude JS SDK
    "httponly": False,
    "secure": False
  })