bcmd 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

bcmd/tasks/image.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import random
+import tkinter as tk
+from enum import StrEnum
+from pathlib import Path
+from typing import Final, List, Tuple
+
+import httpx
+import typer
+from beni import bcolor, bfile, bhttp, binput, block, bpath, btask
+from beni.bbyte import BytesReader, BytesWriter
+from beni.bfunc import syncCall
+from beni.btype import Null, XPath
+from PIL import Image, ImageDraw, ImageFont
+
+from bcmd.utils.tkUtil import TkForm, setWidgetEnabled
+from tkinter import messagebox
+
+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='指定目录或具体图片文件，默认当前目录'),
+    optimization: int = typer.Option(25, '--optimization', help='指定优化大小，如果没有达到优化效果就不处理，单位：%，默认25'),
+    isKeepOriginal: bool = typer.Option(False, '--keep-original', help='保留原始图片'),
+):
+
+    keyList = [
+        'MB3QmtvZ8HKRkXcDnxhWCNTXzvx6cNF3',
+        '7L7X2CJ35GM1bChSHdT14yZPLx7FlpNk',
+        'q8YLcvrXVW2NYcr5mMyzQhsSHF4j7gny',
+    ]
+    random.shuffle(keyList)
+
+    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
+
+        def getSizeDisplay(self):
+            size = bpath.get(self._file).stat().st_size / 1024
+            return f'{size:,.2f}KB'
+
+        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 - 100:.2f}% / 压缩 / {self.getSizeDisplay()}）')
+                else:
+                    # 不进行压缩
+                    await self._flushInfo(outputCompression, False)
+                    bcolor.printMagenta(f'{self._file} （{outputCompression - 100:.2f}% / 不处理 / {self.getSizeDisplay()}）')
+
+    btask.assertTrue(0 < optimization < 100, '优化大小必须在0-100之间')
+    compression = 100 - optimization
+    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:
+            # 要忽略掉的文件
+            if file.isTiny:
+                bcolor.printYellow(f'{file.file}（{file.compression - 100:.2f}% / 已压缩 / {file.getSizeDisplay()}）')
+            else:
+                bcolor.printMagenta(f'{file.file}（{file.compression - 100:.2f}% / 不处理 / {file.getSizeDisplay()}）')
+
+            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)
+
+
+@app.command()
+@syncCall
+async def merge(
+    path: Path = typer.Argument(Path.cwd(), help='workspace 路径'),
+    force: bool = typer.Option(False, '--force', '-f', help='强制覆盖'),
+):
+    '合并多张图片'
+
+    def _get_watermark_font(font_size: int) -> ImageFont.FreeTypeFont:
+        font_candidates = [
+            'arial.ttf',                  # Windows
+            'Arial.ttf',                  # macOS（部分系统可能区分大小写）
+            'Helvetica.ttc',              # macOS
+            'DejaVuSans.ttf',             # Linux
+            'FreeSans.ttf',               # 某些Linux发行版
+            'LiberationSans-Regular.ttf'  # RHEL系发行版
+        ]
+        for font_name in font_candidates:
+            try:
+                return ImageFont.truetype(font_name, font_size)
+            except (IOError, OSError):
+                continue
+        raise Exception('No font found!')
+
+    def _add_watermark(image: Image.Image, text: str, position: Tuple[float, float]) -> Image.Image:
+        """添加圆形背景水印"""
+        draw = ImageDraw.Draw(image)
+        font_size = 100
+        font = _get_watermark_font(font_size)
+
+        # 计算文本尺寸并确定圆形参数
+        text_bbox = draw.textbbox(position, text, font=font)
+        text_width = text_bbox[2] - text_bbox[0]
+        text_height = text_bbox[3] - text_bbox[1]
+
+        # 计算圆形参数（直径取文本宽高的最大值 + 边距）
+        diameter = max(text_width, text_height) + 20  # 10像素边距
+        radius = diameter // 2
+
+        # 计算圆形中心坐标（保持与原矩形左上角一致）
+        circle_center = (
+            position[0] + text_width // 2 + 5,  # 原位置向右偏移边距
+            position[1] + text_height // 2 + 5  # 原位置向下偏移边距
+        )
+
+        # 绘制圆形背景
+        ellipse_box = (
+            circle_center[0] - radius,
+            circle_center[1] - radius,
+            circle_center[0] + radius,
+            circle_center[1] + radius
+        )
+        draw.ellipse(ellipse_box, fill='#B920D9')
+
+        # 绘制居中文字
+        draw.text(
+            circle_center,
+            text,
+            (255, 255, 255),
+            font=font,
+            anchor="mm"  # 设置锚点为水平垂直居中
+        )
+        return image
+
+    def _merge_images(image_paths: List[Path], output_path: Path) -> None:
+        images = [Image.open(img_path) for img_path in image_paths]
+        max_width = max(img.width for img in images)
+        total_height = sum(img.height for img in images)
+        merged_image = Image.new('RGB', (max_width, total_height))
+        y_offset = 0
+        for idx, img in enumerate(images):
+            merged_image.paste(img, (0, y_offset))
+            _add_watermark(merged_image, f'{idx + 1}', (22, y_offset + 17))
+            y_offset += img.height
+        # 修改保存参数为 WebP 格式
+        merged_image.save(
+            output_path,
+            format='JPEG',
+            quality=80,        # 质量参数（0-100），推荐 80-90 之间
+            method=6,          # 压缩方法（0-6），6 为最佳压缩
+            lossless=False,    # 不使用无损压缩（更小的文件体积）
+        )
+
+    image_files = [x for x in bpath.listFile(path) if x.suffix in ('.png', '.jpg', '.jpeg', '.webp', '.bmp')]
+    output_image = path / f'merge_{path.name}.jpg'  # 修改文件扩展名为 webp
+    if output_image in image_files:
+        if not force:
+            print(output_image)
+            await binput.confirm(f'生成文件已经存在，是否覆盖？')
+        image_files.remove(output_image)
+    image_files.sort(key=lambda x: x.as_posix())
+    _merge_images(image_files, output_image)
+    bcolor.printMagenta(output_image)
+    bcolor.printGreen('OK')
+
+
+@app.command()
+@syncCall
+async def xone():
+    def showGui():
+        app = TkForm()
+        app.title('图片操作')
+        entry = app.addEntry('保存文件', tk.StringVar(value=r'C:\project\docs\source\docs\public\icon.webp'), width=60)
+        app.addEntry('输入密码', tk.StringVar(), password=True, width=60, command=lambda: messagebox.showerror('错误', '密码错误'))
+
+        scrolltextVar = tk.StringVar(value='xxiioo')
+        app.addScrolledText('测试信箱', scrolltextVar)
+
+
+        radioVarScale = app.addRadioBtnList(
+            '缩放操作',
+            [
+                '保持',
+                '缩放比',
+                '指定宽度',
+                '指定高度',
+            ],
+            selectedIndex=0,
+            onChanged=lambda x: onScaleValueChanged(x),
+        )
+
+        scaleValueEntry = app.addEntry('缩放参数', tk.StringVar(), width=10, justify=tk.CENTER)
+
+        app.addChoisePath('选择文件', tk.StringVar(), isDir=True, focus=True)
+
+        radioVarFormat = app.addRadioBtnList(
+            '格式转换',
+            [
+                '保持',
+                'PNG',
+                'JPEG',
+                'WEBP',
+            ],
+            selectedIndex=0,
+        )
+        app.addCheckBox('去除透明', '去除透明', False)
+        app.addCheckBox('TinyPng', 'TinyPng', True)
+        app.addCheckBoxList('其他选项', [
+            ('去除透明', False),
+            ('TinyPng', True),
+        ])
+
+        def onScaleValueChanged(value: str):
+            match value:
+                case '保持':
+                    setWidgetEnabled(scaleValueEntry, False)
+                case _:
+                    setWidgetEnabled(scaleValueEntry, True)
+
+        app.addBtn('确定', lambda: onBtn())
+
+        def onBtn():
+            nonlocal result
+            app.destroy()
+
+        result: str = ''
+        app.run()
+        return result
+
+    showGui()

