Merge branch 'pyBatch'

Author: tmschl

README.md

@@ -36,9 +36,25 @@ Once you have your Project ID, use the client like so:
     client.add_event("sign_ups", {
         "username": "lloyd",
         "referred_by": "harry"
-    }
+    })
+
+##### Send Batch Events to Keen IO
+
+You can upload Events in a batch, like so:
+
+    client.add_events({
+        "sign_ups": [
+            { "username": "nameuser1" },
+            { "username": "nameuser2" } 
+        ],
+        "purchases": [
+            { "price": 5 },
+            { "price": 6 }
+        ]
+    })
 
-That's it! After running your code, check your Keen IO Project to see the event has been added.
+
+That's it! After running your code, check your Keen IO Project to see the event/events has been added.
 
 ##### Do analysis with Keen IO
 
@@ -82,6 +98,10 @@ Here are some examples of querying.  Let's assume you've added some events to th
 
 ### Changelog
 
+##### 0.1.9
+
++ Added support for publishing events in batches
+
 ##### 0.1.8
 
 + Added querying support

keen/api.py

@@ -1,4 +1,5 @@
 import requests
+import json
 from keen import exceptions
 import json
 
@@ -16,6 +17,8 @@ class KeenApi(object):
     # the default version of the Keen API
     api_version = "3.0"
 
+    # self says it belongs to KeenApi/andOr is the object passed into KeenApi
+    # __init__ create keenapi object whenever KeenApi class is invoked
     def __init__(self, project_id,
                  write_key=None, read_key=None,
                  base_url=None, api_version=None):
@@ -30,6 +33,7 @@ def __init__(self, project_id,
         :param api_version: string, optional, set this to override what API
         version is used
         """
+        # super? recreates the object with values passed into KeenApi
         super(KeenApi, self).__init__()
         self.project_id = project_id
         self.write_key = write_key
@@ -55,6 +59,7 @@ def post_event(self, event):
                                                        event.event_collection)
         headers = {"Content-Type": "application/json", "Authorization": self.write_key}
         payload = event.to_json()
+        print payload
         response = requests.post(url, data=payload, headers=headers)
         if response.status_code != 201:
             error = response.json()
@@ -80,4 +85,26 @@ def query(self, analysis_type, params):
             error = response.json()
             raise exceptions.KeenApiError(error)
 
-        return response.json()["result"]
+        return response.json()["result"]
+
+    def post_events(self, events):
+
+        """
+        Posts a single event to the Keen IO API. The write key must be set first.
+
+        :param event: an Event to upload
+        """
+        if not self.write_key:
+            raise Exception("The Keen IO API requires a write key to send events. "
+                            "Please set a 'write_key' when initializing the "
+                            "KeenApi object.")
+
+        url = "{0}/{1}/projects/{2}/events".format(self.base_url, self.api_version,
+                                                       self.project_id)
+        headers = {"Content-Type": "application/json", "Authorization": self.write_key}
+        payload = json.dumps(events)
+        response = requests.post(url, data=payload, headers=headers)
+        print payload
+        if response.status_code != 200:
+            error = response.json()
+            raise exceptions.KeenApiError(error)

keen/client.py

@@ -98,6 +98,17 @@ def add_event(self, event_collection, event_body, timestamp=None):
                       timestamp=timestamp)
         self.persistence_strategy.persist(event)
 
+    def add_events(self, events):
+        """ Adds a batch of events
+
+        Depending on the persistence strategy of the client,
+        this will either result in the event being uploaded to Keen
+        immediately or will result in saving the event to some local cache.
+
+        :param events: dictionary of events
+        """
+        self.persistence_strategy.batch_persist(events)
+
     def count(self, event_collection, timeframe=None, timezone=None, interval=None, filters=None, group_by=None):
         """ Performs a count query
 
@@ -357,4 +368,5 @@ def get_params(self, event_collection=None, timeframe=None, timezone=None, inter
         if steps:
             params["steps"] = json.dumps(steps)
 
-        return params
+        return params
+

keen/persistence_strategies.py

@@ -36,6 +36,12 @@ def persist(self, event):
         """
         self.api.post_event(event)
 
+    def batch_persist(self, events):
+        """ Posts the given events directly to the Keen API.
+
+        :param events: a batch of events to persist
+        """
+        self.api.post_events(events)
 
 class RedisPersistenceStrategy(BasePersistenceStrategy):
     """

keen/tests/base_test_case.py

@@ -64,4 +64,4 @@ def to_mixed(cls, underscore_input):
             for i in range(1, word_count):
                 word_list[i] = string.capwords(word_list[i])
         ret = ''.join(word_list)
-        return ret
+        return ret

keen/tests/client_tests.py

@@ -56,6 +56,20 @@ def test_direct_persistence_strategy(self):
         read_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["read"]})
         client = KeenClient(project_id, write_key=write_key, read_key=read_key)
         client.add_event("python_test", {"hello": "goodbye"})
+        client.add_event("python_test", {"hello": "goodbye"})
+        client.add_events(
+            {"sign_ups": [
+                    { 
+                      "username": "timmy",
+                      "referred_by": "steve",
+                      "son_of": "my_mom"
+                    },
+            ],
+            "purchases": [
+                { "price": 5 },
+                { "price": 6 },
+                { "price": 7 }
+            ]})
 
 class QueryTests(BaseTestCase):
     def setUp(self):
@@ -127,4 +141,4 @@ def test_group_by(self):
 
     def test_interval(self):
         resp = self.client.count("query test", timeframe="this_2_days", interval="daily")
-        assert type(resp) is list
+        assert type(resp) is list