Python client.KeenClient类代码示例

def index(request):

    hits = cache.get('keen_hit_count')

    if not hits:
        keen = KeenClient(
            project_id=settings.KEEN_PROJECT_ID,
            write_key=settings.KEEN_WRITE_KEY,
            read_key=settings.KEEN_READ_KEY,
            get_timeout=3
        )
        try:
            detail_count = keen.count('detail_hit')
            list_count = keen.count('list_hit')
            schema_count = keen.count('schema_hit')
            hits = detail_count + list_count + schema_count
        except Exception:
            print('exception!')
            hits = DEFAULT_HITS

        cache.set('keen_hit_count', hits, DEFAULT_HITS)


    stripe_key = settings.STRIPE_KEYS['publishable']
    return render_to_response('index.html',
        {
            "hits": hits,
            "stripe_key": stripe_key
        }
    )

    def run(self):
        keen_client = KeenClient(
            project_id=self.project_id,
            write_key=self.write_key,
        )

        timezone = pytz.timezone(self.data['user']['timezone'])

        self.events = []
        with click.progressbar(self.data['days'],
                            label='Preparing keen.io events',
                            fill_char=click.style('#', fg='blue')) as days:

            for day in days:
                dt = self._parse_date(day['date'], timezone)

                self.append_event(dt, 'total', {
                    'seconds': day['grand_total']['total_seconds'],
                })

                categories = [
                    'editor',
                    'language',
                    'operating_system',
                    'project',
                ]
                for category in categories:
                    for item in day.get(category + 's', []):
                        self.append_event(dt, category, {
                            'seconds': item['total_seconds'],
                            'name': item['name'],
                        })

                files = {}
                for project in day.get('projects', []):
                    for f in project.get('dump', {}).get('files', []):
                        if f['name'] not in files:
                            files[f['name']] = 0
                        files[f['name']] += f['total_seconds']

                for name, seconds in files.items():
                    self.append_event(dt, 'file', {
                        'seconds': seconds,
                        'name': name,
                    })

        if len(self.events) == 0:
            click.echo('No events available for exporting to keen.io')
            return

        click.echo('Uploading events to keen.io...')
        start = datetime.utcfromtimestamp(self.data['range']['start'])
        end = datetime.utcfromtimestamp(self.data['range']['end'])
        collection = 'WakaTime Data Dump from {start} until {end}'.format(
            start=start.strftime('%Y-%m-%d'),
            end=end.strftime('%Y-%m-%d'),
        )
        keen_client.add_events({
            collection: self.events,
        })

