LargeST/dataset.py

from __future__ import annotations

import argparse
import tempfile
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, Iterable
from torch.utils.data import Dataset, DataLoader

import pandas as pd
import yaml
import ipdb

# Record whether the required fields are provided.
field_dict = {
    'dataset': {'modalities': ['meta_features', 'node_level_task_graphs', 'time_series']},
    'graphs': ['', '', '', ''],
    'time_series': ['', '', '', ' ', '']
}

def read_yaml(path: Path) -> dict[str, Any]:
    with path.open("r", encoding="utf-8") as f:
        return yaml.safe_load(f)

def read_all_configs(dataset_yaml_path: str) -> Dict[str, Any]:
    """
    Read all related configuration files, starting from dataset.yaml.
    
    Args:
        dataset_yaml_path: Path to dataset.yaml.
        
    Returns:
        A dictionary containing all configurations.
    """
    # Get the protocol directory path.
    protocol_dir = Path(dataset_yaml_path).parent
    
    # 1. Read dataset.yaml.
    dataset_config = read_yaml(Path(dataset_yaml_path))
    print(f"已读取 dataset.yaml: {dataset_config['dataset_name']}")
    
    # 2. Read graph configurations.
    graph_configs = {}
    if 'node_level_task_graphs' in dataset_config['modalities']:
        graph_ids = dataset_config['modalities']['node_level_task_graphs'].get('graph_ids', [])
        
        for graph_id in graph_ids:
            graph_yaml_path = protocol_dir / f"input_multimodal/node_level_task_graphs/{graph_id}/graph.yaml"
            if graph_yaml_path.exists():
                graph_config = read_yaml(Path(graph_yaml_path))
                graph_configs[graph_id] = graph_config
                print(f"已读取 graph.yaml: {graph_id}")
            else:
                print(f"警告: 未找到 graph.yaml: {graph_yaml_path}")
    
    # 3. Read time series configurations.
    ts_configs = {}
    if 'time_series' in dataset_config['modalities']:
        ts_ids = dataset_config['modalities']['time_series'].get('time_series_ids', [])
        
        for ts_id in ts_ids:
            ts_yaml_path = protocol_dir / f"input_multimodal/time_series/{ts_id}/series.yaml"
            if ts_yaml_path.exists():
                ts_config = read_yaml(Path(ts_yaml_path))
                ts_configs[ts_id] = ts_config
                print(f"已读取 series.yaml: {ts_id}")
            else:
                print(f"警告: 未找到 series.yaml: {ts_yaml_path}")
    
    # 4. Combine all configurations.
    all_configs = {
        'dataset': dataset_config,
        'graphs': graph_configs,
        'time_series': ts_configs
    }
    
    return all_configs

def _first_existing(candidates: Iterable[Path]) -> Path:
    candidate_list = [Path(p).expanduser() for p in candidates]
    for p in candidate_list:  # Return an existing path from the candidate paths.
        if p.is_file():
            return p.resolve()
    shown = ", ".join(str(c) for c in candidate_list)
    raise FileNotFoundError(f"None of the candidate paths exist: {shown}")


def _load_frame(path: Path) -> pd.DataFrame:
    """Load a single-table file as used in protocol YAMLs (csv / parquet / h5)."""
    path = Path(path).expanduser().resolve()
    suf = path.suffix.lower()
    if suf == ".csv":
        return pd.read_csv(path)
    if suf in (".tsv", ".txt"):
        return pd.read_csv(path, sep="\t")
    if suf in (".parquet", ".pq"):
        return pd.read_parquet(path)
    if suf in (".h5", ".hdf5", ".hdf"):
        return pd.read_hdf(path)
    raise ValueError(f"Unsupported data file extension for {path}")


def _meta_candidates(dataset_dir: Path, file_name: str) -> list[Path]:
    p = Path(file_name).expanduser()
    if p.is_absolute():
        return [p]
    return [
        dataset_dir / "input_multimodal" / file_name,
    ]


