python-plugins 0.1.4__tar.gz → 0.1.5__tar.gz

{python_plugins-0.1.4 → python_plugins-0.1.5}/.gitignore

@@ -3,7 +3,6 @@
 
 ### JupyterNotebooks ###
 .ipynb_checkpoints
-*/.ipynb_checkpoints/*
 
 ### Python ###
 # Byte-compiled / optimized / DLL files

{python_plugins-0.1.4 → python_plugins-0.1.5}/CHANGES.rst

@@ -1,3 +1,10 @@
+v0.1.5
+------
+
+Released 2024-09-28
+
+- weixin.wechat
+
 v0.1.4
 ------
 

{python_plugins-0.1.4 → python_plugins-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-plugins
-Version: 0.1.4
+Version: 0.1.5
 Summary: A collection of Python functions and classes.
 Project-URL: Documentation, https://python-plugins.readthedocs.io
 Project-URL: Source, https://github.com/ojso/python-plugins
@@ -46,6 +46,8 @@ Provides-Extra: pillow
 Requires-Dist: pillow; extra == 'pillow'
 Provides-Extra: qrcode
 Requires-Dist: qrcode; extra == 'qrcode'
+Provides-Extra: requests
+Requires-Dist: requests; extra == 'requests'
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy; extra == 'sqlalchemy'
 Description-Content-Type: text/x-rst

{python_plugins-0.1.4 → python_plugins-0.1.5}/docs/usage.rst

@@ -44,18 +44,37 @@ mixins
    from flask_sqlalchemy import SQLAlchemy
    from python_plugins.models.mixins import PrimaryKeyMixin
    from python_plugins.models.mixins import UserMixin
+   from python_plugins.models.mixins import DataMixin
    from python_plugins.models.mixins import TimestampMixin
 
    db = SQLAlchemy()
 
-   class User(PrimaryKeyMixin,UserMixin, TimestampMixin,db.models):
-      pass
+   class User(PrimaryKeyMixin, DataMixin, TimestampMixin, UserMixin, db.models):
+      __tablename__ = "users"
 
 remove_pycache
 =======================
 
-.. code-block :: python
+.. code-block:: python
 
     from  python_plugins.utils.remove_pycache import remove_pycache
 
     remove_pycache(".")
+
+
+weixin.wechat
+==================
+
+.. code-block:: python
+
+   from python_plugins.weixin.wechat import Wechat
+
+   class MyWechat(Wechat):
+      def get_app(self) -> dict:
+         # may depended on self.name from self.__init__(name)
+         return "<your app>"
+
+   mywechat = MyWechat("name")
+   mywechat.verify(query)
+   mywechat.chat(query,content)
+   

{python_plugins-0.1.4 → python_plugins-0.1.5}/pyproject.toml

@@ -27,8 +27,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-sqlalchemy = ["SQLAlchemy"]
 cryptography = ["cryptography"]
+requests = ["requests"]
+sqlalchemy = ["SQLAlchemy"]
 pillow = ["pillow"]
 qrcode = ["qrcode"]
 jwt = ["PyJWT"]

{python_plugins-0.1.4 → python_plugins-0.1.5}/requirements/test.in

@@ -2,4 +2,5 @@ pytest
 Faker
 cryptography
 SQLAlchemy
-PyJWT
+PyJWT
+requests

python_plugins-0.1.5/src/python_plugins/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.5"

{python_plugins-0.1.4 → python_plugins-0.1.5}/src/python_plugins/models/mixins/__init__.py

@@ -1,4 +1,5 @@
 from .primary_key_mixin import PrimaryKeyMixin
 from .timestamp_mixin import TimestampMixin, CreateTimestampMixin, UpdateTimestampMixin
 from .data_mixin import DataMixin
+from .token_minxin import TokenMixin
 from .user_minxin import UserMixin

python_plugins-0.1.5/src/python_plugins/models/mixins/token_minxin.py

@@ -0,0 +1,8 @@
+from typing import Optional
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from ...random.random_str import secret_token
+
+
+class TokenMixin:
+    token: Mapped[Optional[str]] = mapped_column(unique=True, default=secret_token)

python_plugins-0.1.5/src/python_plugins/weixin/biz_data_crypt.py

@@ -0,0 +1,69 @@
+import base64
+import json
+import time
+
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+
+class WeixinBizDataCrypt:
+    """Weixin Biz Data Crypt
+    微信小程序服务端获取开放数据
+    see https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/signature.html
+    """
+
+    def __init__(self, appid, sessionKey):
+        self.appid = appid
+        self.sessionKey = sessionKey
+
+    def decrypt(self, data, iv):
+        # base64 decode
+        sessionKey = base64.b64decode(self.sessionKey)
+        encryptedData = base64.b64decode(data)
+        iv = base64.b64decode(iv)
+
+        # cipher = AES.new(sessionKey, AES.MODE_CBC, iv)
+        # decrypted = json.loads(self._unpad(cipher.decrypt(encryptedData)))
+        decryptor = Cipher(
+            algorithms.AES(sessionKey),
+            modes.CBC(iv),
+        ).decryptor()
+        plaintext_padded = decryptor.update(encryptedData)
+        plaintext_padded += decryptor.finalize()
+
+        unpadded = self._unpad(plaintext_padded)
+        decrypted = json.loads(unpadded)
+
+        # 校验签名
+        if decrypted["watermark"]["appid"] != self.appid:
+            raise Exception("Invalid Buffer")
+
+        return decrypted
+
+    def encrypt(self, data, iv) -> str:
+        # 添加watermark
+        data["watermark"] = {"appid": self.appid, "timestamp": int(time.time())}
+        nopadData = json.dumps(data).encode()
+        sessionKey = base64.b64decode(self.sessionKey)
+        iv = base64.b64decode(iv)
+
+        encryptor = Cipher(
+            algorithms.AES(sessionKey),
+            modes.CBC(iv),
+        ).encryptor()
+
+        # see https://cryptography.io/en/latest/hazmat/primitives/padding/
+        # 填补数据，满足block_size的倍数
+        padder = padding.PKCS7(128).padder()
+        padded_data = padder.update(nopadData)
+        padded_data += padder.finalize()
+
+        # 加密
+        encrypted = encryptor.update(padded_data) + encryptor.finalize()
+        # base64.b64encode -> str
+        encrypted = base64.b64encode(encrypted).decode()
+        return encrypted
+
+    def _unpad(self, s):
+        """cryptography.hazmat.primitives.padding.PKCS7(128).unpadder()的简化版本"""
+        return s[: -ord(s[-1:])]

python_plugins-0.1.5/src/python_plugins/weixin/error_code.py

@@ -0,0 +1,29 @@
+# /**
+#  * error code 说明.
+#  * <ul>
+#  *    <li>-40001: 签名验证错误</li>
+#  *    <li>-40002: xml解析失败</li>
+#  *    <li>-40003: sha加密生成签名失败</li>
+#  *    <li>-40004: encodingAesKey 非法</li>
+#  *    <li>-40005: appid 校验错误</li>
+#  *    <li>-40006: aes 加密失败</li>
+#  *    <li>-40007: aes 解密失败</li>
+#  *    <li>-40008: 解密后得到的buffer非法</li>
+#  *    <li>-40009: base64加密失败</li>
+#  *    <li>-40010: base64解密失败</li>
+#  *    <li>-40011: 生成xml失败</li>
+#  * </ul>
+#  */
+class ErrorCode:
+    OK = 0
+    ValidateSignatureError = -40001
+    ParseXmlError = -40002
+    ComputeSignatureError = -40003
+    IllegalAesKey = -40004
+    ValidateAppidError = -40005
+    EncryptAESError = -40006
+    DecryptAESError = -40007
+    IllegalBuffer = -40008
+    EncodeBase64Error = -40009
+    DecodeBase64Error = -40010
+    GenReturnXmlError = -40011

