Python SDK

pip install 'splitio_client[cpphash]==10.0.1'

from splitio import get_factory
from splitio.exceptions import TimeoutException

factory = get_factory('YOUR_SDK_KEY')
try:
    factory.block_until_ready(5) # wait up to 5 seconds
except TimeoutException:
    # Now the user can choose whether to abort the whole execution, or just keep going
    # without a ready client, which if configured properly, should become ready at some point.
    pass
split = factory.client()

pip install 'splitio_client[cpphash,asyncio]==10.0.1'

from splitio import get_factory_async
from splitio.exceptions import TimeoutException

async def main():
    factory = await get_factory_async('YOUR_SDK_KEY')
    try:
        await factory.block_until_ready(5) # wait up to 5 seconds
    except TimeoutException:
        # Now the user can choose whether to abort the whole execution, or just keep going
        # without a ready client, which if configured properly, should become ready at some point.
        pass
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

pip install 'splitio_client[redis,cpphash]==10.0.1'

pip install 'splitio_client[redis,cpphash,asyncio]==10.0.1'

pip install django_splitio[redis]==2.4.0

from splitio import get_factory

config = {
  'redisHost' : 'localhost',
  'redisPort' : 6379,
  'redisDb' : 0,
  'redisPassword' : 'somePassword',
  # if the user access is not the default 'root' user, inlcude parameter below
  'redisUsername' : 'username',
  # if you've set a redis prefix also include that in the config
  'redisPrefix' : 'your prefix that you defined'
}

factory = get_factory('YOUR_SDK_KEY', config=config)
split = factory.client()

from splitio import get_factory_async

async def main():
    config = {
    'redisHost' : 'localhost',
    'redisPort' : 6379,
    'redisDb' : 0,
    'redisPassword' : 'somePassword',
    # if the user access is not the default 'root' user, inlcude parameter below
    'redisUsername' : 'username',
    # if you've set a redis prefix also include that in the config
    'redisPrefix' : 'your prefix that you defined'
    }

    factory = await get_factory_async('YOUR_SDK_KEY', config=config)
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

# In your django config:
INSTALLED_APPS = (
        ...
        'django_splitio',
        ...
    )

SPLITIO = {
    'apiKey': 'YOUR_SDK_KEY',
    'labelsEnabled': True,
    'redisHost': 'localhost',
    'redisPort': 6379,
    'redisDb': 0,
    'redisPassword': 'somePassword'
    # if the user access is not the default 'root' user, inlcude parameter below
    'redisUsername' : 'username',
    # if you've set a redis prefix also include that in the config
    'redisPrefix' : 'your prefix that you defined'
}

# -------------------------

# in any module where the sdk is to be used.
from django_splitio import get_factory

factory = get_factory()
client = factory.client()

from splitio import get_factory

config = {
    'redisDb': 0,
    'redisPrefix': '',
    'redisSentinels': [('SENTINEL_HOST_1', SENTINEL_PORT_1), ('SENTINEL_HOST_2', SENTINEL_PORT_2), ('SENTINEL_HOST_3', SENTINEL_PORT_3)],
    'redisMasterService': 'SERVICE_MASTER_NAME',
    'redisSocketTimeout': 5
}

factory = get_factory('SDK_KEY', config=config)
split = factory.client()

from splitio import get_factory_async

async def main():
    config = {
        'redisDb': 0,
        'redisPrefix': '',
        'redisSentinels': [('SENTINEL_HOST_1', SENTINEL_PORT_1), ('SENTINEL_HOST_2', SENTINEL_PORT_2), ('SENTINEL_HOST_3', SENTINEL_PORT_3)],
        'redisMasterService': 'SERVICE_MASTER_NAME',
        'redisSocketTimeout': 5
    }

    factory = await get_factory_async('SDK_KEY', config=config)
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

# In your django config:
INSTALLED_APPS = (
        ...
        'django_splitio',
        ...
    )

