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

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

@@ -1,3 +1,17 @@
+v0.1.7
+------
+
+Released 2024-10-16
+
+- change html_theme of docs to sphinx_rtd_theme
+
+v0.1.6
+------
+
+Released 2024-10-01
+
+- weixin.wechat support news
+
 v0.1.5
 ------
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-plugins
-Version: 0.1.5
+Version: 0.1.7
 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

python_plugins-0.1.7/docs/conf.py

@@ -0,0 +1,51 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'python-plugins'
+copyright = '2024, David Hua'
+author = 'David Hua'
+
+# -- General configuration ---------------------------------------------------
+# -- General configuration
+
+extensions = [
+    "sphinx.ext.duration",
+    "sphinx.ext.doctest",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+]
+
+# intersphinx_mapping = {
+#     "rtd": ("https://docs.readthedocs.io/en/stable/", None),
+#     "python": ("https://docs.python.org/3/", None),
+#     "sphinx": ("https://www.sphinx-doc.org/en/master/", None),
+# }
+# intersphinx_disabled_domains = ["std"]
+
+templates_path = ["_templates"]
+
+# -- Options for EPUB output
+epub_show_urls = "footnote"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "sphinx_rtd_theme"
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]

{python_plugins-0.1.5 → python_plugins-0.1.7}/docs/index.rst

@@ -1,7 +1,7 @@
 Welcome to python-plugins's documentation!
 ============================================
 
-**python-plugins** is a Flask extensions with admin, SQLAlchemy, babel, forms, fields, widgets, and so on.
+**python-plugins** is a collection with common python utils.
 
 .. toctree::
    :maxdepth: 2

python_plugins-0.1.7/docs/requirements.txt

@@ -0,0 +1,2 @@
+sphinx
+sphinx_rtd_theme

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

@@ -59,7 +59,8 @@ remove_pycache
 
     from  python_plugins.utils.remove_pycache import remove_pycache
 
-    remove_pycache(".")
+    remove_pycache()   # default is "."
+    remove_pycache("./tests")
 
 
 weixin.wechat

python_plugins-0.1.7/src/python_plugins/__about__.py

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

python_plugins-0.1.7/src/python_plugins/__init__.py

@@ -0,0 +1 @@
+from .utils.remove_pycache import remove_pycache

python_plugins-0.1.7/src/python_plugins/convert/pretty.py

@@ -0,0 +1,11 @@
+from re import sub
+
+
+def prettify_class_name(name):
+    """Split words in PascalCase string into separate words.
+
+    :param name:
+        String to split
+    """
+    return sub(r"(?<=.)([A-Z])", r" \1", name)
+

python_plugins-0.1.7/src/python_plugins/crypto/file_to_file.py

