folio-migration-tools 1.2.1__py3-none-any.whl → 1.9.10__py3-none-any.whl

folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py

@@ -1,48 +1,53 @@
 import calendar
+import contextlib
 import logging
 import re
+from typing import List
 
-from folio_migration_tools.custom_exceptions import TransformationFieldMappingError
+import i18n
 from pymarc import Field, Record
 
+from folio_migration_tools.custom_exceptions import TransformationFieldMappingError
 
-class HoldingsStatementsParser:
-    @staticmethod
-    def get_textual_statements(marc_record, field_textual, return_dict):
-        for f in marc_record.get_fields(field_textual):
-            return_dict["statements"].append(
-                {"statement": (f["a"] or ""), "note": (f["z"] or ""), "staffNote": ""}
-            )
-            return_dict["migration_report"].append(
-                ("Holdings statements", f"From {field_textual}")
-            )
 
+class HoldingsStatementsParser:
     @staticmethod
     def get_holdings_statements(
-        marc_record: Record, pattern_tag, value_tag, field_textual, legacy_id: str
-    ):
+        marc_record: Record,
+        pattern_tag: str,
+        value_tag: str,
+        field_textual: str,
+        legacy_ids: List[str],
+        dedupe_results: bool = True,
+    ) -> dict:
+        """_summary_
+
+        Args:
+            marc_record (Record): pymarc Record object
+            pattern_tag (str): MARC tag for the pattern field
+            value_tag (str): MARC tag for the value field
+            field_textual (str): MARC tag for the textual holdings field
+            legacy_ids (List[str]): List of legacy IDs associated with the record
+            dedupe_results (bool): Whether to deduplicate the results. Defaults to True.
+
+        Raises:
+            TransformationFieldMappingError: If there is an error in mapping the holdings statements.
+
+        Returns:
+            dict: A dictionary containing parsed holdings statements and related information.
+        """
+
         # Textual holdings statements
-        return_dict = {"statements": [], "migration_report": [], "hlm_stmts": []}
+        return_dict: dict = {"statements": [], "migration_report": [], "hlm_stmts": []}
         HoldingsStatementsParser.get_textual_statements(
-            marc_record,
-            field_textual,
-            return_dict,
+            marc_record, field_textual, return_dict, legacy_ids
         )
 
         value_fields = marc_record.get_fields(value_tag)
         for pattern_field in marc_record.get_fields(pattern_tag):
-            if "8" not in pattern_field:
-                raise TransformationFieldMappingError(
-                    legacy_id,
-                    f"{pattern_tag} subfield 8 not in field",
-                    pattern_field.format_field(),
-                )
-            linked_value_fields = [
-                value_field
-                for value_field in value_fields
-                if "8" in value_field
-                and value_field["8"].split(".")[0] == pattern_field["8"]
-            ]
+            linked_value_fields = HoldingsStatementsParser.get_linked_value_fields(
+                pattern_tag, legacy_ids, value_fields, pattern_field
+            )
 
             if not any(linked_value_fields):
                 return_dict["migration_report"].append(
@@ -53,130 +58,287 @@ class HoldingsStatementsParser:
                 )
 
             else:
-
                 for linked_value_field in linked_value_fields:
-                    parsed_dict = HoldingsStatementsParser.parse_linked_field(
-                        pattern_field, linked_value_field
-                    )
-                    if parsed_dict["hlm_stmt"]:
-                        return_dict["hlm_stmts"].append(parsed_dict["hlm_stmt"])
-                    if parsed_dict["statement"]:
-                        logging.info(
-                            f"HOLDINGS STATEMENT PATTERN\t{legacy_id}\t{pattern_field}"
-                            f"\t{linked_value_field}"
-                            f"\t{parsed_dict['statement']['statement']}"
-                            f"\t{parsed_dict['statement']['note']}"
-                            f"\t{parsed_dict['statement']['staffNote']}"
-                        )
-                        return_dict["migration_report"].append(
-                            (
-                                "Holdings statements",
-                                f"From {pattern_tag}",
-                            )
+                    try:
+                        parsed_dict = HoldingsStatementsParser.parse_linked_field(
+                            pattern_field, linked_value_field
                         )
-                        return_dict["statements"].append(parsed_dict["statement"])
+                    except KeyError as e:
+                        raise TransformationFieldMappingError(
+                            legacy_ids,
+                            i18n.t(
+                                "subfield present in %{linked_value_tag} but not in %{pattern_field}",
+                                pattern_field=pattern_field,
+                                linked_value_tag=linked_value_field,
+                            ),
+                            pattern_field,
+                        ) from e
+                    HoldingsStatementsParser.prepare_return_dict(
+                        pattern_tag, legacy_ids, return_dict, pattern_field, linked_value_field, parsed_dict
+                    )
 
-        return_dict["statements"] = dedupe_list_of_dict(return_dict["statements"])
+        if dedupe_results:
+            return_dict["statements"] = HoldingsStatementsParser.dedupe_list_of_dict(
+                return_dict["statements"]
+            )
         return return_dict
 
     @staticmethod
-    def parse_linked_field(pattern_field: Field, linked_value_field: Field):
+    def prepare_return_dict(
+        pattern_tag, legacy_ids, return_dict, pattern_field, linked_value_field, parsed_dict
+    ):
+        if parsed_dict["hlm_stmt"]:
+            return_dict["hlm_stmts"].append(parsed_dict["hlm_stmt"])
+        if parsed_dict["statement"]:
+            logging.info(
+                f"HOLDINGS STATEMENT PATTERN\t{'-'.join(legacy_ids)}\t{pattern_field}"
+                f"\t{linked_value_field}"
+                f"\t{parsed_dict['statement']['statement']}"
+                f"\t{parsed_dict['statement']['note']}"
+                f"\t{parsed_dict['statement']['staffNote']}"
+            )
+            return_dict["migration_report"].append(
+                (
+                    "Holdings statements",
+                    f"From {pattern_tag}",
+                )
+            )
+            return_dict["statements"].append(parsed_dict["statement"])
+
+    @staticmethod
+    def get_linked_value_fields(pattern_tag, legacy_ids, value_fields, pattern_field):
+        if "8" not in pattern_field:
+            raise TransformationFieldMappingError(
+                legacy_ids,
+                i18n.t(
+                    "%{tag} subfield %{subfield} not in field",
+                    tag=pattern_tag,
+                    subfield="8",
+                ),
+                pattern_field,
+            )
+        linked_value_fields = [
+            value_field
+            for value_field in value_fields
+            if "8" in value_field and value_field["8"].split(".")[0] == pattern_field["8"]
+        ]
+        return linked_value_fields
+
+    @staticmethod
+    def parse_linked_field(pattern_field: Field, linked_value_fields: Field):
+        break_ind = HoldingsStatementsParser.get_break_indicator(linked_value_fields)
+        _from, _to, is_span = HoldingsStatementsParser.get_from_to(
+            pattern_field, linked_value_fields
+        )
+        cron_from, cron_to, hlm_stmt, is_cron_span = HoldingsStatementsParser.get_cron_from_to(
+            pattern_field, linked_value_fields
+        )
         return_dict = {
-            "hlm_stmt": "",
-            "statement": {
-                "statement": "",
-                "note": "",
-                "staffNote": "",
-            },
+            "statement": {"statement": "", "note": "", "staffNote": ""},
+            "hlm_stmt": hlm_stmt,
         }
-        _from, _to = get_from_to(pattern_field, linked_value_field)
-        cron_from, cron_to, hlm_stmt = get_cron_from_to(
-            pattern_field, linked_value_field
-        )
-        return_dict["hlm_stmt"] = hlm_stmt
-        if cron_from:
+
+        _from, _to = HoldingsStatementsParser.format_from_to(_from, _to, cron_from, cron_to)
+        span = "-" if is_span or is_cron_span else ""
+        stmt = f"{_from}{span}{_to}{break_ind}" if _from else ""
+        stmt = stmt.strip()
+        if "z" in linked_value_fields:
+            return_dict["statement"]["note"] = linked_value_fields["z"]
+        if "x" in linked_value_fields:
+            return_dict["statement"]["staffNote"] = linked_value_fields["x"]
+        stmt = re.sub(" +", " ", stmt)
+        return_dict["statement"]["statement"] = stmt
+        return return_dict
+
+    @staticmethod
+    def format_from_to(_from, _to, cron_from, cron_to):
+        if _from and cron_from:
             _from = f"{_from} ({cron_from})"
+        if not _from and cron_from:
+            _from = cron_from
         if _to and cron_to:
             _to = f"{_to} ({cron_to})"
         if _to and cron_from and not cron_to:
             _to = f"{_to} ({cron_from})"
-        stmt = f"{_from}-{_to}" if _from else ""
-        stmt = stmt.strip("-")
-        if "z" in linked_value_field:
-            return_dict["statement"]["note"] = linked_value_field["z"]
-        if "x" in linked_value_field:
-            return_dict["statement"]["staffNote"] = linked_value_field["x"]
-        stmt = re.sub(" +", " ", stmt)
-        return_dict["statement"]["statement"] = stmt
-        return return_dict
+        if not _to and cron_to:
+            _to = cron_to
+        if _to == cron_to and _to:
+            _to = f"({cron_to})"
+        if _from and _from == cron_from:
+            _from = f"({cron_from})"
+        return _from, _to
+
+    @staticmethod
+    def get_textual_statements(
+        marc_record: Record, field_textual: str, return_dict: dict, legacy_ids: List[str]
+    ):
+        """Returns the textual statements from the relevant marc fields
+
+        Args:
+            marc_record (Record): _description_
+            field_textual (str): _description_
+            return_dict (dict): _description_
+            legacy_ids (List[str]): List of legacy ids in record
+
+        Raises:
+            TransformationFieldMappingError: _description_
+            TransformationFieldMappingError: _description_
+        """
+        for f in marc_record.get_fields(field_textual):
+            if all(
+                [
+                    len("".join(f.get_subfields("a")).strip()) == 0,
+                    len("".join(f.get_subfields("z")).strip()) == 0,
+                    len("".join(f.get_subfields("x")).strip()) == 0,
+                ]
+            ):
+                raise TransformationFieldMappingError(
+                    legacy_ids,
+                    i18n.t("%{field} a, x and z are missing or empty", field=field_textual),
+                    f,
+                )
+            return_dict["statements"].append(
+                {
+                    "statement": "".join(f.get_subfields("a")),
+                    "note": "".join(f.get_subfields("z")),
+                    "staffNote": "".join(f.get_subfields("x")),
+                }
+            )
+            return_dict["migration_report"].append(
+                ("Holdings statements", f"From {field_textual}")
+            )
 
+    @staticmethod
+    def get_break_indicator(field: Field):
+        if "w" not in field or field["w"] not in ["g", "n"]:
+            return ""
+        elif field["w"] == "g":
+            return ","
+        elif field["w"] == "n":
+            return ";"
+        else:
+            return ""
 
-def get_season(val):
-    try:
-        val = int(val)
-        if val == 21:
+    @staticmethod
+    def g_s(val: str):
+        val_int = int(val)
+        if val_int == 21:
             return "Spring"
-        elif val == 22:
+        elif val_int == 22:
             return "Summer"
-        elif val == 23:
+        elif val_int == 23:
             return "Fall"
-        elif val == 24:
+        elif val_int == 24:
             return "Winter"
         else:
             return val
-    except Exception:
-        return val
-
-
-def dedupe_list_of_dict(list_of_dict):
-    return [dict(t) for t in {tuple(d.items()) for d in list_of_dict}]
-
-
-def get_cron_from_to(pattern_field: Field, linked_value_field: Field):
-    cron_from = ""
-    cron_to = ""
-    hlm_stmt = ""
-    year = False
-
-    for chron_level in [cl for cl in "ijkl" if cl in linked_value_field]:
-        desc = pattern_field[chron_level] or ""
-        if linked_value_field[chron_level]:
-            if chron_level == "i" and desc == "(year)":
-                hlm_stmt = linked_value_field[chron_level]
-            if desc == "(year)":
-                year = True
-            val, *val_rest = linked_value_field[chron_level].split("-")
-            if desc == "(month)":
-                try:
-                    val = f"{calendar.month_abbr[int(val)]}."
-                except Exception:
-                    pass
-                if "".join(val_rest):
-                    try:
-                        val_rest = calendar.month_abbr[int("".join(val_rest))]
-                    except Exception:
-                        pass
-                if year:
-                    cron_from = f"{cron_from.strip()}:{val} "
-                    cron_to = f"{cron_to}:{''.join(val_rest)} "
-            else:
-                if "season" in desc:
-                    val = get_season(val)
-                cron_from = f"{cron_from} {val} "
-                cron_to = f"{cron_to} {''.join(val_rest)}"
-    return (cron_from.strip(), cron_to.strip(), hlm_stmt)
-
-
-def get_from_to(pattern_field: Field, linked_value_field: Field):
-    _from = ""
-    _to = ""
-    for enum_level in [el for el in "abcdef" if el in linked_value_field]:
-        desc = pattern_field[enum_level] or ""
-        desc = desc if "(" not in desc else ""
-        if linked_value_field[enum_level]:
+
+    @staticmethod
+    def get_season(val: str):
+        try:
+            result = HoldingsStatementsParser.g_s(val)
+            if result == val:
+                result = HoldingsStatementsParser.g_m(int(val))
+            return result
+        except Exception:
+            return val
+
+    @staticmethod
+    def dedupe_list_of_dict(list_of_dict):
+        return [dict(t) for t in {tuple(d.items()): None for d in list_of_dict}]
+
+    @staticmethod
+    def g_m(m: int):
+        if m == 5:
+            return "May"
+        elif m == 6:
+            return "June"
+        elif m == 7:
+            return "July"
+        else:
+            return f"{calendar.month_abbr[m]}."
+
+    @staticmethod
+    def get_month(month_str: str):
+        month_str = month_str.strip()
+        if "/" in month_str:
+            return "/".join([HoldingsStatementsParser.g_m(int(m)) for m in month_str.split("/")])
+        else:
+            result = HoldingsStatementsParser.g_m(int(month_str))
+            if result == month_str:
+                result = HoldingsStatementsParser.g_s(month_str)
+            return result
+
+    @staticmethod
+    def get_cron_from_to(pattern_field: Field, linked_value_field: Field):
+        cron_from = ""
+        cron_to = ""
+        hlm_stmt = ""
+        year = False
+        is_span = False
+        for chron_level in [cl for cl in "ijkl" if cl in linked_value_field]:
+            desc = pattern_field.get(chron_level, "")
+            if linked_value_field.get(chron_level):
+                if chron_level == "i" and desc == "(year)":
+                    hlm_stmt = linked_value_field[chron_level]
+                if desc == "(year)":
+                    year = True
+                val, *val_rest = linked_value_field[chron_level].split("-")
+                is_span = "-" in linked_value_field[chron_level] or is_span
+                if desc == "(month)":
+                    with contextlib.suppress(Exception):
+                        val = HoldingsStatementsParser.get_month(val)
+                    with contextlib.suppress(Exception):
+                        val_rest = HoldingsStatementsParser.get_month(val_rest[0])
+                    if "".join(val_rest):
+                        with contextlib.suppress(Exception):
+                            val_rest = HoldingsStatementsParser.get_month("".join(val_rest))
+                    elif cron_to.strip() and val:
+                        val_rest = val
+                    if year:
+                        cron_from, cron_to = HoldingsStatementsParser.format_year_cron_from_cron_to(
+                            cron_from, cron_to, hlm_stmt, val, val_rest
+                        )
+
+                else:
+                    if "season" in desc:
+                        val = HoldingsStatementsParser.get_season(val)
+                        if "".join(val_rest):
+                            val_rest = HoldingsStatementsParser.get_season("".join(val_rest))
+                    cron_from = f"{cron_from} {val}".strip()
+                    cron_to = f"{cron_to} {''.join(val_rest)}".strip()
+        return (f"{cron_from.strip()}", cron_to.strip(), hlm_stmt, is_span)
+
+    @staticmethod
+    def format_year_cron_from_cron_to(cron_from, cron_to, hlm_stmt, val, val_rest):
+        spill_year = f"{hlm_stmt}:" if "-" not in hlm_stmt else ""
+        cron_from = f"{cron_from.strip()}:{val}"
+        if cron_to and "".join(val_rest):
+            cron_to = f"{cron_to}:{''.join(val_rest)}"
+        elif not cron_to and "".join(val_rest):
+            cron_to = f"{spill_year}{''.join(val_rest)}"
+        return cron_from, cron_to
+
+    @staticmethod
+    def get_from_to(pattern_field: Field, linked_value_field: Field):
+        _from = ""
+        _to = ""
+        is_span = False
+        for enum_level in [el for el in "abcdef" if el in linked_value_field]:
+            desc = pattern_field.get(enum_level, "")
+            desc = desc.strip() if "(" not in desc else ""
+            _from, _to, is_span = HoldingsStatementsParser.format_enum_parts(
+                linked_value_field, _from, _to, is_span, enum_level, desc
+            )
+        return (f"{_from.strip()}", _to.strip(), is_span)
+
+    @staticmethod
+    def format_enum_parts(linked_value_field, _from, _to, is_span, enum_level, desc):
+        if linked_value_field.get(enum_level):
             val, *val_rest = linked_value_field[enum_level].split("-")
+            is_span = "-" in linked_value_field[enum_level] or is_span
             _from = f"{_from}{(':' if _from else '')}{desc}{val}"
             temp_to = "".join(val_rest)
             if temp_to.strip():
                 _to = f"{_to}{(':' if _to else '')}{desc}{temp_to}"
-    return (_from.strip(), _to.strip())
+        return _from, _to, is_span