feat: intergrate itchat to lib

lib/itchat/components/__init__.py

@@ -0,0 +1,12 @@
+from .contact import load_contact
+from .hotreload import load_hotreload
+from .login import load_login
+from .messages import load_messages
+from .register import load_register
+
+def load_components(core):
+    load_contact(core)
+    load_hotreload(core)
+    load_login(core)
+    load_messages(core)
+    load_register(core)

lib/itchat/components/contact.py

@@ -0,0 +1,519 @@
+import time
+import re
+import io
+import json
+import copy
+import logging
+
+from .. import config, utils
+from ..returnvalues import ReturnValue
+from ..storage import contact_change
+from ..utils import update_info_dict
+
+logger = logging.getLogger('itchat')
+
+
+def load_contact(core):
+    core.update_chatroom = update_chatroom
+    core.update_friend = update_friend
+    core.get_contact = get_contact
+    core.get_friends = get_friends
+    core.get_chatrooms = get_chatrooms
+    core.get_mps = get_mps
+    core.set_alias = set_alias
+    core.set_pinned = set_pinned
+    core.accept_friend = accept_friend
+    core.get_head_img = get_head_img
+    core.create_chatroom = create_chatroom
+    core.set_chatroom_name = set_chatroom_name
+    core.delete_member_from_chatroom = delete_member_from_chatroom
+    core.add_member_into_chatroom = add_member_into_chatroom
+
+
+def update_chatroom(self, userName, detailedMember=False):
+    if not isinstance(userName, list):
+        userName = [userName]
+    url = '%s/webwxbatchgetcontact?type=ex&r=%s' % (
+        self.loginInfo['url'], int(time.time()))
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Count': len(userName),
+        'List': [{
+            'UserName': u,
+            'ChatRoomId': '', } for u in userName], }
+    chatroomList = json.loads(self.s.post(url, data=json.dumps(data), headers=headers
+                                          ).content.decode('utf8', 'replace')).get('ContactList')
+    if not chatroomList:
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'No chatroom found',
+            'Ret': -1001, }})
+
+    if detailedMember:
+        def get_detailed_member_info(encryChatroomId, memberList):
+            url = '%s/webwxbatchgetcontact?type=ex&r=%s' % (
+                self.loginInfo['url'], int(time.time()))
+            headers = {
+                'ContentType': 'application/json; charset=UTF-8',
+                'User-Agent': config.USER_AGENT, }
+            data = {
+                'BaseRequest': self.loginInfo['BaseRequest'],
+                'Count': len(memberList),
+                'List': [{
+                    'UserName': member['UserName'],
+                    'EncryChatRoomId': encryChatroomId}
+                    for member in memberList], }
+            return json.loads(self.s.post(url, data=json.dumps(data), headers=headers
+                                          ).content.decode('utf8', 'replace'))['ContactList']
+        MAX_GET_NUMBER = 50
+        for chatroom in chatroomList:
+            totalMemberList = []
+            for i in range(int(len(chatroom['MemberList']) / MAX_GET_NUMBER + 1)):
+                memberList = chatroom['MemberList'][i *
+                                                    MAX_GET_NUMBER: (i+1)*MAX_GET_NUMBER]
+                totalMemberList += get_detailed_member_info(
+                    chatroom['EncryChatRoomId'], memberList)
+            chatroom['MemberList'] = totalMemberList
+
+    update_local_chatrooms(self, chatroomList)
+    r = [self.storageClass.search_chatrooms(userName=c['UserName'])
+         for c in chatroomList]
+    return r if 1 < len(r) else r[0]
+
+
+def update_friend(self, userName):
+    if not isinstance(userName, list):
+        userName = [userName]
+    url = '%s/webwxbatchgetcontact?type=ex&r=%s' % (
+        self.loginInfo['url'], int(time.time()))
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Count': len(userName),
+        'List': [{
+            'UserName': u,
+            'EncryChatRoomId': '', } for u in userName], }
+    friendList = json.loads(self.s.post(url, data=json.dumps(data), headers=headers
+                                        ).content.decode('utf8', 'replace')).get('ContactList')
+
+    update_local_friends(self, friendList)
+    r = [self.storageClass.search_friends(userName=f['UserName'])
+         for f in friendList]
+    return r if len(r) != 1 else r[0]
+
+
+@contact_change
+def update_local_chatrooms(core, l):
+    '''
+        get a list of chatrooms for updating local chatrooms
+        return a list of given chatrooms with updated info
+    '''
+    for chatroom in l:
+        # format new chatrooms
+        utils.emoji_formatter(chatroom, 'NickName')
+        for member in chatroom['MemberList']:
+            if 'NickName' in member:
+                utils.emoji_formatter(member, 'NickName')
+            if 'DisplayName' in member:
+                utils.emoji_formatter(member, 'DisplayName')
+            if 'RemarkName' in member:
+                utils.emoji_formatter(member, 'RemarkName')
+        # update it to old chatrooms
+        oldChatroom = utils.search_dict_list(
+            core.chatroomList, 'UserName', chatroom['UserName'])
+        if oldChatroom:
+            update_info_dict(oldChatroom, chatroom)
+            #  - update other values
+            memberList = chatroom.get('MemberList', [])
+            oldMemberList = oldChatroom['MemberList']
+            if memberList:
+                for member in memberList:
+                    oldMember = utils.search_dict_list(
+                        oldMemberList, 'UserName', member['UserName'])
+                    if oldMember:
+                        update_info_dict(oldMember, member)
+                    else:
+                        oldMemberList.append(member)
+        else:
+            core.chatroomList.append(chatroom)
+            oldChatroom = utils.search_dict_list(
+                core.chatroomList, 'UserName', chatroom['UserName'])
+        # delete useless members
+        if len(chatroom['MemberList']) != len(oldChatroom['MemberList']) and \
+                chatroom['MemberList']:
+            existsUserNames = [member['UserName']
+                               for member in chatroom['MemberList']]
+            delList = []
+            for i, member in enumerate(oldChatroom['MemberList']):
+                if member['UserName'] not in existsUserNames:
+                    delList.append(i)
+            delList.sort(reverse=True)
+            for i in delList:
+                del oldChatroom['MemberList'][i]
+        #  - update OwnerUin
+        if oldChatroom.get('ChatRoomOwner') and oldChatroom.get('MemberList'):
+            owner = utils.search_dict_list(oldChatroom['MemberList'],
+                                           'UserName', oldChatroom['ChatRoomOwner'])
+            oldChatroom['OwnerUin'] = (owner or {}).get('Uin', 0)
+        #  - update IsAdmin
+        if 'OwnerUin' in oldChatroom and oldChatroom['OwnerUin'] != 0:
+            oldChatroom['IsAdmin'] = \
+                oldChatroom['OwnerUin'] == int(core.loginInfo['wxuin'])
+        else:
+            oldChatroom['IsAdmin'] = None
+        #  - update Self
+        newSelf = utils.search_dict_list(oldChatroom['MemberList'],
+                                         'UserName', core.storageClass.userName)
+        oldChatroom['Self'] = newSelf or copy.deepcopy(core.loginInfo['User'])
+    return {
+        'Type': 'System',
+        'Text': [chatroom['UserName'] for chatroom in l],
+        'SystemInfo': 'chatrooms',
+        'FromUserName': core.storageClass.userName,
+        'ToUserName': core.storageClass.userName, }
+
+
+@contact_change
+def update_local_friends(core, l):
+    '''
+        get a list of friends or mps for updating local contact
+    '''
+    fullList = core.memberList + core.mpList
+    for friend in l:
+        if 'NickName' in friend:
+            utils.emoji_formatter(friend, 'NickName')
+        if 'DisplayName' in friend:
+            utils.emoji_formatter(friend, 'DisplayName')
+        if 'RemarkName' in friend:
+            utils.emoji_formatter(friend, 'RemarkName')
+        oldInfoDict = utils.search_dict_list(
+            fullList, 'UserName', friend['UserName'])
+        if oldInfoDict is None:
+            oldInfoDict = copy.deepcopy(friend)
+            if oldInfoDict['VerifyFlag'] & 8 == 0:
+                core.memberList.append(oldInfoDict)
+            else:
+                core.mpList.append(oldInfoDict)
+        else:
+            update_info_dict(oldInfoDict, friend)
+
+
+@contact_change
+def update_local_uin(core, msg):
+    '''
+        content contains uins and StatusNotifyUserName contains username
+        they are in same order, so what I do is to pair them together
+
+        I caught an exception in this method while not knowing why
+        but don't worry, it won't cause any problem
+    '''
+    uins = re.search('<username>([^<]*?)<', msg['Content'])
+    usernameChangedList = []
+    r = {
+        'Type': 'System',
+        'Text': usernameChangedList,
+        'SystemInfo': 'uins', }
+    if uins:
+        uins = uins.group(1).split(',')
+        usernames = msg['StatusNotifyUserName'].split(',')
+        if 0 < len(uins) == len(usernames):
+            for uin, username in zip(uins, usernames):
+                if not '@' in username:
+                    continue
+                fullContact = core.memberList + core.chatroomList + core.mpList
+                userDicts = utils.search_dict_list(fullContact,
+                                                   'UserName', username)
+                if userDicts:
+                    if userDicts.get('Uin', 0) == 0:
+                        userDicts['Uin'] = uin
+                        usernameChangedList.append(username)
+                        logger.debug('Uin fetched: %s, %s' % (username, uin))
+                    else:
+                        if userDicts['Uin'] != uin:
+                            logger.debug('Uin changed: %s, %s' % (
+                                userDicts['Uin'], uin))
+                else:
+                    if '@@' in username:
+                        core.storageClass.updateLock.release()
+                        update_chatroom(core, username)
+                        core.storageClass.updateLock.acquire()
+                        newChatroomDict = utils.search_dict_list(
+                            core.chatroomList, 'UserName', username)
+                        if newChatroomDict is None:
+                            newChatroomDict = utils.struct_friend_info({
+                                'UserName': username,
+                                'Uin': uin,
+                                'Self': copy.deepcopy(core.loginInfo['User'])})
+                            core.chatroomList.append(newChatroomDict)
+                        else:
+                            newChatroomDict['Uin'] = uin
+                    elif '@' in username:
+                        core.storageClass.updateLock.release()
+                        update_friend(core, username)
+                        core.storageClass.updateLock.acquire()
+                        newFriendDict = utils.search_dict_list(
+                            core.memberList, 'UserName', username)
+                        if newFriendDict is None:
+                            newFriendDict = utils.struct_friend_info({
+                                'UserName': username,
+                                'Uin': uin, })
+                            core.memberList.append(newFriendDict)
+                        else:
+                            newFriendDict['Uin'] = uin
+                    usernameChangedList.append(username)
+                    logger.debug('Uin fetched: %s, %s' % (username, uin))
+        else:
+            logger.debug('Wrong length of uins & usernames: %s, %s' % (
+                len(uins), len(usernames)))
+    else:
+        logger.debug('No uins in 51 message')
+        logger.debug(msg['Content'])
+    return r
+
+
+def get_contact(self, update=False):
+    if not update:
+        return utils.contact_deep_copy(self, self.chatroomList)
+
+    def _get_contact(seq=0):
+        url = '%s/webwxgetcontact?r=%s&seq=%s&skey=%s' % (self.loginInfo['url'],
+                                                          int(time.time()), seq, self.loginInfo['skey'])
+        headers = {
+            'ContentType': 'application/json; charset=UTF-8',
+            'User-Agent': config.USER_AGENT, }
+        try:
+            r = self.s.get(url, headers=headers)
+        except:
+            logger.info(
+                'Failed to fetch contact, that may because of the amount of your chatrooms')
+            for chatroom in self.get_chatrooms():
+                self.update_chatroom(chatroom['UserName'], detailedMember=True)
+            return 0, []
+        j = json.loads(r.content.decode('utf-8', 'replace'))
+        return j.get('Seq', 0), j.get('MemberList')
+    seq, memberList = 0, []
+    while 1:
+        seq, batchMemberList = _get_contact(seq)
+        memberList.extend(batchMemberList)
+        if seq == 0:
+            break
+    chatroomList, otherList = [], []
+    for m in memberList:
+        if m['Sex'] != 0:
+            otherList.append(m)
+        elif '@@' in m['UserName']:
+            chatroomList.append(m)
+        elif '@' in m['UserName']:
+            # mp will be dealt in update_local_friends as well
+            otherList.append(m)
+    if chatroomList:
+        update_local_chatrooms(self, chatroomList)
+    if otherList:
+        update_local_friends(self, otherList)
+    return utils.contact_deep_copy(self, chatroomList)
+
+
+def get_friends(self, update=False):
+    if update:
+        self.get_contact(update=True)
+    return utils.contact_deep_copy(self, self.memberList)
+
+
+def get_chatrooms(self, update=False, contactOnly=False):
+    if contactOnly:
+        return self.get_contact(update=True)
+    else:
+        if update:
+            self.get_contact(True)
+        return utils.contact_deep_copy(self, self.chatroomList)
+
+
+def get_mps(self, update=False):
+    if update:
+        self.get_contact(update=True)
+    return utils.contact_deep_copy(self, self.mpList)
+
+
+def set_alias(self, userName, alias):
+    oldFriendInfo = utils.search_dict_list(
+        self.memberList, 'UserName', userName)
+    if oldFriendInfo is None:
+        return ReturnValue({'BaseResponse': {
+            'Ret': -1001, }})
+    url = '%s/webwxoplog?lang=%s&pass_ticket=%s' % (
+        self.loginInfo['url'], 'zh_CN', self.loginInfo['pass_ticket'])
+    data = {
+        'UserName': userName,
+        'CmdId': 2,
+        'RemarkName': alias,
+        'BaseRequest': self.loginInfo['BaseRequest'], }
+    headers = {'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, json.dumps(data, ensure_ascii=False).encode('utf8'),
+                    headers=headers)
+    r = ReturnValue(rawResponse=r)
+    if r:
+        oldFriendInfo['RemarkName'] = alias
+    return r
+
+
+def set_pinned(self, userName, isPinned=True):
+    url = '%s/webwxoplog?pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'])
+    data = {
+        'UserName': userName,
+        'CmdId': 3,
+        'OP': int(isPinned),
+        'BaseRequest': self.loginInfo['BaseRequest'], }
+    headers = {'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, json=data, headers=headers)
+    return ReturnValue(rawResponse=r)
+
+
+def accept_friend(self, userName, v4='', autoUpdate=True):
+    url = f"{self.loginInfo['url']}/webwxverifyuser?r={int(time.time())}&pass_ticket={self.loginInfo['pass_ticket']}"
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Opcode': 3,  # 3
+        'VerifyUserListSize': 1,
+        'VerifyUserList': [{
+            'Value': userName,
+            'VerifyUserTicket': v4, }],
+        'VerifyContent': '',
+        'SceneListCount': 1,
+        'SceneList': [33],
+        'skey': self.loginInfo['skey'], }
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, headers=headers,
+                    data=json.dumps(data, ensure_ascii=False).encode('utf8', 'replace'))
+    if autoUpdate:
+        self.update_friend(userName)
+    return ReturnValue(rawResponse=r)
+
+
+def get_head_img(self, userName=None, chatroomUserName=None, picDir=None):
+    ''' get head image
+     * if you want to get chatroom header: only set chatroomUserName
+     * if you want to get friend header: only set userName
+     * if you want to get chatroom member header: set both
+    '''
+    params = {
+        'userName': userName or chatroomUserName or self.storageClass.userName,
+        'skey': self.loginInfo['skey'],
+        'type': 'big', }
+    url = '%s/webwxgeticon' % self.loginInfo['url']
+    if chatroomUserName is None:
+        infoDict = self.storageClass.search_friends(userName=userName)
+        if infoDict is None:
+            return ReturnValue({'BaseResponse': {
+                'ErrMsg': 'No friend found',
+                'Ret': -1001, }})
+    else:
+        if userName is None:
+            url = '%s/webwxgetheadimg' % self.loginInfo['url']
+        else:
+            chatroom = self.storageClass.search_chatrooms(
+                userName=chatroomUserName)
+            if chatroomUserName is None:
+                return ReturnValue({'BaseResponse': {
+                    'ErrMsg': 'No chatroom found',
+                    'Ret': -1001, }})
+            if 'EncryChatRoomId' in chatroom:
+                params['chatroomid'] = chatroom['EncryChatRoomId']
+            params['chatroomid'] = params.get(
+                'chatroomid') or chatroom['UserName']
+    headers = {'User-Agent': config.USER_AGENT}
+    r = self.s.get(url, params=params, stream=True, headers=headers)
+    tempStorage = io.BytesIO()
+    for block in r.iter_content(1024):
+        tempStorage.write(block)
+    if picDir is None:
+        return tempStorage.getvalue()
+    with open(picDir, 'wb') as f:
+        f.write(tempStorage.getvalue())
+    tempStorage.seek(0)
+    return ReturnValue({'BaseResponse': {
+        'ErrMsg': 'Successfully downloaded',
+        'Ret': 0, },
+        'PostFix': utils.get_image_postfix(tempStorage.read(20)), })
+
+
+def create_chatroom(self, memberList, topic=''):
+    url = '%s/webwxcreatechatroom?pass_ticket=%s&r=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'], int(time.time()))
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'MemberCount': len(memberList.split(',')),
+        'MemberList': [{'UserName': member} for member in memberList.split(',')],
+        'Topic': topic, }
+    headers = {
+        'content-type': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, headers=headers,
+                    data=json.dumps(data, ensure_ascii=False).encode('utf8', 'ignore'))
+    return ReturnValue(rawResponse=r)
+
+
+def set_chatroom_name(self, chatroomUserName, name):
+    url = '%s/webwxupdatechatroom?fun=modtopic&pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'])
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'ChatRoomName': chatroomUserName,
+        'NewTopic': name, }
+    headers = {
+        'content-type': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, headers=headers,
+                    data=json.dumps(data, ensure_ascii=False).encode('utf8', 'ignore'))
+    return ReturnValue(rawResponse=r)
+
+
+def delete_member_from_chatroom(self, chatroomUserName, memberList):
+    url = '%s/webwxupdatechatroom?fun=delmember&pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'])
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'ChatRoomName': chatroomUserName,
+        'DelMemberList': ','.join([member['UserName'] for member in memberList]), }
+    headers = {
+        'content-type': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, data=json.dumps(data), headers=headers)
+    return ReturnValue(rawResponse=r)
+
+
+def add_member_into_chatroom(self, chatroomUserName, memberList,
+                             useInvitation=False):
+    ''' add or invite member into chatroom
+     * there are two ways to get members into chatroom: invite or directly add
+     * but for chatrooms with more than 40 users, you can only use invite
+     * but don't worry we will auto-force userInvitation for you when necessary
+    '''
+    if not useInvitation:
+        chatroom = self.storageClass.search_chatrooms(
+            userName=chatroomUserName)
+        if not chatroom:
+            chatroom = self.update_chatroom(chatroomUserName)
+        if len(chatroom['MemberList']) > self.loginInfo['InviteStartCount']:
+            useInvitation = True
+    if useInvitation:
+        fun, memberKeyName = 'invitemember', 'InviteMemberList'
+    else:
+        fun, memberKeyName = 'addmember', 'AddMemberList'
+    url = '%s/webwxupdatechatroom?fun=%s&pass_ticket=%s' % (
+        self.loginInfo['url'], fun, self.loginInfo['pass_ticket'])
+    params = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'ChatRoomName': chatroomUserName,
+        memberKeyName: memberList, }
+    headers = {
+        'content-type': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, data=json.dumps(params), headers=headers)
+    return ReturnValue(rawResponse=r)

