Python

基于mitm中间人的形�获�所有公众�历�文章，评论，阅读�

feature
1，支�水平扩展
2，支�增�更新与自动化抓�阅读�，评论数�
3，支�抓����继续��抓�
4，支��阶段时间频率控制
5，支��续监控指定公众�
代ç ?æš‚ä¸?å¼€æº?，如有问题交æµ?å?¯åœ¨è¯¥ä»“库æ??issue,对应处ç?†æµ?程图如下：

nice_download.py 多线程文件下载器

ç?†è®ºåœ¨å¤§åž‹æ–‡ä»¶ä¸‹è½½ï¼Œå¸¦å®½å……足的情况下，å?¯å¢žåŠ æ•°å??å€?下载速度
原�是多线程对目标文件分�下载
1,å?‘é€?head请求获å?–目标文件总大å°?，以å?Šå½“å‰?是å?¦æ”¯æŒ?分å?—下载(详情:httpå??è®®header头rangeå?Šresponseçš„content-range)，现在基本都支æŒ?
2,下载�创建一个和�下载文件一样大�的文件
3,根�1中获得的文件大�分�多线程,�个线程下载��的数��
�型文件�能看�出加速效果，在大型文件上就会拉大差�
关于http的range特性：
有些文件下载器在下载中断之��以在中断�置继续下载，而�必�新开始的原因就是利用了支�range的特性
记录了中断时的文件å??移ä½?ç½®,在实现时å?ªè¦?在中断异常的时候记录文件å??移ä½?置到临时文件
下次继续下载读å?–临时文件中的å??移å?³å?¯æ”¯æŒ?断点下载,下载完æˆ?时删除记录文件å??移的临时文件å?³å?¯
说明：
nice_download.py是多线程模å¼?,所以去除断点下载功能，å?¦åˆ™ç»´æŠ¤ä¸´æ—¶æ–‡ä»¶å??移ä½?置比维护å?•ä¸€è¿›ç¨‹çš„临时文件å??移ä½?ç½®è¦?å¤?æ?‚的多
查看帮助：python nice_download.py -h

基于tensorflow的验��识别

ä¾?èµ–:
pip install tensorflow
pip install numpy

0x01,cd tensorflow
0x02,模型训练：python train.py
0x03,验�验�：python cnn_test.py

已有大多相关案例，测试相关总结与截图如下:

详相说明相关截图

总结文档：基于机器学习(TensorFlow)的��验��识别.pdf

redpackage.py && red_package_optimize.py 一�红包分��路

red_package_optimize.py为优化版，redpackage.py的range有点浪费内存，比如在红包个数特别大的情况下

指定红包总金�，�指定红包的个数，获得�个红包分�金�详情

例，红包总金�为10元，分�7个
➜  Py git:(master) ✗ py redpackage.py 10 7
[0.57, 2.37, 1.91, 0.32, 1.3, 2.24, 1.29]
第 1 个红包金�:0.57元
第 2 个红包金�:2.37元
第 3 个红包金�:1.91元
第 4 个红包金�:0.32元
第 5 个红包金�:1.3元
第 6 个红包金�:2.24元
第 7 个红包金�:1.29元
验�:红包总金� is 10.0元, 分�� res sum is 10.0元

ac.py 字符串�索算法（tire树+AC自动机)

学习记录:
如果你的本地å?ªæœ‰å‡ ä¸ªï¼Œå‡ å??个è¯?，那么没有必è¦?使用，直接存é…?置文件，字典查找å?³å?¯ï¼Œ
这比�api�起http请求�快的多。但如果�的数目�断增加，那么�期将�利于维护，
需��务化。

这个算法存在于实际场景,判断�个��是�是�感�，就涉�到字符串查找。
æ•?æ„Ÿè¯?被å°?装æˆ?了一个api接å?£,使用起æ?¥ä¹Ÿå¾ˆæ–¹ä¾¿,直接å?‘apiæ??交å?•è¯?,
看返回结果就知�是�命中,命中了则字符串存在,表明查找到了。

需�数�结构与算法知识：
�考文档1(海�数�处�之Tire树（字典树))：
      http://blog.csdn.net/ts173383201/article/details/7858598
�考文档2(AC自动机总结)：
      http://blog.csdn.net/mobius_strip/article/details/22549517

