diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e06c3b7..864ca34 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -35,36 +35,86 @@ jobs: with: python-version: "3.12" - run: pip install -r requirements.txt pyinstaller pillow + # 러너 파이썬에 기본으로 깔린 certifi 등이 구버전일 수 있어 점검 전에 최신으로 + - run: pip install --upgrade certifi setuptools + + - name: Audit dependencies for known vulnerabilities (pip-audit) + shell: bash + run: | + # 번들에 들어가거나 빌드에 쓰이는 패키지 전체를 그대로 점검. 알려진 취약점이 있으면 빌드 실패 + python -m pip freeze > audit-requirements.txt + pipx run pip-audit --no-deps --desc -r audit-requirements.txt - name: Make .icns (macOS) if: runner.os == 'macOS' - run: python scripts/make_icns.py + run: | + python scripts/make_icns.py masker + python scripts/make_icns.py excelpaster - name: Build - run: pyinstaller --noconfirm --clean pdfmasker.spec + run: | + pyinstaller --noconfirm --clean pdfmasker.spec + pyinstaller --noconfirm --clean excelpaster.spec + # 앱마다 폴더를 나눠 아티팩트를 따로 올린다 (각각 받을 수 있게) - name: Package (Windows) if: runner.os == 'Windows' shell: pwsh run: | - New-Item -ItemType Directory -Force out | Out-Null - Copy-Item "dist/PDF Masker.exe" "out/PDF-Masker-windows.exe" + New-Item -ItemType Directory -Force out/pdfmasker, out/excelpaster | Out-Null + Copy-Item "dist/PDF Masker.exe" "out/pdfmasker/PDF-Masker-windows.exe" + Copy-Item "dist/Excel Paster.exe" "out/excelpaster/Excel-Paster-windows.exe" + # SHA-256 체크섬: 받은 파일이 CI 가 만든 그 파일인지 확인용 + foreach ($dir in "out/pdfmasker", "out/excelpaster") { + Get-ChildItem "$dir/*.exe" | ForEach-Object { + "$((Get-FileHash $_ -Algorithm SHA256).Hash.ToLower()) $($_.Name)" + } | Set-Content -Encoding ascii "$dir/SHA256SUMS.txt" + } - name: Package (macOS .dmg) if: runner.os == 'macOS' run: | - mkdir -p out dmgroot + mkdir -p out/pdfmasker out/excelpaster # 서명 인증서가 없으므로 ad-hoc 서명 (Gatekeeper 경고는 README 참고) - codesign --force --deep --sign - "dist/PDF Masker.app" - cp -R "dist/PDF Masker.app" dmgroot/ - ln -s /Applications dmgroot/Applications - hdiutil create -volname "PDF Masker" -srcfolder dmgroot -ov -format UDZO \ - "out/PDF-Masker-${{ matrix.name }}.dmg" + package() { # $1 앱 이름, $2 출력 폴더 + codesign --force --deep --sign - "dist/$1.app" + rm -rf dmgroot && mkdir dmgroot + cp -R "dist/$1.app" dmgroot/ + ln -s /Applications dmgroot/Applications + hdiutil create -volname "$1" -srcfolder dmgroot -ov -format UDZO \ + "$2/${1// /-}-${{ matrix.name }}.dmg" + (cd "$2" && shasum -a 256 *.dmg > SHA256SUMS.txt) + } + package "PDF Masker" out/pdfmasker + package "Excel Paster" out/excelpaster + + - name: Report sizes and checksums + shell: bash + run: | + { + echo "### ${{ matrix.name }} 빌드 결과" + echo + echo '| 파일 | 크기 |' + echo '| --- | --- |' + for f in out/*/*.exe out/*/*.dmg; do + [ -e "$f" ] || continue + echo "| $(basename "$f") | $(du -h "$f" | cut -f1) |" + done + echo + echo '```' + cat out/*/SHA256SUMS.txt + echo '```' + } | tee -a "$GITHUB_STEP_SUMMARY" - uses: actions/upload-artifact@v4 with: name: PDF-Masker-${{ matrix.name }} - path: out/* + path: out/pdfmasker/* + + - uses: actions/upload-artifact@v4 + with: + name: Excel-Paster-${{ matrix.name }} + path: out/excelpaster/* release: if: startsWith(github.ref, 'refs/tags/v') @@ -73,9 +123,21 @@ jobs: permissions: contents: write steps: + - uses: actions/checkout@v4 + - name: Verify tag matches app version + run: | + v="v$(python3 -c 'from excelpaster._version import __version__; print(__version__)')" + if [ "$v" != "$GITHUB_REF_NAME" ]; then + echo "태그 $GITHUB_REF_NAME 가 excelpaster/_version.py 의 $v 와 다릅니다"; exit 1 + fi - uses: actions/download-artifact@v4 with: path: artifacts + - name: Merge checksums + run: cat artifacts/*/SHA256SUMS.txt > SHA256SUMS.txt - uses: softprops/action-gh-release@v2 with: - files: artifacts/**/* + files: | + artifacts/**/*.exe + artifacts/**/*.dmg + SHA256SUMS.txt diff --git a/.gitignore b/.gitignore index 3000408..0c3273c 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,5 @@ dist/ out/ masker/assets/icon.icns masker/assets/icon.iconset/ +excelpaster/assets/icon.icns +excelpaster/assets/icon.iconset/ diff --git a/README.md b/README.md index 97f9280..513f994 100644 --- a/README.md +++ b/README.md @@ -20,13 +20,16 @@ PDF에서 가릴 부분을 드래그로 지정하거나 자동으로 찾아, ** ## 다운로드 / 설치 -GitHub Actions가 자동으로 빌드합니다. 저장소의 **Actions** 탭 → 최근 실행 → **Artifacts** 에서 받거나, -`v1.0.0` 같은 태그를 푸시하면 **Releases** 에 올라갑니다. +GitHub Actions가 자동으로 빌드합니다. 저장소의 **Actions** 탭 → 최근 실행 → **Artifacts** 에서 앱별로 따로 받거나 +(`PDF-Masker-windows`, `Excel-Paster-windows`, macOS 는 `-macos-arm64`), `v1.0.0` 같은 태그를 푸시하면 **Releases** 에 올라갑니다. +각 zip 에는 실행 파일과 `SHA256SUMS.txt` 가 들어 있습니다. | 파일 | 대상 | | --- | --- | | `PDF-Masker-windows.exe` | Windows 10/11 (64비트) — 설치 없이 바로 실행 | | `PDF-Masker-macos-arm64.dmg` | Mac (Apple Silicon, M1 이후) | +| `Excel-Paster-windows.exe` | [Excel Paster](#excel-paster) Windows용 — 설치 없이 바로 실행 | +| `Excel-Paster-macos-arm64.dmg` | Excel Paster Mac용 | > **처음 실행 시 경고가 뜨는 이유** > 개발자 서명 인증서(Apple $99/년, Windows 코드사인)를 쓰지 않아 OS가 "확인되지 않은 앱"으로 경고합니다. @@ -35,6 +38,11 @@ GitHub Actions가 자동으로 빌드합니다. 저장소의 **Actions** 탭 → > > 서명 인증서가 있다면 `.github/workflows/build.yml` 의 패키징 단계에 서명을 추가하면 됩니다. +**빌드 신뢰성**: 모든 실행 파일은 GitHub 가 제공하는 깨끗한 가상머신에서 이 저장소의 소스만으로 빌드됩니다. +빌드마다 포함되는 패키지 전체를 `pip-audit` 로 알려진 취약점 점검을 하고(발견 시 빌드 실패), 산출물의 SHA-256 체크섬을 +`SHA256SUMS-*.txt` 로 함께 올립니다. Actions 실행 페이지의 Summary 에서 파일 크기와 체크섬을 바로 볼 수 있습니다. +받은 파일은 Windows 에서 `certutil -hashfile 파일.exe SHA256`, macOS 에서 `shasum -a 256 파일.dmg` 로 대조하면 됩니다. + ## 사용법 1. PDF를 창에 끌어다 놓거나 `Ctrl+O`로 엽니다. @@ -68,14 +76,15 @@ GitHub Actions가 자동으로 빌드합니다. 저장소의 **Actions** 탭 → python3 -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate pip install -r requirements.txt -python main.py # 실행 +python main.py # PDF Masker 실행 +python paster_main.py # Excel Paster 실행 pytest -q # 테스트 ``` ### 로컬 빌드 -- macOS: `scripts/build.sh` → `dist/PDF Masker.app` -- Windows: `scripts\build.bat` → `dist\PDF Masker.exe` +- macOS: `scripts/build.sh` → `dist/PDF Masker.app`, `dist/Excel Paster.app` +- Windows: `scripts\build.bat` → `dist\PDF Masker.exe`, `dist\Excel Paster.exe` ### 구조 @@ -85,7 +94,106 @@ pytest -q # 테스트 | `masker/detect.py` | 개인정보 패턴 자동 탐지 (텍스트 / OCR 공통) | | `masker/ocr.py` | OS 내장 OCR 백엔드 (macOS Vision, Windows.Media.Ocr) | | `masker/gui.py` | PySide6 데스크톱 UI | -| `masker/theme.py` | 라이트/다크 테마 토큰, 스타일시트, 아이콘 | -| `tests/` | 핵심 로직 테스트 24개 (OCR 경로는 가짜 백엔드로 검증) | -| `pdfmasker.spec` | PyInstaller 빌드 스펙 | +| `masker/theme.py` | 라이트/다크 테마 토큰, 스타일시트, 아이콘 (두 앱이 공유) | +| `excelpaster/core.py` | 엑셀 클립보드 파싱, 템플릿·필터 변환, 프리셋 직렬화. GUI 없이 테스트 가능 | +| `excelpaster/gui.py` | Excel Paster PySide6 UI | +| `tests/` | 핵심 로직 테스트 (`test_core.py`·`test_detect.py` PDF Masker, `test_paster.py` Excel Paster) | +| `pdfmasker.spec`, `excelpaster.spec` | PyInstaller 빌드 스펙 | +| `scripts/pyi_trim.py` | 번들에서 쓰지 않는 Qt 모듈·플러그인·번역을 걸러내 실행 파일 크기 축소 | | `.github/workflows/build.yml` | Windows/macOS 자동 빌드 및 릴리스 | + +--- + +# Excel Paster + +엑셀에서 셀 범위를 복사해 붙여넣으면, 내가 글로 적어 둔 **템플릿** 대로 바꿔 주는 Windows·macOS 데스크톱 앱입니다. +명단을 메신저에 올리거나, 표를 문장으로 풀어 쓸 때 씁니다. PDF Masker 와 마찬가지로 모든 처리는 내 컴퓨터 안에서만 이루어집니다. + +| 라이트 | 다크 | +| --- | --- | +| ![light](docs/paster-light.png) | ![dark](docs/paster-dark.png) | + +## 사용법 + +1. 엑셀에서 원하는 셀 범위를 복사합니다 (`Ctrl+C`). +2. Excel Paster 창으로 오면 자동으로 입력칸에 들어갑니다. (자동 가져오기를 끈 경우 입력칸에 `Ctrl+V` 또는 툴바의 **클립보드 가져오기**) +3. 가운데 템플릿 칸에 원하는 양식을 글로 적습니다. 결과는 오른쪽에 바로 나타납니다. +4. **결과 복사** (`Ctrl+Shift+C`) 를 누른 뒤 원하는 곳에 `Ctrl+V` 합니다. + +## 템플릿 + +원하는 결과를 그대로 적되, 셀 값이 들어갈 자리에 `{열이름}` 또는 `{1}` `{2}` (열 번호) 를 씁니다. +**`{ }` 가 든 줄만 엑셀의 한 행마다 반복**되고, 그 앞뒤 줄은 한 번만 나옵니다. 열 이름 칩을 클릭해도 들어갑니다. + +첫 행이 열 이름(품명, 규격 …)이면 자동으로 건너뛰고, 아니면 전부 데이터로 넣습니다. +**헤더 없이 데이터만 복사**해도 `{품명}` 같은 이름을 쓰려면, 왼쪽 **열 이름** 칸에 시트의 열 순서를 한 번 저장해 두세요. +헤더 행을 한 번 붙여넣고 **첫 행에서 가져오기** 를 누르면 됩니다. 이후엔 어느 행을 복사하든 바로 변환됩니다. + +예) 엑셀에 품명 · 규격(두께·가로·세로·높이) · 재질 · 수량 열이 있을 때, 템플릿을 + +``` +11/5일 입고요청 +{품명} [{가로}*{세로}*{높이}] {재질} {수량}개 +오전입고 바랍니다. +``` + +라고 적으면 결과는 + +``` +11/5일 입고요청 +Xx형태 700*350*1600 SUS304 1개 +GAa STEEL 1개 +AR38 20개 +오전입고 바랍니다. +``` + +**빈 셀 처리**: 빈 셀은 옆의 공백 하나와 함께 사라져 `AR38 20개` 처럼 공백이 겹치지 않습니다. +`{가로}*{세로}` 처럼 자리표시자 사이의 구분 기호는 한쪽이 비면 같이 사라지고, `[ ]` 로 묶은 부분은 +안의 자리표시자가 전부 비면 통째로 사라집니다 (예: `[{두께}t]`). 대괄호를 글자 그대로 쓰려면 `[[ ]]`. + +**헤더가 두 줄**인 시트(규격 아래 두께·가로·세로·높이)는 두 줄을 합쳐 아래 줄 이름으로 참조합니다. +반복 줄이 여러 줄이어도 되고, 꼬리말 앞에 빈 줄을 두면 그 간격이 유지됩니다. 꼬리말 없이 끝에 빈 줄을 두면 행 사이가 띄어집니다. + +| 쓰기 | 뜻 | +| --- | --- | +| `{품명}` `{수량}` | 열 이름으로 참조 (첫 행 또는 저장해 둔 열 이름) | +| `{1}` `{2}` … | 열 번호로 참조 (열 이름이 없어도 됨) | +| `{#}` | 행 번호 (1부터) | +| `{행수}` | 전체 행 수 (머리말·꼬리말에서도 사용 가능) | +| `{오늘}` | 오늘 날짜, `11/5` 형식 | +| `{{` `}}` `[[` `]]` | 중괄호·대괄호 글자 그대로 | + +필요하면 `|` 뒤에 필터를 붙일 수 있습니다 (여러 개 연달아 가능). + +| 필터 | 예 | 결과 | +| --- | --- | --- | +| `comma` | `{금액\|comma}` | `1234567` → `1,234,567` | +| `nocomma` | `{금액\|nocomma}` | `1,234` → `1234` | +| `trim` `upper` `lower` | `{코드\|trim\|upper}` | 공백 제거 / 대문자 / 소문자 | +| `default:값` | `{비고\|default:없음}` | 비어 있으면 `없음` | +| `ljust:N` `rjust:N` `center:N` `zfill:N` | `{금액\|rjust:10}` | 폭 맞추기 / 0 채우기 | +| `replace:a,b` | `{전화\|replace:-,}` | `a` 를 `b` 로 바꿈 | +| `oneline` | `{메모\|oneline}` | 셀 안 줄바꿈·연속 공백을 한 칸으로 | +| `quote` | `{값\|quote}` | 큰따옴표로 감싸기 (내부 따옴표는 `""`) | + +## 업데이트 + +앱을 켤 때 GitHub Releases 에 새 버전이 있는지 확인하고, 있으면 오른쪽 아래에 **새 버전 vX — 업데이트** 버튼이 뜹니다. +누르면 새 실행 파일을 받아 `SHA256SUMS.txt` 로 검증한 뒤 교체하고 다시 실행합니다 (Windows). macOS 는 받은 dmg 를 열어 줍니다. +**도움말 → 업데이트 확인…** 으로 직접 확인할 수 있고, **시작할 때 업데이트 확인** 을 끄면 시작 시 인터넷에 접속하지 않습니다. +확인 과정에서 보내는 것은 버전 조회 요청뿐이며, 붙여넣은 내용은 어디에도 전송되지 않습니다. + +새 버전을 내려면 `excelpaster/_version.py` 의 버전을 올리고 같은 번호의 태그(`v1.1.0`)를 푸시하면 CI 가 Releases 에 올립니다. + +## 저장된 템플릿 + +자주 쓰는 템플릿은 **저장…** (`Ctrl+S`) 으로 이름을 붙여 두고 목록에서 고릅니다. 내 템플릿은 ★ 표시로 위쪽에 나옵니다. +**프리셋 메뉴 → 내보내기/가져오기** 로 JSON 파일로 옮길 수 있습니다. 마지막으로 쓰던 템플릿과 창 크기는 다음 실행 때 그대로 복원됩니다. + +## 동작 세부 + +- 엑셀이 클립보드에 넣는 탭 구분 텍스트를 그대로 해석합니다. 줄바꿈·탭·따옴표가 든 셀(엑셀이 큰따옴표로 감싸는 셀)도 올바르게 읽습니다. +- 엑셀이 붙이는 마지막 빈 줄은 무시하고, 행마다 열 수가 다르면 빈 칸으로 채웁니다. +- 탭이 없는 일반 텍스트를 붙여넣으면 한 줄이 한 행(1열)이 됩니다. +- 모르는 자리표시자는 그대로 남겨 두고 경고로 알려 줍니다 (타이핑 중 결과가 깨지지 않도록). +- 자동 가져오기는 탭이나 줄바꿈이 든 텍스트만 가져오며, 방금 복사한 결과물은 다시 가져오지 않습니다. diff --git a/docs/paster-dark.png b/docs/paster-dark.png new file mode 100644 index 0000000..c608a52 Binary files /dev/null and b/docs/paster-dark.png differ diff --git a/docs/paster-light.png b/docs/paster-light.png new file mode 100644 index 0000000..25e6b06 Binary files /dev/null and b/docs/paster-light.png differ diff --git a/excelpaster.spec b/excelpaster.spec new file mode 100644 index 0000000..1e0df44 --- /dev/null +++ b/excelpaster.spec @@ -0,0 +1,50 @@ +# -*- mode: python ; coding: utf-8 -*- +# PyInstaller 스펙 (Excel Paster). 사용: pyinstaller excelpaster.spec +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(SPECPATH) / "scripts")) +from pyi_trim import trim_qt # noqa: E402 — 쓰지 않는 Qt 구성 요소 제거 + +APP_NAME = "Excel Paster" +ROOT = Path(SPECPATH) +ASSETS = ROOT / "excelpaster" / "assets" +icon = None +if sys.platform == "win32": + icon = str(ASSETS / "icon.ico") +elif sys.platform == "darwin" and (ASSETS / "icon.icns").exists(): + icon = str(ASSETS / "icon.icns") + +a = Analysis( + ["paster_main.py"], + pathex=[str(ROOT)], + datas=[(str(ASSETS / "icon.png"), "excelpaster/assets")], + hiddenimports=[], + excludes=["pymupdf", "fitz", "PySide6.QtWebEngineCore", "PySide6.QtWebEngineWidgets", + "PySide6.QtPdf", "PySide6.QtQml", "PySide6.QtQuick", "PySide6.Qt3DCore", + "PySide6.QtMultimedia", "pymupdf4llm", "pymupdf_layout", "tkinter"], + noarchive=False, +) +trim_qt(a) +pyz = PYZ(a.pure) + +if sys.platform == "darwin": + exe = EXE(pyz, a.scripts, exclude_binaries=True, name=APP_NAME, console=False, icon=icon) + coll = COLLECT(exe, a.binaries, a.datas, name=APP_NAME) + app = BUNDLE( + coll, + name=f"{APP_NAME}.app", + icon=icon, + bundle_identifier="dev.local.excelpaster", + info_plist={ + "CFBundleDisplayName": APP_NAME, + "CFBundleShortVersionString": "1.0.0", + "NSHighResolutionCapable": True, + "NSRequiresAquaSystemAppearance": False, + }, + ) +else: + exe = EXE( + pyz, a.scripts, a.binaries, a.datas, [], + name=APP_NAME, console=False, icon=icon, upx=False, + ) diff --git a/excelpaster/__init__.py b/excelpaster/__init__.py new file mode 100644 index 0000000..73b8d52 --- /dev/null +++ b/excelpaster/__init__.py @@ -0,0 +1 @@ +"""엑셀에서 복사한 표를 원하는 텍스트 양식으로 바꿔 주는 데스크톱 앱.""" diff --git a/excelpaster/_version.py b/excelpaster/_version.py new file mode 100644 index 0000000..2a96649 --- /dev/null +++ b/excelpaster/_version.py @@ -0,0 +1,3 @@ +"""앱 버전. 릴리스 태그(vX.Y.Z)와 같아야 하며 CI 가 검사한다.""" + +__version__ = "1.0.0" diff --git a/excelpaster/assets/icon.ico b/excelpaster/assets/icon.ico new file mode 100644 index 0000000..8ad3f3e Binary files /dev/null and b/excelpaster/assets/icon.ico differ diff --git a/excelpaster/assets/icon.png b/excelpaster/assets/icon.png new file mode 100644 index 0000000..13f483c Binary files /dev/null and b/excelpaster/assets/icon.png differ diff --git a/excelpaster/core.py b/excelpaster/core.py new file mode 100644 index 0000000..988ca4f --- /dev/null +++ b/excelpaster/core.py @@ -0,0 +1,623 @@ +"""엑셀 클립보드 텍스트 파싱과 템플릿 변환. GUI 없이 테스트 가능.""" + +from __future__ import annotations + +import csv +import io +import json +import re +from dataclasses import asdict, dataclass, replace +from datetime import date + +Table = list[list[str]] + +# 특수 자리표시자 (열 이름보다 우선하지 않음 — 같은 이름의 열이 있으면 열이 우선) +ROW_NUMBER_KEYS = ("#", "행번호", "n", "row") +ROW_COUNT_KEYS = ("행수", "rows", "count") +COL_COUNT_KEYS = ("열수", "cols") +TODAY_KEYS = ("오늘", "today") + + +@dataclass +class FormatSpec: + """변환 방법 하나. 프리셋으로 저장/불러오기 할 수 있도록 JSON 직렬화 가능.""" + + name: str = "" + template: str = "{1}" # 행마다 반복되는 글. 행 사이는 줄바꿈 + header_row: bool | None = None # None = 첫 행이 열 이름인지 자동 판단, True/False = 강제 + skip_blank_rows: bool = True + + def to_dict(self) -> dict: + return asdict(self) + + @classmethod + def from_dict(cls, d: dict) -> "FormatSpec": + known = {k: v for k, v in d.items() if k in cls.__dataclass_fields__} + if "template" not in known and "row_template" in d: # 이전 버전 프리셋 + known["template"] = d["row_template"] + return cls(**known) + + def copy(self, **changes) -> "FormatSpec": + return replace(self, **changes) + + +# ---------------------------------------------------------------- 파싱 + +def parse_table(text: str) -> Table: + """엑셀이 클립보드에 넣는 TSV를 2차원 문자열 배열로. + + - 행 구분: CRLF/LF, 열 구분: 탭 + - 줄바꿈·탭·따옴표가 든 셀은 엑셀이 큰따옴표로 감싸고 따옴표는 두 번 씀 → csv 모듈로 처리 + - 마지막 빈 줄(엑셀이 붙이는 꼬리 개행)은 제거, 모든 행을 같은 열 수로 맞춤 + """ + if not text: + return [] + text = text.replace("\r\n", "\n").replace("\r", "\n") + reader = csv.reader(io.StringIO(text, newline=""), delimiter="\t", quotechar='"', + doublequote=True, strict=False) + rows: Table = [list(r) for r in reader] + while rows and all(c == "" for c in rows[-1]): + rows.pop() + if not rows: + return [] + width = max(len(r) for r in rows) + for r in rows: + r.extend([""] * (width - len(r))) + return rows + + +def normalize_header(h: str) -> str: + """열 이름 정리: 앞뒤 공백 제거, 셀 안의 줄바꿈·연속 공백은 한 칸으로 ('입고\\n예정' → '입고 예정').""" + return " ".join(h.split()) + + +def split_table(table: Table, header_row: bool, skip_blank_rows: bool = True) -> tuple[list[str], Table]: + """(열 이름 목록, 데이터 행) 으로 분리. 헤더가 없으면 열 이름은 '1', '2', ...""" + if not table: + return [], [] + width = len(table[0]) + if header_row: + headers = [normalize_header(h) for h in table[0]] + data = table[1:] + else: + headers = [str(i + 1) for i in range(width)] + data = table + if skip_blank_rows: + data = [r for r in data if any(c.strip() for c in r)] + return headers, data + + +def column_names(headers: list[str]) -> list[str]: + """GUI 자리표시자 칩에 쓸 이름들. 이름이 비어 있으면 번호로 대체.""" + return [h if h else str(i + 1) for i, h in enumerate(headers)] + + +def parse_column_names(text: str) -> list[str]: + """사용자가 적어 둔 열 이름 목록 ('품명, 규격, , , , 재질, 수량' 또는 탭 구분) → 리스트.""" + if not text.strip(): + return [] + sep = "\t" if "\t" in text else "," + return [normalize_header(c) for c in text.split(sep)] + + +_NUMERIC_CELL = re.compile(r"^[\s\-+]?[\d,.]+\s*%?$") + + +def _row_names(row: list[str]) -> list[str]: + return [normalize_header(c) for c in row] + + +def _squash(names: list[str]) -> set[str]: + return {c.replace(" ", "").lower() for c in names if c} + + +def _row_matches(row: list[str], known: set[str], template_names: list[str], threshold: bool) -> bool | None: + """저장된 열 이름 / 템플릿 이름으로 헤더인지 판단. 판단 근거가 없으면 None.""" + nonempty = [c for c in _row_names(row) if c] + if not nonempty: + return False + squashed = _squash(nonempty) + if known: + matches = sum(1 for c in squashed if c in known) + return matches >= (max(1, (len(nonempty) + 1) // 2) if threshold else 1) + if template_names and any(n in squashed for n in template_names): + return True + return None + + +def _template_names(template: str) -> list[str]: + return [n.replace(" ", "").lower() for n in placeholders(template) if not n.isdigit() and not _is_special(n)] + + +def _has_number(row: list[str]) -> bool: + return any(_NUMERIC_CELL.match(c.strip()) for c in row if c.strip()) + + +def looks_like_header(table: Table, known_headers: list[str], template: str) -> bool: + """첫 행이 열 이름인지 판단. + + 1) 저장된 열 이름이 있으면: 첫 행의 셀 절반 이상이 그 이름과 같을 때 + 2) 템플릿에 쓴 열 이름({품명} 등)이 첫 행에 있을 때 + 3) 그 외: 첫 행엔 숫자 셀이 없고 아래 행엔 숫자 셀이 있을 때 (헤더엔 보통 숫자가 없음) + """ + if not table: + return False + known = _squash([normalize_header(k) for k in known_headers]) + verdict = _row_matches(table[0], known, _template_names(template), threshold=True) + if verdict is not None: + return verdict + return not _has_number(table[0]) and any(_has_number(r) for r in table[1:]) + + +def header_row_count(table: Table, known_headers: list[str], template: str) -> int: + """열 이름 행이 몇 줄인지 (0, 1, 2). 둘째 줄은 '규격' 아래 '두께·가로·세로·높이' 같은 세부 이름.""" + if not looks_like_header(table, known_headers, template): + return 0 + if len(table) < 2: + return 1 + row1, row2 = _row_names(table[0]), _row_names(table[1]) + if not any(row2) or _has_number(row2): + return 1 + known = _squash([normalize_header(k) for k in known_headers]) + verdict = _row_matches(table[1], known, _template_names(template), threshold=True) + if verdict is not None: + return 2 if verdict else 1 + fills_gap = any(b and not a for a, b in zip(row1, row2)) + return 2 if fills_gap and any(_has_number(r) for r in table[2:]) else 1 + + +def merged_header_names(table: Table, rows: int) -> list[str]: + """헤더 행들을 합친 열 이름. 아래 줄에 이름이 있으면 그것이 우선 (규격 → 두께/가로/세로/높이).""" + width = len(table[0]) if table else 0 + names = [""] * width + for r in range(min(rows, len(table))): + for i, c in enumerate(_row_names(table[r])): + if c: + names[i] = c + return names + + +def resolve_table(table: Table, spec: FormatSpec, known_headers: list[str] | None = None + ) -> tuple[list[str], Table, int]: + """(열 이름, 데이터 행, 열 이름으로 건너뛴 행 수). + + 저장된 열 이름(known_headers)이 있으면 그것을 쓰고, 없으면 헤더 행(있을 때) 또는 번호를 쓴다. + """ + if not table: + return [], [], 0 + known = [normalize_header(k) for k in (known_headers or [])] + if spec.header_row is None: + n_header = header_row_count(table, known, spec.template) + else: + n_header = 1 if spec.header_row else 0 + width = len(table[0]) + if any(known): + headers = (known + [""] * width)[:width] + elif n_header: + headers = merged_header_names(table, n_header) + else: + headers = [str(i + 1) for i in range(width)] + data = table[n_header:] + if spec.skip_blank_rows: + data = [r for r in data if any(c.strip() for c in r)] + return headers, data, n_header + + +# ---------------------------------------------------------------- 템플릿 + +class TemplateError(ValueError): + pass + + +Token = tuple # ("lit", text) | ("field", inner) | ("group", [tokens]) + + +def _has_field(tokens: list[Token]) -> bool: + return any(t[0] == "field" or (t[0] == "group" and _has_field(t[1])) for t in tokens) + + +def _tokens_to_text(tokens: list[Token]) -> str: + """자리표시자가 없는 토큰들을 글자 그대로 되돌린다 (대괄호 묶음이 아닐 때).""" + out = [] + for t in tokens: + if t[0] == "lit": + out.append(t[1]) + elif t[0] == "field": + out.append("{" + t[1] + "}") + else: + out.append("[" + _tokens_to_text(t[1]) + "]") + return "".join(out) + + +def _scan_until(t: str, i: int, in_group: bool) -> tuple[list[Token], int, bool]: + """t[i:] 를 토큰으로. in_group 이면 짝이 맞는 ']' 에서 멈춘다. (토큰, 다음 위치, 닫혔는지)""" + out: list[Token] = [] + buf: list[str] = [] + n = len(t) + + def flush() -> None: + if buf: + out.append(("lit", "".join(buf))) + buf.clear() + + while i < n: + c = t[i] + if c == "{": + if t.startswith("{{", i): + buf.append("{") + i += 2 + continue + j = t.find("}", i + 1) + if j == -1 or "{" in t[i + 1:j] or "\n" in t[i + 1:j]: + buf.append(c) + i += 1 + continue + flush() + out.append(("field", t[i + 1:j])) + i = j + 1 + elif c == "}" and t.startswith("}}", i): + buf.append("}") + i += 2 + elif c == "[": + if t.startswith("[[", i): + buf.append("[") + i += 2 + continue + sub, k, closed = _scan_until(t, i + 1, in_group=True) + if closed and _has_field(sub): + flush() + out.append(("group", sub)) + i = k + else: + buf.append("[") # 짝이 없거나 자리표시자가 없는 대괄호는 글자 그대로 + i += 1 + elif c == "]": + if t.startswith("]]", i): + buf.append("]") + i += 2 + elif in_group: + flush() + return out, i + 1, True + else: + buf.append("]") + i += 1 + elif c == "\n" and in_group: + flush() + return out, i, False # 묶음은 줄을 넘지 않음 + else: + buf.append(c) + i += 1 + flush() + return out, i, False + + +def _scan(template: str) -> list[Token]: + """템플릿을 토큰으로. {{ }} [[ ]] 는 글자 그대로, [ … ] 안에 자리표시자가 있으면 묶음(group).""" + tokens, _, _ = _scan_until(template, 0, in_group=False) + return tokens + + +def _field_names(tokens: list[Token]) -> list[str]: + names: list[str] = [] + for t in tokens: + if t[0] == "field": + names.append(t[1].split("|", 1)[0].strip()) + elif t[0] == "group": + names.extend(_field_names(t[1])) + return names + + +def placeholders(template: str) -> list[str]: + """템플릿에 쓰인 자리표시자 이름(필터 제외) 목록. 중복 제거, 순서 유지.""" + seen: list[str] = [] + for name in _field_names(_scan(template)): + if name and name not in seen: + seen.append(name) + return seen + + +def unknown_placeholders(template: str, headers: list[str]) -> list[str]: + """열 이름·번호·특수 키 어디에도 해당하지 않는 자리표시자.""" + lookup = _build_lookup(headers) + out = [] + for name in placeholders(template): + if _resolve_index(name, lookup, len(headers)) is None and not _is_special(name): + out.append(name) + return out + + +def _is_special(name: str) -> bool: + k = name.lower() + return k in ROW_NUMBER_KEYS or k in ROW_COUNT_KEYS or k in COL_COUNT_KEYS or k in TODAY_KEYS + + +def _build_lookup(headers: list[str]) -> dict[str, int]: + """열 이름 → 인덱스. 같은 이름이 여러 개면 첫 번째. 대소문자 무시 키도 추가.""" + lookup: dict[str, int] = {} + for i, h in enumerate(headers): + h = normalize_header(h) + if not h: + continue + for key in (h, h.lower(), h.replace(" ", ""), h.replace(" ", "").lower()): + lookup.setdefault(key, i) # '입고 예정' 은 {입고 예정} 으로도 {입고예정} 으로도 참조 가능 + return lookup + + +def _resolve_index(name: str, lookup: dict[str, int], width: int) -> int | None: + name = normalize_header(name) + for key in (name, name.lower(), name.replace(" ", ""), name.replace(" ", "").lower()): + if key in lookup: + return lookup[key] + if name.isdigit(): + i = int(name) - 1 + return i if 0 <= i < width else None + return None + + +_NUM_RE = re.compile(r"^\s*(-?)([\d,]*)(\.\d+)?\s*$") + + +def _comma(value: str) -> str: + m = _NUM_RE.match(value) + if not m or not m.group(2): + return value + sign, whole, frac = m.group(1), m.group(2).replace(",", ""), m.group(3) or "" + if not whole.isdigit(): + return value + return f"{sign}{int(whole):,}{frac}" + + +def _apply_filter(value: str, spec: str) -> str: + """`이름|필터1|필터2:인자` 형태의 필터 하나 적용.""" + name, _, arg = spec.strip().partition(":") + name = name.strip().lower() + if name == "comma": + return _comma(value) + if name == "nocomma": + return value.replace(",", "") + if name == "upper": + return value.upper() + if name == "lower": + return value.lower() + if name == "trim": + return value.strip() + if name == "default": + return value if value.strip() else arg + if name in ("ljust", "rjust", "zfill", "center"): + try: + n = int(arg) + except ValueError as e: + raise TemplateError(f"필터 '{name}' 에는 숫자 인자가 필요합니다") from e + return getattr(value, name)(n) + if name == "replace": + old, _, new = arg.partition(",") + return value.replace(old, new) + if name == "quote": + return '"' + value.replace('"', '""') + '"' + if name == "oneline": + return " ".join(value.split()) + raise TemplateError(f"알 수 없는 필터: {name}") + + +def _today() -> str: + d = date.today() + return f"{d.month}/{d.day}" + + +# 렌더링 중간 결과: ("lit", text) 또는 ("val", text, empty) +def _eval_tokens(tokens: list[Token], lookup: dict[str, int], width: int, row: list[str], + row_number: int, row_count: int) -> list[tuple]: + parts: list[tuple] = [] + for t in tokens: + kind = t[0] + if kind == "lit": + parts.append(("lit", t[1])) + elif kind == "field": + parts.append(_eval_field(t[1], lookup, width, row, row_number, row_count)) + else: # group: 안의 자리표시자가 전부 비면 통째로 생략 + inner = _eval_tokens(t[1], lookup, width, row, row_number, row_count) + vals = [q for q in inner if q[0] == "val"] + if vals and all(q[2] for q in vals): + parts.append(("val", "", True)) + else: + parts.append(("val", _join_parts(inner), False)) + return parts + + +def _eval_field(inner: str, lookup: dict[str, int], width: int, row: list[str], + row_number: int, row_count: int) -> tuple: + parts = inner.split("|") + name = parts[0].strip() + idx = _resolve_index(name, lookup, width) + if idx is not None: + value = row[idx] if idx < len(row) else "" + elif name.lower() in ROW_NUMBER_KEYS: + value = str(row_number) + elif name.lower() in ROW_COUNT_KEYS: + value = str(row_count) + elif name.lower() in COL_COUNT_KEYS: + value = str(width) + elif name.lower() in TODAY_KEYS: + value = _today() + else: + return ("val", "{" + inner + "}", False) # 모르는 이름은 그대로 둠 (타이핑 중 깨지지 않도록) + for f in parts[1:]: + if f.strip(): + value = _apply_filter(value, f) + return ("val", value, value == "") + + +def _later_value(parts: list[tuple], j: int) -> bool: + """parts[j] 부터 '값, 구분기호, 값, …' 사슬을 따라가며 비지 않은 값이 있는지.""" + while j < len(parts) and parts[j][0] == "val": + if not parts[j][2]: + return True + sep = parts[j + 1] if j + 1 < len(parts) else None + if not sep or sep[0] != "lit" or not sep[1] or any(ch.isspace() for ch in sep[1]): + return False + j += 2 + return False + + +def _join_parts(parts: list[tuple]) -> str: + """조각을 이어 붙인다. 빈 값은 옆 공백 하나와 함께 사라지고, + 빈 값에 붙은 구분 기호(공백 없는 글자, 예: 700*350 의 *)도 함께 사라진다.""" + out: list[str] = [] + eat_space = False + for k, part in enumerate(parts): + if part[0] == "lit": + text = part[1] + prev = parts[k - 1] if k > 0 else None + nxt = parts[k + 1] if k + 1 < len(parts) else None + is_sep = text and not any(ch.isspace() for ch in text) + if is_sep and prev and prev[0] == "val" and nxt and nxt[0] == "val": + if prev[2]: + continue # 앞 값이 비면 구분 기호 생략 ({가로}*{세로} 의 *) + if nxt[2] and not _later_value(parts, k + 1): + continue # 뒤로 더 이어지는 값이 없으면 생략. 있으면 남겨서 700*1600 처럼 이어 붙임 + if eat_space and text.startswith(" "): + text = text[1:] + eat_space = False + if text: + out.append(text) + continue + _, value, empty = part + if empty: + prev_text = out[-1] if out else "" + so_far = "".join(out).rstrip(" ") + at_line_start = so_far == "" or so_far.endswith("\n") + if not at_line_start and prev_text.endswith(" "): + out[-1] = prev_text[:-1] # 앞 공백 하나 제거 + else: + eat_space = True # 줄 머리(들여쓰기)는 두고 뒤 공백 하나 제거 + continue + eat_space = False + out.append(value) + return "".join(out) + + +def render_template(template: str, headers: list[str], row: list[str], + row_number: int, row_count: int) -> str: + """자리표시자를 채운다. 빈 셀은 옆 공백·구분 기호와 함께 사라지고, [ ] 묶음은 안이 전부 비면 생략.""" + lookup = _build_lookup(headers) + width = len(headers) + return _join_parts(_eval_tokens(_scan(template), lookup, width, row, row_number, row_count)) + + +def _is_row_line(line: str) -> bool: + """셀 값이나 행 번호를 참조하는 줄인가. {오늘} {행수} 처럼 행과 무관한 것만 있으면 머리말/꼬리말.""" + global_keys = TODAY_KEYS + ROW_COUNT_KEYS + COL_COUNT_KEYS + return any(name.lower() not in global_keys for name in placeholders(line)) + + +def split_template(template: str) -> tuple[str, str, str]: + """템플릿을 (머리말, 행마다 반복할 부분, 꼬리말) 로 나눈다. + + 자리표시자가 든 첫 줄부터 마지막 줄까지가 반복 부분이고, 그 앞뒤 줄은 한 번만 나온다. + 자리표시자가 한 줄도 없으면 전체가 반복 부분이다. 꼬리말이 없을 때 끝의 빈 줄은 반복 부분에 + 들어가 행 사이를 띄우고, 꼬리말이 있으면 그 빈 줄은 꼬리말 앞의 간격이 된다. + """ + lines = template.replace("\r\n", "\n").split("\n") + marked = [i for i, ln in enumerate(lines) if _is_row_line(ln)] + if not marked: + return "", template, "" + first, last = marked[0], marked[-1] + if not any(ln.strip() for ln in lines[last + 1:]): + last = len(lines) - 1 # 꼬리말이 없으면 끝의 빈 줄은 반복 부분에 포함 (행 사이 띄우기) + head = "\n".join(lines[:first]) + body = "\n".join(lines[first:last + 1]) + tail = "\n".join(lines[last + 1:]) + return head, body, tail + + +# ---------------------------------------------------------------- 렌더링 + +def render(table: Table, spec: FormatSpec, known_headers: list[str] | None = None) -> str: + """템플릿을 표에 적용한 텍스트. 템플릿 오류는 TemplateError. + + { } 가 든 줄들은 행마다 반복되어 줄바꿈으로 이어지고, 그 앞뒤 줄(머리말·꼬리말)은 한 번만 나온다. + """ + headers, data, _ = resolve_table(table, spec, known_headers) + if not headers: + return "" + n = len(data) + head, body, tail = split_template(spec.template) + meta = [""] * len(headers) + parts = [] + if head: + parts.append(render_template(head, headers, meta, 0, n)) + parts.extend(render_template(body, headers, r, i + 1, n) for i, r in enumerate(data)) + if tail: + parts.append(render_template(tail, headers, meta, 0, n)) + return "\n".join(parts) + + +# ---------------------------------------------------------------- 프리셋 + +BUILTIN_PRESETS: list[FormatSpec] = [ + FormatSpec(name="입고요청 (품명·규격·재질·수량)", + template="{오늘}일 입고요청\n{품명} [{가로}*{세로}*{높이}] {재질} {수량}개\n오전입고 바랍니다."), + FormatSpec(name="품명·규격·재질·수량 한 줄씩", template="{품명} [{가로}*{세로}*{높이}] {재질} {수량}"), + FormatSpec(name="열을 쉼표로 이어서 한 줄씩", template="{1}, {2}, {3}"), + FormatSpec(name="번호 매기기", template="{#}. {1}"), +] + +PRESETS_VERSION = 1 + + +def dump_presets(presets: list[FormatSpec]) -> str: + return json.dumps({"version": PRESETS_VERSION, "presets": [p.to_dict() for p in presets]}, + ensure_ascii=False, indent=2) + + +def load_presets(text: str) -> list[FormatSpec]: + if not text or not text.strip(): + return [] + try: + obj = json.loads(text) + except json.JSONDecodeError: + return [] + items = obj.get("presets", []) if isinstance(obj, dict) else obj + out = [] + for it in items: + if isinstance(it, dict): + out.append(FormatSpec.from_dict(it)) + return out + + +HELP_TEXT = """\ +{ } 가 들어 있는 줄은 엑셀의 한 행마다 반복되고, 그 앞뒤 줄은 한 번만 나옵니다. +첫 행이 열 이름(품명, 규격 …)이면 자동으로 건너뛰고, 아니면 전부 데이터로 넣습니다. +헤더 없이 데이터만 복사해도 {품명} 같은 이름을 쓰려면, 왼쪽 "열 이름" 칸에 시트의 열 순서를 +한 번 저장해 두세요 (헤더 행을 붙여넣고 "첫 행에서 가져오기"). + + 11/5일 입고요청 ← 머리말 (한 번) + {품명} [{가로}*{세로}*{높이}] {수량}개 ← 행마다 반복 + 오전입고 바랍니다. ← 꼬리말 (한 번) + +빈 셀 처리 + 빈 셀은 옆의 공백 하나와 함께 사라집니다. + {가로}*{세로} 처럼 자리표시자 사이의 구분 기호는 한쪽이 비면 같이 사라집니다. + [ ] 로 묶은 부분은 안의 자리표시자가 전부 비면 통째로 사라집니다. 예: [{두께}t] + 헤더가 두 줄(규격 → 두께·가로·세로·높이)이면 아래 줄 이름으로 참조합니다. + +반복 줄이 여러 줄이어도 되고, 끝에 빈 줄을 두면 행 사이가 띄어집니다. +빈 셀은 옆의 공백 하나와 함께 사라져 공백이 두 번 생기지 않습니다. + +자리표시자 + {열이름} 열 이름으로 참조 (예: {품명}, {수량}) + {1} {2} … 열 번호로 참조 (열 이름이 없어도 사용 가능) + {#} 행 번호 (1부터), {행수} 전체 행 수, {오늘} 오늘 날짜 (11/5 형식) + {{ }} [[ ]] 중괄호·대괄호를 글자 그대로 넣을 때 + +필터 (| 로 이어서, 여러 개 가능) + {금액|comma} 1234567 → 1,234,567 + {금액|nocomma} 1,234 → 1234 + {이름|trim} 앞뒤 공백 제거 + {코드|upper} {코드|lower} + {비고|default:없음} 비어 있으면 대신 쓸 값 + {이름|ljust:10} {금액|rjust:12} {번호|zfill:5} + {비고|replace:a,b} a 를 b 로 바꿈 + {메모|oneline} 셀 안의 줄바꿈·연속 공백을 한 칸으로 + {값|quote} 큰따옴표로 감싸기 +""" diff --git a/excelpaster/gui.py b/excelpaster/gui.py new file mode 100644 index 0000000..43d7029 --- /dev/null +++ b/excelpaster/gui.py @@ -0,0 +1,920 @@ +"""엑셀 → 텍스트 양식 변환 데스크톱 앱 (PySide6).""" + +from __future__ import annotations + +import sys +from pathlib import Path + +from PySide6.QtCore import QEvent, QPoint, QRect, QSettings, QSize, Qt, QThread, QTimer, QUrl, Signal +from PySide6.QtGui import QAction, QDesktopServices, QFont, QFontDatabase, QGuiApplication, QIcon, QKeySequence +from PySide6.QtWidgets import ( + QApplication, + QCheckBox, + QComboBox, + QFileDialog, + QFrame, + QHBoxLayout, + QInputDialog, + QLabel, + QLayout, + QLineEdit, + QMainWindow, + QMessageBox, + QPlainTextEdit, + QProgressDialog, + QPushButton, + QSplitter, + QStackedWidget, + QTableWidget, + QTableWidgetItem, + QToolBar, + QToolButton, + QVBoxLayout, + QWidget, +) + +from excelpaster import core, updater +from excelpaster._version import __version__ +from excelpaster.core import BUILTIN_PRESETS, FormatSpec +from masker import theme + +APP_NAME = "Excel Paster" +ORG_NAME = "LocalTools" +MAX_PREVIEW_CELLS = 200_000 # 이보다 큰 표는 미리보기만 생략 (복사는 됨) +MAX_GRID_ROWS = 500 # 왼쪽 격자 표에 보여 줄 최대 행 수 + + +def _extra_stylesheet(t: dict[str, str]) -> str: + return f""" + QPlainTextEdit, QLineEdit, QComboBox {{ + background: {t['panel']}; border: 1px solid {t['border']}; border-radius: 7px; + padding: 6px 8px; selection-background-color: {t['accent']}; + selection-color: {t['accent_fg']}; }} + QPlainTextEdit:focus, QLineEdit:focus, QComboBox:focus {{ border: 1px solid {t['accent']}; }} + QPlainTextEdit[readOnly="true"] {{ background: {t['canvas']}; }} + QTableWidget {{ background: {t['panel']}; border: 1px solid {t['border']}; border-radius: 7px; + gridline-color: {t['border']}; selection-background-color: {t['selected']}; + selection-color: {t['text']}; outline: none; }} + QHeaderView::section {{ background: {t['bg']}; color: {t['muted']}; border: none; + border-right: 1px solid {t['border']}; border-bottom: 1px solid {t['border']}; + padding: 4px 6px; font-weight: 600; }} + QTableCornerButton::section {{ background: {t['bg']}; border: none; }} + QFrame#dropzone:hover {{ border-color: {t['accent']}; }} + QPushButton#update {{ background: {t['accent']}; color: {t['accent_fg']}; border: none; + border-radius: 6px; padding: 3px 10px; font-weight: 600; }} + QComboBox::drop-down {{ border: none; width: 22px; }} + QComboBox QAbstractItemView {{ background: {t['panel']}; border: 1px solid {t['border']}; + selection-background-color: {t['selected']}; selection-color: {t['text']}; outline: none; }} + QToolButton#chip {{ background: {t['selected']}; color: {t['text']}; border: none; + border-radius: 10px; padding: 3px 9px; font-size: 12px; }} + QToolButton#chip:hover {{ background: {t['accent']}; color: {t['accent_fg']}; }} + QLabel#warn {{ color: {t['danger']}; }} + QLabel#ok {{ color: {t['muted']}; }} + QLabel#field {{ color: {t['muted']}; font-size: 12px; }} + """ + + +class _CheckThread(QThread): + """백그라운드에서 최신 릴리스 조회.""" + done = Signal(object) # updater.Release | None + failed = Signal(str) + + def run(self) -> None: + try: + self.done.emit(updater.fetch_latest()) + except updater.UpdateError as e: + self.failed.emit(str(e)) + except Exception as e: # noqa: BLE001 + self.failed.emit(f"{type(e).__name__}: {e}") + + +class _DownloadThread(QThread): + """새 버전 다운로드 + 체크섬 검증.""" + progress = Signal(int, int) + done = Signal(object) # Path + failed = Signal(str) + + def __init__(self, release: updater.Release) -> None: + super().__init__() + self._release = release + + def run(self) -> None: + try: + path = updater.download_and_verify(self._release, lambda got, total: self.progress.emit(got, total)) + self.done.emit(path) + except updater.UpdateError as e: + self.failed.emit(str(e)) + except Exception as e: # noqa: BLE001 + self.failed.emit(f"{type(e).__name__}: {e}") + + +class FlowLayout(QLayout): + """줄바꿈되는 가로 배치 (Qt 예제 기반). 열 이름 칩 표시용.""" + + def __init__(self, parent=None, spacing: int = 6) -> None: + super().__init__(parent) + self._items = [] + self._space = spacing + self.setContentsMargins(0, 0, 0, 0) + + def addItem(self, item) -> None: # noqa: N802 + self._items.append(item) + + def count(self) -> int: + return len(self._items) + + def itemAt(self, i): # noqa: N802 + return self._items[i] if 0 <= i < len(self._items) else None + + def takeAt(self, i): # noqa: N802 + return self._items.pop(i) if 0 <= i < len(self._items) else None + + def clear(self) -> None: + while self._items: + it = self._items.pop() + w = it.widget() + if w is not None: + w.hide() # deleteLater 가 처리되기 전까지 화면에 남지 않도록 + w.setParent(None) + w.deleteLater() + + def expandingDirections(self): # noqa: N802 + return Qt.Orientation(0) + + def hasHeightForWidth(self) -> bool: # noqa: N802 + return True + + def heightForWidth(self, w: int) -> int: # noqa: N802 + return self._layout(QRect(0, 0, w, 0), dry=True) + + def setGeometry(self, rect: QRect) -> None: # noqa: N802 + super().setGeometry(rect) + self._layout(rect, dry=False) + + def sizeHint(self) -> QSize: # noqa: N802 + return self.minimumSize() + + def minimumSize(self) -> QSize: # noqa: N802 + s = QSize() + for it in self._items: + s = s.expandedTo(it.minimumSize()) + return s + + def _layout(self, rect: QRect, dry: bool) -> int: + x, y, line_h = rect.x(), rect.y(), 0 + for it in self._items: + w, h = it.sizeHint().width(), it.sizeHint().height() + if x + w > rect.right() + 1 and line_h > 0: + x, y, line_h = rect.x(), y + line_h + self._space, 0 + if not dry: + it.setGeometry(QRect(QPoint(x, y), it.sizeHint())) + x += w + self._space + line_h = max(line_h, h) + return y + line_h - rect.y() + + +class MainWindow(QMainWindow): + def __init__(self) -> None: + super().__init__() + self.setWindowTitle(f"{APP_NAME} {__version__}") + self.resize(1240, 760) + self._latest: updater.Release | None = None + self._threads: list[QThread] = [] + self.settings = QSettings(ORG_NAME, APP_NAME) + self.table: core.Table = [] + self.user_presets: list[FormatSpec] = core.load_presets(self.settings.value("presets", "", str)) + self._last_result = "" + self._last_imported = "" + self._loading = False + + self._debounce = QTimer(self) + self._debounce.setSingleShot(True) + self._debounce.setInterval(120) + self._debounce.timeout.connect(self._update_output) + + self._build_actions() + self._build_ui() + self._apply_theme() + QGuiApplication.styleHints().colorSchemeChanged.connect(lambda _: self._apply_theme()) + self._restore_state() + self._reload_preset_combo() + if self.settings.value("check_updates", True, bool): + QTimer.singleShot(1500, lambda: self._check_updates(silent=True)) + self.paste_hint.setFocus() + + # ------------------------------------------------------------ UI + + @staticmethod + def _heading(text: str) -> QLabel: + lab = QLabel(text) + lab.setObjectName("heading") + return lab + + @staticmethod + def _field(text: str) -> QLabel: + lab = QLabel(text) + lab.setObjectName("field") + return lab + + @staticmethod + def _mono() -> QFont: + f = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont) + f.setPointSize(max(f.pointSize(), 10)) + return f + + def _build_actions(self) -> None: + def act(text, slot, shortcut=None, tip=None): + a = QAction(text, self) + a.triggered.connect(slot) + if shortcut: + a.setShortcut(QKeySequence(shortcut)) + if tip: + a.setToolTip(f"{tip} ({a.shortcut().toString()})" if shortcut else tip) + return a + + self.act_paste = act("클립보드 가져오기", self._paste_clipboard, "Ctrl+Shift+V", + "엑셀에서 복사한 내용을 입력칸에 넣기") + self.act_copy = act("결과 복사", self._copy_result, "Ctrl+Shift+C", "변환 결과를 클립보드로") + self.act_clear = act("입력 지우기", self._clear_input, "Ctrl+L") + self.act_save_preset = act("프리셋 저장…", self._save_preset, "Ctrl+S") + self.act_delete_preset = act("프리셋 삭제", self._delete_preset) + self.act_export = act("프리셋 내보내기…", self._export_presets) + self.act_import = act("프리셋 가져오기…", self._import_presets) + self.act_help = act("자리표시자 도움말", self._show_help, "F1") + self.act_check_update = act("업데이트 확인…", lambda: self._check_updates(silent=False)) + self.act_auto_update = QAction("시작할 때 업데이트 확인", self) + self.act_auto_update.setCheckable(True) + self.act_auto_update.setChecked(self.settings.value("check_updates", True, bool)) + self.act_auto_update.toggled.connect(lambda v: self.settings.setValue("check_updates", v)) + self.act_about = act("정보", self._show_about) + self.act_quit = act("종료", self.close, "Ctrl+Q") + + self.toolbar = QToolBar("도구") + self.toolbar.setMovable(False) + self.toolbar.setIconSize(QSize(18, 18)) + self.toolbar.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon) + for a in (self.act_paste, self.act_copy): + self.toolbar.addAction(a) + self.toolbar.addSeparator() + self.toolbar.addAction(self.act_clear) + self.toolbar.addSeparator() + self.toolbar.addAction(self.act_help) + self.addToolBar(self.toolbar) + + m = self.menuBar().addMenu("파일") + for a in (self.act_paste, self.act_copy, self.act_clear): + m.addAction(a) + m.addSeparator() + m.addAction(self.act_quit) + m = self.menuBar().addMenu("프리셋") + for a in (self.act_save_preset, self.act_delete_preset): + m.addAction(a) + m.addSeparator() + for a in (self.act_export, self.act_import): + m.addAction(a) + m = self.menuBar().addMenu("도움말") + m.addAction(self.act_help) + m.addSeparator() + m.addAction(self.act_check_update) + m.addAction(self.act_auto_update) + m.addSeparator() + m.addAction(self.act_about) + + def _build_ui(self) -> None: + # 1. 입력: 복사한 내용을 엑셀처럼 격자 표로 보여 준다 (붙여넣기는 Ctrl+V 또는 안내 화면 클릭) + self._raw = "" + self.grid = QTableWidget() + self.grid.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers) + self.grid.setSelectionMode(QTableWidget.SelectionMode.NoSelection) + self.grid.setAlternatingRowColors(False) + self.grid.setWordWrap(False) + self.grid.verticalHeader().setDefaultSectionSize(24) + self.grid.horizontalHeader().setHighlightSections(False) + self.grid.horizontalHeader().setStretchLastSection(False) + self.grid.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + self.grid.installEventFilter(self) + + self.paste_hint = QFrame() + self.paste_hint.setObjectName("dropzone") + self.paste_hint.setCursor(Qt.CursorShape.PointingHandCursor) + self.paste_hint.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + self.paste_hint.installEventFilter(self) + hint_lay = QVBoxLayout(self.paste_hint) + hint_lay.setAlignment(Qt.AlignmentFlag.AlignCenter) + hint_title = QLabel("엑셀에서 복사한 뒤 Ctrl+V") + hint_title.setObjectName("welcomeTitle") + hint_title.setAlignment(Qt.AlignmentFlag.AlignCenter) + hint_sub = QLabel("또는 이 칸을 클릭하면 클립보드 내용을 가져옵니다.\n" + "창이 활성화될 때 자동으로 가져오는 옵션이 기본으로 켜져 있습니다.") + hint_sub.setObjectName("hint") + hint_sub.setAlignment(Qt.AlignmentFlag.AlignCenter) + hint_lay.addWidget(hint_title) + hint_lay.addWidget(hint_sub) + + self.input = QStackedWidget() + self.input.addWidget(self.paste_hint) + self.input.addWidget(self.grid) + self.input_status = QLabel("") + self.input_status.setObjectName("ok") + self.input_status.setWordWrap(True) + # 열 이름: 헤더 없이 데이터만 복사해도 {품명} 같은 이름을 쓸 수 있도록 한 번 저장해 둠 + self.col_names = QLineEdit() + self.col_names.setPlaceholderText("비어 있으면 첫 행이 열 이름일 때만 이름으로 참조 가능") + self.col_names.setToolTip("시트의 열 순서대로 쉼표로 구분. 빈 열은 비워 둠 (예: 품명, 규격, , , , 재질, 수량)") + self.col_names.textChanged.connect(self._on_col_names_changed) + self.btn_grab_header = QPushButton("첫 행에서 가져오기") + self.btn_grab_header.setToolTip("지금 붙여넣은 내용의 첫 행을 열 이름으로 저장") + self.btn_grab_header.clicked.connect(self._grab_header) + col_row = QHBoxLayout() + col_row.addWidget(self.col_names, 1) + col_row.addWidget(self.btn_grab_header) + self.chk_skip_blank = QCheckBox("빈 행 건너뛰기") + self.chk_skip_blank.setChecked(True) + self.chk_skip_blank.toggled.connect(self._on_spec_changed) + self.chk_auto = QCheckBox("창이 활성화되면 클립보드 자동 가져오기") + self.chk_auto.setToolTip("엑셀에서 복사하고 이 창으로 돌아오면 바로 입력칸에 들어갑니다.") + self.chk_auto.toggled.connect(lambda v: self.settings.setValue("auto_paste", v)) + + left = QVBoxLayout() + left.setContentsMargins(12, 10, 6, 12) + left.setSpacing(8) + left.addWidget(self._heading("1. 엑셀에서 복사한 내용")) + left.addWidget(self.input, 1) + left.addWidget(self.input_status) + left.addWidget(self._field("열 이름 (헤더 없이 복사할 때 사용, 한 번만 저장)")) + left.addLayout(col_row) + left.addWidget(self.chk_skip_blank) + left.addWidget(self.chk_auto) + left_w = QWidget() + left_w.setLayout(left) + + # 2. 양식: 템플릿 글상자 하나 + self.preset_combo = QComboBox() + self.preset_combo.currentIndexChanged.connect(self._on_preset_selected) + self.btn_save_preset = QPushButton("저장…") + self.btn_save_preset.setToolTip("지금 템플릿을 이름 붙여 저장 (Ctrl+S)") + self.btn_save_preset.clicked.connect(self._save_preset) + self.btn_del_preset = QPushButton("삭제") + self.btn_del_preset.setObjectName("danger") + self.btn_del_preset.clicked.connect(self._delete_preset) + preset_row = QHBoxLayout() + preset_row.addWidget(self.preset_combo, 1) + preset_row.addWidget(self.btn_save_preset) + preset_row.addWidget(self.btn_del_preset) + + self.chips_box = QWidget() + self.chips = FlowLayout(self.chips_box) + self.chips_hint = self._field("열 이름을 클릭하면 템플릿 커서 위치에 들어갑니다") + + self.template = QPlainTextEdit() + self.template.setFont(self._mono()) + self.template.setPlaceholderText( + "원하는 양식을 그대로 적으세요. { } 가 든 줄만 엑셀 행마다 반복되고\n" + "나머지 줄은 한 번만 나옵니다.\n\n" + "예)\n" + "11/5일 입고요청\n" + "{품명} [{가로}*{세로}*{높이}] {재질} {수량}개\n" + "오전입고 바랍니다.\n\n" + "{열이름} 또는 {1} {2} 로 셀 값을 넣습니다. 자세한 것은 F1.") + self.template.textChanged.connect(self._on_spec_changed) + self.template_warn = QLabel("") + self.template_warn.setObjectName("warn") + self.template_warn.setWordWrap(True) + + mid = QVBoxLayout() + mid.setContentsMargins(6, 10, 6, 12) + mid.setSpacing(8) + mid.addWidget(self._heading("2. 출력 양식 (템플릿)")) + mid.addWidget(self.chips_box) + mid.addWidget(self.chips_hint) + mid.addWidget(self.template, 1) + mid.addWidget(self.template_warn) + mid.addWidget(self._field("저장된 템플릿")) + mid.addLayout(preset_row) + mid_w = QWidget() + mid_w.setLayout(mid) + mid_w.setMinimumWidth(320) + + # 3. 결과 + self.output = QPlainTextEdit() + self.output.setReadOnly(True) + self.output.setFont(self._mono()) + self.output.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap) + self.output.setPlaceholderText("변환 결과가 여기에 바로 표시됩니다.") + self.output_status = QLabel("") + self.output_status.setObjectName("ok") + self.btn_copy = QPushButton("결과 복사 (Ctrl+Shift+C)") + self.btn_copy.setObjectName("primary") + self.btn_copy.setMinimumHeight(40) + self.btn_copy.clicked.connect(self._copy_result) + self.chk_minimize = QCheckBox("복사한 뒤 창 최소화") + self.chk_minimize.toggled.connect(lambda v: self.settings.setValue("minimize_after_copy", v)) + + right = QVBoxLayout() + right.setContentsMargins(6, 10, 12, 12) + right.setSpacing(8) + right.addWidget(self._heading("3. 결과")) + right.addWidget(self.output, 1) + right.addWidget(self.output_status) + right.addWidget(self.chk_minimize) + right.addWidget(self.btn_copy) + right_w = QWidget() + right_w.setLayout(right) + + self.splitter = QSplitter() + for w in (left_w, mid_w, right_w): + self.splitter.addWidget(w) + self.splitter.setCollapsible(self.splitter.count() - 1, False) + self.splitter.setStretchFactor(0, 3) + self.splitter.setStretchFactor(1, 3) + self.splitter.setStretchFactor(2, 4) + self.setCentralWidget(self.splitter) + + self.status_left = QLabel("엑셀에서 복사 → 붙여넣기 → 결과 복사") + self.status_right = QLabel(f"v{__version__}") + self.status_right.setObjectName("hint") + self.btn_update = QPushButton("") + self.btn_update.setObjectName("update") + self.btn_update.setCursor(Qt.CursorShape.PointingHandCursor) + self.btn_update.clicked.connect(self._start_update) + self.btn_update.hide() + self.statusBar().addWidget(self.status_left, 1) + self.statusBar().addPermanentWidget(self.btn_update) + self.statusBar().addPermanentWidget(self.status_right) + + def _apply_theme(self) -> None: + t = theme.tokens() + QApplication.instance().setPalette(theme.palette(t)) + self.setStyleSheet(theme.stylesheet(t) + _extra_stylesheet(t)) + c = t["text"] + self.act_paste.setIcon(theme.icon("open", c)) + self.act_copy.setIcon(theme.icon("save", c)) + self.act_clear.setIcon(theme.icon("trash", c)) + self.act_help.setIcon(theme.icon("shield", c)) + + # ------------------------------------------------------------ 상태 저장/복원 + + def _restore_state(self) -> None: + s = self.settings + self.chk_auto.setChecked(s.value("auto_paste", True, bool)) + self.col_names.setText(s.value("column_names", "", str)) + self.chk_minimize.setChecked(s.value("minimize_after_copy", False, bool)) + geo = s.value("geometry") + if geo: + self.restoreGeometry(geo) + sizes = s.value("splitter") + if sizes: + self.splitter.setSizes([int(x) for x in sizes]) + last = s.value("last_spec", "", str) + specs = core.load_presets(last) + self._load_spec(specs[0] if specs else BUILTIN_PRESETS[0]) + + def _current_spec(self) -> FormatSpec: + return FormatSpec( + name="", + template=self.template.toPlainText(), + header_row=None, # 첫 행이 열 이름인지 자동 판단 + skip_blank_rows=self.chk_skip_blank.isChecked(), + ) + + def _load_spec(self, spec: FormatSpec) -> None: + self._loading = True + try: + self.template.setPlainText(spec.template) + self.chk_skip_blank.setChecked(spec.skip_blank_rows) + finally: + self._loading = False + self._on_spec_changed() + + def closeEvent(self, event) -> None: # noqa: N802 + s = self.settings + s.setValue("geometry", self.saveGeometry()) + s.setValue("splitter", self.splitter.sizes()) + s.setValue("last_spec", core.dump_presets([self._current_spec()])) + s.setValue("presets", core.dump_presets(self.user_presets)) + event.accept() + + def event(self, e) -> bool: + if e.type() == QEvent.Type.WindowActivate and self.chk_auto.isChecked(): + QTimer.singleShot(0, self._auto_paste) + return super().event(e) + + # ------------------------------------------------------------ 입력 + + def _auto_paste(self) -> None: + text = QGuiApplication.clipboard().text() + if not text or text == self._last_imported or text == self._last_result: + return + if "\t" not in text and "\n" not in text.strip(): + return # 표 모양이 아니면 건드리지 않음 + self._set_input(text) + self.status_left.setText("클립보드에서 자동으로 가져왔습니다") + + def _paste_clipboard(self) -> None: + text = QGuiApplication.clipboard().text() + if not text: + self.status_left.setText("클립보드에 텍스트가 없습니다") + return + self._set_input(text) + self.status_left.setText("클립보드에서 가져왔습니다") + + def _set_input(self, text: str) -> None: + self._last_imported = text + self._raw = text + self._on_input_changed() + + def _clear_input(self) -> None: + self._raw = "" + self._last_imported = "" + self._on_input_changed() + + def eventFilter(self, obj, event) -> bool: # noqa: N802 + # 격자 표나 안내 화면에서 Ctrl+V → 클립보드 가져오기, 안내 화면 클릭도 같은 동작 + if obj in (self.grid, self.paste_hint): + if event.type() == QEvent.Type.KeyPress and event.matches(QKeySequence.StandardKey.Paste): + self._paste_clipboard() + return True + if obj is self.paste_hint and event.type() == QEvent.Type.MouseButtonRelease: + self._paste_clipboard() + return True + return super().eventFilter(obj, event) + + def _fill_grid(self, headers: list[str], data: core.Table, is_header: bool) -> None: + """복사한 내용을 격자 표로. 열 머리글은 인식된 열 이름(없으면 번호).""" + if not self.table: + self.input.setCurrentWidget(self.paste_hint) + self.grid.clear() + self.grid.setRowCount(0) + self.grid.setColumnCount(0) + return + self.input.setCurrentWidget(self.grid) + rows = data[:MAX_GRID_ROWS] + self.grid.setUpdatesEnabled(False) + try: + self.grid.clear() + self.grid.setColumnCount(len(headers)) + self.grid.setHorizontalHeaderLabels(core.column_names(headers)) + self.grid.setRowCount(len(rows)) + for r, row in enumerate(rows): + for c, val in enumerate(row): + item = QTableWidgetItem(val.replace("\r\n", " ⏎ ").replace("\n", " ⏎ ")) + item.setToolTip(val) if ("\n" in val or len(val) > 40) else None + self.grid.setItem(r, c, item) + self.grid.resizeColumnsToContents() + for c in range(len(headers)): + self.grid.setColumnWidth(c, min(max(self.grid.columnWidth(c), 48), 260)) + finally: + self.grid.setUpdatesEnabled(True) + + def _known_headers(self) -> list[str]: + return core.parse_column_names(self.col_names.text()) + + def _resolve(self) -> tuple[list[str], core.Table, bool]: + return core.resolve_table(self.table, self._current_spec(), self._known_headers()) + + def _on_input_changed(self) -> None: + self.table = core.parse_table(self._raw) + self.btn_grab_header.setEnabled(bool(self.table)) + self._refresh_chips() + self._debounce.start() + + def _on_col_names_changed(self) -> None: + self.settings.setValue("column_names", self.col_names.text()) + self._on_spec_changed() + + def _grab_header(self) -> None: + if not self.table: + return + rows = core.header_row_count(self.table, [], self.template.toPlainText()) or 1 + names = core.merged_header_names(self.table, rows) + while names and not names[-1]: + names.pop() + self.col_names.setText(", ".join(names)) + what = "첫 두 행을 합쳐" if rows == 2 else "첫 행을" + self.status_left.setText(f"{what} 열 이름으로 저장했습니다. 이제 데이터만 복사해도 이름으로 참조됩니다.") + + def _update_input_status(self, header_rows: int, data_rows: int) -> None: + if not self.table: + self.input_status.setText("") + return + rows, cols = len(self.table), len(self.table[0]) + if header_rows == 2: + how = "첫 두 행은 열 이름으로 인식해 건너뜀" + elif header_rows: + how = "첫 행은 열 이름으로 인식해 건너뜀" + else: + how = "모든 행을 데이터로 처리" + more = f" (표에는 {MAX_GRID_ROWS}행까지만 표시)" if data_rows > MAX_GRID_ROWS else "" + self.input_status.setText(f"{rows}행 × {cols}열 감지 · {how} · 데이터 {data_rows}행{more}") + + # ------------------------------------------------------------ 양식 + + def _on_spec_changed(self) -> None: + if self._loading: + return + self._refresh_chips() + self._debounce.start() + + def _refresh_chips(self) -> None: + self.chips.clear() + headers, _, _ = self._resolve() + names = core.column_names(headers) + for name in names: + b = QToolButton() + b.setObjectName("chip") + b.setText(name) + b.setToolTip(f"{{{name}}} 삽입") + b.setCursor(Qt.CursorShape.PointingHandCursor) + b.clicked.connect(lambda _=False, n=name: self._insert_placeholder(n)) + self.chips.addWidget(b) + for name, tip in (("#", "행 번호"), ("행수", "전체 행 수")): + b = QToolButton() + b.setObjectName("chip") + b.setText(name) + b.setToolTip(tip) + b.setCursor(Qt.CursorShape.PointingHandCursor) + b.clicked.connect(lambda _=False, n=name: self._insert_placeholder(n)) + self.chips.addWidget(b) + self.chips_hint.setText("열 이름을 클릭하면 템플릿 커서 위치에 들어갑니다" if names + else "먼저 왼쪽에 엑셀 내용을 붙여넣으세요") + + def _insert_placeholder(self, name: str) -> None: + self.template.insertPlainText("{" + name + "}") + self.template.setFocus() + + # ------------------------------------------------------------ 출력 + + def _update_output(self) -> None: + spec = self._current_spec() + self.template_warn.setText("") + if not self.table: + self.output.setPlainText("") + self.output_status.setText("") + self.input_status.setText("") + self._fill_grid([], [], False) + self.btn_copy.setEnabled(False) + return + headers, data, is_header = core.resolve_table(self.table, spec, self._known_headers()) + self._update_input_status(is_header, len(data)) + self._fill_grid(headers, data, is_header) + unknown = core.unknown_placeholders(spec.template, headers) + if unknown: + hint = "" if self._known_headers() or is_header else " — 헤더 없이 복사했다면 왼쪽 '열 이름'을 저장하세요" + self.template_warn.setText("알 수 없는 자리표시자: " + ", ".join("{" + u + "}" for u in unknown) + hint) + try: + result = core.render(self.table, spec, self._known_headers()) + except core.TemplateError as e: + self.template_warn.setText(str(e)) + self.output.setPlainText("") + self.output_status.setText("") + self.btn_copy.setEnabled(False) + return + self._result = result + cells = len(self.table) * len(self.table[0]) + if cells > MAX_PREVIEW_CELLS: + self.output.setPlainText(result[:20000] + "\n…(미리보기 생략, 복사는 전체가 됩니다)") + else: + self.output.setPlainText(result) + self.output_status.setText(f"{len(data)}행 변환 · {len(result):,}자") + self.btn_copy.setEnabled(bool(result)) + + def _copy_result(self) -> None: + result = getattr(self, "_result", "") + if not result: + self.status_left.setText("복사할 결과가 없습니다") + return + QGuiApplication.clipboard().setText(result) + self._last_result = result + self.status_left.setText(f"결과를 클립보드에 복사했습니다 ({len(result):,}자) — 원하는 곳에 Ctrl+V") + if self.chk_minimize.isChecked(): + self.showMinimized() + + # ------------------------------------------------------------ 프리셋 + + def _reload_preset_combo(self, select_name: str | None = None) -> None: + self._loading = True + try: + self.preset_combo.clear() + self.preset_combo.addItem("(저장된 템플릿 선택)", None) + for i, p in enumerate(self.user_presets): + self.preset_combo.addItem(f"★ {p.name}", ("user", i)) + for i, p in enumerate(BUILTIN_PRESETS): + self.preset_combo.addItem(p.name, ("builtin", i)) + if select_name is not None: + for i in range(self.preset_combo.count()): + d = self.preset_combo.itemData(i) + if d and d[0] == "user" and self.user_presets[d[1]].name == select_name: + self.preset_combo.setCurrentIndex(i) + break + finally: + self._loading = False + self._update_preset_buttons() + + def _update_preset_buttons(self) -> None: + d = self.preset_combo.currentData() + self.btn_del_preset.setEnabled(bool(d) and d[0] == "user") + self.act_delete_preset.setEnabled(bool(d) and d[0] == "user") + + def _on_preset_selected(self) -> None: + if self._loading: + return + d = self.preset_combo.currentData() + self._update_preset_buttons() + if not d: + return + spec = self.user_presets[d[1]] if d[0] == "user" else BUILTIN_PRESETS[d[1]] + self._load_spec(spec) + self.status_left.setText(f"프리셋 적용: {spec.name}") + + def _save_preset(self) -> None: + d = self.preset_combo.currentData() + default = self.user_presets[d[1]].name if d and d[0] == "user" else "" + name, ok = QInputDialog.getText(self, "프리셋 저장", "프리셋 이름:", text=default) + name = name.strip() + if not ok or not name: + return + spec = self._current_spec().copy(name=name) + for i, p in enumerate(self.user_presets): + if p.name == name: + self.user_presets[i] = spec + break + else: + self.user_presets.append(spec) + self.settings.setValue("presets", core.dump_presets(self.user_presets)) + self._reload_preset_combo(select_name=name) + self.status_left.setText(f"프리셋 저장: {name}") + + def _delete_preset(self) -> None: + d = self.preset_combo.currentData() + if not d or d[0] != "user": + return + name = self.user_presets[d[1]].name + if QMessageBox.question(self, "프리셋 삭제", f"'{name}' 프리셋을 삭제할까요?") != QMessageBox.StandardButton.Yes: + return + del self.user_presets[d[1]] + self.settings.setValue("presets", core.dump_presets(self.user_presets)) + self._reload_preset_combo() + self.status_left.setText(f"프리셋 삭제: {name}") + + def _export_presets(self) -> None: + if not self.user_presets: + QMessageBox.information(self, "프리셋 내보내기", "저장된 프리셋이 없습니다.") + return + path, _ = QFileDialog.getSaveFileName(self, "프리셋 내보내기", "excel-paster-presets.json", "JSON (*.json)") + if not path: + return + Path(path).write_text(core.dump_presets(self.user_presets), encoding="utf-8") + self.status_left.setText(f"프리셋 {len(self.user_presets)}개 내보냄: {path}") + + def _import_presets(self) -> None: + path, _ = QFileDialog.getOpenFileName(self, "프리셋 가져오기", "", "JSON (*.json)") + if not path: + return + try: + loaded = core.load_presets(Path(path).read_text(encoding="utf-8")) + except OSError as e: + QMessageBox.warning(self, "프리셋 가져오기", f"파일을 읽을 수 없습니다.\n{e}") + return + if not loaded: + QMessageBox.warning(self, "프리셋 가져오기", "프리셋을 찾을 수 없는 파일입니다.") + return + names = {p.name for p in self.user_presets} + added = 0 + for p in loaded: + if not p.name: + continue + if p.name in names: + self.user_presets = [p if q.name == p.name else q for q in self.user_presets] + else: + self.user_presets.append(p) + names.add(p.name) + added += 1 + self.settings.setValue("presets", core.dump_presets(self.user_presets)) + self._reload_preset_combo() + self.status_left.setText(f"프리셋 {added}개 가져옴") + + # ------------------------------------------------------------ 업데이트 + + def _check_updates(self, silent: bool) -> None: + t = _CheckThread() + t.done.connect(lambda rel: self._on_update_checked(rel, silent)) + t.failed.connect(lambda msg: self._on_update_check_failed(msg, silent)) + t.finished.connect(lambda: self._threads.remove(t) if t in self._threads else None) + self._threads.append(t) + if not silent: + self.status_left.setText("업데이트 확인 중…") + t.start() + + def _on_update_checked(self, rel: updater.Release | None, silent: bool) -> None: + if rel is not None and updater.is_newer(rel.version): + self._latest = rel + self.btn_update.setText(f"새 버전 v{rel.version} — 업데이트") + self.btn_update.show() + self.status_left.setText(f"새 버전 v{rel.version} 이 있습니다. 오른쪽 아래 버튼으로 업데이트하세요.") + return + if not silent: + if rel is None: + QMessageBox.information(self, "업데이트 확인", "아직 배포된 버전이 없습니다.") + else: + QMessageBox.information(self, "업데이트 확인", f"최신 버전입니다. (v{__version__})") + self.status_left.setText(f"최신 버전입니다 (v{__version__})") + + def _on_update_check_failed(self, msg: str, silent: bool) -> None: + if silent: + self.status_right.setToolTip(f"업데이트 확인 실패: {msg}") + return + QMessageBox.warning(self, "업데이트 확인", f"확인하지 못했습니다.\n{msg}") + self.status_left.setText("업데이트 확인 실패") + + def _start_update(self) -> None: + rel = self._latest + if rel is None: + return + notes = rel.notes.strip() + text = f"v{__version__} → v{rel.version} 으로 업데이트할까요?\n\n받은 파일은 SHA-256 체크섬으로 검증한 뒤 교체합니다." + if sys.platform == "win32": + text += "\n교체를 위해 앱이 잠시 종료되었다가 자동으로 다시 실행됩니다." + box = QMessageBox(self) + box.setWindowTitle("업데이트") + box.setText(text) + if notes: + box.setDetailedText(notes) + box.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No) + box.button(QMessageBox.StandardButton.Yes).setText("업데이트") + box.button(QMessageBox.StandardButton.No).setText("나중에") + if box.exec() != QMessageBox.StandardButton.Yes: + return + if not rel.asset_url(): + QMessageBox.information(self, "업데이트", "이 운영체제용 파일이 없어 릴리스 페이지를 엽니다.") + QDesktopServices.openUrl(QUrl(rel.page_url)) + return + progress = QProgressDialog("새 버전을 받는 중…", "취소", 0, 100, self) + progress.setWindowTitle("업데이트") + progress.setWindowModality(Qt.WindowModality.WindowModal) + progress.setMinimumDuration(0) + progress.setValue(0) + t = _DownloadThread(rel) + + def on_progress(got: int, total: int) -> None: + if total: + progress.setMaximum(100) + progress.setValue(min(100, got * 100 // total)) + progress.setLabelText(f"새 버전을 받는 중… {got / 1048576:.1f} / {total / 1048576:.1f} MB") + else: + progress.setMaximum(0) + + def on_done(path) -> None: + progress.close() + try: + msg = updater.apply_update(path) + except updater.UpdateError as e: + QMessageBox.warning(self, "업데이트", str(e)) + return + QMessageBox.information(self, "업데이트", msg) + if sys.platform == "win32": + self.close() + + def on_failed(msg: str) -> None: + progress.close() + QMessageBox.warning(self, "업데이트 실패", msg) + + t.progress.connect(on_progress) + t.done.connect(on_done) + t.failed.connect(on_failed) + progress.canceled.connect(t.requestInterruption) + t.finished.connect(lambda: self._threads.remove(t) if t in self._threads else None) + self._threads.append(t) + t.start() + + def _show_about(self) -> None: + QMessageBox.about( + self, "Excel Paster 정보", + f"Excel Paster v{__version__}