lib/itchat/components/hotreload.py

@@ -0,0 +1,102 @@
+import pickle, os
+import logging
+
+import requests
+
+from ..config import VERSION
+from ..returnvalues import ReturnValue
+from ..storage import templates
+from .contact import update_local_chatrooms, update_local_friends
+from .messages import produce_msg
+
+logger = logging.getLogger('itchat')
+
+def load_hotreload(core):
+    core.dump_login_status = dump_login_status
+    core.load_login_status = load_login_status
+
+def dump_login_status(self, fileDir=None):
+    fileDir = fileDir or self.hotReloadDir
+    try:
+        with open(fileDir, 'w') as f:
+            f.write('itchat - DELETE THIS')
+        os.remove(fileDir)
+    except:
+        raise Exception('Incorrect fileDir')
+    status = {
+        'version'   : VERSION,
+        'loginInfo' : self.loginInfo,
+        'cookies'   : self.s.cookies.get_dict(),
+        'storage'   : self.storageClass.dumps()}
+    with open(fileDir, 'wb') as f:
+        pickle.dump(status, f)
+    logger.debug('Dump login status for hot reload successfully.')
+
+def load_login_status(self, fileDir,
+        loginCallback=None, exitCallback=None):
+    try:
+        with open(fileDir, 'rb') as f:
+            j = pickle.load(f)
+    except Exception as e:
+        logger.debug('No such file, loading login status failed.')
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'No such file, loading login status failed.',
+            'Ret': -1002, }})
+
+    if j.get('version', '') != VERSION:
+        logger.debug(('you have updated itchat from %s to %s, ' + 
+            'so cached status is ignored') % (
+            j.get('version', 'old version'), VERSION))
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'cached status ignored because of version',
+            'Ret': -1005, }})
+    self.loginInfo = j['loginInfo']
+    self.loginInfo['User'] = templates.User(self.loginInfo['User'])
+    self.loginInfo['User'].core = self
+    self.s.cookies = requests.utils.cookiejar_from_dict(j['cookies'])
+    self.storageClass.loads(j['storage'])
+    try:
+        msgList, contactList = self.get_msg()
+    except:
+        msgList = contactList = None
+    if (msgList or contactList) is None:
+        self.logout()
+        load_last_login_status(self.s, j['cookies'])
+        logger.debug('server refused, loading login status failed.')
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'server refused, loading login status failed.',
+            'Ret': -1003, }})
+    else:
+        if contactList:
+            for contact in contactList:
+                if '@@' in contact['UserName']:
+                    update_local_chatrooms(self, [contact])
+                else:
+                    update_local_friends(self, [contact])
+        if msgList:
+            msgList = produce_msg(self, msgList)
+            for msg in msgList: self.msgList.put(msg)
+        self.start_receiving(exitCallback)
+        logger.debug('loading login status succeeded.')
+        if hasattr(loginCallback, '__call__'):
+            loginCallback()
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'loading login status succeeded.',
+            'Ret': 0, }})
+
+def load_last_login_status(session, cookiesDict):
+    try:
+        session.cookies = requests.utils.cookiejar_from_dict({
+            'webwxuvid': cookiesDict['webwxuvid'],
+            'webwx_auth_ticket': cookiesDict['webwx_auth_ticket'],
+            'login_frequency': '2',
+            'last_wxuin': cookiesDict['wxuin'],
+            'wxloadtime': cookiesDict['wxloadtime'] + '_expired',
+            'wxpluginkey': cookiesDict['wxloadtime'],
+            'wxuin': cookiesDict['wxuin'],
+            'mm_lang': 'zh_CN',
+            'MM_WX_NOTIFY_STATE': '1',
+            'MM_WX_SOUND_STATE': '1', })
+    except:
+        logger.info('Load status for push login failed, we may have experienced a cookies change.')
+        logger.info('If you are using the newest version of itchat, you may report a bug.')

