workpytools 0.1.4__py3-none-any.whl

workpytools/common/outline_parse.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from workpytools.common.textfile import normalize_newlines
+
+_HEADING_RE = re.compile(r"^#{1,6} .+")
+
+
+@dataclass(frozen=True)
+class OutlineItem:
+    title: str
+    body: str  # "\n"-joined when multi-line; "" when there's no body
+
+
+def parse_outline(text: str) -> list[OutlineItem]:
+    """Auto-detect one of three outline formats and extract title/body pairs.
+
+    Tried in order: Markdown headings, tab-separated lines, blank-line-
+    delimited blocks (the fallback for anything that matches neither).
+    """
+    normalized = normalize_newlines(text)
+    lines = normalized.split("\n")
+
+    if any(_HEADING_RE.match(line) for line in lines):
+        return _parse_markdown_headings(lines)
+    if "\t" in normalized:
+        return _parse_tab_separated(lines)
+    return _parse_blank_line_blocks(normalized)
+
+
+def _parse_markdown_headings(lines: list[str]) -> list[OutlineItem]:
+    items: list[OutlineItem] = []
+    title: str | None = None
+    body_lines: list[str] = []
+
+    def flush() -> None:
+        if title is not None:
+            trimmed = list(body_lines)
+            while trimmed and not trimmed[-1].strip():
+                trimmed.pop()
+            items.append(OutlineItem(title=title, body="\n".join(trimmed)))
+
+    for line in lines:
+        if _HEADING_RE.match(line):
+            flush()
+            title = line.split(" ", 1)[1].strip()
+            body_lines = []
+        elif title is not None:
+            body_lines.append(line)
+    flush()
+
+    return items
+
+
+def _parse_tab_separated(lines: list[str]) -> list[OutlineItem]:
+    items: list[OutlineItem] = []
+    for line in lines:
+        if not line.strip():
+            continue
+        if "\t" in line:
+            title, body = line.split("\t", 1)
+            items.append(OutlineItem(title=title.strip(), body=body.strip()))
+        else:
+            items.append(OutlineItem(title=line.strip(), body=""))
+    return items
+
+
+def _parse_blank_line_blocks(normalized: str) -> list[OutlineItem]:
+    blocks = re.split(r"\n\s*\n", normalized.strip())
+    items: list[OutlineItem] = []
+    for block in blocks:
+        block = block.strip("\n")
+        if not block.strip():
+            continue
+        block_lines = block.split("\n")
+        title = block_lines[0].strip()
+        body = "\n".join(block_lines[1:]).strip("\n")
+        items.append(OutlineItem(title=title, body=body))
+    return items

workpytools/common/output.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import Protocol
+
+from PIL import Image
+
+from workpytools.common.clipboard import SourceKind, copy_file_to_clipboard, copy_image_to_clipboard
+
+
+class HasSource(Protocol):
+    """Structural type for anything that knows where its input data came from.
+
+    `LoadedImage` and `LoadedText` both satisfy this. Attributes are declared
+    as read-only properties because Protocol treats mutable attributes as
+    invariant — a plain `source_kind: SourceKind` field would fail mypy
+    strict unless the implementing class declares the exact same type.
+    """
+
+    @property
+    def source_path(self) -> Path | None: ...
+    @property
+    def source_kind(self) -> SourceKind: ...
+
+
+def save_result(
+    loaded: HasSource, result: Image.Image, command: str, output: str | None
+) -> Path | None:
+    """Save `result` following the shared output convention across all commands.
+
+    - `output` explicitly given: save there, no clipboard interaction.
+    - `source_kind == "path"`: save next to the source file as
+      `{stem}_{command}.png`.
+    - `source_kind == "clipboard_file"` (a file copied in Explorer): save
+      under the OS temp dir as `{stem}_{command}.png` and put that file on
+      the clipboard, ready to paste.
+    - otherwise (`clipboard_data` / `clipboard_text`, no source file): don't
+      save to disk; put the processed image directly on the clipboard as data.
+
+    Returns the path written to disk, or `None` when the result was only
+    placed on the clipboard as raw image data.
+    """
+    if output is not None:
+        output_path = Path(output)
+        result.save(output_path)
+        return output_path
+
+    if loaded.source_kind == "path":
+        assert loaded.source_path is not None
+        output_path = loaded.source_path.with_name(f"{loaded.source_path.stem}_{command}.png")
+        result.save(output_path)
+        return output_path
+
+    if loaded.source_kind == "clipboard_file":
+        assert loaded.source_path is not None
+        tmpdir = Path(tempfile.gettempdir())
+        output_path = tmpdir / f"{loaded.source_path.stem}_{command}.png"
+        result.save(output_path)
+        copy_file_to_clipboard(output_path)
+        return output_path
+
+    copy_image_to_clipboard(result)
+    return None
+
+
+def describe_output(output_path: Path | None) -> str:
+    """Human-readable line for `print()` after `save_result`."""
+    if output_path is not None:
+        return str(output_path)
+    return "(クリップボードに画像データをコピーしました)"

