genice3 3.0b0__py3-none-any.whl

genice3/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+
+class ConfigurationError(Exception):
+    """設定に関するエラーを表す例外"""
+
+    pass

genice3/_build.py

@@ -0,0 +1,43 @@
+"""
+カスタムビルドフック: symlinkを実際のファイルにコピーする
+"""
+import os
+import shutil
+from pathlib import Path
+from setuptools.command.build_py import build_py as _build_py
+
+
+class BuildPy(_build_py):
+    """symlinkを実際のファイルにコピーするカスタムビルドコマンド"""
+
+    def copy_file(self, src, dst, preserve_mode=True, preserve_times=True, link=None, level=1):
+        """ファイルをコピーする際に、symlinkの場合は実際のファイルをコピー"""
+        # symlinkの場合は、ターゲットファイルをコピー
+        if os.path.islink(src):
+            # symlinkのターゲットを取得
+            target = os.readlink(src)
+            
+            # 相対パスの場合は、srcのディレクトリからの相対パスとして解決
+            if not os.path.isabs(target):
+                src_dir = os.path.dirname(src)
+                target_path = os.path.normpath(os.path.join(src_dir, target))
+            else:
+                target_path = target
+            
+            # ターゲットファイルが存在する場合のみコピー
+            if os.path.exists(target_path):
+                # ターゲットファイルをコピー（再帰的に呼び出し）
+                return super().copy_file(
+                    target_path, dst, preserve_mode, preserve_times, link, level
+                )
+            else:
+                # ターゲットが見つからない場合は警告を出してスキップ
+                print(f"Warning: symlink target not found: {src} -> {target_path}")
+                return dst, False
+        
+        # 通常のファイルの場合は親クラスのメソッドを呼び出す
+        return super().copy_file(src, dst, preserve_mode, preserve_times, link, level)
+
+
+
+

genice3/cage.py