python_plugins-0.1.5/src/python_plugins/weixin/wechat.py

@@ -0,0 +1,128 @@
+import hashlib
+import time
+from python_plugins.convert import xml2dict
+from .wechat_crypt import MessageCrypt
+
+XML_TEXT_TEMPLATE = """<xml>
+<ToUserName><![CDATA[{touser}]]></ToUserName>
+<FromUserName><![CDATA[{fromuser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[text]]></MsgType>
+<Content><![CDATA[{content}]]></Content>
+</xml>"""
+
+
+class Wechat:
+
+    def __init__(self, name=None):
+        self.name = name
+        self.app = self.get_app()
+
+    # 获取app
+    def get_app(self) -> dict:
+        raise NotImplementedError()
+
+    # 记录信息
+    def log_data(self):
+        return
+
+    def verify(self, args):
+        signature = args["signature"]
+        timestamp = args["timestamp"]
+        nonce = args["nonce"]
+        echostr = args["echostr"]
+        token = self.app["token"]
+        tmpstr = "".join(sorted([token, timestamp, nonce])).encode("utf8")
+        if hashlib.sha1(tmpstr).hexdigest() == signature:
+            return echostr
+        else:
+            return
+
+    def chat(self, args, content):
+        self.openid = args.get("openid")
+        msg_signature = args.get("msg_signature", "")
+        timestamp = args.get("timestamp", "")
+        nonce = args.get("nonce", "")
+        # 加密标记
+        encrypt_type = args.get("encrypt_type")
+        xml_dict = xml2dict(content)
+
+        if not encrypt_type:
+            # 未加密
+            result = self.dispatch(xml_dict)
+            xml_reponse = self.responseText(result)
+        else:
+            # 解密
+            mc = MessageCrypt(self.app["appid"], self.app["token"], self.app["aeskey"])
+            xml_decrypted = mc.decrypt_msg(
+                timestamp, nonce, xml_dict["Encrypt"], msg_signature
+            )
+            decrypted_dict = xml2dict(xml_decrypted)
+            result = self.dispatch(decrypted_dict)
+            unencrypted_xml = self.responseText(result)
+            # 加密
+            xml_reponse = mc.encrypt_msg(unencrypted_xml, timestamp, nonce)
+
+        return xml_reponse
+
+    def responseText(self, content):
+        data = {
+            "touser": self.fromUser,
+            "fromuser": self.toUser,
+            "createtime": int(time.time()),
+            "content": content,
+        }
+        return XML_TEXT_TEMPLATE.format(**data)
+
+    def dispatch(self, data):
+        self.toUser = data["ToUserName"]
+        self.fromUser = data["FromUserName"]
+        msgType = data["MsgType"]
+
+        if msgType == "text":
+            keyword = data["Content"]
+        elif msgType == "event":
+            event = data["Event"]
+            if event == "subscribe":
+                # self.onSubscribe()
+                keyword = "subscribe"
+            elif event == "unsubscribe":
+                # self.onUnsubscribe()
+                keyword = "unsubscribe"
+            elif event == "CLICK":
+                eventKey = data["EventKey"]
+                keyword = eventKey
+            else:
+                keyword = "<event:{event}>"
+        elif msgType == "image":
+            keyword = f"<{msgType}>"
+        elif msgType == "voice":
+            keyword = f"<{msgType}>"
+        elif msgType == "video":
+            keyword = f"<{msgType}>"
+        elif msgType == "shortvideo":
+            keyword = f"<{msgType}>"
+        elif msgType == "location":
+            location_x = data["location_x"]
+            location_y = data["location_y"]
+            keyword = f"<{msgType}({location_x},{location_y})>"
+        elif msgType == "link":
+            keyword = f"<{msgType}>"
+        else:
+            keyword = f"<{msgType}>"
+
+        self.keyword = keyword
+        answer = self.answer()
+
+        # 返回前记录下日志，如果实现记录日志的话
+        self.log_data()
+
+        return self.responseText(answer)
+
+    def answer(self):
+        q = self.keyword
+        if q == "subscribe":
+            r = f"您好,欢迎关注[{self.app['name']}]!"
+        else:
+            r = q
+        return r