workpytools/common/powerpoint.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+import win32com.client
+
+
+class PowerPointNotRunningError(RuntimeError):
+    """Raised when no running PowerPoint instance can be attached to."""
+
+
+class NoActivePresentationError(RuntimeError):
+    """Raised when PowerPoint is running but has no active window
+    (e.g. Presentations.Count == 0)."""
+
+
+def get_running_powerpoint() -> Any:
+    """Attach to an already-running PowerPoint Application via COM.
+
+    Never launches a new instance -- deciding whether to start one is left
+    to the caller, since that's a per-command policy (outline does; ikko
+    and mokuji don't).
+    """
+    try:
+        return win32com.client.GetActiveObject("PowerPoint.Application")
+    except Exception as exc:
+        raise PowerPointNotRunningError(
+            "PowerPointが起動していません"
+        ) from exc
+
+
+def get_active_presentation(app: Any) -> Any:
+    """Return the presentation behind the focused window.
+
+    Uses ActiveWindow.Presentation rather than ActivePresentation so that,
+    with multiple PowerPoint windows open, the one currently focused wins.
+    """
+    try:
+        return app.ActiveWindow.Presentation
+    except Exception as exc:
+        raise NoActivePresentationError(
+            "PowerPointでプレゼンテーションが開かれていません"
+        ) from exc

workpytools/common/shape_cluster.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+LEFT_TOLERANCE = 1.0  # points
+LINE_STEP_MIN_RATIO = 0.8
+LINE_STEP_MAX_RATIO = 2.2
+
+
+@dataclass(frozen=True)
+class ShapeInfo:
+    """A text-carrying shape's geometry, style, and a reference back to the
+    underlying COM shape object (opaque to this module -- clustering never
+    touches it directly)."""
+
+    left: float
+    top: float
+    width: float
+    height: float
+    text: str
+    font_name: str | None
+    font_size: float | None
+    bold: int | None  # COM returns 0 / -1, not a Python bool
+    color: int | None
+    alignment: int | None
+    ref: object
+
+
+def cluster_shapes(
+    shapes: list[ShapeInfo],
+    left_tolerance: float = LEFT_TOLERANCE,
+    line_step_min_ratio: float = LINE_STEP_MIN_RATIO,
+    line_step_max_ratio: float = LINE_STEP_MAX_RATIO,
+) -> list[list[ShapeInfo]]:
+    """Group adjacent shapes that look like consecutive lines of one
+    paragraph, sorted left-then-top so clustering is independent of input
+    order.
+    """
+    ordered = sorted(shapes, key=lambda s: (s.left, s.top))
+    if not ordered:
+        return []
+
+    clusters: list[list[ShapeInfo]] = [[ordered[0]]]
+
+    for prev, curr in zip(ordered, ordered[1:], strict=False):
+        if _same_cluster(prev, curr, left_tolerance, line_step_min_ratio, line_step_max_ratio):
+            clusters[-1].append(curr)
+        else:
+            clusters.append([curr])
+
+    return clusters
+
+
+def _same_cluster(
+    prev: ShapeInfo,
+    curr: ShapeInfo,
+    left_tolerance: float,
+    line_step_min_ratio: float,
+    line_step_max_ratio: float,
+) -> bool:
+    same_style = (
+        prev.font_name == curr.font_name
+        and prev.font_size == curr.font_size
+        and prev.bold == curr.bold
+        and prev.color == curr.color
+    )
+    same_left = abs(prev.left - curr.left) <= left_tolerance
+
+    size = prev.font_size
+    if not size:
+        return False
+    line_step = curr.top - prev.top
+    step_ok = (size * line_step_min_ratio) <= line_step <= (size * line_step_max_ratio)
+
+    return same_style and same_left and step_ok

