workpytools 0.1.4__py3-none-any.whl

workpytools/__init__.py

@@ -0,0 +1 @@
+"""Collection of Python processing utilities."""

workpytools/cli.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import argparse
+import importlib
+import inspect
+import pkgutil
+import sys
+from pathlib import PureWindowsPath
+
+from workpytools import processing
+from workpytools.common.logging import setup_logging
+from workpytools.processing.base import Processor
+
+
+def _discover_processors() -> dict[str, Processor]:
+    """Import every module under `workpytools.processing` and collect Processor subclasses."""
+    processors: dict[str, Processor] = {}
+    for module_info in pkgutil.iter_modules(processing.__path__, prefix=f"{processing.__name__}."):
+        if module_info.name.endswith(".base"):
+            continue
+        try:
+            module = importlib.import_module(module_info.name)
+        except ImportError as exc:
+            print(f"warning: skipping {module_info.name}: {exc}", file=sys.stderr)
+            continue
+        for _, obj in inspect.getmembers(module, inspect.isclass):
+            if issubclass(obj, Processor) and obj is not Processor:
+                instance = obj()
+                processors[instance.name] = instance
+    return processors
+
+
+def build_parser(processors: dict[str, Processor]) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="tools", description="Collection of processing commands")
+    parser.add_argument("--log-level", default="INFO", help="Logging level (default: INFO)")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for proc in processors.values():
+        sub = subparsers.add_parser(proc.name, help=proc.help)
+        proc.add_arguments(sub)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    processors = _discover_processors()
+    parser = build_parser(processors)
+    args = parser.parse_args(argv)
+
+    setup_logging(args.log_level)
+
+    processor = processors[args.command]
+    return processor.run(args)
+
+
+_ENTRY_POINT_ALIASES = {
+    # toolh.exe だけは他の1コマンド=1exe規則に沿わない特別なエントリーポイント名
+    # （help.exe は分かりにくいので toolh とした）。
+    "toolh": "help",
+}
+
+
+def run_as_subcommand() -> int:
+    """Entry point for a per-command executable (e.g. `denoise.exe`).
+
+    The subcommand name is taken from how this executable was invoked (its
+    own file name), so `denoise.exe args...` behaves like `tools denoise
+    args...`. Register one `[project.scripts]` entry per Processor name in
+    pyproject.toml, all pointing to this same function.
+    """
+    command_name = PureWindowsPath(sys.argv[0]).stem
+    command_name = _ENTRY_POINT_ALIASES.get(command_name, command_name)
+    return main([command_name, *sys.argv[1:]])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

workpytools/common/browser_preview.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_query_counter = itertools.count()
+
+
+def cache_busting_query() -> str:
+    """Wall-clock time plus a per-process counter, so consecutive calls
+    within the same clock tick still differ. Used to defeat the browser's
+    tendency to not reload a fixed-name file:// URL it already has open.
+    """
+    return f"{time.time_ns()}-{next(_query_counter)}"
+
+
+def write_and_open(html: str, filename: str, no_open: bool) -> Path:
+    """Write `html` to a fixed-name file under %TEMP% and open it in the
+    default browser (unless `no_open`). Reused by every command that
+    previews a result in the browser (clipview, profiler --view, ...).
+    """
+    preview_path = Path(tempfile.gettempdir()) / filename
+    try:
+        preview_path.write_text(html, encoding="utf-8")
+    except OSError as exc:
+        raise RuntimeError(f"一時ファイルの書き込みに失敗しました: {preview_path}") from exc
+
+    logger.info("プレビューを書き出しました: %s", preview_path)
+
+    if not no_open:
+        url = f"{preview_path.as_uri()}?v={cache_busting_query()}"
+        webbrowser.open(url)
+
+    return preview_path

