python-plugins 0.1.2__tar.gz → 0.1.3__tar.gz

{python_plugins-0.1.2 → python_plugins-0.1.3}/CHANGES.rst

@@ -1,3 +1,10 @@
+v0.1.3
+------
+
+Released 2024-09-19
+
+- support random_str,jwt,hash_file,fernet
+
 v0.1.2
 ------
 

{python_plugins-0.1.2 → python_plugins-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-plugins
-Version: 0.1.2
+Version: 0.1.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
@@ -40,6 +40,8 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
 Provides-Extra: cryptography
 Requires-Dist: cryptography; extra == 'cryptography'
+Provides-Extra: jwt
+Requires-Dist: pyjwt; extra == 'jwt'
 Provides-Extra: pillow
 Requires-Dist: pillow; extra == 'pillow'
 Provides-Extra: qrcode

{python_plugins-0.1.2 → python_plugins-0.1.3}/pyproject.toml

@@ -31,6 +31,7 @@ sqlalchemy = ["SQLAlchemy"]
 cryptography = ["cryptography"]
 pillow = ["pillow"]
 qrcode = ["qrcode"]
+jwt = ["PyJWT"]
 
 [project.urls]
 Documentation = "https://python-plugins.readthedocs.io"

python_plugins-0.1.3/requirements/test.in

@@ -0,0 +1,5 @@
+pytest
+Faker
+cryptography
+SQLAlchemy
+PyJWT

python_plugins-0.1.3/src/python_plugins/__about__.py

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

python_plugins-0.1.3/src/python_plugins/convert/__init__.py

@@ -0,0 +1,2 @@
+from .datetime_str import datetime2str, str2datetime
+from .xml import xml2dict

python_plugins-0.1.3/src/python_plugins/convert/datetime_str.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+
+date_fmt = "%Y-%m-%d"
+datetime_fmt = "%Y-%m-%d %H:%M:%S"
+
+# datetime.isoformat()
+# datetime.fromisoformat(str)
+
+
+def datetime2str(dt):
+    return datetime.strftime(dt, datetime_fmt)
+
+
+def str2datetime(s):
+    return datetime.strptime(s, datetime_fmt)

python_plugins-0.1.3/src/python_plugins/convert/xml.py

@@ -0,0 +1,7 @@
+import xml.etree.cElementTree as ET
+
+
+def xml2dict(xmlstr):
+    xml_tree = ET.fromstring(xmlstr)
+    xmldict = {k.tag: k.text for k in xml_tree}
+    return xmldict

python_plugins-0.1.3/src/python_plugins/crypto/__init__.py

@@ -0,0 +1 @@
+from .fernet import generate_fernet_key,fernet_encrypt,fernet_decrypt

python_plugins-0.1.3/src/python_plugins/crypto/fernet.py

@@ -0,0 +1,41 @@
+import base64
+from cryptography.hazmat.primitives import padding
+from cryptography.fernet import Fernet
+
+# Fernet文档 : https://github.com/fernet/spec/blob/master/Spec.md
+
+
+def generate_fernet_key(key) -> bytes:
+    """see cryptography.fernet.Fernet.generate_key()
+
+    :param key: _description_
+    :raises ValueError: _description_
+    :return: _description_
+    """
+    if isinstance(key, str):
+        key = key.encode("utf-8")
+    if not isinstance(key, bytes):
+        raise ValueError
+    if len(key) < 32:
+        padder = padding.PKCS7(32 * 8).padder()
+        key = padder.update(key) + padder.finalize()
+    fernet_key = key[0:16] + key[16:32]
+    return base64.urlsafe_b64encode(fernet_key)
+
+
+def fernet_encrypt(key, txt) -> str:
+    if isinstance(txt, str):
+        txt = txt.encode("utf-8")
+    fernet_key = generate_fernet_key(key)
+    f = Fernet(fernet_key)
+    token = f.encrypt(txt)
+    return token.decode("utf-8")
+
+
+def fernet_decrypt(key, token) -> str:
+    if isinstance(token, str):
+        token = token.encode("utf-8")
+    fernet_key = generate_fernet_key(key)
+    f = Fernet(fernet_key)
+    decrypt_data = f.decrypt(token)
+    return decrypt_data.decode("utf-8")

python_plugins-0.1.3/src/python_plugins/crypto/str_to_list.py

@@ -0,0 +1,91 @@
+import base64
+import os
+import random
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from ..random import rand_letter
+
+
+def bytes_to_url64str(bstr: bytes):
+    s = base64.urlsafe_b64encode(bstr).rstrip(b"=").decode()
+    return s
+
+
+def url64str_to_bytes(s):
+    _, r = divmod(len(s), 4)
+    bstr = base64.urlsafe_b64decode((s + "=" * r).encode())
+    return bstr
+
+
+def get_key(password, safe_salt=None, times=None):
+    if isinstance(password, str):
+        password = password.encode()
+    if safe_salt is None:
+        salt = os.urandom(16)
+        safe_salt = bytes_to_url64str(salt)
+    else:
+        salt = url64str_to_bytes(safe_salt)
+    if times is None:
+        times = random.randint(100, 100000)
+
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=times,
+    )
+    key = base64.urlsafe_b64encode(kdf.derive(password))
+    return (key, safe_salt, times)
+
+
+def str_randsplit_to_list(s, n1=10, n2=30):
+    r = []
+    while s:
+        if len(s) < 40:
+            r.append(s)
+            break
+        k = random.randint(n1, n2)
+        r.append(s[:k])
+        if k < len(s):
+            s = s[k:]
+        else:
+            s = ""
+    return r
+
+
+def encrypt_str_to_list(s: str, password=None, prefix=None):
+    if password is None:
+        password = rand_letter(random.randint(6, 16))
+        out_password = password
+    else:
+        out_password = "-"
+    if prefix is not None:
+        password = str(prefix) + password
+
+    key, safe_salt, times = get_key(password)
+
+    cipher_suite = Fernet(key)
+    encrypted_data = cipher_suite.encrypt(s.encode())
+    safe_data = bytes_to_url64str(encrypted_data)
+
+    list_out = [out_password, safe_salt, str(times)] + str_randsplit_to_list(safe_data)
+
+    return list_out
+
+
+def decrypt_list_to_str(list_in, password=None, prefix=None):
+    _password, safe_salt, _times, *_data = list_in
+    if password is None:
+        password = _password
+    else:
+        password = password
+    if prefix is not None:
+        password = str(prefix) + password
+
+    times = int(_times)
+    s = "".join(_data)
+    key, _, _ = get_key(password, safe_salt, times)
+    cipher_suite = Fernet(key)
+    decrypted_bytes = cipher_suite.decrypt(url64str_to_bytes(s))
+    return decrypted_bytes.decode()