workpytools/common/table_shapes.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+GAP_RATIO = 0.05  # margin between decomposed shapes, as a fraction of cell size
+GRID_TOLERANCE = 1.0  # points, same reasoning as ikko's LEFT_TOLERANCE
+
+
+@dataclass(frozen=True)
+class CellSpacing:
+    """Cumulative left/top offset and unchanged width/height for one cell,
+    after inserting a gap-ratio margin before each column/row."""
+
+    left: float
+    top: float
+    width: float
+    height: float
+
+
+def compute_spaced_positions(
+    sizes: list[float], gap_ratio: float = GAP_RATIO
+) -> list[tuple[float, float]]:
+    """For a sequence of column widths (or row heights), return
+    (new_offset, gap_used) pairs computed with the cursor method: advance by
+    this cell's gap, record the offset, then advance by its size.
+
+    Offsets are relative to 0; callers add the table's own Left/Top.
+    """
+    cursor = 0.0
+    result = []
+    for size in sizes:
+        gap = size * gap_ratio
+        cursor += gap
+        result.append((cursor, gap))
+        cursor += size
+    return result
+
+
+@dataclass(frozen=True)
+class GridShape:
+    """A shape's geometry and a reference back to the underlying COM object
+    (opaque to this module), used as input to grid estimation."""
+
+    left: float
+    top: float
+    width: float
+    height: float
+    ref: object
+
+
+@dataclass(frozen=True)
+class GridPosition:
+    row: int
+    col: int
+    shape: GridShape
+
+
+class DuplicateGridPositionError(RuntimeError):
+    """Raised when two or more shapes map to the same (row, col)."""
+
+
+def estimate_grid(
+    shapes: list[GridShape], tolerance: float = GRID_TOLERANCE
+) -> tuple[list[GridPosition], int, int]:
+    """Cluster shapes' Left values into columns and Top values into rows,
+    independent of whether gaps between shapes are uniform.
+
+    Returns (positions, row_count, col_count). Raises
+    DuplicateGridPositionError if two shapes land on the same grid cell.
+    """
+    col_starts = _cluster_axis([s.left for s in shapes], tolerance)
+    row_starts = _cluster_axis([s.top for s in shapes], tolerance)
+
+    positions: list[GridPosition] = []
+    seen: set[tuple[int, int]] = set()
+    for shape in shapes:
+        col = _index_of_cluster(shape.left, col_starts, tolerance)
+        row = _index_of_cluster(shape.top, row_starts, tolerance)
+        if (row, col) in seen:
+            raise DuplicateGridPositionError(
+                f"同じセル位置に複数のシェイプが重なっています (row={row}, col={col})"
+            )
+        seen.add((row, col))
+        positions.append(GridPosition(row=row, col=col, shape=shape))
+
+    return positions, len(row_starts), len(col_starts)
+
+
+def _cluster_axis(values: list[float], tolerance: float) -> list[float]:
+    """Sort and greedily chain-merge values within `tolerance` of the
+    previous value, so a run like 0.0, 0.9, 1.8, 2.7 (each step within
+    tolerance, but the ends 2.7 apart) becomes one cluster rather than
+    splitting on absolute distance from the first member. This intentionally
+    favors simplicity over guarding against chained drift, since a table's
+    columns/rows are normally cleanly separated in practice.
+    """
+    ordered = sorted(values)
+    clusters: list[float] = []
+    for value in ordered:
+        if not clusters or value - clusters[-1] > tolerance:
+            clusters.append(value)
+    return clusters
+
+
+def _index_of_cluster(value: float, cluster_starts: list[float], tolerance: float) -> int:
+    """Find which cluster `value` belongs to, using the same chained
+    tolerance test as `_cluster_axis`: the closest cluster start at or
+    below `value` within `tolerance`, falling back to nearest overall.
+    """
+    best_index = 0
+    best_distance = abs(value - cluster_starts[0])
+    for i, start in enumerate(cluster_starts):
+        distance = abs(value - start)
+        if distance < best_distance:
+            best_distance = distance
+            best_index = i
+    return best_index
+
+
+def column_and_row_sizes(
+    positions: list[GridPosition], n_rows: int, n_cols: int
+) -> tuple[list[float], list[float]]:
+    """Per-column max width and per-row max height, taken only from shapes
+    that actually landed in that column/row. A cell (row, col) can be a gap
+    (no shape there) and still get a nonzero size from other shapes sharing
+    its row or column; only a row/col with zero shapes anywhere in it would
+    read 0.0, which can't happen here since estimate_grid only ever
+    produces rows/columns backed by at least one real shape's coordinate.
+    """
+    col_width = [0.0] * n_cols
+    row_height = [0.0] * n_rows
+    for pos in positions:
+        col_width[pos.col] = max(col_width[pos.col], pos.shape.width)
+        row_height[pos.row] = max(row_height[pos.row], pos.shape.height)
+    return col_width, row_height
+
+
+def grid_centers(
+    col_width: list[float], row_height: list[float], overall_left: float, overall_top: float
+) -> tuple[list[float], list[float]]:
+    """Center x/y of each column/row, laid out with the cursor method
+    (no gap between cells -- sizes alone determine the pitch) starting at
+    the grid's own top-left corner.
+    """
+    center_x = []
+    cursor_x = overall_left
+    for width in col_width:
+        center_x.append(cursor_x + width / 2)
+        cursor_x += width
+
+    center_y = []
+    cursor_y = overall_top
+    for height in row_height:
+        center_y.append(cursor_y + height / 2)
+        cursor_y += height
+
+    return center_x, center_y

