folio-migration-tools 1.9.2__tar.gz → 1.9.3__tar.gz

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: folio_migration_tools
-Version: 1.9.2
+Version: 1.9.3
 Summary: A tool allowing you to migrate data from legacy ILS:s (Library systems) into FOLIO LSP
 License: MIT
 Keywords: FOLIO,ILS,LSP,Library Systems,MARC21,Library data

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "folio_migration_tools"
-version = "1.9.2"
+version = "1.9.3"
 description =  "A tool allowing you to migrate data from legacy ILS:s (Library systems) into FOLIO LSP"
 authors = [
 	{name = "Theodor Tolstoy", email = "github.teddes@tolstoy.se"},

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/src/folio_migration_tools/mapping_file_transformation/user_mapper.py

@@ -59,8 +59,8 @@ class UserMapper(MappingFileMapperBase):
                 True,
             )
             self.notes_mapper.migration_report = self.migration_report
-            self.setup_departments_mapping(departments_mapping)
-            self.setup_groups_mapping(groups_map)
+            self.departments_mapping = self.setup_departments_mapping(departments_mapping)
+            self.groups_mapping = self.setup_groups_mapping(groups_map)
 
             for m in self.record_map["data"]:
                 if m["folio_field"].startswith("customFields"):
@@ -120,7 +120,8 @@ class UserMapper(MappingFileMapperBase):
 
         return clean_folio_object
 
-    def get_users(self, source_file, file_format: str):
+    @staticmethod
+    def get_users(source_file, file_format: str):
         csv.register_dialect("tsv", delimiter="\t")
         if file_format == "tsv":
             reader = csv.DictReader(source_file, dialect="tsv")
@@ -156,12 +157,25 @@ class UserMapper(MappingFileMapperBase):
                     "No Departments mapping set up. Set up a departments mapping file "
                     " or remove the mapping of the Departments field",
                 )
-            return self.get_mapped_name(
-                self.departments_mapping,
-                legacy_user,
-                index_or_id,
-                True,
-            )
+            if len(self.departments_mapping.mapped_legacy_keys) == 1 and self.library_configuration.multi_field_delimiter in legacy_user.get(self.departments_mapping.mapped_legacy_keys[0], ""):
+                split_departments = legacy_user.get(self.departments_mapping.mapped_legacy_keys[0], "").split(
+                    self.library_configuration.multi_field_delimiter
+                )
+                return self.library_configuration.multi_field_delimiter.join([
+                    self.get_mapped_name(
+                        self.departments_mapping,
+                        {self.departments_mapping.mapped_legacy_keys[0]: dept},
+                        index_or_id,
+                        True,
+                    ) for dept in split_departments
+                ])
+            else:
+                return self.get_mapped_name(
+                    self.departments_mapping,
+                    legacy_user,
+                    index_or_id,
+                    True,
+                )
         elif folio_prop_name in ["expirationDate", "enrollmentDate", "personal.dateOfBirth"]:
             return self.get_parsed_date(mapped_value, folio_prop_name)
         return mapped_value
@@ -184,27 +198,21 @@ class UserMapper(MappingFileMapperBase):
             return ""
 
     def setup_groups_mapping(self, groups_map):
-        if groups_map:
-            self.groups_mapping = RefDataMapping(
-                self.folio_client,
-                "/groups",
-                "usergroups",
-                groups_map,
-                "group",
-                "UserGroupMapping",
-            )
-        else:
-            self.groups_mapping = None
+        return RefDataMapping(
+            self.folio_client,
+            "/groups",
+            "usergroups",
+            groups_map,
+            "group",
+            "UserGroupMapping",
+        ) if groups_map else None
 
     def setup_departments_mapping(self, departments_mapping):
-        if departments_mapping:
-            self.departments_mapping = RefDataMapping(
-                self.folio_client,
-                "/departments",
-                "departments",
-                departments_mapping,
-                "name",
-                "DepartmentsMapping",
-            )
-        else:
-            self.departments_mapping = None
+        return RefDataMapping(
+            self.folio_client,
+            "/departments",
+            "departments",
+            departments_mapping,
+            "name",
+            "DepartmentsMapping",
+        ) if departments_mapping else None

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/src/folio_migration_tools/marc_rules_transformation/conditions.py

@@ -90,6 +90,7 @@ class Conditions:
         logging.info("%s\tholding_note_types", len(self.folio.holding_note_types)) # type: ignore
         logging.info("%s\tcall_number_types", len(self.folio.call_number_types)) # type: ignore
         self.setup_and_validate_holdings_types()