python_plugins-0.1.3/src/python_plugins/dumps/__init__.py

@@ -0,0 +1,2 @@
+from .postgresql_dump import pg_dump
+from .postgresql_dump import remove_ndays_ago

python_plugins-0.1.3/src/python_plugins/dumps/postgresql_dump.py

@@ -0,0 +1,31 @@
+import subprocess
+import sys
+
+
+def pg_dump(dump_dir, username, dbname, tbname):
+    """pg_dump
+
+    :param dir: dump dir
+    :param username: db user
+    :param dbname: db name
+    :param tbname: table name
+    """
+    pgdump_cmd = (
+        f"dump_user={username};dump_db={dbname};dump_tb={tbname};dump_dir={dump_dir};"
+        "pg_dump -U ${dump_user} --no-password -d ${dump_db} -t ${dump_tb} | gzip > ${dump_dir}/${dump_db}.${dump_tb}-`date +'%Y%m%d'`.gz;"
+        "cp ${dump_dir}/${dump_db}.${dump_tb}-`date +'%Y%m%d'`.gz  ${dump_dir}/${dump_db}.${dump_tb}.gz;"
+    )
+    if sys.platform == "linux":
+        r = subprocess.run(pgdump_cmd, shell=True)
+    else:
+        r = f"not pg_dump because sys.platform is {sys.platform}"
+    return r
+
+
+def remove_ndays_ago(dir, days=30):
+    remove_cmd = f"rm -f {dir}/*`date +'%Y%m%d' -d'-{days} days'`.gz"
+    if sys.platform == "linux":
+        r = subprocess.run(remove_cmd, shell=True)
+    else:
+        r = f"not remove files because sys.platform is {sys.platform}"
+    return r