def _graph_file_candidates(dataset_dir: Path, graph_level: str, graph_id: str, file_name: str) -> list[Path]:
    p = Path(file_name).expanduser()
    if p.is_absolute():
        return [p]
    base = [
        dataset_dir
        / "input_multimodal"
        / graph_level
        / graph_id
        / file_name,
    ]
    return base


def _series_file_candidates(dataset_dir: Path, series_id: str, file_name: str) -> list[Path]: # Generate all candidate storage paths.
    p = Path(file_name).expanduser()
    if p.is_absolute():
        return [p]
    return [
        dataset_dir / "input_multimodal" / "time_series" / series_id / file_name,
        dataset_dir / file_name,
        dataset_dir / "input_multimodal" / file_name,
    ]

def _parse_meta(meta: pd.DataFrame) -> Dict[str, Any]:
    # Parse each column in meta_df and convert the data to a dictionary.
    meta_dict = {}
    for col in meta.columns:
        meta_dict[col] = list(meta[col])
    return meta_dict

def _parse_graph(graph: pd.DataFrame, graph_features: list[str] | None) -> Dict[str, Any]:
    ''' 
    Required information in the graph dictionary includes:
    - A sparse adjacency list
    - The weight of each edge
    - Edge features (optional)
    '''
    graph_dict = {}
    required_fields = ['src_id', 'dst_id', 'weight']
    for field in required_fields:
        if field not in graph.columns:
            raise ValueError(f"Missing required column: {field}")

    graph_dict['edge'] = list(zip(graph['src_id'], graph['dst_id']))
    graph_dict['weight'] = graph['weight'].tolist()
    if all(x == 1.0 for x in list(graph_dict['weight'])):
        graph_dict['weighted'] = False
    else:
        graph_dict['weighted'] = True

    if graph_features is not None: # Add graph features to the dictionary if they are available.
        for feature in graph_features:
            graph_dict[feature] = list(graph[feature])
    
    return graph_dict

def _parse_time_series(time_series: pd.DataFrame, scfg: dict[str, Any], time2graph_map: Dict[str, Any]|None) -> Dict[str, Any]:
    
    time_series_dict = {}   
    variables_mode = scfg.get("variables_mode")
    time_series_dict['variables_mode'] = variables_mode # Use mode to distinguish single-variable and multivariable data.

    if variables_mode == "single": # For a single variable, the index is timestamp, column names are sample_id values, and the feature name is series_id.
        time_type = str(time_series.index.dtype)

        time_series_dict['time_type'] = time_type
        time_series_dict['timestamp'] = time_series.index.tolist()
        time_series_dict['value'] = {}
        if time2graph_map: # 
            for col in time_series.columns:
                time_series_dict['value'][time2graph_map.get(int(col), col)] = list(time_series[col])
        else:
            for col in time_series.columns:
                time_series_dict['value'][col] = list(time_series[col])
    else: 
        # For multiple variables, the columns are sample_id, timestamp, feature_name1, feature_name2, ...
        # Extract timestamps and feature values in timestamp order, using the structure feature_name*: {sample_id: [values]}.
        index_cfg = scfg.get("index") or {}
        id_col = index_cfg.get("id_colunm") or index_cfg.get("id_column")
        time_col = index_cfg.get("time_column")
        if not id_col:
            raise ValueError("time_series.index must configure id_colunm or id_column")
        if not time_col:
            raise ValueError("time_series.index must configure time_column")

        required_columns = [id_col, time_col]
        missing_columns = [col for col in required_columns if col not in time_series.columns]
        if missing_columns:
            raise ValueError(f"Missing required time series column(s): {missing_columns}")

        series_features = index_cfg.get("feature_column")
        if not series_features:
            series_features = [col for col in time_series.columns if col not in required_columns]
        elif isinstance(series_features, str):
            series_features = [series_features]
        else:
            series_features = list(series_features)

        if not series_features:
            raise ValueError("No feature columns configured or inferred for time series")

        missing_features = [col for col in series_features if col not in time_series.columns]
        if missing_features:
            raise ValueError(f"Missing configured feature column(s): {missing_features}")

        sorted_time_series = time_series.sort_values([id_col, time_col])
        time_series_dict['feature_names'] = series_features
        time_series_dict['time_type'] = str(time_series[time_col].dtype)
        time_series_dict['timestamp'] = sorted(time_series[time_col].drop_duplicates().tolist())
        timestamp_by_sample = {}
        time_series_dict['value'] = {feature: {} for feature in series_features}

        for sample_id, sample_df in sorted_time_series.groupby(id_col, sort=False):
            output_sample_id = time2graph_map.get(sample_id, sample_id) if time2graph_map else sample_id
            timestamp_by_sample[output_sample_id] = sample_df[time_col].tolist()
            for feature in series_features:
                time_series_dict['value'][feature][output_sample_id] = sample_df[feature].tolist()

        if any(timestamps != time_series_dict['timestamp'] for timestamps in timestamp_by_sample.values()):
            time_series_dict['timestamp_by_sample'] = timestamp_by_sample
        
    return time_series_dict