python_plugins-0.1.5/src/python_plugins/weixin/wechat_crypt.py

@@ -0,0 +1,141 @@
+import base64
+import string
+import random
+import hashlib
+import struct
+import socket
+
+# from Crypto.Cipher import AES
+# 使用 cryptography 替代 pycrypto 作为加密包
+from cryptography.hazmat.primitives import hashes, padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+ENCRYPT_TEXT_RESPONSE_TEMPLATE = """<xml>
+<Encrypt><![CDATA[{msg_encrypt}]]></Encrypt>
+<MsgSignature><![CDATA[{msg_signaturet}]]></MsgSignature>
+<TimeStamp>{timestamp}</TimeStamp>
+<Nonce><![CDATA[{nonce}]]></Nonce>
+</xml>"""
+
+
+class MessageCrypt:
+    def __init__(self, appid, token, aeskey):
+        self.appid = appid
+        self.token = token
+        self.key = base64.b64decode(aeskey + "=")
+
+    def get_sha1(self, token, timestamp, nonce, txt):
+        tmpstr = "".join(sorted([token, timestamp, nonce, txt])).encode("utf8")
+        return hashlib.sha1(tmpstr).hexdigest()
+
+    def generate(self, encrypt, signature, timestamp, nonce):
+        data = {
+            "msg_encrypt": encrypt,
+            "msg_signaturet": signature,
+            "timestamp": timestamp,
+            "nonce": nonce,
+        }
+        return ENCRYPT_TEXT_RESPONSE_TEMPLATE.format(**data)
+
+    def encrypt_msg(self, msg, timestamp, nonce):
+        msg_encrypt = WechatCrypt.encrypt(msg, self.key, self.appid)
+        signature = self.get_sha1(self.token, timestamp, nonce, msg_encrypt)
+        return self.generate(msg_encrypt, signature, timestamp, nonce)
+
+    def decrypt_msg(self, timestamp, nonce, encrypt, msg_signature):
+        signature = self.get_sha1(self.token, timestamp, nonce, encrypt)
+        if signature != msg_signature:
+            return "ValidateSignatureError"
+        decrypted = WechatCrypt.decrypt(encrypt, self.key, self.appid)
+        return decrypted
+
+
+class WechatCrypt:
+    # mode = AES.MODE_CBC
+
+    @classmethod
+    def encrypt(cls, text, key, appid):
+        # struct
+        text_append = (
+            (cls.get_random_str()).encode("utf-8")
+            + struct.pack("I", socket.htonl(len(text.encode("utf-8"))))
+            + text.encode("utf-8")
+            + appid.encode("utf-8")
+        )
+
+        # 使用cryptography中的pad方法填补
+        padded_data = PKCS7Encoder.padder(text_append)
+
+        # 使用cryptography中加密
+        iv = key[:16]
+        encryptor = Cipher(algorithms.AES(key), modes.CBC(iv)).encryptor()
+        ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+        # b64encode and decode('utf-8')
+        text_base64 = base64.b64encode(ciphertext)
+        return text_base64.decode("utf-8")
+
+    @classmethod
+    def decrypt(cls, text, key, appid):
+        ciphertext = base64.b64decode(text)
+
+        # 解密
+        iv = key[:16]
+        decryptor = Cipher(algorithms.AES(key), modes.CBC(iv)).decryptor()
+        plaintext_padded = decryptor.update(ciphertext) + decryptor.finalize()
+
+        # 使用cryptography中的pad方法反填补
+        plain_text = PKCS7Encoder.unpadder(plaintext_padded)
+
+        # 解构
+        content = plain_text[16:]
+        xml_len = socket.ntohl(struct.unpack("I", content[:4])[0])
+        xml = content[4 : xml_len + 4]
+        from_appid = content[xml_len + 4 :]
+
+        # 校验
+        if from_appid == appid.encode("utf-8"):
+            return xml
+        else:
+            raise Exception("ValidateAppidError")
+
+    @classmethod
+    def get_random_str(cls):
+        rule = string.ascii_letters + string.digits
+        str = random.sample(rule, 16)
+        return "".join(str)
+
+
+class PKCS7Encoder:
+    block_size = 32
+
+    @classmethod
+    def padder(cls, data):
+        """use cryptography, equal encode"""
+        padder = padding.PKCS7(cls.block_size * 8).padder()
+        padded_data = padder.update(data) + padder.finalize()
+        return padded_data
+
+    @classmethod
+    def unpadder(cls, data):
+        """use cryptography, equal decode"""
+        unpadder = padding.PKCS7(cls.block_size * 8).unpadder()
+        unpadded_data = unpadder.update(data) + unpadder.finalize()
+        return unpadded_data
+
+    @classmethod
+    def encode(cls, text):
+        text_length = len(text)
+        amount_to_pad = cls.block_size - (text_length % cls.block_size)
+        if amount_to_pad == 0:
+            amount_to_pad = cls.block_size
+        pad = chr(amount_to_pad)
+        return text + (pad * amount_to_pad).encode("utf-8")
+
+    @classmethod
+    def decode(cls, decrypted):
+        # pad = ord(decrypted[-1])  will error # for a bytes object b, b[0] will be an integer
+        pad = decrypted[-1]
+        if pad < 1 or pad > 32:
+            pad = 0
+        return decrypted[:-pad]