@@ -0,0 +1,160 @@
+"""
+Utility functions for genice3
+"""
+
+import numpy as np
+from dataclasses import dataclass
+import string
+from logging import getLogger
+
+import networkx as nx
+from cycless import center_of_graph
+from cycless.cycles import cycles_iter
+from cycless.polyhed import cage_to_graph, polyhedra_iter
+from graphstat import GraphStat
+
+
+@dataclass
+class CageSpec:
+    """ケージの仕様。cage_type は "A12" などのケージ種別を表す文字列。"""
+
+    cage_type: str  # A12, 1b, etc.
+    faces: str  # 5^12 6^2, etc.
+    graph: nx.Graph  # ケージを構成する水分子ノードのグラフ
+
+    def to_json_capable_data(self) -> dict:
+        return {
+            "cage_type": self.cage_type,
+            "faces": self.faces,
+            "nodes": [int(x) for x in self.graph],
+        }
+
+    def __repr__(self) -> str:
+        return (
+            f"CageSpec(cage_type={self.cage_type!r}, "
+            f"faces={self.faces!r}, "
+            f"n_nodes={self.graph.number_of_nodes()})"
+        )
+
+    def __str__(self) -> str:
+        return f"{self.cage_type} ({self.faces}) {self.graph.number_of_nodes()} nodes"
+
+
+@dataclass
+class CageSpecs:
+    """拡大単位胞内の全ケージの位置と仕様。
+
+    specs: 各ケージの CageSpec（cage_type, faces, graph）。
+    positions: 分数座標の配列（Nx3）。specs と同順。
+    node_to_cage_indices: __post_init__ で生成。ノード番号 → そのノードを含むケージのインデックスリスト。
+    """
+
+    specs: list[CageSpec]
+    positions: np.ndarray  # in fractional coordinates
+
+    def __post_init__(self) -> None:
+        """ノード番号 → ケージ番号の逆引き辞書を生成。"""
+        self.node_to_cage_indices: dict[int, list[int]] = {}
+        for cage_idx, spec in enumerate(self.specs):
+            for node in spec.graph:
+                self.node_to_cage_indices.setdefault(int(node), []).append(cage_idx)
+
+    def to_json_capable_data(self) -> dict:
+        """JSON シリアライズ用の辞書を返す。キーはケージインデックス、値は frac_pos と specs。"""
+        data = []
+        for position, specs in zip(self.positions, self.specs):
+            data.append(
+                {
+                    "frac_pos": position.tolist(),
+                    "specs": specs.to_json_capable_data(),
+                }
+            )
+        return dict(enumerate(data))
+
+    def __repr__(self) -> str:
+        return (
+            f"CageSpecs(n_cages={len(self.specs)}, "
+            f"positions_shape={self.positions.shape})"
+        )
+
+
+def _assign_cage_type(basename: int, existing_types: set[str]) -> str:
+    """未使用のケージタイプ名（A12, A12a など）を生成する。"""
+    enum = 0
+    cage_type = f"A{basename}"
+    while cage_type in existing_types:
+        char = string.ascii_lowercase[enum]
+        cage_type = f"A{basename}{char}"
+        enum += 1
+    return cage_type
+
+
+def _make_cage_expression(ring_ids: list, ringlist: list) -> str:
+    """ケージを構成するリングのサイズから "5^12 6^2" のような面表現文字列を生成する。"""
+    ringcount = [0 for i in range(9)]
+    for ring in ring_ids:
+        ringcount[len(ringlist[ring])] += 1
+    index = []
+    for i in range(9):
+        if ringcount[i] > 0:
+            index.append(f"{i}^{ringcount[i]}")
+    index = " ".join(index)
+    return index
+
+
+def assess_cages(
+    graph: nx.Graph, node_frac: np.ndarray
+) -> CageSpecs:
+    """水素結合グラフとノードの分数座標からケージを検出・分類し、CageSpecs を返す。
+
+    Args:
+        graph: 水素結合ネットワーク（無向グラフ）。
+        node_frac: ノードの分数座標（Nx3）。
+
+    Returns:
+        検出されたケージの位置（分数座標）と仕様（CageSpec のリスト）。
+    """
+    logger = getLogger()
+
+    # Prepare the list of rings
+    # taking the positions in PBC into account.
+    ringlist = [
+        [int(x) for x in ring]
+        for ring in cycles_iter(nx.Graph(graph), 8, pos=node_frac)
+    ]
+
+    MaxCageSize = 22
+    cage_fracs = []
+    # data storage of the found cages
+    db = GraphStat()
+    existing_cage_types: set[str] = set()
+    g_id_to_cage_type: dict[int, str] = {}
+
+    # Detect cages and classify
+    cages = [cage for cage in polyhedra_iter(ringlist, MaxCageSize)]
+    cage_graphs = [cage_to_graph(cage, ringlist) for cage in cages]
+    cage_fracs = [center_of_graph(g, node_frac) for g in cage_graphs]
+    if len(cage_fracs) == 0:
+        logger.info("    No cages detected.")
+
+    cagespecs = []
+    for cage, g in zip(cages, cage_graphs):
+        cagesize = len(cage)
+        graph_id = db.query_id(g)
+        # if it is a new cage type
+        if graph_id < 0:
+            # new type!
+            # register the last query
+            graph_id = db.register()
+
+            cage_type = _assign_cage_type(cagesize, existing_cage_types)
+            g_id_to_cage_type[graph_id] = cage_type
+            existing_cage_types.add(cage_type)
+        else:
+            cage_type = g_id_to_cage_type[graph_id]
+        faces = _make_cage_expression(cage, ringlist)
+        cagespecs.append(CageSpec(cage_type=cage_type, faces=faces, graph=g))
+        # print(f"{label=}, {faces=}, {ringlist=}")
+        # print([len(ringlist[ring]) for ring in cage])
+
+    return CageSpecs(specs=cagespecs, positions=np.array(cage_fracs))

genice3/cli/__init__.py

@@ -0,0 +1,20 @@
+"""
+genice3 CLI パッケージ。
+
+- option_parser: option_handling.md に基づくオプション文字列パーサー
+- runner: argv のパースとプラグイン dispatch（parse_argv, validate_result）
+"""
+
+from genice3.cli.option_parser import (
+    parse_options,
+    structure_for_display,
+    scalarize_single_item_lists,
+    structure_to_option_string,
+)
+
+__all__ = [
+    "parse_options",
+    "structure_for_display",
+    "scalarize_single_item_lists",
+    "structure_to_option_string",
+]