@@ -0,0 +1,112 @@
+from .str_to_list import encrypt_bytes_to_list
+from .str_to_list import encrypt_str_to_list
+from .str_to_list import decrypt_list_to_bytes
+from .str_to_list import decrypt_list_to_str
+from getpass import getpass
+
+
+def bytes_from_file(fin) -> bytes:
+    with open(fin, "rb") as f:
+        s = f.read()
+    return s
+
+
+def bytes_to_file(s: bytes, fout):
+    with open(fout, "wb") as f:
+        f.write(s)
+
+
+def str_from_txtfile(fin) -> str:
+    with open(fin, encoding="utf-8") as f:
+        s = f.read()
+    return s
+
+
+def str_to_txtfile(s: str, fout):
+    with open(fout, "w", encoding="utf-8") as f:
+        f.write(s)
+
+
+def bytes_to_file(s, fout):
+    with open(fout, "wb") as f:
+        f.write(s)
+
+
+def encrypt_txt(s: str, prompt=None, accept_password=False):
+    if not prompt:
+        prompt = input("input prompt=")
+    password = None
+    if accept_password:
+        password = getpass("input password=")
+    if password:
+        encrypted_list = encrypt_str_to_list(s, password)
+        encrypted_list[0] = "-"
+    else:
+        encrypted_list = encrypt_str_to_list(s)
+    s2 = "\n".join([prompt] + encrypted_list)
+    return s2
+
+
+def decrypt_txt(s: str):
+    encrypted_list = s.split("\n")
+    prompt = encrypted_list[0]
+    if encrypted_list[1] == "-":
+        print(prompt)
+        password = getpass("input password=")
+        s2 = decrypt_list_to_str(encrypted_list[1:], password)
+    else:
+        s2 = decrypt_list_to_str(encrypted_list[1:])
+
+    return s2
+
+
+def encrypt_txtfile(fin, fout, prompt=None, accept_password=False):
+    s = str_from_txtfile(fin)
+    s2 = encrypt_txt(s, prompt, accept_password)
+    str_to_txtfile(s2, fout)
+
+
+def decrypt_txtfile(fin, fout):
+    s = str_from_txtfile(fin)
+    s2 = decrypt_txt(s)
+    str_to_txtfile(s2, fout)
+
+
+def encrypt_bytes(s: bytes, prompt=None, accept_password=False):
+    if not prompt:
+        prompt = input("input prompt=")
+    password = None
+    if accept_password:
+        password = getpass("input password=")
+    if password:
+        encrypted_list = encrypt_bytes_to_list(s, password)
+        encrypted_list[0] = "-"
+    else:
+        encrypted_list = encrypt_bytes_to_list(s)
+    s2 = "\n".join([prompt] + encrypted_list)
+    return s2
+
+
+def decrypt_bytes(s: str):
+    encrypted_list = s.split("\n")
+    prompt = encrypted_list[0]
+    if encrypted_list[1] == "-":
+        print(prompt)
+        password = getpass("input password=")
+        s2 = decrypt_list_to_bytes(encrypted_list[1:], password)
+    else:
+        s2 = decrypt_list_to_bytes(encrypted_list[1:])
+
+    return s2
+
+
+def encrypt_file(fin, fout, prompt=None, accept_password=False):
+    s = bytes_from_file(fin)
+    s2 = encrypt_bytes(s, prompt, accept_password)
+    str_to_txtfile(s2, fout)
+
+
+def decrypt_file(fin, fout):
+    s = str_from_txtfile(fin)
+    s2 = decrypt_bytes(s)
+    bytes_to_file(s2, fout)

{python_plugins-0.1.5 → python_plugins-0.1.7}/src/python_plugins/crypto/str_to_list.py

@@ -54,7 +54,7 @@ def str_randsplit_to_list(s, n1=10, n2=30):
     return r
 
 
-def encrypt_str_to_list(s: str, password=None, prefix=None):
+def encrypt_bytes_to_list(s: bytes, password=None, prefix=None):
     if password is None:
         password = rand_letter(random.randint(6, 16))
         out_password = password
@@ -66,7 +66,7 @@ def encrypt_str_to_list(s: str, password=None, prefix=None):
     key, safe_salt, times = get_key(password)
 
     cipher_suite = Fernet(key)
-    encrypted_data = cipher_suite.encrypt(s.encode())
+    encrypted_data = cipher_suite.encrypt(s)
     safe_data = bytes_to_url64str(encrypted_data)
 
     list_out = [out_password, safe_salt, str(times)] + str_randsplit_to_list(safe_data)
@@ -74,7 +74,7 @@ def encrypt_str_to_list(s: str, password=None, prefix=None):
     return list_out
 
 
-def decrypt_list_to_str(list_in, password=None, prefix=None):
+def decrypt_list_to_bytes(list_in, password=None, prefix=None) -> bytes:
     _password, safe_salt, _times, *_data = list_in
     if password is None:
         password = _password
@@ -88,4 +88,14 @@ def decrypt_list_to_str(list_in, password=None, prefix=None):
     key, _, _ = get_key(password, safe_salt, times)
     cipher_suite = Fernet(key)
     decrypted_bytes = cipher_suite.decrypt(url64str_to_bytes(s))
+    return decrypted_bytes
+
+
+def encrypt_str_to_list(s: str, password=None, prefix=None):
+    arr = encrypt_bytes_to_list(s.encode(), password, prefix)
+    return arr
+
+
+def decrypt_list_to_str(list_in, password=None, prefix=None):
+    decrypted_bytes = decrypt_list_to_bytes(list_in, password, prefix)
     return decrypted_bytes.decode()

{python_plugins-0.1.5 → python_plugins-0.1.7}/src/python_plugins/utils/remove_pycache.py

@@ -1,7 +1,7 @@
 import os
 import shutil
 
