{
  "ask_string": "步不之来疏笔口平去重学青字斟浅之论暗明尊易伐道不云句来刊酌诛才师",
  "type": "asking",
  "scores": [
    {
      "nick": "吕耀辉",
      ....
    },
    {
      "nick": "xxxx",
      ......
    }
  ]
}

{
  "answer": "口诛笔伐",
  "answer_index": [
    "6",
    "29",
    "5",
    "21"
  ],
  "type": "answer"
}

import json
import time
import collections

from mitmproxy import ctx

'''
> mitmdump -s chengyu_mitm.py '~u websock_m/websock_message'
'''

Red = '\033[0;31m'
Green = '\033[0;32m'
Yellow = '\033[0;33m'
Blue = '\033[0;34m'
Purple = '\033[0;35m'
Cyan = '\033[0;36m'
White = '\033[0;37m'

colors = {
    0:Red,
    1:Purple,
    2:Yellow,
    3:Blue,
    4:White,
}

class Chengyu(object):
    def __init__(self):
        self.dictpath = '/Users/zhoujie/chengyu.text'
        self.chengyu = set()
        with open(self.dictpath, 'rt') as f:
            for line in f.readlines():
                self.chengyu.add(line.strip())

        self.answers = list()
        self.ask_string = ''

        # {'和':[1,8], '我':[11]}
        self.char_indexs_dict = dict()

        # {1:'和', 8:'和', 11:'我'}
        self.index_char_dict = dict()

        self.count = 0

        # 自动提交答案的网络发送次数
        self.auto_send_count = 0

        # 自动发送的成语
        self.auto_send_list = list()

        # 服务器确定正确的成语
        self.ack_true_list = list()

        # {'中流砥柱':[1,9,21,25]}
        self.answer_indexs_dict = dict()

        # 查找到的错误答案
        self.error_answers = []

        # 玩了多少局
        self.play_times = 0

        self.firt_auto_answer = True



    # General lifecycle
    def load(self, loader):
        ctx.log.info('\033[1;31mevent: load\033[0m')

    def configure(self, updated):
        ctx.log.info('\033[1;31mevent: configure\033[0m')



    # Websocket lifecycle
    def websocket_message(self, flow):
        """
            Called when a WebSocket message is received from the client or
            server. The most recent message will be flow.messages[-1]. The
            message is user-modifiable. Currently there are two types of
            messages, corresponding to the BINARY and TEXT frame types.
        """

        ctx.log.info('\033[1;31m websocket_message \033[0m')

        # get the latest message
        message = flow.messages[-1]

        # simply print the content of the message
        ctx.log.info('')
        ctx.log.info(message.content)
        ctx.log.info('')

        m = json.loads(message.content)
        message_type = m['type']
        if m.get('ask_string'):
            self.ask_string = m['ask_string']
            # 计算答案
            self.find_answers_v2(self.ask_string)
            self.play_times += 1

        # {"answer": "\u957f\u9a71\u76f4\u5165", "answer_index": ["0", "20", "43", "41"], "type": "answer"}
        if message_type == 'answer':
            self.answer_indexs_dict[m['answer']] = m['answer_index']

        # 删除已回答正确的答案
        ack = False

        # {"answer":"长驱直入","type":"answer_ack","seq":0,"ack":1}
        if m.get('ack') == 1:

            answer = m['answer']
            self.ack_true_list.append(answer)
            answer_index = self.answer_indexs_dict.get(answer,[])
            for i in answer_index:
                self.index_char_dict[int(i)] = '  '

            for c,i in zip(answer,answer_index):                
                indexs = self.char_indexs_dict[c]
                indexs.remove(int(i))

            try:
                ack = True
                self.answers.remove(m['answer'])
            except:
                pass

        if message_type == 'answer_ack' and m.get('ack') == 0:
            pass


        # 自动答题
        if message_type == 'answer_ack' or self.firt_auto_answer:
            
            self.auto_answer(flow)

        # 显示答案
        if len(self.ask_string):
            self.print_answers()


        if message_type == 'game_result':
            # 把答案增加到内存字典中
            self.__add_new_worlds_to_memory(m)

            self.reset_data_to_init()


    def websocket_end(self, flow):
        """
            A websocket connection has ended.
        """
        ctx.log.info('\033[1;31m websocket_end \033[0m')

        self.reset_data_to_init()

        if self.play_times % 5 == 0:
            with open(self.dictpath, 'wt') as f:
                l = list(self.chengyu)
                l.sort()
                for item in l:
                    f.write(item)
                    f.write('\n')


    # ---------------------------------------------
    def find_answers_v2(self, ask_string):
        '''
            在内存成语字典查找答案
        '''
        ask_set = set(ask_string)
        for i, c in enumerate(ask_string):
            self.char_indexs_dict.setdefault(c, []).append(i)
        self.index_char_dict = dict( zip(range(len(ask_string)), ask_string))

        used_chars = set()
        # 找到的的成语中各异字符为2个的答案数量：如 [真真假假]
        answer_2chars_count = 0
        max_count = len(ask_string) / 4
        for item in self.chengyu:
            item_set = set(item)
            if not (item_set - ask_set):
                self.answers.append(item)
                used_chars.update(item_set)
                if len(item_set)<4:
                    answer_2chars_count += 1
                if len(self.answers) - answer_2chars_count >= max_count and used_chars >= ask_set:
                    self.count = len(self.answers)
                    return
        self.count = len(self.answers)

    def auto_answer(self, flow):
        while len(self.answers) > 0:
            item = self.answers[0]
            answer_index = []
            counter = collections.Counter(item)

            b_continue = False
            for char, count in counter.items():
                if len(self.char_indexs_dict[char]) < count:
                    self.error_answers.append(item)
                    self.answers.remove(item)
                    b_continue = True
                    break # break for

            if b_continue:
                continue

            char_index = {}
            for c in item:                
                x = char_index.get(c, 0)
                index = self.char_indexs_dict[c][x]
                answer_index.append( str(index) )
                char_index[c] = x+1

            if len(set(answer_index)) < 4:
                ctx.log.error(f'?算法有错误：{answer_index} 小于4')
                continue

            send_message = {
                'answer': item,
                'answer_index': answer_index,
                'type': 'answer'
            }
            mm = json.dumps(send_message)
            # -----------------------
            print(mm)
            # -----------------------
            self.answer_indexs_dict[item] = answer_index
            # 向服务器发送消息
            if not flow.ended and not flow.error:
                self.firt_auto_answer = False
                self.auto_send_count += 1
                self.auto_send_list.append(item)
                self.answers.remove(item)
                time.sleep(1.5)
                flow.inject_message(flow.server_conn, mm)
                break




    def __add_new_worlds_to_memory(self, m):
        '''
            把答案增加到内存字典中
        '''
        for answer in m['all_answer']:
            self.chengyu.add(answer['phrase'])

        ctx.log.info('\033[1;31m 共收录{}个成语 \033[0m'.format(len(self.chengyu)))
        ctx.log.info(f'\033[1;31m 共玩了 {self.play_times} 局\033[0m')

    def print_answers(self):
        '''
            图形化、色彩化显示答案
        '''
        self.print_color(self.ask_string)
        self.print_color('共找到 {}/{} 个成语'.format(self.count, len(self.ask_string)//4))
        self.print_color('错误成语 {}'.format(self.error_answers))
        self.print_color('共自动 {} 次提交'.format(self.auto_send_count))
        self.print_color('自动{:2}个：{}'.format(len(self.auto_send_list),self.auto_send_list))
        self.print_color('确认{:2}个：{}'.format(len(self.ack_true_list),self.ack_true_list))
        for item in self.answers:
            self.print_color(item)
            self.print_matrix(item)

        if (not self.answers) and self.index_char_dict:
            self.print_matrix()


    def print_matrix(self, item = []):
        '''
        item: '腊尽春回' or []
        '''
        chars_in_line = 6
        length = len(self.ask_string)

        lines = (length + chars_in_line - 1) // chars_in_line
        PADDING = ' '*(lines * chars_in_line - length)
        is_need_padding = len(PADDING) != 0

        global colors, White
        
        self.print_color('--'*chars_in_line)

        for i, c in self.index_char_dict.items():
            end = ''
            if (i+1) % chars_in_line == 0 or (i+1) == length:
                end = '\n'

            color = White
            if c in item:
                color = colors[item.index(c)]

            line, first = divmod(i, chars_in_line)
            if is_need_padding and first == 0 and (line + 1 == lines):
                c = PADDING + c

            self.print_color(c, end=end, front_color=color)

        self.print_color('--'*chars_in_line)

    def print_color(self, message, end='\n', front_color=Red):
        print(f'{front_color}{message}\033[0m', end=end)


    def reset_data_to_init(self):
        self.ask_string = ''
        self.answers.clear()
        self.index_char_dict.clear()

        self.count = 0
        self.auto_send_count = 0

        self.answer_indexs_dict.clear()
        self.char_indexs_dict.clear()
        self.error_answers.clear()
        self.ack_true_list.clear()
        self.auto_send_list.clear()
        self.firt_auto_answer = True


addons = [
    Chengyu()
]

if __name__ == "__main__":
    c = Chengyu()

    ask_string = '腊见家义降德若功赎仁判悲生升道肘两身乐极尽立罪春命明回人捉襟性暗'
    ask_string = '来戴恶自唇而怙到生二不马亡竹锲寒擒梅香听寒星圆其十贼其鸟舍悛口一自不月披青擒王说曝手然擒一齿齿石'
    ask_string = '侧拨扮相大拔挈然纲打富提敲如涌门见助济行踽全弄轩责刀危踽击贫独波可云岌日班思求斧乔备泉领旁岌劫装'
    c.ask_string = ask_string
    c.find_answers_v2(ask_string)
    print(c.answers)
    c.print_answers()

一劳永逸
一掷千金
一曝十寒
一石二鸟
一筹莫展
一落千丈
一衣带水
一语破的

mitmdump --mode=upstream:http://127.0.0.1:8888 --ssl-insecure

def readtimer_report(self):

    headers = {
		'User-Agent': 'qukan_android;retrofit/2.4.0 okhttp/3.11.0;os/7.0 M5 Note Meizu;device/862546036581345;version/3.9.41.000.0904.1121;channel/012',
		'Host': 'api.1sapp.com',
		'Accept-Encoding': 'gzip',
		'Connection': 'keep-alive',
	}

    params = {
		'qdata': 'NzVFNkE3Mjc0RjEzRkYwRTM5OTEzNjAyRUZBMDMzQTAuY0dGeVlXMGZPR0kyTldKalltTXRNVGczT1MwME9EZGlMVGszT0RBdE1EUmlOVEV3TWpOak9UazRIblpsY25OcGIyNGZNVEVlY0d4aGRHWnZjbTBmWVc1a2NtOXBaQjVsWXg4eC46LxvyIvgD62/T93SlANmywpigTwlOwcfCHe0iZ1D8mH1zpslt2JCRPdiHOj1M20bU0zDX0odUOBig6Kt51mheNJuQYeDvp15R8RSGTT3LR9s55nBCGvWyTLq+3pjEvkyERElR9E2I384/nHQR4iqxqv7LKQ4rBA0R6bNG8sksHqNl1izSbF87G/4/Qw5vVYcuNUfU0BM6vvIbsy2CTPWlJ51YCzadQZZLONuaYTpyhuOiUV4vnx6qkvpYDNp9XpPPjbXxJAb7fikqjWSdyx167hXDPzUkNZGndjZsv7kQANDkIk2Dm+g5YW1I49xnkOzJkmxvyrLevnsSb9S5fSEUEyfq0GlPHE0RRBeSjFxVltH1zdZraTtk13Z+MvA7HBYQONz/0OwyMnujc1Ety91uKh6YCCVEDvBO+RTOzoRDa3nlRo3FTo9OeRBsyL20qIP24977MMYXEoxinTuwNonipCjnjSYIrhOu6cyv7uxuLd6FxtmTsydawNGMPI/K+habIKXNUFsQMCUcAGhYpoKQJvkQqHEq6lPyZZzXDot1EsN6bsGj56xQdiuJZLMFyZaGNR6E9FmVlI0LAVT8ttVpOvs+5f08T0iMxMNb0VQk6DOySpYHp7EVjc9YFpPcVxj8aXvuTjoPkaNGhSKQ0fgBd8HVRLslcnzX0QLJkTuU7NQ9aili6m2M2hWvh/q8ghWrvtLT+izCiFNKHE+4GTC9J6jqgyjHsXkAjcOSBAaIXMQKnOd664hdoR2GqV+GAy95fc5zZCJ7EFvzmTbJQrpMOwW+Y2NvYPZtgjw1uJEyU7AR7nVw7VqMjPpCDYeWBWoQ1W4OjlXTqgBR4MIu1sTag6a+my/0hItf91SNa58zCN3YmE2NnsWwwiCC+ZP91moV/KqPwX3vMLKW4/3Vsziqe8gl',
	}

    data = {
	}

    url = 'http://api.1sapp.com/readtimer/report'
    result = self._get(url, headers=headers, params=params, data=data)
    return result
     

'''
代码模板
'''
import requests
import json
import logging

logging.basicConfig(format='%(asctime)s:%(message)s', datefmt='%m-%d %H:%M:%S', level=logging.INFO)

class User(object):
    def __init__(self):
        pass
        
    def api_need_implement(self):
        pass

    def _header(self):
        return {
            'User-Agent': '',
            'Cookie':self.cookie
        }

    @staticmethod
    def _post(url, data=None, json=None, p=logging.warning, **kwargs):
        res = requests.post(url, data=data, **kwargs)
        result = res.text
        p(res.json())
        logging.info('')
        return result

    @staticmethod
    def _get(url, params=None, p=logging.warning, **kwargs):
        res = requests.get(url, params=params, **kwargs)
        result = res.text
        p(json.loads(result))
        logging.info('')
        return result

def genUsers():
    yield User()

if __name__ == "__main__":
    for user in genUsers():
        user.api_need_implement()  

import json
import re
from urllib.parse import urlparse

from mitmproxy import ctx
from mitmproxy import flowfilter
from mitmproxy import http

'''
生成接口python代码
'''

class GenCode(object):
    def __init__(self):
        ctx.log.info('__init__')

        # 趣头条
        urls = [
            r'taskcenter/getListV2',#tab页：任务
            r'readtimer/report',
        ]
        self.qu_tou_tiao = flowfilter.parse('|'.join(urls)) 

        # 百度 - 全民小视频 
        urls = [
            r'mvideo/api', # 每日签到
        ]
        self.quan_ming = flowfilter.parse('|'.join(urls)) 

        self.flowfilters = [
            self.qu_tou_tiao, 
            self.quan_ming,
        ]      

    def load(self, loader):
        ctx.log.info('event: load')

    def configure(self, updated):
        ctx.log.info('event: configure')

    def running(self):
        ctx.log.info('event: running')

    def done(self):
        ctx.log.info('event: done')



    def response(self, flow: http.HTTPFlow):
        if any( [ filter(flow) for filter in self.flowfilters ] ):

            request: http.HTTPRequest = flow.request

            parse_result = urlparse(request.url)
            url_path = parse_result.path

            function_name = re.sub(r'[/-]','_', url_path).strip('_')
            headers_code = self.headers_string(flow)
            params_code = self.params_string(flow)
            data_code = self.data_string(flow) 

            path = f'''/Users/zhoujie/Desktop/api/{function_name}.text'''  
            with open(path, 'a') as f:
                print(f'''# ---------------------''',file=f)

                code = f'''
def {function_name}(self):

    {headers_code}

    {params_code}

    {data_code}

    url = '{request.scheme}://{request.pretty_host}{url_path}'
    result = self._{request.method.lower()}(url, headers=headers, params=params, data=data)
    return result
                
'''
                f.write(code)

                print(f'''Response:''',file=f)
                print(f'''{flow.response.text}''',file=f)
                print(f'''# ---------------------\n\n''',file=f)

    def headers_string(self, flow: http.HTTPFlow):
        lines = ''
        for key,value in flow.request.headers.items():
            lines += f"\n\t\t'{key}': '{value}',"
        s = f'''headers = {{{lines}\n\t}}'''        
        return s


    def params_string(self, flow: http.HTTPFlow):
        lines = ''
        for key,value in flow.request.query.items():
            lines += f"\n\t\t'{key}': '{value}',"
        s = f'''params = {{{lines}\n\t}}'''        
        return s

    def data_string(self, flow: http.HTTPFlow):
        '''
        Content-Type: application/x-www-form-urlencoded
        Content-Type: application/json; charset=utf-8
        Content-Type: text/plain;charset=utf-8
        '''
        lines = ''

        # [urlencoded_form, multipart_form, plan, json]取其一
        for key,value in flow.request.urlencoded_form.items():
            lines += f"\n\t\t'{key}': '{value}',"

        for key,value in flow.request.multipart_form.items():
            key = key.decode(encoding='utf-8')
            value = value.decode(encoding='utf-8') 
            lines += f"\n\t\t'{key}': '{value}',"

        # Todo:复杂json数据还不能代码化
        if 'application/json' in flow.request.headers.get('content-type',''):
            d = json.loads(flow.request.text)
            for key,value in d.items():
                lines += f"\n\t\t'{key}': {value},"
        
        s = f'''data = {{{lines}\n\t}}'''        
        return s


    

addons = [
    GenCode()
]

# 普通阅读文章/视频
https://is.snssdk.com/score_task/v1/task/get_read_bonus/?fp=xxx&...&group_id=6689697061983486472

# 推送文章的阅读
https://is.snssdk.com/score_task/v1/task/get_read_bonus/?fp=xxx&...&&impression_type=push&group_id=6689697061983486472

<?xml version='1.0' encoding='UTF-8' ?>
<?charles serialisation-version='2.0' ?>
<rewriteSet-array>
  <rewriteSet>
    <active>true</active>
    <name>get_read_bonus</name>
    <hosts>
      <locationPatterns>
        <locationMatch>
          <location>
            <protocol>https</protocol>
            <host>is.snssdk.com</host>
            <path>/score_task/v1/task/get_read_bonus/</path>
          </location>
          <enabled>true</enabled>
        </locationMatch>
      </locationPatterns>
    </hosts>
    <rules>
      <rewriteRule>
        <active>true</active>
        <ruleType>8</ruleType>
        <matchHeader></matchHeader>
        <matchValue></matchValue>
        <matchHeaderRegex>false</matchHeaderRegex>
        <matchValueRegex>false</matchValueRegex>
        <matchRequest>false</matchRequest>
        <matchResponse>false</matchResponse>
        <newHeader>impression_type</newHeader>
        <newValue>push</newValue>
        <newHeaderRegex>false</newHeaderRegex>
        <newValueRegex>false</newValueRegex>
        <matchWholeValue>false</matchWholeValue>
        <caseSensitive>false</caseSensitive>
        <replaceType>2</replaceType>
      </rewriteRule>
    </rules>
  </rewriteSet>
</rewriteSet-array>

https://is.snssdk.com/api/ad/union/sdk/get_ads/

{
......
		"video": {
			"cover_height": 1280,
			"cover_url": "http://sf1-ttcdn-tos.pstatp.com/img/mosaic-legacy/1be91000a8c62c6ba6221~noop.jpg",
			"cover_width": 720,
			"endcard": "https://www.toutiaopage.com/union/endcard/1629848424707111/?rit=909946692\u0026req_id=ED6EC127-C359-4C18-A41E-3A5F6F499250u3183\u0026ad_sdk_version=1.9.9.0\u0026os=ios\u0026lang=cn\u0026style_id=1104\u0026ad_id=1629844369912839\u0026_toutiao_params=%7B%22cid%22%3A1629848424707111%2C%22device_id%22%3A9724339963504202%2C%22log_extra%22%3A%22%7B%5C%22ad_price%5C%22%3A%5C%22XOub4AAGRWZc65vgAAZFZgz-hMMMgth42hwxAg%5C%22%2C%5C%22convert_id%5C%22%3A1629408290774020%2C%5C%22orit%5C%22%3A900000000%2C%5C%22req_id%5C%22%3A%5C%22ED6EC127-C359-4C18-A41E-3A5F6F499250u3183%5C%22%2C%5C%22rit%5C%22%3A909946692%7D%22%2C%22orit%22%3A900000000%2C%22req_id%22%3A%22ED6EC127-C359-4C18-A41E-3A5F6F499250u3183%22%2C%22rit%22%3A909946692%2C%22sign%22%3A%22D41D8CD98F00B204E9800998ECF8427E%22%2C%22uid%22%3A9724339963504202%2C%22ut%22%3A14%7D\u0026append=%7B%22openurl%22%3A%22%22%2C%22postdata%22%3A%5B%7B%22__type__%22%3A%22req_id%22%2C%22cid%22%3A1629848424707111%2C%22req_id%22%3A%22ED6EC127-C359-4C18-A41E-3A5F6F499250u3183%22%2C%22rit%22%3A909946692%7D%5D%7D",
			"resolution": "720x1280",
			"size": 5628226,
			"video_duration": 29.04,
			"video_url": "http://vd2.bdstatic.com/mda-jesntzw6569xqudw/mda-jesntzw6569xqudw.mp4"
		}
	}],
......
}

