graphica-plot 2.0.0__py3-none-any.whl

graphica/gui/datasets/operations/runner.py

@@ -0,0 +1,148 @@
+"""データセットの処理の流れ(対象の確認 → ダイアログ → 入力の確認 → 計算 → 結果の追加)を担う実行役。
+
+操作ごとの違い(確認の順番、警告の題と文言、例外を捕まえる範囲、Undo の有無)は操作の本体に残す。
+ここで捕まえるのは本体が calculate() に渡した計算の ValueError だけで、それ以外の例外は今までどおり外に出る。
+"""
+from dataclasses import dataclass
+from typing import Callable
+
+import numpy as np
+from PySide6.QtWidgets import QDialog
+
+from graphica.gui import notify
+
+INPUT_ERROR_TITLE = "入力エラー"
+EMPTY_OUTPUT_NAME_TEXT = "出力データセット名が空です。"
+
+
+class OperationStopped(Exception):
+    """流れを止める。知らせる必要があれば、止める前に知らせてある。"""
+
+
+class OperationState:
+    """操作をまたいで持つもの。非モーダルの結果の窓は、次に同じ処理をしたときに閉じる。"""
+
+    def __init__(self):
+        self.result_windows = {}
+        self.copied_style = None  # スタイルのコピーの控え(貼り付けるまで持つ)
+        self.runners = {}  # バックグラウンドで動いている計算。終わるまで同じ種類の計算は始めない
+
+
+@dataclass(frozen=True)
+class Operation:
+    title: str  # 警告・お知らせの題
+    body: Callable[["OperationContext"], None]
+
+
+class OperationContext:
+    """操作の本体に渡す。流れを止める手順と、結果の追加の手順を持つ。"""
+
+    def __init__(self, host, state, title):
+        self.host = host
+        self.state = state
+        self.title = title
+
+    @property
+    def parent(self):
+        return self.host.parent_widget
+
+    # --- 流れを止める ---
+
+    def stop(self):
+        raise OperationStopped
+
+    def stop_with_warning(self, text, title=None):
+        notify.warning(self.parent, title or self.title, text)
+        raise OperationStopped
+
+    def stop_with_information(self, text, title=None):
+        notify.information(self.parent, title or self.title, text)
+        raise OperationStopped
+
+    def information(self, text, title=None):
+        notify.information(self.parent, title or self.title, text)
+
+    # --- 対象 ---
+
+    def current_dataset(self):
+        """今のデータセット。無ければ何も言わずに止める。"""
+        dataset = self.host.current_dataset()
+        if dataset is None:
+            self.stop()
+        return dataset
+
+    def selected_datasets(self, *, exactly=None, at_least=None, message=None):
+        """数が合わなければ止める。message が無ければ何も言わずに止める。"""
+        selected = self.host.selected_datasets()
+        if (exactly is not None and len(selected) != exactly) or (at_least is not None and len(selected) < at_least):
+            if message is None:
+                self.stop()
+            self.stop_with_information(message)
+        return selected
+
+    def as_numbers(self, dataset, axis):
+        """X か Y の列を数に直す。文字の列(カテゴリ軸)なら、その処理の題で知らせて止める。"""
+        values, column = (dataset.x_data, dataset.x_col_name) if axis == "x" else (dataset.y_data, dataset.y_col_name)
+        try:
+            return np.asarray(values, dtype=float)
+        except (TypeError, ValueError):
+            if axis == "x":
+                self.stop_with_warning(
+                    f"X軸の列「{column}」が数値ではないため、この処理はできません"
+                    "(文字の列はカテゴリ軸として表示だけできます)。")
+            self.stop_with_warning(f"Y軸の列「{column}」が数値ではないため、この処理はできません。")
+
+    def valid_points(self, dataset):
+        """X と Y を数に直し、どちらかが NaN の点を除く。"""
+        x = self.as_numbers(dataset, "x")
+        y = self.as_numbers(dataset, "y")
+        valid = ~(np.isnan(x) | np.isnan(y))
+        return x[valid], y[valid]
+
+    # --- ダイアログと入力 ---
+
+    def ask(self, dialog):
+        """取り消されたら止める。"""
+        if dialog.exec() != QDialog.DialogCode.Accepted:
+            self.stop()
+        return dialog
+
+    def require_output_name(self, output_name):
+        if not output_name:
+            self.stop_with_warning(EMPTY_OUTPUT_NAME_TEXT, title=INPUT_ERROR_TITLE)
+
+    def calculate(self, compute):
+        """compute() の ValueError は、その文言を警告にして止める。"""
+        try:
+            return compute()
+        except ValueError as e:
+            self.stop_with_warning(str(e))
+
+    # --- 結果 ---
+
+    def add(self, dataset):
+        """Undo できる追加。Undo の名前はその処理の題。"""
+        self.host.add_dataset_with_undo(dataset, self.host.target_folder_for_new_dataset(), description=self.title)
+
+    def status(self, text, timeout_ms):
+        self.host.show_status(text, timeout_ms)
+
+    def add_and_report(self, dataset, timeout_ms=3000):
+        self.add(dataset)
+        self.status(f"「{dataset.name}」を追加しました", timeout_ms)
+
+    def show_result_window(self, key, create_window):
+        """同じ key の前の窓を閉じてから作って出す。"""
+        previous = self.state.result_windows.get(key)
+        if previous is not None:
+            previous.close()
+        window = create_window()
+        self.state.result_windows[key] = window
+        window.show()
+
+
+def run_operation(operation, host, state):
+    try:
+        operation.body(OperationContext(host, state, operation.title))
+    except OperationStopped:
+        pass