trie的核心�想是空间�时间,跟彩虹表的�想一致,但trie树�是彩虹表,
简而言之,trie树利用字符串的公共å‰?ç¼€æ?¥é™?低查询时间的开销以达到æ??高效率的目的。

它有3个基本性质：
      根节点�包�字符，除根节点外�一个节点都�包�一个字符。
      从根节点到�一节点，路径上�过的字符连接起�，为该节点对应的字符串。
      �个节点的所有�节点包�的字符都�相�。

�制了别人画的图，大致就是一�如下的树结构,需�用语言构造这棵树��:

fail 指针的�解图解,以下内容需�仔细读
�考：http://www.cnblogs.com/crazyacking/p/4659501.html

树上的�分别是：
{ he , hers , his , she}
按图所示分�3层。看到第三层，是"she"，其中：
①s指�root
②h先找到s的fail指针
å?‘现是0å?·æŒ‡é’ˆï¼Œä¸?是h，然å?Žhå°±ä¸?高兴了，å†?问问sçš„fail指针root：“你有没有儿å­?和我å?Œå??å?«hçš„â€?
root说：“有，你指�他��，然�h就高兴的指�了第一行的h.
③e开始找了，首先问他�爸h：“你的fail指针指���
h说：“图上第一行那个h啊�
然å?Žeå°±å±?颠å±?颠地跑去问图上第一行那个h：“你有没有å??字和我一样的儿å­?å•Šâ€?
图上第一行那个h说：“有，他地�是xxx�
最�e的fail指针就指�xxx地�，也就是第一行那个e了
�现这样，如果一个字符串查到第三行的e以�的字符��匹�，那说明他��应该有个‘he’
刚好e的失败指针指�的是第一行的‘he...’的那个e；
这样就ä¸?用从h开始å†?找一é??，而是接ç?€ç¬¬ä¸€è¡Œçš„e继续往å?Žæ‰¾ï¼Œä»Žè€ŒèŠ‚çœ?了时间.

➜  ~ du -h word.md && wc -l word.md
1.0M  word.md
57193 word.md

本地测试了一下，57000�记录大于�1M硬盘空间，那么6M的空间大约包�记录34W�记录,
我传到github的word.md没有几个字符,��了演示,而且�个��还加了rank等级，\t制表符,实际�用空间应该更�,
生产环境甚至�以直接将这些数�缓存到内存中。

测试�索指定字符串：

查找到了
➜  ~ python ac.py lock
Good ! Find it, the item is:
[(0, 3, 'lock', 1, 2)]

查找到了
➜  ~ python ac.py stop
Good ! Find it, the item is:
[(0, 3, 'stop', 2, 3)]

没有查找到
➜  ~ python ac.py test
Sorry, The item not in file dict

如果查找到了返回一个list，list中item类型为tuple, 并且包�了在树中匹�的起,终点�置index

calc24.py 算24游��程�

游�规则：给定4个数，�以执行的�算有 + - * / , 求出算的结果是24的算法过程

get help：
➜  Py git:(master) ✗ py calc24.py -h
Usage: usage -n 1,2,3,4

Options:
  -h, --help  show this help message and exit
  -n NUMS     specify num list
  
exp:
➜  Py git:(master) ✗ py calc24.py -n 10,8,9,4
[10, 8, 9, 4]
9 - 10 = -1
4 + -1 = 3
8 * 3 = 24
Success

or random test:
➜  Py git:(master) ✗ py calc24.py
[9, 10, 3, 6]
10 - 9 = 1
3 + 1 = 4
6 * 4 = 24
Success

~~~python轮�很强大~~~

rpn.py 逆波兰表达� python 版实现

逆波兰表达�被广泛应用于编译原�中，是一�是由波兰数学家扬·武�谢维奇1920年引入的数学表达�方�，在逆波兰记法中，
所有�作符置于�作数的��，因此也被称为�缀表示法。逆波兰记法�需�括��标识�作符的优先级。
以利用堆栈结构�少计算机内存访问。
➜  Py git:(master) ✗ python rpn.py
['11111111111111', '9999999999999', '*', '99', '12', '4', '/', '-', '10', '+', '+']
True 111111111111098888888888995 111111111111098888888888995
True 326 326

dispatch.py 轮转队列 | å??程实现