-def remove_pycache(dir_path):
+def remove_pycache(dir_path="."):
     for root, dirs, files in os.walk(dir_path):
         if "venv" in root or "git" in root:
             continue

python_plugins-0.1.7/src/python_plugins/weixin/format_response.py

@@ -0,0 +1,148 @@
+import time
+
+# see https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Passive_user_reply_message.html
+
+# 文本消息
+# Content 回复的消息内容（换行：在content中能够换行\n,支持超链接<a href="url">xxx</a>）,
+XML_TEXT_TEMPLATE = """<xml>
+<ToUserName><![CDATA[{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[text]]></MsgType>
+<Content><![CDATA[{content}]]></Content>
+</xml>"""
+
+
+# 图片消息
+# MediaId 是 通过素材管理中的接口上传多媒体文件，得到的id
+XML_IMAGE_TEMPLATE = """<xml>
+<ToUserName><![CDATA [{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[image]]></MsgType>
+<Image>
+<MediaId><![CDATA[{media_id}]]></MediaId>
+</Image>
+</xml>"""
+
+
+# 语音消息
+# MediaId 是 通过素材管理中的接口上传多媒体文件，得到的id
+
+XML_VOICE_TEMPLATE = """<xml>
+<ToUserName><![CDATA [{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[voice]]></MsgType>
+<Voice>
+<MediaId><![CDATA[{media_id}]]></MediaId>
+</Voice>
+</xml>"""
+
+# 视频消息
+# MediaId 是 通过素材管理中的接口上传多媒体文件，得到的id
+# Title 否 视频消息的标题
+# Description 否 视频消息的描述
+
+XML_VIDEO_TEMPLATE = """<xml>
+<ToUserName><![CDATA [{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[video]]></MsgType>
+<Video>
+<MediaId><![CDATA[{media_id}]]></MediaId>
+<Title><![CDATA[{title}]]></Title>
+<Description><![CDATA[{description}]]></Description>
+</Video>
+</xml>"""
+
+# 音乐消息
+
+# Title 否 音乐标题
+# Description 否 音乐描述
+# MusicURL 否 音乐链接
+# HQMusicUrl 否 高质量音乐链接，WIFI环境优先使用该链接播放音乐
+# ThumbMediaId 是 缩略图的媒体id，通过素材管理中的接口上传多媒体文件，得到的id
+
+XML_MUSIC_TEMPLATE = """<xml>
+<ToUserName><![CDATA [{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[music]]></MsgType>
+<Music>
+<Title><![CDATA[{title}]]></Title>
+<Description><![CDATA[{description}]]></Description>
+<MusicUrl><![CDATA[{music_url}]]></MusicUrl>
+<HQMusicUrl><![CDATA[{hq_music_url}]]></HQMusicUrl>
+<ThumbMediaId><![CDATA[{media_id}]]></ThumbMediaId>
+</Music>
+</xml>"""
+
+# 图文消息
+
+# ArticleCount  是 图文消息个数；当用户发送文本、图片、语音、视频、图文、地理位置这六种消息时，开发者只能回复1条图文消息；其余场景最多可回复8条图文消息
+# Articles      是 图文消息信息，注意，如果图文数超过限制，则将只发限制内的条数
+# Title         是 图文消息标题
+# Description   是 图文消息描述
+# PicUrl        是 图片链接，支持JPG、PNG格式，较好的效果为大图360*200，小图200*200
+# Url           是 点击图文消息跳转链接
+
+XML_NEWS_TEMPLATE_OLD = """<xml>
+  <ToUserName><![CDATA [{toUser}]]></ToUserName>
+  <FromUserName><![CDATA[{fromUser}]]></FromUserName>
+  <CreateTime>{createtime}</CreateTime>
+  <MsgType><![CDATA[news]]></MsgType>
+  <ArticleCount>{article_count}</ArticleCount>
+  <Articles>
+    <item>
+      <Title><![CDATA[{title}]]></Title>
+      <Description><![CDATA[{description}]]></Description>
+      <PicUrl><![CDATA[{pic_url}]]></PicUrl>
+      <Url><![CDATA[{url}]]></Url>
+    </item>
+  </Articles>
+</xml>"""
+
+XML_ARTICLE_ITEM = """<item>
+<Title><![CDATA[{title}]]></Title>
+<Description><![CDATA[{description}]]></Description>
+<PicUrl><![CDATA[{pic_url}]]></PicUrl>
+<Url><![CDATA[{url}]]></Url>
+</item>"""
+
+XML_NEWS_TEMPLATE = """<xml>
+<ToUserName><![CDATA [{toUser}]]></ToUserName>
+<FromUserName><![CDATA[{fromUser}]]></FromUserName>
+<CreateTime>{createtime}</CreateTime>
+<MsgType><![CDATA[news]]></MsgType>
+<ArticleCount>{article_count}</ArticleCount>
+<Articles>
+{xml_articles_items}
+</Articles>
+</xml>"""
+
+
+def get_wechat_xml_response(data):
+    if "createtime" not in data:
+        data["createtime"] = int(time.time())
+
+    match data["type"]:
+        case "text":
+            xml = XML_TEXT_TEMPLATE.format(**data)
+        case "image":
+            xml = XML_IMAGE_TEMPLATE.format(**data)
+        case "voice":
+            xml = XML_VOICE_TEMPLATE.format(**data)
+        case "video":
+            xml = XML_VIDEO_TEMPLATE.format(**data)
+        case "music":
+            xml = XML_MUSIC_TEMPLATE.format(**data)
+        case "news":
+            xml_articles_items = ""
+            for article in data["articles"]:
+                xml_articles_items += XML_ARTICLE_ITEM.format(**article)
+            data["article_count"] = len(data["articles"])
+            data["xml_articles_items"] = xml_articles_items
+            xml = XML_NEWS_TEMPLATE.format(**data)
+
+    return xml