workpytools/common/clipboard.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import io
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import win32clipboard
+import win32con
+from PIL import Image, ImageGrab
+
+from workpytools.common.textfile import (
+    TextFileError,
+    normalize_newlines,
+    read_text_with_fallback,
+)
+
+SourceKind = Literal["path", "clipboard_file", "clipboard_data", "clipboard_text"]
+
+
+class ClipboardImageError(RuntimeError):
+    """Raised when no usable image can be obtained from the clipboard."""
+
+
+class ClipboardTextError(RuntimeError):
+    """Raised when no usable text can be obtained from the clipboard."""
+
+
+@dataclass(frozen=True)
+class LoadedImage:
+    """An image plus where it came from.
+
+    `source_kind` distinguishes the three supported input patterns:
+    - "path": an explicit file path argument
+    - "clipboard_file": clipboard holds a copied file object (e.g. Ctrl+C on
+      a file in Explorer)
+    - "clipboard_data": clipboard holds raw image data with no file behind
+      it (e.g. "Copy Image" in a viewer)
+
+    `source_path` is set for "path" and "clipboard_file" (a real file exists),
+    and is `None` for "clipboard_data".
+    """
+
+    image: Image.Image
+    source_path: Path | None
+    source_kind: SourceKind
+
+
+def load_image(path: str | Path | None) -> LoadedImage:
+    """Load an image from a file path, or from the Windows clipboard if `path` is None.
+
+    Clipboard input covers two cases:
+    - raw image data (e.g. copied via "Copy Image" in a browser/viewer)
+    - a copied file object (e.g. Ctrl+C on a file in Explorer), which Pillow
+      reports as a list of file paths on Windows.
+    """
+    if path is not None:
+        resolved = Path(path)
+        return LoadedImage(
+            image=Image.open(resolved).convert("RGBA"), source_path=resolved, source_kind="path"
+        )
+
+    clip = ImageGrab.grabclipboard()
+    if clip is None:
+        raise ClipboardImageError("クリップボードに画像データがありません")
+    if isinstance(clip, list):
+        if not clip:
+            raise ClipboardImageError("クリップボードにファイルがありません")
+        resolved = Path(clip[0])
+        return LoadedImage(
+            image=Image.open(resolved).convert("RGBA"),
+            source_path=resolved,
+            source_kind="clipboard_file",
+        )
+    return LoadedImage(image=clip.convert("RGBA"), source_path=None, source_kind="clipboard_data")
+
+
+@dataclass(frozen=True)
+class LoadedText:
+    """Text plus where it came from. Mirrors `LoadedImage` for text-based commands."""
+
+    text: str
+    source_path: Path | None
+    source_kind: SourceKind
+
+
+def _normalize_newlines(text: str) -> str:
+    return normalize_newlines(text)
+
+
+def _read_text_file(path: Path, encoding: str | None) -> str:
+    """Read a text file, re-raising as ClipboardTextError for this module's callers."""
+    try:
+        return read_text_with_fallback(path, encoding)
+    except TextFileError as exc:
+        raise ClipboardTextError(str(exc)) from exc
+
+
+def load_text(path: str | Path | None, encoding: str | None = None) -> LoadedText:
+    """Load text from a file path, or from the Windows clipboard if `path` is None.
+
+    Clipboard input covers two cases:
+    - plain text (e.g. copied from a text editor)
+    - a copied file object (e.g. Ctrl+C on a file in Explorer), read as text
+
+    `encoding` forces a specific codec (no fallback) when reading a file;
+    `None` tries UTF-8 (with BOM support) then falls back to CP932.
+    """
+    if path is not None:
+        resolved = Path(path)
+        text = _read_text_file(resolved, encoding)
+        return LoadedText(
+            text=_normalize_newlines(text), source_path=resolved, source_kind="path"
+        )
+
+    win32clipboard.OpenClipboard()
+    try:
+        has_files = win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_HDROP)
+        has_text = win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT)
+        if has_files:
+            files = win32clipboard.GetClipboardData(win32clipboard.CF_HDROP)
+        elif has_text:
+            clip_text = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
+        else:
+            raise ClipboardTextError("クリップボードにテキストがありません")
+    finally:
+        win32clipboard.CloseClipboard()
+
+    if has_files:
+        if not files:
+            raise ClipboardTextError("クリップボードにファイルがありません")
+        resolved = Path(files[0])
+        text = _read_text_file(resolved, encoding)
+        return LoadedText(
+            text=_normalize_newlines(text), source_path=resolved, source_kind="clipboard_file"
+        )
+
+    return LoadedText(
+        text=_normalize_newlines(clip_text), source_path=None, source_kind="clipboard_text"
+    )
+
+
+def copy_file_to_clipboard(path: Path) -> None:
+    """Put a file object on the clipboard (CF_HDROP), as if copied in Explorer.
+
+    Lets the user paste the resulting file with Ctrl+V into Explorer, Outlook,
+    Slack, etc.
+    """
+    path_str = str(path.resolve())
+    # DROPFILES構造体 + ダブルNUL終端のファイルパス列（CF_HDROPの仕様）
+    dropfiles = struct.pack("Iiiii", 20, 0, 0, 0, 0)
+    data = dropfiles + path_str.encode("utf-16-le") + b"\x00\x00\x00\x00"
+
+    win32clipboard.OpenClipboard()
+    try:
+        win32clipboard.EmptyClipboard()
+        win32clipboard.SetClipboardData(win32con.CF_HDROP, data)
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def copy_image_to_clipboard(image: Image.Image) -> None:
+    """Put raw image data on the clipboard (CF_DIB), as if via "Copy Image"."""
+    with io.BytesIO() as buf:
+        image.convert("RGB").save(buf, "BMP")
+        # BMPファイルヘッダー（先頭14バイト）を除いたDIB部分のみがCF_DIBの中身
+        dib = buf.getvalue()[14:]
+
+    win32clipboard.OpenClipboard()
+    try:
+        win32clipboard.EmptyClipboard()
+        win32clipboard.SetClipboardData(win32con.CF_DIB, dib)
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def _cf_html_format() -> int:
+    """The CF_HTML format ID is not a fixed constant; it must be looked up at runtime."""
+    return int(win32clipboard.RegisterClipboardFormat("HTML Format"))
+
+
+def has_clipboard_html() -> bool:
+    win32clipboard.OpenClipboard()
+    try:
+        return bool(win32clipboard.IsClipboardFormatAvailable(_cf_html_format()))
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def has_clipboard_text() -> bool:
+    win32clipboard.OpenClipboard()
+    try:
+        return bool(win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT))
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def get_clipboard_text() -> str:
+    """Read CF_UNICODETEXT from the clipboard, raising if not available."""
+    win32clipboard.OpenClipboard()
+    try:
+        if not win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
+            raise ClipboardTextError("クリップボードにテキストがありません")
+        return str(win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT))
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def get_clipboard_html_fragment() -> str:
+    """Read CF_HTML from the clipboard and return just the fragment between
+    <!--StartFragment--> and <!--EndFragment-->, falling back to the header
+    byte offsets if the comment markers are missing or the offsets are stale.
+    """
+    win32clipboard.OpenClipboard()
+    try:
+        fmt = _cf_html_format()
+        if not win32clipboard.IsClipboardFormatAvailable(fmt):
+            raise ClipboardTextError("クリップボードにHTMLがありません")
+        raw = win32clipboard.GetClipboardData(fmt)
+    finally:
+        win32clipboard.CloseClipboard()
+
+    raw_bytes = raw if isinstance(raw, bytes) else str(raw).encode("utf-8")
+    text = raw_bytes.decode("utf-8", errors="replace")
+
+    start_marker = "<!--StartFragment-->"
+    end_marker = "<!--EndFragment-->"
+    start_idx = text.find(start_marker)
+    end_idx = text.find(end_marker)
+    if start_idx != -1 and end_idx != -1:
+        return text[start_idx + len(start_marker) : end_idx]
+
+    # コメントマーカーが見つからない場合、ヘッダーのバイトオフセットにフォールバックする
+    headers: dict[str, int] = {}
+    for line in text.split("\r\n"):
+        if not line or ":" not in line:
+            continue
+        key, _, value = line.partition(":")
+        if key in ("StartFragment", "EndFragment"):
+            try:
+                headers[key] = int(value)
+            except ValueError:
+                continue
+        if len(headers) == 2:
+            break
+
+    if "StartFragment" not in headers or "EndFragment" not in headers:
+        raise ClipboardTextError("CF_HTMLのヘッダーを解析できません")
+
+    return raw_bytes[headers["StartFragment"] : headers["EndFragment"]].decode(
+        "utf-8", errors="replace"
+    )
+
+
+def get_clipboard_html_raw() -> bytes:
+    """Read the raw CF_HTML payload (with its header) as bytes, for marker detection
+    (e.g. Excel's ProgId marker) that needs to see the whole payload, not just the fragment.
+    """
+    win32clipboard.OpenClipboard()
+    try:
+        fmt = _cf_html_format()
+        if not win32clipboard.IsClipboardFormatAvailable(fmt):
+            raise ClipboardTextError("クリップボードにHTMLがありません")
+        raw = win32clipboard.GetClipboardData(fmt)
+    finally:
+        win32clipboard.CloseClipboard()
+    return raw if isinstance(raw, bytes) else str(raw).encode("utf-8")
+
+
+def _build_cf_html(html_fragment: str) -> bytes:
+    """Wrap an HTML fragment in the CF_HTML header format (byte offsets, UTF-8)."""
+    header_template = (
+        "Version:0.9\r\n"
+        "StartHTML:{:010d}\r\n"
+        "EndHTML:{:010d}\r\n"
+        "StartFragment:{:010d}\r\n"
+        "EndFragment:{:010d}\r\n"
+    )
+    header_len = len(header_template.format(0, 0, 0, 0).encode("utf-8"))
+
+    prefix = "<html><body>\r\n<!--StartFragment-->"
+    suffix = "<!--EndFragment-->\r\n</body></html>"
+
+    start_html = header_len
+    start_fragment = start_html + len(prefix.encode("utf-8"))
+    end_fragment = start_fragment + len(html_fragment.encode("utf-8"))
+    end_html = end_fragment + len(suffix.encode("utf-8"))
+
+    header = header_template.format(start_html, end_html, start_fragment, end_fragment)
+    return (header + prefix + html_fragment + suffix).encode("utf-8")
+
+
+def copy_html_and_text_to_clipboard(html_fragment: str, plain_text: str) -> None:
+    """Put both CF_HTML and CF_UNICODETEXT on the clipboard in one session.
+
+    Rich-text-aware apps (Outlook/Word/Slack) read CF_HTML for styled paste;
+    plain-text-only apps fall back to CF_UNICODETEXT.
+    """
+    html_data = _build_cf_html(html_fragment)
+
+    win32clipboard.OpenClipboard()
+    try:
+        win32clipboard.EmptyClipboard()
+        win32clipboard.SetClipboardData(_cf_html_format(), html_data)
+        win32clipboard.SetClipboardData(win32con.CF_UNICODETEXT, plain_text)
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def copy_text_to_clipboard(text: str) -> None:
+    """Put plain text on the clipboard (CF_UNICODETEXT only)."""
+    win32clipboard.OpenClipboard()
+    try:
+        win32clipboard.EmptyClipboard()
+        win32clipboard.SetClipboardData(win32con.CF_UNICODETEXT, text)
+    finally:
+        win32clipboard.CloseClipboard()

