Python Whale.count_now方法代碼示例

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
    def dump_now(cls):
        """ Flush hits to Whale and increment """
        # Get the incoming hits from Hail
        
        r=cls.hail_driver()
        set_number_name = 'hail_number'
        r.setnx(set_number_name, 0)
        set_number = r.incr(set_number_name) - 1
        set_name = 'hail_%s' % set_number
        try: keys_from_hail = r.smembers(set_name)
        except: return
        if not len(keys_from_hail):
            r.delete(set_name)
            return

        def get_keys_from_json(k):
            try: 
                class_name, pk, dimensions, metrics, at = json.loads(r[k])
                #at = datetime.datetime.fromtimestamp(float(t))
                return (pk, dimensions, metrics, at)
            except Exception as e: 
                print e
                return False 

        keys_to_update = map(get_keys_from_json, keys_from_hail)
        for packed in keys_to_update:
            if packed:
                pk, dimensions, metrics, at = packed
                Whale.count_now(pk, dimensions, metrics, at=at)

        # Delete the hits
        map(r.delete, keys_from_hail)
        r.delete(set_name)

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
    def dump_now(cls):
        """ Flush hits to Whale and increment """
        # Get the incoming hits from Hail
        from whale import Whale
        whale = Whale()
        r=cls.driver()
        _s_n_n = 'hail_number'
        r.setnx(_s_n_n, 0)
        set_number = r.incr(_s_n_n) - 1
        set_name = 'hail_%s'%set_number
        try: keys_from_hail = r.smembers(set_name)
        except: return
        if len(keys_from_hail) is 0:
            r.delete(set_name)
            return
        def get_keys_from_json(k):
            try: 
                class_name, categories, dimensions, metrics, t = json.loads(r[k])
                at = datetime.datetime.fromtimestamp(float(t))
                return (categories, dimensions, metrics, at)
            except Exception as e: 
                print e
                return False 

        keys_to_update = map(get_keys_from_json, keys_from_hail)
        for packed in keys_to_update:
            if not packed: continue
            categories, dimensions, metrics, at = packed
            whale.count_now(categories, dimensions, metrics, at=at)

        # Delete the hits
        map(r.delete, keys_to_update)
        r.delete(set_name)

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
class TestHailWHale(unittest.TestCase):
    def setUp(self):
        from hail import Hail
        from whale import Whale

        self.hail = Hail()
        self.whale = Whale()

    def testGetSubdimensions(self):
        self.whale.count_now("test", {"a": 1, "b": 2})
        subs = self.whale.get_subdimensions("test")
        assert ["a"] in subs
        assert ["b"] in subs

    def testGetAllSubdimensions(self):
        self.whale.count_now("test", {"a": 1, "b": 2})
        subs = self.whale.all_subdimensions("test")
        assert ["a"] in subs
        assert ["a", "1"] in subs
        assert ["b"] in subs
        assert ["b", "2"] in subs

    def testCrunch(self):
        # Unique key for every test
        t = str(time.time())
        self.whale.count_now("test_crunch", [t, "a"], {"value": 5})
        self.whale.count_now("test_crunch", [t, "b"], {"value": 1})
        self.whale.count_now("test_crunch", [t, "c"], {"value": 15})

        data = self.whale.crunch("test_crunch", [t], "value")

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
def count_now():
    whale = Whale()
    at = g('at', False)
    tzoffset = None
    if not at:
        at = times.now()
    else:
        from dateutil.parser import parse
        at = parse(g('at'))
        at = at.replace(tzinfo=None)
    val = whale.count_now(at=at, **default_params())
    return 'OK'

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
def count_now():
    whale = Whale()
    vals = default_params()
    at = vals.get("at")#g('at', False)
    tzoffset = None
    if not at:
        at = times.now()
    else:
        from dateutil.parser import parse
        at = parse(at)
    val = whale.count_now(at= at, pk=vals.get("pk"), metrics=vals.get("metrics"), dimensions=vals.get("dimensions"))
    return 'OK'

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
def tracker():
    from periods import Period
    import random
    params = default_params()
    # LOLOL THIS SHOULD REALLY CHANGE
    key = hashlib.sha256('hailwhale_weak_key').digest()
    if 'pk' not in req.GET and 'pixel' in req.GET:
        from Crypto.Cipher import AES
        from base64 import b64encode, b64decode
        from urllib import quote_plus

        mode = AES.MODE_CBC
        encryptor = AES.new(key, mode)
        text = g('pixel')
        INTERRUPT = u'\u0001'
        PAD = u'\u0000'

        # Since you need to pad your data before encryption,
        # create a padding function as well
        # Similarly, create a function to strip off the padding after decryption
        def AddPadding(data, interrupt, pad, block_size):
            new_data = ''.join([data, interrupt])
            new_data_len = len(new_data)
            remaining_len = block_size - new_data_len
            to_pad_len = remaining_len % block_size
            pad_string = pad * to_pad_len
            return ''.join([new_data, pad_string])
        def StripPadding(data, interrupt, pad):
            return data.rstrip(pad).rstrip(interrupt)
        def hw_encoded(t):
            return quote_plus(b64encode(encryptor.encrypt(AddPadding(t, INTERRUPT, PAD, 32))))
        def hw_decoded(t):
            return StripPadding(encryptor.decrypt(b64decode(t)), INTERRUPT, PAD)
        params['pk'] = hw_decoded(text)
    pk = params['pk']
    whale = Whale()
    hail = Hail()
    val = whale.count_now(at=times.now(), **params)
    #val = whale.count_now(**params)
    uid = g('uid')
    if not uid or uid == '_new':
        default = random.randrange(10**6,10**9)
        uid = str(req.get_cookie('uid', str(default), key))
    hail.spy_log(uid, params)
    response.set_cookie('uid', uid, key)
    return str(uid)

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
class TestHailWhale(unittest.TestCase):
    def setUp(self):
        from hail import Hail
        from whale import Whale
        self.hail = Hail()
        self.whale = Whale()

    def testGetSubdimensions(self):
        t = 'subs_%s' % str(time.time())
        self.whale.count_now(t, {'a': 1, 'b': 2})
        subs = self.whale.get_subdimensions(t)
        assert('a' in subs)
        assert('b' in subs)

    def testGetAllSubdimensions(self):
        t = 'all_subs_%s' % str(time.time())
        self.whale.count_now(t, {'a': 1, 'b': 2})
        subs = self.whale.all_subdimensions(t)
        assert('a' in subs)
        assert(['a', '1'] in subs)
        assert('b' in subs)
        assert(['b', '2'] in subs)

    def testPlotpoints(self):
        t = str(time.time())

        for i in range(5):
            self.whale.count_now('test_plotpoints', t, {'hits': 1, 'values': 5})
        plotpoints = self.whale.plotpoints('test_plotpoints', t, ['hits', 'values'], points_type=list)

        self.assertEqual(plotpoints[t]['hits'][-1][1], 5)
        self.assertEqual(plotpoints[t]['values'][-1][1], 25)

    def testPlotpointsDepth(self):
        t = str(time.time())
        self.whale.count_now('test_depth', {t: 'a'})
        self.whale.count_now('test_depth', {t: 'b'})
        self.whale.count_now('test_depth', {t: 'b'})
        self.whale.count_now('test_depth', {t: {'c': 'child'}})
        # Test 1 level deep
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list, depth=1)
        self.assertEqual(plotpoints[maybe_dumps([t, 'a'])]['hits'][-1][1], 1)
        self.assertEqual(plotpoints[maybe_dumps([t, 'b'])]['hits'][-1][1], 2)
        self.assertEqual(plotpoints[maybe_dumps([t, 'c'])]['hits'][-1][1], 1)
        self.assertEqual(False, maybe_dumps([t, 'c', 'child']) in plotpoints)
        # Test 2 levels deep
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list, depth=2)
        self.assertEqual(True, maybe_dumps([t, 'c', 'child']) in plotpoints)
        self.assertEqual(plotpoints[maybe_dumps([t, 'c', 'child'])]['hits'][-1][1], 1)

        # Test ranking and limiting
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list,
                depth=1, limit=2)
        self.assertEqual(plotpoints[maybe_dumps([t, 'b'])]['hits'][-1][1], 2)
        self.assertEqual(True, maybe_dumps([t, 'a']) not in plotpoints)
        self.assertEqual(True, maybe_dumps([t, 'c']) not in plotpoints)

    def testRatioPlotpoints(self):
        t = str(time.time())

        for i in range(5):
            self.whale.count_now('test_ratio', t, {'hit': 1, 'value': 5})

        plotpoints = self.whale.plotpoints('test_ratio', t, ['hit', 'value', 'value/hit'], points_type=list)

        self.assertEqual(plotpoints[t]['hit'][-1][1], 5)
        self.assertEqual(plotpoints[t]['value'][-1][1], 25)

        self.assertEqual(plotpoints[t]['value/hit'][-1][1], 5)

    def testRankSubdimensionsScalar(self):
        t = str(time.time())
        self.whale.count_now('test_rank', [t, 'a', 'asub1'], {'value': 1})
        self.whale.count_now('test_rank', [t, 'a', 'asub2'], {'value': 30})
        self.whale.count_now('test_rank', [t, 'b'], {'value': 80})
        self.whale.count_now('test_rank', [t, 'c'], {'value': 10})
        ranked = self.whale.rank_subdimensions_scalar('test_rank', t, 'value')
        self.assertEqual(ranked[maybe_dumps([t, 'a'])]['important'], False)
        self.assertEqual(ranked[maybe_dumps([t, 'a', 'asub1'])]['important'], False)
        self.assertEqual(ranked[maybe_dumps([t, 'a', 'asub2'])]['important'], True)
        self.assertEqual(ranked[maybe_dumps([t, 'b'])]['important'], True)
        self.assertEqual(ranked[maybe_dumps([t, 'c'])]['important'], False)

    def testRankSubdimensionsRatio(self):
        t = str(time.time())
        pk = 'test_ratio_rank'
        # OVERALL STATS: 529,994 value, 50,000 visitors, 10.6 value per visitor
        # Not important, too close to overall
        self.whale.count_now(pk, [t, 'a', 'asub1'],
            {'value': 54989, 'visitors': 4999})  # 11 value per visitor
        # Important, high relative ratio
        self.whale.count_now(pk, [t, 'a', 'asub2'],
            {'value': 375000, 'visitors': 25000})  # 15 value per visitor
        # Important, low relative ratio
        self.whale.count_now(pk, [t, 'b'],
            {'value': 100000, 'visitors': 20000})  # 5 value per visitor
        # Not important, not enough visitors
        self.whale.count_now(pk, [t, 'c'],
            {'value': 5, 'visitors': 1})  # 5 value per visitor

#.........這裏部分代碼省略.........

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
def count_now():
    from datetime import datetime
    whale = Whale()
    val = whale.count_now(at=datetime.utcnow(), **default_params())
    return 'OK'

# 需要導入模塊: from whale import Whale [as 別名]
# 或者: from whale.Whale import count_now [as 別名]
def count_now():
    whale = Whale()
    val = whale.count_now(at=datetime.now(), **default_params())
    return 'OK'