@dataclass
class LoadedDataset:
    dataset_dir: Path
    config: dict[str, Any]
    meta_features: Dict[str, Any]
    graphs: Dict[str, Any]
    time_series: Dict[str, Any]
 
    
# def _check_graphs(graph_config: dict[str, Any]) -> None:
#     check 


# Read all YAML files into one configuration.
class MultiModalDataset(LoadedDataset):
    """
    Use the configuration returned by ``read_all_configs`` to resolve protocol paths under ``dataset_dir`` and load tables.

    ``dataset_dir`` is usually the protocol root containing ``input_multimodal/`` and ``dataset.yaml``,
    or an equivalent data root. Path resolution tries ``dataset_dir/<file>`` and
    ``dataset_dir/input_multimodal/...``, among other candidate locations, in order.
    """

    def __init__(self, config: dict[str, Any], dataset_dir: Path | str) -> None:
        root = Path(dataset_dir).expanduser().resolve()
        dataset_cfg = config["dataset"]
        modalities = dataset_cfg.get("modalities") or {}
        time2graph_map = {}

        # Read meta_features data.
        meta_block: Dict[str, Any] = {}
        if isinstance(modalities.get("meta_features"), dict):
            mf = modalities["meta_features"]
            meta_file = mf.get("file_name")
            if mf.get("required") and not meta_file:
                raise ValueError("meta_features is required but file_name is not configured")
            if meta_file:
                meta_path = _first_existing(_meta_candidates(root, str(meta_file)))
                meta_tmp = _load_frame(meta_path)
                meta_features = _parse_meta(meta_tmp) # Parse meta_df.
                sample_def = dataset_cfg.get("sample_defination") or dataset_cfg.get(
                    "sample_definition"
                )
                id_col_graph = None
                id_col_time_series = None
                if isinstance(sample_def, dict):
                    id_col_graph = sample_def.get("sample_id_graph")
                    id_col_time_series = sample_def.get("sample_id_time_series")

                meta_block = {
                    "path": str(meta_path),
                    "features": meta_features,
                    "sample_id_graph": id_col_graph,
                    "sample_id_time_series": id_col_time_series,
                }
                if id_col_graph is not None and id_col_time_series is not None: 
                    # If both id_col_graph and id_col_time_series exist, build a mapping between them to align the two modalities.
                    # By default, map time series IDs from id_col_time_series to graph IDs in id_col_graph.
                    time2graph_map = {time_id: graph_id for time_id, graph_id in zip(meta_tmp[id_col_time_series], meta_tmp[id_col_graph])}
        # Read graph data.
        graphs: Dict[str, Any] = {}
        for gid, gcfg in (config.get("graphs") or {}).items():
            if not isinstance(gcfg, dict):
                continue
            fname = gcfg.get("file_name")
            graph_level = gcfg.get("graph_level") # Graph level, for example: node_level_task_graph, graph_level_task_graph.
            graph_directed = gcfg.get("directed") # Graph type, for example: directed, undirected.
            edge_features_cfg = gcfg.get("edge_features") or {}
            graph_features = edge_features_cfg.get("feature_name") if edge_features_cfg.get("available") else None # Graph features, for example: edge_features.
            if not fname:
                continue
            
            gpath = _first_existing(_graph_file_candidates(root, str(graph_level), str(gid), str(fname)))
            tmp_graph = _load_frame(gpath)
            # Continue parsing individual graph features.
            tmp_graph_dict = _parse_graph(tmp_graph, graph_features)
            tmp_graph_dict['directed'] = graph_directed
            tmp_graph_dict['edge_features'] = graph_features
            graphs[str(gid)] = tmp_graph_dict # Load graph data into the dictionary.

        time_series: Dict[str, Any] = {}
        for sid, scfg in (config.get("time_series") or {}).items():
            if not isinstance(scfg, dict):
                continue
            fname = scfg.get("file_name")
            if not fname:
                continue
            spath = _first_existing(_series_file_candidates(root, str(sid), str(fname)))
            tmp_time_series = _load_frame(spath)
            
            frequency = scfg.get("temporal_granularity")
            tmp_time_series_dict = _parse_time_series(tmp_time_series, scfg, time2graph_map)
            tmp_time_series_dict['frequency'] = frequency
            time_series[str(sid)] = tmp_time_series_dict

        super().__init__(
            dataset_dir=root,
            config=config,
            meta_features=meta_block,
            graphs=graphs,
            time_series=time_series,
        )