workpytools/common/clustering.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def agglomerative_average_linkage(
+    distance_matrix: NDArray[np.float64], distance_threshold: float
+) -> NDArray[np.int_]:
+    """Average-linkage agglomerative clustering via the Lance-Williams update.
+
+    Equivalent to `sklearn.cluster.AgglomerativeClustering(metric="precomputed",
+    linkage="average", distance_threshold=distance_threshold, n_clusters=None)`
+    (verified against sklearn on random inputs during development).
+
+    Clusters are merged, closest pair first, until the closest remaining pair
+    exceeds `distance_threshold`. Merged-cluster distances are updated in O(1)
+    per neighbor via Lance-Williams (`d(k, i∪j) = (|i|·d(k,i) + |j|·d(k,j)) / (|i|+|j|)`)
+    rather than recomputed from scratch, keeping updates to O(n^2) overall
+    (finding the closest pair each round is still a linear scan).
+
+    Returns a 0-indexed label array, one entry per input row.
+    """
+    n = distance_matrix.shape[0]
+    if n == 0:
+        return np.array([], dtype=int)
+    if n == 1:
+        return np.array([0], dtype=int)
+
+    sizes: dict[int, int] = {i: 1 for i in range(n)}
+    members: dict[int, list[int]] = {i: [i] for i in range(n)}
+    dist: dict[tuple[int, int], float] = {}
+    for i in range(n):
+        for j in range(i + 1, n):
+            dist[(i, j)] = float(distance_matrix[i, j])
+
+    def get_dist(a: int, b: int) -> float:
+        return dist[(a, b)] if a < b else dist[(b, a)]
+
+    def set_dist(a: int, b: int, value: float) -> None:
+        if a < b:
+            dist[(a, b)] = value
+        else:
+            dist[(b, a)] = value
+
+    active = list(range(n))
+    next_id = n
+
+    while len(active) > 1:
+        best_pair: tuple[int, int] | None = None
+        best_distance: float | None = None
+        for ai in range(len(active)):
+            for bi in range(ai + 1, len(active)):
+                a, b = active[ai], active[bi]
+                d = get_dist(a, b)
+                if best_distance is None or d < best_distance:
+                    best_distance = d
+                    best_pair = (a, b)
+
+        assert best_pair is not None and best_distance is not None
+        if best_distance > distance_threshold:
+            break
+
+        a, b = best_pair
+        new_id = next_id
+        next_id += 1
+        size_a, size_b = sizes[a], sizes[b]
+        new_size = size_a + size_b
+        members[new_id] = members[a] + members[b]
+        sizes[new_id] = new_size
+
+        for k in active:
+            if k in (a, b):
+                continue
+            new_d = (size_a * get_dist(k, a) + size_b * get_dist(k, b)) / new_size
+            set_dist(k, new_id, new_d)
+
+        active = [x for x in active if x not in (a, b)]
+        active.append(new_id)
+
+    labels = np.zeros(n, dtype=int)
+    for label, cluster_id in enumerate(active):
+        for member in members[cluster_id]:
+            labels[member] = label
+    return labels