python_plugins-0.1.3/src/python_plugins/hashes/__init__.py

@@ -0,0 +1 @@
+from .hash import hash_file, hash_text

python_plugins-0.1.3/src/python_plugins/hashes/hash.py

@@ -0,0 +1,26 @@
+import hashlib
+import os.path
+
+
+def hash_file(filename, algorithm="sha1"):
+    if os.path.isfile(filename) is False:
+        raise Exception("File not found for hash operation")
+
+    sha_func = getattr(hashlib, algorithm)
+    sha_obj = sha_func()
+
+    with open(filename, "rb") as f:
+        chunk = 0
+        while chunk != b"":
+            chunk = f.read(1024)
+            sha_obj.update(chunk)
+
+    return sha_obj.hexdigest()
+
+
+def hash_text(text, algorithm="sha1"):
+    # hashlib.md5(text).hexdigest()  # simple
+    sha_func = getattr(hashlib, algorithm)
+    sha_obj = sha_func()
+    sha_obj.update(text)
+    return sha_obj.hexdigest()

python_plugins-0.1.3/src/python_plugins/jwt/__init__.py

@@ -0,0 +1 @@
+from .jwt import jwt_encode, jwt_decode

python_plugins-0.1.3/src/python_plugins/jwt/jwt.py

@@ -0,0 +1,37 @@
+import jwt
+import datetime
+
+
+def jwt_encode(payload: dict, key: str, delta: int = None, algorithm="HS256"):
+    """encode payload.
+
+    :param payload: _description_
+    :param key: _description_
+    :param delta: _description_, defaults to None
+    :param algorithm: _description_, defaults to "HS256"
+    :return: An encoded access token
+    """
+    if delta and delta > 0:
+        exp = datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(
+            seconds=delta
+        )
+        payload |= {"exp": exp}
+
+    token = jwt.encode(payload, key, algorithm)
+    return token
+
+
+def jwt_decode(encoded, key: str, algorithm="HS256"):
+    """decode jwt."""
+
+    payload = jwt.decode(encoded, key, algorithm)
+    return payload
+
+
+#     try:
+#         ...
+#     except Exception as e:
+#         # import sys
+#         # print(sys.exc_info())
+#         # return None,str(e)
+#         return None

python_plugins-0.1.3/src/python_plugins/process/__init__.py

@@ -0,0 +1,2 @@
+from .sub_process import run_process
+from .python_venv_process import run_process_in_venv

python_plugins-0.1.3/src/python_plugins/process/python_venv_process.py

@@ -0,0 +1,18 @@
+import subprocess
+import os.path
+import json
+
+
+def run_process_in_venv(dir: str, cmd: str, params):
+    if not (os.path.exists(dir) and os.path.isdir(dir)):
+        return f"dir {dir} not exists"
+
+    cmd = [
+        os.path.join(dir, "venv/bin/python"),
+        os.path.join(dir, cmd),
+        json.dumps(params) if isinstance(params, dict) else str(params),
+    ]
+    # print(cmd)
+    completedProcess = subprocess.run(cmd, capture_output=True)
+    r = str(completedProcess)
+    return r

python_plugins-0.1.3/src/python_plugins/process/sub_process.py