+        self.ill_policies = self.folio.folio_get_all("/ill-policies", "illPolicies")
         # Raise for empty settings
         if not self.folio.holding_note_types:
             raise TransformationProcessError("", "No holding_note_types in FOLIO")
@@ -466,36 +467,6 @@ class Conditions:
     def condition_char_select(self, legacy_id, value, parameter, marc_field: field.Field):
         return value[parameter["from"] : parameter["to"]]
 
-    def condition_set_receipt_status(self, legacy_id, value, parameter, marc_field: field.Field):
-        if len(value) < 7:
-            self.mapper.migration_report.add(
-                "ReceiptStatusMapping", i18n.t("008 is too short") + f": {value}"
-            )
-            return ""
-        try:
-            status_map = {
-                "0": "Unknown",
-                "1": "Other receipt or acquisition status",
-                "2": "Received and complete or ceased",
-                "3": "On order",
-                "4": "Currently received",
-                "5": "Not currently received",
-                "6": "External access",
-            }
-            mapped_value = status_map[value[6]]
-            self.mapper.migration_report.add(
-                "ReceiptStatusMapping",
-                i18n.t(
-                    "%{value} mapped to %{mapped_value}", value=value[6], mapped_value=mapped_value
-                ),
-            )
-
-            return
-        except Exception:
-            self.mapper.migration_report.add(
-                "ReceiptStatusMapping", i18n.t("%{value} not found in map.", value=value)
-            )
-            return "Unknown"
 
     def condition_set_identifier_type_id_by_name(
         self, legacy_id, value, parameter, marc_field: field.Field
@@ -915,3 +886,241 @@ class Conditions:
                 legacy_id,
                 f"Subject source not found for {value} {marc_field}",
             )
