Python Server SDK

user = StatsigUser("a-user")

if statsig.check_gate(user, "a_gate"):
    # Gate is on, enable new feature
else:
    # Gate is off

# Get a dynamic config for a specific user
config = statsig.get_dynamic_config(StatsigUser("my_user"), "a_config")

# Access config values with type-safe getters and fallback values
product_name = config.get_string("product_name", "Awesome Product v1")  # returns String
price = config.get_float("price", 10.0)  # returns float
should_discount = config.get_bool("discount", False)  # returns bool
quantity = config.get_integer("quantity", 1)  # returns int64

# Advanced Usage:
# You can disable exposure logging for this specific check
options = DynamicConfigEvaluationOptions(disable_exposure_logging=True)
config = statsig.get_dynamic_config(user, "a_config", options)

# The config object also provides metadata about the evaluation
print(config.rule_id)  # The ID of the rule that served this config
print(config.id_type)  # The type of the evaluation (experiment, config, etc)

# Values via get_layer
layer = statsig.get_layer(StatsigUser("my_user"), "user_promo_experiments")
title = layer.get_string("title", "Welcome to Statsig!")
discount = layer.get_float("discount", 0.1)

# Via get_experiment
title_exp = statsig.get_experiment(StatsigUser("my_user"), "new_user_promo_title")
price_exp = statsig.get_experiment(StatsigUser("my_user"), "new_user_promo_price")

title = title_exp.get_string("title", "Welcome to Statsig!")
discount = price_exp.get_float("discount", 0.1)

gate = statsig.get_feature_gate(user, "example_gate")
print(gate.rule_id)
print(gate.value)

# Get a Parameter Store by name
param_store = statsig.get_parameter_store(user, "my_parameter_store")

# String parameters
string_value = param_store.get_string("string_param", "default_value")

# Boolean parameters
bool_value = param_store.get_bool("bool_param", False)

# Numeric parameters
float_value = param_store.get_float("float_param", 0.0)
integer_value = param_store.get_integer("integer_param", 0)

# Complex parameters
default_array = ["item1", "item2"]
array_value = param_store.get_array("array_param", default_array)

default_map = {"key": "value"}
map_value = param_store.get_map("map_param", default_map)

from statsig_python_core import ParameterStoreEvaluationOptions

options = ParameterStoreEvaluationOptions(disable_exposure_logging=True)
param_store = statsig.get_parameter_store(user, "my_parameter_store", options)

statsig.log_event(
    user=StatsigUser("user_id"),  # Replace with your user object
    event_name="add_to_cart",
    value="SKU_12345",
    metadata={
        "price": "9.99",
        "item_name": "diet_coke_48_pack"
    }
)

user = StatsigUser(
    user_id="a-user",
    custom={
        "service": "my-service",
        "pod": "my-pod",
        "namespace": "my-namespace",
        "container": "my-container",
        # ...include any service-specific metadata
    }
)

# levels: trace, debug, info, log, warn, error
statsig.forward_log_line_event(user, "warn", "script failed to load", {
    "custom_metadata": "script_name:my-script"
    # ... include any event-specific metadata
})

# Create a shared instance that can be accessed globally
statsig = Statsig.new_shared("secret-key", options)
statsig.initialize().wait()

# Access the shared instance from anywhere in your code
shared_statsig = Statsig.shared()
is_feature_enabled = shared_statsig.check_gate(StatsigUser("user_id"), "feature_name")

# Check if a shared instance exists
if Statsig.has_shared_instance():
    # Use the shared instance
    pass

# Remove the shared instance when no longer needed
Statsig.remove_shared()

statsig.shutdown().wait()

# Overrides the given gate to the specified value
statsig.override_gate("a_gate_name", True)
	
# Overrides the given dynamic config to the provided value
statsig.override_dynamic_config("a_config_name", {"key": "value"})

# Overrides the given experiment to the provided value
statsig.override_experiment("an_experiment_name", {"key": "value"})
	
# Overrides the given layer to the provided value
statsig.override_layer("a_layer_name", {"key": "value"})

# Overrides the given experiment to a particular groupname, available for experiments only:
statsig.override_experiment_by_group_name("an_experiment_name", "a_group_name")

import json
from statsig_python_core import Statsig, StatsigUser