graphica/gui/datasets/operations/transfer.py

@@ -0,0 +1,227 @@
+"""データセットをタブの外とやり取りする本体: データ表の書き出し、別のタブへのコピー・移動、スタイルのコピー、元ファイルからの再読み込み。"""
+import copy
+import logging
+import os
+import re
+import uuid
+
+import pandas as pd
+from PySide6.QtWidgets import QApplication
+
+from graphica.gui import notify
+from graphica.core.methods_text import generate_methods_text
+from graphica.gui.datasets.operations.runner import Operation
+
+logger = logging.getLogger(__name__)
+
+# スタイルのコピーで写す見た目の属性。data_kind/z_col_name は「どの列を使うか」という構造の選択なので含めない
+# (写すと相手を意図せず2Dマップ扱いにしてしまう)。
+STYLE_ATTRS = ('plot_type', 'color', 'linestyle', 'linewidth', 'marker', 'markersize', 'smoothing',
+               'smoothing_method', 'alpha',
+               'error_display', 'colormap', 'vmin', 'vmax', 'grid_interp_method')
+
+
+def _write_failed(op, error):
+    logger.exception("データセットの書き出しに失敗しました")
+    op.stop_with_warning(f"ファイルの書き出しに失敗しました:\n{error}", title="書き出しエラー")
+
+
+def _export_one(op, dataset):
+    default_name = re.sub(r'[\\/:*?"<>|]', '_', dataset.name) or "dataset"
+    file_path, selected_filter = notify.get_save_file_name(
+        op.parent, "データ表を書き出す", default_name, "CSV Files (*.csv);;Excel Files (*.xlsx)"
+    )
+    if not file_path:
+        op.stop()
+    try:
+        if file_path.lower().endswith('.xlsx') or "Excel" in selected_filter:
+            if not file_path.lower().endswith('.xlsx'):
+                file_path += '.xlsx'
+            dataset.df.to_excel(file_path, index=False)
+        else:
+            if not file_path.lower().endswith('.csv'):
+                file_path += '.csv'
+            dataset.df.to_csv(file_path, index=False, encoding='utf-8-sig')
+    except Exception as e:
+        _write_failed(op, e)
+    op.information(f"書き出しました:\n{file_path}", title="書き出し完了")
+
+
+def _export_book(op, selected):
+    file_path, _ = notify.get_save_file_name(op.parent, "データ表を書き出す", "datasets.xlsx", "Excel Files (*.xlsx)")
+    if not file_path:
+        op.stop()
+    if not file_path.lower().endswith('.xlsx'):
+        file_path += '.xlsx'
+    used_sheet_names = set()
+    try:
+        with pd.ExcelWriter(file_path, engine='openpyxl') as writer:
+            for dataset in selected:
+                sheet_name = re.sub(r'[\\/:*?\[\]]', '_', dataset.name)[:31] or "Sheet"
+                base_name, suffix = sheet_name, 1
+                while sheet_name in used_sheet_names:
+                    suffix += 1
+                    sheet_name = f"{base_name[:28]}_{suffix}"
+                used_sheet_names.add(sheet_name)
+                dataset.df.to_excel(writer, sheet_name=sheet_name, index=False)
+    except Exception as e:
+        _write_failed(op, e)
+    op.information(f"{len(selected)}件を書き出しました:\n{file_path}", title="書き出し完了")
+
+
+def _export_folder(op, selected):
+    dir_path = notify.get_existing_directory(op.parent, "書き出し先フォルダを選択")
+    if not dir_path:
+        op.stop()
+    succeeded, failed = [], []
+    used_names = set()
+    for dataset in selected:
+        base_name = re.sub(r'[\\/:*?"<>|]', '_', dataset.name) or "dataset"
+        file_name, suffix = base_name, 1
+        while file_name in used_names:
+            suffix += 1
+            file_name = f"{base_name}_{suffix}"
+        used_names.add(file_name)
+        try:
+            dataset.df.to_csv(os.path.join(dir_path, f"{file_name}.csv"), index=False, encoding='utf-8-sig')
+            succeeded.append(dataset.name)
+        except Exception as e:
+            failed.append(f"{dataset.name}: {e}")
+    message = f"{len(succeeded)}件を書き出しました。"
+    if failed:
+        message += "\n\n失敗:\n" + "\n".join(failed)
+    op.information(message, title="書き出し完了")
+
+
+def export_data(op):
+    """1件ならCSVかExcelの1ファイル、複数ならデータセットごとのCSVか、シートに分けた1つのExcelブックに書き出す。"""
+    selected = op.selected_datasets(at_least=1)
+    if len(selected) == 1:
+        _export_one(op, selected[0])
+        return
+
+    format_choice, ok = notify.get_item(
+        op.parent, "データ表を書き出す", "書き出し形式を選択してください:",
+        ["CSV (データセットごとに別ファイル)", "Excel (1ブックにシート分け)"], 0, False
+    )
+    if not ok:
+        op.stop()
+    if format_choice.startswith("Excel"):
+        _export_book(op, selected)
+    else:
+        _export_folder(op, selected)
+
+
+def copy_or_move_to_tab(op, move):
+    """
+    選んだデータセットを複製して別のタブに足す(移動なら、足した後でこのタブから消す)。
+    タブごとに Undo の履歴が別なので、相手のタブへの追加は Undo できない。移動を Undo しても
+    このタブの削除だけが戻り、両方のタブにある状態になる。
+    """
+    selected = op.selected_datasets(at_least=1)
+    sibling_tabs = op.host.sibling_tabs()
+    if not sibling_tabs:
+        op.stop_with_information("コピー/移動先の他のタブがありません。")
+
+    tab_titles = [title for title, _ in sibling_tabs]
+    action_label = "移動" if move else "コピー"
+    choice, ok = notify.get_item(op.parent, f"別のタブへ{action_label}", "転送先のタブ:", tab_titles, 0, False)
+    if not ok:
+        op.stop()
+    target = sibling_tabs[tab_titles.index(choice)][1]
+
+    for dataset in selected:
+        new_dataset = copy.deepcopy(dataset)
+        new_dataset.dataset_id = uuid.uuid4().hex
+        target.add_dataset(new_dataset, target.target_folder_for_new_dataset())
+
+    if move:
+        op.host.remove_datasets(selected, description=f"別のタブへ移動({len(selected)}件)")
+
+    op.host.show_status(f"{len(selected)}件のデータセットを「{choice}」へ{action_label}しました")
+
+
+def copy_style(op):
+    """今のデータセットの見た目を値で控える(後で元を変えても控えは変わらない)。"""
+    dataset = op.current_dataset()
+    op.state.copied_style = {attr: getattr(dataset, attr) for attr in STYLE_ATTRS}
+    op.host.show_status(f"「{dataset.name}」のスタイルをコピーしました")
+
+
+def paste_style(op):
+    """控えた見た目を選んだデータセットすべてに当てる(Undo 1回分)。"""
+    copied_style = op.state.copied_style
+    if copied_style is None:
+        op.stop()
+    selected_datasets = op.selected_datasets(at_least=1)
+
+    with op.host.undo_macro(f"スタイルの貼り付け ({len(selected_datasets)}件)", enabled=len(selected_datasets) > 1):
+        for dataset in selected_datasets:
+            old_values = {attr: getattr(dataset, attr) for attr in STYLE_ATTRS}
+            op.host.push_property_change(dataset, old_values, dict(copied_style), description="スタイルの貼り付け")
+
+
+def reload_from_source(op):
+    """
+    元のファイルを読み直して df だけを差し替える。書式・注釈・使う列の選択はそのまま。
+    取り込みウィザードでの調整(文字コード・区切り等)は保存していないので、自動判定で読み直す。
+    使っている列が無くなっていたら何も変えずに止める。除外した行は古いデータの行番号なので消す。
+    """
+    dataset = op.current_dataset()
+    if not dataset.source_file:
+        op.stop()
+
+    if not os.path.exists(dataset.source_file):
+        op.stop_with_warning(f"元ファイルが見つかりません:\n{dataset.source_file}")
+
+    from graphica.gui.workers import read_data_file, excel_engine_for
+    try:
+        if dataset.source_sheet:
+            new_df = pd.read_excel(dataset.source_file, sheet_name=dataset.source_sheet,
+                                   engine=excel_engine_for(dataset.source_file))
+        else:
+            new_df = read_data_file(dataset.source_file)
+    except Exception as e:
+        logger.exception("元ファイルからの再読み込みに失敗しました")
+        op.stop_with_warning(f"ファイルの読み込みに失敗しました:\n{e}")
+
+    required_columns = (
+        dataset.x_col_name, dataset.y_col_name,
+        dataset.x_err_col_name, dataset.y_err_col_name, dataset.point_label_col_name,
+    )
+    missing = [col for col in required_columns if col and col not in new_df.columns]
+    if missing:
+        op.stop_with_warning(
+            "再読み込みしたファイルに、現在使用中の列が見つかりませんでした:\n"
+            + "\n".join(missing)
+            + "\n\nファイルの構造(列名/区切り文字/ヘッダー行など)が変わった可能性があります。"
+            "「データセット追加」から改めてインポートし直すことをお勧めします。"
+            "再読み込みは中止しました。"
+        )
+
+    old_values = {'df': dataset.df, 'masked_row_indices': list(dataset.masked_row_indices)}
+    new_values = {'df': new_df, 'masked_row_indices': []}
+    # DataFrame を含む辞書は == で比べられないので、変化の有無は確かめずに積む。
+    op.host.push_property_change(dataset, old_values, new_values,
+                                 f"「{dataset.name}」を再読み込み", skip_if_unchanged=False)
+    op.host.show_status(f"「{dataset.name}」を元ファイルから再読み込みしました")
+
+
+def copy_methods_text(op):
+    """今のデータセットの処理履歴から「方法」節向けの説明文を作り、クリップボードに写す。"""
+    dataset = op.current_dataset()
+    if dataset.provenance is None:
+        op.stop()
+    QApplication.clipboard().setText(generate_methods_text(dataset, op.host.project))
+    op.host.show_status("「方法」文をクリップボードにコピーしました")
+
+
+TRANSFER_OPERATIONS = {
+    "export_data": Operation("データ表を書き出す", export_data),
+    "copy_to_tab": Operation("タブ間のデータセット転送", lambda op: copy_or_move_to_tab(op, move=False)),
+    "move_to_tab": Operation("タブ間のデータセット転送", lambda op: copy_or_move_to_tab(op, move=True)),
+    "copy_style": Operation("スタイルのコピー", copy_style),
+    "paste_style": Operation("スタイルの貼り付け", paste_style),
+    "reload_from_source": Operation("再読み込み", reload_from_source),
+    "copy_methods_text": Operation("「方法」文のコピー", copy_methods_text),
+}