bcmd/tasks/json.py

@@ -0,0 +1,25 @@
+import json
+from typing import Final
+
+import pyperclip
+from beni import bcolor, btask
+from beni.bfunc import syncCall
+from rich.console import Console
+
+app: Final = btask.app
+
+
+@app.command('json')
+@syncCall
+async def format_json():
+    '格式化 JSON （使用复制文本）'
+    content = pyperclip.paste()
+    try:
+        Console().print_json(content, indent=4, ensure_ascii=False, sort_keys=True)
+        data = json.loads(content)
+        pyperclip.copy(
+            json.dumps(data, indent=4, ensure_ascii=False, sort_keys=True)
+        )
+    except:
+        bcolor.printRed('无效的 JSON')
+        bcolor.printRed(content)

bcmd/tasks/lib.py

@@ -0,0 +1,94 @@
+import os
+from pathlib import Path
+from typing import Final
+
+import typer
+from beni import bcolor, bfile, bpath, brun, btask
+from beni.bfunc import syncCall
+
+from bcmd.utils.tkUtil import TkForm
+
+from ..common import secret
+
+app: Final = btask.newSubApp('lib 工具')
+
+
+@app.command()
+@syncCall
+async def update_version(
+    path: Path = typer.Argument(Path.cwd(), help='workspace 路径'),
+    isNotCommit: bool = typer.Option(False, '--no-commit', '-d', help='是否提交git'),
+):
+    '修改 pyproject.toml 版本号'
+    file = path / 'pyproject.toml'
+    btask.assertTrue(file.is_file(), '文件不存在', file)
+    data = await bfile.readToml(file)
+    latestVersion = data['project']['version']
+    vAry = [int(x) for x in latestVersion.split('.')]
+    versionList = [
+        f'{vAry[0] + 1}.0.0',
+        f'{vAry[0]}.{vAry[1] + 1}.0',
+        f'{vAry[0]}.{vAry[1]}.{vAry[2] + 1}',
+    ]
+
+    def showGui():
+        app = TkForm()
+        app.title('bcmd 版本更新')
+        app.addLabel('当前版本号', latestVersion)
+        version_var = app.addRadioBtnList(
+            '请选择新版本',
+            versionList,
+            selectedIndex=-1,
+        )
+        result: str = ''
+
+        def onBtn():
+            nonlocal result
+            result = version_var.get()
+            app.destroy()
+
+        app.addBtn('确定', onBtn, focus=True)
+        app.run()
+        return result
+
+    newVersion = showGui()
+    if not newVersion:
+        btask.abort('用户取消操作')
+    content = await bfile.readText(file)
+    if f"version = '{latestVersion}'" in content:
+        content = content.replace(f"version = '{latestVersion}'", f"version = '{newVersion}'")
+    elif f'version = "{latestVersion}"' in content:
+        content = content.replace(f'version = "{latestVersion}"', f'version = "{newVersion}"')
+    else:
+        raise Exception('版本号修改失败，先检查文件中定义的版本号格式是否正常')
+    await bfile.writeText(file, content)
+
+    # 执行一遍 uv.lock
+    with bpath.changePath(path):
+        await brun.run('uv lock')
+
+    bcolor.printCyan(newVersion)
+    if not isNotCommit:
+        msg = f'更新版本号 {newVersion}'
+        os.system(
+            rf'TortoiseGitProc.exe /command:commit /path:{path} /logmsg:"{msg}"'
+        )
+    bcolor.printGreen('OK')
+
+
+@app.command()
+@syncCall
+async def build(
+    path: Path = typer.Argument(Path.cwd(), help='workspace 路径'),
+    secretValue: str = typer.Option('', '--secret', '-s', help='密钥信息'),
+):
+    '发布项目'
+    data = await secret.getPypi(secretValue)
+    bpath.remove(path / 'dist')
+    bpath.remove(
+        *list(path.glob('*.egg-info'))
+    )
+    with bpath.changePath(path):
+        await brun.run(f'uv build')
+        await brun.run(f'uv publish -u {data['username']} -p {data['password']}')
+    bcolor.printGreen('OK')