lib/itchat/components/login.py

@@ -0,0 +1,410 @@
+import os
+import time
+import re
+import io
+import threading
+import json
+import xml.dom.minidom
+import random
+import traceback
+import logging
+try:
+    from httplib import BadStatusLine
+except ImportError:
+    from http.client import BadStatusLine
+
+import requests
+from pyqrcode import QRCode
+
+from .. import config, utils
+from ..returnvalues import ReturnValue
+from ..storage.templates import wrap_user_dict
+from .contact import update_local_chatrooms, update_local_friends
+from .messages import produce_msg
+
+logger = logging.getLogger('itchat')
+
+
+def load_login(core):
+    core.login = login
+    core.get_QRuuid = get_QRuuid
+    core.get_QR = get_QR
+    core.check_login = check_login
+    core.web_init = web_init
+    core.show_mobile_login = show_mobile_login
+    core.start_receiving = start_receiving
+    core.get_msg = get_msg
+    core.logout = logout
+
+
+def login(self, enableCmdQR=False, picDir=None, qrCallback=None,
+          loginCallback=None, exitCallback=None):
+    if self.alive or self.isLogging:
+        logger.warning('itchat has already logged in.')
+        return
+    self.isLogging = True
+    while self.isLogging:
+        uuid = push_login(self)
+        if uuid:
+            qrStorage = io.BytesIO()
+        else:
+            logger.info('Getting uuid of QR code.')
+            while not self.get_QRuuid():
+                time.sleep(1)
+            logger.info('Downloading QR code.')
+            qrStorage = self.get_QR(enableCmdQR=enableCmdQR,
+                                    picDir=picDir, qrCallback=qrCallback)
+            logger.info('Please scan the QR code to log in.')
+        isLoggedIn = False
+        while not isLoggedIn:
+            status = self.check_login()
+            if hasattr(qrCallback, '__call__'):
+                qrCallback(uuid=self.uuid, status=status,
+                           qrcode=qrStorage.getvalue())
+            if status == '200':
+                isLoggedIn = True
+            elif status == '201':
+                if isLoggedIn is not None:
+                    logger.info('Please press confirm on your phone.')
+                    isLoggedIn = None
+                    time.sleep(7)
+            elif status != '408':
+                break
+        if isLoggedIn:
+            break
+        elif self.isLogging:
+            logger.info('Log in time out, reloading QR code.')
+    else:
+        return  # log in process is stopped by user
+    logger.info('Loading the contact, this may take a little while.')
+    self.web_init()
+    self.show_mobile_login()
+    self.get_contact(True)
+    if hasattr(loginCallback, '__call__'):
+        r = loginCallback()
+    else:
+        utils.clear_screen()
+        if os.path.exists(picDir or config.DEFAULT_QR):
+            os.remove(picDir or config.DEFAULT_QR)
+        logger.info('Login successfully as %s' % self.storageClass.nickName)
+    self.start_receiving(exitCallback)
+    self.isLogging = False
+
+
+def push_login(core):
+    cookiesDict = core.s.cookies.get_dict()
+    if 'wxuin' in cookiesDict:
+        url = '%s/cgi-bin/mmwebwx-bin/webwxpushloginurl?uin=%s' % (
+            config.BASE_URL, cookiesDict['wxuin'])
+        headers = {'User-Agent': config.USER_AGENT}
+        r = core.s.get(url, headers=headers).json()
+        if 'uuid' in r and r.get('ret') in (0, '0'):
+            core.uuid = r['uuid']
+            return r['uuid']
+    return False
+
+
+def get_QRuuid(self):
+    url = '%s/jslogin' % config.BASE_URL
+    params = {
+        'appid': 'wx782c26e4c19acffb',
+        'fun': 'new',
+        'redirect_uri': 'https://wx.qq.com/cgi-bin/mmwebwx-bin/webwxnewloginpage?mod=desktop',
+        'lang': 'zh_CN'}
+    headers = {'User-Agent': config.USER_AGENT}
+    r = self.s.get(url, params=params, headers=headers)
+    regx = r'window.QRLogin.code = (\d+); window.QRLogin.uuid = "(\S+?)";'
+    data = re.search(regx, r.text)
+    if data and data.group(1) == '200':
+        self.uuid = data.group(2)
+        return self.uuid
+
+
+def get_QR(self, uuid=None, enableCmdQR=False, picDir=None, qrCallback=None):
+    uuid = uuid or self.uuid
+    picDir = picDir or config.DEFAULT_QR
+    qrStorage = io.BytesIO()
+    qrCode = QRCode('https://login.weixin.qq.com/l/' + uuid)
+    qrCode.png(qrStorage, scale=10)
+    if hasattr(qrCallback, '__call__'):
+        qrCallback(uuid=uuid, status='0', qrcode=qrStorage.getvalue())
+    else:
+        with open(picDir, 'wb') as f:
+            f.write(qrStorage.getvalue())
+        if enableCmdQR:
+            utils.print_cmd_qr(qrCode.text(1), enableCmdQR=enableCmdQR)
+        else:
+            utils.print_qr(picDir)
+    return qrStorage
+
+
+def check_login(self, uuid=None):
+    uuid = uuid or self.uuid
+    url = '%s/cgi-bin/mmwebwx-bin/login' % config.BASE_URL
+    localTime = int(time.time())
+    params = 'loginicon=true&uuid=%s&tip=1&r=%s&_=%s' % (
+        uuid, int(-localTime / 1579), localTime)
+    headers = {'User-Agent': config.USER_AGENT}
+    r = self.s.get(url, params=params, headers=headers)
+    regx = r'window.code=(\d+)'
+    data = re.search(regx, r.text)
+    if data and data.group(1) == '200':
+        if process_login_info(self, r.text):
+            return '200'
+        else:
+            return '400'
+    elif data:
+        return data.group(1)
+    else:
+        return '400'
+
+
+def process_login_info(core, loginContent):
+    ''' when finish login (scanning qrcode)
+     * syncUrl and fileUploadingUrl will be fetched
+     * deviceid and msgid will be generated
+     * skey, wxsid, wxuin, pass_ticket will be fetched
+    '''
+    regx = r'window.redirect_uri="(\S+)";'
+    core.loginInfo['url'] = re.search(regx, loginContent).group(1)
+    headers = {'User-Agent': config.USER_AGENT,
+               'client-version': config.UOS_PATCH_CLIENT_VERSION,
+               'extspam': config.UOS_PATCH_EXTSPAM,
+               'referer': 'https://wx.qq.com/?&lang=zh_CN&target=t'
+               }
+    r = core.s.get(core.loginInfo['url'],
+                   headers=headers, allow_redirects=False)
+    core.loginInfo['url'] = core.loginInfo['url'][:core.loginInfo['url'].rfind(
+        '/')]
+    for indexUrl, detailedUrl in (
+            ("wx2.qq.com", ("file.wx2.qq.com", "webpush.wx2.qq.com")),
+            ("wx8.qq.com", ("file.wx8.qq.com", "webpush.wx8.qq.com")),
+            ("qq.com", ("file.wx.qq.com", "webpush.wx.qq.com")),
+            ("web2.wechat.com", ("file.web2.wechat.com", "webpush.web2.wechat.com")),
+            ("wechat.com", ("file.web.wechat.com", "webpush.web.wechat.com"))):
+        fileUrl, syncUrl = ['https://%s/cgi-bin/mmwebwx-bin' %
+                            url for url in detailedUrl]
+        if indexUrl in core.loginInfo['url']:
+            core.loginInfo['fileUrl'], core.loginInfo['syncUrl'] = \
+                fileUrl, syncUrl
+            break
+    else:
+        core.loginInfo['fileUrl'] = core.loginInfo['syncUrl'] = core.loginInfo['url']
+    core.loginInfo['deviceid'] = 'e' + repr(random.random())[2:17]
+    core.loginInfo['logintime'] = int(time.time() * 1e3)
+    core.loginInfo['BaseRequest'] = {}
+    cookies = core.s.cookies.get_dict()
+    skey = re.findall('<skey>(.*?)</skey>', r.text, re.S)[0]
+    pass_ticket = re.findall(
+        '<pass_ticket>(.*?)</pass_ticket>', r.text, re.S)[0]
+    core.loginInfo['skey'] = core.loginInfo['BaseRequest']['Skey'] = skey
+    core.loginInfo['wxsid'] = core.loginInfo['BaseRequest']['Sid'] = cookies["wxsid"]
+    core.loginInfo['wxuin'] = core.loginInfo['BaseRequest']['Uin'] = cookies["wxuin"]
+    core.loginInfo['pass_ticket'] = pass_ticket
+    # A question : why pass_ticket == DeviceID ?
+    #               deviceID is only a randomly generated number
+
+    # UOS PATCH By luvletter2333, Sun Feb 28 10:00 PM
+    # for node in xml.dom.minidom.parseString(r.text).documentElement.childNodes:
+    #     if node.nodeName == 'skey':
+    #         core.loginInfo['skey'] = core.loginInfo['BaseRequest']['Skey'] = node.childNodes[0].data
+    #     elif node.nodeName == 'wxsid':
+    #         core.loginInfo['wxsid'] = core.loginInfo['BaseRequest']['Sid'] = node.childNodes[0].data
+    #     elif node.nodeName == 'wxuin':
+    #         core.loginInfo['wxuin'] = core.loginInfo['BaseRequest']['Uin'] = node.childNodes[0].data
+    #     elif node.nodeName == 'pass_ticket':
+    #         core.loginInfo['pass_ticket'] = core.loginInfo['BaseRequest']['DeviceID'] = node.childNodes[0].data
+    if not all([key in core.loginInfo for key in ('skey', 'wxsid', 'wxuin', 'pass_ticket')]):
+        logger.error(
+            'Your wechat account may be LIMITED to log in WEB wechat, error info:\n%s' % r.text)
+        core.isLogging = False
+        return False
+    return True
+
+
+def web_init(self):
+    url = '%s/webwxinit' % self.loginInfo['url']
+    params = {
+        'r': int(-time.time() / 1579),
+        'pass_ticket': self.loginInfo['pass_ticket'], }
+    data = {'BaseRequest': self.loginInfo['BaseRequest'], }
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT, }
+    r = self.s.post(url, params=params, data=json.dumps(data), headers=headers)
+    dic = json.loads(r.content.decode('utf-8', 'replace'))
+    # deal with login info
+    utils.emoji_formatter(dic['User'], 'NickName')
+    self.loginInfo['InviteStartCount'] = int(dic['InviteStartCount'])
+    self.loginInfo['User'] = wrap_user_dict(
+        utils.struct_friend_info(dic['User']))
+    self.memberList.append(self.loginInfo['User'])
+    self.loginInfo['SyncKey'] = dic['SyncKey']
+    self.loginInfo['synckey'] = '|'.join(['%s_%s' % (item['Key'], item['Val'])
+                                          for item in dic['SyncKey']['List']])
+    self.storageClass.userName = dic['User']['UserName']
+    self.storageClass.nickName = dic['User']['NickName']
+    # deal with contact list returned when init
+    contactList = dic.get('ContactList', [])
+    chatroomList, otherList = [], []
+    for m in contactList:
+        if m['Sex'] != 0:
+            otherList.append(m)
+        elif '@@' in m['UserName']:
+            m['MemberList'] = []  # don't let dirty info pollute the list
+            chatroomList.append(m)
+        elif '@' in m['UserName']:
+            # mp will be dealt in update_local_friends as well
+            otherList.append(m)
+    if chatroomList:
+        update_local_chatrooms(self, chatroomList)
+    if otherList:
+        update_local_friends(self, otherList)
+    return dic
+
+
+def show_mobile_login(self):
+    url = '%s/webwxstatusnotify?lang=zh_CN&pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'])
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Code': 3,
+        'FromUserName': self.storageClass.userName,
+        'ToUserName': self.storageClass.userName,
+        'ClientMsgId': int(time.time()), }
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT, }
+    r = self.s.post(url, data=json.dumps(data), headers=headers)
+    return ReturnValue(rawResponse=r)
+
+
+def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
+    self.alive = True
+
+    def maintain_loop():
+        retryCount = 0
+        while self.alive:
+            try:
+                i = sync_check(self)
+                if i is None:
+                    self.alive = False
+                elif i == '0':
+                    pass
+                else:
+                    msgList, contactList = self.get_msg()
+                    if msgList:
+                        msgList = produce_msg(self, msgList)
+                        for msg in msgList:
+                            self.msgList.put(msg)
+                    if contactList:
+                        chatroomList, otherList = [], []
+                        for contact in contactList:
+                            if '@@' in contact['UserName']:
+                                chatroomList.append(contact)
+                            else:
+                                otherList.append(contact)
+                        chatroomMsg = update_local_chatrooms(
+                            self, chatroomList)
+                        chatroomMsg['User'] = self.loginInfo['User']
+                        self.msgList.put(chatroomMsg)
+                        update_local_friends(self, otherList)
+                retryCount = 0
+            except requests.exceptions.ReadTimeout:
+                pass
+            except:
+                retryCount += 1
+                logger.error(traceback.format_exc())
+                if self.receivingRetryCount < retryCount:
+                    self.alive = False
+                else:
+                    time.sleep(1)
+        self.logout()
+        if hasattr(exitCallback, '__call__'):
+            exitCallback()
+        else:
+            logger.info('LOG OUT!')
+    if getReceivingFnOnly:
+        return maintain_loop
+    else:
+        maintainThread = threading.Thread(target=maintain_loop)
+        maintainThread.setDaemon(True)
+        maintainThread.start()
+
+
+def sync_check(self):
+    url = '%s/synccheck' % self.loginInfo.get('syncUrl', self.loginInfo['url'])
+    params = {
+        'r': int(time.time() * 1000),
+        'skey': self.loginInfo['skey'],
+        'sid': self.loginInfo['wxsid'],
+        'uin': self.loginInfo['wxuin'],
+        'deviceid': self.loginInfo['deviceid'],
+        'synckey': self.loginInfo['synckey'],
+        '_': self.loginInfo['logintime'], }
+    headers = {'User-Agent': config.USER_AGENT}
+    self.loginInfo['logintime'] += 1
+    try:
+        r = self.s.get(url, params=params, headers=headers,
+                       timeout=config.TIMEOUT)
+    except requests.exceptions.ConnectionError as e:
+        try:
+            if not isinstance(e.args[0].args[1], BadStatusLine):
+                raise
+            # will return a package with status '0 -'
+            # and value like:
+            # 6f:00:8a:9c:09:74:e4:d8:e0:14:bf:96:3a:56:a0:64:1b:a4:25:5d:12:f4:31:a5:30:f1:c6:48:5f:c3:75:6a:99:93
+            # seems like status of typing, but before I make further achievement code will remain like this
+            return '2'
+        except:
+            raise
+    r.raise_for_status()
+    regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'
+    pm = re.search(regx, r.text)
+    if pm is None or pm.group(1) != '0':
+        logger.debug('Unexpected sync check result: %s' % r.text)
+        return None
+    return pm.group(2)
+
+
+def get_msg(self):
+    self.loginInfo['deviceid'] = 'e' + repr(random.random())[2:17]
+    url = '%s/webwxsync?sid=%s&skey=%s&pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['wxsid'],
+        self.loginInfo['skey'], self.loginInfo['pass_ticket'])
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'SyncKey': self.loginInfo['SyncKey'],
+        'rr': ~int(time.time()), }
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent': config.USER_AGENT}
+    r = self.s.post(url, data=json.dumps(data),
+                    headers=headers, timeout=config.TIMEOUT)
+    dic = json.loads(r.content.decode('utf-8', 'replace'))
+    if dic['BaseResponse']['Ret'] != 0:
+        return None, None
+    self.loginInfo['SyncKey'] = dic['SyncKey']
+    self.loginInfo['synckey'] = '|'.join(['%s_%s' % (item['Key'], item['Val'])
+                                          for item in dic['SyncCheckKey']['List']])
+    return dic['AddMsgList'], dic['ModContactList']
+
+
+def logout(self):
+    if self.alive:
+        url = '%s/webwxlogout' % self.loginInfo['url']
+        params = {
+            'redirect': 1,
+            'type': 1,
+            'skey': self.loginInfo['skey'], }
+        headers = {'User-Agent': config.USER_AGENT}
+        self.s.get(url, params=params, headers=headers)
+        self.alive = False
+    self.isLogging = False
+    self.s.cookies.clear()
+    del self.chatroomList[:]
+    del self.memberList[:]
+    del self.mpList[:]
+    return ReturnValue({'BaseResponse': {
+        'ErrMsg': 'logout successfully.',
+        'Ret': 0, }})

