bcmd 0.0.66__py3-none-any.whl → 0.5.2__py3-none-any.whl

bcmd/common/func.py

@@ -0,0 +1,19 @@
+import importlib.resources
+from contextlib import contextmanager
+from pathlib import Path
+
+from beni import btask
+
+
+def checkFileOrNotExists(file: Path):
+    btask.assertTrue(file.is_file() or not file.exists(), f'必须是文件 {file}')
+
+
+def checkPathOrNotExists(folder: Path):
+    btask.assertTrue(folder.is_dir() or not folder.exists(), f'必须是目录 {folder}')
+
+
+@contextmanager
+def useResources(name: str):
+    with importlib.resources.path('bcmd.resources', name) as target:
+        yield target

bcmd/main.py

@@ -6,5 +6,5 @@ from .tasks import *
 
 
 def run():
-    btask.options.lock = ''
+    btask.options.lock = 0
     asyncio.run(btask.main())

bcmd/resources/project/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+*~$*
+venv/

bcmd/resources/project/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: main.py",
+            "type": "debugpy",
+            "request": "launch",
+            // "console": "internalConsole",
+            "program": "${workspaceFolder}/main.py"
+        }
+    ]
+}

bcmd/resources/project/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "files.exclude": {
+        ".pytest_cache": true,
+        "**/__pycache__": true,
+        ".gitignore": true,
+        ".venv": true,
+        ".venv-lock": true,
+        "venv": true,
+    },
+    "python.defaultInterpreterPath": "${workspaceFolder}/venv/Scripts/python.exe",
+}

bcmd/resources/project/.vscode/tasks.json

@@ -0,0 +1,68 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "git commit",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:commit",
+                "/path:${workspaceFolder}/",
+            ],
+        },
+        {
+            "label": "git commit file",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:commit",
+                "/path:${file}",
+            ],
+        },
+        {
+            "label": "git revert",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:revert",
+                "/path:${workspaceFolder}/",
+            ],
+        },
+        {
+            "label": "git revert file",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:revert",
+                "/path:${file}",
+            ],
+        },
+        {
+            "label": "git sync",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:sync",
+                "/path:${workspaceFolder}/",
+            ],
+        },
+        {
+            "label": "git log",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:log",
+                "/path:${workspaceFolder}/",
+            ],
+        },
+        {
+            "label": "git log file",
+            "problemMatcher": [],
+            "command": "TortoiseGitProc.exe",
+            "args": [
+                "/command:log",
+                "/path:${file}",
+            ],
+        },
+    ],
+}

bcmd/resources/project/main.py

@@ -0,0 +1 @@
+print('OK')

bcmd/tasks/__init__.py

@@ -1,15 +1,15 @@
 # type: ignore
 from . import bin
+from . import code
 from . import crypto
 from . import debian
 from . import download
+from . import image
 from . import json
-from . import jwt
 from . import lib
 from . import math
 from . import mirror
+from . import project
 from . import proxy
-from . import task
-from . import temp
 from . import time
 from . import venv

bcmd/tasks/bin.py

@@ -1,16 +1,15 @@
-import os
 from datetime import datetime
 from pathlib import Path
 from typing import Final
 
 import typer
 from beni import bcolor, bfile, bpath, btask, bzip
-from beni.bfunc import syncCall
+from beni.bfunc import syncCall, textToAry
 from beni.bqiniu import QiniuBucket
 from beni.btype import Null
 from prettytable import PrettyTable
 
-from bcmd.common import password
+from ..common import password
 
 app: Final = btask.newSubApp('bin 工具')
 
@@ -20,24 +19,18 @@ _PREFIX = 'bin/'
 @app.command()
 @syncCall
 async def download(
-    names: str = typer.Argument(None, help="如果有多个使用,分割"),
+    names: list[str] = typer.Argument(None, help="支持多个"),
     file: Path = typer.Option(None, '--file', '-f', help="文件形式指定参数，行为单位"),
-    output: Path = typer.Option(None, '--output', '-o', help="本地保存路径"),
+    output: Path = typer.Option(Path.cwd(), '--output', '-o', help="本地保存路径"),
 ):
     '从七牛云下载执行文件'
     bucket: QiniuBucket = Null