# Get client initialize response for a user
response_data = statsig.get_client_initialize_response(user)
response = json.loads(response_data)

# Pass response to a client SDK to initialize without a network request

class PersistentStorage(PersistentStorageBaseClass):
    def __init__():
        # When you initialize, remember to call super.__init__()
        super().__init__()

    def load(self, key: str) -> Optional[UserPersistedValues]:
        """
        Load persisted values for a user from storage

        Args:
            key: A string key that uniquely identifies a user

        Returns:
            Dictionary mapping config names to their persisted values
        """
        pass

    def save(self, key: str, config_name: str, data: StickyValues):
        """
        Save a persistent value for a user

        Args:
            key: A string key that uniquely identifies a user
            config_name: The name of the config/experiment
            data: The values to persist
        """
        pass

    def delete(self, key: str, config_name: str):
        """
        Delete a persistent value for a user

        Args:
            key: A string key that uniquely identifies a user
            config_name: The name of the config/experiment to delete
        """
        pass

class DataStore(DataStoreBase):
    def initialize(self):
        """
        Initialize the data store. Called when the Statsig client initializes.
        """
        pass

    def shutdown(self):
        """
        Clean up resources when the Statsig client shuts down.
        """
        pass

    def get(self, key: str) -> Optional[DataStoreResponse]:
        """
        Retrieve value from the data store.
        
        Args:
            key: The key to retrieve the value for
            
        Returns:
            DataStoreResponse containing the result and time
        """
        pass

    def set(self, key: str, value: str, time: Optional[int] = None):
        """
        Store a value in the data store.
        
        Args:
            key: The key to store the value under
            value: The value to store
            time: Optional timestamp
        """
        pass

    def support_polling_updates_for(self, key: str) -> bool:
        """
        Whether the data store supports polling for updates for the given key.
        
        Args:
            key: The key to check
            
        Returns:
            True if polling is supported, False otherwise
        """
        return False

class OutputLoggerProvider(OutputLoggerProviderBase):
    def init(self):
        """
        Initialize the logger. Called when the Statsig client initializes.
        """
        pass

    def debug(self, tag: str, msg: str):
        """
        Log a debug message.
        
        Args:
            tag: Category/component tag for the message
            msg: The message to log
        """
        pass

    def info(self, tag: str, msg: str):
        """
        Log an info message.
        
        Args:
            tag: Category/component tag for the message
            msg: The message to log
        """
        pass

    def warn(self, tag: str, msg: str):
        """
        Log a warning message.
        
        Args:
            tag: Category/component tag for the message
            msg: The message to log
        """
        pass

    def error(self, tag: str, msg: str):
        """
        Log an error message.
        
        Args:
            tag: Category/component tag for the message
            msg: The message to log
        """
        pass

    def shutdown(self):
        """
        Clean up resources when the Statsig client shuts down.
        """
        pass

class ObservabilityClient(ObservabilityClientBase):
    def init(self):
        """
        Initialize the observability client. Called when the Statsig client initializes.
        """
        pass

    def increment(self, metric_name: str, value: float, tags: Optional[Dict[str, str]] = None):
        """
        Report a counter metric.
        
        Args:
            metric_name: The name of the metric
            value: The amount to increment by
            tags: Optional tags to associate with the metric
        """
        pass

    def gauge(self, metric_name: str, value: float, tags: Optional[Dict[str, str]] = None):
        """
        Report a gauge metric.
        
        Args:
            metric_name: The name of the metric
            value: The current value
            tags: Optional tags to associate with the metric
        """
        pass

    def dist(self, metric_name: str, value: float, tags: Optional[Dict[str, str]] = None):
        """
        Report a distribution metric.
        
        Args:
            metric_name: The name of the metric
            value: The value to record
            tags: Optional tags to associate with the metric
        """
        pass

    def error(self, tag: str, error: str):
        """
        Report an error.
        
        Args:
            tag: Category/component tag for the error
            error: The error message
        """
        pass

    def should_enable_high_cardinality_for_this_tag(self, tag: str) -> bool:
        """
        Determine if high cardinality should be enabled for a tag.
        
        Args:
            tag: The tag to check
            
        Returns:
            True if high cardinality should be enabled, False otherwise
        """
        pass