lib/itchat/components/messages.py

@@ -0,0 +1,528 @@
+import os, time, re, io
+import json
+import mimetypes, hashlib
+import logging
+from collections import OrderedDict
+
+import requests
+
+from .. import config, utils
+from ..returnvalues import ReturnValue
+from ..storage import templates
+from .contact import update_local_uin
+
+logger = logging.getLogger('itchat')
+
+def load_messages(core):
+    core.send_raw_msg = send_raw_msg
+    core.send_msg     = send_msg
+    core.upload_file  = upload_file
+    core.send_file    = send_file
+    core.send_image   = send_image
+    core.send_video   = send_video
+    core.send         = send
+    core.revoke       = revoke
+
+def get_download_fn(core, url, msgId):
+    def download_fn(downloadDir=None):
+        params = {
+            'msgid': msgId,
+            'skey': core.loginInfo['skey'],}
+        headers = { 'User-Agent' : config.USER_AGENT }
+        r = core.s.get(url, params=params, stream=True, headers = headers)
+        tempStorage = io.BytesIO()
+        for block in r.iter_content(1024):
+            tempStorage.write(block)
+        if downloadDir is None:
+            return tempStorage.getvalue()
+        with open(downloadDir, 'wb') as f:
+            f.write(tempStorage.getvalue())
+        tempStorage.seek(0)
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'Successfully downloaded',
+            'Ret': 0, },
+            'PostFix': utils.get_image_postfix(tempStorage.read(20)), })
+    return download_fn
+
+def produce_msg(core, msgList):
+    ''' for messages types
+     * 40 msg, 43 videochat, 50 VOIPMSG, 52 voipnotifymsg
+     * 53 webwxvoipnotifymsg, 9999 sysnotice
+    '''
+    rl = []
+    srl = [40, 43, 50, 52, 53, 9999]
+    for m in msgList:
+        # get actual opposite
+        if m['FromUserName'] == core.storageClass.userName:
+            actualOpposite = m['ToUserName']
+        else:
+            actualOpposite = m['FromUserName']
+        # produce basic message
+        if '@@' in m['FromUserName'] or '@@' in m['ToUserName']:
+            produce_group_chat(core, m)
+        else:
+            utils.msg_formatter(m, 'Content')
+        # set user of msg
+        if '@@' in actualOpposite:
+            m['User'] = core.search_chatrooms(userName=actualOpposite) or \
+                templates.Chatroom({'UserName': actualOpposite})
+            # we don't need to update chatroom here because we have
+            # updated once when producing basic message
+        elif actualOpposite in ('filehelper', 'fmessage'):
+            m['User'] = templates.User({'UserName': actualOpposite})
+        else:
+            m['User'] = core.search_mps(userName=actualOpposite) or \
+                core.search_friends(userName=actualOpposite) or \
+                templates.User(userName=actualOpposite)
+            # by default we think there may be a user missing not a mp
+        m['User'].core = core
+        if m['MsgType'] == 1: # words
+            if m['Url']:
+                regx = r'(.+?\(.+?\))'
+                data = re.search(regx, m['Content'])
+                data = 'Map' if data is None else data.group(1)
+                msg = {
+                    'Type': 'Map',
+                    'Text': data,}
+            else:
+                msg = {
+                    'Type': 'Text',
+                    'Text': m['Content'],}
+        elif m['MsgType'] == 3 or m['MsgType'] == 47: # picture
+            download_fn = get_download_fn(core,
+                '%s/webwxgetmsgimg' % core.loginInfo['url'], m['NewMsgId'])
+            msg = {
+                'Type'     : 'Picture',
+                'FileName' : '%s.%s' % (time.strftime('%y%m%d-%H%M%S', time.localtime()),
+                    'png' if m['MsgType'] == 3 else 'gif'),
+                'Text'     : download_fn, }
+        elif m['MsgType'] == 34: # voice
+            download_fn = get_download_fn(core,
+                '%s/webwxgetvoice' % core.loginInfo['url'], m['NewMsgId'])
+            msg = {
+                'Type': 'Recording',
+                'FileName' : '%s.mp3' % time.strftime('%y%m%d-%H%M%S', time.localtime()),
+                'Text': download_fn,}
+        elif m['MsgType'] == 37: # friends
+            m['User']['UserName'] = m['RecommendInfo']['UserName']
+            msg = {
+                'Type': 'Friends',
+                'Text': {
+                    'status'        : m['Status'],
+                    'userName'      : m['RecommendInfo']['UserName'],
+                    'verifyContent' : m['Ticket'],
+                    'autoUpdate'    : m['RecommendInfo'], }, }
+            m['User'].verifyDict = msg['Text']
+        elif m['MsgType'] == 42: # name card
+            msg = {
+                'Type': 'Card',
+                'Text': m['RecommendInfo'], }
+        elif m['MsgType'] in (43, 62): # tiny video
+            msgId = m['MsgId']
+            def download_video(videoDir=None):
+                url = '%s/webwxgetvideo' % core.loginInfo['url']
+                params = {
+                    'msgid': msgId,
+                    'skey': core.loginInfo['skey'],}
+                headers = {'Range': 'bytes=0-', 'User-Agent' : config.USER_AGENT }
+                r = core.s.get(url, params=params, headers=headers, stream=True)
+                tempStorage = io.BytesIO()
+                for block in r.iter_content(1024):
+                    tempStorage.write(block)
+                if videoDir is None:
+                    return tempStorage.getvalue()
+                with open(videoDir, 'wb') as f:
+                    f.write(tempStorage.getvalue())
+                return ReturnValue({'BaseResponse': {
+                    'ErrMsg': 'Successfully downloaded',
+                    'Ret': 0, }})
+            msg = {
+                'Type': 'Video',
+                'FileName' : '%s.mp4' % time.strftime('%y%m%d-%H%M%S', time.localtime()),
+                'Text': download_video, }
+        elif m['MsgType'] == 49: # sharing
+            if m['AppMsgType'] == 0: # chat history
+                msg = {
+                    'Type': 'Note',
+                    'Text': m['Content'], }
+            elif m['AppMsgType'] == 6:
+                rawMsg = m
+                cookiesList = {name:data for name,data in core.s.cookies.items()}
+                def download_atta(attaDir=None):
+                    url = core.loginInfo['fileUrl'] + '/webwxgetmedia'
+                    params = {
+                        'sender': rawMsg['FromUserName'],
+                        'mediaid': rawMsg['MediaId'],
+                        'filename': rawMsg['FileName'],
+                        'fromuser': core.loginInfo['wxuin'],
+                        'pass_ticket': 'undefined',
+                        'webwx_data_ticket': cookiesList['webwx_data_ticket'],}
+                    headers = { 'User-Agent' : config.USER_AGENT }
+                    r = core.s.get(url, params=params, stream=True, headers=headers)
+                    tempStorage = io.BytesIO()
+                    for block in r.iter_content(1024):
+                        tempStorage.write(block)
+                    if attaDir is None:
+                        return tempStorage.getvalue()
+                    with open(attaDir, 'wb') as f:
+                        f.write(tempStorage.getvalue())
+                    return ReturnValue({'BaseResponse': {
+                        'ErrMsg': 'Successfully downloaded',
+                        'Ret': 0, }})
+                msg = {
+                    'Type': 'Attachment',
+                    'Text': download_atta, }
+            elif m['AppMsgType'] == 8:
+                download_fn = get_download_fn(core,
+                    '%s/webwxgetmsgimg' % core.loginInfo['url'], m['NewMsgId'])
+                msg = {
+                    'Type'     : 'Picture',
+                    'FileName' : '%s.gif' % (
+                        time.strftime('%y%m%d-%H%M%S', time.localtime())),
+                    'Text'     : download_fn, }
+            elif m['AppMsgType'] == 17:
+                msg = {
+                    'Type': 'Note',
+                    'Text': m['FileName'], }
+            elif m['AppMsgType'] == 2000:
+                regx = r'\[CDATA\[(.+?)\][\s\S]+?\[CDATA\[(.+?)\]'
+                data = re.search(regx, m['Content'])
+                if data:
+                    data = data.group(2).split(u'\u3002')[0]
+                else:
+                    data = 'You may found detailed info in Content key.'
+                msg = {
+                    'Type': 'Note',
+                    'Text': data, }
+            else:
+                msg = {
+                    'Type': 'Sharing',
+                    'Text': m['FileName'], }
+        elif m['MsgType'] == 51: # phone init
+            msg = update_local_uin(core, m)
+        elif m['MsgType'] == 10000:
+            msg = {
+                'Type': 'Note',
+                'Text': m['Content'],}
+        elif m['MsgType'] == 10002:
+            regx = r'\[CDATA\[(.+?)\]\]'
+            data = re.search(regx, m['Content'])
+            data = 'System message' if data is None else data.group(1).replace('\\', '')
+            msg = {
+                'Type': 'Note',
+                'Text': data, }
+        elif m['MsgType'] in srl:
+            msg = {
+                'Type': 'Useless',
+                'Text': 'UselessMsg', }
+        else:
+            logger.debug('Useless message received: %s\n%s' % (m['MsgType'], str(m)))
+            msg = {
+                'Type': 'Useless',
+                'Text': 'UselessMsg', }
+        m = dict(m, **msg)
+        rl.append(m)
+    return rl
+
+def produce_group_chat(core, msg):
+    r = re.match('(@[0-9a-z]*?):<br/>(.*)$', msg['Content'])
+    if r:
+        actualUserName, content = r.groups()
+        chatroomUserName = msg['FromUserName']
+    elif msg['FromUserName'] == core.storageClass.userName:
+        actualUserName = core.storageClass.userName
+        content = msg['Content']
+        chatroomUserName = msg['ToUserName']
+    else:
+        msg['ActualUserName'] = core.storageClass.userName
+        msg['ActualNickName'] = core.storageClass.nickName
+        msg['IsAt'] = False
+        utils.msg_formatter(msg, 'Content')
+        return
+    chatroom = core.storageClass.search_chatrooms(userName=chatroomUserName)
+    member = utils.search_dict_list((chatroom or {}).get(
+        'MemberList') or [], 'UserName', actualUserName)
+    if member is None:
+        chatroom = core.update_chatroom(chatroomUserName)
+        member = utils.search_dict_list((chatroom or {}).get(
+            'MemberList') or [], 'UserName', actualUserName)
+    if member is None:
+        logger.debug('chatroom member fetch failed with %s' % actualUserName)
+        msg['ActualNickName'] = ''
+        msg['IsAt'] = False
+    else:
+        msg['ActualNickName'] = member.get('DisplayName', '') or member['NickName']
+        atFlag = '@' + (chatroom['Self'].get('DisplayName', '') or core.storageClass.nickName)
+        msg['IsAt'] = (
+            (atFlag + (u'\u2005' if u'\u2005' in msg['Content'] else ' '))
+            in msg['Content'] or msg['Content'].endswith(atFlag))
+    msg['ActualUserName'] = actualUserName
+    msg['Content']        = content
+    utils.msg_formatter(msg, 'Content')
+
+def send_raw_msg(self, msgType, content, toUserName):
+    url = '%s/webwxsendmsg' % self.loginInfo['url']
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Msg': {
+            'Type': msgType,
+            'Content': content,
+            'FromUserName': self.storageClass.userName,
+            'ToUserName': (toUserName if toUserName else self.storageClass.userName),
+            'LocalID': int(time.time() * 1e4),
+            'ClientMsgId': int(time.time() * 1e4),
+            },
+        'Scene': 0, }
+    headers = { 'ContentType': 'application/json; charset=UTF-8', 'User-Agent' : config.USER_AGENT }
+    r = self.s.post(url, headers=headers,
+        data=json.dumps(data, ensure_ascii=False).encode('utf8'))
+    return ReturnValue(rawResponse=r)
+
+def send_msg(self, msg='Test Message', toUserName=None):
+    logger.debug('Request to send a text message to %s: %s' % (toUserName, msg))
+    r = self.send_raw_msg(1, msg, toUserName)
+    return r
+
+def _prepare_file(fileDir, file_=None):
+    fileDict = {}
+    if file_:
+        if hasattr(file_, 'read'):
+            file_ = file_.read()
+        else:
+            return ReturnValue({'BaseResponse': {
+                'ErrMsg': 'file_ param should be opened file',
+                'Ret': -1005, }})
+    else:
+        if not utils.check_file(fileDir):
+            return ReturnValue({'BaseResponse': {
+                'ErrMsg': 'No file found in specific dir',
+                'Ret': -1002, }})
+        with open(fileDir, 'rb') as f:
+            file_ = f.read()
+    fileDict['fileSize'] = len(file_)
+    fileDict['fileMd5'] = hashlib.md5(file_).hexdigest()
+    fileDict['file_'] = io.BytesIO(file_)
+    return fileDict
+
+def upload_file(self, fileDir, isPicture=False, isVideo=False,
+        toUserName='filehelper', file_=None, preparedFile=None):
+    logger.debug('Request to upload a %s: %s' % (
+        'picture' if isPicture else 'video' if isVideo else 'file', fileDir))
+    if not preparedFile:
+        preparedFile = _prepare_file(fileDir, file_)
+        if not preparedFile:
+            return preparedFile
+    fileSize, fileMd5, file_ = \
+        preparedFile['fileSize'], preparedFile['fileMd5'], preparedFile['file_']
+    fileSymbol = 'pic' if isPicture else 'video' if isVideo else'doc'
+    chunks = int((fileSize - 1) / 524288) + 1
+    clientMediaId = int(time.time() * 1e4)
+    uploadMediaRequest = json.dumps(OrderedDict([
+        ('UploadType', 2),
+        ('BaseRequest', self.loginInfo['BaseRequest']),
+        ('ClientMediaId', clientMediaId),
+        ('TotalLen', fileSize),
+        ('StartPos', 0),
+        ('DataLen', fileSize),
+        ('MediaType', 4),
+        ('FromUserName', self.storageClass.userName),
+        ('ToUserName', toUserName),
+        ('FileMd5', fileMd5)]
+        ), separators = (',', ':'))
+    r = {'BaseResponse': {'Ret': -1005, 'ErrMsg': 'Empty file detected'}}
+    for chunk in range(chunks):
+        r = upload_chunk_file(self, fileDir, fileSymbol, fileSize,
+            file_, chunk, chunks, uploadMediaRequest)
+    file_.close()
+    if isinstance(r, dict):
+        return ReturnValue(r)
+    return ReturnValue(rawResponse=r)
+
+def upload_chunk_file(core, fileDir, fileSymbol, fileSize,
+        file_, chunk, chunks, uploadMediaRequest):
+    url = core.loginInfo.get('fileUrl', core.loginInfo['url']) + \
+        '/webwxuploadmedia?f=json'
+    # save it on server
+    cookiesList = {name:data for name,data in core.s.cookies.items()}
+    fileType = mimetypes.guess_type(fileDir)[0] or 'application/octet-stream'
+    fileName = utils.quote(os.path.basename(fileDir))
+    files = OrderedDict([
+        ('id', (None, 'WU_FILE_0')),
+        ('name', (None, fileName)),
+        ('type', (None, fileType)),
+        ('lastModifiedDate', (None, time.strftime('%a %b %d %Y %H:%M:%S GMT+0800 (CST)'))),
+        ('size', (None, str(fileSize))),
+        ('chunks', (None, None)),
+        ('chunk', (None, None)),
+        ('mediatype', (None, fileSymbol)),
+        ('uploadmediarequest', (None, uploadMediaRequest)),
+        ('webwx_data_ticket', (None, cookiesList['webwx_data_ticket'])),
+        ('pass_ticket', (None, core.loginInfo['pass_ticket'])),
+        ('filename' , (fileName, file_.read(524288), 'application/octet-stream'))])
+    if chunks == 1:
+        del files['chunk']; del files['chunks']
+    else:
+        files['chunk'], files['chunks'] = (None, str(chunk)), (None, str(chunks))
+    headers = { 'User-Agent' : config.USER_AGENT }
+    return core.s.post(url, files=files, headers=headers, timeout=config.TIMEOUT)
+
+def send_file(self, fileDir, toUserName=None, mediaId=None, file_=None):
+    logger.debug('Request to send a file(mediaId: %s) to %s: %s' % (
+        mediaId, toUserName, fileDir))
+    if hasattr(fileDir, 'read'):
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'fileDir param should not be an opened file in send_file',
+            'Ret': -1005, }})
+    if toUserName is None:
+        toUserName = self.storageClass.userName
+    preparedFile = _prepare_file(fileDir, file_)
+    if not preparedFile:
+        return preparedFile
+    fileSize = preparedFile['fileSize']
+    if mediaId is None:
+        r = self.upload_file(fileDir, preparedFile=preparedFile)
+        if r:
+            mediaId = r['MediaId']
+        else:
+            return r
+    url = '%s/webwxsendappmsg?fun=async&f=json' % self.loginInfo['url']
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Msg': {
+            'Type': 6,
+            'Content': ("<appmsg appid='wxeb7ec651dd0aefa9' sdkver=''><title>%s</title>" % os.path.basename(fileDir) +
+                "<des></des><action></action><type>6</type><content></content><url></url><lowurl></lowurl>" +
+                "<appattach><totallen>%s</totallen><attachid>%s</attachid>" % (str(fileSize), mediaId) +
+                "<fileext>%s</fileext></appattach><extinfo></extinfo></appmsg>" % os.path.splitext(fileDir)[1].replace('.','')),
+            'FromUserName': self.storageClass.userName,
+            'ToUserName': toUserName,
+            'LocalID': int(time.time() * 1e4),
+            'ClientMsgId': int(time.time() * 1e4), },
+        'Scene': 0, }
+    headers = {
+        'User-Agent': config.USER_AGENT,
+        'Content-Type': 'application/json;charset=UTF-8', }
+    r = self.s.post(url, headers=headers,
+        data=json.dumps(data, ensure_ascii=False).encode('utf8'))
+    return ReturnValue(rawResponse=r)
+
+def send_image(self, fileDir=None, toUserName=None, mediaId=None, file_=None):
+    logger.debug('Request to send a image(mediaId: %s) to %s: %s' % (
+        mediaId, toUserName, fileDir))
+    if fileDir or file_:
+        if hasattr(fileDir, 'read'):
+            file_, fileDir = fileDir, None
+        if fileDir is None:
+            fileDir = 'tmp.jpg' # specific fileDir to send gifs
+    else:
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'Either fileDir or file_ should be specific',
+            'Ret': -1005, }})
+    if toUserName is None:
+        toUserName = self.storageClass.userName
+    if mediaId is None:
+        r = self.upload_file(fileDir, isPicture=not fileDir[-4:] == '.gif', file_=file_)
+        if r:
+            mediaId = r['MediaId']
+        else:
+            return r
+    url = '%s/webwxsendmsgimg?fun=async&f=json' % self.loginInfo['url']
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Msg': {
+            'Type': 3,
+            'MediaId': mediaId,
+            'FromUserName': self.storageClass.userName,
+            'ToUserName': toUserName,
+            'LocalID': int(time.time() * 1e4),
+            'ClientMsgId': int(time.time() * 1e4), },
+        'Scene': 0, }
+    if fileDir[-4:] == '.gif':
+        url = '%s/webwxsendemoticon?fun=sys' % self.loginInfo['url']
+        data['Msg']['Type'] = 47
+        data['Msg']['EmojiFlag'] = 2
+    headers = {
+        'User-Agent': config.USER_AGENT,
+        'Content-Type': 'application/json;charset=UTF-8', }
+    r = self.s.post(url, headers=headers,
+        data=json.dumps(data, ensure_ascii=False).encode('utf8'))
+    return ReturnValue(rawResponse=r)
+
+def send_video(self, fileDir=None, toUserName=None, mediaId=None, file_=None):
+    logger.debug('Request to send a video(mediaId: %s) to %s: %s' % (
+        mediaId, toUserName, fileDir))
+    if fileDir or file_:
+        if hasattr(fileDir, 'read'):
+            file_, fileDir = fileDir, None
+        if fileDir is None:
+            fileDir = 'tmp.mp4' # specific fileDir to send other formats
+    else:
+        return ReturnValue({'BaseResponse': {
+            'ErrMsg': 'Either fileDir or file_ should be specific',
+            'Ret': -1005, }})
+    if toUserName is None:
+        toUserName = self.storageClass.userName
+    if mediaId is None:
+        r = self.upload_file(fileDir, isVideo=True, file_=file_)
+        if r:
+            mediaId = r['MediaId']
+        else:
+            return r
+    url = '%s/webwxsendvideomsg?fun=async&f=json&pass_ticket=%s' % (
+        self.loginInfo['url'], self.loginInfo['pass_ticket'])
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        'Msg': {
+            'Type'         : 43,
+            'MediaId'      : mediaId,
+            'FromUserName' : self.storageClass.userName,
+            'ToUserName'   : toUserName,
+            'LocalID'      : int(time.time() * 1e4),
+            'ClientMsgId'  : int(time.time() * 1e4), },
+        'Scene': 0, }
+    headers = {
+        'User-Agent' : config.USER_AGENT,
+        'Content-Type': 'application/json;charset=UTF-8', }
+    r = self.s.post(url, headers=headers,
+        data=json.dumps(data, ensure_ascii=False).encode('utf8'))
+    return ReturnValue(rawResponse=r)
+
+def send(self, msg, toUserName=None, mediaId=None):
+    if not msg:
+        r = ReturnValue({'BaseResponse': {
+            'ErrMsg': 'No message.',
+            'Ret': -1005, }})
+    elif msg[:5] == '@fil@':
+        if mediaId is None:
+            r = self.send_file(msg[5:], toUserName)
+        else:
+            r = self.send_file(msg[5:], toUserName, mediaId)
+    elif msg[:5] == '@img@':
+        if mediaId is None:
+            r = self.send_image(msg[5:], toUserName)
+        else:
+            r = self.send_image(msg[5:], toUserName, mediaId)
+    elif msg[:5] == '@msg@':
+        r = self.send_msg(msg[5:], toUserName)
+    elif msg[:5] == '@vid@':
+        if mediaId is None:
+            r = self.send_video(msg[5:], toUserName)
+        else:
+            r = self.send_video(msg[5:], toUserName, mediaId)
+    else:
+        r = self.send_msg(msg, toUserName)
+    return r
+
+def revoke(self, msgId, toUserName, localId=None):
+    url = '%s/webwxrevokemsg' % self.loginInfo['url']
+    data = {
+        'BaseRequest': self.loginInfo['BaseRequest'],
+        "ClientMsgId": localId or str(time.time() * 1e3),
+        "SvrMsgId": msgId,
+        "ToUserName": toUserName}
+    headers = {
+        'ContentType': 'application/json; charset=UTF-8',
+        'User-Agent' : config.USER_AGENT }
+    r = self.s.post(url, headers=headers,
+        data=json.dumps(data, ensure_ascii=False).encode('utf8'))
+    return ReturnValue(rawResponse=r)