workpytools/common/config.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+
+def load_config(path: str | Path) -> dict[str, Any]:
+    """Load a TOML config file into a dict."""
+    with Path(path).open("rb") as f:
+        return tomllib.load(f)
+
+
+class ConfigLocationError(RuntimeError):
+    """Raised when the per-user config location can't be determined."""
+
+
+def _appdata_dir() -> Path:
+    """%APPDATA%\\workpytools, with a clear error instead of a bare KeyError."""
+    appdata = os.environ.get("APPDATA")
+    if not appdata:
+        raise ConfigLocationError(
+            "環境変数 APPDATA が設定されていないため、設定の保存先を決定できません"
+        )
+    return Path(appdata) / "workpytools"
+
+
+def default_config_path() -> Path:
+    """Default location of the shared config file: %APPDATA%\\workpytools\\config.toml."""
+    return _appdata_dir() / "config.toml"
+
+
+def vv_prompts_dir() -> Path:
+    """Folder holding one .txt per saved prompt: %APPDATA%\\workpytools\\vv\\."""
+    return _appdata_dir() / "vv"
+
+
+def load_default_config() -> dict[str, Any]:
+    """Load the default config file, or return {} if it doesn't exist."""
+    path = default_config_path()
+    if not path.exists():
+        return {}
+    return load_config(path)

