workpytools 0.1.4__py3-none-any.whl

workpytools/common/textfile.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import unicodedata
+from pathlib import Path
+
+
+class TextFileError(RuntimeError):
+    """Raised when a text file can't be read with any supported encoding."""
+
+
+def normalize_newlines(text: str) -> str:
+    """Normalize CRLF / CR line endings to LF."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def to_crlf(text: str) -> str:
+    """Convert line endings to CRLF, the Windows clipboard convention.
+
+    Normalizes to LF first so that already-CRLF input doesn't become CR CRLF.
+    """
+    return normalize_newlines(text).replace("\n", "\r\n")
+
+
+def read_text_with_fallback(path: Path, encoding: str | None = None) -> str:
+    """Read a text file as UTF-8 (BOM tolerated), falling back to CP932.
+
+    Japanese Windows files are commonly CP932, so a UTF-8-only read would fail
+    on files written with Notepad and similar tools. Passing `encoding`
+    forces that codec with no fallback.
+    """
+    raw = path.read_bytes()
+
+    if encoding is not None:
+        try:
+            return raw.decode(encoding)
+        except UnicodeDecodeError as exc:
+            raise TextFileError(
+                f"指定されたエンコーディング {encoding!r} でファイルを読み込めません: {path}"
+            ) from exc
+
+    try:
+        return raw.decode("utf-8-sig")
+    except UnicodeDecodeError:
+        try:
+            return raw.decode("cp932")
+        except UnicodeDecodeError as exc:
+            raise TextFileError(
+                f"UTF-8/CP932のいずれでもファイルを読み込めません: {path}"
+            ) from exc
+
+
+def display_width(text: str) -> int:
+    """Terminal display width, counting East Asian wide/fullwidth chars as 2.
+
+    `len()` is not usable for column alignment in this project because
+    Japanese text is half the character count of its rendered width.
+    """
+    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in text)
+
+
+def pad_to_width(text: str, width: int) -> str:
+    """Left-align `text` padded with spaces to `width` display columns."""
+    padding = width - display_width(text)
+    return text + " " * max(0, padding)
+
+
+def truncate_to_width(text: str, width: int, ellipsis: str = "...") -> str:
+    """Truncate `text` so it fits within `width` display columns.
+
+    When truncation happens, `ellipsis` is appended and counted toward the
+    limit, so the result never exceeds `width`.
+    """
+    if display_width(text) <= width:
+        return text
+
+    ellipsis_width = display_width(ellipsis)
+    budget = width - ellipsis_width
+    if budget <= 0:
+        return ellipsis[:width]
+
+    result: list[str] = []
+    used = 0
+    for char in text:
+        char_width = display_width(char)
+        if used + char_width > budget:
+            break
+        result.append(char)
+        used += char_width
+
+    return "".join(result) + ellipsis

workpytools/common/walk.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_EXCLUDE = frozenset({".git", ".svn", "node_modules", "__pycache__"})
+
+
+@dataclass(frozen=True)
+class Entry:
+    type: str  # "file" or "dir"
+    name: str
+    fullpath: str
+    parent: str
+    ext: str
+    size: int | None
+    mtime: str
+    depth: int
+    source: str
+
+
+def _mtime_str(stat_result: os.stat_result) -> str:
+    return datetime.fromtimestamp(stat_result.st_mtime).strftime("%Y/%m/%d %H:%M")
+
+
+def walk(
+    root: str,
+    source_label: str,
+    exclude: frozenset[str] = _DEFAULT_EXCLUDE,
+    include_temp: bool = False,
+) -> tuple[list[Entry], int]:
+    """Walk `root` with an explicit stack (not recursion): measured ~27%
+    faster than a recursive generator, and immune to RecursionError on very
+    deep trees (see doc/lsdir.md for the benchmark).
+
+    Uses os.scandir + DirEntry.stat() rather than os.walk + os.stat(), since
+    DirEntry.stat() reuses information already fetched by scandir() instead
+    of making another syscall per entry (measured ~18% faster).
+
+    Returns (entries, skipped_dir_count). Directories that raise on access
+    are logged as warnings and skipped rather than aborting the whole walk.
+    """
+    entries: list[Entry] = []
+    skipped = 0
+
+    # (path, depth) スタック。再帰ではなく明示スタックにすることで、
+    # 深い階層でも RecursionError にならず、実測でも速い。
+    stack: list[tuple[str, int]] = [(root, 0)]
+
+    while stack:
+        current, depth = stack.pop()
+
+        try:
+            with os.scandir(current) as scan_it:
+                dir_entries = list(scan_it)
+        except OSError as exc:
+            skipped += 1
+            logger.warning("フォルダにアクセスできないためスキップします: %s (%s)", current, exc)
+            continue
+
+        for dir_entry in dir_entries:
+            if dir_entry.name in exclude:
+                continue
+            if not include_temp and dir_entry.name.startswith("~$"):
+                continue
+
+            try:
+                is_dir = dir_entry.is_dir(follow_symlinks=False)
+                stat_result = dir_entry.stat(follow_symlinks=False)
+            except OSError as exc:
+                logger.warning("エントリを読めないためスキップします: %s (%s)", dir_entry.path, exc)
+                continue
+
+            new_depth = depth + 1
+            ext = "" if is_dir else os.path.splitext(dir_entry.name)[1]
+
+            entries.append(
+                Entry(
+                    type="dir" if is_dir else "file",
+                    name=dir_entry.name,
+                    fullpath=dir_entry.path,
+                    parent=current,
+                    ext=ext,
+                    size=None if is_dir else stat_result.st_size,
+                    mtime=_mtime_str(stat_result),
+                    depth=new_depth,
+                    source=source_label,
+                )
+            )
+
+            if is_dir:
+                stack.append((dir_entry.path, new_depth))
+
+    return entries, skipped
+
+
+def dedupe_by_fullpath(entries: list[Entry]) -> tuple[list[Entry], int]:
+    """Remove entries whose normalized full path was already seen (for
+    overlapping roots, e.g. `lsdir C:\\work C:\\work\\sub`). Windows paths
+    are case-insensitive, so normcase() is used for the comparison key.
+    """
+    seen: set[str] = set()
+    result = []
+    skipped = 0
+    for entry in entries:
+        key = os.path.normcase(os.path.abspath(entry.fullpath))
+        if key in seen:
+            skipped += 1
+            continue
+        seen.add(key)
+        result.append(entry)
+    return result, skipped
+
+
+def compute_total_sizes(entries: list[Entry]) -> dict[str, int]:
+    """Total size in bytes of everything under each directory entry's path.
+
+    Requires a full walk to have already completed (can't be streamed),
+    which is why --total-size is opt-in rather than the default.
+    """
+    totals: dict[str, int] = {}
+    # 深い順（depthが大きい順）に処理すれば、子の合計を親に一度で足し込める
+    for entry in sorted(entries, key=lambda e: -e.depth):
+        if entry.type == "file" and entry.size is not None:
+            totals[entry.parent] = totals.get(entry.parent, 0) + entry.size
+        elif entry.type == "dir":
+            own_total = totals.get(entry.fullpath, 0)
+            totals[entry.parent] = totals.get(entry.parent, 0) + own_total
+    return totals

workpytools/data/synonym.tsv

@@ -0,0 +1,3 @@
+# cwc既定の同義語辞書（TSV: 代表語\t異表記1\t異表記2\t...）
+# 行頭が # の行はコメント。既定の区切り文字分割経路（--semantic）専用。
+なし	特になし	特にない	ない

workpytools/data/user.dic

@@ -0,0 +1,2 @@
+# cwc既定のユーザー辞書（Janome simpledic形式: 表層形,品詞,読み）
+# 固有名詞や社内用語をここに追記して育てる。

workpytools/processing/base.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import argparse
+from abc import ABC, abstractmethod
+
+
+class Processor(ABC):
+    """Base class for a single processing command.
+
+    Subclass this in a new module under `tools/processing/` and it will be
+    picked up automatically as a `tools <name>` subcommand.
+    """
+
+    name: str
+    help: str = ""
+
+    @abstractmethod
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        """Register this processor's CLI arguments on `parser`."""
+
+    @abstractmethod
+    def run(self, args: argparse.Namespace) -> int:
+        """Execute the processing. Return a process exit code."""

workpytools/processing/clipfmt.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+
+from workpytools.common.clipboard import copy_text_to_clipboard, get_clipboard_text
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+# 引用の入れ子(`>`の繰り返し)とインデントを保ったまま、行頭の箇条書き記号 */+ を捉える。
+_BULLET_RE = re.compile(r"^((?:>\s*)*)([ \t]*)([*+])(\s+)(.*)$")
+
+
+def _is_horizontal_rule(line: str) -> bool:
+    """`* * *` / `- - -` / `___` などのCommonMark水平線かどうか。"""
+    stripped = line.strip()
+    if not stripped:
+        return False
+    without_spaces = stripped.replace(" ", "")
+    chars = set(without_spaces)
+    if len(chars) != 1:
+        return False
+    ch = next(iter(chars))
+    if ch not in "*-_":
+        return False
+    return len(without_spaces) >= 3
+
+
+def normalize_bullet_markers(text: str) -> tuple[str, bool]:
+    """Rewrite leading `*`/`+` bullet markers to `-` so mdformat treats a
+    hand-typed mixed-marker list as one list instead of splitting it into
+    alternating adjacent lists. Returns (rewritten_text, changed).
+
+    Code fences and indented code blocks are left untouched; horizontal
+    rules (`* * *`) and emphasis (`**bold**`, `*italic*`) are not mistaken
+    for bullets.
+    """
+    lines = text.split("\n")
+    out: list[str] = []
+    in_fence = False
+    changed = False
+    prev_line_is_list_item = False
+
+    for line in lines:
+        stripped_left = line.lstrip()
+
+        if stripped_left.startswith("```") or stripped_left.startswith("~~~"):
+            in_fence = not in_fence
+            out.append(line)
+            prev_line_is_list_item = False
+            continue
+        if in_fence:
+            out.append(line)
+            continue
+
+        if not line.strip():
+            out.append(line)
+            continue
+
+        leading_spaces = len(line) - len(line.lstrip(" "))
+        if leading_spaces >= 4 and not prev_line_is_list_item:
+            # インデントコードブロックの可能性が高いため触らない
+            out.append(line)
+            prev_line_is_list_item = False
+            continue
+
+        if _is_horizontal_rule(line):
+            out.append(line)
+            prev_line_is_list_item = False
+            continue
+
+        match = _BULLET_RE.match(line)
+        if match:
+            quote_prefix, indent, marker, spacing, rest = match.groups()
+            if marker != "-":
+                changed = True
+            out.append(f"{quote_prefix}{indent}-{spacing}{rest}")
+            prev_line_is_list_item = True
+            continue
+
+        out.append(line)
+        prev_line_is_list_item = False
+
+    return "\n".join(out), changed
+
+
+def format_markdown(text: str) -> str:
+    import mdformat
+
+    result: str = mdformat.text(text, extensions={"tables"})
+    return result
+
+
+class ClipfmtProcessor(Processor):
+    """Format the clipboard's Markdown text (mdformat) and write it back.
+
+    Always reads CF_UNICODETEXT (CF_HTML, if present, is ignored) and writes
+    only CF_UNICODETEXT back -- formatting doesn't change the document's
+    format, so there's nothing rich-text-specific to set.
+    """
+
+    name = "clipfmt"
+    help = "クリップボードのMarkdownを整形する"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--no-normalize-bullets",
+            action="store_true",
+            help="箇条書き記号(*/+)を-に統一する前処理を行わない",
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        try:
+            source_text = get_clipboard_text()
+        except Exception as exc:
+            raise SystemExit("整形対象のテキストがありません") from exc
+
+        text_to_format = source_text
+        if not args.no_normalize_bullets:
+            text_to_format, bullets_changed = normalize_bullet_markers(source_text)
+            if bullets_changed:
+                logger.info("箇条書き記号を - に統一しました")
+
+        try:
+            formatted = format_markdown(text_to_format)
+        except Exception as exc:
+            raise SystemExit(
+                f"Markdownの整形に失敗しました（クリップボードは変更していません）: {exc}"
+            ) from exc
+
+        if not formatted.strip():
+            raise SystemExit("整形結果が空です")
+
+        if formatted == source_text:
+            logger.info("整形の必要はありませんでした（既に整形済みです）")
+        else:
+            logger.info("整形により内容が変わりました")
+
+        copy_text_to_clipboard(formatted)
+        print("整形しました")
+        return 0

workpytools/processing/clipmd.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import argparse
+import logging
+
+from workpytools.common.clipboard import (
+    copy_html_and_text_to_clipboard,
+    copy_text_to_clipboard,
+    get_clipboard_html_fragment,
+    get_clipboard_text,
+    has_clipboard_html,
+    has_clipboard_text,
+)
+from workpytools.common.markdown_html import markdown_to_html_fragment
+from workpytools.processing.base import Processor
+
+logger = logging.getLogger(__name__)
+
+
+def _preprocess_table_html(soup: object) -> list[str]:
+    """Rewrite <table> elements for markdownify: promote first row to <thead> when
+    missing, pad colspan/rowspan cells with empty cells so column counts line up.
+    Returns warning messages describing what was rewritten or will be lost.
+    """
+    from bs4 import Tag
+
+    warnings: list[str] = []
+
+    for table in soup.find_all("table"):  # type: ignore[attr-defined]
+        if not table.find("thead"):
+            rows = table.find_all("tr")
+            if rows:
+                first_row = rows[0]
+                for cell in first_row.find_all("td"):
+                    cell.name = "th"
+                thead = soup.new_tag("thead")  # type: ignore[attr-defined]
+                first_row.wrap(thead)
+
+        for row in table.find_all("tr"):
+            for cell in row.find_all(["td", "th"]):
+                colspan = cell.get("colspan")
+                if colspan and int(colspan) > 1:
+                    n = int(colspan) - 1
+                    warnings.append(
+                        f"表のセル結合(colspan={colspan})を検出したため、空セルで列数を揃えました"
+                    )
+                    del cell["colspan"]
+                    for _ in range(n):
+                        empty: Tag = soup.new_tag(cell.name)  # type: ignore[attr-defined]
+                        cell.insert_after(empty)
+                if cell.get("rowspan"):
+                    warnings.append(
+                        f"表のセル結合(rowspan={cell.get('rowspan')})を検出しました"
+                        "（行方向の結合は補完されません）"
+                    )
+                    del cell["rowspan"]
+
+            for cell in row.find_all(["td", "th"]):
+                if cell.find(["p", "ul", "ol", "br"]):
+                    warnings.append("表のセル内に改行やリストがあり、情報が失われました")
+                if cell.find("img"):
+                    warnings.append("表のセル内の画像は変換で失われました")
+
+    return warnings
+
+
+def _collect_alignment(soup: object) -> dict[int, dict[int, str]]:
+    """Collect per-table, per-column text-align, keyed by table index then column index."""
+    alignments: dict[int, dict[int, str]] = {}
+    for table_idx, table in enumerate(soup.find_all("table")):  # type: ignore[attr-defined]
+        header_row = table.find("tr")
+        if header_row is None:
+            continue
+        col_aligns: dict[int, str] = {}
+        for col_idx, cell in enumerate(header_row.find_all(["th", "td"])):
+            style = cell.get("style", "")
+            if "text-align:right" in style or "text-align: right" in style:
+                col_aligns[col_idx] = "right"
+            elif "text-align:center" in style or "text-align: center" in style:
+                col_aligns[col_idx] = "center"
+            elif "text-align:left" in style or "text-align: left" in style:
+                col_aligns[col_idx] = "left"
+        if col_aligns:
+            alignments[table_idx] = col_aligns
+    return alignments
+
+
+def _apply_alignment_to_markdown(markdown_text: str, alignments: dict[int, dict[int, str]]) -> str:
+    """Rewrite Markdown table separator rows (`| --- |`) to reflect collected alignment."""
+    if not alignments:
+        return markdown_text
+
+    lines = markdown_text.split("\n")
+    table_idx = -1
+    result = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        is_separator = (
+            line.strip().startswith("|")
+            and set(line.replace("|", "").replace("-", "").replace(":", "").strip()) == set()
+            and "-" in line
+        )
+        if is_separator and i > 0 and lines[i - 1].strip().startswith("|"):
+            table_idx += 1
+            col_aligns = alignments.get(table_idx, {})
+            cols = [c.strip() for c in line.strip().strip("|").split("|")]
+            new_cols = []
+            for col_idx, _ in enumerate(cols):
+                align = col_aligns.get(col_idx)
+                if align == "right":
+                    new_cols.append("---:")
+                elif align == "center":
+                    new_cols.append(":---:")
+                elif align == "left":
+                    new_cols.append(":---")
+                else:
+                    new_cols.append("---")
+            result.append("| " + " | ".join(new_cols) + " |")
+        else:
+            result.append(line)
+        i += 1
+    return "\n".join(result)
+
+
+def _collect_image_warnings(soup: object) -> list[str]:
+    warnings: list[str] = []
+    for img in soup.find_all("img"):  # type: ignore[attr-defined]
+        src = img.get("src", "")
+        if src.startswith("file:///"):
+            if "msohtmlclip" in src.lower():
+                warnings.append(
+                    "画像がWord由来の一時ファイルを参照しています"
+                    f"（後でリンクが切れる可能性があります）: {src}"
+                )
+            else:
+                warnings.append(
+                    "画像がローカルの一時ファイルらしきパスを参照しています"
+                    f"（後でリンクが切れる可能性があります）: {src}"
+                )
+        elif src.startswith("data:"):
+            b64_part = src.split(",", 1)[1] if "," in src else ""
+            size_kb = len(b64_part) * 3 / 4 / 1024
+            warnings.append(f"データURI画像を検出しました（約{size_kb:.1f}KBの1行になります）")
+    return warnings
+
+
+def html_to_markdown(html_fragment: str) -> str:
+    from bs4 import BeautifulSoup
+    from markdownify import MarkdownConverter
+
+    soup = BeautifulSoup(html_fragment, "html.parser")
+
+    for warning in _preprocess_table_html(soup):
+        logger.warning(warning)
+    for warning in _collect_image_warnings(soup):
+        logger.warning(warning)
+
+    alignments = _collect_alignment(soup)
+
+    markdown_text = MarkdownConverter().convert_soup(soup).strip()
+    markdown_text = _apply_alignment_to_markdown(markdown_text, alignments)
+    return markdown_text
+
+
+class ClipmdProcessor(Processor):
+    """Convert clipboard contents between Markdown and rich text (HTML).
+
+    Direction is auto-detected from what's on the clipboard: CF_HTML present
+    means rich text was copied (convert HTML -> Markdown); CF_UNICODETEXT
+    only means plain text was copied (convert Markdown -> rich text).
+    """
+
+    name = "clipmd"
+    help = "クリップボードのMarkdownとリッチテキストを相互変換する"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        group = parser.add_mutually_exclusive_group()
+        group.add_argument(
+            "--to-markdown", action="store_true", help="入力をHTMLとみなしMarkdownに変換する"
+        )
+        group.add_argument(
+            "--to-rich", action="store_true", help="入力をMarkdownとみなしリッチテキストに変換する"
+        )
+
+    def run(self, args: argparse.Namespace) -> int:
+        direction, use_html_source = self._resolve_direction(args)
+
+        if direction == "to_markdown":
+            fragment = get_clipboard_html_fragment() if use_html_source else get_clipboard_text()
+            markdown_text = html_to_markdown(fragment)
+            if not markdown_text.strip():
+                raise SystemExit("変換結果が空です")
+            copy_text_to_clipboard(markdown_text)
+            print("HTML → Markdown に変換しました")
+        else:
+            source_text = get_clipboard_text()
+            html_fragment = markdown_to_html_fragment(source_text)
+            if not html_fragment.strip():
+                raise SystemExit("変換結果が空です")
+            copy_html_and_text_to_clipboard(html_fragment, source_text)
+            print("Markdown → リッチテキスト に変換しました")
+
+        return 0
+
+    def _resolve_direction(self, args: argparse.Namespace) -> tuple[str, bool]:
+        """Returns (direction, use_html_source_for_markdown_conversion)."""
+        has_html = has_clipboard_html()
+        has_text = has_clipboard_text()
+
+        if args.to_markdown:
+            if not has_html and not has_text:
+                raise SystemExit("変換できるテキストがありません")
+            if not has_html:
+                logger.info(
+                    "--to-markdown指定: CF_HTMLが無いためCF_UNICODETEXTをHTMLソースとして解釈します"
+                )
+                return "to_markdown", False
+            return "to_markdown", True
+
+        if args.to_rich:
+            if not has_text:
+                raise SystemExit("変換できるテキストがありません")
+            if has_html:
+                logger.info(
+                    "--to-rich指定: CF_HTMLを無視しCF_UNICODETEXTをMarkdownとして解釈します"
+                )
+            return "to_rich", False
+
+        if has_html:
+            logger.info("CF_HTMLを検出したため HTML → Markdown に変換します")
+            return "to_markdown", True
+        if has_text:
+            logger.info("CF_UNICODETEXTのみのため Markdown → リッチテキスト に変換します")
+            return "to_rich", False
+
+        raise SystemExit("変換できるテキストがありません")