Well Event: Emit RPTRST/RPTSCHED as proper mnemonic lists

Schedule-level keywords whose OPM ParserRecord is a single ALL-sized item
(RPTRST, RPTSCHED, ...) are not positional — they take a free-form list
of mnemonic tokens like `BASIC=2 DEN ROCKC NORST=1`. Previously each
`keyword_data` entry became its own DeckItem, and OPM emitted them
either as truncated positional values or as a quoted, space-collapsed
single string.

Detect that schema shape in `RifEventKeywordFormatter::formatKeyword`
and pack the user's entries into one RawString DeckItem of mnemonic
tokens: `KEY` for FLAG items, `KEY=VALUE` otherwise.

To distinguish flag mnemonics (`DEN`) from `KEY=1`-style entries, add a
new `FLAG` value to `RimWellEventKeywordItem::ItemType` plumbed end to
end (Python -> GRPC -> Rimc -> storage -> formatter). The Python API
now maps `bool True` to FLAG and silently drops `bool False`.

For positional keywords (WCONHIST etc.) FLAG items have no value to
emit and are rendered as default markers ("1*").

A `rawStringItem` helper is added to `RifOpmDeckTools` so the
mnemonic-list path can produce DeckItems whose OPM output is not
quoted.

GrpcInterface/Python/rips/tests/test_well_events.py

@@ -1895,3 +1895,55 @@ class TestScheduleKeywordEvents:
         )
 
         assert event is not None, "Event with mixed types should be created"
+
+    def test_rptrst_mnemonic_output(self, project_with_case_and_well):
+        """RPTRST/RPTSCHED are mnemonic-list keywords. bool True must emit a
+        bare KEY, int/float/str must emit KEY=VALUE, bool False must be omitted.
+        """
+        project, case, timeline = project_with_case_and_well
+        well_path = project.well_paths()[0]
+
+        # Schedule generation requires at least one well event so a well path is
+        # selected for output; the assertions below target only the RPTRST block.
+        timeline.add_control_event(
+            event_date="2024-01-01",
+            well_path=well_path,
+            control_mode="ORAT",
+            control_value=1000.0,
+            oil_rate=1000.0,
+            is_producer=True,
+        )
+
+        timeline.add_keyword_event(
+            event_date="2024-01-01",
+            keyword_name="RPTRST",
+            keyword_data={
+                "BASIC": 2,
+                "DEN": True,
+                "ROCKC": True,
+                "RPORV": True,
+                "RFIP": True,
+                "FLOWS": True,
+                "NORST": 1,
+                "FLORES": True,
+                "OBSOLETE": False,
+            },
+        )
+
+        schedule_text = timeline.generate_schedule_text(eclipse_case=case)
+        print(f"\nRPTRST mnemonic output:\n{schedule_text}")
+
+        assert "RPTRST" in schedule_text
+        rptrst_block = schedule_text.split("RPTRST", 1)[1].split("/", 1)[0]
+
+        # Keyed mnemonics rendered as KEY=VALUE.
+        assert "BASIC=2" in rptrst_block
+        assert "NORST=1" in rptrst_block
+        # Flag mnemonics rendered as bare tokens. Whitespace-bounded so we don't accept
+        # accidental substring matches like 'DEN' inside another token.
+        for flag in ("DEN", "ROCKC", "RPORV", "RFIP", "FLOWS", "FLORES"):
+            assert f" {flag} " in rptrst_block or rptrst_block.rstrip().endswith(
+                f" {flag}"
+            ), f"flag {flag!r} missing from RPTRST output: {rptrst_block!r}"
+        # False-valued flag must be omitted entirely.
+        assert "OBSOLETE" not in rptrst_block

GrpcInterface/Python/rips/well_events.py

@@ -121,15 +121,24 @@ def add_well_keyword_event(
     item_values = []
 
     for name, value in keyword_data.items():
+        # Handle bool before int (bool is subclass of int in Python).
+        # bool semantics: True -> flag (emitted as bare KEY in mnemonic-list keywords,
+        # ignored elsewhere); False -> the entry is dropped entirely.
+        if isinstance(value, bool):
+            if not value:
+                continue
+            item_names.append(name)
+            item_types.append("FLAG")
+            # The value is ignored for FLAG items but must be a non-empty string;
+            # empty strings get dropped by the GRPC vector<string> serialization.
+            item_values.append("1")
+            continue
+
         item_names.append(name)
 
         if isinstance(value, str):
             item_types.append("STRING")
             item_values.append(value)
-        elif isinstance(value, bool):
-            # Handle bool before int (bool is subclass of int in Python)
-            item_types.append("INT")
-            item_values.append("1" if value else "0")
         elif isinstance(value, int):
             item_types.append("INT")
             item_values.append(str(value))
@@ -228,15 +237,24 @@ def add_keyword_event(
     item_values = []
 
     for name, value in keyword_data.items():
+        # Handle bool before int (bool is subclass of int in Python).
+        # bool semantics: True -> flag (emitted as bare KEY in mnemonic-list keywords,
+        # ignored elsewhere); False -> the entry is dropped entirely.
+        if isinstance(value, bool):
+            if not value:
+                continue
+            item_names.append(name)
+            item_types.append("FLAG")
+            # The value is ignored for FLAG items but must be a non-empty string;
+            # empty strings get dropped by the GRPC vector<string> serialization.
+            item_values.append("1")
+            continue
+
         item_names.append(name)
 
         if isinstance(value, str):
             item_types.append("STRING")
             item_values.append(value)
-        elif isinstance(value, bool):
-            # Handle bool before int (bool is subclass of int in Python)
-            item_types.append("INT")
-            item_values.append("1" if value else "0")
         elif isinstance(value, int):
             item_types.append("INT")
             item_values.append(str(value))