if __name__ == '__main__':
    protocol_dir = Path(__file__).resolve().parent
    dataset_yaml_path = protocol_dir / "dataset.yaml"

    configs = read_all_configs(str(dataset_yaml_path))
    dataset = MultiModalDataset(configs, protocol_dir)
    ipdb.set_trace()
    # At the breakpoint, check whether all required information has been loaded.

    # assert isinstance(dataset.config, dict), "dataset.config should be a dict"
    # assert "dataset" in dataset.config, "dataset.config should include dataset config"
    # assert isinstance(dataset.meta_features, dict), "dataset.meta_features should be a dict"
    # assert "features" in dataset.meta_features, "dataset.meta_features should include parsed features"
    # assert isinstance(dataset.meta_features["features"], dict), (
    #     "dataset.meta_features['features'] should be a dict"
    # )
    # assert isinstance(dataset.graphs, dict), "dataset.graphs should be a dict"
    # assert "road_distance_graph" in dataset.graphs, (
    #     "dataset.graphs should include road_distance_graph"
    # )
    # assert isinstance(dataset.graphs["road_distance_graph"], dict), (
    #     "road_distance_graph should be a parsed dict"
    # )
    # assert isinstance(dataset.time_series, dict), "dataset.time_series should be a dict"
    # assert "traffic_flow" in dataset.time_series, (
    #     "dataset.time_series should include traffic_flow"
    # )
    # traffic_flow = dataset.time_series["traffic_flow"]
    # assert isinstance(traffic_flow, dict), (
    #     "traffic_flow should be a parsed dict"
    # )
    # for field in ("variables_mode", "timestamp", "value", "frequency"):
    #     assert field in traffic_flow, f"traffic_flow should include {field}"

    print(f"Dataset: {dataset.config['dataset'].get('dataset_name')}")
    print(f"Protocol dir: {dataset.dataset_dir}")
    print(f"Meta features: columns={len(dataset.meta_features.get('features', {}))}")
    for graph_id, graph_dict in dataset.graphs.items():
        print(
            f"Graph[{graph_id}]: edges={len(graph_dict.get('edge', []))}, "
            f"directed={graph_dict.get('directed')}"
        )
    for series_id, series_data in dataset.time_series.items():
        if isinstance(series_data, dict):
            value = series_data.get("value", {})
            if series_data.get("variables_mode") == "single":
                feature_count = 1
                sample_count = len(value)
            else:
                feature_count = len(value)
                sample_count = len(next(iter(value.values()), {}))
            print(
                f"TimeSeries[{series_id}]: mode={series_data.get('variables_mode')}, "
                f"features={feature_count}, timestamps={len(series_data.get('timestamp', []))}, "
                f"samples={sample_count}"
            )
        else:
            print(f"TimeSeries[{series_id}]: shape={series_data.shape}")