python_plugins-0.1.5/src/python_plugins/weixin/weixin_api.py

@@ -0,0 +1,94 @@
+import datetime, json
+import requests
+
+HTTPS_API_WEIXIN = "https://api.weixin.qq.com/"
+API_WEIXIN_ACCESSTOKEN = (
+    HTTPS_API_WEIXIN
+    + "cgi-bin/token?grant_type=client_credential&appid={APPID}&secret={APPSECRET}"
+)
+API_WEIXIN_GETMENU = HTTPS_API_WEIXIN + "cgi-bin/menu/get?access_token={ACCESS_TOKEN}"
+API_WEIXIN_SETMENU = (
+    HTTPS_API_WEIXIN + "cgi-bin/menu/create?access_token={ACCESS_TOKEN}"
+)
+API_WEIXIN_CODE2SESSION = (
+    HTTPS_API_WEIXIN
+    + "sns/jscode2session?appid={APPID}&secret={SECRET}&js_code={JSCODE}&grant_type=authorization_code"
+)
+API_WEIXIN_MSGSECCHECK = (
+    HTTPS_API_WEIXIN + "wxa/msg_sec_check?access_token={ACCESS_TOKEN}"
+)
+API_WEIXIN_IMGSECCHECK = (
+    HTTPS_API_WEIXIN + "wxa/img_sec_check?access_token={ACCESS_TOKEN}"
+)
+API_WEIXIN_MEDIACHECKASYNC = (
+    HTTPS_API_WEIXIN + "wxa/media_check_async?access_token={ACCESS_TOKEN}"
+)
+
+
+class WeixinApi:
+    def __init__(self, app):
+        self.app = app
+
+    def get_local_access_token(self) -> dict | None:
+        """从本地获取access_token"""
+        raise NotImplementedError()
+
+    def update_local_access_token(self, token):
+        """更新本地的access_token"""
+        raise NotImplementedError()
+
+    def get_access_token(self):
+        """get access_token from local, if expire then get from api of weixin and update local data."""
+        access_token = self.get_access_token_from_local()
+        if access_token and access_token["expires_at"] > datetime.datetime.now():
+            return access_token["token"]
+        r = requests.get(
+            API_WEIXIN_ACCESSTOKEN.format(
+                APPID=self.app["appid"], APPSECRET=self.app["appsecret"]
+            )
+        )
+        if r.status_code == 200:
+            rtoken = r.json()
+            token = rtoken["access_token"]
+            expires_at = datetime.datetime.now() + datetime.timedelta(
+                seconds=rtoken["expires_in"]
+            )
+            self.update_local_access_token(token, expires_at)
+            return token
+        return None
+
+    def get_menu(self):
+        token = self.get_access_token()
+        r = requests.get(API_WEIXIN_GETMENU.format(ACCESS_TOKEN=token))
+        return r.json()
+
+    def set_menu(self, menu):
+        token = self.get_access_token()
+        r = requests.post(
+            API_WEIXIN_SETMENU.format(ACCESS_TOKEN=token),
+            data=json.dumps(menu, ensure_ascii=False).encode("utf-8"),
+        )
+        if r.status_code == 200:
+            return r.json()
+        else:
+            return r
+
+    def code2Session(self, code):
+        """调用 auth.code2Session 接口，换取 用户唯一标识 OpenID 和 会话密钥 session_key"""
+        response = requests.get(
+            API_WEIXIN_CODE2SESSION.format(
+                APPID=self.app["appid"], SECRET=self.app["appsecret"], JSCODE=code
+            )
+        )
+        return response.json()
+
+    def msgseccheck(self, content):
+        """检查一段文本是否含有违法违规内容"""
+        token = self.get_access_token()
+        r = requests.post(
+            API_WEIXIN_MSGSECCHECK.format(ACCESS_TOKEN=token),
+            data=json.dumps({"content": content}, ensure_ascii=False).encode("utf-8"),
+        )
+        if r.status_code == 200:
+            return r.json()
+        return r

