pax_global_header00006660000000000000000000000064130221644400014506gustar00rootroot0000000000000052 comment=2933866e9bd98eeee23d885369529ce59b8ed6a9 rudder-sdk-python-1.2.6/000077500000000000000000000000001302216444000150775ustar00rootroot00000000000000rudder-sdk-python-1.2.6/.gitignore000066400000000000000000000000731302216444000170670ustar00rootroot00000000000000**sublime** *.pyc dist *.egg-info dist MANIFEST build .eggsrudder-sdk-python-1.2.6/.travis.yml000066400000000000000000000002261302216444000172100ustar00rootroot00000000000000language: python python: - "2.6" - "2.7" - "3.3" - "3.4" - "3.5" install: - "pip install ." script: make test matrix: fast_finish: true rudder-sdk-python-1.2.6/HISTORY.md000066400000000000000000000044521302216444000165670ustar00rootroot00000000000000 1.2.6 / 2016-12-07 ================== * dont add messages to the queue if send is false * drop py32 support 1.2.5 / 2016-07-02 ================== * Fix outdated python-dateutil<2 requirement for python2 - dateutil > 2.1 runs is python2 compatible * Fix a bug introduced in 1.2.4 where we could try to join a thread that was not yet started 1.2.4 / 2016-06-06 ================== * Fix race conditions in overflow and flush tests * Join daemon thread on interpreter exit to prevetn valueerrors * Capitalize HISTORY.md (#76) * Quick fix for Decimal to send as a float 1.2.3 / 2016-03-23 ================== * relaxing requests dep 1.2.2 / 2016-03-17 ================== * Fix environment markers definition * Use proper way for defining conditional dependencies 1.2.1 / 2016-03-11 ================== * fixing requirements.txt 1.2.0 / 2016-03-11 ================== * adding versioned requirements.txt file 1.1.0 / 2015-06-23 ================== * Adding fixes for handling invalid json types * Fixing byte/bytearray handling * Adding `logging.DEBUG` fix for `setLevel` * Support HTTP keep-alive using a Session connection pool * Suppport universal wheels * adding .sentAt * make it really testable * fixing overflow test * removing .io's * Update README.md * spacing 1.0.3 / 2014-09-30 ================== * adding top level send option 1.0.2 / 2014-09-17 ================== * fixing debug logging levels 1.0.1 / 2014-09-08 ================== * fixing unicode handling, for write_key and events * adding six to requirements.txt and install scripts 1.0.0 / 2014-09-05 ================== * updating to spec 1.0 * adding python3 support * moving to analytics.write_key API * moving consumer to a separate thread * adding request retries * making analytics.flush() syncrhonous * adding full travis tests 0.4.4 / 2013-11-21 ================== * add < python 2.7 compatibility by removing `delta.total_seconds` 0.4.3 / 2013-11-13 ================== * added datetime serialization fix (alexlouden) 0.4.2 / 2013-06-26 ================== * Added history.d change log * Merging https://github.com/segmentio/analytics-python/pull/14 to add support for lists and PEP8 fixes. Thanks https://github.com/dfee! * Fixing #12, adding static public API to analytics.__init__ rudder-sdk-python-1.2.6/MANIFEST.in000066400000000000000000000000221302216444000166270ustar00rootroot00000000000000include README.md rudder-sdk-python-1.2.6/Makefile000066400000000000000000000001401302216444000165320ustar00rootroot00000000000000 test: python setup.py test dist: python setup.py sdist bdist_wheel upload .PHONY: test distrudder-sdk-python-1.2.6/README.md000066400000000000000000000032251302216444000163600ustar00rootroot00000000000000analytics-python ============== [![Build Status](https://travis-ci.org/segmentio/analytics-python.svg?branch=master)](https://travis-ci.org/segmentio/analytics-python) analytics-python is a python client for [Segment](https://segment.com) ## Documentation Documentation is available at [https://segment.com/libraries/python](https://segment.com/libraries/python). ## License ``` WWWWWW||WWWWWW W W W||W W W || ( OO )__________ / | \ /o o| MIT \ \___/||_||__||_|| * || || || || _||_|| _||_|| (__|__|(__|__| ``` (The MIT License) Copyright (c) 2013 Segment Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. rudder-sdk-python-1.2.6/analytics/000077500000000000000000000000001302216444000170665ustar00rootroot00000000000000rudder-sdk-python-1.2.6/analytics/__init__.py000066400000000000000000000024061302216444000212010ustar00rootroot00000000000000 from analytics.version import VERSION from analytics.client import Client __version__ = VERSION """Settings.""" write_key = None on_error = None debug = False send = True default_client = None def track(*args, **kwargs): """Send a track call.""" _proxy('track', *args, **kwargs) def identify(*args, **kwargs): """Send a identify call.""" _proxy('identify', *args, **kwargs) def group(*args, **kwargs): """Send a group call.""" _proxy('group', *args, **kwargs) def alias(*args, **kwargs): """Send a alias call.""" _proxy('alias', *args, **kwargs) def page(*args, **kwargs): """Send a page call.""" _proxy('page', *args, **kwargs) def screen(*args, **kwargs): """Send a screen call.""" _proxy('screen', *args, **kwargs) def flush(): """Tell the client to flush.""" _proxy('flush') def join(): """Block program until the client clears the queue""" _proxy('join') def _proxy(method, *args, **kwargs): """Create an analytics client if one doesn't exist and send to it.""" global default_client if not default_client: default_client = Client(write_key, debug=debug, on_error=on_error, send=send) fn = getattr(default_client, method) fn(*args, **kwargs) rudder-sdk-python-1.2.6/analytics/client.py000066400000000000000000000177241302216444000207310ustar00rootroot00000000000000from datetime import datetime from uuid import uuid4 import logging import numbers import atexit from dateutil.tz import tzutc from six import string_types from analytics.utils import guess_timezone, clean from analytics.consumer import Consumer from analytics.version import VERSION try: import queue except: import Queue as queue ID_TYPES = (numbers.Number, string_types) class Client(object): """Create a new Segment client.""" log = logging.getLogger('segment') def __init__(self, write_key=None, debug=False, max_queue_size=10000, send=True, on_error=None): require('write_key', write_key, string_types) self.queue = queue.Queue(max_queue_size) self.consumer = Consumer(self.queue, write_key, on_error=on_error) self.write_key = write_key self.on_error = on_error self.debug = debug self.send = send if debug: self.log.setLevel(logging.DEBUG) # if we've disabled sending, just don't start the consumer if send: # On program exit, allow the consumer thread to exit cleanly. # This prevents exceptions and a messy shutdown when the interpreter is # destroyed before the daemon thread finishes execution. However, it # is *not* the same as flushing the queue! To guarantee all messages # have been delivered, you'll still need to call flush(). atexit.register(self.join) self.consumer.start() def identify(self, user_id=None, traits=None, context=None, timestamp=None, anonymous_id=None, integrations=None): traits = traits or {} context = context or {} integrations = integrations or {} require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES) require('traits', traits, dict) msg = { 'integrations': integrations, 'anonymousId': anonymous_id, 'timestamp': timestamp, 'context': context, 'type': 'identify', 'userId': user_id, 'traits': traits } return self._enqueue(msg) def track(self, user_id=None, event=None, properties=None, context=None, timestamp=None, anonymous_id=None, integrations=None): properties = properties or {} context = context or {} integrations = integrations or {} require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES) require('properties', properties, dict) require('event', event, string_types) msg = { 'integrations': integrations, 'anonymousId': anonymous_id, 'properties': properties, 'timestamp': timestamp, 'context': context, 'userId': user_id, 'type': 'track', 'event': event } return self._enqueue(msg) def alias(self, previous_id=None, user_id=None, context=None, timestamp=None, integrations=None): context = context or {} integrations = integrations or {} require('previous_id', previous_id, ID_TYPES) require('user_id', user_id, ID_TYPES) msg = { 'integrations': integrations, 'previousId': previous_id, 'timestamp': timestamp, 'context': context, 'userId': user_id, 'type': 'alias' } return self._enqueue(msg) def group(self, user_id=None, group_id=None, traits=None, context=None, timestamp=None, anonymous_id=None, integrations=None): traits = traits or {} context = context or {} integrations = integrations or {} require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES) require('group_id', group_id, ID_TYPES) require('traits', traits, dict) msg = { 'integrations': integrations, 'anonymousId': anonymous_id, 'timestamp': timestamp, 'groupId': group_id, 'context': context, 'userId': user_id, 'traits': traits, 'type': 'group' } return self._enqueue(msg) def page(self, user_id=None, category=None, name=None, properties=None, context=None, timestamp=None, anonymous_id=None, integrations=None): properties = properties or {} context = context or {} integrations = integrations or {} require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES) require('properties', properties, dict) if name: require('name', name, string_types) if category: require('category', category, string_types) msg = { 'integrations': integrations, 'anonymousId': anonymous_id, 'properties': properties, 'timestamp': timestamp, 'category': category, 'context': context, 'userId': user_id, 'type': 'page', 'name': name, } return self._enqueue(msg) def screen(self, user_id=None, category=None, name=None, properties=None, context=None, timestamp=None, anonymous_id=None, integrations=None): properties = properties or {} context = context or {} integrations = integrations or {} require('user_id or anonymous_id', user_id or anonymous_id, ID_TYPES) require('properties', properties, dict) if name: require('name', name, string_types) if category: require('category', category, string_types) msg = { 'integrations': integrations, 'anonymousId': anonymous_id, 'properties': properties, 'timestamp': timestamp, 'category': category, 'context': context, 'userId': user_id, 'type': 'screen', 'name': name, } return self._enqueue(msg) def _enqueue(self, msg): """Push a new `msg` onto the queue, return `(success, msg)`""" timestamp = msg['timestamp'] if timestamp is None: timestamp = datetime.utcnow().replace(tzinfo=tzutc()) require('integrations', msg['integrations'], dict) require('type', msg['type'], string_types) require('timestamp', timestamp, datetime) require('context', msg['context'], dict) # add common timestamp = guess_timezone(timestamp) msg['timestamp'] = timestamp.isoformat() msg['messageId'] = str(uuid4()) msg['context']['library'] = { 'name': 'analytics-python', 'version': VERSION } msg = clean(msg) self.log.debug('queueing: %s', msg) # if send is False, return msg as if it was successfully queued if not self.send: return True, msg try: self.queue.put(msg, block=False) self.log.debug('enqueued %s.', msg['type']) return True, msg except queue.Full: self.log.warn('analytics-python queue is full') return False, msg def flush(self): """Forces a flush from the internal queue to the server""" queue = self.queue size = queue.qsize() queue.join() # Note that this message may not be precise, because of threading. self.log.debug('successfully flushed about %s items.', size) def join(self): """Ends the consumer thread once the queue is empty. Blocks execution until finished""" self.consumer.pause() try: self.consumer.join() except RuntimeError: # consumer thread has not started pass def require(name, field, data_type): """Require that the named `field` has the right `data_type`""" if not isinstance(field, data_type): msg = '{0} must have {1}, got: {2}'.format(name, data_type, field) raise AssertionError(msg) rudder-sdk-python-1.2.6/analytics/consumer.py000066400000000000000000000050021302216444000212700ustar00rootroot00000000000000import logging from threading import Thread from analytics.version import VERSION from analytics.request import post try: from queue import Empty except: from Queue import Empty class Consumer(Thread): """Consumes the messages from the client's queue.""" log = logging.getLogger('segment') def __init__(self, queue, write_key, upload_size=100, on_error=None): """Create a consumer thread.""" Thread.__init__(self) # Make consumer a daemon thread so that it doesn't block program exit self.daemon = True self.upload_size = upload_size self.write_key = write_key self.on_error = on_error self.queue = queue # It's important to set running in the constructor: if we are asked to # pause immediately after construction, we might set running to True in # run() *after* we set it to False in pause... and keep running forever. self.running = True self.retries = 3 def run(self): """Runs the consumer.""" self.log.debug('consumer is running...') while self.running: self.upload() self.log.debug('consumer exited.') def pause(self): """Pause the consumer.""" self.running = False def upload(self): """Upload the next batch of items, return whether successful.""" success = False batch = self.next() if len(batch) == 0: return False try: self.request(batch) success = True except Exception as e: self.log.error('error uploading: %s', e) success = False if self.on_error: self.on_error(e, batch) finally: # mark items as acknowledged from queue for item in batch: self.queue.task_done() return success def next(self): """Return the next batch of items to upload.""" queue = self.queue items = [] while len(items) < self.upload_size or self.queue.empty(): try: item = queue.get(block=True, timeout=0.5) items.append(item) except Empty: break return items def request(self, batch, attempt=0): """Attempt to upload the batch and retry before raising an error """ try: post(self.write_key, batch=batch) except: if attempt > self.retries: raise self.request(batch, attempt+1) rudder-sdk-python-1.2.6/analytics/request.py000066400000000000000000000030111302216444000211230ustar00rootroot00000000000000from datetime import datetime from dateutil.tz import tzutc import logging import json from requests.auth import HTTPBasicAuth from requests import sessions _session = sessions.Session() def post(write_key, **kwargs): """Post the `kwargs` to the API""" log = logging.getLogger('segment') body = kwargs body["sentAt"] = datetime.utcnow().replace(tzinfo=tzutc()).isoformat() url = 'https://api.segment.io/v1/batch' auth = HTTPBasicAuth(write_key, '') data = json.dumps(body, cls=DatetimeSerializer) headers = { 'content-type': 'application/json' } log.debug('making request: %s', data) res = _session.post(url, data=data, auth=auth, headers=headers, timeout=15) if res.status_code == 200: log.debug('data uploaded successfully') return res try: payload = res.json() log.debug('received response: %s', payload) raise APIError(res.status_code, payload['code'], payload['message']) except ValueError: raise APIError(res.status_code, 'unknown', res.text) class APIError(Exception): def __init__(self, status, code, message): self.message = message self.status = status self.code = code def __str__(self): msg = "[Segment] {0}: {1} ({2})" return msg.format(self.code, self.message, self.status) class DatetimeSerializer(json.JSONEncoder): def default(self, obj): if isinstance(obj, datetime): return obj.isoformat() return json.JSONEncoder.default(self, obj) rudder-sdk-python-1.2.6/analytics/test/000077500000000000000000000000001302216444000200455ustar00rootroot00000000000000rudder-sdk-python-1.2.6/analytics/test/__init__.py000066400000000000000000000004531302216444000221600ustar00rootroot00000000000000import unittest import pkgutil import logging import sys def all_names(): for _, modname, _ in pkgutil.iter_modules(__path__): yield 'analytics.test.' + modname def all(): logging.basicConfig(stream=sys.stderr) return unittest.defaultTestLoader.loadTestsFromNames(all_names()) rudder-sdk-python-1.2.6/analytics/test/client.py000066400000000000000000000223751302216444000217060ustar00rootroot00000000000000from datetime import datetime import unittest import time import six from analytics.version import VERSION from analytics.client import Client class TestClient(unittest.TestCase): def fail(self, e, batch): """Mark the failure handler""" self.failed = True def setUp(self): self.failed = False self.client = Client('testsecret', on_error=self.fail) def test_requires_write_key(self): self.assertRaises(AssertionError, Client) def test_empty_flush(self): self.client.flush() def test_basic_track(self): client = self.client success, msg = client.track('userId', 'python test event') client.flush() self.assertTrue(success) self.assertFalse(self.failed) self.assertEqual(msg['event'], 'python test event') self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['properties'], {}) self.assertEqual(msg['type'], 'track') def test_advanced_track(self): client = self.client success, msg = client.track( 'userId', 'python test event', { 'property': 'value' }, { 'ip': '192.168.0.1' }, datetime(2014, 9, 3), 'anonymousId', { 'Amplitude': True }) self.assertTrue(success) self.assertEqual(msg['timestamp'], '2014-09-03T00:00:00+00:00') self.assertEqual(msg['properties'], { 'property': 'value' }) self.assertEqual(msg['integrations'], { 'Amplitude': True }) self.assertEqual(msg['context']['ip'], '192.168.0.1') self.assertEqual(msg['event'], 'python test event') self.assertEqual(msg['anonymousId'], 'anonymousId') self.assertEqual(msg['context']['library'], { 'name': 'analytics-python', 'version': VERSION }) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'track') def test_basic_identify(self): client = self.client success, msg = client.identify('userId', { 'trait': 'value' }) client.flush() self.assertTrue(success) self.assertFalse(self.failed) self.assertEqual(msg['traits'], { 'trait': 'value' }) self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'identify') def test_advanced_identify(self): client = self.client success, msg = client.identify( 'userId', { 'trait': 'value' }, { 'ip': '192.168.0.1' }, datetime(2014, 9, 3), 'anonymousId', { 'Amplitude': True }) self.assertTrue(success) self.assertEqual(msg['timestamp'], '2014-09-03T00:00:00+00:00') self.assertEqual(msg['integrations'], { 'Amplitude': True }) self.assertEqual(msg['context']['ip'], '192.168.0.1') self.assertEqual(msg['traits'], { 'trait': 'value' }) self.assertEqual(msg['anonymousId'], 'anonymousId') self.assertEqual(msg['context']['library'], { 'name': 'analytics-python', 'version': VERSION }) self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'identify') def test_basic_group(self): client = self.client success, msg = client.group('userId', 'groupId') client.flush() self.assertTrue(success) self.assertFalse(self.failed) self.assertEqual(msg['groupId'], 'groupId') self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'group') def test_advanced_group(self): client = self.client success, msg = client.group( 'userId', 'groupId', { 'trait': 'value' }, { 'ip': '192.168.0.1' }, datetime(2014, 9, 3), 'anonymousId', { 'Amplitude': True }) self.assertTrue(success) self.assertEqual(msg['timestamp'], '2014-09-03T00:00:00+00:00') self.assertEqual(msg['integrations'], { 'Amplitude': True }) self.assertEqual(msg['context']['ip'], '192.168.0.1') self.assertEqual(msg['traits'], { 'trait': 'value' }) self.assertEqual(msg['anonymousId'], 'anonymousId') self.assertEqual(msg['context']['library'], { 'name': 'analytics-python', 'version': VERSION }) self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'group') def test_basic_alias(self): client = self.client success, msg = client.alias('previousId', 'userId') client.flush() self.assertTrue(success) self.assertFalse(self.failed) self.assertEqual(msg['previousId'], 'previousId') self.assertEqual(msg['userId'], 'userId') def test_basic_page(self): client = self.client success, msg = client.page('userId', name='name') self.assertFalse(self.failed) client.flush() self.assertTrue(success) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'page') self.assertEqual(msg['name'], 'name') def test_advanced_page(self): client = self.client success, msg = client.page( 'userId', 'category', 'name', { 'property': 'value' }, { 'ip': '192.168.0.1' }, datetime(2014, 9, 3), 'anonymousId', { 'Amplitude': True }) self.assertTrue(success) self.assertEqual(msg['timestamp'], '2014-09-03T00:00:00+00:00') self.assertEqual(msg['integrations'], { 'Amplitude': True }) self.assertEqual(msg['context']['ip'], '192.168.0.1') self.assertEqual(msg['properties'], { 'property': 'value' }) self.assertEqual(msg['anonymousId'], 'anonymousId') self.assertEqual(msg['context']['library'], { 'name': 'analytics-python', 'version': VERSION }) self.assertEqual(msg['category'], 'category') self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'page') self.assertEqual(msg['name'], 'name') def test_basic_screen(self): client = self.client success, msg = client.screen('userId', name='name') client.flush() self.assertTrue(success) self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'screen') self.assertEqual(msg['name'], 'name') def test_advanced_screen(self): client = self.client success, msg = client.screen( 'userId', 'category', 'name', { 'property': 'value' }, { 'ip': '192.168.0.1' }, datetime(2014, 9, 3), 'anonymousId', { 'Amplitude': True }) self.assertTrue(success) self.assertEqual(msg['timestamp'], '2014-09-03T00:00:00+00:00') self.assertEqual(msg['integrations'], { 'Amplitude': True }) self.assertEqual(msg['context']['ip'], '192.168.0.1') self.assertEqual(msg['properties'], { 'property': 'value' }) self.assertEqual(msg['anonymousId'], 'anonymousId') self.assertEqual(msg['context']['library'], { 'name': 'analytics-python', 'version': VERSION }) self.assertTrue(isinstance(msg['timestamp'], str)) self.assertTrue(isinstance(msg['messageId'], str)) self.assertEqual(msg['category'], 'category') self.assertEqual(msg['userId'], 'userId') self.assertEqual(msg['type'], 'screen') self.assertEqual(msg['name'], 'name') def test_flush(self): client = self.client # set up the consumer with more requests than a single batch will allow for i in range(1000): success, msg = client.identify('userId', { 'trait': 'value' }) # We can't reliably assert that the queue is non-empty here; that's # a race condition. We do our best to load it up though. client.flush() # Make sure that the client queue is empty after flushing self.assertTrue(client.queue.empty()) def test_overflow(self): client = Client('testsecret', max_queue_size=1) # Ensure consumer thread is no longer uploading client.join() for i in range(10): client.identify('userId') success, msg = client.identify('userId') # Make sure we are informed that the queue is at capacity self.assertFalse(success) def test_success_on_invalid_write_key(self): client = Client('bad_key', on_error=self.fail) client.track('userId', 'event') client.flush() self.assertFalse(self.failed) def test_unicode(self): Client(six.u('unicode_key')) def test_numeric_user_id(self): self.client.track(1234, 'python event') self.client.flush() self.assertFalse(self.failed) def test_debug(self): Client('bad_key', debug=True) rudder-sdk-python-1.2.6/analytics/test/consumer.py000066400000000000000000000024061302216444000222540ustar00rootroot00000000000000import unittest try: from queue import Queue except: from Queue import Queue from analytics.consumer import Consumer class TestConsumer(unittest.TestCase): def test_next(self): q = Queue() consumer = Consumer(q, '') q.put(1) next = consumer.next() self.assertEqual(next, [1]) def test_next_limit(self): q = Queue() upload_size = 50 consumer = Consumer(q, '', upload_size) for i in range(10000): q.put(i) next = consumer.next() self.assertEqual(next, list(range(upload_size))) def test_upload(self): q = Queue() consumer = Consumer(q, 'testsecret') track = { 'type': 'track', 'event': 'python event', 'userId': 'userId' } q.put(track) success = consumer.upload() self.assertTrue(success) def test_request(self): consumer = Consumer(None, 'testsecret') track = { 'type': 'track', 'event': 'python event', 'userId': 'userId' } consumer.request([track]) def test_pause(self): consumer = Consumer(None, 'testsecret') consumer.pause() self.assertFalse(consumer.running) rudder-sdk-python-1.2.6/analytics/test/module.py000066400000000000000000000020171302216444000217040ustar00rootroot00000000000000import unittest import analytics class TestModule(unittest.TestCase): def failed(self): self.failed = True def setUp(self): self.failed = False analytics.write_key = 'testsecret' analytics.on_error = self.failed def test_no_write_key(self): analytics.write_key = None self.assertRaises(Exception, analytics.track) def test_track(self): analytics.track('userId', 'python module event') analytics.flush() def test_identify(self): analytics.identify('userId', { 'email': 'user@email.com' }) analytics.flush() def test_group(self): analytics.group('userId', 'groupId') analytics.flush() def test_alias(self): analytics.alias('previousId', 'userId') analytics.flush() def test_page(self): analytics.page('userId') analytics.flush() def test_screen(self): analytics.screen('userId') analytics.flush() def test_flush(self): analytics.flush()rudder-sdk-python-1.2.6/analytics/test/request.py000066400000000000000000000013471302216444000221140ustar00rootroot00000000000000from datetime import datetime import unittest import json from analytics.request import post, DatetimeSerializer class TestRequests(unittest.TestCase): def test_valid_request(self): res = post('testsecret', batch=[{ 'userId': 'userId', 'event': 'python event', 'type': 'track' }]) self.assertEqual(res.status_code, 200) def test_invalid_request_error(self): self.assertRaises(Exception, post, 'testsecret', '[{]') def test_datetime_serialization(self): data = { 'created': datetime(2012, 3, 4, 5, 6, 7, 891011) } result = json.dumps(data, cls=DatetimeSerializer) self.assertEqual(result, '{"created": "2012-03-04T05:06:07.891011"}') rudder-sdk-python-1.2.6/analytics/test/utils.py000066400000000000000000000033341302216444000215620ustar00rootroot00000000000000from datetime import datetime, timedelta from decimal import Decimal import unittest from dateutil.tz import tzutc import six from analytics import utils class TestUtils(unittest.TestCase): def test_timezone_utils(self): now = datetime.now() utcnow = datetime.now(tz=tzutc()) self.assertTrue(utils.is_naive(now)) self.assertFalse(utils.is_naive(utcnow)) fixed = utils.guess_timezone(now) self.assertFalse(utils.is_naive(fixed)) shouldnt_be_edited = utils.guess_timezone(utcnow) self.assertEqual(utcnow, shouldnt_be_edited) def test_clean(self): simple = { 'decimal': Decimal('0.142857'), 'unicode': six.u('woo'), 'date': datetime.now(), 'long': 200000000, 'integer': 1, 'float': 2.0, 'bool': True, 'str': 'woo', 'none': None } complicated = { 'exception': Exception('This should show up'), 'timedelta': timedelta(microseconds=20), 'list': [1, 2, 3] } combined = dict(simple.items()) combined.update(complicated.items()) pre_clean_keys = combined.keys() utils.clean(combined) self.assertEqual(combined.keys(), pre_clean_keys) def test_bytes(self): if six.PY3: item = bytes(10) else: item = bytearray(10) utils.clean(item) def test_clean_fn(self): cleaned = utils.clean({ 'fn': lambda x: x, 'number': 4 }) self.assertEqual(cleaned['number'], 4) # TODO: fixme, different behavior on python 2 and 3 if 'fn' in cleaned: self.assertEqual(cleaned['fn'], None) rudder-sdk-python-1.2.6/analytics/utils.py000066400000000000000000000044241302216444000206040ustar00rootroot00000000000000from dateutil.tz import tzlocal, tzutc from datetime import datetime from decimal import Decimal import logging import numbers import six log = logging.getLogger('segment') def is_naive(dt): """Determines if a given datetime.datetime is naive.""" return dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None def total_seconds(delta): """Determines total seconds with python < 2.7 compat.""" # http://stackoverflow.com/questions/3694835/python-2-6-5-divide-timedelta-with-timedelta return (delta.microseconds + (delta.seconds + delta.days * 24 * 3600) * 1e6) / 1e6 def guess_timezone(dt): """Attempts to convert a naive datetime to an aware datetime.""" if is_naive(dt): # attempts to guess the datetime.datetime.now() local timezone # case, and then defaults to utc delta = datetime.now() - dt if total_seconds(delta) < 5: # this was created using datetime.datetime.now() # so we are in the local timezone return dt.replace(tzinfo=tzlocal()) else: # at this point, the best we can do is guess UTC return dt.replace(tzinfo=tzutc()) return dt def clean(item): if isinstance(item, Decimal): return float(item) elif isinstance(item, (six.string_types, bool, numbers.Number, datetime, type(None))): return item elif isinstance(item, (set, list, tuple)): return _clean_list(item) elif isinstance(item, dict): return _clean_dict(item) else: return _coerce_unicode(item) def _clean_list(list_): return [clean(item) for item in list_] def _clean_dict(dict_): data = {} for k, v in six.iteritems(dict_): try: data[k] = clean(v) except TypeError: log.warning( 'Dictionary values must be serializeable to ' 'JSON "%s" value %s of type %s is unsupported.', k, v, type(v), ) return data def _coerce_unicode(cmplx): try: item = cmplx.decode("utf-8", "strict") except AttributeError as exception: item = ":".join(exception) item.decode("utf-8", "strict") log.warning('Error decoding: %s', item) return None except: raise return item rudder-sdk-python-1.2.6/analytics/version.py000066400000000000000000000000221302216444000211170ustar00rootroot00000000000000VERSION = '1.2.6' rudder-sdk-python-1.2.6/setup.cfg000066400000000000000000000000341302216444000167150ustar00rootroot00000000000000[bdist_wheel] universal = 1 rudder-sdk-python-1.2.6/setup.py000066400000000000000000000036621302216444000166200ustar00rootroot00000000000000 import os import sys try: from setuptools import setup except ImportError: from distutils.core import setup # Don't import analytics-python module here, since deps may not be installed sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'analytics')) from version import VERSION long_description = ''' Segment is the simplest way to integrate analytics into your application. One API allows you to turn on any other analytics service. No more learning new APIs, repeated code, and wasted development time. This is the official python client that wraps the Segment REST API (https://segment.com). Documentation and more details at https://github.com/segmentio/analytics-python ''' install_requires = [ "requests>=2.7,<3.0", "six>=1.5", "python-dateutil>2.1" ] setup( name='analytics-python', version=VERSION, url='https://github.com/segmentio/analytics-python', author='Segment', author_email='friends@segment.com', maintainer='Segment', maintainer_email='friends@segment.com', test_suite='analytics.test.all', packages=['analytics', 'analytics.test'], license='MIT License', install_requires=install_requires, description='The hassle-free way to integrate analytics into any python application.', long_description=long_description, classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.2", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", ], )