python-plugins 0.2.1__tar.gz → 0.2.3__tar.gz

{python_plugins-0.2.1 → python_plugins-0.2.3}/CHANGES.rst

@@ -1,3 +1,17 @@
+v0.2.3
+------
+
+Released 2025-11-02
+
+- zip7
+  
+v0.2.2
+------
+
+Released 2024-12-27
+
+- update-icons
+
 v0.2.1
 ------
 
@@ -10,7 +24,7 @@ v0.2.0
 
 Released 2024-11-20
 
-- add forms
+- add random
 
 
 v0.1.9
@@ -18,7 +32,7 @@ v0.1.9
 
 Released 2024-11-19
 
-- add forms
+- add convert
 
 
 v0.1.8
@@ -62,7 +76,7 @@ v0.1.3
 
 Released 2024-09-19
 
-- support random_str,jwt,hash_file,fernet
+- support hash_file,fernet
 
 v0.1.2
 ------

{python_plugins-0.2.1 → python_plugins-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-plugins
-Version: 0.2.1
+Version: 0.2.3
 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
@@ -27,6 +27,7 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
+License-File: LICENSE.rst
 Keywords: plugin,utils
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -49,8 +50,6 @@ Provides-Extra: requests
 Requires-Dist: requests; extra == 'requests'
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy; extra == 'sqlalchemy'
-Provides-Extra: wtforms
-Requires-Dist: wtforms; extra == 'wtforms'
 Description-Content-Type: text/x-rst
 
 python-plugins

{python_plugins-0.2.1 → python_plugins-0.2.3}/docs/usage.rst

@@ -54,7 +54,7 @@ mixins
 
    db = SQLAlchemy(model_class=Base)
 
-   class User(db.models,PrimaryKeyMixin, DataMixin, TimestampMixin, UserMixin):
+   class User(db.Model,PrimaryKeyMixin, DataMixin, TimestampMixin, UserMixin):
       __tablename__ = "users"
 
 walk_remove_dir

{python_plugins-0.2.1 → python_plugins-0.2.3}/pyproject.toml

@@ -30,7 +30,6 @@ dependencies = [
 cryptography = ["cryptography"]
 requests = ["requests"]
 sqlalchemy = ["SQLAlchemy"]
-wtforms = ["WTForms"]
 pillow = ["pillow"]
 qrcode = ["qrcode"]
 jwt = ["PyJWT"]

python_plugins-0.2.3/requirements/develop.in

@@ -0,0 +1 @@
+lxml

{python_plugins-0.2.1 → python_plugins-0.2.3}/requirements/test.in

@@ -4,4 +4,3 @@ cryptography
 SQLAlchemy
 PyJWT
 requests
-WTForms

python_plugins-0.2.3/src/python_plugins/__about__.py

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

python_plugins-0.2.3/src/python_plugins/crypto/zipmix.py

@@ -0,0 +1,264 @@
+import os
+import random
+import hashlib
+import tempfile
+import filecmp
+from pathlib import Path
+import subprocess
+
+
+class ZipMix:
+    def __init__(self, zipcmd="7z"):
+        self.zipcmd = zipcmd
+        self.z7_available = self.check_7z_available()
+
+    def check_7z_available(self) -> bool:
+        try:
+            subprocess.run([self.zipcmd], capture_output=True, check=True)
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def create_mix_flag(self, pos: int, nlen: int) -> bytes:
+        """m{}i{}x{}{nlen}{}"""
+        start_bytes = pos.to_bytes(4, byteorder="big")
+        return b"m%si%sx%s%s%s" % (
+            start_bytes[0:1],
+            start_bytes[1:2],
+            start_bytes[2:3],
+            nlen.to_bytes(1, byteorder="big"),
+            start_bytes[3:4],
+        )
+
+    def int_to_bytes(self, pos: int):
+        return pos.to_bytes(4, byteorder="big")
+
+    def int_from_bytes(self, intbs):
+        return int.from_bytes(intbs, byteorder="big")
+
+    def extract_from_mix_flag(self, mix_flag):
+        fix_flag = mix_flag[0:1] + mix_flag[2:3] + mix_flag[4:5]
+        if fix_flag != b"mix":
+            raise ValueError("not match mix.")
+        nlen = self.int_from_bytes(mix_flag[6:7])
+        pos = self.int_from_bytes(
+            mix_flag[1:2] + mix_flag[3:4] + mix_flag[5:6] + mix_flag[7:8]
+        )
+        return (pos, nlen)
+
+    def insert_string_to_binary(self, data, insert_bytes):
+        n_data = len(data)
+        n_ibytes = len(insert_bytes)
+        pos_list = sorted(random.sample(range(min(n_data, 0xFFFFFFFF)), n_ibytes))
+
+        parts = []
+        pre_pos = 0
+
+        for i, curr_pos in enumerate(pos_list):
+            if i == 0:
+                end_flag = self.create_mix_flag(curr_pos, n_ibytes)
+            else:
+                parts.append(self.int_to_bytes(curr_pos))
+
+            parts.append(data[pre_pos:curr_pos])
+            parts.append(insert_bytes[i : i + 1])
+            pre_pos = curr_pos
+
+        parts.append(data[pre_pos:])
+        parts.append(end_flag)
+        return b"".join(parts)
+
+    def extract_string_from_binary(self, data):
+        start_pos, n_insert_bytes = self.extract_from_mix_flag(data[-8:])
+        parts = []
+        insert_parts = []
+        pos_list = [start_pos]
+        data_pre_pos = 0
+        curr_pos = start_pos
+
+        for k in range(n_insert_bytes):
+            data_curr_pos = curr_pos + 5 * k
+            parts.append(data[data_pre_pos:data_curr_pos])
+            insert_parts.append(data[data_curr_pos : data_curr_pos + 1])
+            if k < n_insert_bytes - 1:
+                curr_pos = self.int_from_bytes(
+                    data[data_curr_pos + 1 : data_curr_pos + 5]
+                )
+                pos_list.append(curr_pos)
+                data_pre_pos = data_curr_pos + 5
+            else:
+                curr_pos = None
+                data_pre_pos = data_curr_pos + 1
+
+        parts.append(data[data_pre_pos:-8])
+        return b"".join(insert_parts), b"".join(parts)
+
+    def _generate_password(self) -> str:
+        return hashlib.sha256(os.urandom(1000)).hexdigest()[:32]
+
+    def zip7(self, file_or_dir, archive_path=None, pwd=None, force_pwd=False,silent = True):
+        path_obj = Path(file_or_dir)
+        if not path_obj.exists():
+            return None
+
+        if archive_path is None:
+            archive_path = file_or_dir + ".7z"
+
+        if pwd is None:
+            if force_pwd:
+                pwd = self._generate_password()
+        else:
+            pwd = pwd[:32]
+
+        cmd = [self.zipcmd, "a"]
+        if silent:
+            cmd.append("-bso0")
+        if pwd:
+            cmd.extend([f"-p{pwd}", "-mhe=on"])
+        cmd.extend([archive_path, file_or_dir])
+
+        try:
+            subprocess.run(cmd, check=True)
+            if pwd is not None:
+                return ("ok", archive_path, pwd)
+            else:
+                return ("ok", archive_path)
+        except subprocess.CalledProcessError as e:
+            return ("fail", f"{e}")
+
+    def unzip7_list_archive(self, archive_path, pwd=None,silent = True):
+        cmd = [self.zipcmd, "l"]
+        if silent:
+            cmd.append("-bso0")
+        if pwd:
+            cmd.append(f"-p{pwd}")
+        cmd.append(archive_path)
+
+        try:
+            subprocess.run(cmd, check=True)
+            return ("ok", archive_path)
+        except subprocess.CalledProcessError as e:
+            return ("fail", f"{e}")
+
+    def unzip7(self, archive_path, output_path=None, pwd=None, overwrite: bool = True,silent = True):
+        archive_obj = Path(archive_path)
+
+        if output_path is None:
+            output_dir = archive_obj.parent
+        else:
+            output_dir = Path(output_path)
+
+        if not output_dir.exists():
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+        if not output_dir.is_dir():
+            return ("fail", f"{output_dir} is not dir")
+
+        cmd = [self.zipcmd, "x", "-y"]
+        if silent:
+            cmd.append("-bso0")
+        if not overwrite:
+            cmd.append("-aos")
+        if pwd:
+            cmd.append(f"-p{pwd}")
+        cmd.extend([archive_path, f"-o{output_dir}"])
+
+        try:
+            subprocess.run(cmd, check=True)
+            return ("ok", f"{output_dir}")
+        except subprocess.CalledProcessError as e:
+            return ("fail", f"{e}")
+
+    def zip7mix(self, file_or_dir, archive_path=None,silent = True):
+        path_obj = Path(file_or_dir)
+        if not path_obj.exists():
+            return None
+
+        if archive_path is None:
+            archive_path = file_or_dir + ".7z"
+
+        tmp_archive_path = archive_path+".tmp"
+
+        tmp_obj = Path(tmp_archive_path)
+        if tmp_obj.exists():
+            tmp_obj.unlink()
+
+        pwd = self._generate_password()
+
+        cmd = [self.zipcmd, "a"]
+        if silent:
+            cmd.append("-bso0")
+        cmd.extend([f"-p{pwd}", "-mhe=on"])
+        cmd.extend([tmp_archive_path, file_or_dir])
+
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as e:
+            return ("fail", f"{e}")
+        
+        with open(tmp_archive_path,"rb") as f1:
+            data = f1.read()
+
+        # remove tmp file  
+        tmp_obj.unlink()
+        
+        new_data = self.insert_string_to_binary(data,pwd.encode('utf-8'))
+
+        # append fake 7z tail
+        new_data += data[-100:]
+
+        with open(archive_path,"wb") as f2:
+            f2.write(new_data)
+
+        return ("ok", archive_path)
+
+    def unzip7mix(self, archive_path, output_path=None, overwrite: bool = True,silent = True):
+        archive_obj = Path(archive_path)
+
+        tmp_archive_path = archive_path+".tmp"
+
+        tmp_obj = Path(tmp_archive_path)
+        if tmp_obj.exists():
+            tmp_obj.unlink()
+
+        if output_path is None:
+            output_dir = archive_obj.parent
+        else:
+            output_dir = Path(output_path)
+
+        if not output_dir.exists():
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+        if not output_dir.is_dir():
+            return ("fail", f"{output_dir} is not dir")
+        
+        with open(archive_path,"rb") as f1:
+            data = f1.read()
+            # remove fake 7z tail
+            data = data[:-100]
+
+        pwdbts,new_data = self.extract_string_from_binary(data)
+
+        pwd = pwdbts.decode("utf-8")
+
+        with open(tmp_archive_path,"wb") as f2:
+            f2.write(new_data)
+        
+        cmd = [self.zipcmd, "x", "-y"]
+        if silent:
+            cmd.append("-bso0")
+        if not overwrite:
+            cmd.append("-aos")
+        cmd.append(f"-p{pwd}")
+        cmd.extend([tmp_archive_path, f"-o{output_dir}"])
+
+        try:
+            subprocess.run(cmd, check=True)
+            tmp_obj.unlink()
+            return ("ok", f"{output_dir}")
+        except subprocess.CalledProcessError as e:
+            return ("fail", f"{e}")
+
+    def filecmp(self,f1,f2):
+        result = filecmp.cmp(f1, f2, shallow=False)
+        return result

python_plugins-0.2.3/src/python_plugins/email/__init__.py

@@ -0,0 +1 @@
+from .smtp import SmtpSSL

python_plugins-0.2.3/src/python_plugins/email/smtp.py

@@ -0,0 +1,51 @@
+import smtplib
+from email.message import EmailMessage
+import mimetypes
+
+
+class SmtpSSL:
+    def __init__(self, host, port, user, password):
+        self.host = host
+        self.port = port
+        self.user = user
+        self.password = password
+
+    def send_emsg(self, data):
+        emsg = EmailMessage()
+        emsg["Subject"] = data["subject"]
+        emsg["From"] = data.get("From", self.user)
+        emsg["To"] = data["to"]
+
+        if "cc" in data:
+            emsg["Cc"] = data["cc"]
+
+        if "bcc" in data:
+            emsg["Bcc"] = data["bcc"]
+
+        # Check if HTML content is provided
+        if "html_content" in data:
+            emsg.add_alternative(data["html_content"], subtype="html")
+        else:
+            emsg.set_content(data["content"])
+
+        # Add attachments if provided
+        if "attachments" in data:
+            for file_path in data["attachments"]:
+                ctype, encoding = mimetypes.guess_type(file_path)
+                if ctype is None or encoding is not None:
+                    ctype = "application/octet-stream"
+                maintype, subtype = ctype.split("/", 1)
+
+                with open(file_path, "rb") as f:
+                    emsg.add_attachment(
+                        f.read(),
+                        maintype=maintype,
+                        subtype=subtype,
+                        filename=file_path.split("\\")[-1],
+                    )
+
+        with smtplib.SMTP_SSL(self.host, self.port) as smtp:
+            # smtp.set_debuglevel(1)
+            smtp.login(self.user, self.password)
+            senderrs = smtp.send_message(emsg)
+        return senderrs

python_plugins-0.2.3/src/python_plugins/utils/update-icons.py

@@ -0,0 +1,49 @@
+"""Generate example page with overview of all icons."""
+
+from lxml import etree
+
+
+def parse(filename):
+    """Parse SVG file containing icons."""
+    symbols = set()
+    data = etree.parse(filename)
+    svg = data.getroot()
+    for symbol in svg:
+        symbols.add(symbol.attrib["id"])
+    return sorted(symbols)
+
+
+def generate(version):
+    """Write the HTML template file."""
+    head = f"""{{% extends "base.html" %}}
+{{% from 'macro/icon.html' import render_icon %}}
+<!-- DO NOT EDIT! Use update-icons.py for updating this file. -->
+{{% block content %}}
+<h2>Icons</h2>
+<p>These are all the icons which are currently supported by Bootstrap-Flask.</p>
+<ul class="row row-cols-3 row-cols-sm-4 row-cols-lg-6 row-cols-xl-8 list-unstyled list">
+"""
+    names = parse(f"icons/bootstrap-icons.svg")
+    with open(f"bootstrap{version}/templates/icons.html", "w") as file:
+        file.write(head)
+        number = 0
+        for name in sorted(names):
+            item = f"""<li class="col mb-4">
+<a class="d-block text-dark text-body-emphasis text-decoration-none" href="https://icons.getbootstrap.com/icons/{name}/">
+<div class="px-3 py-4 mb-2 bg-light text-center rounded">
+{{{{ render_icon('{name}', 32) }}}}
+</div>
+</a>
+<div class="name text-body-secondary text-decoration-none text-center pt-1">{name}</div>
+</li>
+"""
+            file.write(item)
+            number += 1
+        file.write("</ul>\n")
+        file.write(f"<p>This is a total of {number} icons.</p>\n")
+        file.write("{% endblock %}\n")
+        print(f"For Bootstrap{version}, a total of {number} icons are supported.")
+
+
+for value in (4, 5):
+    generate(value)

python_plugins-0.2.3/tests/test_email.py

@@ -0,0 +1,83 @@
+import os.path as op
+import pytest
+from python_plugins.email import SmtpSSL
+
+@pytest.mark.skip(reason="test ok")
+def test_send_content():
+    host = "smtp.qiye.aliyun.com"
+    port = "465"
+    user = "test@ojso.com"
+    password = "gTk94GEeNvujr4zm"
+
+    to = "test@ojso.com"
+    data = {
+        "to": to,
+        "subject": "test send content",
+        "content": "This is a plain text email.",
+    }
+
+    s = SmtpSSL(host, port, user, password)
+    r = s.send_emsg(data)
+
+    assert not r
+
+@pytest.mark.skip(reason="test ok")
+def test_send_html():
+    host = "smtp.qiye.aliyun.com"
+    port = "465"
+    user = "test@ojso.com"
+    password = "gTk94GEeNvujr4zm"
+
+    to = "test@ojso.com"
+    html_content = """
+<html>
+  <body>
+    <h1>This is a HTML email.</h1>
+    <p>You can use <strong>HTML</strong> format!</p>
+    <p><a href="https://www.example.com">Click here to access the sample website</a></p>
+  </body>
+</html>
+"""
+
+    data = {
+        "to": to,
+        "subject": "test send html",
+        "html_content": html_content,
+    }
+
+    s = SmtpSSL(host, port, user, password)
+    r = s.send_emsg(data)
+
+    assert not r
+
+@pytest.mark.skip(reason="test ok")
+def test_send_attach():
+    host = "smtp.qiye.aliyun.com"
+    port = "465"
+    user = "test@ojso.com"
+    password = "gTk94GEeNvujr4zm"
+
+    to = "test@ojso.com"
+    html_content = """
+<html>
+  <body>
+    <h1>This a HTML email with attach</h1>
+    <p>have a look at attach</p>
+  </body>
+</html>
+"""
+    parent_dir = op.realpath(op.dirname(__file__))
+    attach_path_1 = op.join(parent_dir, "tmp","a.txt")
+    attach_path_2 = op.join(parent_dir, "tmp","a.png")
+    
+    data = {
+        "to": to,
+        "subject": "test send attach",
+        "html_content": html_content,
+        "attachments": [attach_path_1, attach_path_2],
+    }
+
+    s = SmtpSSL(host, port, user, password)
+    r = s.send_emsg(data)
+
+    assert not r

python_plugins-0.2.3/tests/test_zipmix.py

@@ -0,0 +1,142 @@
+import pytest
+import os
+import os.path as op
+import shutil
+from python_plugins.crypto.zipmix import ZipMix
+
+def test_z7_available():
+    zm = ZipMix()
+    assert zm.z7_available is True
+
+def test_int_bytes_roundtrip():
+    zm = ZipMix()
+    for v in (0, 1, 255, 256, 65535, 2**24 - 1):
+        b = zm.int_to_bytes(v)
+        assert isinstance(b, bytes)
+        assert zm.int_from_bytes(b) == v
+
+
+def test_create_and_extract_mix_flag():
+    zm = ZipMix()
+    pos = 0x01020304
+    nlen = 7
+    flag = zm.create_mix_flag(pos, nlen)
+    assert isinstance(flag, bytes)
+    assert len(flag) == 8
+    extracted = zm.extract_from_mix_flag(flag)
+    assert extracted == (pos, nlen)
+    with pytest.raises(ValueError):
+        zm.extract_from_mix_flag(b"0" * 8)
+
+
+def test_insert_string_to_binary():
+    zm = ZipMix()
+    data = os.urandom(500)
+    insert = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    new_1 = zm.insert_string_to_binary(data, insert)
+    assert len(new_1) - len(data) == len(insert) * 5 + 4
+    old_insert, old = zm.extract_string_from_binary(new_1)
+    assert old_insert == insert
+    assert data == old
+    new_2 = zm.insert_string_to_binary(data, insert)
+    assert len(new_2) == len(new_1)
+    assert new_2 != new_1
+    old_insert, old = zm.extract_string_from_binary(new_2)
+    assert old_insert == insert
+    assert data == old
+
+
+def test_zip7():
+    parent_dir = op.realpath(op.dirname(__file__))
+    f_test = op.join(parent_dir, "tmp","test.txt")
+    f_test_7z = op.join(parent_dir, "tmp","test.txt.7z")
+    if os.path.exists(f_test_7z):
+        os.unlink(f_test_7z)
+    dir_test_out = op.join(parent_dir, "tmp","out")
+    f_test_out = op.join(parent_dir, "tmp","out","test.txt")
+    
+    zm = ZipMix()
+    r_zip=zm.zip7(f_test)
+    assert len(r_zip)==2
+    assert r_zip[0] == "ok"
+    f_zip = r_zip[1]
+    # r_list = zm.unzip7_list_archive(f_zip)
+    # assert r_list[0] == "ok"
+    r_unzip = zm.unzip7(f_zip,dir_test_out)
+    assert r_unzip[0] == "ok"
+    r_cmp = zm.filecmp(f_test,f_test_out)
+    assert r_cmp is True
+    if os.path.exists(f_zip):
+        os.unlink(f_zip)
+    if os.path.exists(f_test_out):
+        os.unlink(f_test_out)
+
+def test_zip7_dir():
+    parent_dir = op.realpath(op.dirname(__file__))
+    f_test = op.join(parent_dir, "tmp","testdir")
+    f_test_7z = op.join(parent_dir, "tmp","testdir.7z")
+    if os.path.exists(f_test_7z):
+        os.unlink(f_test_7z)
+    dir_test_out = op.join(parent_dir, "tmp","out","testdir")
+    zm = ZipMix()
+    r_zip=zm.zip7(f_test)
+    assert len(r_zip)==2
+    assert r_zip[0] == "ok"
+    f_zip = r_zip[1]
+    # r_list = zm.unzip7_list_archive(f_zip)
+    # assert r_list[0] == "ok"
+    r_unzip = zm.unzip7(f_zip,dir_test_out)
+    assert r_unzip[0] == "ok"
+    # r_cmp = zm.filecmp(f_test,f_test_out)
+    # assert r_cmp is True
+    if os.path.exists(f_zip):
+        os.unlink(f_zip)
+    if os.path.exists(dir_test_out):
+        shutil.rmtree(dir_test_out)
+
+def test_zip7_force_password():
+    parent_dir = op.realpath(op.dirname(__file__))
+    f_test = op.join(parent_dir, "tmp","test.txt")
+    f_test_7z = op.join(parent_dir, "tmp","test.txt.7z")
+    if os.path.exists(f_test_7z):
+        os.unlink(f_test_7z)
+    dir_test_out = op.join(parent_dir, "tmp","out")
+    f_test_out = op.join(parent_dir, "tmp","out","test.txt")
+    zm = ZipMix()
+    r_zip=zm.zip7(f_test,force_pwd=True)
+    assert len(r_zip)==3
+    assert r_zip[0] == "ok"
+    f_zip = r_zip[1]
+    pwd = r_zip[2]
+    # r_list = zm.unzip7_list_archive(f_zip)
+    # assert r_list[0] == "ok"
+    r_unzip = zm.unzip7(f_zip,dir_test_out,pwd=pwd)
+    assert r_unzip[0] == "ok"
+    r_cmp = zm.filecmp(f_test,f_test_out)
+    assert r_cmp is True
+    if os.path.exists(f_zip):
+        os.unlink(f_zip)
+    if os.path.exists(f_test_out):
+        os.unlink(f_test_out)
+
+def test_zip7_mix():
+    parent_dir = op.realpath(op.dirname(__file__))
+    f_test = op.join(parent_dir, "tmp","test.txt")
+    f_test_7z = op.join(parent_dir, "tmp","test.txt.7z")
+    if os.path.exists(f_test_7z):
+        os.unlink(f_test_7z)
+    dir_test_out = op.join(parent_dir, "tmp","out")
+    f_test_out = op.join(parent_dir, "tmp","out","test.txt")
+    zm = ZipMix()
+    r_zip=zm.zip7mix(f_test)
+    assert len(r_zip)==2
+    assert r_zip[0] == "ok"
+    f_zipmix = r_zip[1]
+    r_unzip = zm.unzip7mix(f_zipmix,dir_test_out)
+    assert r_unzip[0] == "ok"
+    r_cmp = zm.filecmp(f_test,f_test_out)
+    assert r_cmp is True
+    if os.path.exists(f_zipmix):
+        os.unlink(f_zipmix)
+    if os.path.exists(f_test_out):
+        os.unlink(f_test_out)