你的手头上会有多个任务，�个任务耗时很长，而你��想�步处�，而是希望能�多线程一样交替执行。
yield 没有逻辑�义，仅是作为暂�的标志点。
程���以在此暂�，也�以在此��。而通过实现一个调度器，完�多个任务的并行处�。
通过轮转队列�次唤起任务，并将已�完�的任务清出队列，模拟任务调度的过程。
核心代�：
from collections import deque
class Runner(object):
    def __init__(self, tasks):
        self.tasks = deque(tasks)

    def next(self):
        return self.tasks.pop()

    def run(self):
        while len(self.tasks):
            task = self.next()
            try:
                next(task)
            except StopIteration:
                pass
            else:
                self.tasks.appendleft(task)

def task(name, times):
    for i in range(times):
        yield
        print(name, i)

Runner([
    task('hsfzxjy', 5),
    task('Jack', 4),
    task('Bob', 6)
]).run()

coroutine.py 通过gevent第三方库实现å??程

上é?¢çš„dispatch.py通过yieldæ??供了对å??程的支æŒ?,模拟了任务调度。而下é?¢çš„这个gevent第三方库就更简å?•äº†ã€‚

第三方的gevent为Pythonæ??供了比较完善的å??程支æŒ?。通过greenlet实现å??程，其基本æ€?想是：
    当一个greenlet�到IO�作时，比如访问网络，就自动切�到其他的greenlet，等到IO�作完�，�在适当的时候切�回�继续执行。
    由于IOæ“?作é?žå¸¸è€—时，ç»?常使程åº?处于等待状æ€?，有了gevent为我们自动切æ?¢å??程，就ä¿?è¯?总有greenlet在è¿?行，而ä¸?是等待IO。

由于切�是在IO�作时自动完�，所以gevent需�修改Python自带的一些标准库，这一过程在�动时通过monkey patch完�：

�赖：
pip install gevent

执行：
➜  Py git:(master) ✗ python coroutine.py
GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
91430 bytes received from https://github.com/.
47391 bytes received from https://www.python.org/.
461975 bytes received from https://www.yahoo.com/.

base64_str.py base64编�原�

base64编�原�，使用Python实现base64编�，�能有bug，未完全完善版
1,准备一个包�64个字符的数组
2,对二进制数�进行处�，�3个字节一组，一共是3x8=24bit，划为4组，�组正好6个bit
3,得到4个数字作为索引，然�查表，获得相应的4个字符，就是编��的字符串
4,如果�编�的二进制数��是3的�数，最�会剩下1个或2个字节,Base64用\x00字节在末尾补足�，�在编�的末尾加上1个或2个=�，
表示补了多少字节，解�的时候，会自动去掉。

Base64编�会把3字节的二进制数�编�为4字节的文本数�，长度增加33%

例：
➜  Py git:(master) ✗ python base64_str.py lock
bG9jaw==
➜  Py git:(master) ✗ echo -n lock|base64
bG9jaw==

rsa.py RSA算法演示

➜  py python rsa.py
下�是一个RSA加解密算法的简�演示:

报文    加密       加密�密文

12      248832          17
15      759375          15
22      5153632         22
5       3125            10


---------------------------
----------执行解密---------
---------------------------
原始报文        密文      加密            解密报文

12              17      1419857         12
15              15      759375          15
22              22      5153632         22
5               10      100000          5

selenium.py 自动化测试demo

�1：
  执行 python selenium.py 始终无法唤醒chrome。
  最终�现chromedriver很早之�安装的，没有进行：brew upgrade chromedriver，导致执行脚本时报错
  upgrade chromedriver 之�解决问题，官方文档说明了selenium支�好几个Browser driver。
  演示时用的是Chrome，python的unittest模�，文档上说也�以用pytest

大致支�这以下几�DOM查找,��语言的接�略微的�区别
  driver.findElement(By.id(<element ID>))
  driver.findElement(By.name(<element name>))
  driver.findElement(By.className(<element class>))
  driver.findElement(By.tagName(<htmltagname>))
  driver.findElement(By.linkText(<linktext>))
  driver.findElement(By.partialLinkText(<linktext>))
  driver.findElement(By.cssSelector(<css selector>))
  driver.findElement(By.xpath(<xpath>))