bcmd/tasks/math.py

@@ -0,0 +1,97 @@
+from typing import Final
+
+import typer
+from beni import bcolor, btask
+from beni.bfunc import Counter, syncCall, toFloat
+from prettytable import PrettyTable
+
+app: Final = btask.newSubApp('math 工具集')
+
+
+@app.command()
+@syncCall
+async def scale(
+    a: float = typer.Argument(..., help='原始数值'),
+    b: float = typer.Argument(..., help='原始数值'),
+    c: str = typer.Argument(..., help='数值 或 ?'),
+    d: str = typer.Argument(..., help='数值 或 ?'),
+):
+    '按比例计算数值，例子：beni math scale 1 2 3 ?'
+    if not ((c == '?') != (d == '?')):
+        return bcolor.printRed('参数C和参数D必须有且仅有一个为?')
+    print()
+    table = PrettyTable(
+        title=bcolor.yellow('按比例计算数值'),
+    )
+    if c == '?':
+        dd = toFloat(d)
+        cc = a * dd / b
+        table.add_rows([
+            ['A', a, bcolor.magenta(str(cc)), bcolor.magenta('C')],
+            ['B', b, dd, 'D'],
+        ])
+    elif d == '?':
+        cc = toFloat(c)
+        dd = b * cc / a
+        table.add_rows([
+            ['A', a, cc, 'C'],
+            ['B', b, bcolor.magenta(str(dd)), bcolor.magenta('D')],
+        ])
+    print(table.get_string(header=False))
+
+
+@app.command()
+@syncCall
+async def discount(
+    values: list[str] = typer.Argument(..., help='每组数据使用#作为分隔符，注意后面的数据不能为0，例：123#500'),
+):
+    '计算折扣，例子：beni math discount 123#500 130#550'
+    btask.assertTrue(len(values) >= 2, '至少需要提供2组数据用作比较')
+
+    class Data:
+        def __init__(self, value: str):
+            try:
+                ary = [x.strip() for x in value.strip().split('#')]
+                self.a = float(ary[0])
+                self.b = float(ary[1])
+                self.v = self.a / self.b
+                self.discount = 0.0
+            except:
+                btask.abort(f'数据格式错误', value)
+
+    datas = [Data(x) for x in values]
+    table = PrettyTable(
+        title=bcolor.yellow('计算折扣'),
+    )
+    vAry = [x.v for x in datas]
+    minV = min(vAry)
+    maxV = max(vAry)
+    for data in datas:
+        data.discount = -(maxV - data.v) / maxV
+    table.add_column(
+        '',
+        [
+            '前数据',
+            '后数据',
+            '单价',
+            '折扣',
+        ],
+    )
+    counter = Counter(-1)
+    for data in datas:
+        colorFunc = bcolor.white
+        if data.v == minV:
+            colorFunc = bcolor.green
+        elif data.v == maxV:
+            colorFunc = bcolor.red
+        columns = [
+            f'{data.a:,}',
+            f'{data.b:,}',
+            f'{data.v:,.3f}',
+            f'{data.discount * 100:+,.3f}%' if data.discount else '',
+        ]
+        table.add_column(
+            chr(65 + counter()),
+            [colorFunc(x) for x in columns],
+        )
+    print(table.get_string())