@@ -0,0 +1,12 @@
+import subprocess
+import json
+
+
+def run_process(cmd: str, params=None,shell=False):
+    cmd_args = [
+        cmd,
+        json.dumps(params) if isinstance(params, dict) else str(params),
+    ]
+    completedProcess = subprocess.run(cmd_args, capture_output=True,shell=shell)
+    r = str(completedProcess)
+    return r

python_plugins-0.1.3/src/python_plugins/random/__init__.py

@@ -0,0 +1,4 @@
+from .random_str import rand_digit
+from .random_str import rand_letter
+from .random_str import rand_sentence
+from .random_str import secret_token, secret_token_16

python_plugins-0.1.3/src/python_plugins/random/random_str.py

@@ -0,0 +1,46 @@
+import random
+import string
+import os
+import base64
+import uuid
+import secrets
+
+# random.sample  # unique
+# random.choices # not unique
+
+
+def rand_digit(n):
+    """随机数字"""
+    return "".join(random.choices(string.digits, k=n))
+
+
+def rand_letter(n: int):
+    return "".join(random.choices(string.ascii_letters + string.digits, k=n))
+
+
+def rand_sentence(n):
+    return "".join(
+        random.choices(string.ascii_letters + string.digits + " " * 10, k=n)
+    ).strip()
+
+
+def rand_uuid4():
+    return str(uuid.uuid4())
+
+
+def rand_token():
+    return uuid.uuid4().hex
+
+
+def secret_token():
+    return secrets.token_hex(32)
+
+
+def secret_token_16():
+    return secrets.token_hex(16)
+
+
+def rand_token_2(n):
+    # replace '+/' with '1a'
+    token = base64.b64encode(os.urandom(n), b"1a").decode()[0:n]
+    return token

python_plugins-0.1.3/tests/test_crypto.py

@@ -0,0 +1,82 @@
+import pytest
+import random
+import base64
+from python_plugins.random import rand_letter, rand_sentence
+from python_plugins.random import secret_token, secret_token_16
+from python_plugins.crypto.str_to_list import get_key
+from python_plugins.crypto.str_to_list import encrypt_str_to_list, decrypt_list_to_str
+from python_plugins.crypto import generate_fernet_key, fernet_encrypt, fernet_decrypt
+
+
+class TestFetnet:
+    def test_random_secret_token(self):
+        token_1 = secret_token()
+        # print(token_1)
+        assert len(token_1) == 64
+        token_2 = secret_token_16()
+        # print(token_2)
+        assert len(token_2) == 32
+
+    def test_generate_fernet_key(self, fake):
+        skey = fake.sentence()
+        key = generate_fernet_key(skey)
+        # print(key)
+        decode_key = base64.urlsafe_b64decode(key)
+        # print(decode_key)
+        assert len(decode_key) == 32
+
+    def test_fernet_encrypt_decrypt(self, fake):
+        key = generate_fernet_key(fake.sentence())
+        txt = fake.sentence()
+        # print(key,txt)
+        token = fernet_encrypt(key, txt)
+        # print(token)
+        assert isinstance(token, str)
+        decrypt_txt = fernet_decrypt(key, token)
+        # print(decrypt_txt)
+        assert isinstance(decrypt_txt, str)
+        assert txt == decrypt_txt
+
+
+class TestStr2List:
+    def test_get_key(self):
+        password = rand_letter(random.randint(1, 50))
+        key, safe_salt, times = get_key(password)
+        decode_key = base64.urlsafe_b64decode(key)
+        assert len(decode_key) == 32
+
+    def test_encrypt_decrypt(self):
+        s = rand_sentence(random.randint(10, 100))
+        encrypted_list = encrypt_str_to_list(s)
+        s2 = decrypt_list_to_str(encrypted_list)
+        assert s == s2
+
+    def test_encrypt_decrypt_with_password(self):
+        s = rand_sentence(random.randint(10, 100))
+        password = rand_letter(16)
+        encrypted_list = encrypt_str_to_list(s, password)
+        with pytest.raises(Exception):
+            s1 = decrypt_list_to_str(encrypted_list)
+        s2 = decrypt_list_to_str(encrypted_list, password)
+        assert s == s2
+        s3 = decrypt_list_to_str([None] + encrypted_list[1:], password)
+        assert s == s3
+
+    def test_encrypt_decrypt_with_prefix(self):
+        s = rand_sentence(random.randint(10, 100))
+        prefix = rand_letter(16)
+        encrypted_list = encrypt_str_to_list(s, prefix=prefix)
+        with pytest.raises(Exception):
+            s1 = decrypt_list_to_str(encrypted_list)
+        s2 = decrypt_list_to_str(encrypted_list, prefix=prefix)
+        assert s == s2
+
+    def test_encrypt_decrypt_with_password_prefix(self):
+        s = rand_sentence(random.randint(10, 100))
+        password = rand_letter(16)
+        prefix = rand_letter(16)
+        encrypted_list = encrypt_str_to_list(s, password, prefix)
+        with pytest.raises(Exception):
+            s1 = decrypt_list_to_str(encrypted_list, prefix=prefix)
+        s2 = decrypt_list_to_str(encrypted_list, password, prefix)
+        assert s == s2

