folio-migration-tools 1.9.2__py3-none-any.whl → 1.9.3__py3-none-any.whl

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/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/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/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

folio_migration_tools/migration_tasks/batch_poster.py

@@ -33,9 +33,9 @@ def write_failed_batch_to_file(batch, file):
 
 
 class BatchPoster(MigrationTaskBase):
-    """Batchposter
+    """BatchPoster
 
-    Args:
+    Parents:
         MigrationTaskBase (_type_): _description_
 
     Raises:
@@ -158,7 +158,8 @@ class BatchPoster(MigrationTaskBase):
         if self.api_info["supports_upsert"]:
             self.query_params["upsert"] = self.task_configuration.upsert
         elif self.task_configuration.upsert and not self.api_info["supports_upsert"]:
-            logging.info("Upsert is not supported for this object type. Query parameter will not be set.")
+            logging.info(
+                "Upsert is not supported for this object type. Query parameter will not be set.")
         self.snapshot_id = str(uuid4())
         self.failed_objects: list = []
         self.batch_size = self.task_configuration.batch_size
@@ -174,11 +175,14 @@ class BatchPoster(MigrationTaskBase):
         self.okapi_headers = self.folio_client.okapi_headers
         self.http_client = None
         self.starting_record_count_in_folio: Optional[int] = None
+        self.finished_record_count_in_folio: Optional[int] = None
 
     def do_work(self):
         with self.folio_client.get_folio_http_client() as httpx_client:
             self.http_client = httpx_client
-            with open(self.folder_structure.failed_recs_path, "w", encoding='utf-8') as failed_recs_file:
+            with open(
+                    self.folder_structure.failed_recs_path, "w", encoding='utf-8'
+            ) as failed_recs_file:
                 self.get_starting_record_count()
                 try:
                     batch = []
@@ -249,7 +253,7 @@ class BatchPoster(MigrationTaskBase):
                             self.handle_generic_exception(
                                 exception, last_row, batch, self.processed, failed_recs_file
                             )
-                    logging.info("Done posting %s records. ", (self.processed))
+                    logging.info("Done posting %s records. ", self.processed)
                     if self.task_configuration.object_type == "SRS":
                         self.commit_snapshot()
 