+
+    def condition_set_receipt_status(
+        self, legacy_id, value, parameter, marc_field: field.Field
+    ):
+        """
+        This method maps the receipt status based on the 008 field.
+        This condition is not available in FOLIO's MARC mapping engine and 
+        will require use of a supplemental mapping rules file in the
+        HoldingsMarcTransformer task definition.
+        """
+        if len(value) < 7:
+            self.mapper.migration_report.add(
+                "ReceiptStatusMapping", i18n.t("008 is too short") + f": {value}"
+            )
+            return ""
+        
+        status_map = {
+            "0": "Unknown",
+            "1": "Other receipt or acquisition status",
+            "2": "Received and complete or ceased",
+            "3": "On order",
+            "4": "Currently received",
+            "5": "Not currently received",
+            "6": "External access",
+        }
+
+        try:
+            mapped_value = status_map[value[6]]
+            self.mapper.migration_report.add(
+                "ReceiptStatusMapping",
+                i18n.t(
+                    "%{value} mapped to %{mapped_value}",
+                    value=value[6],
+                    mapped_value=mapped_value,
+                ),
+            )
+            return mapped_value
+        except Exception:
+            self.mapper.migration_report.add(
+                "ReceiptStatusMapping", i18n.t("%{value} not found in map.", value=value[6])
+            )
+            return ""
+
+    def condition_set_acquisition_method(
+        self, legacy_id, value, parameter, marc_field: field.Field
+    ):
+        """
+        This method maps the acquisition method based on the 008 field.
+        This condition is not available in FOLIO's MARC mapping engine and 
+        will require use of a supplemental mapping rules file in the
+        HoldingsMarcTransformer task definition.
+        """
+        if len(value) < 8:
+            self.mapper.migration_report.add(
+                "ReceiptStatusMapping", i18n.t("008 is too short") + f": {value}"
+            )
+            return ""
+
+        try:
+            acq_methods = {
+                "c": "Cooperative or consortial purchase",
+                "d": "Deposit",
+                "e": "Exchange",
+                "f": "Free",
+                "g": "Gift",
+                "l": "Legal deposit",
+                "m": "Membership",
+                "n": "Non-library purchase",
+                "p": "Purchase",
+                "q": "Lease",
+                "u": "Unknown",
+                "z": "Other method of acquisition",
+            }
+            mapped_value = acq_methods[value[7]]
+            self.mapper.migration_report.add(
+                "MethodOfAcquisitionMapping",
+                i18n.t(
+                    "%{value} mapped to %{mapped_value}", value=value[7], mapped_value=mapped_value
+                ),
+            )
+            return mapped_value
+        except Exception:
+            self.mapper.migration_report.add(
+                "MethodOfAcquisitionMapping", i18n.t("%{value} not found in map.", value=value[8])
+            )
+            return ""
+
+    def condition_set_retention_policy(
+        self, legacy_id, value, parameter, marc_field: field.Field
+    ):
+        """
+        This method maps the retention policy based on the 008 field.
+        This condition is not available in FOLIO's MARC mapping engine and
+        will require use of a supplemental mapping rules file in the
+        HoldingsMarcTransformer task definition.
+        """
+        if len(value) < 13:
+            self.mapper.migration_report.add(
+                "RetentionPolicyMapping", i18n.t("008 is too short") + f": {value}"
+            )
+            return ""
+        value = value.replace("|", " ").replace("#", " ") # Replace pipe with space for mapping consistency
+        try:
+            retention_policies = {
+                "0": "Unknown",
+                "1": "Other general retention policy",
+                "2": "Retained except as replaced by updates",
+                "3": "Sample issue retained",
+                "4": "Retained until replaced by microform",
+                "5": "Retained until replaced by cumulation, replacement volume, or revision",
+                "6": "Retained for a limited period",
+                "7": "Not retained",
+                "8": "Permanently retained",
+            }
+            mapped_value = retention_policies[value[12]]
+            self.mapper.migration_report.add(
+                "RetentionPolicyMapping",
+                i18n.t(
+                    "%{value} mapped to %{mapped_value}",
+                    value=value[12],
+                    mapped_value=mapped_value,
+                ),
+            )
+            if value[12] == "6":
+                policy_types = {
+                    "l": "Latest",
+                    "p": "Previous",
+                }
+                unit_types = {
+                    "m": "Day",
+                    "w": "Month",
+                    "y": "Year",
+                    "e": "Edition",
+                    "i": "Issue",
+                    "s": "Supplement"
+                }
+                try:
+                    specific_retention_policy = ""
+                    if value[13].strip() or value[15].strip():
+                        if value[14].strip() and int(value[14]) > 1:
+                            specific_retention_policy = f"{policy_types.get(value[13], '')} {value[14]} {unit_types.get(value[15], '')}s retained".strip()
+                        else:
+                            specific_retention_policy = f"{policy_types.get(value[13], '')} {unit_types.get(value[15], '')} retained".strip()
+                    if specific_retention_policy:
+                        self.mapper.migration_report.add(
+                            "RetentionPolicyMapping",
+                            i18n.t(
+                                "Retention policy 6 indicates a limited period. Specific retention period will be mapped from 008/13-15",
+                            )
+                        )
+                        return specific_retention_policy
+                    else:
+                        raise ValueError(
+                            "Specific retention policy is empty or invalid in 008/13-15"
+                        )
+                except ValueError:
+                    self.mapper.migration_report.add(
+                        "RetentionPolicyMapping",
+                        i18n.t("Invalid specific retention policy in 008/13-15: %{value}", value=value[13:16]),
+                    )
+            return mapped_value
+        except Exception:
+            self.mapper.migration_report.add(
+                "RetentionPolicyMapping", i18n.t("%{value} not found in map.", value=value[12])
+            )
+            return ""
+
+    def condition_set_ill_policy(
+        self, legacy_id, value, parameter, marc_field: field.Field
+    ):
+        """
+        This method maps the ILL policy based on the 008 field.
+        This condition is not available in FOLIO's MARC mapping engine and
+        will require use of a supplemental mapping rules file in the
+        HoldingsMarcTransformer task definition."""
+        if len(value) < 21:
+            self.mapper.migration_report.add(
+                "ILLPolicyMapping", i18n.t("008 is too short") + f": {value}"
+            )
+            return ""
+        try:
+            ill_policies = {
+                "a": "Will lend",
+                "b": "Will not lend",
+                "c": "Will lend hard copy only",
+                "l": "Limited lending policy",
+                "u": "Unknown",
+            }
+            mapped_value = ill_policies[value[20]]
+            self.mapper.migration_report.add(
+                "ILLPolicyMapping",
+                i18n.t("%{value} mapped to %{mapped_value}", value=value[20], mapped_value=mapped_value),
+            )
+            ill_policy_id = self.get_ref_data_tuple_by_name(
+                self.ill_policies, "ill_policies", mapped_value
+            )
+            return ill_policy_id[0] if ill_policy_id else ""
+        except Exception:
+            self.mapper.migration_report.add(
+                "ILLPolicyMapping", i18n.t("%{value} not found in map.", value=value[20])
+            )
+            return ""
+
+    def condition_set_digitization_policy(
+        self, legacy_id, value, parameter, marc_field: field.Field
+    ):
+        """
+        This method maps the digitization policy based on the 008 field.
+        This condition is not available in FOLIO's MARC mapping engine and
+        will require use of a supplemental mapping rules file in the
+        HoldingsMarcTransformer task definition.
+        """
+        if len(value) < 22:
+            self.mapper.migration_report.add(
+                "DigitizationPolicyMapping", i18n.t("008 is too short") + f": {value}"
+            )
+            return ""
+        try:
+            digitization_policies = {
+                "a": "Will reproduce",
+                "b": "Will not reproduce",
+                "u": "Unknown",
+            }
+            mapped_value = digitization_policies[value[21]]
+            self.mapper.migration_report.add(
+                "DigitizationPolicyMapping",
+                i18n.t(
+                    "%{value} mapped to %{mapped_value}",
+                    value=value[21],
+                    mapped_value=mapped_value,
+                ),
+            )
+            return mapped_value
+        except Exception:
+            self.mapper.migration_report.add(
+                "DigitizationPolicyMapping", i18n.t("%{value} not found in map.", value=value[21])
+            )
+            return ""

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/src/folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py

