flextool 4.0.0__py3-none-any.whl

flextool/gui/plot_config_reader.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from flextool.plot_outputs.config import _is_new_format_entry
+
+logger = logging.getLogger(__name__)
+
+GROUP_NAMES: dict[str, str] = {
+    "0": "Infeasibilities",
+    "1": "Curtailments",
+    "2": "Flows",
+    "3": "Costs",
+    "4": "Capacities",
+    "5": "Emissions",
+    "6": "NodeGroups",
+    "7": "Nodes",
+    "8": "Unit/Conn details",
+    "9": "Extras",
+}
+
+
+@dataclass
+class PlotVariant:
+    """A single variant (letter) within a plot entry."""
+
+    letter: str  # e.g., "d", "t", "g", "a", "tf"
+    result_key: str  # e.g., "node_slack_up_dt_e"
+    sub_config: str  # e.g., "default", "chunks"
+    full_name: str  # e.g., "Loss of load (upward slack)"
+
+
+@dataclass
+class PlotEntry:
+    """A second-level entry in the plot tree (e.g., "0.0")."""
+
+    number: str  # e.g., "0.0"
+    short_name: str  # e.g., "Loss of load (upwar..."
+    full_name: str  # e.g., "Loss of load (upward slack)"
+    variants: list[PlotVariant] = field(default_factory=list)
+
+
+@dataclass
+class PlotGroup:
+    """A first-level group in the plot tree (e.g., "0")."""
+
+    number: str  # e.g., "0"
+    name: str  # e.g., "Infeasibilities"
+    entries: list[PlotEntry] = field(default_factory=list)
+
+
+@dataclass
+class PlotConfigData:
+    """Parsed plot config: tree groups plus top-level metadata.
+
+    Attributes
+    ----------
+    groups:
+        Plot tree as a list of :class:`PlotGroup` objects.
+    default_durations:
+        Map of variant letter -> default time-range duration. Values are
+        either an ``int`` (number of timesteps) or the string ``"all"``
+        (resolved at view time to the available data length). Empty if
+        the YAML does not define a ``default_duration`` key.
+    """
+
+    groups: list[PlotGroup] = field(default_factory=list)
+    default_durations: dict[str, int | str] = field(default_factory=dict)
+
+    # Allow legacy callers that treat the result as a list of groups
+    # (iteration, len, indexing, equality with []) to keep working.
+    def __iter__(self):
+        return iter(self.groups)
+
+    def __len__(self) -> int:
+        return len(self.groups)
+
+    def __getitem__(self, index):
+        return self.groups[index]
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, PlotConfigData):
+            return (
+                self.groups == other.groups
+                and self.default_durations == other.default_durations
+            )
+        if isinstance(other, list):
+            return self.groups == other
+        return NotImplemented
+
+    def __bool__(self) -> bool:
+        return bool(self.groups) or bool(self.default_durations)
+
+
+
+def _derive_variant_letter(result_key: str, sub_config: str,
+                           sub_value: dict | None = None) -> str:
+    """Derive variant letter from result_key suffix and sub_config name.
+
+    The variant letter determines the display order and label for each
+    plot variant (p=period, h=hourly, w=weekly, a=aggregated).
+
+    If *sub_value* contains an explicit ``variant`` key, that value is
+    used directly.
+    """
+    # Explicit override
+    if sub_value and 'variant' in sub_value:
+        return str(sub_value['variant'])
+    if sub_config == 'chunks':
+        return 'w'
+    if sub_config == 'sum_periods':
+        return 'a'
+    if sub_config == 'lines':
+        return 'h'  # lines are always time-based
+    # Default: derive from result_key data type
+    is_dt = '_dt_' in result_key or result_key.endswith('_dt') or '_gdt_' in result_key
+    if is_dt:
+        return 'h'
+    return 'p'
+
+
+def _extract_plot_items(
+    plots: dict,
+) -> list[tuple[str, str, str, str, str, str]]:
+    """Walk the YAML *plots* dict and yield parsed plot items.
+
+    Each entry under ``plots:`` is an entry-name key with ``group``/``order``
+    fields and nested result_keys.
+
+    Each item is ``(group, number, variant, human_name, result_key, sub_config)``.
+    Entries without ``map_dimensions_for_plots`` are skipped.
+    """
+    items: list[tuple[str, str, str, str, str, str]] = []
+    for key, value in plots.items():
+        if not isinstance(value, dict):
+            continue
+        if not _is_new_format_entry(value):
+            continue
+
+        entry_name = key
+        group_num = str(value['group'])
+        order_num = str(value['order'])
+        number = f"{group_num}.{order_num}"
+
+        for result_key, rk_value in value.items():
+            if result_key in ('group', 'order') or not isinstance(rk_value, dict):
+                continue
+            for sub_config, sub_value in rk_value.items():
+                if not isinstance(sub_value, dict):
+                    continue
+                if 'map_dimensions_for_plots' not in sub_value:
+                    continue
+                variant_letter = _derive_variant_letter(
+                    result_key, sub_config, sub_value,
+                )
+                # Use per-variant plot_name if specified, otherwise entry name
+                variant_name = sub_value.get('plot_name', entry_name)
+                items.append(
+                    (group_num, number, variant_letter, variant_name,
+                     result_key, sub_config)
+                )
+
+    return items
+
+
+def _parse_default_durations(data: dict) -> dict[str, int | str]:
+    """Extract ``default_duration`` mapping from a parsed YAML doc.
+
+    Values are either an ``int`` (number of timesteps) or the literal
+    string ``"all"`` (resolve at view time to the available data length).
+    Anything else is silently dropped.
+    """
+    raw = data.get("default_duration")
+    if not isinstance(raw, dict):
+        return {}
+    cleaned: dict[str, int | str] = {}
+    for letter, value in raw.items():
+        key = str(letter)
+        if isinstance(value, bool):
+            continue  # reject bools (int subclass)
+        if isinstance(value, (int, float)):
+            cleaned[key] = int(value)
+        elif isinstance(value, str) and value.strip().lower() == "all":
+            cleaned[key] = "all"
+    return cleaned
+
+
+def parse_plot_config(config_path: Path) -> PlotConfigData:
+    """Parse a plot config YAML and return the tree structure plus defaults.
+
+    Returns a :class:`PlotConfigData` with two attributes:
+
+    * ``groups`` — list of :class:`PlotGroup` objects sorted by group number.
+      Each group contains :class:`PlotEntry` objects sorted by entry number,
+      and each entry contains :class:`PlotVariant` objects for available
+      variant letters. Entries without ``map_dimensions_for_plots`` are
+      excluded.
+    * ``default_durations`` — mapping of variant letter to default time-range
+      duration (``int`` or the sentinel string ``"all"``).
+
+    The returned object is iterable / indexable / comparable to a list of
+    :class:`PlotGroup`, so legacy callers keep working.
+    """
+    if not config_path.is_file():
+        logger.warning("Plot config file not found: %s", config_path)
+        return PlotConfigData()
+
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except (yaml.YAMLError, OSError) as exc:
+        logger.error("Failed to read plot config %s: %s", config_path, exc)
+        return PlotConfigData()
+
+    if not isinstance(data, dict):
+        return PlotConfigData()
+
+    default_durations = _parse_default_durations(data)
+
+    plots = data.get("plots")
+    if not isinstance(plots, dict):
+        return PlotConfigData(default_durations=default_durations)
+
+    items = _extract_plot_items(plots)
+
+    # Group by entry number, collecting variants
+    # Use dict to preserve insertion order; entries keyed by number
+    entry_map: dict[str, PlotEntry] = {}
+    for group, number, variant, human_name, result_key, sub_config in items:
+        if number not in entry_map:
+            entry_map[number] = PlotEntry(
+                number=number,
+                short_name=human_name,
+                full_name=human_name,
+                variants=[],
+            )
+        entry = entry_map[number]
+        # Update full_name if this variant has a longer/better name
+        # (keep the first one encountered for consistency)
+        pv = PlotVariant(
+            letter=variant,
+            result_key=result_key,
+            sub_config=sub_config,
+            full_name=human_name,
+        )
+        # Avoid duplicate variant letters for the same entry
+        existing_letters = {v.letter for v in entry.variants}
+        if variant not in existing_letters:
+            entry.variants.append(pv)
+
+    # Build group structure
+    group_map: dict[str, PlotGroup] = {}
+    for number, entry in entry_map.items():
+        group_num = number.split(".")[0]
+        if group_num not in group_map:
+            group_map[group_num] = PlotGroup(
+                number=group_num,
+                name=GROUP_NAMES.get(group_num, f"Group {group_num}"),
+                entries=[],
+            )
+        group_map[group_num].entries.append(entry)
+
+    # Sort groups by number, entries by number within each group
+    groups = sorted(group_map.values(), key=lambda g: int(g.number))
+    for group in groups:
+        group.entries.sort(key=lambda e: [int(x) for x in e.number.split(".")])
+
+    return PlotConfigData(groups=groups, default_durations=default_durations)