@@ -276,7 +280,7 @@ class BatchPoster(MigrationTaskBase):
 
     async def set_version_async(self, batch, query_api, object_type) -> None:
         """
-        Fetches the current version of the records in the batch, if the record exists in FOLIO
+        Fetches the current version of the records in the batch if the record exists in FOLIO
 
         Args:
             batch (list): List of records to fetch versions for
@@ -297,7 +301,10 @@ class BatchPoster(MigrationTaskBase):
                         client,
                         query_api,
                         params={
-                            "query": f"id==({' OR '.join([record['id'] for record in batch_slice if 'id' in record])})",
+                            "query": (
+                                "id==("
+                                f"{' OR '.join([r['id'] for r in batch_slice if 'id' in r])})"
+                            ),
                             "limit": fetch_batch_size
                         },
                     )
@@ -332,11 +339,14 @@ class BatchPoster(MigrationTaskBase):
                         response.text,
                     )
 
-    async def get_with_retry(self, client: httpx.AsyncClient, url: str, params: dict = {}):
+    async def get_with_retry(self, client: httpx.AsyncClient, url: str, params=None):
+        if params is None:
+            params = {}
         retries = 3
         for attempt in range(retries):
             try:
-                response = await client.get(url, params=params, headers=self.folio_client.okapi_headers)
+                response = await client.get(
+                    url, params=params, headers=self.folio_client.okapi_headers)
                 response.raise_for_status()
                 return response
             except httpx.HTTPError as e:
@@ -477,8 +487,8 @@ class BatchPoster(MigrationTaskBase):
         )
         logging.info(last_row)
         logging.info("=========Stack trace==============")
-        traceback.logging.info_exc() # type: ignore
-        logging.info("=======================", flush=True)
+        traceback.logging.info_exc()  # type: ignore
+        logging.info("=======================")
 
     def post_batch(self, batch, failed_recs_file, num_records, recursion_depth=0):
         if self.query_params.get("upsert", False) and self.api_info.get("query_endpoint", ""):
@@ -514,7 +524,7 @@ class BatchPoster(MigrationTaskBase):
                 )
                 write_failed_batch_to_file(batch, failed_recs_file)
             if json_report.get("failedUsers", []):
-                logging.error("Errormessage: %s", json_report.get("error", []))
+                logging.error("Error message: %s", json_report.get("error", []))
                 for failed_user in json_report.get("failedUsers"):
                     logging.error(
                         "User failed. %s\t%s\t%s",
@@ -581,8 +591,8 @@ class BatchPoster(MigrationTaskBase):
                 resp = json.dumps(response, indent=4)
             except TypeError:
                 resp = response
-            except Exception:
-                logging.exception("something unexpected happened")
+            except Exception as e:
+                logging.exception(f"something unexpected happened, {e}")
                 resp = response
             raise TransformationRecordFailedError(
                 "",
@@ -603,17 +613,29 @@ class BatchPoster(MigrationTaskBase):
             payload = {self.api_info["object_name"]: batch}
         if self.http_client and not self.http_client.is_closed:
             return self.http_client.post(
-                url, json=payload, headers=self.folio_client.okapi_headers, params=self.query_params
+                url,
+                json=payload,
+                headers=self.folio_client.okapi_headers,
+                params=self.query_params
             )
         else:
-            return httpx.post(url, headers=self.okapi_headers, json=payload, params=self.query_params, timeout=None)
+            return httpx.post(
+                url,
+                headers=self.okapi_headers,
+                json=payload,
+                params=self.query_params,
+                timeout=None)
 
     def get_current_record_count_in_folio(self):
         if "query_endpoint" in self.api_info:
             url = f"{self.folio_client.gateway_url}{self.api_info['query_endpoint']}"
             query_params = {"query": "cql.allRecords=1", "limit": 0}
             if self.http_client and not self.http_client.is_closed:
-                res = self.http_client.get(url, headers=self.folio_client.okapi_headers, params=query_params)
+                res = self.http_client.get(
+                    url,
+                    headers=self.folio_client.okapi_headers,
+                    params=query_params
+                )
             else:
                 res = httpx.get(url, headers=self.okapi_headers, params=query_params, timeout=None)
             try:
@@ -623,11 +645,15 @@ class BatchPoster(MigrationTaskBase):
                 logging.error("Failed to get current record count. HTTP %s", res.status_code)
                 return 0
             except KeyError:
-                logging.error(f"Failed to get current record count. No 'totalRecords' in response: {res.json()}")
+                logging.error(
+                    "Failed to get current record count. "
+                    f"No 'totalRecords' in response: {res.json()}"
+                )
                 return 0
         else:
             raise ValueError(
-                "No 'query_endpoint' available for %s. Cannot get current record count.", self.task_configuration.object_type
+                "No 'query_endpoint' available for %s. Cannot get current record count.",
+                self.task_configuration.object_type
             )
 
     def get_starting_record_count(self):
@@ -635,14 +661,20 @@ class BatchPoster(MigrationTaskBase):
             logging.info("Getting starting record count in FOLIO")
             self.starting_record_count_in_folio = self.get_current_record_count_in_folio()
         else:
-            logging.info("No query_endpoint available for %s. Cannot get starting record count.", self.task_configuration.object_type)
+            logging.info(
+                "No query_endpoint available for %s. Cannot get starting record count.",
+                self.task_configuration.object_type
+            )
 
     def get_finished_record_count(self):
         if "query_endpoint" in self.api_info:
             logging.info("Getting finished record count in FOLIO")
             self.finished_record_count_in_folio = self.get_current_record_count_in_folio()
         else:
-            logging.info("No query_endpoint available for %s. Cannot get ending record count.", self.task_configuration.object_type)
+            logging.info(
+                "No query_endpoint available for %s. Cannot get ending record count.",
+                self.task_configuration.object_type
+            )
 
     def wrap_up(self):
         logging.info("Done. Wrapping up")
@@ -663,7 +695,9 @@ class BatchPoster(MigrationTaskBase):
             logging.info("Done posting %s records. %s failed", self.num_posted, self.num_failures)
         if self.starting_record_count_in_folio:
             self.get_finished_record_count()
-            total_on_server = self.finished_record_count_in_folio - self.starting_record_count_in_folio
+            total_on_server = (
+                    self.finished_record_count_in_folio - self.starting_record_count_in_folio
+            )
             discrepancy = self.processed - self.num_failures - total_on_server
             if discrepancy != 0:
                 logging.error(
@@ -712,7 +746,10 @@ class BatchPoster(MigrationTaskBase):
                 temp_report = copy.deepcopy(self.migration_report)
                 temp_start = self.start_datetime
                 self.task_configuration.rerun_failed_records = False
-                self.__init__(self.task_configuration, self.library_configuration, self.folio_client)
+                self.__init__(
+                    self.task_configuration,
+                    self.library_configuration,
+                    self.folio_client)
                 self.performing_rerun = True
                 self.migration_report = temp_report
                 self.start_datetime = temp_start
@@ -747,9 +784,11 @@ class BatchPoster(MigrationTaskBase):
                 res = httpx.post(url, headers=self.okapi_headers, json=snapshot, timeout=None)
             res.raise_for_status()
             logging.info("Posted Snapshot to FOLIO: %s", json.dumps(snapshot, indent=4))
-            get_url = f"{self.folio_client.gateway_url}/source-storage/snapshots/{self.snapshot_id}"
-            getted = False
-            while not getted:
+            get_url = (
+                f"{self.folio_client.gateway_url}/source-storage/snapshots/{self.snapshot_id}"
+            )
+            got = False
+            while not got:
                 logging.info("Sleeping while waiting for the snapshot to get created")
                 time.sleep(5)
                 if self.http_client and not self.http_client.is_closed:
@@ -757,11 +796,14 @@ class BatchPoster(MigrationTaskBase):
                 else:
                     res = httpx.get(get_url, headers=self.okapi_headers, timeout=None)
                 if res.status_code == 200:
-                    getted = True
+                    got = True
                 else:
                     logging.info(res.status_code)
-        except Exception:
-            logging.exception("Could not post the snapshot")
+        except httpx.HTTPStatusError as exc:
+            logging.exception("HTTP error occurred while posting the snapshot: %s", exc)
+            sys.exit(1)
+        except Exception as exc:
+            logging.exception("Could not post the snapshot: %s", exc)
             sys.exit(1)
 
     def commit_snapshot(self):
@@ -776,11 +818,15 @@ class BatchPoster(MigrationTaskBase):
                 res = httpx.put(url, headers=self.okapi_headers, json=snapshot, timeout=None)
             res.raise_for_status()
             logging.info("Posted Committed snapshot to FOLIO: %s", json.dumps(snapshot, indent=4))
-        except Exception:
+        except httpx.HTTPStatusError as exc:
+            logging.exception("HTTP error occurred while posting the snapshot: %s", exc)
+            sys.exit(1)
+        except Exception as exc:
             logging.exception(
                 "Could not commit snapshot with id %s. Post this to /source-storage/snapshots/%s:",
                 self.snapshot_id,
                 self.snapshot_id,
+                exc,
             )
             logging.info("%s", json.dumps(snapshot, indent=4))
             sys.exit(1)
@@ -891,8 +937,11 @@ def get_api_info(object_type: str, use_safe: bool = True):
     try:
         return choices[object_type]
     except KeyError:
-        key_string = ",".join(choices.keys())
-        logging.error(f"Wrong type. Only one of {key_string} are allowed")
+        key_string = ", ".join(choices.keys())
+        logging.error(
+            f"Wrong type. Only one of {key_string} are allowed, "
+            f"received {object_type=} instead"
+        )
         logging.error("Halting")
         sys.exit(1)
 
@@ -908,7 +957,7 @@ def chunks(records, number_of_chunks):
         _type_: _description_
     """
     for i in range(0, len(records), number_of_chunks):