" + "엑셀에서 복사한 표를 템플릿대로 텍스트로 바꿔 줍니다.
" + "모든 변환은 내 컴퓨터 안에서만 이루어집니다.

" + f"업데이트 확인은 GitHub Releases 에 버전만 조회합니다.
" + f'{updater.RELEASES_PAGE}', + ) + + # ------------------------------------------------------------ 도움말 + + def _show_help(self) -> None: + box = QMessageBox(self) + box.setWindowTitle("자리표시자 도움말") + box.setTextFormat(Qt.TextFormat.PlainText) + box.setFont(self._mono()) + box.setText(core.HELP_TEXT) + box.exec() + + +def main(argv: list[str] | None = None) -> int: + app = QApplication(argv if argv is not None else sys.argv) + app.setApplicationName(APP_NAME) + app.setOrganizationName(ORG_NAME) + app.setStyle("Fusion") + icon_path = Path(__file__).with_name("assets") / "icon.png" + if icon_path.exists(): + app.setWindowIcon(QIcon(str(icon_path))) + win = MainWindow() + win.show() + return app.exec() diff --git a/excelpaster/updater.py b/excelpaster/updater.py new file mode 100644 index 0000000..28f7e19 --- /dev/null +++ b/excelpaster/updater.py @@ -0,0 +1,227 @@ +"""GitHub Releases 기반 업데이트 확인·다운로드·교체. + +- 확인: https://api.github.com/repos//releases/latest 의 tag_name 과 현재 버전 비교 +- 다운로드: 플랫폼에 맞는 자산을 임시 파일로 받고 SHA256SUMS.txt 로 무결성 검증 +- 교체(Windows): 실행 중인 exe 는 지울 수 없으므로 작은 .cmd 스크립트가 앱 종료를 기다렸다가 + 파일을 바꿔치기하고 새 버전을 실행한다. macOS 는 dmg 를 받은 뒤 Finder 로 열어 준다. + +네트워크 접속은 이 모듈에서만 일어나며, 보내는 것은 버전 조회 요청뿐이다. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import subprocess +import sys +import tempfile +import urllib.request +from dataclasses import dataclass, field +from pathlib import Path +from typing import Callable + +from excelpaster._version import __version__ + +REPO = "Balragon/Local-PDF-Masking" +API_LATEST = f"https://api.github.com/repos/{REPO}/releases/latest" +RELEASES_PAGE = f"https://github.com/{REPO}/releases/latest" +ASSET_NAMES = { + "win32": "Excel-Paster-windows.exe", + "darwin": "Excel-Paster-macos-arm64.dmg", +} +CHECKSUMS_NAME = "SHA256SUMS.txt" +USER_AGENT = f"Excel-Paster/{__version__}" + + +@dataclass +class Release: + version: str # "1.2.3" + tag: str # "v1.2.3" + page_url: str + assets: dict[str, str] = field(default_factory=dict) # 파일 이름 → 다운로드 URL + notes: str = "" + + def asset_url(self, platform: str = sys.platform) -> str | None: + name = ASSET_NAMES.get(platform) + return self.assets.get(name) if name else None + + @property + def checksums_url(self) -> str | None: + return self.assets.get(CHECKSUMS_NAME) + + +class UpdateError(Exception): + pass + + +# ---------------------------------------------------------------- 버전 비교 + +def parse_version(text: str) -> tuple[int, ...]: + """'v1.2.3', '1.2.3-beta' → (1, 2, 3). 숫자 부분만 본다.""" + m = re.search(r"(\d+(?:\.\d+)*)", text or "") + if not m: + return (0,) + return tuple(int(x) for x in m.group(1).split(".")) + + +def is_newer(candidate: str, current: str = __version__) -> bool: + a, b = parse_version(candidate), parse_version(current) + n = max(len(a), len(b)) + return a + (0,) * (n - len(a)) > b + (0,) * (n - len(b)) + + +# ---------------------------------------------------------------- 네트워크 + +def _get(url: str, timeout: float, accept: str = "*/*") -> bytes: + req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept": accept}) + with urllib.request.urlopen(req, timeout=timeout) as resp: # noqa: S310 — https 고정 URL + return resp.read() + + +def parse_release(payload: dict) -> Release: + tag = str(payload.get("tag_name", "")) + assets = {a.get("name", ""): a.get("browser_download_url", "") for a in payload.get("assets", [])} + return Release( + version=".".join(str(x) for x in parse_version(tag)), + tag=tag, + page_url=payload.get("html_url") or RELEASES_PAGE, + assets={k: v for k, v in assets.items() if k and v}, + notes=payload.get("body") or "", + ) + + +def fetch_latest(timeout: float = 6.0) -> Release | None: + """최신 릴리스. 릴리스가 하나도 없으면 None. 네트워크 오류는 UpdateError.""" + try: + raw = _get(API_LATEST, timeout, accept="application/vnd.github+json") + except urllib.error.HTTPError as e: + if e.code == 404: + return None + raise UpdateError(f"업데이트 서버 응답 오류 ({e.code})") from e + except (urllib.error.URLError, OSError) as e: + raise UpdateError(f"업데이트 서버에 연결할 수 없습니다: {e.reason if hasattr(e, 'reason') else e}") from e + try: + return parse_release(json.loads(raw.decode("utf-8"))) + except (ValueError, AttributeError) as e: + raise UpdateError("업데이트 정보를 해석할 수 없습니다") from e + + +def parse_checksums(text: str) -> dict[str, str]: + """'해시 파일이름' 줄들 → {파일이름: 해시}. '*파일이름' 형식도 허용.""" + out: dict[str, str] = {} + for line in text.splitlines(): + parts = line.strip().split(None, 1) + if len(parts) == 2 and re.fullmatch(r"[0-9a-fA-F]{64}", parts[0]): + out[parts[1].strip().lstrip("*")] = parts[0].lower() + return out + + +def sha256_of(path: Path) -> str: + h = hashlib.sha256() + with open(path, "rb") as f: + for chunk in iter(lambda: f.read(1 << 20), b""): + h.update(chunk) + return h.hexdigest() + + +def download(url: str, dest: Path, progress: Callable[[int, int], None] | None = None, + timeout: float = 30.0) -> None: + """url → dest. progress(받은 바이트, 전체 바이트 또는 0).""" + req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT}) + try: + with urllib.request.urlopen(req, timeout=timeout) as resp, open(dest, "wb") as f: # noqa: S310 + total = int(resp.headers.get("Content-Length") or 0) + got = 0 + while True: + chunk = resp.read(1 << 16) + if not chunk: + break + f.write(chunk) + got += len(chunk) + if progress: + progress(got, total) + except (urllib.error.URLError, OSError) as e: + raise UpdateError(f"다운로드 실패: {e}") from e + + +def download_and_verify(release: Release, progress: Callable[[int, int], None] | None = None, + platform: str = sys.platform) -> Path: + """플랫폼 자산을 임시 폴더에 받고 SHA-256 을 검증해 경로를 돌려준다.""" + url = release.asset_url(platform) + name = ASSET_NAMES.get(platform) + if not url or not name: + raise UpdateError("이 운영체제용 파일이 릴리스에 없습니다") + if not release.checksums_url: + raise UpdateError("릴리스에 체크섬 파일(SHA256SUMS.txt)이 없어 검증할 수 없습니다") + try: + sums = parse_checksums(_get(release.checksums_url, 15).decode("utf-8", "replace")) + except (urllib.error.URLError, OSError) as e: + raise UpdateError(f"체크섬 파일을 받을 수 없습니다: {e}") from e + expected = sums.get(name) + if not expected: + raise UpdateError(f"체크섬 파일에 {name} 항목이 없습니다") + tmpdir = Path(tempfile.mkdtemp(prefix="excel-paster-update-")) + dest = tmpdir / name + download(url, dest, progress) + actual = sha256_of(dest) + if actual != expected: + dest.unlink(missing_ok=True) + raise UpdateError("받은 파일의 SHA-256 이 릴리스 체크섬과 다릅니다. 설치를 중단했습니다.") + return dest + + +# ---------------------------------------------------------------- 교체 + +def is_frozen() -> bool: + return bool(getattr(sys, "frozen", False)) + + +def current_executable() -> Path: + return Path(sys.executable).resolve() + + +def windows_swap_script(current_exe: Path, new_exe: Path, pids: list[int]) -> str: + """앱 종료를 기다렸다가 exe 를 바꿔치기하고 새 버전을 실행하는 cmd 스크립트.""" + waits = "\n".join( + f':wait{p}\ntasklist /FI "PID eq {p}" 2>nul | find "{p}" >nul && (timeout /t 1 /nobreak >nul & goto wait{p})' + for p in pids + ) + old = f"{current_exe}.old" + return ( + "@echo off\r\n" + + waits.replace("\n", "\r\n") + "\r\n" + f'if exist "{old}" del /f /q "{old}"\r\n' + f'move /y "{current_exe}" "{old}" >nul || (echo 교체 실패 & pause & exit /b 1)\r\n' + f'move /y "{new_exe}" "{current_exe}" >nul || (move /y "{old}" "{current_exe}" >nul & echo 교체 실패 & pause & exit /b 1)\r\n' + f'start "" "{current_exe}"\r\n' + f'del /f /q "{old}" >nul 2>&1\r\n' + 'del /f /q "%~f0" >nul 2>&1\r\n' + ) + + +def apply_update(new_file: Path, platform: str = sys.platform) -> str: + """새 파일을 설치 위치에 적용한다. 돌려주는 문자열은 사용자에게 보여 줄 안내. + + Windows: 교체 스크립트를 띄우고 호출자는 곧바로 앱을 종료해야 한다. + macOS: dmg 를 열어 주고 사용자가 끌어다 놓는다. + """ + if platform == "win32": + if not is_frozen(): + raise UpdateError("개발 환경(소스 실행)에서는 자동 교체를 하지 않습니다. 받은 파일: " + str(new_file)) + exe = current_executable() + pids = [os.getpid()] + try: + pids.append(os.getppid()) # PyInstaller onefile 은 부트로더(부모) + 본체(자식) + except Exception: # noqa: BLE001 + pass + script = Path(tempfile.gettempdir()) / "excel-paster-update.cmd" + script.write_text(windows_swap_script(exe, new_file, pids), encoding="cp949", errors="replace") + flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) | getattr(subprocess, "DETACHED_PROCESS", 0) + subprocess.Popen(["cmd.exe", "/c", str(script)], creationflags=flags, close_fds=True) # noqa: S603 + return "새 버전으로 교체하기 위해 앱을 종료합니다. 잠시 뒤 자동으로 다시 실행됩니다." + if platform == "darwin": + subprocess.Popen(["open", str(new_file)]) # noqa: S603, S607 + return "디스크 이미지를 열었습니다. Excel Paster 를 Applications 폴더로 끌어다 놓아 교체하세요." + return f"받은 파일: {new_file}" diff --git a/masker/gui.py b/masker/gui.py index 4e98852..e8138e5 100644 --- a/masker/gui.py +++ b/masker/gui.py @@ -732,16 +732,29 @@ def _save(self) -> None: ) if answer != QMessageBox.StandardButton.Yes: return + # 자동 탐지 등으로 들어온 아주 작은(1pt 미만) 영역은 저장을 막지 않도록 걸러 낸다 + regions = {p: [r for r in rs if r[2] - r[0] >= 1 and r[3] - r[1] >= 1] for p, rs in self.regions.items()} + regions = {p: rs for p, rs in regions.items() if rs} + if not regions: + QMessageBox.information(self, "영역 없음", "가릴 수 있는 크기의 영역이 없습니다.") + return progress = QProgressDialog("마스킹 적용 중…", None, 0, 0, self) progress.setWindowModality(Qt.WindowModality.WindowModal) progress.show() QApplication.processEvents() try: - redact_pdf(self.pdf_path, dst, self.regions, rasterize=self.rasterize.isChecked(), + redact_pdf(self.pdf_path, dst, regions, rasterize=self.rasterize.isChecked(), password=self.password) except Exception as exc: # noqa: BLE001 progress.close() - QMessageBox.critical(self, "저장 실패", f"저장 중 오류가 발생했습니다.\n{exc}") + import traceback + box = QMessageBox(self) + box.setIcon(QMessageBox.Icon.Critical) + box.setWindowTitle("저장 실패") + box.setText(f"저장 중 오류가 발생했습니다.\n{type(exc).__name__}: {exc}") + box.setInformativeText("'자세히' 내용을 복사해서 알려 주시면 원인을 찾는 데 도움이 됩니다.") + box.setDetailedText(traceback.format_exc()) + box.exec() return progress.close() self.status_left.setText(f"저장 완료: {dst}") diff --git a/paster_main.py b/paster_main.py new file mode 100644 index 0000000..8812e4e --- /dev/null +++ b/paster_main.py @@ -0,0 +1,6 @@ +import sys + +from excelpaster.gui import main + +if __name__ == "__main__": + sys.exit(main()) diff --git a/pdfmasker.spec b/pdfmasker.spec index 01ab9a9..4a872b5 100644 --- a/pdfmasker.spec +++ b/pdfmasker.spec @@ -3,6 +3,9 @@ import sys from pathlib import Path +sys.path.insert(0, str(Path(SPECPATH) / "scripts")) +from pyi_trim import trim_qt # noqa: E402 — 쓰지 않는 Qt 구성 요소 제거 + from PyInstaller.utils.hooks import collect_all APP_NAME = "PDF Masker" @@ -36,6 +39,7 @@ a = Analysis( "pymupdf4llm", "pymupdf_layout", "tkinter"], noarchive=False, ) +trim_qt(a) pyz = PYZ(a.pure) if sys.platform == "darwin": diff --git a/scripts/build.bat b/scripts/build.bat index eeb6790..59510f7 100644 --- a/scripts/build.bat +++ b/scripts/build.bat @@ -1,8 +1,9 @@ @echo off -REM Windows 로컬 빌드. 결과: dist\PDF Masker.exe +REM Windows 로컬 빌드. 결과: dist\PDF Masker.exe, dist\Excel Paster.exe cd /d "%~dp0\.." py -3 -m venv .venv-build || python -m venv .venv-build call .venv-build\Scripts\activate.bat pip install -q -r requirements.txt pyinstaller pillow pyinstaller --noconfirm --clean pdfmasker.spec +pyinstaller --noconfirm --clean excelpaster.spec echo 빌드 완료: dist\ diff --git a/scripts/build.sh b/scripts/build.sh index 24f0071..35a01cd 100755 --- a/scripts/build.sh +++ b/scripts/build.sh @@ -1,12 +1,14 @@ #!/usr/bin/env bash -# macOS / Linux 로컬 빌드. 결과: dist/PDF Masker.app (mac) 또는 dist/PDF Masker (linux) +# macOS / Linux 로컬 빌드. 결과: dist/PDF Masker.app, dist/Excel Paster.app (mac) 또는 dist/<이름> (linux) set -euo pipefail cd "$(dirname "$0")/.." python3 -m venv .venv-build source .venv-build/bin/activate pip install -q -r requirements.txt pyinstaller pillow if [[ "$(uname)" == "Darwin" ]]; then - python scripts/make_icns.py + python scripts/make_icns.py masker + python scripts/make_icns.py excelpaster fi pyinstaller --noconfirm --clean pdfmasker.spec +pyinstaller --noconfirm --clean excelpaster.spec echo "빌드 완료: dist/" diff --git a/scripts/make_icns.py b/scripts/make_icns.py index a9789de..bfbe689 100644 --- a/scripts/make_icns.py +++ b/scripts/make_icns.py @@ -1,4 +1,7 @@ -"""icon.png -> icon.icns (macOS 전용, iconutil 사용).""" +"""icon.png -> icon.icns (macOS 전용, iconutil 사용). + +사용: python scripts/make_icns.py [masker|excelpaster] (기본 masker) +""" import shutil import subprocess import sys @@ -6,7 +9,8 @@ from PIL import Image -assets = Path(__file__).resolve().parent.parent / "masker" / "assets" +pkg = sys.argv[1] if len(sys.argv) > 1 else "masker" +assets = Path(__file__).resolve().parent.parent / pkg / "assets" src = assets / "icon.png" iconset = assets / "icon.iconset" if iconset.exists(): diff --git a/scripts/make_paster_icon.py b/scripts/make_paster_icon.py new file mode 100644 index 0000000..6268256 --- /dev/null +++ b/scripts/make_paster_icon.py @@ -0,0 +1,78 @@ +"""Excel Paster 아이콘 생성: excelpaster/assets/icon.png (512px) 와 icon.ico. + +PNG 는 Qt 로 그리고, ICO 는 Pillow 가 있으면 함께 만든다. +사용: python scripts/make_paster_icon.py +""" + +import os +import sys +from pathlib import Path + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +from PySide6.QtCore import QPointF, QRectF, Qt # noqa: E402 +from PySide6.QtGui import QColor, QGuiApplication, QImage, QPainter, QPainterPath, QPen # noqa: E402 + +ASSETS = Path(__file__).resolve().parent.parent / "excelpaster" / "assets" +SIZE = 512 + + +def draw(size: int) -> QImage: + img = QImage(size, size, QImage.Format.Format_ARGB32) + img.fill(Qt.GlobalColor.transparent) + p = QPainter(img) + p.setRenderHint(QPainter.RenderHint.Antialiasing) + s = size / 512 + + # 배경: 둥근 사각형 (초록 → 엑셀 연상) + bg = QPainterPath() + bg.addRoundedRect(QRectF(32 * s, 32 * s, 448 * s, 448 * s), 96 * s, 96 * s) + p.fillPath(bg, QColor("#1f7a4d")) + + # 왼쪽: 표 (셀 격자) + p.setPen(QPen(QColor("#ffffff"), 14 * s, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap)) + p.setBrush(QColor(255, 255, 255, 40)) + grid = QRectF(92 * s, 140 * s, 150 * s, 232 * s) + p.drawRoundedRect(grid, 12 * s, 12 * s) + for i in (1, 2): + y = grid.top() + grid.height() * i / 3 + p.drawLine(QPointF(grid.left(), y), QPointF(grid.right(), y)) + x = grid.left() + grid.width() / 2 + p.drawLine(QPointF(x, grid.top()), QPointF(x, grid.bottom())) + + # 가운데: 화살표 + p.setPen(QPen(QColor("#ffffff"), 18 * s, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap, + Qt.PenJoinStyle.RoundJoin)) + p.setBrush(Qt.BrushStyle.NoBrush) + cy = 256 * s + p.drawLine(QPointF(262 * s, cy), QPointF(318 * s, cy)) + p.drawLine(QPointF(296 * s, cy - 24 * s), QPointF(320 * s, cy)) + p.drawLine(QPointF(296 * s, cy + 24 * s), QPointF(320 * s, cy)) + + # 오른쪽: 텍스트 줄 + p.setPen(QPen(QColor("#ffffff"), 18 * s, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap)) + for i, w in enumerate((84, 60, 84, 48)): + y = 168 * s + i * 58 * s + p.drawLine(QPointF(344 * s, y), QPointF((344 + w) * s, y)) + p.end() + return img + + +def main() -> None: + QGuiApplication(sys.argv) + ASSETS.mkdir(parents=True, exist_ok=True) + png = ASSETS / "icon.png" + draw(SIZE).save(str(png), "PNG") + print(f"written {png}", file=sys.stderr) + try: + from PIL import Image + except ImportError: + print("Pillow 없음: icon.ico 생략", file=sys.stderr) + return + im = Image.open(png) + im.save(ASSETS / "icon.ico", sizes=[(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)]) + print(f"written {ASSETS / 'icon.ico'}", file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/scripts/pyi_trim.py b/scripts/pyi_trim.py new file mode 100644 index 0000000..00ab54d --- /dev/null +++ b/scripts/pyi_trim.py @@ -0,0 +1,79 @@ +"""PyInstaller 번들에서 쓰지 않는 Qt 구성 요소를 걸러내 exe 크기를 줄인다. + +두 앱 모두 QtCore · QtGui · QtWidgets (+ SVG 아이콘) 만 쓰는데, PyInstaller 의 PySide6 훅은 +Qt Quick/Qml, Pdf, Network, 번역 파일, 소프트웨어 OpenGL 등을 통째로 넣는다. +스펙 파일에서 `trim_qt(a)` 를 Analysis 뒤에 호출한다. +""" + +from __future__ import annotations + +import re + +# 모듈 이름(Qt6<이름>) 이 이 접두사로 시작하면 제거 +DROP_MODULE_PREFIXES = ( + "Quick", "Qml", "Labs", "Pdf", "Network", "VirtualKeyboard", "Multimedia", "WebEngine", + "WebChannel", "WebSockets", "WebView", "3D", "Designer", "Help", "Sql", "Test", "Xml", + "PrintSupport", "Charts", "DataVisualization", "Graphs", "Bluetooth", "Nfc", "Positioning", + "Location", "Sensors", "SerialPort", "SerialBus", "StateMachine", "Scxml", "RemoteObjects", + "TextToSpeech", "SpatialAudio", "HttpServer", "Concurrent", "OpenGLWidgets", "ShaderTools", + "SvgWidgets", "UiTools", "Wayland", "Core5Compat", "Protobuf", "Grpc", "Examples", +) +# 플러그인 폴더 (plugins/<이름>) 중 제거할 것. platforms · styles · imageformats · iconengines 는 유지 +DROP_PLUGIN_DIRS = { + "qmltooling", "qmllint", "networkinformation", "tls", "multimedia", "sqldrivers", "position", + "sensors", "texttospeech", "printsupport", "virtualkeyboard", "webview", "scenegraph", "designer", + "canbus", "geoservices", "assetimporters", "renderers", "sceneparsers", "geometryloaders", + "egldeviceintegrations", "wayland-decoration-client", "wayland-graphics-integration-client", + "wayland-shell-integration", "xcbglintegrations", "generic", "help", "qmlls", +} +# imageformats 중 제거 (qpdf 는 Qt6Pdf 에 의존하므로 함께 빼야 함) +DROP_IMAGEFORMATS = {"qpdf", "qtiff", "qwebp", "qtga", "qwbmp", "qicns"} +# 파일 이름으로 제거 (Windows 소프트웨어 OpenGL, ANGLE) +DROP_FILES = {"opengl32sw.dll", "d3dcompiler_47.dll", "libegl.dll", "libglesv2.dll"} +# 폴더 (PySide6 아래) 통째로 제거 +DROP_DIRS = ("translations", "qml", "libexec", "resources", "examples", "typesystems", "include", "glue") + +_MODULE_RE = re.compile(r"^(?:lib)?Qt6?(?P[A-Za-z0-9]+?)(?:\.framework|\.abi3\.so|\.pyd|\.dll|\.so(?:\.\d+)*|\.dylib)$") + + +def _module_name(basename: str) -> str | None: + m = _MODULE_RE.match(basename) + return m.group("mod") if m else None + + +def _should_drop(dest: str) -> bool: + d = dest.replace("\\", "/") + if "PySide6" not in d and "shiboken6" not in d: + return False + parts = d.split("/") + base = parts[-1] + low = base.lower() + if low in DROP_FILES: + return True + rel = parts[parts.index("PySide6") + 1:] if "PySide6" in parts else parts + if rel and rel[0] == "Qt": + rel = rel[1:] + if rel and rel[0] in DROP_DIRS: + return True + if len(rel) >= 2 and rel[0] == "plugins": + if rel[1] in DROP_PLUGIN_DIRS: + return True + if rel[1] == "imageformats" and any(low.startswith(("lib" + n, n)) for n in DROP_IMAGEFORMATS): + return True + return False + # Qt 라이브러리 / PySide6 확장 모듈. macOS 프레임워크는 경로 중간에 Qt.framework 가 온다 + for p in rel: + mod = _module_name(p) + if mod and mod.startswith(DROP_MODULE_PREFIXES): + return True + return False + + +def trim_qt(analysis) -> None: + """Analysis 결과의 binaries/datas 에서 불필요한 Qt 파일을 제거하고 요약을 출력한다.""" + for attr in ("binaries", "datas"): + toc = getattr(analysis, attr) + kept = [t for t in toc if not _should_drop(t[0])] + removed = len(toc) - len(kept) + toc[:] = kept + print(f"pyi_trim: {attr}: {removed} removed, {len(kept)} kept") diff --git a/tests/test_paster.py b/tests/test_paster.py new file mode 100644 index 0000000..3ed9c74 --- /dev/null +++ b/tests/test_paster.py @@ -0,0 +1,252 @@ +from datetime import date + +from excelpaster.core import ( + FormatSpec, + column_names, + header_row_count, + looks_like_header, + merged_header_names, + parse_column_names, + placeholders, + resolve_table, + dump_presets, + load_presets, + parse_table, + render, + split_table, + render_template, + split_template, + unknown_placeholders, +) + +ORDER = ("품명\t규격\t수량\r\nXx형태\t700*350*1600\t1\r\nGAa\t백색도장\t1\r\n111N형태\t600*400*1200\t4\r\n" + "AR38\t\t20\r\nAED16\t\t8\r\nM161\t\t1\r\n") +ORDER_EXPECTED = """11/5일 입고요청 +Xx형태 700*350*1600 1개 +GAa 백색도장 1개 +111N형태 600*400*1200 4개 +AR38 20개 +AED16 8개 +M161 1개 +오전입고 바랍니다.""" + +EXCEL = "이름\t부서\t금액\r\n홍길동\t영업\t1234567\r\n김철수\t개발\t89000\r\n" + + +def test_parse_excel_tsv_strips_trailing_newline(): + t = parse_table(EXCEL) + assert t == [["이름", "부서", "금액"], ["홍길동", "영업", "1234567"], ["김철수", "개발", "89000"]] + + +def test_parse_quoted_cell_with_newline_and_quotes(): + # 엑셀은 줄바꿈/따옴표가 든 셀을 큰따옴표로 감싸고 따옴표는 두 번 씀 + text = 'a\tb\r\n"첫줄\n둘째줄"\t"그는 ""안녕""이라 했다"\r\n' + t = parse_table(text) + assert t == [["a", "b"], ["첫줄\n둘째줄", '그는 "안녕"이라 했다']] + + +def test_parse_pads_ragged_rows_and_single_column(): + assert parse_table("a\tb\nc\n") == [["a", "b"], ["c", ""]] + assert parse_table("x\ny\nz") == [["x"], ["y"], ["z"]] + assert parse_table("") == [] + assert parse_table("\r\n\r\n") == [] + + +def test_template_by_header_number_and_specials(): + t = parse_table(EXCEL) + spec = FormatSpec(template="{#}/{행수} {이름}({2}) {금액|comma}원") + assert render(t, spec) == "1/2 홍길동(영업) 1,234,567원\n2/2 김철수(개발) 89,000원" + + +def test_template_without_header_row(): + t = parse_table("홍길동\t영업\n김철수\t개발\n") + spec = FormatSpec(template="{1}-{2}", header_row=False) + assert render(t, spec) == "홍길동-영업\n김철수-개발" + assert column_names(["", "x"]) == ["1", "x"] + + +def test_head_body_tail_template(): + spec = FormatSpec(template="11/5일 입고요청\n{품명} {규격} {수량}개\n오전입고 바랍니다.") + assert render(parse_table(ORDER), spec) == ORDER_EXPECTED + # 헤더 없이 번호로, 꼬리말 앞 빈 줄 유지 + body = ORDER.split("\r\n", 1)[1] + spec = FormatSpec(template="11/5일 입고요청\n{1} {2} {3}개\n\n오전입고 바랍니다.", header_row=False) + assert render(parse_table(body), spec) == ORDER_EXPECTED.replace("\n오전", "\n\n오전") + + +def test_split_template(): + assert split_template("머리\n{1}\n{2}\n꼬리") == ("머리", "{1}\n{2}", "꼬리") + assert split_template("{1}") == ("", "{1}", "") + assert split_template("{1}\n") == ("", "{1}\n", "") # 꼬리말 없음 → 빈 줄은 반복 부분 + assert split_template("{1}\n\n꼬리") == ("", "{1}", "\n꼬리") # 꼬리말 있음 → 빈 줄은 꼬리말 앞 간격 + assert split_template("머리만") == ("", "머리만", "") + # {오늘} {행수} 만 있는 줄은 머리말/꼬리말, 반복 줄 사이의 일반 줄은 반복 부분에 포함 + assert split_template("{오늘}일 요청\n{1}\n---\n{2}\n총 {행수}건") == ("{오늘}일 요청", "{1}\n---\n{2}", "총 {행수}건") + + +def test_today_placeholder(): + d = date.today() + assert render_template("{오늘}", ["a"], ["x"], 1, 1) == f"{d.month}/{d.day}" + + +def test_empty_cell_collapses_one_adjacent_space(): + h = ["a", "b", "c"] + assert render_template("{a} {b} {c}개", h, ["AR38", "", "20"], 1, 1) == "AR38 20개" + assert render_template("{a} {b}", h, ["AR38", "", ""], 1, 1) == "AR38" + assert render_template("{b} {a}", h, ["AR38", "", ""], 1, 1) == "AR38" + assert render_template("[[{b}]] {a}", h, ["AR38", "", ""], 1, 1) == "[] AR38" # [[ ]] 는 글자 그대로 + assert render_template("[{b}] {a}", h, ["AR38", "", ""], 1, 1) == "AR38" # 묶음은 비면 생략 + assert render_template("{a} {b} {c}", h, ["x", "", "z"], 1, 1) == "x z" # 공백 하나만 제거 + assert render_template(" {b} {a}", h, ["AR38", "", ""], 1, 1) == " AR38" # 들여쓰기는 유지 + + +def test_multiline_template_repeats_per_row(): + t = parse_table(EXCEL) + spec = FormatSpec(template="■ {이름}\n 부서: {부서}\n") + assert render(t, spec) == "■ 홍길동\n 부서: 영업\n\n■ 김철수\n 부서: 개발\n" + assert render(t, FormatSpec(template="{이름}\r\n{부서}")) == "홍길동\n영업\n김철수\n개발" + + +def test_unknown_placeholder_left_as_is_and_reported(): + out = render_template("{이름} {없는열}", ["이름"], ["홍"], 1, 1) + assert out == "홍 {없는열}" + assert unknown_placeholders("{이름} {없는열} {#} {2}", ["이름", "부서"]) == ["없는열"] + + +def test_brace_escape_and_filters(): + headers = ["값", "비고"] + assert render_template("{{{값}}}", headers, ["x", ""], 1, 1) == "{x}" + assert render_template("{비고|default:없음}", headers, ["x", ""], 1, 1) == "없음" + assert render_template("{값|upper}|{값|rjust:4}|{값|zfill:3}", headers, ["ab", ""], 1, 1) == "AB| ab|0ab" + assert render_template("{값|comma}", headers, ["-1234.5", ""], 1, 1) == "-1,234.5" + assert render_template("{값|comma}", headers, ["abc", ""], 1, 1) == "abc" + assert render_template("{값|nocomma}", headers, ["1,000", ""], 1, 1) == "1000" + assert render_template("{값|replace:a,b}", headers, ["aaa", ""], 1, 1) == "bbb" + assert render_template("{값|oneline}", headers, ["a\n b", ""], 1, 1) == "a b" + assert render_template("{값|quote}", headers, ['s"q', ""], 1, 1) == '"s""q"' + assert render_template("{값|trim|lower}", headers, [" AB ", ""], 1, 1) == "ab" + + +def test_header_name_case_insensitive_and_duplicates(): + out = render_template("{name}/{NAME}/{2}", ["Name", "Name"], ["a", "b"], 1, 1) + assert out == "a/a/b" + + +def test_skip_blank_rows(): + t = parse_table("h\na\n\t\nb\n") + assert render(t, FormatSpec(template="{h}")) == "a\nb" + assert render(t, FormatSpec(template="{h}", skip_blank_rows=False)) == "a\n\nb" + + +def test_presets_roundtrip_and_bad_input(): + presets = [FormatSpec(name="a", template="{1}"), FormatSpec(name="b", template="{2}\n", header_row=False)] + back = load_presets(dump_presets(presets)) + assert back == presets + assert load_presets("") == [] + assert load_presets("not json") == [] + # 이전 버전 프리셋(row_template, mode 등) 도 읽힘 + old = '{"presets":[{"name":"x","mode":"template","row_template":"{이름}","joiner":"\\\\n","extra":1}]}' + assert load_presets(old)[0] == FormatSpec(name="x", template="{이름}") + + +REAL_HEADER = ("품명\t규격\t\t\t\t재질\t수량\t 매입가 \t 판매가 \t주요사양\t비고\t발주처\t작성일\t" + "\"입고\n예정\"\t입고일\t출고 예정일\t출고일\r\n") +REAL_ROWS = ("Xx형태\t700*350*1600\t\t\t\tSUS304\t1\t10000\t12000\t\t\tA사\t11/1\t11/5\t\t\t\r\n" + "AR38\t\t\t\t\t\t20\t\t\t\t\t\t\t\t\t\t\r\n") + + +def test_real_sheet_header_row(): + t = parse_table(REAL_HEADER + REAL_ROWS) + assert len(t[0]) == 17 + names = column_names(resolve_table(t, FormatSpec(template="{품명}"))[0]) + assert names[:7] == ["품명", "규격", "3", "4", "5", "재질", "수량"] + assert names[7] == "매입가" and names[13] == "입고 예정" and names[15] == "출고 예정일" + spec = FormatSpec(template="{오늘}일 입고요청\n{품명} {규격} {재질} {수량}개\n오전입고 바랍니다.") + out = render(t, spec) + assert out.splitlines()[1:] == ["Xx형태 700*350*1600 SUS304 1개", "AR38 20개", "오전입고 바랍니다."] + # 셀 안 줄바꿈·공백이 든 열 이름도 여러 방식으로 참조 가능 + assert render(t, FormatSpec(template="{입고예정}|{입고 예정}|{매입가}|{출고예정일}")).splitlines()[0] == "11/5|11/5|10000" + assert unknown_placeholders("{입고예정} {없음}", split_table(t, True)[0]) == ["없음"] + + +def test_auto_header_detection(): + data_only = "Xx형태\t700*350*1600\tSUS304\t1\r\nAR38\t\t\t20\r\n" + with_header = "품명\t규격\t재질\t수량\r\n" + data_only + tpl = FormatSpec(template="{품명} {규격} {재질} {수량}개") + # 1) 템플릿에 쓴 이름이 첫 행에 있으면 헤더 + assert looks_like_header(parse_table(with_header), [], tpl.template) + # 2) 데이터만 복사: 첫 행에 숫자 있음 → 데이터. 모든 행이 들어감 + assert not looks_like_header(parse_table(data_only), [], tpl.template) + headers, rows, is_header = resolve_table(parse_table(data_only), tpl) + assert not is_header and len(rows) == 2 and headers == ["1", "2", "3", "4"] + # 3) 저장된 열 이름이 있으면 데이터만 복사해도 이름으로 참조 + known = parse_column_names("품명, 규격, 재질, 수량") + assert render(parse_table(data_only), tpl, known) == "Xx형태 700*350*1600 SUS304 1개\nAR38 20개" + # 저장된 열 이름 + 헤더 포함 복사 → 헤더 건너뜀 + assert render(parse_table(with_header), tpl, known) == "Xx형태 700*350*1600 SUS304 1개\nAR38 20개" + # 4) 번호 템플릿 + 헤더 있음: 첫 행엔 숫자 없고 아래엔 있음 → 헤더로 판단 + num = FormatSpec(template="{1} {4}") + assert render(parse_table(with_header), num) == "Xx형태 1\nAR38 20" + # 숫자가 전혀 없는 명단은 전부 데이터 + names_only = "홍길동\t영업\n김철수\t개발\n" + assert render(parse_table(names_only), FormatSpec(template="{1}")) == "홍길동\n김철수" + # 강제 지정도 그대로 동작 + assert render(parse_table(names_only), FormatSpec(template="{1}", header_row=True)) == "김철수" + + +def test_parse_column_names(): + assert parse_column_names("품명, 규격, , , , 재질, 수량") == ["품명", "규격", "", "", "", "재질", "수량"] + assert parse_column_names("품명\t규격\t\t재질") == ["품명", "규격", "", "재질"] + assert parse_column_names(" ") == [] + # 실제 헤더 행 17열을 저장해 두고 데이터만 복사 + known = [c for c in parse_table(REAL_HEADER)[0]] + known = [" ".join(k.split()) for k in known] + out = render(parse_table(REAL_ROWS), FormatSpec(template="{품명} {규격} {재질} {수량}개"), known) + assert out == "Xx형태 700*350*1600 SUS304 1개\nAR38 20개" + + +TWO_ROW_HEADER = ("품명\t규격\t\t\t\t재질\t수량\t 매입가 \t 판매가 \t주요사양\t비고\t발주처\t작성일\t" + "\"입고\n예정\"\t입고일\t출고 예정일\t출고일\r\n" + "\t두께\t가로 \t세로 \t높이\t\t\t\t\t\t\t\t\t\t\t\t\r\n") +TWO_ROW_DATA = ("Xx형태\t1.2\t700\t350\t1600\tSUS304\t1\t\t\t\t\t\t\t\t\t\t\r\n" + "GAa\t\t\t\t\tSTEEL\t1\t\t\t\t\t\t\t\t\t\t\r\n" + "AR38\t\t\t\t\t\t20\t\t\t\t\t\t\t\t\t\t\r\n") +ORDER_TPL = "{오늘}일 입고요청\n{품명} [{가로}*{세로}*{높이}] {재질} {수량}개\n오전입고 바랍니다." + + +def test_two_row_header_is_merged(): + t = parse_table(TWO_ROW_HEADER + TWO_ROW_DATA) + assert header_row_count(t, [], ORDER_TPL) == 2 + names = merged_header_names(t, 2) + assert names[:7] == ["품명", "두께", "가로", "세로", "높이", "재질", "수량"] + headers, rows, n = resolve_table(t, FormatSpec(template=ORDER_TPL)) + assert n == 2 and len(rows) == 3 and headers[:5] == ["품명", "두께", "가로", "세로", "높이"] + out = render(t, FormatSpec(template=ORDER_TPL)).splitlines() + assert out[1:] == ["Xx형태 700*350*1600 SUS304 1개", "GAa STEEL 1개", "AR38 20개", "오전입고 바랍니다."] + # 저장된 열 이름(두 줄 합친 것)으로 데이터만 복사해도 같은 결과 + out2 = render(parse_table(TWO_ROW_DATA), FormatSpec(template=ORDER_TPL), names).splitlines() + assert out2[1:] == out[1:] + # 저장된 열 이름이 있을 때 두 줄 헤더째로 복사해도 둘 다 건너뜀 + assert resolve_table(t, FormatSpec(template=ORDER_TPL), names)[2] == 2 + # 한 줄짜리 헤더는 그대로 한 줄 + assert header_row_count(parse_table(REAL_HEADER + REAL_ROWS), [], ORDER_TPL) == 1 + + +def test_groups_and_separators(): + h = ["a", "b", "c", "t"] + r = lambda tpl, row: render_template(tpl, h, row, 1, 1) # noqa: E731 + assert r("{a}*{b}*{c}", ["700", "350", "1600", ""]) == "700*350*1600" + assert r("{a}*{b}*{c}", ["700", "", "1600", ""]) == "700*1600" + assert r("{a}*{b}*{c}", ["", "", "", ""]) == "" + assert r("X [{a}*{b}*{c}] Y", ["", "", "", ""]) == "X Y" + assert r("X [{a}*{b}*{c}] Y", ["1", "2", "3", ""]) == "X 1*2*3 Y" + assert r("[{t}t] {a}", ["7", "", "", ""]) == "7" + assert r("[{t}t] {a}", ["7", "", "", "1.2"]) == "1.2t 7" + assert r("[{t}t] [{a}*{b}*{c}]", ["", "", "", ""]) == "" + # 자리표시자가 없는 대괄호, 짝이 안 맞는 대괄호, 줄을 넘는 대괄호는 글자 그대로 + assert r("[메모] {a}", ["x", "", "", ""]) == "[메모] x" + assert r("[{a} {b}", ["x", "", "", ""]) == "[x" + assert r("[{a}\n{b}]", ["x", "y", "", ""]) == "[x\ny]" + # 공백이 든 구분자는 그대로 (단어는 지우지 않음) + assert r("{a} 및 {b}", ["x", "", "", ""]) == "x 및" + assert placeholders("[{가로}*{세로}] {수량|comma}") == ["가로", "세로", "수량"] diff --git a/tests/test_pyi_trim.py b/tests/test_pyi_trim.py new file mode 100644 index 0000000..ab34bab --- /dev/null +++ b/tests/test_pyi_trim.py @@ -0,0 +1,54 @@ +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts")) + +from pyi_trim import _should_drop # noqa: E402 + + +def test_drops_unused_qt_modules_on_each_platform(): + # Linux + assert _should_drop("PySide6/Qt/lib/libQt6Quick.so.6") + assert _should_drop("PySide6/Qt/lib/libQt6Qml.so.6") + assert _should_drop("PySide6/Qt/lib/libQt6Pdf.so.6") + assert _should_drop("PySide6/Qt/lib/libQt6Network.so.6") + assert _should_drop("PySide6/QtNetwork.abi3.so") + # Windows + assert _should_drop("PySide6/Qt6Quick.dll") + assert _should_drop("PySide6/QtPdf.pyd") + assert _should_drop("PySide6/opengl32sw.dll") + assert _should_drop("PySide6/d3dcompiler_47.dll") + # macOS + assert _should_drop("PySide6/Qt/lib/QtQuick.framework/Versions/A/QtQuick") + assert _should_drop("PySide6/Qt/lib/QtPdf.framework/Resources/Info.plist") + + +def test_keeps_what_the_apps_use(): + for p in ( + "PySide6/Qt/lib/libQt6Core.so.6", "PySide6/Qt/lib/libQt6Gui.so.6", "PySide6/Qt/lib/libQt6Widgets.so.6", + "PySide6/Qt/lib/libQt6Svg.so.6", "PySide6/Qt/lib/libQt6DBus.so.6", "PySide6/Qt/lib/libQt6OpenGL.so.6", + "PySide6/Qt6Core.dll", "PySide6/Qt6Widgets.dll", "PySide6/Qt6Svg.dll", + "PySide6/QtWidgets.pyd", "PySide6/QtCore.abi3.so", "PySide6/libpyside6.abi3.so.6.12", + "PySide6/Qt/lib/QtWidgets.framework/Versions/A/QtWidgets", + "PySide6/Qt/plugins/platforms/libqxcb.so", "PySide6/plugins/platforms/qwindows.dll", + "PySide6/Qt/plugins/styles/libqmacstyle.dylib", + "PySide6/Qt/plugins/imageformats/libqsvg.so", "PySide6/plugins/imageformats/qico.dll", + "PySide6/Qt/plugins/iconengines/libqsvgicon.so", + "PySide6/Qt/plugins/platformthemes/libqgtk3.so", "PySide6/Qt/plugins/platforminputcontexts/libibusplatforminputcontextplugin.so", + "shiboken6/libshiboken6.abi3.so.6.12", + "masker/assets/icon.png", "libpython3.13.so.1.0", "PIL/_imaging.cpython-313-x86_64-linux-gnu.so", + ): + assert not _should_drop(p), p + + +def test_drops_plugins_and_folders(): + assert _should_drop("PySide6/Qt/translations/qtbase_ko.qm") + assert _should_drop("PySide6/translations/qtbase_ko.qm") + assert _should_drop("PySide6/Qt/plugins/tls/libqopensslbackend.so") + assert _should_drop("PySide6/plugins/networkinformation/qnetworklistmanager.dll") + assert _should_drop("PySide6/Qt/plugins/qmltooling/libqmldbg_debugger.so") + assert _should_drop("PySide6/Qt/plugins/imageformats/libqpdf.so") + assert _should_drop("PySide6/plugins/imageformats/qpdf.dll") + assert _should_drop("PySide6/Qt/qml/QtQuick/libqtquick2plugin.so") + assert _should_drop("PySide6/Qt/libexec/QtWebEngineProcess") + assert _should_drop("PySide6/Qt/plugins/wayland-shell-integration/libxdg-shell.so") diff --git a/tests/test_updater.py b/tests/test_updater.py new file mode 100644 index 0000000..2e00c99 --- /dev/null +++ b/tests/test_updater.py @@ -0,0 +1,70 @@ +from pathlib import Path + +from excelpaster import updater +from excelpaster._version import __version__ +from excelpaster.updater import ( + Release, + is_newer, + parse_checksums, + parse_release, + parse_version, + windows_swap_script, +) + + +def test_version_parse_and_compare(): + assert parse_version("v1.2.3") == (1, 2, 3) + assert parse_version("1.10") == (1, 10) + assert parse_version("junk") == (0,) + assert is_newer("v1.0.1", "1.0.0") + assert is_newer("v2", "1.9.9") + assert not is_newer("v1.0.0", "1.0.0") + assert not is_newer("v0.9", "1.0.0") + assert not is_newer("1.0", "1.0.0") + assert parse_version(__version__) >= (1, 0, 0) + + +def test_parse_release_and_assets(): + payload = { + "tag_name": "v1.2.0", + "html_url": "https://github.com/x/y/releases/tag/v1.2.0", + "body": "notes", + "assets": [ + {"name": "Excel-Paster-windows.exe", "browser_download_url": "https://dl/win.exe"}, + {"name": "Excel-Paster-macos-arm64.dmg", "browser_download_url": "https://dl/mac.dmg"}, + {"name": "SHA256SUMS.txt", "browser_download_url": "https://dl/sums"}, + {"name": "PDF-Masker-windows.exe", "browser_download_url": "https://dl/pdf.exe"}, + ], + } + rel = parse_release(payload) + assert rel.version == "1.2.0" and rel.tag == "v1.2.0" and rel.notes == "notes" + assert rel.asset_url("win32") == "https://dl/win.exe" + assert rel.asset_url("darwin") == "https://dl/mac.dmg" + assert rel.asset_url("linux") is None + assert rel.checksums_url == "https://dl/sums" + assert Release(version="1", tag="v1", page_url="u").asset_url("win32") is None + + +def test_parse_checksums(): + text = ("96bda7c5148b0e76b1fc6ddbdf5b09d79e8f25018835e6c2ed9aa66cc3a1d8e3 Excel-Paster-windows.exe\n" + "55F7CD964E08399281EAB8F919DB24A47CB8E323C48CCC6CFC0DDFE2AE2D01B3 *PDF-Masker-windows.exe\n" + "not a checksum line\n") + sums = parse_checksums(text) + assert sums["Excel-Paster-windows.exe"].startswith("96bda7c5") + assert sums["PDF-Masker-windows.exe"].startswith("55f7cd96") + assert len(sums) == 2 + + +def test_sha256_of(tmp_path: Path): + f = tmp_path / "a.bin" + f.write_bytes(b"hello") + assert updater.sha256_of(f) == "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824" + + +def test_windows_swap_script_waits_and_swaps(): + script = windows_swap_script(Path(r"C:\Apps\Excel Paster.exe"), Path(r"C:\Temp\new.exe"), [123, 456]) + assert "PID eq 123" in script and "PID eq 456" in script + assert 'move /y "C:\\Apps\\Excel Paster.exe" "C:\\Apps\\Excel Paster.exe.old"' in script + assert 'move /y "C:\\Temp\\new.exe" "C:\\Apps\\Excel Paster.exe"' in script + assert 'start "" "C:\\Apps\\Excel Paster.exe"' in script + assert script.endswith('del /f /q "%~f0" >nul 2>&1\r\n')