edi-core 1.1.0__py3-none-any.whl

edi_core/cloud/README.md

@@ -0,0 +1 @@
+https://help.aliyun.com/zh/oss/developer-reference/get-started-with-oss-sdk-for-python-v2?spm=a2c4g.11186623.help-menu-31815.d_5_2_2_0_0.31152f8dIqy5FD

edi_core/cloud/oss.py

@@ -0,0 +1,64 @@
+from abc import ABC
+
+import alibabacloud_oss_v2 as oss
+from alibabacloud_oss_v2 import GetObjectMetaRequest, GetObjectMetaResult, GetObjectRequest
+from loguru import logger as log
+
+
+class OssClient(ABC):
+    def get_object_metadata(self, key: str):
+        pass
+
+    def get_object(self, key: str, target_path: str):
+        pass
+
+    def put_object(self, source_path: str, key: str):
+        pass
+
+    def delete_object(self, key: str):
+        pass
+
+
+class AliCloudOssClient(OssClient):
+    _config: oss.Config
+    _client: oss.Client
+    _bucket: str
+
+    def __init__(self, region: str, access_key: str, secret_key: str, endpoint: str, bucket: str):
+        config = oss.config.load_default()
+        config.region = region
+        config.credentials_provider = oss.credentials.StaticCredentialsProvider(access_key_id=access_key,
+                                                                                access_key_secret=secret_key)
+        config.endpoint = endpoint
+        self._config = config
+        self.print_config()
+        self._client = oss.Client(self._config)
+        self._bucket = bucket
+
+    def get_config(self) -> oss.Config:
+        return self._config
+
+    def get_object_metadata(self, key: str) -> GetObjectMetaResult:
+        request = GetObjectMetaRequest(bucket=self._bucket, key=key)
+        return self._client.get_object_meta(request)
+
+    def get_object(self, key: str, target_path: str):
+        log.debug(f"downloading {key} to {target_path}")
+        request = GetObjectRequest(bucket=self._bucket, key=key)
+        result = self._client.get_object(request)
+        with result.body as body_stream:
+            data = body_stream.read()
+            with open(target_path, 'wb') as f:
+                f.write(data)
+        log.debug(f"finished downloading {key} to {target_path}")
+
+    def put_object(self, source_path: str, key: str):
+        pass
+
+    def delete_object(self, key: str):
+        pass
+
+    def print_config(self):
+        config_attrs = vars(self._config)
+        config_str = "\n".join(f"{key}={value}" for key, value in config_attrs.items())
+        log.debug(f"OSS Config: {config_str}")

edi_core/db/simple_kv.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+from tinydb import TinyDB, Query
+
+from edi_core.utils.file import get_path_from_app_dir, ensure_parent_dir_exists
+
+
+class CreateStrategy(Enum):
+    RECREATE = 1
+    REUSE_IF_PRESENT = 2
+
+
+class SimpleKV(ABC):
+    @abstractmethod
+    def get_str(self, key: str):
+        raise NotImplementedError("get_str is not implemented")
+
+    @abstractmethod
+    def set_str(self, key: str, value: str):
+        raise NotImplementedError("set_str is not implemented")
+
+    @abstractmethod
+    def print_all(self):
+        raise NotImplementedError("print_all is not implemented")
+
+
+class TinyDbSimpleKV(SimpleKV):
+    db_path: str
+    db: TinyDB
+
+    def __init__(self, db_name: str, create_strategy: CreateStrategy = CreateStrategy.RECREATE):
+        self.db_path = get_path_from_app_dir(db_name)
+        ensure_parent_dir_exists(self.db_path)
+        self.db = TinyDB(f'{self.db_path}.json')
+        if create_strategy == CreateStrategy.RECREATE:
+            self.db.truncate()
+
+    def get_str(self, key: str):
+        results = self.db.search(Query().key == key)
+        if len(results) == 0:
+            raise KeyError("Key not found")
+        return results[0]["value"]
+
+    def set_str(self, key: str, value: str):
+        self.db.remove(Query().key == key)
+        self.db.insert({"key": key, "value": value})
+
+    def print_all(self):
+        return self.db.all()

edi_core/db/tinydb.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from tinydb import TinyDB
+from tinydb.table import Document
+
+
+class Tiny:
+    _db = None
+
+    def __init__(self, db_file):
+        self._db = TinyDB(db_file)
+
+    def insert(self, data: dict) -> int:
+        return self._db.insert(data)
+
+    def all(self) -> List[Document]:
+        return self._db.all()
+
+    def search(self, query) -> List[Document]:
+        return self._db.search(query)
+
+    def close(self):
+        self._db.close()

edi_core/scm/git.py