workpytools/common/embedding.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import logging
+import os
+import urllib.request
+from pathlib import Path
+
+import numpy as np
+from numpy.typing import NDArray
+
+logger = logging.getLogger(__name__)
+
+# 接続先はここに固定値として持つ（huggingface-hubは使わず urllib で直接取得する）。
+_MODEL_BASE_URL = (
+    "https://huggingface.co/Xenova/paraphrase-multilingual-MiniLM-L12-v2/resolve/main"
+)
+_MODEL_FILES = {
+    "model.onnx": f"{_MODEL_BASE_URL}/onnx/model_quantized.onnx",
+    "tokenizer.json": f"{_MODEL_BASE_URL}/tokenizer.json",
+}
+
+DEFAULT_MODEL_NAME = "paraphrase-multilingual-MiniLM-L12-v2"
+
+
+class ModelDownloadError(RuntimeError):
+    """Raised when the embedding model can't be downloaded."""
+
+
+def _model_cache_dir(model_name: str) -> Path:
+    return Path(os.environ["LOCALAPPDATA"]) / "workpytools" / "models" / model_name
+
+
+def ensure_model(model_name: str = DEFAULT_MODEL_NAME) -> Path:
+    """Download the embedding model (ONNX + tokenizer.json) if not already cached.
+
+    Downloads from Hugging Face (`huggingface.co`) via `urllib`, not the
+    `huggingface-hub` client library, so the connection target is a plain
+    constant in this module rather than resolved by a third-party library.
+    """
+    if model_name != DEFAULT_MODEL_NAME:
+        raise ModelDownloadError(
+            f"未対応のモデル名です: {model_name}（対応済み: {DEFAULT_MODEL_NAME}）"
+        )
+
+    cache_dir = _model_cache_dir(model_name)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    for filename, url in _MODEL_FILES.items():
+        dest = cache_dir / filename
+        if dest.exists():
+            continue
+        logger.info("埋め込みモデルをダウンロードします: %s -> %s", url, dest)
+        try:
+            urllib.request.urlretrieve(url, dest)
+        except OSError as exc:
+            raise ModelDownloadError(
+                f"モデルのダウンロードに失敗しました: {url}"
+            ) from exc
+        size_mb = dest.stat().st_size / (1024 * 1024)
+        logger.info("ダウンロード完了: %s (%.1f MB)", dest, size_mb)
+
+    return cache_dir
+
+
+def embed_sentences(
+    sentences: list[str], model_name: str = DEFAULT_MODEL_NAME
+) -> NDArray[np.float64]:
+    """Embed sentences with mean pooling + L2 normalization. Returns (n, dim) float64 array."""
+    import onnxruntime as ort  # 遅延インポート: --similar 指定時のみ読み込む
+    from tokenizers import Tokenizer
+
+    cache_dir = ensure_model(model_name)
+    tokenizer = Tokenizer.from_file(str(cache_dir / "tokenizer.json"))
+    tokenizer.enable_padding()
+    session = ort.InferenceSession(
+        str(cache_dir / "model.onnx"), providers=["CPUExecutionProvider"]
+    )
+
+    encodings = tokenizer.encode_batch(sentences)
+    input_ids = np.array([e.ids for e in encodings], dtype=np.int64)
+    attention_mask = np.array([e.attention_mask for e in encodings], dtype=np.int64)
+    token_type_ids = np.zeros_like(input_ids)
+
+    outputs = session.run(
+        None,
+        {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "token_type_ids": token_type_ids,
+        },
+    )
+    last_hidden = outputs[0]
+
+    mask = attention_mask[:, :, None].astype(np.float64)
+    summed = (last_hidden * mask).sum(axis=1)
+    counts = mask.sum(axis=1)
+    pooled = summed / counts
+
+    norms = np.linalg.norm(pooled, axis=1, keepdims=True)
+    normalized: NDArray[np.float64] = pooled / norms
+    return normalized