{python_plugins-0.1.5 → python_plugins-0.1.7}/src/python_plugins/weixin/wechat.py

@@ -1,15 +1,8 @@
 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>"""
+from .wechat_crypt import get_signature
+from .format_response import get_wechat_xml_response
 
 
 class Wechat:
@@ -32,8 +25,7 @@ class Wechat:
         nonce = args["nonce"]
         echostr = args["echostr"]
         token = self.app["token"]
-        tmpstr = "".join(sorted([token, timestamp, nonce])).encode("utf8")
-        if hashlib.sha1(tmpstr).hexdigest() == signature:
+        if get_signature([token, timestamp, nonce]) == signature:
             return echostr
         else:
             return
@@ -48,41 +40,37 @@ class Wechat:
         xml_dict = xml2dict(content)
 
         if not encrypt_type:
-            # 未加密
-            result = self.dispatch(xml_dict)
-            xml_reponse = self.responseText(result)
+            self.input = xml_dict
+            self.dispatch()
+            self.get_xml_response()
+            xml_reponse = self.xml_response
         else:
-            # 解密
+            # decrypt
             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)
+            self.input = xml2dict(xml_decrypted)
+            self.dispatch()
+            self.get_xml_response()
+            # encrypt
+            xml_reponse = mc.encrypt_msg(self.xml_response, timestamp, nonce)
 
-        return xml_reponse
+        # 返回前记录下日志，如果实现记录日志的话
+        self.log_data()
 
-    def responseText(self, content):
-        data = {
-            "touser": self.fromUser,
-            "fromuser": self.toUser,
-            "createtime": int(time.time()),
-            "content": content,
-        }
-        return XML_TEXT_TEMPLATE.format(**data)
+        return xml_reponse
 
-    def dispatch(self, data):
-        self.toUser = data["ToUserName"]
-        self.fromUser = data["FromUserName"]
-        msgType = data["MsgType"]
+    def dispatch(self):
+        self.default_answer()
+        self.toUser = self.input["ToUserName"]
+        self.fromUser = self.input["FromUserName"]
+        msgType = self.input["MsgType"]
 
         if msgType == "text":
-            keyword = data["Content"]
+            keyword = self.input["Content"]
         elif msgType == "event":
-            event = data["Event"]
+            event = self.input["Event"]
             if event == "subscribe":
                 # self.onSubscribe()
                 keyword = "subscribe"
@@ -90,7 +78,7 @@ class Wechat:
                 # self.onUnsubscribe()
                 keyword = "unsubscribe"
             elif event == "CLICK":
-                eventKey = data["EventKey"]
+                eventKey = self.input["EventKey"]
                 keyword = eventKey
             else:
                 keyword = "<event:{event}>"
@@ -103,8 +91,8 @@ class Wechat:
         elif msgType == "shortvideo":
             keyword = f"<{msgType}>"
         elif msgType == "location":
-            location_x = data["location_x"]
-            location_y = data["location_y"]
+            location_x = self.input["location_x"]
+            location_y = self.input["location_y"]
             keyword = f"<{msgType}({location_x},{location_y})>"
         elif msgType == "link":
             keyword = f"<{msgType}>"
@@ -112,17 +100,36 @@ class Wechat:
             keyword = f"<{msgType}>"
 
         self.keyword = keyword
-        answer = self.answer()
 
-        # 返回前记录下日志，如果实现记录日志的话
-        self.log_data()
+        self.get_answer()
+        return
 
-        return self.responseText(answer)
+    def default_answer(self):
+        self.answer = {"type": "text", "content": "I'm sorry, I don't understand."}
+        return
 
-    def answer(self):
-        q = self.keyword
-        if q == "subscribe":
-            r = f"您好,欢迎关注[{self.app['name']}]!"
-        else:
-            r = q
-        return r
+    def get_answer(self):
+        match self.keyword:
+            case "subscribe":
+                r = f"Hello, welcome to {self.app['name']}!"
+                self.answer = {"type": "text", "content": r}
+            case _:
+                self.answer = {"type": "text", "content": "a:" + self.keyword}
+        return
+
+    def get_xml_response(self):
+        self.data_response = {
+            "type" : self.answer["type"],
+            "toUser": self.fromUser,
+            "fromUser": self.toUser,
+        }
+        
+        match self.answer["type"]:
+            case "text":                
+                self.data_response["content"] = self.answer["content"]
+            case "news":
+                self.data_response["articles"] = self.answer["articles"]
+                
+        self.xml_response = get_wechat_xml_response(self.data_response)
+        
+        return

{python_plugins-0.1.5 → python_plugins-0.1.7}/src/python_plugins/weixin/wechat_crypt.py

@@ -12,11 +12,15 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
 ENCRYPT_TEXT_RESPONSE_TEMPLATE = """<xml>
 <Encrypt><![CDATA[{msg_encrypt}]]></Encrypt>