lib/itchat/components/register.py

@@ -0,0 +1,103 @@
+import logging, traceback, sys, threading
+try:
+    import Queue
+except ImportError:
+    import queue as Queue
+
+from ..log import set_logging
+from ..utils import test_connect
+from ..storage import templates
+
+logger = logging.getLogger('itchat')
+
+def load_register(core):
+    core.auto_login       = auto_login
+    core.configured_reply = configured_reply
+    core.msg_register     = msg_register
+    core.run              = run
+
+def auto_login(self, hotReload=False, statusStorageDir='itchat.pkl',
+        enableCmdQR=False, picDir=None, qrCallback=None,
+        loginCallback=None, exitCallback=None):
+    if not test_connect():
+        logger.info("You can't get access to internet or wechat domain, so exit.")
+        sys.exit()
+    self.useHotReload = hotReload
+    self.hotReloadDir = statusStorageDir
+    if hotReload:
+        if self.load_login_status(statusStorageDir,
+                loginCallback=loginCallback, exitCallback=exitCallback):
+            return
+        self.login(enableCmdQR=enableCmdQR, picDir=picDir, qrCallback=qrCallback,
+            loginCallback=loginCallback, exitCallback=exitCallback)
+        self.dump_login_status(statusStorageDir)
+    else:
+        self.login(enableCmdQR=enableCmdQR, picDir=picDir, qrCallback=qrCallback,
+            loginCallback=loginCallback, exitCallback=exitCallback)
+
+def configured_reply(self):
+    ''' determine the type of message and reply if its method is defined
+        however, I use a strange way to determine whether a msg is from massive platform
+        I haven't found a better solution here
+        The main problem I'm worrying about is the mismatching of new friends added on phone
+        If you have any good idea, pleeeease report an issue. I will be more than grateful.
+    '''
+    try:
+        msg = self.msgList.get(timeout=1)
+    except Queue.Empty:
+        pass
+    else:
+        if isinstance(msg['User'], templates.User):
+            replyFn = self.functionDict['FriendChat'].get(msg['Type'])
+        elif isinstance(msg['User'], templates.MassivePlatform):
+            replyFn = self.functionDict['MpChat'].get(msg['Type'])
+        elif isinstance(msg['User'], templates.Chatroom):
+            replyFn = self.functionDict['GroupChat'].get(msg['Type'])
+        if replyFn is None:
+            r = None
+        else:
+            try:
+                r = replyFn(msg)
+                if r is not None:
+                    self.send(r, msg.get('FromUserName'))
+            except:
+                logger.warning(traceback.format_exc())
+
+def msg_register(self, msgType, isFriendChat=False, isGroupChat=False, isMpChat=False):
+    ''' a decorator constructor
+        return a specific decorator based on information given '''
+    if not (isinstance(msgType, list) or isinstance(msgType, tuple)):
+        msgType = [msgType]
+    def _msg_register(fn):
+        for _msgType in msgType:
+            if isFriendChat:
+                self.functionDict['FriendChat'][_msgType] = fn
+            if isGroupChat:
+                self.functionDict['GroupChat'][_msgType] = fn
+            if isMpChat:
+                self.functionDict['MpChat'][_msgType] = fn
+            if not any((isFriendChat, isGroupChat, isMpChat)):
+                self.functionDict['FriendChat'][_msgType] = fn
+        return fn
+    return _msg_register
+
+def run(self, debug=False, blockThread=True):
+    logger.info('Start auto replying.')
+    if debug:
+        set_logging(loggingLevel=logging.DEBUG)
+    def reply_fn():
+        try:
+            while self.alive:
+                self.configured_reply()
+        except KeyboardInterrupt:
+            if self.useHotReload:
+                self.dump_login_status()
+            self.alive = False
+            logger.debug('itchat received an ^C and exit.')
+            logger.info('Bye~')
+    if blockThread:
+        reply_fn()
+    else:
+        replyThread = threading.Thread(target=reply_fn)
+        replyThread.setDaemon(True)
+        replyThread.start()