def main():

    call(['./get_sleep.sh'])

    with open('data_json.txt') as raw:
        print '[Info] Loading raw sleep data...'
        raw_sessions = json.load(raw)
        timestamp = (datetime.today() - timedelta(days=TIME_DELTA)).isoformat()
        chk_sessions = [s for s in raw_sessions if s['start'] > timestamp]
        
        if len(chk_sessions) > 0:
            print '[Info] Found {0} sleep sessions to check...'.format(len(chk_sessions))

            client = KeenClient(
                project_id = KEEN_PROJECT_ID,
                write_key = KEEN_WRITE_KEY,
                read_key = KEEN_READ_KEY
                )
            old_sessions = client.extraction('sessions', timeframe=TIME_FRAME)
            new_sessions = [s for s in chk_sessions if 'tyin' + s['start'] not in [s2['id'] for s2 in old_sessions]]

            if len(new_sessions) > 0:
                print '[Info] Found {0} sleep sessions to add...'.format(len(new_sessions))
                sessions = []
                events = []
                sessions, events = transform(new_sessions, 'tyin')

                client.add_events({'sessions': sessions, 'events': events})
                print '[Info] Added {0} sleep sessions.'.format(len(new_sessions))

    print '[Info] Done.'

 def test_post_timeout_batch(self):
     keen.project_id = "5004ded1163d66114f000000"
     api_key = "2e79c6ec1d0145be8891bf668599c79a"
     keen.write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})
     client = KeenClient(keen.project_id, write_key=keen.write_key, read_key=None,
                         post_timeout=0.0001)
     client.add_events({"python_test": [{"hello": "goodbye"}]})

    def test_generate_image_beacon(self):
        keen.project_id = "5004ded1163d66114f000000"
        api_key = "2e79c6ec1d0145be8891bf668599c79a"
        keen.write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})

        event_collection = "python_test hello!?"
        event_data = {"a": "b"}
        data = self.base64_encode(json.dumps(event_data))

        # module level should work
        url = keen.generate_image_beacon(event_collection, event_data)
        expected = "https://api.keen.io/3.0/projects/{0}/events/{1}?api_key={2}&data={3}".format(
            keen.project_id, self.url_escape(event_collection), keen.write_key.decode(sys.getdefaultencoding()), data
        )
        self.assert_equal(expected, url)

        # so should instance level
        client = KeenClient(keen.project_id, write_key=keen.write_key, read_key=None)
        url = client.generate_image_beacon(event_collection, event_data)
        self.assert_equal(expected, url)

        # make sure URL works
        response = requests.get(url)
        self.assert_equal(200, response.status_code)
        self.assert_equal(b"GIF89a\x01\x00\x01\x00\x80\x01\x00\xff\xff\xff\x00\x00\x00!\xf9\x04\x01\n\x00\x01\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02L\x01\x00;",
                          response.content)

 def send_events(self, events):
     keen_project = keen_settings['private']['project_id']
     write_key = keen_settings['private']['write_key']
     if keen_project and write_key:
         client = KeenClient(
             project_id=keen_project,
             write_key=write_key,
         )
         logger.info('Adding {} events to the {} collection'.format(len(events), self.collection_name))
         client.add_events({self.collection_name: events})
     else:
         logger.info('Keen not enabled - would otherwise be adding the following {} events to the {} collection'.format(len(events), self.collection_name))
         print(events)

 def setUp(self):
     super(CustomJSONEncoderTests, self).setUp()
     api_key = "2e79c6ec1d0145be8891bf668599c79a"
     self.client = KeenClient(project_id='5004ded1163d66114f000000',
                              write_key=scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]}),
                              read_key=scoped_keys.encrypt(api_key, {"allowed_operations": ["read"]}),
                              json_encoder=CustomEncoder)

 def __init__(self):
     self.client = KeenClient(
         project_id=ENV["keen"]["project_id"],
         write_key=ENV["keen"]["write_key"],
         read_key=ENV["keen"]["read_key"],
         master_key=ENV["keen"]["master_key"],
     )

    def test_generate_image_beacon(self, post):
        event_collection = "python_test hello!?"
        event_data = {"a": "b"}
        data = self.base64_encode(json.dumps(event_data))

        # module level should work
        url = keen.generate_image_beacon(event_collection, event_data)
        expected = "https://api.keen.io/3.0/projects/{0}/events/{1}?api_key={2}&data={3}".format(
            keen.project_id, self.url_escape(event_collection), keen.write_key.decode(sys.getdefaultencoding()), data
        )
        self.assert_equal(expected, url)

        # so should instance level
        client = KeenClient(keen.project_id, write_key=keen.write_key, read_key=None)
        url = client.generate_image_beacon(event_collection, event_data)
        self.assert_equal(expected, url)

    def send_events(self, events):
        keen_project = keen_settings["private"]["project_id"]
        write_key = keen_settings["private"]["write_key"]
        if keen_project and write_key:
            client = KeenClient(project_id=keen_project, write_key=write_key)
            logger.info("Adding {} events to the {} collection".format(len(events), self.collection_name))

            for chunk in self.yield_chunked_events(events):
                client.add_events({self.collection_name: chunk})
                time.sleep(1)

        else:
            logger.info(
                "Keen not enabled - would otherwise be adding the following {} events to the {} collection".format(
                    len(events), self.collection_name
                )
            )
            print(events)

 def __keen_client(self):
    if KEEN_CLIENT_ENABLED and self.keen_client == None:
       self.keen_client = KeenClient(
          project_id=KEEN_PROJECT_ID,
          write_key=KEEN_WRITE_KEY,
          read_key=KEEN_READ_KEY,
          base_url=KEEN_API_URL
       )
    return self.keen_client