-        yield records[i : i + number_of_chunks]
+        yield records[i: i + number_of_chunks]
 
 
 def get_human_readable(size, precision=2):

folio_migration_tools/migration_tasks/holdings_marc_transformer.py

@@ -1,5 +1,3 @@
-'''Main "script."'''
-
 import csv
 import json
 import logging
@@ -19,7 +17,10 @@ from folio_migration_tools.library_configuration import (
 from folio_migration_tools.marc_rules_transformation.rules_mapper_holdings import (
     RulesMapperHoldings,
 )
-from folio_migration_tools.migration_tasks.migration_task_base import MarcTaskConfigurationBase, MigrationTaskBase
+from folio_migration_tools.migration_tasks.migration_task_base import (
+    MarcTaskConfigurationBase,
+    MigrationTaskBase
+)
 
 
 class HoldingsMarcTransformer(MigrationTaskBase):
@@ -37,14 +38,18 @@ class HoldingsMarcTransformer(MigrationTaskBase):
             str,
             Field(
                 title="Migration task type",
-                description=("The type of migration task you want to perform"),
+                description=(
+                    "The type of migration task you want to perform"
+                ),
             ),
         ]
         files: Annotated[
             List[FileDefinition],
             Field(
                 title="Source files",
-                description=("List of MARC21 files with holdings records"),
+                description=(
+                    "List of MARC21 files with holdings records"
+                ),
             ),
         ]
         hrid_handling: Annotated[
@@ -125,8 +130,8 @@ class HoldingsMarcTransformer(MigrationTaskBase):
         default_call_number_type_name: Annotated[
             str,
             Field(
-                title="Default callnumber type name",
-                description="The name of the callnumber type that will be used as fallback",
+                title="Default call_number type name",
+                description="The name of the call_number type that will be used as fallback",
             ),
         ]
         fallback_holdings_type_id: Annotated[
@@ -140,7 +145,10 @@ class HoldingsMarcTransformer(MigrationTaskBase):
             str,
             Field(
                 title="Supplemental MFHD mapping rules file",
-                description="The name of the file in the mapping_files directory containing supplemental MFHD mapping rules",
+                description=(
+                    "The name of the file in the mapping_files directory "
+                    "containing supplemental MFHD mapping rules"
+                ),
             ),
         ] = ""
         include_mrk_statements: Annotated[
@@ -148,8 +156,10 @@ class HoldingsMarcTransformer(MigrationTaskBase):
             Field(
                 title="Include MARC statements (MRK-format) as staff-only Holdings notes",
                 description=(
-                    "If set to true, the MARC statements will be included in the output as MARC Maker format fields. "
-                    "If set to false (default), the MARC statements will not be included in the output."
+                    "If set to true, the MARC statements "
+                    "will be included in the output as MARC Maker format fields. "
+                    "If set to false (default), the MARC statements "
+                    "will not be included in the output."
                 ),
             ),
         ] = False
@@ -188,7 +198,8 @@ class HoldingsMarcTransformer(MigrationTaskBase):
                 title="Include MARC Record (as MARC21 decoded string) as note",
                 description=(
                     "If set to true, the MARC record will be included in the output as a "
-                    "decoded binary MARC21 record. If set to false (default), the MARC record will not be "
+                    "decoded binary MARC21 record. If set to false (default), "
+                    "the MARC record will not be "
                     "included in the output."
                 ),
             ),

