Generate repeated condition codes once

A condition code maps 1:1 to a <code>.wnd filename, so a repeated code (for
example an "EWM True [50, 50]" row or two "- EWM50" lines) can only describe the
same output. generate_all now generates each distinct code once, preserving
first-seen order.

This fixes a P1 in atomic mode: the duplicate path was staged twice, so the
second os.replace raised FileNotFoundError after one file had already been
committed, breaking the advertised all-or-nothing behaviour. It also keeps the
non-atomic result count honest.

Adds regression tests for repeated codes in both atomic and non-atomic paths.

Author: SMI-Lab-Inha

CHANGELOG.md

@@ -43,6 +43,9 @@ valid case.
 
 - Input files are read with `utf-8-sig`, so a leading byte-order mark (common in
   files saved by Windows editors) no longer corrupts the first line.
+- A repeated condition code (it maps to the same `.wnd` file) is now generated
+  once instead of being staged twice, which previously broke `atomic=True` with a
+  `FileNotFoundError` and left partial output behind.
 
 ## [0.1.2] - 2026-05-22
 

src/pyiecwind/generation.py

@@ -603,6 +603,18 @@ def gen_ewm(code: str, params: IECParameters, output_dir: str | Path | None = No
 }
 
 
+def _ordered_unique(codes: tuple[str, ...]) -> list[str]:
+    """Return ``codes`` with duplicates removed, preserving first-seen order.
+
+    Each condition code maps to a single ``<code>.wnd`` file, so a repeated code
+    can only ever describe the same output. Generating it once keeps the result
+    count honest and -- crucially for ``atomic=True`` -- avoids staging the same
+    path twice and then failing to move it on the second commit pass.
+    """
+
+    return list(dict.fromkeys(codes))
+
+
 def _generate_one(
     code: str,
     params: IECParameters,
@@ -656,7 +668,7 @@ def _generate_all_atomic(
     generated: list[Path] = []
     with tempfile.TemporaryDirectory(prefix=".pyiecwind-staging-", dir=final_dir) as staging:
         staging_dir = Path(staging)
-        for code in params.conditions:
+        for code in _ordered_unique(params.conditions):
             _generate_one(code, params, staging_dir, strict=strict, generated=staged, errors=errors)
         # Reaching here means every condition was generated (or, under
         # strict=False, recorded as an error). Now commit by moving into place.
@@ -677,7 +689,8 @@ def generate_all(
     """Generate every condition listed in ``params``.
 
     Fails closed by default: the first invalid condition raises, so a caller
-    never silently receives partial output.
+    never silently receives partial output. Repeated condition codes describe the
+    same ``<code>.wnd`` file and are generated once (first-seen order preserved).
 
     Parameters
     ----------
@@ -725,7 +738,7 @@ def generate_all(
 
     generated: list[Path] = []
     errors: list[GenerationError] = []
-    for code in params.conditions:
+    for code in _ordered_unique(params.conditions):
         _generate_one(code, params, output_dir, strict=strict, generated=generated, errors=errors)
     return GenerationResult(tuple(generated), tuple(errors))
 

tests/test_generation.py

@@ -190,3 +190,23 @@ def test_atomic_non_strict_commits_valid_files_and_records_errors(self) -> None:
         self.assertTrue((out / "EWM50.wnd").exists())
         self.assertTrue((out / "NWP10.0.wnd").exists())
         self.assertEqual([entry for entry in out.iterdir() if entry.is_dir()], [])
+
+    def test_atomic_handles_repeated_condition_codes(self) -> None:
+        # A repeated code maps to the same file; atomic mode must generate it once
+        # rather than staging it twice and failing on the second commit.
+        out = self.workspace_tempdir() / "out"
+        params = default_parameters(conditions=["EWM50", "NWP10.0", "EWM50"])
+
+        result = generate_all(params, output_dir=out, strict=True, atomic=True)
+
+        self.assertEqual(result.count, 2)
+        self.assertEqual(sorted(p.name for p in out.glob("*.wnd")), ["EWM50.wnd", "NWP10.0.wnd"])
+
+    def test_non_atomic_dedupes_repeated_condition_codes(self) -> None:
+        out = self.workspace_tempdir() / "out"
+        params = default_parameters(conditions=["EWM50", "EWM50"])
+
+        result = generate_all(params, output_dir=out, strict=True, atomic=False)
+
+        self.assertEqual(result.count, 1)
+        self.assertEqual([p.name for p in out.glob("*.wnd")], ["EWM50.wnd"])