SPLITIO = {
    'apiKey': 'YOUR_SDK_KEY',
    'labelsEnabled': True,
    'redisSentinels': [('SENTINEL_HOST_1', SENTINEL_PORT_1),   ('SENTINEL_HOST_2', SENTINEL_PORT_2), ('SENTINEL_HOST_3', SENTINEL_PORT_3)],
    'redisMasterService': 'SERVICE_MASTER_NAME',
    'redisDb': 0,
    'redisPassword': 'somePassword',
    'redisSocketTimeout': 5
    # if the user access is not the default 'root' user, inlcude parameter below
    'redisUsername' : 'username'
}

# -------------------------

# in any module where the sdk is to be used.
from django_splitio import get_factory

factory = get_factory()
client = factory.client()

uwsgi --http :8080 --chdir /var/app --wsgi-file ${WSGI_PATH} ${UWSGI_MODULE} --master
--processes ${UWSGI_NUM_PROCESSES} --uid ${UWSGI_UID} --gid ${UWSGI_GID} -t ${UWSGI_TIMEOUT}
--http-keepalive --add-header ${UWSGI_HEADERS} --buffer-size ${UWSGI_BUFFER_SIZE}
--enable-threads

import logging
import uwsgi
from uwsgidecorators import postfork  # Step 1


logging.basicConfig(level=logging.DEBUG)

# more code ...

SPLIT = get_factory(
    'YOUR_SDK_KEY',
    config={
        'preforkedInitialization': True,  # Step 2
    },
)


@postfork # Step 3
def post_fork_execution():
    SPLIT.resume()  # Step 4
    SPLIT.block_until_ready(5)

# more code ...

# In your django config:
INSTALLED_APPS = (
        ...
        'django_splitio',
        ...
    )
 SPLITIO = {
        'apiKey': 'YOUR_SDK_KEY',
        'preforkedInitialization': True # Step 2
    }
# -------------------------
# in setup Split module
from django_splitio import get_factory


global SPLIT


def setup():
    global SPLIT
    if 'SPLIT' in globals():
        return
    SPLIT = get_factory()

# in master module
import logging
import uwsgi
from uwsgidecorators import postfork  # Step 1
from django_splitio_testapp.split_wrapper import setup


logging.basicConfig(level=logging.DEBUG)
setup()


@postfork # Step 3
def post_fork():
    from django_splitio_testapp.split_wrapper import SPLIT
    SPLIT.resume() # Step 4
    SPLIT.block_until_ready(5)

# more code ...

# The key here represents the ID of the user/account/etc you're trying to evaluate a treatment for
treatment = split.get_treatment('key', 'FEATURE_FLAG_NAME')

if treatment == "on":
    # insert code here to show on treatment
elif treatment == "off":
    # insert code here to show off treatment
else:
    # insert your control treatment code here

# The key here represents the ID of the user/account/etc you're trying to evaluate a treatment for
treatment = await split.get_treatment('key', 'FEATURE_FLAG_NAME')

if treatment == "on":
    # insert code here to show on treatment
elif treatment == "off":
    # insert code here to show off treatment
else:
    # insert your control treatment code here

import arrow
from splitio import get_factory

factory = get_factory('YOUR_SDK_KEY')
split = factory.client()

attributes = dict()
attributes['plan_type'] = 'growth'
attributes['registered_date'] = arrow.utcnow().timestamp
attributes['deal_size'] = 1000
attributes['paying_customer'] = True

treatment = split.get_treatment("key", "FEATURE_FLAG_NAME", attributes)

if treatment == "on":
    # insert on code here
elif treatment == "off":
    # insert off code here
else:
    # insert control code here

import arrow
from splitio import get_factory_async