genice3/cli/genice.py

@@ -0,0 +1,168 @@
+from logging import getLogger, basicConfig, DEBUG, INFO
+import sys
+from importlib.metadata import version, PackageNotFoundError
+
+from genice3.plugin import safe_import
+from genice3.genice import GenIce3, log_cation_cages, log_spot_cation_cages
+from genice3.cli.runner import parse_argv, validate_result
+from genice3.cli.options import (
+    BASE_HELP_ORDER,
+    get_option_def,
+    format_option_for_help,
+    extract_genice_args,
+    validate_parsed_options,
+)
+
+
+def get_version():
+    """パッケージのバージョンを取得する。見つからない場合はデフォルト値を返す。"""
+    try:
+        return version("genice3")
+    except PackageNotFoundError:
+        return "3.*.*.*"
+
+
+# ヘルプ整形: 先頭2スペース＋オプション書式が24文字超なら改行。説明は28〜72桁で折り返し。
+_HELP_OPTION_MAX = 24  # 2スペース＋オプションがこの桁数までなら1行に
+_HELP_DESC_START = 28  # 説明開始桁（1-based）
+_HELP_DESC_END = 72
+_HELP_DESC_WIDTH = _HELP_DESC_END - _HELP_DESC_START + 1  # 45
+
+
+def _wrap_desc(text: str, width: int) -> list[str]:
+    """説明文を width 文字で折り返した行リストを返す"""
+    words = text.split()
+    lines: list[str] = []
+    current: list[str] = []
+    current_len = 0
+    for w in words:
+        need = len(w) + (1 if current else 0)
+        if current_len + need <= width:
+            current.append(w)
+            current_len += need
+        else:
+            if current:
+                lines.append(" ".join(current))
+            current = [w]
+            current_len = len(w)
+    if current:
+        lines.append(" ".join(current))
+    return lines
+
+
+def _opt_line(option: str, description: str) -> list[str]:
+    """オプション1件を指定ルールで整形。2スペース＋オプションが24文字超なら改行。説明は28〜72桁で折り畳み。"""
+    head_len = 2 + len(option)  # 先頭2スペース＋オプション
+    desc_lines = _wrap_desc(description, _HELP_DESC_WIDTH)
+    indent = " " * (_HELP_DESC_START - 1)  # 説明行の左インデント（27スペース）
+
+    if head_len > _HELP_OPTION_MAX:
+        # オプションだけ1行、説明は次の行から28桁目から
+        out = ["  " + option]
+        for line in desc_lines:
+            out.append(indent + line)
+        return out
+    # オプション＋説明を同じ行から（オプション後に空白を入れて28桁目に合わせる）
+    pad = _HELP_DESC_START - 1 - head_len  # 2 + len(option) + pad == 27
+    out = ["  " + option + " " * pad + desc_lines[0]]
+    for line in desc_lines[1:]:
+        out.append(indent + line)
+    return out
+
+
+def print_help():
+    """ヘルプメッセージを表示（options のオプション定義から組み立て）"""
+    print("Usage: genice3 [OPTIONS] UNITCELL")
+    print()
+    print("Options:")
+    seen = set()  # rep / replication_factors は同じ行なので1回だけ表示
+    for name in BASE_HELP_ORDER:
+        if name in seen:
+            continue
+        def_ = get_option_def(name)
+        if def_ is None or def_.help_text is None:
+            continue
+        if def_.name == "replication_factors":
+            seen.add("rep")
+        seen.add(def_.name)
+        opt_str = format_option_for_help(def_)
+        for line in _opt_line(opt_str, def_.help_text):
+            print(line)
+    print()
+    print("Arguments:")
+    for line in _opt_line("UNITCELL", "Unitcell plugin name (required)"):
+        print(line)
+
+
+def main() -> None:
+    """メイン関数"""
+    # --helpと--versionを先に処理
+    if "--help" in sys.argv or "-h" in sys.argv:
+        print_help()
+        sys.exit(0)
+    if "--version" in sys.argv or "-V" in sys.argv:
+        print(f"genice3 {get_version()}")
+        sys.exit(0)
+
+    # ロギングを初期化（デフォルトはINFOレベル）
+    basicConfig(level=INFO)
+    logger = getLogger()
+
+    try:
+        result = parse_argv(sys.argv[1:])
+    except Exception as e:
+        logger.error(f"パースエラー: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+    # バリデーション
+    is_valid, errors = validate_result(result)
+    if not is_valid:
+        for error in errors:
+            logger.error(error)
+        sys.exit(1)
+
+    base_options = result["base_options"]
+    if base_options.get("debug"):
+        logger.setLevel(DEBUG)
+        for handler in logger.handlers:
+            handler.setLevel(DEBUG)
+
+    try:
+        validate_parsed_options(base_options)
+    except ValueError as e:
+        logger.error(str(e))
+        sys.exit(1)
+
+    genice_kwargs = extract_genice_args(base_options)
+    logger.debug(f"Settings: {genice_kwargs}")
+
+    unitcell_name = result["unitcell"]["name"]
+    unitcell_processed = result["unitcell"]["processed"]
+    exporter_name = result["exporter"]["name"] or "gromacs"
+    exporter_processed = result["exporter"]["processed"]
+
+    genice = GenIce3(**genice_kwargs)
+
+    # unitcellプラグインを設定
+    genice.unitcell = safe_import("unitcell", unitcell_name).UnitCell(
+        **unitcell_processed
+    )
+
+    log_spot_cation_cages(genice)
+    log_cation_cages(genice)
+
+    # コマンドライン全体を取得
+    command_line = " ".join(sys.argv)
+    exporter_processed["command_line"] = command_line
+
+    # exporterプラグインを実行
+    safe_import("exporter", exporter_name).dump(
+        genice, sys.stdout, **exporter_processed
+    )
+
+
+if __name__ == "__main__":
+    main()

genice3/cli/option_def.py

@@ -0,0 +1,25 @@
+"""OptionDef と型定数（--help と検証用）。options と validator の両方から参照する。"""
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+OPTION_TYPE_FLAG = "flag"
+OPTION_TYPE_STRING = "string"
+OPTION_TYPE_TUPLE = "tuple"
+OPTION_TYPE_KEYVALUE = "keyvalue"
+
+
+@dataclass(frozen=True)
+class OptionDef:
+    """CLI で認識するオプションの定義（ヘルプ・検証用）。"""
+
+    name: str
+    short: Optional[str] = None
+    is_flag: bool = False
+    max_values: Optional[int] = None
+    level: str = "base"
+    parse_type: Optional[str] = None
+    metavar: Optional[str] = None
+    help_text: Optional[str] = None
+    help_format: Optional[str] = None
+    parse_validator: Optional[Callable[[Any], None]] = None

genice3/cli/option_parser.py

@@ -0,0 +1,142 @@
+"""
+option_handling.md のルールに従うオプション文字列パーサー。
+
+- 第一引数 = unitcell、以降は -- / : で第一・第二階層を区別。
+- 引数は文字列のまま（= で分割しない）。各オプションはリストで、
+  要素はスカラー（引数1個のみ）または 1 キーの辞書 { 引数: サブオプション辞書 }。
+- 構造体 ↔ オプション文字列 ↔ YAML 表現の往復が可能。
+
+CLI は runner.parse_argv がこのモジュールを利用する。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Union
+
+
+def parse_options(line: str) -> Dict[str, Any]:
+    """
+    空白で分割し、先頭を unitcell、以降を -- / : のルールで構造体に格納する。
+
+    - 第一引数 = unitcell（省略不可）
+    - -- で始まる = 第一階層オプション名、直後からが引数
+    - : で始まる = 第二階層（直前の第一階層に引数が1個だけのときのみ）
+    - 引数はすべて文字列のまま。= で分割しない。
+
+    Raises:
+        ValueError: unitcell が空、または第二階層を引数が1個でない第一階層に付けた場合。
+    """
+    tokens = line.split()
+    if not tokens or tokens[0].startswith("-") or tokens[0].startswith(":"):
+        raise ValueError("unitcell が必要（先頭に単位胞名を指定してください）")
+    unitcell = tokens[0]
+    i = 1
+    result: Dict[str, Any] = {"unitcell": unitcell}
+
+    while i < len(tokens):
+        if not tokens[i].startswith("--"):
+            i += 1
+            continue
+        opt_name = tokens[i][2:]
+        i += 1
+        args: List[str] = []
+        subopts: Dict[str, List[str]] = {}
+
+        while i < len(tokens) and not tokens[i].startswith("--"):
+            if tokens[i].startswith(":"):
+                if len(args) != 1:
+                    raise ValueError(
+                        f"第二階層は第一階層の引数が1個のときのみ: {opt_name} の引数数={len(args)}"
+                    )
+                sub_name = tokens[i][1:]
+                i += 1
+                sub_args: List[str] = []
+                while i < len(tokens) and not tokens[i].startswith("--") and not tokens[i].startswith(":"):
+                    sub_args.append(tokens[i])
+                    i += 1
+                subopts[sub_name] = sub_args
+            else:
+                args.append(tokens[i])
+                i += 1
+
+        if opt_name not in result:
+            result[opt_name] = []
+
+        if subopts:
+            result[opt_name].append({args[0]: subopts})
+        else:
+            for a in args:
+                result[opt_name].append([a])
+
+    return result
+
+
+def _normalize_item(item: Union[list, dict]) -> Union[list, dict, str]:
+    """要素1個のリストはスカラーに置き換えてよい、の正規化（表示用）。辞書はそのまま。"""
+    if isinstance(item, list) and len(item) == 1 and isinstance(item[0], str):
+        return item[0]
+    return item
+
+
+def structure_for_display(data: Dict[str, Any]) -> Dict[str, Any]:
+    """構造体を「要素1個のリスト→スカラー」で表示用に整える。"""
+    out: Dict[str, Any] = {"unitcell": data["unitcell"]}
+    for k, v in data.items():
+        if k == "unitcell":
+            continue
+        if isinstance(v, list):
+            out[k] = [_normalize_item(e) for e in v]
+        else:
+            out[k] = v
+    return out
+
+
+def scalarize_single_item_lists(
+    obj: Union[Dict[str, Any], List[Any], str, int, float]
+) -> Union[Dict[str, Any], List[Any], str, int, float]:
+    """
+    再帰的に、要素が1個だけのリストをそのスカラーに置き換える。
+    YAML 出力前に適用すると、water: ['4site^ice'] → water: 4site^ice のようになる。
+    """
+    if isinstance(obj, list):
+        if len(obj) == 1:
+            return scalarize_single_item_lists(obj[0])
+        return [scalarize_single_item_lists(e) for e in obj]
+    if isinstance(obj, dict):
+        return {k: scalarize_single_item_lists(v) for k, v in obj.items()}
+    return obj
+
+
+def structure_to_option_string(data: Dict[str, Any]) -> str:
+    """
+    YAML 表現で使った構造体（単成分リストをスカラーにしたもの）を、
+    オプション文字列に戻して 1 行で返す。
+    サブオプションがない要素ばかりの場合は、--key を1回だけ出して引数を連続で並べる。
+    """
+    parts: List[str] = [str(data["unitcell"])]
+    for key, value in data.items():
+        if key == "unitcell":
+            continue
+        items: List[Any] = value if isinstance(value, list) else [value]
+        run: List[str] = []  # サブオプションなしの連続要素
+        for item in items:
+            if isinstance(item, dict):
+                if run:
+                    parts.append(f"--{key}")
+                    parts.extend(run)
+                    run = []
+                (arg, subopts), = item.items()
+                parts.append(f"--{key}")
+                parts.append(str(arg))
+                for subk, subv in subopts.items():
+                    parts.append(f":{subk}")
+                    if isinstance(subv, list):
+                        parts.extend(str(x) for x in subv)
+                    else:
+                        parts.append(str(subv))
+            else:
+                run.append(str(item))
+        if run:
+            parts.append(f"--{key}")
+            parts.extend(run)
+    return " ".join(parts)