workpytools 0.1.4__py3-none-any.whl

workpytools/processing/help.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import webbrowser
+from pathlib import Path
+
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+# リポジトリ直下の doc/help.html。commit時のpre-commitフックで最新化される
+# （scripts/gen_help.py 参照）。このコマンド自体は生成せず、既存ファイルを開くだけ。
+_HELP_HTML_PATH = Path(__file__).resolve().parents[3] / "doc" / "help.html"
+
+
+class HelpProcessor(Processor):
+    """Open doc/help.html (a one-liner summary + full --help for every command)
+    in the default browser.
+
+    doc/help.html is regenerated by a pre-commit hook (scripts/gen_help.py)
+    whenever a command's help text changes, so it always reflects the last
+    committed state, not necessarily uncommitted local edits.
+    """
+
+    name = "help"
+    help = "全コマンドのヘルプ一覧(doc/help.html)をブラウザで開く"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--no-open", action="store_true", help="ブラウザを開かず、パスの表示のみ行う"
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        if not _HELP_HTML_PATH.exists():
+            raise SystemExit(
+                f"help.htmlが見つかりません: {_HELP_HTML_PATH}\n"
+                "python scripts/gen_help.py を実行して生成してください。"
+            )
+
+        logger.info("ヘルプページを開きます: %s", _HELP_HTML_PATH)
+        print(_HELP_HTML_PATH)
+
+        if not args.no_open:
+            webbrowser.open(_HELP_HTML_PATH.as_uri())
+
+        return 0