def main():
    print "[INFO] Getting raw spire data..."
    date = (datetime.today() - timedelta(days=DAYS_AGO)).strftime("%Y-%m-%d")

    # Breath
    breath_client = KeenClient(
        project_id=keen["breath"]["project_id"],
        read_key=keen["breath"]["read_key"],
        write_key=keen["breath"]["write_key"],
    )

    if len(breath_client.extraction("sessions", timeframe="this_" + str(DAYS_AGO) + "_days")) > 0:
        print "[INFO] Already uploaded breath data for " + date + "."
    else:
        breaths = get_spire(spire["breath"], date)

        if len(breaths["data"]) > 0:
            print "[INFO] Uploading breath data..."

            keen_breaths = {}
            keen_breaths["breaths"] = [{"timestamp": b["timestamp"], "value": b["value"]} for b in breaths["data"]]
            keen_breaths["metadata"] = breaths["metadata"]

            keen_breaths["metadata"]["min"] = min([b["value"] for b in breaths["data"]])
            keen_breaths["metadata"]["max"] = max([b["value"] for b in breaths["data"]])
            keen_breaths["id"] = USER + date
            breath_client.add_event("sessions", keen_breaths)
            print "[INFO] Uploaded breath data for " + date + "."
        else:
            print "[INFO] No breath data found for " + date + "."

    # Steps
    steps_client = KeenClient(
        project_id=keen["steps"]["project_id"], read_key=keen["steps"]["read_key"], write_key=keen["steps"]["write_key"]
    )

    if len(steps_client.extraction("sessions", timeframe="this_" + str(DAYS_AGO) + "_days")) > 0:
        print "[INFO] Already uploaded steps data for " + date + "."
    else:
        steps = get_spire(spire["step"], date)

        if len(steps["data"]) > 0:
            print "[INFO] Uploading steps data..."

            keen_steps = {}
            keen_steps["steps"] = [{"timestamp": s["timestamp"], "value": s["value"]} for s in steps["data"]]
            keen_steps["metadata"] = steps["metadata"]
            keen_steps["id"] = USER + date
            steps_client.add_event("sessions", keen_steps)
            print "[INFO] Uploaded steps data for " + date + "."
        else:
            print "[INFO] No steps data found for " + date + "."

class AsyncKeenClient(object):
    def __init__(self):
        self._client = KeenClient(
            project_id=os.environ['KEEN_PROJECT_ID'],
            write_key=os.environ['KEEN_WRITE_KEY'],
            post_timeout=100
        )

    def add_event(self, collection, body):
        push = lambda: self._client.add_event(collection, body)
        IOLoop.current().spawn_callback(push)

class CustomJSONEncoderTests(BaseTestCase):

    def setUp(self):
        super(CustomJSONEncoderTests, self).setUp()
        api_key = "2e79c6ec1d0145be8891bf668599c79a"
        self.client = KeenClient(project_id='5004ded1163d66114f000000',
                                 write_key=scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]}),
                                 read_key=scoped_keys.encrypt(api_key, {"allowed_operations": ["read"]}),
                                 json_encoder=CustomEncoder)

    def tearDown(self):
        self.client = None
        super(CustomJSONEncoderTests, self).tearDown()

    def test_custom_encoder_with_datetime_type(self):
        self.client.add_event("sign_ups", {
            "username": "lloyd",
            "referred_by": "harry",
            "confirmed_at": datetime.datetime.utcnow()
        })

 def test_direct_persistence_strategy(self):
     project_id = "5004ded1163d66114f000000"
     api_key = "2e79c6ec1d0145be8891bf668599c79a"
     write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})
     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}
             ]}
     )