{python_plugins-0.1.4 → python_plugins-0.1.5}/tests/test_sqlalchemy.py

@@ -1,6 +1,7 @@
 from sqlalchemy.orm import Mapped
 from sqlalchemy.orm import mapped_column
 from python_plugins.models.mixins import PrimaryKeyMixin
+from python_plugins.models.mixins import TokenMixin
 from python_plugins.models.mixins import DataMixin
 from python_plugins.models.mixins import TimestampMixin
 from sqlalchemy.orm import DeclarativeBase
@@ -13,7 +14,7 @@ class Base(DeclarativeBase):
     pass
 
 
-class Demo(PrimaryKeyMixin, DataMixin, TimestampMixin,Base):
+class Demo(PrimaryKeyMixin, TokenMixin, DataMixin, TimestampMixin, Base):
     __tablename__ = "demo"
 
 

python_plugins-0.1.5/tests/test_weixin.py

@@ -0,0 +1,104 @@
+import pytest
+import time
+import hashlib
+from python_plugins.weixin.wechat import Wechat
+from python_plugins.random import rand_digit, rand_letter
+
+
+test_wechat_app = {
+    "name": "test",
+    "appid": "wx2c2769f8efd9abc2",
+    "token": "spamtest",
+    "aeskey": "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
+    "appsecret": "45658c05647671e481d75b6fa23e6add",
+}
+
+
+class MyWechat(Wechat):
+    def get_app(self) -> dict:
+        return test_wechat_app
+
+
+class TestWechat:
+    def test_verify(self):
+        mywechat = MyWechat()
+        # timestamp = "1409735669"
+        timestamp = str(int(time.time()))
+        # nonce = "1320562132"
+        nonce = rand_digit(10)
+        token = test_wechat_app["token"]
+        signature = hashlib.sha1(
+            "".join(sorted([token, timestamp, nonce])).encode("utf8")
+        ).hexdigest()
+        # echostr = "780419598460648693"
+        echostr = rand_digit(18)
+        query = {
+            "timestamp": timestamp,
+            "nonce": nonce,
+            "signature": signature,
+            "echostr": echostr,
+        }
+        r = mywechat.verify(query)
+        # print(r)
+        assert r == echostr
+
+    def test_chat(self):
+        """chat（明文）"""
+        text = rand_letter(10)
+        timestamp = str(int(time.time()))
+        nonce = rand_digit(10)
+        xml = (
+            "<xml>"
+            "<ToUserName><![CDATA[gh_73951532543e]]></ToUserName>"
+            "<FromUserName><![CDATA[oMIza6tX35aDNfoXr4JGP02QvM08]]></FromUserName>"
+            "<CreateTime>{timestamp}</CreateTime>"
+            "<MsgType><![CDATA[text]]></MsgType>"
+            f"<Content><![CDATA[{text}]]></Content>"
+            "<MsgId>23533248665819413</MsgId>"
+            "</xml>"
+        )
+        query = {
+            "timestamp": timestamp,
+            "nonce": nonce,
+            "signature": "b5fa0bcde34ab0b6dccd6e23034c26c0cf5ecbaa",
+            "openid": "oMIza6tX35aDNfoXr4JGP02QvM08",
+        }
+
+        mywechat = MyWechat()
+        r = mywechat.chat(query, xml)
+        # print(r)
+        assert query["openid"] in r
+
+    def test_chat_aes(self):
+        """chat（密文），微信提供的demo"""
+        xml = (
+            "<xml>"
+            "<ToUserName><![CDATA[gh_10f6c3c3ac5a]]></ToUserName>"
+            "<FromUserName><![CDATA[oyORnuP8q7ou2gfYjqLzSIWZf0rs]]></FromUserName>"
+            "<CreateTime>1409735668</CreateTime>"
+            "<MsgType><![CDATA[text]]></MsgType>"
+            "<Content><![CDATA[abcdteT]]></Content>"
+            "<MsgId>6054768590064713728</MsgId>"
+            "<Encrypt>"
+            "<![CDATA[hyzAe4OzmOMbd6TvGdIOO6uBmdJoD0Fk53REIHvxYtJlE2B655HuD0m8KUePW"
+            "B3+LrPXo87wzQ1QLvbeUgmBM4x6F8PGHQHFVAFmOD2LdJF9FrXpbUAh0B5GIItb52sn896"
+            "wVsMSHGuPE328HnRGBcrS7C41IzDWyWNlZkyyXwon8T332jisa+h6tEDYsVticbSnyU8dK"
+            "OIbgU6ux5VTjg3yt+WGzjlpKn6NPhRjpA912xMezR4kw6KWwMrCVKSVCZciVGCgavjIQ6X"
+            "8tCOp3yZbGpy0VxpAe+77TszTfRd5RJSVO/HTnifJpXgCSUdUue1v6h0EIBYYI1BD1DlD+"
+            "C0CR8e6OewpusjZ4uBl9FyJvnhvQl+q5rv1ixrcpCumEPo5MJSgM9ehVsNPfUM669WuMyV"
+            "WQLCzpu9GhglF2PE=]]>"
+            "</Encrypt>"
+            "</xml>"
+        )
+
+        query = {
+            "timestamp": "1409735669",
+            "nonce": "1320562132",
+            "encrypt_type": "aes",
+            "msg_signature": "5d197aaffba7e9b25a30732f161a50dee96bd5fa",
+        }
+
+        mywechat = MyWechat()
+        r = mywechat.chat(query, xml)
+        # print(r)
+        assert f'<Nonce><![CDATA[{query["nonce"]}]]></Nonce>' in r

python_plugins-0.1.4/src/python_plugins/__about__.py

@@ -1 +0,0 @@
-__version__ = "0.1.4"