workpytools/processing/ikko.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import argparse
+import logging
+
+from workpytools.common.powerpoint import (
+    NoActivePresentationError,
+    PowerPointNotRunningError,
+    get_active_presentation,
+    get_running_powerpoint,
+)
+from workpytools.common.shape_cluster import (
+    LEFT_TOLERANCE,
+    LINE_STEP_MAX_RATIO,
+    LINE_STEP_MIN_RATIO,
+    ShapeInfo,
+    cluster_shapes,
+)
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+_SELECTION_SHAPES = 2  # ppSelectionShapes
+
+
+class IkkoProcessor(Processor):
+    """Merge adjacent single-line text boxes on the current slide (or the
+    current selection) into one multi-paragraph text box. Meant for
+    PowerPoint's "convert to shapes" output, which splits each line of a
+    paragraph into its own text box.
+    """
+
+    name = "ikko"
+    help = "スライド上のバラバラなテキストボックスを1つに合体する"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="実際には変更せず、合体対象になるクラスタを表示するだけにする",
+        )
+        parser.add_argument(
+            "--left-tolerance",
+            type=float,
+            default=LEFT_TOLERANCE,
+            help=f"左端座標の許容誤差（ポイント、既定{LEFT_TOLERANCE}）",
+        )
+        parser.add_argument(
+            "--line-step-min",
+            type=float,
+            default=LINE_STEP_MIN_RATIO,
+            help=f"行送りの下限（フォントサイズ比、既定{LINE_STEP_MIN_RATIO}）",
+        )
+        parser.add_argument(
+            "--line-step-max",
+            type=float,
+            default=LINE_STEP_MAX_RATIO,
+            help=f"行送りの上限（フォントサイズ比、既定{LINE_STEP_MAX_RATIO}）",
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        try:
+            app = get_running_powerpoint()
+        except PowerPointNotRunningError as exc:
+            raise SystemExit(
+                "PowerPointでプレゼンテーションを開いた状態で実行してください"
+            ) from exc
+
+        try:
+            get_active_presentation(app)
+        except NoActivePresentationError as exc:
+            raise SystemExit(
+                "PowerPointでプレゼンテーションを開いた状態で実行してください"
+            ) from exc
+
+        try:
+            com_shapes = self._resolve_target_shapes(app)
+        except Exception as exc:
+            raise SystemExit(f"対象範囲の取得中にエラーが発生しました: {exc}") from exc
+
+        shape_infos = [
+            info for info in (self._to_shape_info(s) for s in com_shapes) if info is not None
+        ]
+
+        if not shape_infos:
+            print("対象になるテキストボックスがありません")
+            return 0
+
+        clusters = [c for c in cluster_shapes(
+            shape_infos,
+            left_tolerance=args.left_tolerance,
+            line_step_min_ratio=args.line_step_min,
+            line_step_max_ratio=args.line_step_max,
+        ) if len(c) >= 2]
+
+        if not clusters:
+            print("合体できる組み合わせが見つかりませんでした（--left-tolerance等のオプションで閾値を調整できます）")
+            return 0
+
+        if args.dry_run:
+            self._print_dry_run(clusters)
+            return 0
+
+        try:
+            app.StartNewUndoEntry()
+            merged_count = 0
+            removed_count = 0
+            for cluster in clusters:
+                self._merge_cluster(cluster)
+                merged_count += 1
+                removed_count += len(cluster) - 1
+        except Exception as exc:
+            raise SystemExit(
+                f"PowerPointの操作中にエラーが発生しました（Ctrl+Zで開始前の状態に戻せます）: {exc}"
+            ) from exc
+
+        logger.info("合体したクラスタ数=%d 削除したシェイプ数=%d", merged_count, removed_count)
+        total_before = removed_count + merged_count
+        print(f"{merged_count}個のクラスタを合体しました（{total_before}個のシェイプを{merged_count}個に）")
+        return 0
+
+    def _resolve_target_shapes(self, app: object) -> list[object]:
+        selection = app.ActiveWindow.Selection  # type: ignore[attr-defined]
+        if selection.Type == _SELECTION_SHAPES:
+            shape_range = selection.ShapeRange
+            return [shape_range.Item(i) for i in range(1, shape_range.Count + 1)]
+
+        slide = app.ActiveWindow.View.Slide  # type: ignore[attr-defined]
+        return [slide.Shapes.Item(i) for i in range(1, slide.Shapes.Count + 1)]
+
+    def _to_shape_info(self, shape: object) -> ShapeInfo | None:
+        if not getattr(shape, "HasTextFrame", False):
+            return None
+        text_range = shape.TextFrame.TextRange  # type: ignore[attr-defined]
+        text = text_range.Text
+        if not text or not text.strip():
+            return None
+        if text_range.Paragraphs().Count != 1:
+            return None
+
+        font = text_range.Font
+        try:
+            color = font.Color.RGB
+        except Exception:
+            color = None
+
+        if font.Name is None or font.Size is None:
+            return None
+
+        return ShapeInfo(
+            left=shape.Left,  # type: ignore[attr-defined]
+            top=shape.Top,  # type: ignore[attr-defined]
+            width=shape.Width,  # type: ignore[attr-defined]
+            height=shape.Height,  # type: ignore[attr-defined]
+            text=text,
+            font_name=font.Name,
+            font_size=font.Size,
+            bold=font.Bold,
+            color=color,
+            alignment=text_range.ParagraphFormat.Alignment,
+            ref=shape,
+        )
+
+    def _print_dry_run(self, clusters: list[list[ShapeInfo]]) -> None:
+        for i, cluster in enumerate(clusters, start=1):
+            print(f"クラスタ{i}: {len(cluster)}個のシェイプ")
+            for info in cluster:
+                print(f"  Left={info.left:.1f} Top={info.top:.1f} Text={info.text!r}")
+
+    def _merge_cluster(self, cluster: list[ShapeInfo]) -> None:
+        lefts = [c.left for c in cluster]
+        tops = [c.top for c in cluster]
+        rights = [c.left + c.width for c in cluster]
+        bottoms = [c.top + c.height for c in cluster]
+
+        new_left = min(lefts)
+        new_top = min(tops)
+        new_width = max(rights) - new_left
+        new_height = max(bottoms) - new_top
+
+        style = cluster[0]
+        base_shape = cluster[0].ref
+        lines = [c.text for c in cluster]
+
+        text_range = base_shape.TextFrame.TextRange  # type: ignore[attr-defined]
+        text_range.Text = "\r".join(lines)
+
+        if style.font_name is not None:
+            text_range.Font.Name = style.font_name
+        if style.font_size is not None:
+            text_range.Font.Size = style.font_size
+        if style.bold is not None:
+            text_range.Font.Bold = style.bold
+        if style.color is not None:
+            text_range.Font.Color.RGB = style.color
+        if style.alignment is not None:
+            text_range.ParagraphFormat.Alignment = style.alignment
+
+        base_shape.Left = new_left  # type: ignore[attr-defined]
+        base_shape.Top = new_top  # type: ignore[attr-defined]
+        base_shape.Width = new_width  # type: ignore[attr-defined]
+        base_shape.Height = new_height  # type: ignore[attr-defined]
+
+        for info in cluster[1:]:
+            info.ref.Delete()  # type: ignore[attr-defined]

workpytools/processing/kukiri.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import argparse
+import logging
+
+import cv2
+import numpy as np
+from PIL import Image
+
+from workpytools.common.clipboard import load_image
+from workpytools.common.output import describe_output, save_result
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+_BILATERAL_DIAMETER = 9
+_UNSHARP_BLUR_SIGMA = 3.0
+
+
+class KukiriProcessor(Processor):
+    """Clean up JPEG edge bleeding/ringing and sharpen boundaries.
+
+    Intended for flat-design illustrations where JPEG compression has
+    blurred/smudged the boundary between flat color regions. Applies an
+    edge-preserving bilateral filter (smooths within regions, leaves edges
+    intact) followed by an unsharp mask (boosts edge contrast).
+
+    Input source and default output location follow the same convention as
+    touka/denoise: explicit `path` or a file copied in Explorer saves next
+    to (or, for the clipboard-file case, into the OS temp dir and back onto
+    the clipboard as) `{stem}_kukiri.png`; raw clipboard image data skips
+    the file and is placed directly on the clipboard as image data.
+    """
+
+    name = "kukiri"
+    help = "JPEGの輪郭滲みを除去し境界をくっきりさせる（フラットイラスト向け）"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "path",
+            nargs="?",
+            default=None,
+            help="画像ファイルパス。省略時はクリップボードの画像/コピーしたファイルを使用",
+        )
+        parser.add_argument(
+            "-o", "--output", default=None, help="出力先パス（省略時は自動生成、拡張子はpng）"
+        )
+        parser.add_argument(
+            "--smooth",
+            type=float,
+            default=75.0,
+            help="バイラテラルフィルタの強さ（デフォルト: 75.0）。"
+            "大きいほど滲みは消えるが細部も失われる",
+        )
+        parser.add_argument(
+            "--sharpen",
+            type=float,
+            default=0.5,
+            help="アンシャープマスクの強さ（デフォルト: 0.5、0で無効）。"
+            "大きいほど境界のコントラストが強調される",
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        loaded = load_image(args.path)
+        logger.info(
+            "kukiri starting (size=%s, smooth=%s, sharpen=%s)",
+            loaded.image.size,
+            args.smooth,
+            args.sharpen,
+        )
+
+        result = self._process(loaded.image, smooth=args.smooth, sharpen=args.sharpen)
+
+        output_path = save_result(loaded, result, "kukiri", args.output)
+        print(describe_output(output_path))
+        return 0
+
+    @staticmethod
+    def _process(image: Image.Image, smooth: float, sharpen: float) -> Image.Image:
+        """Bilateral-filter then unsharp-mask, preserving the alpha channel untouched."""
+        rgba = np.array(image)
+        rgb = rgba[:, :, :3]
+        alpha = rgba[:, :, 3]
+
+        bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+        smoothed = cv2.bilateralFilter(
+            bgr, d=_BILATERAL_DIAMETER, sigmaColor=smooth, sigmaSpace=smooth
+        )
+        blurred = cv2.GaussianBlur(smoothed, (0, 0), sigmaX=_UNSHARP_BLUR_SIGMA)
+        sharpened = cv2.addWeighted(smoothed, 1 + sharpen, blurred, -sharpen, 0)
+
+        result_rgb = cv2.cvtColor(sharpened, cv2.COLOR_BGR2RGB)
+        out = np.dstack([result_rgb, alpha])
+        return Image.fromarray(out, mode="RGBA")

workpytools/processing/lsdir.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+from pathlib import Path
+
+from workpytools.common.clipboard import copy_text_to_clipboard
+from workpytools.common.walk import Entry, compute_total_sizes, dedupe_by_fullpath, walk
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_EXCLUDE = (".git", ".svn", "node_modules", "__pycache__")
+_UNIT_DIVISORS = {"b": 1, "kb": 1024, "mb": 1024**2, "gb": 1024**3}
+
+
+def _format_size(size: int | None, unit: str) -> str:
+    if size is None:
+        return ""
+    if unit == "b":
+        return str(size)
+    value = size / _UNIT_DIVISORS[unit]
+    return f"{value:.2f}"
+
+
+def _resolve_link(fullpath: str) -> str:
+    """Resolve a .lnk shortcut target via WScript.Shell (a public COM API),
+    not by parsing the .lnk binary format ourselves.
+    """
+    import win32com.client
+
+    try:
+        shell = win32com.client.Dispatch("WScript.Shell")
+        shortcut = shell.CreateShortCut(fullpath)
+        return str(shortcut.TargetPath)
+    except Exception as exc:
+        logger.warning("ショートカットの解決に失敗しました: %s (%s)", fullpath, exc)
+        return ""
+
+
+class LsdirProcessor(Processor):
+    """List files and directories under one or more roots as a flat table,
+    suitable for sorting/filtering in Excel. Column count is fixed for a
+    given invocation (no variable-length directory nesting columns).
+    """
+
+    name = "lsdir"
+    help = "フォルダ配下をExcelで集計できる表形式で一覧化する"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("path", nargs="+", help="対象フォルダ（複数・グロブ可）")
+        parser.add_argument("-o", "--output", default=None, help="出力先パス（.tsv / .xlsx）")
+        parser.add_argument("--clip", action="store_true", help="結果をクリップボードにコピーする")
+        parser.add_argument(
+            "--files-only", action="store_true", help="ファイルのみ出力する"
+        )
+        parser.add_argument(
+            "--dirs-only", action="store_true", help="フォルダのみ出力する"
+        )
+        parser.add_argument(
+            "--exclude",
+            nargs="+",
+            default=list(_DEFAULT_EXCLUDE),
+            help="除外するフォルダ名（既定: %(default)s）",
+        )
+        parser.add_argument(
+            "--include-temp",
+            action="store_true",
+            help="'~$'で始まる一時ファイルも含める",
+        )
+        parser.add_argument(
+            "--total-size",
+            action="store_true",
+            help="フォルダ配下の合計サイズを計算する（全走査後に出力するため待ち時間が発生する）",
+        )
+        parser.add_argument(
+            "--unit",
+            choices=["b", "kb", "mb", "gb"],
+            default="kb",
+            help="サイズの単位（既定: kb）",
+        )
+        parser.add_argument(
+            "--resolve-link",
+            action="store_true",
+            help=".lnkのリンク先を解決する（WScript.Shell経由、大量にあると遅くなる）",
+        )
+        parser.add_argument(
+            "--encoding",
+            default="cp932" if os.name == "nt" else "utf-8",
+            help="出力エンコーディング",
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        roots = self._resolve_roots(args.path)
+
+        all_entries: list[Entry] = []
+        total_skipped_dirs = 0
+        for root, source_label in roots:
+            entries, skipped = walk(
+                root,
+                source_label,
+                exclude=frozenset(args.exclude),
+                include_temp=args.include_temp,
+            )
+            all_entries.extend(entries)
+            total_skipped_dirs += skipped
+
+        if total_skipped_dirs:
+            logger.warning("アクセスできず読み飛ばしたフォルダ: %d件", total_skipped_dirs)
+
+        all_entries, dup_skipped = dedupe_by_fullpath(all_entries)
+        if dup_skipped:
+            logger.info("起点の重複により除外したエントリ: %d件", dup_skipped)
+
+        # ファイル行を落とす前に合計サイズを計算する必要がある
+        # （--dirs-only 指定時、ファイルのサイズ情報がないと配下の合計が出せない）。
+        total_sizes = compute_total_sizes(all_entries) if args.total_size else {}
+
+        if args.files_only:
+            all_entries = [e for e in all_entries if e.type == "file"]
+        elif args.dirs_only:
+            all_entries = [e for e in all_entries if e.type == "dir"]
+
+        link_by_path: dict[str, str] = {}
+        if args.resolve_link:
+            for entry in all_entries:
+                if entry.ext.lower() == ".lnk":
+                    link_by_path[entry.fullpath] = _resolve_link(entry.fullpath)
+
+        header = ["source", "type", "name", "fullpath", "parent", "ext", "size", "mtime", "depth"]
+        if args.resolve_link:
+            header.append("link")
+
+        rows = [header]
+        for entry in all_entries:
+            if args.total_size and entry.type == "dir":
+                size_value: int | None = total_sizes.get(entry.fullpath, 0)
+            else:
+                size_value = entry.size
+
+            row = [
+                entry.source,
+                entry.type,
+                entry.name,
+                entry.fullpath,
+                entry.parent,
+                entry.ext,
+                _format_size(size_value, args.unit),
+                entry.mtime,
+                str(entry.depth),
+            ]
+            if args.resolve_link:
+                row.append(link_by_path.get(entry.fullpath, ""))
+            rows.append(row)
+
+        self._emit(rows, args)
+        return 0
+
+    def _resolve_roots(self, patterns: list[str]) -> list[tuple[str, str]]:
+        from glob import glob
+
+        roots = []
+        for pattern in patterns:
+            matches = glob(pattern) or [pattern]
+            for match in matches:
+                path = Path(match)
+                if not path.exists():
+                    raise SystemExit(f"指定したパスが存在しません: {path}")
+                roots.append((str(path), match))
+        return roots
+
+    def _emit(self, rows: list[list[str]], args: argparse.Namespace) -> None:
+        tsv_text = "\n".join("\t".join(row) for row in rows)
+
+        if args.clip:
+            copy_text_to_clipboard(tsv_text)
+            print("一覧をコピーしました")
+            return
+
+        if args.output:
+            self._write_output(rows, tsv_text, args.output, args.encoding)
+            return
+
+        print(tsv_text)
+
+    def _write_output(
+        self, rows: list[list[str]], tsv_text: str, output: str, encoding: str
+    ) -> None:
+        output_path = Path(output)
+        if output_path.suffix.lower() == ".xlsx":
+            self._write_excel(rows, output_path)
+        else:
+            output_path.write_bytes(
+                tsv_text.encode(encoding, errors="backslashreplace")
+            )
+        logger.info("一覧を書き出しました: %s", output_path)
+        print(output_path)
+
+    def _write_excel(self, rows: list[list[str]], output_path: Path) -> None:
+        import xlsxwriter
+
+        header = rows[0]
+        size_col = header.index("size") if "size" in header else None
+
+        with xlsxwriter.Workbook(str(output_path)) as workbook:
+            worksheet = workbook.add_worksheet("lsdir")
+            header_format = workbook.add_format({"bold": True, "border": 1})
+            worksheet.write_row(0, 0, header, header_format)
+
+            for r, row in enumerate(rows[1:], start=1):
+                for c, value in enumerate(row):
+                    if c == size_col and value:
+                        worksheet.write_number(r, c, float(value))
+                    else:
+                        worksheet.write(r, c, value)
+
+            worksheet.autofilter(0, 0, len(rows) - 1, len(header) - 1)