支�Using Selenium with remote WebDriver
  支�远程WebDriver，默认监�4444端�
  �动：brew services start selenium-server-standalone
  �止：brew services stop selenium-server-standalone
  访问http://127.0.0.1:4444 点击console,
  新建正在测试所使用的webdriver,对于正在�行driver的测试程�，�以截图看当�测试程�的�行�置

Python 沙箱逃逸

�温2012.hack.lu的比赛题目，在这次挑战中，需�读�'./1.key'文件的内容。
他们首先通过删除引用�销�打开文件的内置函数。然�它们�许您执行用户输入。看看他们的代��微修改的版本：

def make_secure():
    UNSAFE = ['open',
              'file',
              'execfile',
              'compile',
              'reload',
              '__import__',
              'eval',
              'input']
    for func in UNSAFE:
        del __builtins__.__dict__[func]
from re import findall
# Remove dangerous builtins
make_secure()
print 'Go Ahead, Expoit me >;D'
while True:
    try:
        # Read user input until the first whitespace character
        inp = findall('\S+', raw_input())[0]
        a = None
        # Set a to the result from executing the user input
        exec 'a=' + inp
        print 'Return Value:', a
    except Exception, e:
    	print 'Exception:', e
由于没有在__builtins__中引用file和open，所以常规的编�技巧是行�通的。但�以在Python解释器中挖掘出�一�代替file或open引用的方法。

�类读�文件的方�：
().__class__.__bases__[0].__subclasses__()[40]('1.key').read()
这个方法�然�以读�到1.key的内容，coder,hack,geek�以深入了解下，本人测试时的python版本为：Python 2.7.12

avl_tree.py 平衡二��索树

特点：
1�若它的左�树�为空，则左�树上所有的节点值都�于它的根节点值。
2�若它的��树�为空，则��树上所有的节点值�大于它的根节点值。
3�它的左��树也分别�以充当为二�查找树。
4��个节点的左�树和��树的高度差至多等于1。

如果普通二��索树的深度很高且�一左边节点很多或者�一�边节点很多，那么查找性能几乎就��了线性的
而平衡二�树的�个节点的左�树和��树的高度差至多等于1，这�树结构的查找性能时间��度趋�lgn

➜  Py git:(master) ✗ py avl_tree.py
8
9
1

rb_tree.py 红黑树

红黑树多用在内部排�，�全放在内存中的，微软STL的map和set的内部实现就是红黑树。
B树多用在内存里放�下，大部分数�存储在外存上时。因为B树层数少，因此�以确��次�作，读��盘的次数尽�能的少。
在数�较�，�以完全放到内存中时，红黑树的时间��度比B树低。
å??之，数æ?®é‡?较大，外存中å? ä¸»è¦?部分时，B树因其读ç£?盘次数少，而具有更快的速度。

特点：
（1）�个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）�个��节点（NIL）是黑色。 [注�：这里��节点，是指为空(NIL或NULL)的��节点�]
（4）如果一个节点是红色的，则它的�节点必须是黑色的。
（5）从一个节点到该节点的�孙节点的所有路径上包�相�数目的黑节点。

revert_list.py å??转链表

➜  Py git:(master) ✗ py revert_list.py
1
2
3
start revert list ...
3
2
1

palindrome.py python版回文数,heapq_sort.py基于堆排�

life is short , use python
-(1)时间å¤?æ?‚度：O(n)，空间å¤?æ?‚度：O(1)。从两头å?‘中间扫æ??
-(2)时间��度：O(n)，空间��度：O(1)。先从中间开始�然��两边扩展

堆排实现，python对有对应�装好的heapq模�
py heapq_sort.py

kmp.py kmp字符串查找算法

➜  Py git:(master) ✗ python kmp.py
Found 'sase' start at string 'asfdehhaassdsdasasedwa' 15 index position, find use times: 23
Found 'sase' start at string '12s3sasexxx' 4 index position, find use times: 9

核心算法：
def kmp(string, match):
    n = len(string)
    m = len(match)
    i = 0
    j = 0
    count_times_used = 0
    while i < n:
        count_times_used += 1
        if match[j] == string[i]:
            if j == m - 1:
                print "Found '%s' start at string '%s' %s index position, find use times: %s" % (match, string, i - m + 1, count_times_used,)
                return
            i += 1
            j += 1
        elif j > 0:
            j = j - 1
        else:
            i += 1