bcmd/tasks/mirror.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import platform
+from typing import Final
+
+import typer
+from beni import bcolor, bfile, bpath, btask
+from beni.bfunc import syncCall
+
+app: Final = btask.app
+
+
+@app.command()
+@syncCall
+async def mirror(
+    disabled: bool = typer.Option(False, '--disabled', '-d', help="是否禁用"),
+):
+    '设置镜像'
+
+    # 根据不同的系统平台
+    match platform.system():
+        case 'Windows':
+            file = bpath.user('pip/pip.ini')
+        case 'Linux':
+            file = bpath.user('.pip/pip.conf')
+        case _:
+            btask.abort('暂时不支持该平台', platform.system())
+            return
+
+    if disabled:
+        bpath.remove(file)
+        bcolor.printRed('删除文件', file)
+    else:
+        content = _content.strip()
+        await bfile.writeText(file, content)
+        bcolor.printYellow(file)
+        bcolor.printMagenta(content)
+    bcolor.printGreen('OK')
+
+
+# ------------------------------------------------------------------------------------
+
+_content = '''
+[global]
+index-url = https://mirrors.aliyun.com/pypi/simple
+'''

bcmd/tasks/pdf.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from typing import Final
+
+import fitz
+import typer
+from beni import bcolor, bfile, btask
+from beni.bfunc import syncCall
+
+app: Final = btask.newSubApp('PDF相关')
+
+
+@app.command()
+@syncCall
+async def output_images(
+    target: Path = typer.Option(Path.cwd(), '--target', help='PDF文件路径或多个PDF文件所在的目录'),
+):
+    '保存 PDF 文件里面的图片'
+
+    # 列出需要检查的PDF文件
+    pdfFileList: list[Path] = []
+    if target.is_dir():
+        pdfFileList = list(target.glob('*.pdf'))
+    elif target.is_file():
+        pdfFileList = [target]
+    else:
+        raise ValueError("目标路径不存在")
+
+    for pdf_file in pdfFileList:
+        pdf_document = fitz.open(pdf_file)
+        output_dir = pdf_file.with_name(pdf_file.stem + '-PDF图片文件')
+        for page_num in range(len(pdf_document)):
+            page = pdf_document.load_page(page_num)
+            images = page.get_images(full=True)
+            for img_index, img in enumerate(images):
+                xref = img[0]
+                base_image = pdf_document.extract_image(xref)
+                image_bytes = base_image["image"]
+                image_ext = base_image["ext"]
+                image_filename = f"page{page_num + 1}_img{img_index + 1}.{image_ext}"
+                image_path = output_dir / image_filename
+                output_dir.mkdir(exist_ok=True)
+                bcolor.printGreen(image_path)
+                await bfile.writeBytes(image_path, image_bytes)