@@ -23,18 +23,18 @@ class HoldingsStatementsParser:
         """_summary_
 
         Args:
-            marc_record (Record): _description_
-            pattern_tag (str): _description_
-            value_tag (str): _description_
-            field_textual (str): _description_
-            legacy_ids (List[str]): _description_
-            dedupe_results (bool): _description_. Defaults to True.
+            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: _description_
+            TransformationFieldMappingError: If there is an error in mapping the holdings statements.
 
         Returns:
-            dict: _description_
+            dict: A dictionary containing parsed holdings statements and related information.
         """
 
         # Textual holdings statements
@@ -45,21 +45,9 @@ class HoldingsStatementsParser:
 
         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_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"]
-            ]
+            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(
@@ -75,7 +63,7 @@ class HoldingsStatementsParser:
                         parsed_dict = HoldingsStatementsParser.parse_linked_field(
                             pattern_field, linked_value_field
                         )
-                    except KeyError:
+                    except KeyError as e:
                         raise TransformationFieldMappingError(
                             legacy_ids,
                             i18n.t(
@@ -84,24 +72,10 @@ class HoldingsStatementsParser:
                                 linked_value_tag=linked_value_field,
                             ),
                             pattern_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{'-'.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"])
+                        ) from e
+                    HoldingsStatementsParser.prepare_return_dict(
+                        pattern_tag, legacy_ids, return_dict, pattern_field, linked_value_field, parsed_dict
+                    )
 
         if dedupe_results:
             return_dict["statements"] = HoldingsStatementsParser.dedupe_list_of_dict(
@@ -109,6 +83,47 @@ class HoldingsStatementsParser:
             )
         return return_dict
 
+    @staticmethod
+    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)
@@ -123,6 +138,20 @@ class HoldingsStatementsParser:
             "hlm_stmt": hlm_stmt,
         }
 
+        _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:
@@ -137,16 +166,7 @@ class HoldingsStatementsParser:
             _to = f"({cron_to})"
         if _from and _from == cron_from:
             _from = f"({cron_from})"
-        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
+        return _from, _to
 
     @staticmethod
     def get_textual_statements(
@@ -276,12 +296,9 @@ class HoldingsStatementsParser:
                     elif cron_to.strip() and val:
                         val_rest = val
                     if year:
-                        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)}"
+                        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:
@@ -292,6 +309,16 @@ class HoldingsStatementsParser:
                     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 = ""
@@ -300,11 +327,18 @@ class HoldingsStatementsParser:
         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 ""
-            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}"
+            _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, _to, is_span

{folio_migration_tools-1.9.2 → folio_migration_tools-1.9.3}/src/folio_migration_tools/marc_rules_transformation/marc_file_processor.py

@@ -65,7 +65,12 @@ class MarcFileProcessor:
         self.records_count += 1
         try:
             # Transform the MARC21 to a FOLIO record
-            legacy_ids = self.mapper.get_legacy_ids(marc_record, idx)
+            try:
+                legacy_ids = self.mapper.get_legacy_ids(marc_record, idx)
+            except ValueError as e:
+                raise TransformationRecordFailedError(
+                    f"{idx} in {file_def.file_name}", str(e), idx
+                ) from e
             if not legacy_ids:
                 raise TransformationRecordFailedError(
                     f"Index in file: {idx}", "No legacy id found", idx