-    if not output:
-        output = Path(os.curdir)
-    output = output.resolve()
-    targetList: list[str] = []
-    if names:
-        targetList.extend(names.split(','))
     if file:
         content = await bfile.readText(Path(file))
-        targetList.extend(content.split('\n'))
-    targetList = [x.strip() for x in targetList]
-    targetList = [x for x in targetList if x]
-    for target in targetList:
+        names.extend(
+            textToAry(content)
+        )
+    for target in names:
         binFile = output / target
         if binFile.exists():
             bcolor.printYellow(f'已存在 {binFile}')
@@ -55,6 +48,7 @@ async def getList():
     bucket = await _getBucket()
     datas = (await bucket.getFileList(_PREFIX, limit=1000))[0]
     datas = [x for x in datas if x.key != _PREFIX and x.key.endswith('.zip')]
+    datas.sort(key=lambda x: x.time, reverse=True)
     table = PrettyTable()
     table.add_column(
         bcolor.yellow('文件名称'),
@@ -97,6 +91,9 @@ async def remove(
     bcolor.printGreen('OK')
 
 
+# ------------------------------------------------------------------------------------
+
+
 async def _getBucket():
     ak, sk = await password.getQiniu()
     return QiniuBucket(

bcmd/tasks/code.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+from typing import Final
+
+import typer
+from beni import bfile, bpath, btask
+from beni.bcolor import printGreen, printMagenta, printYellow
+from beni.bfunc import syncCall
+
+app: Final = btask.newSubApp('code 工具')
+
+
+@app.command()
+@syncCall
+async def tidy_tasks(
+    tasks_path: Path = typer.Argument(Path.cwd(), help="tasks 路径"),
+):
+    '整理 task 项目中的 tasks/__init__.py'
+
+    initFile = tasks_path / '__init__.py'
+    btask.assertTrue(initFile.is_file(), '文件不存在', initFile)
+    files = bpath.listFile(tasks_path)
+    files = [x for x in files if not x.name.startswith('_')]
+    contents = [f'from . import {x.stem}' for x in files]
+    contents.insert(0, '# type: ignore')
+    contents.append('')
+    content = '\n'.join(contents)
+    oldContent = await bfile.readText(initFile)
+    if oldContent != content:
+        await bfile.writeText(
+            initFile,
+            content,
+        )
+        printYellow(initFile)
+        printMagenta(content)
+    printGreen('OK')
+
+
+@app.command()
+@syncCall
+async def tidy_modules(
+    modules_path: Path = typer.Argument(Path.cwd(), help="modules_path 路径"),
+):
+    '整理 fastapi 项目中的 modules/__init__.py'
+
+    importContents: list[str] = []
+    managerContents: list[str] = []
+
+    xxdict: dict[str, set[Path]] = {}
+    for file in sorted(modules_path.glob('**/*Manager.py')):
+        if file.parent == modules_path:
+            subName = '.'
+        elif file.parent.parent == modules_path:
+            subName = f'.{file.parent.stem}'
+        else:
+            continue
+        xxdict.setdefault(subName, set()).add(file)
+    for subName in sorted(xxdict.keys()):
+        files = sorted(xxdict[subName])
+        importContents.append(f'from {subName} import {", ".join([x.stem for x in files])}')
+    managerContents.extend([f'    {x.stem},' for x in sorted([y for x in xxdict.values() for y in x])])
+
+    managerContents = [x for x in managerContents if x]
+    contents = [
+        '\n'.join(importContents),
+        'managers = [\n' + '\n'.join(managerContents) + '\n]',
+    ]
+    content = '\n\n'.join(contents) + '\n'
+    file = modules_path / '__init__.py'
+    printYellow(str(file))
+    printMagenta(content)
+    await bfile.writeText(file, content)
+    printGreen('OK')
+
+
+@app.command()
+@syncCall
+async def gen_init_py(
+    workspace_path: Path = typer.Argument(Path.cwd(), help='workspace 路径'),
+):
+    '递归生成 __init__.py 文件'
+
+    async def makeInitFiles(p: Path):
+        if p.name == '__pycache__':
+            return
+        if p.name.startswith('.'):
+            return
+        if workspace_path != p:
+            initFile = p / '__init__.py'
+            if not initFile.exists():
+                printYellow(initFile)
+                await bfile.writeText(initFile, '')
+        for x in bpath.listDir(p):
+            await makeInitFiles(x)
+
+    await makeInitFiles(workspace_path)
+    printGreen('OK')

bcmd/tasks/crypto.py

@@ -104,6 +104,9 @@ async def decrypt_file(
     bcolor.printGreen('OK')
 
 
+# ------------------------------------------------------------------------------------
+
+
 def _genPassword():
     password = ''
     while not password:

bcmd/tasks/download.py

@@ -2,38 +2,73 @@ import asyncio
 import os
 from pathlib import Path
 from typing import Final
+from urllib.parse import urlparse
+from uuid import uuid4
 
 import pyperclip
 import typer
-from beni import bcolor, bhttp, binput, bpath, btask
-from beni.bfunc import syncCall
+from beni import bcolor, bfile, bhttp, binput, bpath, btask
+from beni.bfunc import syncCall, textToAry
 
-app: Final = btask.newSubApp('下载')
+app: Final = btask.app
 
 
 @app.command()
 @syncCall
-async def urls(
-    path: Path = typer.Option(None, '--path', '-p', help='指定路径，默认当前目录'),
+async def download(
+    url_file: Path = typer.Option(None, '--file', '-f', help='需要下载的url文件路径，默认使用剪贴板内容'),
+    save_path: Path = typer.Option(None, '--path', '-p', help='下载存放目录，默认当前目录'),
+    keep_directory: bool = typer.Option(False, '--keep', '-k', help='保持原始目录结构，默认不保持'),
 ):
-    '下载文件'
-    path = path or Path(os.getcwd())
-    content = pyperclip.paste()
-    urlSet = set([x.strip() for x in content.strip().split('\n') if x.strip()])
+    '下载资源资源文件'
+    save_path = save_path or Path(os.getcwd())
+
+    if url_file:
+        if not url_file.exists():
+            btask.abort('指定文件不存在', url_file)
+        content = await bfile.readText(url_file)
+    else:
+        content = pyperclip.paste()
+    urlSet = set(textToAry(content))
 
     for i, url in enumerate(urlSet):
         print(f'{i + 1}. {url}')
-    print(f'输出目录：{path}')
+    print(f'输出目录：{save_path}')
     await binput.confirm('是否确认？')
 
+    fileSet: set[Path] = set()
+    retryUrlSet: set[str] = set()
+
     async def download(url: str):
-        file = bpath.get(path, '/'.join([x for x in url.replace('://', '/').split('/') if x]))
+        urlPath = urlparse(url).path
+        if keep_directory:
+            file = bpath.get(save_path, '/'.join([x for x in urlPath.split('/') if x]))
+        else:
+            file = save_path / Path(urlPath).name
+        if file in fileSet:
+            file = file.with_stem(f'{file.stem}--{uuid4()}')
+        fileSet.add(file)
         try:
             bcolor.printGreen(url)
             await bhttp.download(url, file)
         except:
+            retryUrlSet.add(url)
             bcolor.printRed(url)
 
     await asyncio.gather(*[download(x) for x in urlSet])
 
-    bcolor.printYellow('Done')
+    for i in range(4):
+        if i > 0:
+            print(f'等待重试第 {i} 次')
+            await asyncio.sleep(3)
+        await asyncio.gather(*[download(x) for x in urlSet])
+        if not retryUrlSet:
+            break
+        urlSet = set(retryUrlSet)
+        retryUrlSet.clear()
+
+    if retryUrlSet:
+        pyperclip.copy('\n'.join(retryUrlSet))
+        bcolor.printYellow('部分下载失败，失败部分已复制到剪贴板')
+    else:
+        bcolor.printGreen('OK')

bcmd/tasks/image.py

@@ -0,0 +1,201 @@
+import asyncio
+import os
+import random
+from enum import StrEnum
+from pathlib import Path
+from typing import Final
+
+import httpx
+import typer
+from beni import bcolor, bfile, bhttp, block, bpath, btask
+from beni.bbyte import BytesReader, BytesWriter
+from beni.bfunc import syncCall
+from beni.btype import Null, XPath
+from PIL import Image
+
+app: Final = btask.newSubApp('图片工具集')
+
+
+class _OutputType(StrEnum):
+    '输出类型'
+    normal = '0'
+    replace_ = '1'
+    crc_replace = '2'
+
+
+@app.command()
+@syncCall
+async def convert(
+    path: Path = typer.Option(None, '--path', '-p', help='指定目录或具体图片文件，默认当前目录'),
+    src_format: str = typer.Option('jpg|jpeg|png', '--src-format', '-s', help='如果path是目录，指定源格式，可以指定多个，默认值：jpg|jpeg|png'),
+    dst_format: str = typer.Option('webp', '--dst-format', '-d', help='目标格式，只能是单个'),
+    rgb: bool = typer.Option(False, '--rgb', help='转换为RGB格式'),
+    quality: int = typer.Option(85, '--quality', '-q', help='图片质量，0-100，默认85'),
+    output_type: _OutputType = typer.Option(_OutputType.normal, '--output-type', help='输出类型，0：普通输出，1：删除源文件，2：输出文件使用CRC32命名并删除源文件'),
+):
+    '图片格式转换'
+    path = path or Path(os.getcwd())
+    fileList: list[Path] = []
+    if path.is_file():
+        fileList.append(path)
+    elif path.is_dir():
+        extNameList = [x for x in src_format.strip().split('|')]
+        fileList = [x for x in bpath.listFile(path, True) if x.suffix[1:].lower() in extNameList]
+    if not fileList:
+        return bcolor.printRed(f'未找到图片文件（{path}）')
+    for file in fileList:
+        with Image.open(file) as img:
+            if rgb:
+                img = img.convert('RGB')
+            with bpath.useTempFile() as tempFile:
+                img.save(tempFile, format=dst_format, quality=quality)
+                outputFile = file.with_suffix(f'.{dst_format}')
+                if output_type == _OutputType.crc_replace:
+                    outputFile = outputFile.with_stem(await bfile.crc(tempFile))
+                bpath.copy(tempFile, outputFile)
+                if output_type in [_OutputType.replace_, _OutputType.crc_replace]:
+                    if outputFile != file:
+                        bpath.remove(file)
+                bcolor.printGreen(f'{file} -> {outputFile}')
+
+
+# ------------------------------------------------------------------------------------
+
+@app.command()
+@syncCall
+async def tiny(
+    path: Path = typer.Option(None, '--path', help='指定目录或具体图片文件，默认当前目录'),
+    compression: int = typer.Option(75, '--compression', help='如果压缩小于指定数值则使用原来的图片，单位：%，默认75'),
+    isKeepOriginal: bool = typer.Option(False, '--keep-original', help='保留原始图片'),
+):
+
+    keyList = [
+        'MB3QmtvZ8HKRkXcDnxhWCNTXzvx6cNF3',
+        '7L7X2CJ35GM1bChSHdT14yZPLx7FlpNk',
+        'q8YLcvrXVW2NYcr5mMyzQhsSHF4j7gny',
+    ]
+    random.shuffle(keyList)
+    await block.setLimit(_TinyFile.runTiny, len(keyList))
+
+    # 整理文件列表
+    fileList = []
+    path = path or Path(os.getcwd())
+    if path.is_file():
+        fileList.append(path)
+    elif path.is_dir():
+        fileList = [x for x in bpath.listFile(path, True) if x.suffix[1:].lower() in ['jpg', 'jpeg', 'png']]
+    else:
+        btask.abort('未找到图片文件', path)
+    fileList.sort()
+
+    # 将文件列表整理成 _TinyFile 对象
+    fileList = [_TinyFile(x) for x in fileList]
+    await asyncio.gather(*[x.updateInfo() for x in fileList])
+
+    # 过滤掉已经处理过的图片
+    for i in range(len(fileList)):
+        file = fileList[i]
+        if file.compression == 0:
+            # 未处理过的图片，进行图片的压缩处理
+            pass
+        elif not file.isTiny and file.compression < compression:
+            # 之前测试的压缩率不符合要求，不过现在符合了，进行图片的压缩处理
+            pass
+        else:
+            # 要忽略掉的文件
+            bcolor.printYellow(f'{file.file}（{file.compression}% / 忽略）')
+            fileList[i] = Null
+    fileList = [x for x in fileList if x]
+
+    # 开始压缩
+    taskList = [
+        x.runTiny(keyList[i % len(keyList)], compression, isKeepOriginal)
+        for i, x in enumerate(fileList)
+    ]
+    await asyncio.gather(*taskList)
+
+
+# ------------------------------------------------------------------------------------
+
+
+class _TinyFile:
+
+    _endian: Final = '>'
+    _sep = BytesWriter(_endian).writeStr('tiny').writeUint(9527).writeUint(709394).toBytes()
+
+    @property
+    def compression(self):
+        return self._compression
+
+    @property
+    def isTiny(self):
+        return self._isTiny
+
+    @property
+    def file(self):
+        return self._file
+
+    def __init__(self, file: XPath):
+        self._file = file
+        self._compression: float = 0.0
+        self._isTiny: bool = False
+
+    async def updateInfo(self):
+        fileBytes = await bfile.readBytes(self._file)
+        self._compression = 0.0
+        self._isTiny = False
+        blockAry = fileBytes.split(self._sep)
+        if len(blockAry) > 1:
+            info = BytesReader(self._endian, blockAry[1])
+            size = info.readUint()
+            if size == len(blockAry[0]):
+                self._compression = round(info.readFloat(), 2)
+                self._isTiny = info.readBool()
+
+    async def _flushInfo(self, compression: float, isTiny: bool):
+        self._compression = compression
+        self._isTiny = isTiny
+        content = await self._getPureContent()
+        info = (
+            BytesWriter(self._endian)
+            .writeUint(len(content))
+            .writeFloat(compression)
+            .writeBool(isTiny)
+            .toBytes()
+        )
+        content += self._sep + info
+        await bfile.writeBytes(self._file, content)
+
+    async def _getPureContent(self):
+        content = await bfile.readBytes(self._file)
+        content = content.split(self._sep)[0]
+        return content
+
+    @block.limit(1)
+    async def runTiny(self, key: str, compression: float, isKeepOriginal: bool):
+        content = await self._getPureContent()
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                'https://api.tinify.com/shrink',
+                auth=('api', key),
+                content=content,
+                timeout=30,
+            )
+            response.raise_for_status()
+            result = response.json()
+            outputCompression = round(result['output']['ratio'] * 100, 2)
+            if outputCompression < compression:
+                # 下载文件
+                url = result['output']['url']
+                with bpath.useTempFile() as tempFile:
+                    await bhttp.download(url, tempFile)
+                    await _TinyFile(tempFile)._flushInfo(outputCompression, True)
+                    outputFile = bpath.get(self._file)
+                    if isKeepOriginal:
+                        outputFile = outputFile.with_stem(f'{outputFile.stem}_tiny')
+                    bpath.move(tempFile, outputFile, True)
+                    bcolor.printGreen(f'{outputFile}（{outputCompression}% / 已压缩）')
+            else:
+                # 不进行压缩
+                await self._flushInfo(outputCompression, False)
+                bcolor.printMagenta(f'{self._file} （{outputCompression}% / 不处理）')