async def main():
    factory = await get_factory_async('YOUR_SDK_KEY')
    split = factory.client()

    attributes = dict()
    attributes['plan_type'] = 'growth'
    attributes['registered_date'] = arrow.utcnow().timestamp
    attributes['deal_size'] = 1000
    attributes['paying_customer'] = True

    treatment = await split.get_treatment("key", "FEATURE_FLAG_NAME", attributes)

    if treatment == "on":
        # insert on code here
    elif treatment == "off":
        # insert off code here
    else:
        # insert control code here

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

treatments = split.get_treatments('key', ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'])

print(treatments)

treatments = split.get_treatments_by_flag_set('key', 'backend')

print(treatments)

treatments = split.get_treatments_by_flag_sets('key', ['backend', 'server_side'])

print(treatments)

treatments = await split.get_treatments('key', ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'])

print(treatments)

treatments = await split.get_treatments_by_flag_set('key', 'backend')

print(treatments)

treatments = await split.get_treatments_by_flag_sets('key', ['backend', 'server_side'])

print(treatments)

treatment, raw_config = client.get_treatment_with_config('key', 'FEATURE_FLAG_NAME', attributes)
configs = json.loads(raw_config)

if treatment == 'on':
    # insert on code here and use configs here as necessary
else if treatment == 'off':
    # insert off code here and use configs here as necessary
else:
    # insert control code here

treatment, raw_config = await client.get_treatment_with_config('key', 'FEATURE_FLAG_NAME', attributes)
configs = json.loads(raw_config)

if treatment == 'on':
    # insert on code here and use configs here as necessary
else if treatment == 'off':
    # insert off code here and use configs here as necessary
else:
    # insert control code here

feature_flag_names = ['FEATURE_FLAG_1', 'FEATURE_FLAG_2']
split_results = client.get_treatments_with_config('key', feature_flag_names)

 # split_results will have the following form:
 # {
 #   'FEATURE_FLAG_1': ('on', '{"color": "red"}'),
 #   'FEATURE_FLAG_2': ('v2', '{"copy": "better copy"}')
 # }

attributes = {}
result = split.get_treatments_with_config_by_flag_set('key', 'backend', attributes)
for feature_flag, treatment_with_config in result.items():
  treatment = treatment_with_config[0]
  configs = treatment_with_config[1]
  print("Feature: %s, Treatment: %s, Config: %s" % (feature_flag, treatment, configs))

attributes = {}
result = split.get_treatments_with_config_by_flag_sets('key', 'backend', attributes)
for feature_flag, treatment_with_config in result.items():
  treatment = treatment_with_config[0]
  configs = treatment_with_config[1]
  print("Feature: %s, Treatment: %s, Config: %s" % (feature_flag, treatment, configs))

feature_flag_names = ['FEATURE_FLAG_1', 'FEATURE_FLAG_2']
split_results = await client.get_treatments_with_config('key', feature_flag_names)

 # split_results will have the following form:
 # {
 #   'FEATURE_FLAG_1': ('on', '{"color": "red"}'),
 #   'FEATURE_FLAG_2': ('v2', '{"copy": "better copy"}')
 # }

attributes = {}
result = await split.get_treatments_with_config_by_flag_set('key', 'backend', attributes)
for feature_flag, treatment_with_config in result.items():
  treatment = treatment_with_config[0]
  configs = treatment_with_config[1]
  print("Feature: %s, Treatment: %s, Config: %s" % (feature_flag, treatment, configs))

attributes = {}
result = await split.get_treatments_with_config_by_flag_sets('key', ['backend'], attributes)
for feature_flag, treatment_with_config in result.items():
  treatment = treatment_with_config[0]
  configs = treatment_with_config[1]
  print("Feature: %s, Treatment: %s, Config: %s" % (feature_flag, treatment, configs))

stop_event = threading.Event()
factory.destroy(stop_event)
stop_event.wait()
sys.exit(0)

await factory.destroy()
sys.exit(0)

# If you would like to send an event without a value
trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE")
# Example
trackEvent = client.track("john@doe.com", "user", "page_load_time")

# If you would like to associate a value to an event
trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", VALUE)
# Example
trackEvent = client.track("john@doe.com", "user", "page_load_time", 83.334)

# If you would like to associate just properties to an event
trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", None, {PROPERTIES})

# If you would like to associate a value and properties to an event
trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", VALUE, {PROPERTIES})
# Example
properties = {
    "package": "premium",
    "admin": true,
    "discount": 50
}
trackEvent = client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", 83.334, properties)

# If you would like to send an event without a value
trackEvent = await client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE")
# Example
trackEvent = await client.track("john@doe.com", "user", "page_load_time")

# If you would like to associate a value to an event
trackEvent = await client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", VALUE)
# Example
trackEvent = await client.track("john@doe.com", "user", "page_load_time", 83.334)

# If you would like to associate just properties to an event
trackEvent = await client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", None, {PROPERTIES})

# If you would like to associate a value and properties to an event
trackEvent = await client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", VALUE, {PROPERTIES})
# Example
properties = {
    "package": "premium",
    "admin": true,
    "discount": 50
}
trackEvent = await client.track("key", "TRAFFIC_TYPE", "EVENT_TYPE", 83.334, properties)

from splitio import get_factory

configuration = {
    'metricsRefreshRate' : 60,
    'impressionsRefreshRate' : 60,
    'ready' : 0,
    'connectionTimeout' : 1500,
    'readTimeout' : 1500,
    'labelsEnabled' : True
}

factory = get_factory('YOUR_SDK_KEY', config=configuration)
split = factory.client()

from splitio import get_factory_async

async def main():
    configuration = {
        'metricsRefreshRate' : 60,
        'impressionsRefreshRate' : 60,
        'ready' : 0,
        'connectionTimeout' : 1500,
        'readTimeout' : 1500,
        'labelsEnabled' : True
    }

    factory = await get_factory_async('YOUR_SDK_KEY', config=configuration)
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

SPLITIO = {
    'apiKey': 'YOUR_SDK_KEY',
    'labelsEnabled': True,
    'redisHost': 'localhost',
    'redisPort': 6379,
    'redisDb': 0,
    'redisPassword': 'somePassword',
    # if the user access is not the default 'root' user, inlcude parameter below
    'redisUsername' : 'username',
      'featuresRefreshRate': 5,
    'segmentsRefreshRate' : 60,
    'metricsRefreshRate' : 60,
    'impressionsRefreshRate' : 60,
}

class SplitChange(object):
    """SplitChange class"""

    @prperty
    def splits(self):
    """return splits"
        return self._splits

    @property
    def since(self):
    """return since epoch time"""
        return self._since

    @property
    def till(self)
    """return till epoch time"""
        return self._till

class Split(object):
    """Split model object."""

    @property
    def name(self):
        """Return name."""
        return self._name

    @property
    def seed(self):
        """Return seed."""
        return self._seed

    @property
    def algo(self):
        """Return hash algorithm."""
        return self._algo

    @property
    def killed(self):
        """Return whether the feature flag has been killed."""
        return self._killed

    @property
    def default_treatment(self):
        """Return the default treatment."""
        return self._default_treatment

    @property
    def traffic_type_name(self):
        """Return the traffic type of the feature flag."""
        return self._traffic_type_name

    @property
    def status(self):
        """Return the status of the feature flag."""
        return self._status

    @property
    def change_number(self):
        """Return the change number of the feature flag."""
        return self._change_number

    @property
    def conditions(self):
        """Return the condition list of the feature flag."""
        return self._conditions

    @property
    def traffic_allocation(self):
        """Return the traffic allocation percentage of the feature flag."""
        return self._traffic_allocation

    @property
    def traffic_allocation_seed(self):
        """Return the traffic allocation seed of the feature flag."""
        return self._traffic_allocation_seed

{
  "splits": [
    {
      "trafficTypeName": "user",
      "name": "feature_flag_1",
      "trafficAllocation": 100,
      "trafficAllocationSeed": -1364119282,
      "seed": -605938843,
      "status": "ACTIVE",
      "killed": false,
      "defaultTreatment": "off",
      "changeNumber": 1660326991072,
      "algo": 2,
      "configurations": {},
      "conditions": [
        {
          "conditionType": "ROLLOUT",
          "matcherGroup": {
            "combiner": "AND",
            "matchers": [
              {
                "keySelector": {
                  "trafficType": "user",
                  "attribute": null
                },
                "matcherType": "IN_SEGMENT",
                "negate": false,
                "userDefinedSegmentMatcherData": {
                  "segmentName": "segment_1"
                },
                "whitelistMatcherData": null,
                "unaryNumericMatcherData": null,
                "betweenMatcherData": null,
                "booleanMatcherData": null,
                "dependencyMatcherData": null,
                "stringMatcherData": null
              }
            ]
          },
          "partitions": [
            {
              "treatment": "on",
              "size": 0
            },
            {
              "treatment": "off",
              "size": 100
            }
          ],
          "label": "in segment segment_1"
        },
        {
          "conditionType": "ROLLOUT",
          "matcherGroup": {
            "combiner": "AND",
            "matchers": [
              {
                "keySelector": {
                  "trafficType": "user",
                  "attribute": null
                },
                "matcherType": "ALL_KEYS",
                "negate": false,
                "userDefinedSegmentMatcherData": null,
                "whitelistMatcherData": null,
                "unaryNumericMatcherData": null,
                "betweenMatcherData": null,
                "booleanMatcherData": null,
                "dependencyMatcherData": null,
                "stringMatcherData": null
              }
            ]
          },
          "partitions": [
            {
              "treatment": "on",
              "size": 50
            },
            {
              "treatment": "off",
              "size": 50
            }
          ],
          "label": "default rule"
        }
      ]
    }
  ],
  "since": -1,
  "till": 1660326991072
}

class SegmentChange(object):
    """SegmentChange object class."""

    @property
    def name(self):
        """Return segment name."""
        return self._name

    @property
    def added(self):
        """Return the segment keys to be added."""
        return self._added

    @property
    def removed(self):
        """Return the segment keys to be removed."""
        return self._removed

    @property
    def since(self):
    """return since epoch time"""
        return self._since

    @property
    def till(self)
    """return till epoch time"""
        return self._till

{
  "name": "segment_1",
  "added": [
    "example1",
    "example2"
  ],
  "removed": [],
  "since": -1,
  "till": 1585948850110
}

config = {
            'splitFile': 'parentRoot/splits.json',
            'segmentDirectory': '/parentRoot/segments',
            'localhostRefreshEnabled': True
        }
factory = get_factory('localhost', config = config)

try:
    factory.block_until_ready(5) # wait up to 5 seconds
except TimeoutException:
    print("SDK TIMED OUT")

from splitio import get_factory_async

async def main():
    config = {
                'splitFile': 'parentRoot/splits.json',
                'segmentDirectory': '/parentRoot/segments',
                'localhostRefreshEnabled': True
            }
    factory = await get_factory_async('localhost', config = config)

    try:
        await factory.block_until_ready(5) # wait up to 5 seconds
    except TimeoutException:
        print("SDK TIMED OUT")

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

# - feature_flag_name:
#     treatment: "treatment_applied_to_this_entry"
#     keys: "single_key_or_list"
#     config: "{\"desc\" : \"this applies only to ON treatment\"}"

- my_feature_flag:
    treatment: "on"
    keys: "key"
    config: "{\"desc\" : \"this applies only to ON treatment\"}"
- some_other_feature_flag:
    treatment: "off"
- my_feature_flag:
    treatment: "off"

from splitio import get_factory

factory = get_factory('localhost')
split = factory.client()

from splitio import get_factory_async

async def main():
    factory = await get_factory_async('localhost')
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

# sdk.get_treatment(*, reporting_v2) returns 'on'
reporting_v2 on

double_writes_to_cassandra off

new-navigation v3

split = factory.client()
manager = factory.manager()

class SplitManager(object):
    def split_names(self):
        """Returns the names of feature flags registered with the SDK. Subclasses need to override this method.
        :return: A list of str
        :rtype: list
        """
        raise NotImplementedError()

        def splits(self):
        """Retrieves the feature flags that are currently registered with the SDK. Subclasses need to override this method.
        :return: A List of SplitView.
        :rtype: list
        """
        raise NotImplementedError()

    def split(self, feature_flag_name):
        """Returns the Feature Flag registered with the SDK of this name. Subclasses need to override this method.
        :return: The SplitView instance.
        :rtype: SplitView
        """
        raise NotImplementedError()

class SplitManagerAsync(object):
    async def split_names(self):
        """Returns the names of feature flags registered with the SDK. Subclasses need to override this method.
        :return: A list of str
        :rtype: list
        """
        raise NotImplementedError()

    async def splits(self):
        """Retrieves the feature flags that are currently registered with the SDK. Subclasses need to override this method.
        :return: A List of SplitView.
        :rtype: list
        """
        raise NotImplementedError()

    async def split(self, feature_flag_name):
        """Returns the Feature Flag registered with the SDK of this name. Subclasses need to override this method.
        :return: The SplitView instance.
        :rtype: SplitView
        """
        raise NotImplementedError()

SplitView = namedtuple('SplitView', ['name', 'traffic_type', 'killed', 'treatments', 'change_number', 'configs', 'default_treatment', 'sets'])

# Import ImpressionListener interface
from splitio.impressions import ImpressionListener

# Implementation Sample for a Custom Impression Listener
class CustomImpressionListener(ImpressionListener)
{
  def log_impression(self, data):
    # Custom behavior
}

# Import ImpressionListener interface
from splitio.impressions import ImpressionListener

# Implementation Sample for a Custom Impression Listener
class CustomImpressionListener(ImpressionListener)
{
  async def log_impression(self, data):
    # Custom behavior
}

from splitio import get_factory

factory = get_factory(
  'YOUR_SDK_KEY',
  config={
    # ...
    'impressionListener': CustomImpressionListener()
  },
  # ...
)
split = factory.client()

from splitio import get_factory_async

async def main():
    factory = await get_factory_async(
    'YOUR_SDK_KEY',
    config={
        # ...
        'impressionListener': CustomImpressionListener()
    },
    # ...
    )
    split = factory.client()

loop = asyncio.new_event_loop()
loop.run_until_complete(main())

import logging
logger = logging.getLogger('splitio')
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.WARNING)

import asyncio
import logging
import logging.handlers
import time
from queue import SimpleQueue
from splitio import get_factory

queue = SimpleQueue()
queue_handler = logging.handlers.QueueHandler(queue)
listener = logging.handlers.QueueListener(
    queue,
    logging.StreamHandler(),
    logging.FileHandler('split.log'),
)
logger = logging.getLogger()
logFormatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
queue_handler.setFormatter(logFormatter)
logger.addHandler(queue_handler)
logger.setLevel('DEBUG')
logger.propagate = False
lhStdout = logger.handlers[0]
logger.removeHandler(lhStdout)

listener.start()

async def main():
    factory = get_factory('YOUR_SDK_KEY')
    split = factory.client()

try:
    loop = asyncio.new_event_loop()
    loop.run_until_complete(main())
finally:
    listener.stop()

import logging

#Set logging configuration.
logging.basicConfig(filename='example.log',level=logging.WARNING)

$ export HTTP_PROXY="http://10.10.1.10:3128"
$ export HTTPS_PROXY="http://10.10.1.10:1080"