@@ -0,0 +1,6 @@
+import git
+
+
+def clone_and_checkout(path, url, branch):
+    repo = git.Repo.clone_from(url=url, to_path=path)
+    repo.create_head(branch).checkout()

edi_core/utils/assertions.py

@@ -0,0 +1,22 @@
+import os.path
+from typing import Callable
+
+
+def assert_file_exists(
+    path: str,
+    exception_supplier: Callable[[], Exception] | None = None,
+):
+    if not os.path.isfile(path):
+        if exception_supplier is None:
+            raise ValueError(f"File does not exist: {path}")
+        raise exception_supplier()
+
+
+def assert_dir_exists(
+    path: str,
+    exception_supplier: Callable[[], Exception] | None = None,
+):
+    if not os.path.isdir(path):
+        if exception_supplier is None:
+            raise ValueError(f"Directory does not exist: {path}")
+        raise exception_supplier()

edi_core/utils/audio.py

@@ -0,0 +1,37 @@
+import os
+import subprocess
+
+from edi_core.utils.assertions import assert_file_exists
+from edi_core.utils.file import dir_exists, get_file_name_without_extension
+
+
+def extract_audio(file_path: str, output_path: str):
+    assert_file_exists(file_path)
+    result = subprocess.run(
+        ['ffmpeg', '-i', file_path, '-q:a', '0', '-map', 'a', output_path],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to extract audio: {result.stderr.decode()}")
+
+
+def split_audio(source_file: str, dest_dir: str, seconds: int):
+    assert_file_exists(source_file)
+    if not dir_exists(dest_dir):
+        os.makedirs(dest_dir, exist_ok=True)
+
+    base_name = get_file_name_without_extension(source_file)
+    segment_pattern = os.path.join(dest_dir, f"{base_name}_%03d.mp3")
+
+    result = subprocess.run(
+        ['ffmpeg', '-i', source_file, '-f', 'segment', '-segment_time', str(seconds), '-c', 'copy', segment_pattern],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to split audio: {result.stderr.decode()}")
+
+    return sorted([os.path.join(dest_dir, f) for f in os.listdir(dest_dir) if f.startswith(base_name)],
+                  key=lambda x: x.lower())

edi_core/utils/cli.py

@@ -0,0 +1,51 @@
+from typing import TypeVar, Callable
+
+T = TypeVar('T')
+
+
+def select_option(
+    options: list[T],
+    prompt: str,
+    display_names: list[str] | None = None,
+    to_display_name: Callable[[T], str] | None = None,
+) -> T:
+    """
+    Interactive CLI option selector.
+
+    Args:
+        options: List of options to choose from
+        prompt: Message to display to the user
+        display_names: Optional list of display names for options
+        to_display_name: Optional function to convert option to display name
+            (used if display_names is not provided)
+
+    Returns:
+        The selected option
+
+    Raises:
+        ValueError: If options is empty or display_names length doesn't match
+    """
+    if not options:
+        raise ValueError("Options list cannot be empty")
+
+    if display_names is not None:
+        if len(display_names) != len(options):
+            raise ValueError("display_names must have same length as options")
+        names = display_names
+    elif to_display_name is not None:
+        names = [to_display_name(opt) for opt in options]
+    else:
+        names = [str(opt) for opt in options]
+
+    print(prompt)
+    for i, name in enumerate(names, start=1):
+        print(f"{i}. {name}")
+
+    while True:
+        try:
+            choice = int(input())
+            if 1 <= choice <= len(options):
+                return options[choice - 1]
+            print(f"Please enter a number between 1 and {len(options)}")
+        except ValueError:
+            print("Please enter a valid number")

edi_core/utils/datetime.py

@@ -0,0 +1,6 @@
+import pendulum
+from pendulum import DateTime
+
+
+def now(tz='Asia/Shanghai') -> DateTime:
+    return pendulum.now(tz)

edi_core/utils/encoding.py

@@ -0,0 +1,25 @@
+import base64
+
+
+def encode_base64_str(data: str, encoding: str = 'utf-8'):
+    data_bytes = data.encode(encoding)
+    base64_bytes = base64.b64encode(data_bytes)
+    return base64_bytes.decode(encoding)
+
+
+def decode_base64_str(data: str, encoding: str = 'utf-8'):
+    data_bytes = data.encode(encoding)
+    base64_bytes = base64.b64decode(data_bytes)
+    return base64_bytes.decode(encoding)
+
+
+def encode_base64_bytes(data: bytes):
+    return base64.b64encode(data)
+
+
+def decode_base64_bytes(data: bytes):
+    return base64.b64decode(data)
+
+
+def to_bytes(data: str, encoding: str = 'utf-8'):
+    return data.encode(encoding)

edi_core/utils/env.py

@@ -0,0 +1,41 @@
+import os
+import platform
+
+from dotenv import load_dotenv
+
+dotenv_loaded = False
+
+
+def load_env():
+    global dotenv_loaded
+    if not dotenv_loaded:
+        load_dotenv()
+        dotenv_loaded = True
+
+
+def get_env(key: str, default: str = None):
+    load_env()
+    value = os.environ.get(key)
+    if value:
+        return value
+
+    if default is None:
+        raise ValueError(f'Env {key} not found')
+    else:
+        return default
+
+
+def get_platform():
+    return platform.platform()
+
+
+def get_system():
+    return platform.system()
+
+
+def is_windows():
+    return get_system() == 'Windows'
+
+
+def get_app_name():
+    return get_env('APP_NAME')

edi_core/utils/file.py

@@ -0,0 +1,98 @@
+import os.path
+import shutil
+from io import TextIOWrapper
+
+from edi_core.utils.assertions import assert_file_exists
+from edi_core.utils.env import get_env
+
+
+def dir_exists(path: str) -> bool:
+    return os.path.isdir(path)
+
+
+def file_exists(path: str) -> bool:
+    return os.path.isfile(path)
+
+
+def path_exists(path: str) -> bool:
+    return os.path.exists(path)
+
+
+def move(src, dest):
+    shutil.move(src, dest)
+
+
+def delete_file(path: str):
+    if file_exists(path):
+        os.remove(path)
+
+
+def get_file_name_without_extension(path: str) -> str:
+    base_name = os.path.basename(path)
+    name_without_extension, _ = os.path.splitext(base_name)
+    return name_without_extension
+
+
+def get_file_name_with_extension(path: str) -> str:
+    return os.path.basename(path)
+
+
+def get_output_dir():
+    return os.path.expanduser(get_env("OUTPUT_DIR"))
+
+
+def get_input_dir():
+    return os.path.expanduser(get_env("INPUT_DIR"))
+
+
+def to_output_path(relative_path: str):
+    return os.path.join(get_output_dir(), relative_path)
+
+
+def to_input_path(relative_path: str):
+    return os.path.join(get_input_dir(), relative_path)
+
+
+def ensure_parent_dir_exists(path: str):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+
+def save_str_to_output_dir(relative_path: str, content: str) -> str:
+    output_path = to_output_path(relative_path)
+    ensure_parent_dir_exists(output_path)
+    with open(output_path, 'w', encoding='utf-8') as file:
+        file.write(content)
+    return output_path
+
+
+def save_bytes_to_output_dir(relative_path: str, content: bytes) -> str:
+    output_path = to_output_path(relative_path)
+    ensure_parent_dir_exists(output_path)
+    with open(output_path, 'wb') as file:
+        file.write(content)
+    return output_path
+
+
+def open_file_in_output_for_write(relative_path: str) -> TextIOWrapper:
+    output_path = to_output_path(relative_path)
+    ensure_parent_dir_exists(output_path)
+    return open(output_path, 'w', encoding='utf-8')
+
+
+def open_file_in_input_for_read(relative_path: str) -> TextIOWrapper:
+    input_path = to_input_path(relative_path)
+    return open(input_path, 'r', encoding='utf-8')
+
+
+def read_file(path: str) -> str:
+    assert_file_exists(path)
+    with open(path, 'r', encoding='utf-8') as file:
+        return file.read()
+
+
+def get_app_dir():
+    return os.path.expanduser(get_env("APP_DIR"))
+
+
+def get_path_from_app_dir(relative_path: str) -> str:
+    return os.path.join(get_app_dir(), relative_path)

edi_core/utils/filetype.py

@@ -0,0 +1,5 @@
+import filetype
+
+
+def guess_mime(file):
+    return filetype.guess_mime(file)

edi_core/utils/hash.py

@@ -0,0 +1,9 @@
+import hashlib
+
+algorithms_available = hashlib.algorithms_available
+
+
+def hash_str(data: str, algo='md5') -> str:
+    h = hashlib.new(algo)
+    h.update(data.encode('utf-8'))
+    return h.hexdigest()

edi_core/win/control.py

@@ -0,0 +1,5 @@
+import pyautogui
+
+
+def write(text: str, interval: float = 0.1):
+    pyautogui.write(text, interval)

edi_core/win/reg.py

@@ -0,0 +1,24 @@
+import winreg
+
+SUB_KEY_KEYBOARD_LAYOUT = "SYSTEM\CurrentControlSet\Control\Keyboard Layout"
+
+type_dict = {
+    winreg.REG_BINARY: "Binary",
+    winreg.REG_SZ: "String",
+    winreg.REG_EXPAND_SZ: "Expandable String",
+    winreg.REG_DWORD: "DWORD (32-bit number)",
+    winreg.REG_MULTI_SZ: "Multi-String",
+    winreg.REG_QWORD: "QWORD (64-bit number)",
+}
+
+
+def read_key_for_current_user(sub_key: str, name: str):
+    hkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key, 0, winreg.KEY_READ)
+    return winreg.QueryValueEx(hkey, name)
+
+
+def get_keyboard_scancode_map():
+    hkey = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, SUB_KEY_KEYBOARD_LAYOUT, 0, winreg.KEY_READ)
+    value, type_id = winreg.QueryValueEx(hkey, "Scancode Map")
+    print(type_id)
+    print(value[0])