-<MsgSignature><![CDATA[{msg_signaturet}]]></MsgSignature>
+<MsgSignature><![CDATA[{msg_signature}]]></MsgSignature>
 <TimeStamp>{timestamp}</TimeStamp>
 <Nonce><![CDATA[{nonce}]]></Nonce>
 </xml>"""
 
+def get_signature(arr):
+    tmpstr = "".join(sorted(arr)).encode("utf-8")
+    return hashlib.sha1(tmpstr).hexdigest()
+
 
 class MessageCrypt:
     def __init__(self, appid, token, aeskey):
@@ -24,26 +28,26 @@ class MessageCrypt:
         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,
+            "msg_signature": signature,
             "timestamp": timestamp,
             "nonce": nonce,
         }
         return ENCRYPT_TEXT_RESPONSE_TEMPLATE.format(**data)
 
-    def encrypt_msg(self, msg, timestamp, nonce):
+    def get_encrypt_sig(self, msg, timestamp, nonce):
         msg_encrypt = WechatCrypt.encrypt(msg, self.key, self.appid)
-        signature = self.get_sha1(self.token, timestamp, nonce, msg_encrypt)
+        signature = get_signature([self.token, timestamp, nonce, msg_encrypt])
+        return (msg_encrypt, signature)
+
+    def encrypt_msg(self, msg, timestamp, nonce):
+        msg_encrypt,signature = self.get_encrypt_sig(msg,timestamp,nonce)
         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)
+        signature = get_signature([self.token, timestamp, nonce, encrypt])
         if signature != msg_signature:
             return "ValidateSignatureError"
         decrypted = WechatCrypt.decrypt(encrypt, self.key, self.appid)

python_plugins-0.1.7/tests/test_crypt_file.py

@@ -0,0 +1,84 @@
+import os
+import os.path as op
+import filecmp
+from python_plugins.random.random_str import rand_sentence
+from python_plugins.crypto.file_to_file import encrypt_txtfile
+from python_plugins.crypto.file_to_file import decrypt_txtfile
+from python_plugins.crypto.file_to_file import encrypt_file
+from python_plugins.crypto.file_to_file import decrypt_file
+
+
+tmp_path = op.join(os.path.dirname(os.path.abspath(__file__)), "tmp")
+
+path_1 = op.join(tmp_path, "test1.txt")
+path_2 = op.join(tmp_path, "test2.txt")
+path_3 = op.join(tmp_path, "test3.txt")
+path_4 = op.join(tmp_path, "test4.txt")
+path_5 = op.join(tmp_path, "test5.txt")
+
+
+def _create_temp():
+    if not op.exists(tmp_path):
+        os.mkdir(tmp_path)
+        return tmp_path
+
+
+def safe_delete(path):
+    try:
+        if op.exists(path):
+            os.remove(path)
+    except:
+        pass
+
+
+def _remove_testfiles():
+    safe_delete(path_1)
+    safe_delete(path_2)
+    safe_delete(path_3)
+    safe_delete(path_4)
+    safe_delete(path_5)
+
+
+def test_crypto_file():
+    create_tmp = _create_temp()
+    if create_tmp:
+        print(create_tmp)
+
+    prompt = "test"
+
+    with open(path_1, "w") as f:
+        f.write(rand_sentence(30))
+        f.write(rand_sentence(30))
+
+    encrypt_txtfile(path_1, path_2, prompt=prompt)
+    decrypt_txtfile(path_2, path_3)
+    cmp_result = filecmp.cmp(path_1, path_3)
+    assert cmp_result is True
+
+    encrypt_file(path_1, path_4, prompt=prompt)
+    decrypt_file(path_2, path_5)
+    cmp_result = filecmp.cmp(path_1, path_5)
+    assert cmp_result is True
+
+    _remove_testfiles()
+
+# pytest with `input()` must using `-s` 
+# pytest tests\test_crypt_file.py::test_crypto_file_with_password -s
+def _test_crypto_file_with_password():
+    prompt = "test"
+
+    with open(path_1, "w") as f:
+        f.write(rand_sentence(30))
+        f.write(rand_sentence(30))
+
+    encrypt_txtfile(path_1, path_2, accept_password=True)
+    decrypt_txtfile(path_2, path_3)
+    cmp_result = filecmp.cmp(path_1, path_3)
+    assert cmp_result is True
+
+    encrypt_file(path_1, path_4, accept_password=True)
+    decrypt_file(path_2, path_5)
+    cmp_result = filecmp.cmp(path_1, path_5)
+    assert cmp_result is True
+
+    _remove_testfiles()

{python_plugins-0.1.5 → python_plugins-0.1.7}/tests/test_utils.py

@@ -6,3 +6,6 @@ from python_plugins.utils.remove_pycache import remove_pycache
 def test_remove_pycache():
     remove_pycache("./tests")
 
+@pytest.mark.skip
+def test_remove_pycache():
+    remove_pycache()

python_plugins-0.1.7/tests/test_weixin.py

@@ -0,0 +1,132 @@
+import pytest
+import time
+import hashlib
+from python_plugins.weixin.wechat import Wechat
+from python_plugins.weixin.wechat_crypt import get_signature
+from python_plugins.weixin.wechat_crypt import MessageCrypt
+from python_plugins.random import rand_digit, rand_letter
+from python_plugins.convert.xml import xml2dict
+
+
+test_wechat_app = {
+    "name": "test",
+    "appid": "wxabcdefghijklmnop",
+    "token": "testtest",
+    "aeskey": "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
+    "appsecret": "abcdefghijklmnopqrstuvwxyz012345",
+}
+
+server_id = "gh_1234567890ab"
+openid = "abcdefghijklmnopqrstuvwxyz01"
+
+
+class MyWechat(Wechat):
+    def get_app(self) -> dict:
+        return test_wechat_app
+
+
+class TestWechat:
+    def test_verify(self):
+        mywechat = MyWechat()
+        timestamp = str(int(time.time()))
+        nonce = rand_digit(10)
+        token = test_wechat_app["token"]
+        signature = get_signature([token, timestamp, nonce])
+        echostr = rand_digit(18)
+        query = {
+            "timestamp": timestamp,
+            "nonce": nonce,
+            "signature": signature,
+            "echostr": echostr,
+        }
+        r = mywechat.verify(query)
+        assert r == echostr
+
+    def test_chat(self):
+        """chat（明文）"""
+        input_text = rand_letter(10)
+        timestamp = str(int(time.time()))
+        nonce = rand_digit(10)
+
+        xml = (
+            "<xml>"
+            f"<ToUserName><![CDATA[{server_id}]]></ToUserName>"
+            f"<FromUserName><![CDATA[{openid}]]></FromUserName>"
+            f"<CreateTime>{timestamp}</CreateTime>"
+            "<MsgType><![CDATA[text]]></MsgType>"
+            f"<Content><![CDATA[{input_text}]]></Content>"
+            "<MsgId>23533248665819413</MsgId>"
+            "</xml>"
+        )
+        query = {
+            "timestamp": timestamp,
+            "nonce": nonce,
+            "openid": f"{openid}",
+        }
+
+        mywechat = MyWechat()
+        r = mywechat.chat(query, xml)
+        data = xml2dict(r)
+        # print(data)
+        assert data["ToUserName"] == openid
+        assert data["FromUserName"] == server_id
+        assert data["MsgType"] == "text"
+        assert input_text in data["Content"]
+
+    def test_chat_aes(self):
+        """chat（密文）"""
+        input_text = rand_letter(10)
+        timestamp = str(int(time.time()))
+        nonce = rand_digit(10)
+        mywechat = MyWechat()
+        app = mywechat.app
+        mc = MessageCrypt(app["appid"], app["token"], app["aeskey"])
+
+        xml = (
+            "<xml>"
+            f"<ToUserName><![CDATA[{server_id}]]></ToUserName>"
+            f"<FromUserName><![CDATA[{openid}]]></FromUserName>"
+            f"<CreateTime>{timestamp}</CreateTime>"
+            "<MsgType><![CDATA[text]]></MsgType>"
+            f"<Content><![CDATA[{input_text}]]></Content>"
+            "<MsgId>23533248665819413</MsgId>"
+            "</xml>"
+        )
+
+        # 获取密文和签名
+        encrypt, msg_signature = mc.get_encrypt_sig(xml, timestamp, nonce)
+
+        xml2 = (
+            "<xml>"
+            f"<ToUserName><![CDATA[{server_id}]]></ToUserName>"
+            f"<FromUserName><![CDATA[{openid}]]></FromUserName>"
+            f"<CreateTime>{timestamp}</CreateTime>"
+            "<MsgType><![CDATA[text]]></MsgType>"
+            f"<Content><![CDATA[{input_text}]]></Content>"
+            "<MsgId>6054768590064713728</MsgId>"
+            f"<Encrypt><![CDATA[{encrypt}]]></Encrypt>"
+            "</xml>"
+        )
+
+        query = {
+            "timestamp": timestamp,
+            "nonce": nonce,
+            "encrypt_type": "aes",
+            "msg_signature": msg_signature,
+        }
+
+        r = mywechat.chat(query, xml2)
+        # print(r)
+        r_dict = xml2dict(r)
+        r_xml = mc.decrypt_msg(
+            r_dict["TimeStamp"],
+            r_dict["Nonce"],
+            r_dict["Encrypt"],
+            r_dict["MsgSignature"],
+        )
+        data = xml2dict(r_xml)
+        # print(data)
+        assert data["ToUserName"] == openid
+        assert data["FromUserName"] == server_id
+        assert data["MsgType"] == "text"
+        assert input_text in data["Content"]

python_plugins-0.1.5/docs/conf.py

@@ -1,30 +0,0 @@
-# Configuration file for the Sphinx documentation builder.
-#
-# For the full list of built-in configuration values, see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Project information -----------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
-
-project = 'python-plugins'
-copyright = '2024, David Hua'
-author = 'David Hua'
-
-# -- General configuration ---------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
-
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.intersphinx',
-    'sphinx.ext.doctest',    
-    'sphinx.ext.autosummary',    
-]
-
-templates_path = ['_templates']
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# -- Options for HTML output -------------------------------------------------
-# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
-
-html_theme = 'classic'
-html_title = "python-plugins Documentation"

python_plugins-0.1.5/docs/requirements.txt

@@ -1,2 +0,0 @@
-# Defining the exact version will make sure things don't break
-sphinx

python_plugins-0.1.5/src/python_plugins/__about__.py

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

python_plugins-0.1.5/tests/__init__.py

@@ -1 +0,0 @@
-

python_plugins-0.1.5/tests/test_weixin.py

@@ -1,104 +0,0 @@
-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