folio_migration_tools/migration_tasks/items_transformer.py

@@ -127,7 +127,8 @@ class ItemsTransformer(MigrationTaskBase):
                 title="Statistical code map file name",
                 description=(
                     "Path to the file containing the mapping of statistical codes. "
-                    "The file should be in TSV format with legacy_stat_code and folio_code columns."
+                    "The file should be in TSV format with legacy_stat_code "
+                    "and folio_code columns."
                 ),
             ),
         ] = ""
@@ -355,7 +356,7 @@ class ItemsTransformer(MigrationTaskBase):
                     )
 
                     self.mapper.perform_additional_mappings(legacy_id, folio_rec, file_def)
-                    self.handle_circiulation_notes(folio_rec, self.folio_client.current_user)
+                    self.handle_circulation_notes(folio_rec, self.folio_client.current_user)
                     self.handle_notes(folio_rec)
                     if folio_rec["holdingsRecordId"] in self.boundwith_relationship_map:
                         for idx_, instance_id in enumerate(
@@ -373,7 +374,7 @@ class ItemsTransformer(MigrationTaskBase):
                     if idx == 0:
                         logging.info("First FOLIO record:")
                         logging.info(json.dumps(folio_rec, indent=4))
-                    # TODO: turn this into a asynchrounous task
+                    # TODO: turn this into a asynchronous task
                     Helper.write_to_file(results_file, folio_rec)
                     self.mapper.migration_report.add_general_statistics(
                         i18n.t("Number of records written to disk")
@@ -388,8 +389,8 @@ class ItemsTransformer(MigrationTaskBase):
                     logging.fatal(attribute_error)
                     logging.info("Quitting...")
                     sys.exit(1)
-                except Exception as excepion:
-                    self.mapper.handle_generic_exception(idx, excepion)
+                except Exception as exception:
+                    self.mapper.handle_generic_exception(idx, exception)
                 self.mapper.migration_report.add(
                     "GeneralStatistics",
                     i18n.t("Number of Legacy items in %{container}", container=file_def),
@@ -425,14 +426,14 @@ class ItemsTransformer(MigrationTaskBase):
                 del folio_object["notes"]
 
     @staticmethod
-    def handle_circiulation_notes(folio_rec, current_user_uuid):
+    def handle_circulation_notes(folio_rec, current_user_uuid):
         if not folio_rec.get("circulationNotes", []):
             return
         filtered_notes = []
         for circ_note in folio_rec.get("circulationNotes", []):
             if circ_note.get("noteType", "") not in ["Check in", "Check out"]:
                 raise TransformationProcessError(
-                    "", "Circulation Note types are not mapped correclty"
+                    "", "Circulation Note types are not mapped correctly"
                 )
             if circ_note.get("note", ""):
                 circ_note["id"] = str(uuid.uuid4())
@@ -455,11 +456,22 @@ class ItemsTransformer(MigrationTaskBase):
                         json.loads(x) for x in boundwith_relationship_file
                     )
             logging.info(
-                    "Rows in Bound with relationship map: %s", len(self.boundwith_relationship_map)
+                "Rows in Bound with relationship map: %s",
+                len(self.boundwith_relationship_map)
                 )
         except FileNotFoundError:
             raise TransformationProcessError(
-                    "", "Boundwith relationship file specified, but relationships file from holdings transformation not found. ", self.folder_structure.boundwith_relationships_map_path
+                "",
+                "Boundwith relationship file specified, but relationships file "
+                "from holdings transformation not found.",
+                self.folder_structure.boundwith_relationships_map_path
+            )
+        except ValueError:
+            raise TransformationProcessError(
+                "",
+                "Boundwith relationship file specified, but relationships file "
+                "from holdings transformation is not a valid line JSON.",
+                self.folder_structure.boundwith_relationships_map_path,
             )
 
     def wrap_up(self):

folio_migration_tools/migration_tasks/loans_migrator.py

@@ -17,6 +17,7 @@ from folio_uuid.folio_namespaces import FOLIONamespaces
 from art import tprint
 
 from folio_migration_tools.circulation_helper import CirculationHelper
+from folio_migration_tools.custom_exceptions import TransformationRecordFailedError
 from folio_migration_tools.helper import Helper
 from folio_migration_tools.library_configuration import (
     FileDefinition,
@@ -233,7 +234,7 @@ class LoansMigrator(MigrationTaskBase):
             legacy_loan (LegacyLoan): The Legacy loan
         """
         res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
-
+        
         if res_checkout.was_successful:
             self.migration_report.add("Details", i18n.t("Checked out on first try"))
             self.migration_report.add_general_statistics(i18n.t("Successfully checked out"))
@@ -302,7 +303,7 @@ class LoansMigrator(MigrationTaskBase):
 
     def wrap_up(self):
         for k, v in self.failed.items():
-            self.failed_and_not_dupe[k] = [v.to_dict()]
+            self.failed_and_not_dupe[k] = [v if isinstance(v, dict) else v.to_dict()]
         print(f"Wrapping up. Unique loans in failed:{len(self.failed_and_not_dupe)}")
 
         self.write_failed_loans_to_file()
@@ -404,6 +405,19 @@ class LoansMigrator(MigrationTaskBase):
                     ] = legacy_loan
                 else:
                     results.append(legacy_loan)
+            except TransformationRecordFailedError as trfe:
+                num_bad += 1
+                self.migration_report.add_general_statistics(
+                    i18n.t("Loans failed pre-validation")
+                )
+                self.migration_report.add(
+                    "DiscardedLoans",
+                    f"{trfe.message} - see data issues log",
+                )
+                trfe.log_it()
+                self.failed[
+                    legacy_loan_dict.get("item_barcode", f"no_barcode_{legacy_loan_count}")
+                ] = legacy_loan_dict
             except ValueError as ve:
                 logging.exception(ve)
         logging.info(
@@ -449,7 +463,7 @@ class LoansMigrator(MigrationTaskBase):
         elif folio_checkout.error_message == "Declared lost":
             return folio_checkout
         elif folio_checkout.error_message.startswith("Cannot check out to inactive user"):
-            return self.checkout_to_inactice_user(legacy_loan)
+            return self.checkout_to_inactive_user(legacy_loan)
         else:
             self.migration_report.add(
                 "Details",
@@ -479,7 +493,7 @@ class LoansMigrator(MigrationTaskBase):
                 del self.failed[legacy_loan.item_barcode]
             return TransactionResult(False, False, "", "", "")
 
-    def checkout_to_inactice_user(self, legacy_loan) -> TransactionResult:
+    def checkout_to_inactive_user(self, legacy_loan) -> TransactionResult:
         logging.info("Cannot check out to inactive user. Activating and trying again")
         user = self.get_user_by_barcode(legacy_loan.patron_barcode)
         expiration_date = user.get("expirationDate", datetime.isoformat(datetime.now()))
@@ -487,6 +501,8 @@ class LoansMigrator(MigrationTaskBase):
         self.activate_user(user)
         logging.debug("Successfully Activated user")
         res = self.circulation_helper.check_out_by_barcode(legacy_loan)  # checkout_and_update
+        if res.should_be_retried:
+            res = self.handle_checkout_failure(legacy_loan, res)
         self.migration_report.add("Details", res.migration_report_message)
         self.deactivate_user(user, expiration_date)
         logging.debug("Successfully Deactivated user again")

folio_migration_tools/task_configuration.py

@@ -25,7 +25,9 @@ class AbstractTaskConfiguration(BaseModel):
         str,
         Field(
             title="Migration task type",
-            description=("The type of migration task you want to perform."),
+            description=(
+                "The type of migration task you want to perform."
+            ),
         ),
     ]
     ecs_tenant_id: Annotated[

folio_migration_tools/test_infrastructure/mocked_classes.py

@@ -121,6 +121,11 @@ def folio_get_all_mocked(ref_data_path, array_name, query="", limit=10):
                 "name": "FOLIO user department name",
                 "code": "fdp",
             },
+            {
+                "id": "12a2ad12-951d-4124-9fb2-58c70f0b7f72",
+                "name": "FOLIO user department name 2",
+                "code": "fdp2",
+            },
             {
                 "id": "2f452d21-507d-4b32-a89d-8ea9753cc946",
                 "name": "FOLIO fallback user department name",

folio_migration_tools/transaction_migration/legacy_loan.py

@@ -8,7 +8,7 @@ from dateutil import tz
 from dateutil.parser import parse, ParserError
 
 from folio_migration_tools.migration_report import MigrationReport
-from folio_migration_tools.custom_exceptions import TransformationProcessError
+from folio_migration_tools.custom_exceptions import TransformationRecordFailedError
 
 utc = ZoneInfo("UTC")
 
@@ -124,7 +124,13 @@ class LegacyLoan(object):
             if self.out_date.hour == 0:
                 self.out_date = self.out_date.replace(hour=0, minute=1)
         if self.due_date <= self.out_date:
-            raise TransformationProcessError(self.row, i18n.t("Due date is before out date, or date information is missing from both"), json.dumps(self.legacy_loan_dict, indent=2))
+            raise TransformationRecordFailedError(
+                self.row,
+                i18n.t(
+                    "Due date is before out date, or date information is missing from both"
+                ),
+                json.dumps(self.legacy_loan_dict, indent=2)
+            )
 
     def to_dict(self):
         return {

folio_migration_tools/translations/en.json

@@ -446,6 +446,15 @@
   "blurbs.ValueSetInMappingFile.title": "Value set in mapping file",
   "blurbs.ValuesMappedFromLegacyFields.description": "A list fo the values and what they were mapped to",
   "blurbs.ValuesMappedFromLegacyFields.title": "Values mapped from legacy fields",
+  "blurbs.MethodOfAcquisitionMapping.title": "Method of acquisition",
+  "blurbs.MethodOfAcquisitionMapping.description": "Acquisition methods mapped from `008[7]` (LoC documentation)[https://www.loc.gov/marc/holdings/hd008.html]",
+  "blurbs.RetentionPolicyMapping.title": "Retention policy",
+  "blurbs.RetentionPolicyMapping.description": "Retention policies mapped from `008[12-15]` (LoC documentation)[https://www.loc.gov/marc/holdings/hd008.html]",
+  "blurbs.ILLPolicyMapping.title": "ILL policy",
+  "blurbs.ILLPolicyMapping.description": "ILL policies mapped from `008[20]` (LoC documentation)[https://www.loc.gov/marc/holdings/hd008.html]",
+  "blurbs.DigitizationPolicyMapping.title": "Digitization policy",
+  "blurbs.DigitizationPolicyMapping.description": "Digitization policies mapped from `008[21]` (LoC documentation)[https://www.loc.gov/marc/holdings/hd008.html]",
+  "Invalid specific retention policy in 008/13-15: %{value}": "Invalid specific retention policy in 008/13-15: %{value}",
   "created": "created",
   "instance type code (%{code}) not found in FOLIO": "instance type code (%{code}) not found in FOLIO",
   "item barcode": "item barcode",

{folio_migration_tools-1.9.2.dist-info → folio_migration_tools-1.9.3.dist-info}/METADATA

@@ -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.dist-info → folio_migration_tools-1.9.3.dist-info}/RECORD

@@ -22,13 +22,13 @@ folio_migration_tools/mapping_file_transformation/notes_mapper.py,sha256=vCmZmjr
 folio_migration_tools/mapping_file_transformation/order_mapper.py,sha256=-JEBEeOntNPE9-NYhWAJ1hpQI03ZzMv-_mkyLzSa9x4,17750
 folio_migration_tools/mapping_file_transformation/organization_mapper.py,sha256=u1Lb6tApn-nVLqbbJV38BuipKL3OK8Y2uQ4ogoyGQaI,14639
 folio_migration_tools/mapping_file_transformation/ref_data_mapping.py,sha256=qFsn_LwKZeKFdOudfEQnNA3DEHOdNQVKzTPdZAlDPX0,8864
-folio_migration_tools/mapping_file_transformation/user_mapper.py,sha256=GnePkCK2k8VSd_wAUNlLwTLLB-WwpxZLBC-kDXtONBU,7867
+folio_migration_tools/mapping_file_transformation/user_mapper.py,sha256=LJTj2F2dRKqyI37Ww0gY1AHLLT3dqyuKkY_RS_3-rg0,8543
 folio_migration_tools/marc_rules_transformation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-folio_migration_tools/marc_rules_transformation/conditions.py,sha256=ttTZISieqveu3YpvpnawHh3In1_DNQMTziI5yasfmWU,39142
-folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py,sha256=Rvdub7RdtR1BWnZij_Ejgp7cG9Kz58i_tXwXJbhaMtU,12101
+folio_migration_tools/marc_rules_transformation/conditions.py,sha256=F78a70HXcDLnOXDs_vSTdgf4opMWHzXzOjvpWlOh4PM,47719
+folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py,sha256=gM0ETZVVih35cSSpOBXA8wrBFhq2oeYaGsD89tnSNJs,13433
 folio_migration_tools/marc_rules_transformation/hrid_handler.py,sha256=SgnSYeNR0z_qarkizBMWZZWr8tOPZJ4fvlZjlM3nJOU,9999
 folio_migration_tools/marc_rules_transformation/loc_language_codes.xml,sha256=ztn2_yKws6qySL4oSsZh7sOjxq5bCC1PhAnXJdtgmJ0,382912
-folio_migration_tools/marc_rules_transformation/marc_file_processor.py,sha256=M-PHduzMYmZnrMwOSlwnWQ5bT-566gVRFSMo-JgS2d4,12346
+folio_migration_tools/marc_rules_transformation/marc_file_processor.py,sha256=QhVbJSlsWkGQgUo7ZVmQvlwpEN20Tyon_kzrZOWECoE,12549
 folio_migration_tools/marc_rules_transformation/marc_reader_wrapper.py,sha256=9ATjYMRAjy0QcXtmNZaHVhHLJ5hE1WUgOcF6KMJjbgo,5309
 folio_migration_tools/marc_rules_transformation/rules_mapper_authorities.py,sha256=PGt2w8h2pj8_8sGjQe3L-odFDlquURtKnoNFRWQB3GI,9621
 folio_migration_tools/marc_rules_transformation/rules_mapper_base.py,sha256=loNZ9gEYaAwjkP2_wLlXGedjWvSdHoGF_oJN9g6gI3s,45928
@@ -37,13 +37,13 @@ folio_migration_tools/marc_rules_transformation/rules_mapper_holdings.py,sha256=
 folio_migration_tools/migration_report.py,sha256=BkRspM1hwTBnWeqsHamf7yVEofzLj560Q-9G--O00hw,4258
 folio_migration_tools/migration_tasks/__init__.py,sha256=ZkbY_yGyB84Ke8OMlYUzyyBj4cxxNrhMTwQlu_GbdDs,211
 folio_migration_tools/migration_tasks/authority_transformer.py,sha256=AoXg9s-GLO3yEEDCrQV7hc4YVXxwxsdxDdpj1zhHydE,4251
-folio_migration_tools/migration_tasks/batch_poster.py,sha256=uXxvmxlLSTEhvdBH9FgxhIHHXB4ezLt35LSN6lKprYE,39673
+folio_migration_tools/migration_tasks/batch_poster.py,sha256=xN1BBZNGW2lZHWPznF6nkYV15XGhwwzcZccCzTbPfA4,40868
 folio_migration_tools/migration_tasks/bibs_transformer.py,sha256=46d44pcDAodFXDYbrTCMRASISbDciXmA0CXYfhP2IaE,6298
 folio_migration_tools/migration_tasks/courses_migrator.py,sha256=CzXnsu-KGP7B4zcINJzLYUqz47D16NuFfzu_DPqRlTQ,7061
 folio_migration_tools/migration_tasks/holdings_csv_transformer.py,sha256=kMhtHE8DJjA4d6kXBcfflueha3R3nwlBQjdec8CaY8c,21926
-folio_migration_tools/migration_tasks/holdings_marc_transformer.py,sha256=DVYdSNUPmdTv6GfLJdyT806dZV6UQHH_T8gkqtPgXaU,14143
-folio_migration_tools/migration_tasks/items_transformer.py,sha256=hkrllccEkKajp24BFSS85uiCpaEJinfkfvdjXGxNgCM,19223
-folio_migration_tools/migration_tasks/loans_migrator.py,sha256=CPsin9XLzHwNrpKHPMHAvgRvpoH8QvAfYZYr1FSxAN4,34520
+folio_migration_tools/migration_tasks/holdings_marc_transformer.py,sha256=c_ruhOgidyJdSnnRwWUs3wwFMiLqbVMPOhhCaYuH_TI,14343
+folio_migration_tools/migration_tasks/items_transformer.py,sha256=HlTzV7K0AiGBHw56VMascupMKXG0Pv8LS65O9EiQ2VU,19637
+folio_migration_tools/migration_tasks/loans_migrator.py,sha256=_7yZH951p5mhLjbyH1r496DG591dD1tg_mmTtHas62o,35316
 folio_migration_tools/migration_tasks/manual_fee_fines_transformer.py,sha256=CnmlTge7nChUJ10EiUkriQtJlVxWqglgfhjgneh2_yM,7247
 folio_migration_tools/migration_tasks/migration_task_base.py,sha256=Q-57h6rmt74bC9LidA9ZoagEcwVd_ytq8IUWelVOm2E,22521
 folio_migration_tools/migration_tasks/orders_transformer.py,sha256=6SnzU_rUTu2B5hQykI2nRA7vI1rg-uxuF9Ncupe0AEY,14302
@@ -51,17 +51,17 @@ folio_migration_tools/migration_tasks/organization_transformer.py,sha256=vcCjhN1
 folio_migration_tools/migration_tasks/requests_migrator.py,sha256=QP9OBezC3FfcKpI78oMmydxcPaUIYAgHyKevyLwC-WQ,14841
 folio_migration_tools/migration_tasks/reserves_migrator.py,sha256=4sSPer6_6yMwiiY1VYJmYZske_Ah1XG4KAM3NDadPhg,9952
 folio_migration_tools/migration_tasks/user_transformer.py,sha256=aylrMC9n47fdStgsNfW4ZbJh2E4FDSPypsaNv52ynKc,12330
-folio_migration_tools/task_configuration.py,sha256=2GXVog0-_cFybqsU2WFcxnTNGDhvDzqb7gYyIimdPAk,1131
+folio_migration_tools/task_configuration.py,sha256=73OWc8TX--fwPRptv3eQVEVv0-XmNaZcb3m__1HENSA,1161
 folio_migration_tools/test_infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-folio_migration_tools/test_infrastructure/mocked_classes.py,sha256=lpohRMqKnGmsoyspUQFXuyrGXRoIQZu2Dq7Q5WLQJw8,14877
+folio_migration_tools/test_infrastructure/mocked_classes.py,sha256=BurU3NGU_Q8as_BGmW98q9O6bujZDkOfFmvKKdVw9t8,15056
 folio_migration_tools/transaction_migration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-folio_migration_tools/transaction_migration/legacy_loan.py,sha256=zablUc_xKI2ah12RVNS-63cN6IkFCwTiIaJWE-7T9cU,6229
+folio_migration_tools/transaction_migration/legacy_loan.py,sha256=phd9oO6xd91qC4ilRq3podZ-rKIIwQ01SXe0JxbZAbQ,6339
 folio_migration_tools/transaction_migration/legacy_request.py,sha256=1ulyFzPQw_InOjyPzkWpGnNptgXdQ18nmri0J8Nlpkc,6124
 folio_migration_tools/transaction_migration/legacy_reserve.py,sha256=qzw0okg4axAE_ezXopP9gFsQ_e60o0zh7zqRzFBSWHY,1806
 folio_migration_tools/transaction_migration/transaction_result.py,sha256=cTdCN0BnlI9_ZJB2Z3Fdkl9gpymIi-9mGZsRFlQcmDk,656
-folio_migration_tools/translations/en.json,sha256=FeoaN3INfim4_-l3DSamHo2hn1SUJr5DsgDgsV4XUek,39693
-folio_migration_tools-1.9.2.dist-info/LICENSE,sha256=PhIEkitVi3ejgq56tt6sWoJIG_zmv82cjjd_aYPPGdI,1072
-folio_migration_tools-1.9.2.dist-info/METADATA,sha256=Cqu9bvuBBESPXOo3GoNF9GgijMciQSPtMPFnl94q4a4,7444
-folio_migration_tools-1.9.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-folio_migration_tools-1.9.2.dist-info/entry_points.txt,sha256=Hbe-HjqMcU8FwVshVIkeWyZd9XwgT1CCMNf06EpHQu8,77
-folio_migration_tools-1.9.2.dist-info/RECORD,,
+folio_migration_tools/translations/en.json,sha256=TPQRTDdvdkZI2iHczP4hKmFEbd7Hyo5BE37uSo54W_4,40691
+folio_migration_tools-1.9.3.dist-info/LICENSE,sha256=PhIEkitVi3ejgq56tt6sWoJIG_zmv82cjjd_aYPPGdI,1072
+folio_migration_tools-1.9.3.dist-info/METADATA,sha256=dPvDnsZ0qw3K6pPfHatlCPfSCov_7d8Ll7L2pJYSta8,7444
+folio_migration_tools-1.9.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+folio_migration_tools-1.9.3.dist-info/entry_points.txt,sha256=Hbe-HjqMcU8FwVshVIkeWyZd9XwgT1CCMNf06EpHQu8,77
+folio_migration_tools-1.9.3.dist-info/RECORD,,