Match Value:
"video_url":"(.+)"}

Replace Value:
"video_url":"http://vd2.bdstatic.com/mda-jesntzw6569xqudw/mda.mp4"}

http://vd2.bdstatic.com/mda-jesntzw6569xqudw/mda-jesntzw6569xqudw.mp4

Get https://v3-ad.ixigua.com/.../video/m/.../toutiao.mp4

替换为只有3秒的视频地址
Get http://vd2.bdstatic.com/.../3seconds.mp4

value肯定与成绩相关
hash(value)

function _gameReport(score, callBack, hash, time){
    var oAjax = null;
    //这里进行HTTP请求
    oAjax = new XMLHttpRequest();
    oAjax.open('post',HOSTURLAPI+"/rest/game_report"+"?uid="+UID+"&gameid="+GAMEID+"&score="+score+"&tm="+time+"&hash="+hash,true);
}

function gameReport(score, callBack){
    var timeData = new Date().getTime();
    var hashValue = UID+GAMEID+score+timeData;
    var hash = '';
    dsBridge.call('hashCode',hashValue,function(data){
        hash = data;
        _gameReport(score, callBack, hash, timeData);
    });
}

gameReport(b[0], function(success, old_score){})

Match Value:
gameReport(b[0]

Replace Value:
gameReport('99'

➜  ~ mitmproxy --set scripts=ad_short_mitm.py '~u baidu\.com'

➜  ~ mitmproxy

➜  ~ mitmproxy --help
usage: mitmproxy [options]
...
Proxy Options:
  --no-server, -n
  --server              Start a proxy server. Enabled by default.

➜  ~ mitmproxy

➜  ~ mitmproxy --no-server

curl -H 'Host:zhuanpan.dftoutiao.com' -H 'Content-Type:application/x-www-form-urlencoded' -H 'Connection:keep-alive' -H 'Accept:*/*' -H 'User-Agent:DFTT/2.4.8 (iPhone; iOS 12.3.1; Scale/3.00)' -H 'Accept-Language:zh-Hans-CN;q=1, en-CN;q=0.9, zh-Hant-CN;q=0.8' -H 'Content-Length:484' -H 'Accept-Encoding:br, gzip, deflate' -X POST 'https://zhuanpan.dftoutiao.com/zhuanpan/get_zhuanpan_new' --data-binary 'accid=834536089&appqid=AppStore190602&apptypeid=DFTT&appver=2.4.8&device=iPhone%206s%20Plus%20%28A1634/A1687%29&deviceid=AE9418A1-561A-4F5C-AF05-1EC222A50CF3&fr=rwzx&ime=F2B14555-E2EB-4556-B757-2C55799C92C2&lt=d2RlWExGb015UjRqSkxMZk0rRkYwcTAzd0I3RmErMWRLbzZsYTc4dkFtakxLMmgvdW9xWFhYUEFNdU9XTHZMV3F6cWNhVXRPalBSMkJNUHlvTktRbnc9PQ%3D%3D&network=wifi&num=57&os=iOS%2012.3.1&position=%E6%B5%99%E6%B1%9F&sign=5aac4e159e8d205c084c9f9e6cf4e41f&softname=DFTTIOS&softtype=TouTiao&ts=1564368354'

from mitmproxy import ctx
from mitmproxy import flowfilter
from mitmproxy import http
from mitmproxy import addonmanager

class Myaddon(object):

    def __init__(self):
        pass

    def load(self, entry: addonmanager.Loader):
        pass

    def request(self, flow: http.HTTPFlow):
        pass

    def response(self, flow: http.HTTPFlow):
        pass

addons = [
    Myaddon()
]

import json
import re

from mitmproxy import ctx
from mitmproxy import flowfilter
from mitmproxy import http

class Zhuangpan(object):
    def __init__(self):
        self.filter = flowfilter.parse(r'(~u zhuanpan/get_zhuanpan_new) | (~u zhuanpan/get_gold)')
        self.new_fliter = flowfilter.parse(r'~u zhuanpan/get_zhuanpan_new') 
        self.get_fliter = flowfilter.parse(r'~u zhuanpan/get_gold')
        self.flows = []
        self.urls = set()
        self.remain = 0

addons = [
    Zhuangpan()
]

# mitmproxy/flowfilter.py文件
def parse(s: str) -> TFilter:

# 还定义了：
def match(flt, flow):
    """
        Matches a flow against a compiled filter expression.
        Returns True if matched, False if not.
        ....
    """

class Zhuangpan(object):
    ...
    def request(self, flow: http.HTTPFlow):               
        if flowfilter.match(self.filter, flow):
            url = flow.request.url
            if not url in self.urls: 
                ctx.log.alert(url)
                self.flows.append(flow)
                self.urls.add(url)

class Zhuangpan(object):                       
    ...
    def response(self, flow: http.HTTPFlow):
        if flowfilter.match(self.new_fliter, flow):
            flow.response.replace(r'"gold":0', '"gold":999')

            text = flow.response.text
            data = json.loads(text)
            self.remain = data.get('data').get('cur_num')
            ctx.log.alert('remain count:{}'.format(self.remain))

        if flowfilter.match(self.get_fliter, flow):
            if self.remain > 0 and len(self.urls) >= 2:                
                flows = [f.copy() for f in self.flows]
                ctx.master.commands.call("replay.client", flows)

➜  ~ mitmdump --scripts zhuangpan_mitm.py
Loading script zhuangpan_mitm.py
Proxy server listening at http://*:8080

  # --scripts SCRIPT, -s SCRIPT
                        Execute a script. May be passed multiple times.

mitmdump --set userid=zhj -s "mitm_user_xxx.py"  -s math_mitm.py '~u mapi.hddgood.com'

mitmdump --set replacements='/~s/"video_url":"(.+)"}/"video_url":"https://vd3.bdstatic.com/abc.mp4"}'

# 代码里可以调用
ctx.master.commands.call("replay.client", [flow])

ctx.master.commands.execute("view.focus.go 0")

# Ignore everything but example.com and mitmproxy.org:
--ignore-hosts '^(?!example\.com)(?!mitmproxy\.org)'

正则表达式：反前瞻
反前瞻：要匹配某个模式时，需要在它 后面找不到含有给定前瞻模式的内容
foo(?!bar)  Negative lookahead assertion. The pattern foo will only match if not followed by a match of pattern bar.

入口方法：
def mitmproxy(args=None) -> typing.Optional[int]:
    run(console.master.ConsoleMaster)

def mitmdump(args=None) -> typing.Optional[int]:
    run(dump.DumpMaster)
    
主要代码
def run(master_cls):

    opts   = options.Options()
    master = master_cls(opts)
    
    pconf  = proxy.config.ProxyConfig(opts)
    server = proxy.server.ProxyServer(pconf)
    
    master.server = server
    master.run()
    return master
    
    

master.Master
    console.master.ConsoleMaster
    dump.DumpMaster
    web.master.WebMaster

Server
    proxy.server.ProxyServer
    proxy.server.DummyServer


Master与Server关系：
    master.server = server


Master和Server对象生成：
    Master(opts: options.Options)
    Server(config: config.ProxyConfig)

ProxyConfig与Options关系：
    ProxyConfig(options: options.Options)

开始运行：
    master.run()
        master.start()

    def start(self):
        if self.server:
            ServerThread(self.server).start()

class ServerThread(basethread.BaseThread):
    def __init__(self, server):
        self.server = server
        address = getattr(self.server, "address", None)
        super().__init__(
            "ServerThread ({})".format(repr(address))
        )

    def run(self):
        self.server.serve_forever()

线程：
    ServerThread
    connection_thread

    def connection_thread(self, connection, client_address):
        with self.handler_counter:
            try:
                self.handle_client_connection(connection, client_address)
            finally:
                close_socket(connection)


    def handle_client_connection(self, conn, client_address):
        h = ConnectionHandler(
            conn,
            client_address,
            self.config,
            self.channel
        )
        h.handle()

    def handle(self):
        self.log("clientconnect", "info")

        root_layer = None
        root_layer = self._create_root_layer()
        root_layer = self.channel.ask("clientconnect", root_layer)
        root_layer()

        self.log("clientdisconnect", "info")

    def _create_root_layer(self):
        root_ctx = ...
        mode = self.config.options.mode
        if mode.startswith("upstream:"):
            return modes.HttpUpstreamProxy
        elif mode == "transparent":
            return modes.TransparentProxy(root_ctx)
        elif mode == "regular":
            return modes.HttpProxy(root_ctx)
        

addons的运行过程[生命周期]
[1]. "load"
[2]. "running"
[3]. "configure"

[1]. "load"
DumpMaster.__init__(self,options):
    super().__init__(options)
    self.addons.add(*addons.default_addons())

AddonManager.add(self, *addons):
    for i in addons:
        self.chain.append(self.register(i))
        
AddonManager.register(self, addon):
    l = Loader(self.master)
    self.invoke_addon(addon, "load", l)
    
[2]. "running"
master.run():
    loop = asyncio.get_event_loop()
    self.run_loop(loop.run_forever)
        
    master.run_loop(self, loop):
        asyncio.ensure_future(self.running())
        
    master.running(self):
        self.addons.trigger("running")
        
[3]. "configure"
class AddonManager:
    def __init__(self, master):
        self.lookup = {}
        self.chain = []
        self.master = master
        master.options.changed.connect(self._configure_all)

    def _configure_all(self, options, updated):
        self.trigger("configure", updated)