edi_core-1.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: edi-core
+Version: 1.1.0
+Summary: 
+License: MIT
+Author: LtttAZ
+Author-email: louis_zhang_1303@126.com
+Requires-Python: ==3.13.2
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: alibabacloud-oss-v2 (>=1.2.1,<2.0.0)
+Requires-Dist: filetype (>=1.2.0,<2.0.0)
+Requires-Dist: gitpython (>=3.1.45,<4.0.0)
+Requires-Dist: loguru (>=0.7.3,<0.8.0)
+Requires-Dist: matplotlib (>=3.10.7,<4.0.0)
+Requires-Dist: packaging (>=25.0,<26.0)
+Requires-Dist: pendulum (>=3.1.0,<4.0.0)
+Requires-Dist: poetry-core (>=2.2.1,<3.0.0)
+Requires-Dist: pyautogui (>=0.9.54,<0.10.0)
+Requires-Dist: pydantic (>=2.12.4,<3.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: tinydb (>=4.8.2,<5.0.0)
+Description-Content-Type: text/markdown
+
+# EDI
+
+[PYPI](https://pypi.org/project/edi-core/)

edi_core-1.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+edi_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/cloud/README.md,sha256=eORYs2CT7hkm2i2A7xmREaW4I_Scl1uTbYNwu8TzhhI,151
+edi_core/cloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/cloud/oss.py,sha256=8w5CB1INo1e69VJSjPhbvnqKOUig3JjF3fDMcags1uE,2151
+edi_core/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/db/simple_kv.py,sha256=8PzWUzwuOOWUXhVr9CzsNf1ljeqaLJvzgw5eLlfaLcg,1420
+edi_core/db/tinydb.py,sha256=DB8trZcsxsLPSwlQjJemlOs68F4AcEMJJmyK0x7BXg0,463
+edi_core/scm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/scm/git.py,sha256=-TVM0_IDd34zAuJPZweksTItzqhUV75DtG4YXe9qQvM,150
+edi_core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/utils/assertions.py,sha256=HFgfxOkNUp0RkI2NpAthy7wnlfBEJSYL3zps6JNrG7Y,596
+edi_core/utils/audio.py,sha256=gBLIntKW7ScLiN93jl_SJtM1LHMYtTUftxc-EGxVGO8,1325
+edi_core/utils/cli.py,sha256=40_YXu8NCcC4_7Z650Clb49nk-xgG9zd5suvWO459XE,1524
+edi_core/utils/datetime.py,sha256=sctJzZw_Uruq-qp6IW_JuqZvcJq_fXDbTMpfEwkAPlg,117
+edi_core/utils/encoding.py,sha256=6QgiPsuKPE8rhTkNqC7KqEzV_41YilykMW2LqbkDLf0,625
+edi_core/utils/env.py,sha256=r4ffjexjq8tUh-8xlailykoKO7OiM23rx6DDuYc_3l0,648
+edi_core/utils/file.py,sha256=ohlwL2bMTyhwA239vv4VgVH6sud-CK5rIKGJWrG4JKY,2454
+edi_core/utils/filetype.py,sha256=yfGavZWzMkbmRUeYPFySZ7xVd1olbeCBc7oQVOMvtCE,77
+edi_core/utils/hash.py,sha256=9YRLLDbPdTlZok6zGKfCLmDL9wXUpYVyHcTgz1Gt0Yc,200
+edi_core/win/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+edi_core/win/control.py,sha256=W8JROSAAc900qUWNlCIQV9BikqeAtEycOXxA_7Eimqc,100
+edi_core/win/reg.py,sha256=-l5aCGvyHtRY9pclxrov9-FtbkCroZInX9RFh6a0rpM,770
+edi_core-1.1.0.dist-info/METADATA,sha256=sgZfP515CvmEJM8737bTvvdBdPPRsQnanTx7BpTeF7Q,902
+edi_core-1.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+edi_core-1.1.0.dist-info/RECORD,,

edi_core-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any