python_plugins-0.1.3/tests/test_jwt.py

@@ -0,0 +1,25 @@
+import time
+import datetime
+from python_plugins.jwt import jwt_encode, jwt_decode
+
+
+def test_jwt(fake):
+    payload = {"some": fake.sentence()}
+    key = fake.vin()
+    # print(payload, key)
+    token = jwt_encode(payload, key)
+    # print(token)
+    decoded = jwt_decode(token, key)
+    # print(decoded)
+    assert decoded["some"] == payload["some"]
+    delta = 100
+    token = jwt_encode(payload, key, delta)
+    # print(token)
+    decoded = jwt_decode(token, key)
+    # print(decoded)
+    assert decoded["some"] == payload["some"]
+    # print(decoded["exp"],time.mktime(datetime.datetime.now().timetuple()))
+    assert "exp" in decoded
+    exp_time = time.mktime(datetime.datetime.now().timetuple()) + delta - 10
+    assert decoded["exp"] > exp_time
+    # print(datetime.datetime.fromtimestamp(decoded["exp"]))

python_plugins-0.1.3/tests/test_process.py

@@ -0,0 +1,9 @@
+import pytest
+from python_plugins.process import run_process
+
+@pytest.mark.skip(reason="[test_shell_process] only for debug.")
+def test_run_process():
+    cmd = 'ls '
+    params='-l'
+    r = run_process(cmd,params,True)
+    # print(r)

python_plugins-0.1.3/tests/test_random.py

@@ -0,0 +1,8 @@
+from python_plugins.random.random_str import secret_token, secret_token_16
+
+
+def test_random_secret_token():
+    token_1 = secret_token()
+    assert len(token_1) == 64
+    token_2 = secret_token_16()
+    assert len(token_2) == 32

python_plugins-0.1.3/tests/test_sqlalchemy.py

@@ -0,0 +1,25 @@
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from python_plugins.models.mixins import PrimaryKeyMixin
+from python_plugins.models.mixins import DataMixin
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.schema import CreateTable
+
+from sqlalchemy import create_mock_engine
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Demo(PrimaryKeyMixin, DataMixin, Base):
+    __tablename__ = "demo"
+
+
+def test_info():
+
+    assert Demo.__table__.name == "demo"
+    stmt = CreateTable(Demo.__table__)
+    # print(stmt)
+    assert "id INTEGER" in str(stmt)
+    assert "data JSON" in str(stmt)

python_plugins-0.1.2/requirements/test.in

@@ -1,2 +0,0 @@
-pytest
-Faker

python_plugins-0.1.2/src/python_plugins/__about__.py

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