graphica/gui/datasets/order.py

@@ -0,0 +1,310 @@
+"""データセットの並び。描画の順(project.datasets)・一覧のツリー・保存用のフォルダ構造(dataset_group_tree)の 3 つと、
+それらを合わせる規則をここに集める。
+
+今の規則(変えるときはここだけ):
+- 追加はツリーでは指定したフォルダの末尾。描画順は、最上位なら末尾、フォルダの中ならツリーで直前にあるデータセットの
+  すぐ後(一覧と描画の重なりをそろえる。K-18)。保存済みの並びは変えないので、開いたプロジェクトの見た目は変わらない。
+- ドラッグの並べ替えのあとでだけ、描画順をツリーの順(深さ優先)に合わせる。同じフォルダの中の並べ替えだけ Undo できる。
+- 保存用のフォルダ構造は保存・比較の直前にツリーから作り、読み込みではそこからツリーを作り直す。
+- 削除の Undo は、描画順の全体と各項目の親・位置を控えて戻す。
+"""
+from PySide6.QtCore import Qt
+
+_DATASET_ROLE = Qt.ItemDataRole.UserRole
+
+
+def item_dataset(item):
+    """ツリーの項目のデータセット。フォルダなら None。"""
+    return item.data(0, _DATASET_ROLE)
+
+
+class DatasetOrder:
+
+    def __init__(self, project, tree, make_dataset_item):
+        # ツリーは組み立ての途中で差し替わるので、使うたびに取り出す
+        self._project = project
+        self._tree = tree
+        self._make_dataset_item = make_dataset_item
+
+    @property
+    def tree(self):
+        return self._tree()
+
+    @property
+    def datasets(self):
+        return self._project.datasets
+
+    # --- 探す ---
+
+    def find_row(self, dataset):
+        """描画順の位置。Dataset の == は DataFrame を比べて例外になるので、同一性(is)で探す。"""
+        for i, ds in enumerate(self._project.datasets):
+            if ds is dataset:
+                return i
+        return -1
+
+    def dataset_items(self, parent_item=None):
+        """データセットの葉を表示順(深さ優先)に返す。"""
+        items = []
+        source = self.tree.invisibleRootItem() if parent_item is None else parent_item
+        for i in range(source.childCount()):
+            child = source.child(i)
+            if item_dataset(child) is not None:
+                items.append(child)
+            else:
+                items.extend(self.dataset_items(child))
+        return items
+
+    def item_for(self, dataset):
+        for item in self.dataset_items():
+            if item_dataset(item) is dataset:
+                return item
+        return None
+
+    def current_dataset(self):
+        item = self.tree.currentItem()
+        if item is None:
+            return None
+        return item_dataset(item)
+
+    def selected_datasets(self):
+        return [ds for item in self.tree.selectedItems() if (ds := item_dataset(item)) is not None]
+
+    def target_folder(self):
+        """選択中の項目がフォルダならそれ(新しいデータセットをその中に入れる)。"""
+        current_item = self.tree.currentItem()
+        if current_item is not None and item_dataset(current_item) is None:
+            return current_item
+        return None
+
+    @staticmethod
+    def top_level_items(items):
+        """ほかの選択項目の子孫でないものだけ(フォルダと中身が両方選ばれていても二重に扱わないため)。"""
+        item_ids = {id(it) for it in items}
+        result = []
+        for item in items:
+            ancestor = item.parent()
+            while ancestor is not None and id(ancestor) not in item_ids:
+                ancestor = ancestor.parent()
+            if ancestor is None:
+                result.append(item)
+        return result
+
+    # --- 足す ---
+
+    def append(self, dataset, parent_folder=None):
+        """ツリーのフォルダの末尾と、それに合う描画順の位置に足す。"""
+        item = self._make_dataset_item(dataset, parent_folder)
+        position = len(self._project.datasets) if parent_folder is None else self._draw_position_for(item)
+        self._project.datasets.insert(position, dataset)
+        return item
+
+    def _draw_position_for(self, item):
+        """ツリーで直前にあるデータセットの描画順のすぐ後。前に無ければ直後のものの前、どちらも無ければ末尾。"""
+        leaves = self.dataset_items()
+        index = next(i for i, leaf in enumerate(leaves) if leaf is item)
+        for leaf in reversed(leaves[:index]):
+            row = self.find_row(item_dataset(leaf))
+            if row != -1:
+                return row + 1
+        for leaf in leaves[index + 1:]:
+            row = self.find_row(item_dataset(leaf))
+            if row != -1:
+                return row
+        return len(self._project.datasets)
+
+    def add_folder(self, name, parent_item=None):
+        from PySide6.QtWidgets import QTreeWidgetItem
+
+        item = QTreeWidgetItem([name])
+        item.setData(0, _DATASET_ROLE, None)
+        if parent_item is not None:
+            parent_item.addChild(item)
+        else:
+            self.tree.addTopLevelItem(item)
+        item.setExpanded(True)
+        return item
+
+    def detach_item(self, item):
+        """ツリーから外す(親の子か最上位かで外し方が違う)。"""
+        parent = item.parent()
+        if parent is not None:
+            parent.removeChild(item)
+        else:
+            index = self.tree.indexOfTopLevelItem(item)
+            if index != -1:
+                self.tree.takeTopLevelItem(index)
+
+    def remove_added(self, dataset):
+        """append() の取り消し。"""
+        row = self.find_row(dataset)
+        if row != -1:
+            del self._project.datasets[row]
+        item = self.item_for(dataset)
+        if item is not None:
+            self.detach_item(item)
+
+    # --- 消す ---
+
+    def removal(self, top_level_items):
+        """項目(データセットかフォルダ)を消す手順と戻す手順。消すものが無ければ None。
+
+        戻すために、描画順の全体と各項目の親・位置を控える。外した項目はこの手順が持つので、同じものを差し戻せる。
+        戻り値は (消す手順, 戻す手順, 消えるデータセット)。
+        """
+        tree = self.tree
+        snapshots = []  # [(item, parent_item_or_None, index_in_parent), ...]
+        for item in top_level_items:
+            parent = item.parent()
+            index = parent.indexOfChild(item) if parent is not None else tree.indexOfTopLevelItem(item)
+            if index == -1:
+                continue
+            snapshots.append((item, parent, index))
+        if not snapshots:
+            return None
+
+        removed_datasets = []
+        for item, _parent, _index in snapshots:
+            dataset = item_dataset(item)
+            if dataset is not None:
+                removed_datasets.append(dataset)
+            else:
+                removed_datasets.extend(item_dataset(leaf) for leaf in self.dataset_items(item))
+
+        datasets_before = list(self._project.datasets)
+
+        def remove():
+            # 操作中に currentItemChanged が出ないように
+            tree.blockSignals(True)
+            try:
+                rows = sorted({row for ds in removed_datasets if (row := self.find_row(ds)) != -1}, reverse=True)
+                for row in rows:
+                    del self._project.datasets[row]
+                # 同じ親の中でずれないよう、後ろから外す
+                for item, parent, _index in sorted(snapshots, key=lambda s: s[2], reverse=True):
+                    if parent is not None:
+                        parent.removeChild(item)
+                    else:
+                        index = tree.indexOfTopLevelItem(item)
+                        if index != -1:
+                            tree.takeTopLevelItem(index)
+            finally:
+                tree.blockSignals(False)
+
+        def restore():
+            tree.blockSignals(True)
+            try:
+                for item, parent, index in sorted(snapshots, key=lambda s: s[2]):
+                    if parent is not None:
+                        parent.insertChild(min(index, parent.childCount()), item)
+                    else:
+                        tree.insertTopLevelItem(min(index, tree.topLevelItemCount()), item)
+                # リストの中身だけ差し替える(描画順も戻る)
+                self._project.datasets[:] = datasets_before
+            finally:
+                tree.blockSignals(False)
+
+        return remove, restore, removed_datasets
+
+    # --- 描画順とツリーの順 ---
+
+    def tree_order(self):
+        """ツリーの表示順(深さ優先)に並べたデータセット。"""
+        return [item_dataset(item) for item in self.dataset_items()]
+
+    def sort_tree_to_draw_order(self):
+        """フォルダの中の並びを描画順に合わせる(並べ替えの Undo/Redo 用)。フォルダ自体は動かさない。"""
+        tree = self.tree
+        order_index = {id(ds): i for i, ds in enumerate(self._project.datasets)}
+        selected_ids = {id(item_dataset(item)) for item in tree.selectedItems()}
+        current_item = tree.currentItem()
+        current_dataset = item_dataset(current_item) if current_item else None
+
+        tree.blockSignals(True)
+
+        def sort_children(parent_item):
+            source = tree.invisibleRootItem() if parent_item is None else parent_item
+            children = [source.child(i) for i in range(source.childCount())]
+
+            dataset_positions = [i for i, c in enumerate(children) if item_dataset(c) is not None]
+            dataset_items_sorted = sorted(
+                (children[i] for i in dataset_positions),
+                key=lambda it: order_index.get(id(item_dataset(it)), 0)
+            )
+            new_children = list(children)
+            for pos, item in zip(dataset_positions, dataset_items_sorted):
+                new_children[pos] = item
+
+            for _ in range(source.childCount()):
+                source.takeChild(0)
+            for item in new_children:
+                source.addChild(item)
+
+            for item in new_children:
+                if item_dataset(item) is None:
+                    sort_children(item)
+
+        sort_children(None)
+
+        for item in self.dataset_items():
+            ds = item_dataset(item)
+            if id(ds) in selected_ids:
+                item.setSelected(True)
+            if ds is current_dataset:
+                tree.setCurrentItem(item)
+        tree.blockSignals(False)
+
+    # --- 保存用のフォルダ構造 ---
+
+    def group_tree(self):
+        """ツリーから保存用のフォルダ構造を作る。"""
+        def walk(parent_item):
+            children = []
+            source = self.tree.invisibleRootItem() if parent_item is None else parent_item
+            for i in range(source.childCount()):
+                child = source.child(i)
+                dataset = item_dataset(child)
+                if dataset is not None:
+                    children.append({'dataset': dataset})
+                else:
+                    children.append({'name': child.text(0), 'children': walk(child)})
+            return children
+        return {'name': '', 'children': walk(None)}
+
+    def rebuild_tree(self):
+        """保存用のフォルダ構造からツリーを作り直す(読み込みのあと)。"""
+        tree = self.tree
+        tree.clear()
+
+        def build(node, parent_item):
+            for child_node in node.get('children', []):
+                if 'dataset' in child_node:
+                    self._make_dataset_item(child_node['dataset'], parent_item)
+                else:
+                    folder_item = self.add_folder(child_node.get('name', 'フォルダ'), parent_item)
+                    build(child_node, folder_item)
+
+        build(self._project.dataset_group_tree, None)
+
+    # --- 検索 ---
+
+    def filter_by_name(self, text):
+        """名前に検索文字列を含むデータセットだけを出す。フォルダは中に1つでも当たりがあれば出す。"""
+        query = text.strip().lower()
+
+        def apply_filter(item):
+            dataset = item_dataset(item)
+            if dataset is not None:
+                visible = (not query) or (query in dataset.name.lower())
+                item.setHidden(not visible)
+                return visible
+            any_child_visible = False
+            for i in range(item.childCount()):
+                if apply_filter(item.child(i)):
+                    any_child_visible = True
+            item.setHidden(bool(query) and not any_child_visible)
+            return any_child_visible or not query
+
+        root = self.tree.invisibleRootItem()
+        for i in range(root.childCount()):
+            apply_filter(root.child(i))