workpytools/common/tabular.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import csv
+import io
+import json
+from collections import Counter
+from dataclasses import dataclass
+from itertools import zip_longest
+from pathlib import Path
+
+from workpytools.common.textfile import read_text_with_fallback
+
+DEFAULT_EMPTY_VALUES = frozenset(
+    {None, "", "N/A", "NULL", "null", "None", "none", "-", "NaN"}
+)
+
+_BOOL_TAG_PREFIX = "\x00bool\x00"
+
+
+@dataclass(frozen=True)
+class Table:
+    """A single sheet/file worth of tabular data: column names plus row-major values."""
+
+    columns: list[str]
+    rows: list[tuple[object, ...]]
+
+
+@dataclass(frozen=True)
+class ColumnProfile:
+    column: str
+    rows: int
+    filled: int
+    empty: int
+    unique: int
+    is_filled: bool
+    is_unique: bool
+    fill_rate: float
+    unique_rate: float
+    key_score: float
+    top: list[tuple[str, int]]
+
+
+def normalize_value(value: object) -> object:
+    """Fold Excel's int/float ambiguity (1 vs 1.0) and trim incidental whitespace.
+
+    Values are compared as strings elsewhere, but this keeps `1` and `1.0`
+    (a common artifact of Excel cell formatting) from being counted as
+    distinct values. `bool` is tagged so `True` (the value) and `"True"`
+    (the string) don't collide once both are stringified.
+    """
+    if isinstance(value, bool):
+        return f"{_BOOL_TAG_PREFIX}{value}"
+    if isinstance(value, float) and value.is_integer():
+        return str(int(value))
+    if isinstance(value, str):
+        return value.strip()
+    if value is None:
+        return None
+    return str(value)
+
+
+def is_empty(value: object, empty_values: frozenset[object]) -> bool:
+    if value in empty_values:
+        return True
+    if isinstance(value, str) and value.strip() == "":
+        return True
+    return False
+
+
+def profile_columns(
+    table: Table,
+    top_n: int = 10,
+    empty_values: frozenset[object] = DEFAULT_EMPTY_VALUES,
+) -> list[ColumnProfile]:
+    """Profile every column of `table`.
+
+    Rows are transposed with `zip_longest` before counting (measured faster
+    than a single pass that updates one Counter per column per row: see
+    doc/profiler.md for the benchmark). Ragged rows are padded with None by
+    `zip_longest`, so uneven row lengths don't misalign columns.
+    """
+    n_rows = len(table.rows)
+    results: list[ColumnProfile] = []
+
+    if n_rows == 0:
+        columns_by_index: list[tuple[int, tuple[object, ...]]] = [
+            (i, ()) for i in range(len(table.columns))
+        ]
+    else:
+        columns_by_index = list(enumerate(zip_longest(*table.rows)))
+
+    for col_idx, raw_values in columns_by_index:
+        name = table.columns[col_idx] if col_idx < len(table.columns) else str(col_idx)
+        normalized = [normalize_value(v) for v in raw_values]
+        counter = Counter(v for v in normalized if not is_empty(v, empty_values))
+
+        filled = sum(counter.values())
+        empty = n_rows - filled
+        unique = len(counter)
+
+        fill_rate = filled / n_rows if n_rows else 0.0
+        unique_rate = unique / n_rows if n_rows else 0.0
+        key_score = _harmonic_mean(fill_rate, unique_rate)
+
+        top = counter.most_common(top_n) if top_n > 0 else []
+
+        results.append(
+            ColumnProfile(
+                column=name,
+                rows=n_rows,
+                filled=filled,
+                empty=empty,
+                unique=unique,
+                is_filled=filled == n_rows,
+                is_unique=unique == n_rows,
+                fill_rate=fill_rate,
+                unique_rate=unique_rate,
+                key_score=key_score,
+                top=[(_display_value(v), c) for v, c in top],
+            )
+        )
+
+    return results
+
+
+def _display_value(value: object) -> str:
+    """Undo normalize_value's internal bool tagging for display purposes."""
+    if isinstance(value, str) and value.startswith(_BOOL_TAG_PREFIX):
+        return value[len(_BOOL_TAG_PREFIX) :]
+    return str(value)
+
+
+def _harmonic_mean(a: float, b: float) -> float:
+    if a <= 0 or b <= 0:
+        return 0.0
+    return 2 * a * b / (a + b)
+
+
+def format_top(top: list[tuple[str, int]]) -> str:
+    """`値(件数) / 値(件数)`, space-padded around `/` to reduce ambiguity
+    with slashes that appear inside values (dates, paths).
+    """
+    return " / ".join(f"{value}({count})" for value, count in top)
+
+
+# --- 入力の読み込み ---
+
+
+def read_csv_like(text: str, sep: str, header_row: int | None) -> Table:
+    reader = csv.reader(io.StringIO(text), delimiter=sep)
+    all_rows: list[tuple[object, ...]] = [tuple(row) for row in reader if row]
+
+    if header_row is None:
+        columns = [str(i) for i in range(len(all_rows[0]))] if all_rows else []
+        data_rows = all_rows
+    else:
+        columns = [str(c) for c in all_rows[header_row]] if header_row < len(all_rows) else []
+        data_rows = all_rows[header_row + 1 :]
+
+    return Table(columns=columns, rows=data_rows)
+
+
+def read_json_records(text: str) -> Table:
+    """Accepts either a JSON array of objects, or JSON Lines (one object per line).
+
+    Nested values (dict/list) are kept as JSON strings rather than flattened;
+    this is a flat-table profiler, not a schema explorer.
+    """
+    stripped = text.strip()
+    if stripped.startswith("["):
+        records = json.loads(stripped)
+    else:
+        records = [json.loads(line) for line in stripped.splitlines() if line.strip()]
+
+    columns: list[str] = []
+    seen_columns: set[str] = set()
+    for record in records:
+        for key in record:
+            if key not in seen_columns:
+                seen_columns.add(key)
+                columns.append(key)
+
+    rows = []
+    for record in records:
+        row = []
+        for col in columns:
+            value = record.get(col)
+            if isinstance(value, (dict, list)):
+                value = json.dumps(value, ensure_ascii=False)
+            row.append(value)
+        rows.append(tuple(row))
+
+    return Table(columns=columns, rows=rows)
+
+
+def read_excel_tables(path: Path, header_row: int | None) -> dict[str, Table]:
+    """Read every sheet, read_only for speed (measured ~27% faster than the
+    default mode; see doc/profiler.md). Excel is far slower to read than CSV
+    of the same size regardless, so this only narrows the gap.
+    """
+    import openpyxl
+
+    workbook = openpyxl.load_workbook(path, read_only=True, data_only=True)
+    try:
+        result: dict[str, Table] = {}
+        for sheet_name in workbook.sheetnames:
+            worksheet = workbook[sheet_name]
+            all_rows = [row for row in worksheet.iter_rows(values_only=True) if row]
+
+            if header_row is None:
+                columns = [str(i) for i in range(len(all_rows[0]))] if all_rows else []
+                data_rows = all_rows
+            else:
+                columns = (
+                    [str(c) if c is not None else "" for c in all_rows[header_row]]
+                    if header_row < len(all_rows)
+                    else []
+                )
+                data_rows = all_rows[header_row + 1 :]
+
+            result[sheet_name] = Table(columns=columns, rows=data_rows)
+        return result
+    finally:
+        workbook.close()
+
+
+SUPPORTED_SUFFIXES = frozenset({".csv", ".tsv", ".txt", ".xlsx", ".json", ".jsonl"})
+
+
+def load_tables(path: Path, sep: str | None, header_row: int | None) -> dict[str, Table]:
+    """Load every table in `path`. The dict key is the sheet name for Excel,
+    or "" for everything else (single-table formats).
+    """
+    suffix = path.suffix.lower()
+
+    if suffix not in SUPPORTED_SUFFIXES:
+        raise ValueError(f"対応していない形式です: {path}")
+
+    if suffix == ".xlsx":
+        return read_excel_tables(path, header_row)
+
+    text = read_text_with_fallback(path)
+
+    if suffix in (".json", ".jsonl"):
+        return {"": read_json_records(text)}
+
+    resolved_sep = sep if sep is not None else ("\t" if suffix == ".tsv" else ",")
+    return {"": read_csv_like(text, resolved_sep, header_row)}