Merge remote-tracking branch 'origin/master' into pk/events_uri

Conflicts:
	testing/test_integration.py

Author: pkaeding

demo/demo.py

@@ -4,4 +4,4 @@
 if __name__ == '__main__':
     apiKey = 'feefifofum'
     client = LDClient(apiKey)
-    print(client.api_key)
+    print(client.api_key)

demo/demo_twisted.py

@@ -18,4 +18,4 @@ def main(_):
     print("Value: {}".format(val))
 
 if __name__ == '__main__':
-    task.react(main)
+    task.react(main)

ldclient/__init__.py

@@ -7,11 +7,13 @@
 
 __LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
 
-__BUILTINS__ = ["key", "ip", "country", "email", "firstName", "lastName", "avatar", "name", "anonymous"]
+__BUILTINS__ = ["key", "ip", "country", "email",
+                "firstName", "lastName", "avatar", "name", "anonymous"]
 
 
 # Add a NullHandler for Python < 2.7 compatibility
 class NullHandler(logging.Handler):
+
     def emit(self, record):
         pass
 
@@ -32,4 +34,4 @@ def emit(self, record):
 try:
     from .twisted_impls import *
 except ImportError:
-    print("Twisted support not available")
+    pass

ldclient/client.py

@@ -22,6 +22,7 @@
 
 
 class Config(object):
