Scope female entries and clean unpoify output

Author: burner1024

msg2po/conversion.py

@@ -118,10 +118,10 @@ def po2file(
     resulting_entries = []
     extract_fuzzy = CONFIG.extract_fuzzy
 
-    for file_trans in trans_map[occurrence_path]:
-        file_index = file_trans["file_index"]
-        po_index = file_trans["po_index"]
-        entry = po[po_index]
+    for file_trans in trans_map[occurrence_path]:
+        file_index = file_trans["file_index"]
+        po_index = file_trans["po_index"]
+        entry = po[po_index]
 
         if entry.msgstr == "" or ("fuzzy" in entry.flags and not extract_fuzzy):  # if not translated, keep msgid
             value = entry.msgid
@@ -135,13 +135,14 @@ def po2file(
         # context
         context = entry.msgctxt
 
-        # female strings
-        female = None
-        if entry.msgid in female_map:
-            fe_entry = female_map[entry.msgid]
-            if fe_entry.msgstr == "" or "fuzzy" in fe_entry.flags and not extract_fuzzy:
-                female = fe_entry.msgid
-            else:
+        # female strings
+        female = None
+        female_occurrence = (occurrence_path, str(file_index))
+        if female_occurrence in female_map:
+            fe_entry = female_map[female_occurrence]
+            if fe_entry.msgstr == "" or "fuzzy" in fe_entry.flags and not extract_fuzzy:
+                female = fe_entry.msgid
+            else:
                 female = fe_entry.msgstr
 
         resulting_entries.append({"index": file_index, "value": value, "female": female, "context": context})
@@ -287,40 +288,42 @@ class FemaleUpdate:
 
 
 @dataclass(frozen=True)
-class NewFemaleEntry:
-    """A new female PO entry to append."""
-
-    msgid: str
-    msgstr: str
-
-
-def _compute_female_update(
-    e: polib.POEntry,
-    female_value: str,
-    female_map: dict[str, polib.POEntry],
-    overwrite: bool,
-    same: bool,
-) -> FemaleUpdate | NewFemaleEntry | None:
-    """Decide what to do with a female translation value."""
-    if e.msgid in female_map:
-        fe = female_map[e.msgid]
-        if not fe or fe.msgstr == female_value:
-            return None
-        logger.info(f"female translation change: ORIG: {e.msgid} | OLD: {fe.msgstr} | NEW: {female_value}")
+class NewFemaleEntry:
+    """A new female PO entry to append."""
+
+    msgid: str
+    msgstr: str
+    occurrence: tuple[str, str]
+
+
+def _compute_female_update(
+    e: polib.POEntry,
+    female_value: str,
+    female_map: dict[tuple[str, str], polib.POEntry],
+    occurrence: tuple[str, str],
+    overwrite: bool,
+    same: bool,
+) -> FemaleUpdate | NewFemaleEntry | None:
+    """Decide what to do with a female translation value."""
+    if occurrence in female_map:
+        fe = female_map[occurrence]
+        if not fe or fe.msgstr == female_value:
+            return None
+        logger.info(f"female translation change: ORIG: {e.msgid} | OLD: {fe.msgstr} | NEW: {female_value}")
         if not overwrite:
             logger.debug("Female translation already exists, overwrite disabled, skipping")
             return None
         if e.msgid == female_value:
             if same:
                 logger.info(f"source and female translation are the same, using regardless: {e.msgid}")
             else:
-                logger.info(f"source and female translation are the same for {e.occurrences}, skipping")
-                return None
-        return FemaleUpdate(entry=fe, new_msgstr=female_value, clear_fuzzy="fuzzy" in fe.flags)
-    elif e.msgstr != female_value:
-        logger.info(f"new female translation detected: ORIG: {e.msgid} | MALE: {e.msgstr} | FEMALE: {female_value}")
-        return NewFemaleEntry(msgid=e.msgid, msgstr=female_value)
-    return None
+                logger.info(f"source and female translation are the same for {e.occurrences}, skipping")
+                return None
+        return FemaleUpdate(entry=fe, new_msgstr=female_value, clear_fuzzy="fuzzy" in fe.flags)
+    elif e.msgstr != female_value:
+        logger.info(f"new female translation detected: ORIG: {e.msgid} | MALE: {e.msgstr} | FEMALE: {female_value}")
+        return NewFemaleEntry(msgid=e.msgid, msgstr=female_value, occurrence=occurrence)
+    return None
 
 
 def _compute_entry_update(
@@ -364,13 +367,13 @@ def _compute_entry_update(
 
 
 def compute_msgstr_updates(
-    trans_entries: list,
-    occurrence_path: str,
-    entries_dict: OrderedDict,
-    female_map: dict[str, polib.POEntry],
-    overwrite: bool,
-    same: bool,
-    extract_fuzzy: bool,
+    trans_entries: list,
+    occurrence_path: str,
+    entries_dict: OrderedDict,
+    female_map: dict[tuple[str, str], polib.POEntry],
+    overwrite: bool,
+    same: bool,
+    extract_fuzzy: bool,
 ) -> tuple[list[EntryUpdate], list[FemaleUpdate], list[NewFemaleEntry]]:
     """Pure decision logic: compute what updates to apply without mutating anything."""
     entry_updates: list[EntryUpdate] = []
@@ -385,13 +388,14 @@ def compute_msgstr_updates(
         if (occurrence_path, t.index) not in entries_dict:
             continue
 
-        e: polib.POEntry = entries_dict[(occurrence_path, t.index)]
-
-        if t.female:
-            result = _compute_female_update(e, t.female, female_map, overwrite, same)
-            if isinstance(result, FemaleUpdate):
-                female_updates.append(result)
-            elif isinstance(result, NewFemaleEntry):
+        e: polib.POEntry = entries_dict[(occurrence_path, t.index)]
+        occurrence = (occurrence_path, t.index)
+
+        if t.female:
+            result = _compute_female_update(e, t.female, female_map, occurrence, overwrite, same)
+            if isinstance(result, FemaleUpdate):
+                female_updates.append(result)
+            elif isinstance(result, NewFemaleEntry):
                 new_females.append(result)
 
         update = _compute_entry_update(e, t.value, t.context, overwrite, same, extract_fuzzy)
@@ -424,8 +428,8 @@ def apply_msgstr_updates(
             fu.entry.flags.remove("fuzzy")
             fu.entry.previous_msgid = None
 
-    for nf in new_females:
-        po.append(polib.POEntry(msgid=nf.msgid, msgstr=nf.msgstr, msgctxt=CONTEXT_FEMALE))
+    for nf in new_females:
+        po.append(polib.POEntry(msgid=nf.msgid, msgstr=nf.msgstr, msgctxt=CONTEXT_FEMALE, occurrences=[nf.occurrence]))
 
 
 def file2msgstr(

msg2po/indexed_po.py

@@ -11,11 +11,11 @@
 
 
 @dataclass(frozen=True)
-class IndexedPO:
-    po: polib.POFile
-    trans_map: dict
-    female_map: dict[str, polib.POEntry]
-    occ_dict: OrderedDict
+class IndexedPO:
+    po: polib.POFile
+    trans_map: dict
+    female_map: dict[tuple[str, str], polib.POEntry]
+    occ_dict: OrderedDict
 
     @classmethod
     def from_po(cls, po: polib.POFile) -> "IndexedPO":

msg2po/po_utils.py

@@ -1,7 +1,7 @@
 # PO file manipulation utilities: sorting, deduplication, female entry management,
 # metadata generation, and fuzzy flag cleanup.
 
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 from datetime import datetime
 
 import polib
@@ -54,32 +54,37 @@ def translation_entries(po: polib.POFile):
     return entries
 
 
-def female_entries(po: polib.POFile) -> dict[str, polib.POEntry]:
+def female_entries(po: polib.POFile) -> dict[tuple[str, str], polib.POEntry]:
     """
-    Returns mapping of male msgids to corresponding female PO entries.
-    Uses pre-built dicts for O(n) lookup instead of O(n^2) linear scans.
+    Returns mapping of male occurrences to corresponding female PO entries.
+
+    Female entries with explicit occurrences are scoped to those occurrences.
+    Legacy female entries without occurrences are only mapped when they have
+    exactly one possible male occurrence; ambiguous global matches are skipped.
     """
-    # Pre-build lookup dicts: msgid -> entry for non-female entries
-    male_no_ctx = {}  # entries with no context
-    male_any_ctx = {}  # entries with context != female
+    male_occurrences: dict[str, list[tuple[str, str]]] = defaultdict(list)
     for e in po:
         if e.msgctxt == CONTEXT_FEMALE:
             continue
-        if not e.msgctxt:
-            male_no_ctx.setdefault(e.msgid, e)
-        else:
-            male_any_ctx.setdefault(e.msgid, e)
+        for occurrence in e.occurrences:
+            male_occurrences[e.msgid].append(occurrence)
 
     entries = {}
     for e in po:
-        if e.msgctxt != CONTEXT_FEMALE or len(e.occurrences) != 0:
+        if e.msgctxt != CONTEXT_FEMALE:
             continue
-        # Prefer male entry without context, fall back to any non-female context
-        me = male_no_ctx.get(e.msgid) or male_any_ctx.get(e.msgid)
-        if me:
-            entries[me.msgid] = e
-        else:
+        if e.occurrences:
+            for occurrence in e.occurrences:
+                entries[occurrence] = e
+            continue
+
+        matches = male_occurrences.get(e.msgid, [])
+        if len(matches) == 1:
+            entries[matches[0]] = e
+        elif len(matches) == 0:
             logger.warning(f"couldn't find a corresponding male counterpart for a female entry: {e}")
+        else:
+            logger.warning(f"ambiguous female entry without occurrences, skipping auto-match: {e.msgid}")
     return entries
 
 

msg2po/unpoify.py

@@ -5,6 +5,7 @@
 import argparse
 import concurrent.futures
 import os
+import shutil
 import sys
 
 from loguru import logger
@@ -20,6 +21,17 @@
 from msg2po.log import cli_entry, setup_logging
 
 
+def clean_generated_female_dirs(dst_dir: str) -> None:
+    """Remove generated *_female directories before regenerating translated files."""
+    if not os.path.isdir(dst_dir):
+        return
+
+    female_suffix = CONFIG.female_dir_suffix
+    for entry in os.scandir(dst_dir):
+        if entry.is_dir() and entry.name.endswith(female_suffix):
+            shutil.rmtree(entry.path)
+
+
 def extract_po(pf: str, language_map: LanguageMap, base_dir: str):
     """
     pf is po file basename
@@ -34,6 +46,7 @@ def extract_po(pf: str, language_map: LanguageMap, base_dir: str):
 
     dst_dir = language_map.po2slug[pf]
     abs_dst_dir = os.path.join(base_dir, dst_dir)
+    clean_generated_female_dirs(abs_dst_dir)
 
     for ef in sorted(ipo.trans_map):
         enc = get_enc(abs_po_path, ef)

tests/test_conversion.py

@@ -168,6 +168,25 @@ def test_removes_stale_dialog_female_file_when_falling_back_to_male(self, tmp_pa
         assert output.exists()
         assert not stale_female.exists()
 
+    def test_skips_ambiguous_occurrence_less_female_entry(self, tmp_path, monkeypatch):
+        po = polib.POFile()
+        po.append(polib.POEntry(msgid="Shared", msgstr="Male A", occurrences=[("dialog/a.msg", "100")]))
+        po.append(polib.POEntry(msgid="Shared", msgstr="Male B", occurrences=[("dialog/b.msg", "200")]))
+        po.append(polib.POEntry(msgid="Shared", msgstr="Female shared", msgctxt=CONTEXT_FEMALE))
+
+        config = replace(CONFIG, extract_format="sfall")
+        monkeypatch.setattr("msg2po.conversion.CONFIG", config)
+        monkeypatch.setattr("msg2po.po_utils.CONFIG", config)
+
+        dst_dir = tmp_path / "lang"
+        output = dst_dir / "dialog" / "b.msg"
+
+        po2file(po, str(output), "utf-8", "dialog/b.msg", dst_dir=str(dst_dir))
+
+        female_output = dst_dir / "dialog_female" / "b.msg"
+        assert output.read_text(encoding="utf-8") == "{200}{}{Male B}\n"
+        assert not female_output.exists()
+
 
 class TestFile2Msgstr:
     def test_loads_translations(self, msg_file, msg_translated_file):
@@ -216,8 +235,39 @@ def test_tra_female_entries(self, tra_file, tra_translated_file):
             encoding="utf-8",
         )
         fe_map = female_entries(po)
-        assert "Male greeting" in fe_map
-        assert fe_map["Male greeting"].msgstr == "Salutation feminine"
+        assert (tra_file, "103") in fe_map
+        assert fe_map[(tra_file, "103")].msgstr == "Salutation feminine"
+
+    def test_new_female_entry_keeps_occurrence_scope(self, tmp_path, monkeypatch):
+        source = tmp_path / "dialog" / "scope.msg"
+        source.parent.mkdir(parents=True)
+        source.write_text("{100}{}{Shared}\n", encoding="utf-8")
+
+        translated = tmp_path / "lang" / "dialog" / "scope.msg"
+        translated.parent.mkdir(parents=True)
+        translated.write_text("{100}{}{Male}\n", encoding="utf-8")
+
+        translated_female = tmp_path / "lang" / "dialog_female" / "scope.msg"
+        translated_female.parent.mkdir(parents=True)
+        translated_female.write_text("{100}{}{Female}\n", encoding="utf-8")
+
+        config = replace(CONFIG, extract_format="sfall")
+        monkeypatch.setattr("msg2po.transfile.CONFIG", config)
+        monkeypatch.setattr("msg2po.conversion.CONFIG", config)
+        monkeypatch.setattr("msg2po.po_utils.CONFIG", config)
+
+        po = file2po(str(source), encoding="utf-8", occurrence_path="dialog/scope.msg")
+        file2msgstr(
+            input_file=str(translated),
+            po=po,
+            occurrence_path="dialog/scope.msg",
+            encoding="utf-8",
+            same=True,
+        )
+
+        female = next(e for e in po if e.msgctxt == CONTEXT_FEMALE)
+        assert female.msgstr == "Female"
+        assert female.occurrences == [("dialog/scope.msg", "100")]
 
 
 class TestSortPo:
@@ -292,8 +342,8 @@ def test_finds_female_entries(self):
         po.append(male)
         po.append(female)
         fe_map = female_entries(po)
-        assert "Hello" in fe_map
-        assert fe_map["Hello"].msgstr == "Bonjour F"
+        assert ("f.tra", "1") in fe_map
+        assert fe_map[("f.tra", "1")].msgstr == "Bonjour F"
 
     def test_empty_when_no_female(self, msg_file):
         po = file2po(msg_file, encoding="utf-8")

tests/test_indexed_po.py

@@ -22,11 +22,11 @@ def test_from_po_builds_trans_map(self):
         assert "dialog/1.msg" in ipo.trans_map
         assert len(ipo.trans_map["dialog/1.msg"]) == 1
 
-    def test_from_po_builds_female_map(self):
-        po = self._make_po()
-        ipo = IndexedPO.from_po(po)
-        assert "Hello" in ipo.female_map
-        assert ipo.female_map["Hello"].msgstr == "Bonjour F"
+    def test_from_po_builds_female_map(self):
+        po = self._make_po()
+        ipo = IndexedPO.from_po(po)
+        assert ("dialog/1.msg", "100") in ipo.female_map
+        assert ipo.female_map[("dialog/1.msg", "100")].msgstr == "Bonjour F"
 
     def test_from_po_builds_occ_dict(self):
         po = self._make_po()