compress.py 字符串压缩

针对连续��较多的字符压缩，�则�起压缩效果
➜  Py git:(master) ✗ python compress.py
原始字符串:xAAACCCBBDBB111
压缩�:x1A3C3B2D1B213
执行解压...
x
A
A
A
C
C
C
B
B
D
B
B
1
1
1
解压完毕
解压�:xAAACCCBBDBB111

hashtable.py hash表实现

hash_table = HashTable(5); # 分�5�
hash_table.set(1,'x')
print hash_table.get(1)

核心代�：
class Item(object):
    def __init__(self, key, value):
        self.key = key
        self.value = value


class HashTable(object):
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in xrange(self.size)]

    def hash_function(self, key):
        return key % self.size

    def set(self, key, value):
        hash_index = self.hash_function(key)
        for item in self.table[hash_index]:
            if item.key == key:
                item.value = value
                return
        self.table[hash_index].append(Item(key, value))

    def get(self, key):
        hash_index = self.hash_function(key)
        for item in self.table[hash_index]:
            if item.key == key:
                return item.value
        return None

    def remove(self, key):
        hash_index = self.hash_function(key)
        for i, item in enumerate(self.table[hash_index]):
            if item.key == key:
                del self.table[hash_index][i]

interpreter.py Python解释器�解

Python会执行其他3个步骤：�法分�，语法解�和编译。
这三步�起�把�代�转��code object,它包��解释器�以�解的指令。而解释器的工作就是解释code object中的指令。
核心代�
class Interpreter:
    def __init__(self):
        self.stack = []

    def load_value(self, number):
        self.stack.append(number)

    def print_answer(self):
        answer = self.stack.pop()
        print(answer)

    def add_two_values(self):
        first_num = self.stack.pop()
        second_num = self.stack.pop()
        total = first_num + second_num
        self.stack.append(total)

    def run_code(self, what_to_execute):
            instructions = what_to_execute["instructions"]
            numbers = what_to_execute["numbers"]
            for each_step in instructions:
                instruction, argument = each_step
                if instruction == "load_value":
                    number = numbers[argument]
                    self.load_value(number)
                elif instruction == "add_two_values":
                    self.add_two_values()
                elif instruction == "print_answer":
                    self.print_answer()

linked_list.py 快速查找�链表中间节点

➜  Py git:(master) py linked_list.py
普通é??历方å¼?,å?•é“¾è¡¨ä¸­é—´èŠ‚点为:n3,索引为:2，é??历一次链表，在从0é??历到中间ä½?ç½®
快慢指针方å¼?,å?•é“¾è¡¨ä¸­é—´èŠ‚点为:n3,索引为:2，å?ªé??历一次链表

核心代�：
class Node(object):
  def __init__(self,data,next):
    self.data=data
    self.next=next

n1 = Node('n1',None)
n2 = Node('n2',n1)
n3 = Node('n3',n2)
n4 = Node('n4',n3)
n5 = Node('n5',n4)

head = n5   # 链表的头节点

p1 = head   # 一次步进1个node
p2 = head   # 一次步进2个node

step = 0
while (p2.next is not None and p2.next.next is not None):
  p2 = p2.next.next
  p1 = p1.next
  step = step + 1
print '快慢指针方å¼?,å?•é“¾è¡¨ä¸­é—´èŠ‚点为:%s,索引为:%s，å?ªé??历一次链表' % (p1.data,step)

K最近邻算法

这个算法比svm简�很多
�需使用�中所学的两点�离公�（欧拉�离公�），计算目标点到�组的�离，看绿点和哪组更接近。
k代表å?–当å‰?è¦?分类的点最近的k个点，这k个点如果其中属于红点个数å? å¤šæ•°ï¼Œæˆ‘们就认为绿点应该划分为红组，å??之，则划分为黑组。
k值与分类数�正相关，现在是2个分组，那么k值�3，�设是3个分组，那么k值就��5
�考说明：https://zh.wikipedia.org/wiki/最近鄰居法
�赖：
pip install numpy
pip install matplotlib

下图中标注较大的红点在计算之�被分�到红组
执行：python knn.py

支���机 svm.py

迟早会忘记的svm
属分类算法，目标是寻找一个最优超平�，比knn算法��
demo为线性�分离数�

�考1：https://zh.wikipedia.org/zh-hans/支���机
�考2：http://blog.csdn.net/viewcode/article/details/12840405
�考3：http://blog.csdn.net/lisi1129/article/details/70209945?locationNum=8&fps=1

�赖：
pip install numpy
pip install matplotlib

执行：python svm.py

(��，中�，��，层�) btree.py

➜  Py git:(master) ✗ python btree.py
å‰?åº?é??历： root A C D F G B E
中åº?é??历： C F D G A root B E
å?Žåº?é??历： F G D C A E B root
层åº?é??历： root A B C E D F G
构造树结构如下图

Scrapy 爬虫测试（项目代�在仓库crawl_360目录下）

安装�赖：
pip install Scrapy 
pip install sqlalchemy 
pip install sqlacodegen
pip install mysql-connector

创建db：CREATE DATABASE crawl DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci

创建表：crawl_360/readme/sql.sql 文件

sqlacodegen创建models：
sqlacodegen --outfile=models.py mysql://root@localhost:3306/crawl --tables butian


找测试的目标抓�页�：http://butian.360.cn/Loo 页�被披露�洞的�业列表

创建项目: scrapy startproject crawl_360

目录结构:
➜  crawl_360 tree
.
├── crawl_360
│   ├── __init__.py
│   ├── __init__.pyc
│   ├── items.py
│   ├── items.pyc
│   ├── middlewares.py
│   ├── models
│   │   ├── __init__.py
│   │   ├── __init__.pyc
│   │   ├── db.py
│   │   ├── db.pyc
│   │   ├── models.py
│   │   └── models.pyc
│   ├── pipelines.py
│   ├── pipelines.pyc
│   ├── reademe
│   │   └── sql.sql
│   ├── settings.py
│   ├── settings.pyc
│   └── spiders
│       ├── __init__.py
│       ├── __init__.pyc
│       ├── butian.py
│       └── butian.pyc
└── scrapy.cfg

生�一个爬虫：
cd crawl_360 && scrapy genspider butian butian.360.cn/Loo

编写爬虫代� (crawl_360目录下，xpath代�30行��)

爬�：scrapy crawl butian

�：selenium也是一款�常�错的工具，�是使用selenium调用Browser driver更加逼真真实用户�作

Celery 分布�任务队列Test (仓库celery文件夹下)

pip3 install celery
pip3 install redis
编写tasks.py

from celery import Celery

app = Celery('TASK', broker='redis://127.0.0.1', backend='redis://127.0.0.1')


@app.task
def add(x, y):
    print 'start ...'
    print 'get param :%s,%s' % (x, y,)
    return x + y

�动celery worker �开始监�并执行任务
celery -A tasks worker --loglevel=info
tasks 任务文件å??，worker 任务角色，--loglevel=info 任务日志级别

127.0.0.1:6379> keys *
1) "_kombu.binding.celery"
2) "_kombu.binding.celeryev"
3) "_kombu.binding.celery.pidbox"
127.0.0.1:6379>

redis 集�结构(set),查看value:
SMEMBERS _kombu.binding.celery

在tasks.py文件目录打开终端进入py的交互�模�
>>> from tasks import add
>>> add.delay(1,2)
<AsyncResult: edb1b071-ed94-46fc-8250-a13e3db0e1a4>
>>> t = add.delay(4,5)
>>> t.get()
9
>>> t.ready()
True

celery常用接�
tasks.add(4,6) ---> 本地执行
tasks.add.delay(3,4) --> worker执行
t=tasks.add.delay(3,4)  --> t.get()  获�结果，或��，阻塞
t.ready()---> False：未执行完，True：已执行完
t.get(propagate=False) 抛出简�异常，但程��会�止
t.traceback 追踪完整异常

计算结果�存在redis中,默认结果有效期为1天
127.0.0.1:6379> ttl celery-task-meta-6eb3ee46-e86d-409a-9eb5-0c7d9b005035
(integer) 85917
127.0.0.1:6379> get celery-task-meta-6eb3ee46-e86d-409a-9eb5-0c7d9b005035
"{\"status\": \"SUCCESS\", \"traceback\": null, \"result\": 9, \"task_id\": \"6eb3ee46-e86d-409a-9eb5-0c7d9b005035\", \"children\": []}"
127.0.0.1:6379>