flextool/gui/project_utils.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+# Subdirectories created inside every new project
+PROJECT_SUBDIRS = [
+    "input_sources",
+    "converted",
+    "intermediate",
+    "work",
+    "output_plots",
+    "output_parquet",
+    "output_csv",
+    "output_excel",
+    "output_plot_comparisons",
+]
+
+
+def get_projects_dir() -> Path:
+    """Return the path to the top-level ``projects/`` directory.
+
+    Resolved against the user's current working directory.  In an
+    editable install with the GUI launched from the repo root this is
+    the historical ``<repo>/projects/``; in a wheel install the user is
+    expected to launch ``flextool-gui`` from their workspace, where
+    ``./projects/`` is created on demand.
+    """
+    return Path.cwd() / "projects"
+
+
+def seed_plot_settings(project_path: Path) -> Path:
+    """Ensure ``<project_path>/plot_settings.yaml`` exists.
+
+    Seeds the per-project plot color template from the bundled default so
+    the project owns an editable copy.  Never clobbers an existing file
+    (preserves user edits).  Returns the path to the project file.
+    """
+    plot_settings_path = Path(project_path) / "plot_settings.yaml"
+    if not plot_settings_path.exists():
+        from flextool._resources import package_data_path
+        bundled = package_data_path("schemas/default_plot_settings.yaml")
+        shutil.copy2(bundled, plot_settings_path)
+    return plot_settings_path
+
+
+def create_project(name: str) -> Path:
+    """Create a new project directory with all required subdirectories.
+
+    Returns the path to the newly created project directory.
+    """
+    projects_dir = get_projects_dir()
+    project_path = projects_dir / name
+    project_path.mkdir(parents=True, exist_ok=True)
+
+    for subdir in PROJECT_SUBDIRS:
+        (project_path / subdir).mkdir(exist_ok=True)
+
+    # Seed the per-project plot color template from the bundled default so
+    # the project owns an editable copy.
+    seed_plot_settings(project_path)
+
+    return project_path
+
+
+def list_projects() -> list[str]:
+    """Return a sorted list of project directory names.
+
+    Returns an empty list if the projects directory does not exist.
+    """
+    projects_dir = get_projects_dir()
+    if not projects_dir.exists():
+        return []
+    return sorted(
+        entry.name
+        for entry in projects_dir.iterdir()
+        if entry.is_dir()
+    )
+
+
+def rename_project(old_name: str, new_name: str) -> Path:
+    """Rename a project directory.
+
+    Returns the path to the renamed project directory.
+
+    Raises:
+        FileNotFoundError: If the source project does not exist.
+        FileExistsError: If a project with the new name already exists.
+    """
+    projects_dir = get_projects_dir()
+    old_path = projects_dir / old_name
+    new_path = projects_dir / new_name
+
+    if not old_path.exists():
+        raise FileNotFoundError(f"Project '{old_name}' does not exist.")
+    if new_path.exists():
+        raise FileExistsError(f"Project '{new_name}' already exists.")
+
+    old_path.rename(new_path)
+    return new_path