+
     def __init__(self,
                  base_uri='https://app.launchdarkly.com',
                  events_uri='https://events.launchdarkly.com',
@@ -79,6 +80,7 @@ def default(cls):
 
 
 class InMemoryFeatureStore(FeatureStore):
+
     def __init__(self):
         self._lock = ReadWriteLock()
         self._initialized = False
@@ -142,6 +144,7 @@ def initialized(self):
 
 
 class LDClient(object):
+
     def __init__(self, api_key, config=None):
         check_uwsgi()
         self._api_key = api_key
@@ -152,15 +155,17 @@ def __init__(self, api_key, config=None):
         self._offline = False
         self._lock = Lock()
 
-        self._store = config.feature_store_class()
+        self._store = self._config.feature_store_class()
         """ :type: FeatureStore """
 
-        self._feature_requester = config.feature_requester_class(api_key, config)
+        self._feature_requester = self._config.feature_requester_class(
+            api_key, self._config)
         """ :type: FeatureRequester """
 
         self._stream_processor = None
         if self._config.stream:
-            self._stream_processor = config.stream_processor_class(api_key, config, self._store)
+            self._stream_processor = self._config.stream_processor_class(
+                api_key, self._config, self._store)
             self._stream_processor.start()
 
     @property
@@ -170,7 +175,8 @@ def api_key(self):
     def _check_consumer(self):
         with self._lock:
             if not self._consumer or not self._consumer.is_alive():
-                self._consumer = self._config.consumer_class(self._queue, self._api_key, self._config)
+                self._consumer = self._config.consumer_class(
+                    self._queue, self._api_key, self._config)
                 self._consumer.start()
 
     def _stop_consumers(self):
@@ -190,7 +196,8 @@ def _send(self, event):
             self._queue.put(event)
 
     def track(self, event_name, user, data=None):
-        self._send({'kind': 'custom', 'key': event_name, 'user': user, 'data': data})
+        self._send({'kind': 'custom', 'key': event_name,
+                    'user': user, 'data': data})
 
     def identify(self, user):
         self._send({'kind': 'identify', 'key': user['key'], 'user': user})
@@ -229,7 +236,8 @@ def cb(feature):
                 val = _evaluate(feature, user)
                 if val is None:
                     val = default
-            self._send({'kind': 'feature', 'key': key, 'user': user, 'value': val})
+            self._send({'kind': 'feature', 'key': key,
+                        'user': user, 'value': val})
             return val
 
         if self._config.stream and self._store.initialized:
@@ -239,7 +247,8 @@ def cb(feature):
             try:
                 return self._feature_requester.get(key, cb)
             except Exception:
-                log.exception('Unhandled exception. Returning default value for flag.')
+                log.exception(
+                    'Unhandled exception. Returning default value for flag.')
                 return cb(None)
 
-__all__ = ['LDClient', 'Config']
+__all__ = ['LDClient', 'Config']

ldclient/expiringdict.py

@@ -31,6 +31,7 @@
 
 
 class ExpiringDict(OrderedDict):
+
     def __init__(self, max_len, max_age_seconds):
         assert max_age_seconds >= 0
         assert max_len >= 1

ldclient/interfaces.py

@@ -129,4 +129,4 @@ def get(self, key, callback):
         :param callback: The function that accepts the feature data and returns the feature value
         :type callback: function
         :return: The feature value. None if not found
-        """
+        """

ldclient/noop.py

@@ -7,4 +7,4 @@ def __init__(self, *_):
         pass
 
     def get(self, key, callback):
-        return None
+        return None

ldclient/redis_requester.py

@@ -10,6 +10,7 @@ def create_redis_ldd_requester(api_key, config, **kwargs):
 
 
 class ForgetfulDict(dict):
+
     def __setitem__(self, key, value):
         pass
 
@@ -19,6 +20,7 @@ class RedisLDDRequester(FeatureRequester):
     Requests features from redis, usually stored via the LaunchDarkly Daemon (LDD).  Recommended to be combined
     with the ExpiringInMemoryFeatureStore
     """
+
     def __init__(self, config,
                  expiration=15,
                  redis_host='localhost',
@@ -36,7 +38,8 @@ def __init__(self, config,
 
     def _get_connection(self):
         if self._pool is None:
-            self._pool = redis.ConnectionPool(host=self._redis_host, port=self._redis_port)
+            self._pool = redis.ConnectionPool(
+                host=self._redis_host, port=self._redis_port)
         return redis.Redis(connection_pool=self._pool)
 
     def get(self, key, callback):

ldclient/requests.py

@@ -29,27 +29,32 @@ def do_toggle(should_retry):
             except ProtocolError as e:
                 inner = e.args[1]
                 if inner.errno == errno.ECONNRESET and should_retry:
-                    log.warning('ProtocolError exception caught while getting flag. Retrying.')
+                    log.warning(
+                        'ProtocolError exception caught while getting flag. Retrying.')
                     return do_toggle(False)
                 else:
-                    log.exception('Unhandled exception. Returning default value for flag.')
+                    log.exception(
+                        'Unhandled exception. Returning default value for flag.')
                     return None
             except Exception:
-                log.exception('Unhandled exception. Returning default value for flag.')
+                log.exception(
+                    'Unhandled exception. Returning default value for flag.')
                 return None
 
         return callback(do_toggle(True))
 
     def _toggle(self, key):
         hdrs = _headers(self._api_key)
         uri = self._config.base_uri + '/api/eval/features/' + key
-        r = self._session.get(uri, headers=hdrs, timeout=(self._config.connect, self._config.read))
+        r = self._session.get(uri, headers=hdrs, timeout=(
+            self._config.connect, self._config.read))
         r.raise_for_status()
         feature = r.json()
         return feature
 
 
 class RequestsStreamProcessor(Thread, StreamProcessor):
+
     def __init__(self, api_key, config, store):
         Thread.__init__(self)
         self.daemon = True
@@ -91,6 +96,7 @@ def process_message(store, msg):
 
 
 class RequestsEventConsumer(Thread, EventConsumer):
+
     def __init__(self, event_queue, api_key, config):
         Thread.__init__(self)
         self._session = requests.Session()
@@ -128,12 +134,15 @@ def do_send(should_retry):
             except ProtocolError as e:
                 inner = e.args[1]
                 if inner.errno == errno.ECONNRESET and should_retry:
-                    log.warning('ProtocolError exception caught while sending events. Retrying.')
+                    log.warning(
+                        'ProtocolError exception caught while sending events. Retrying.')
                     do_send(False)
                 else:
-                    log.exception('Unhandled exception in event consumer. Analytics events were not processed.')
+                    log.exception(
+                        'Unhandled exception in event consumer. Analytics events were not processed.')
             except:
-                log.exception('Unhandled exception in event consumer. Analytics events were not processed.')
+                log.exception(
+                    'Unhandled exception in event consumer. Analytics events were not processed.')
 
         try:
             do_send(True)
@@ -172,4 +181,4 @@ def next_item(self):
             item = q.get(block=True, timeout=5)
             return item
         except Exception:
-            return None
+            return None

ldclient/rwlock.py

@@ -37,4 +37,4 @@ def lock(self):
 
     def unlock(self):
         """ Release a write lock. """
-        self._read_ready.release()
+        self._read_ready.release()