folio-migration-tools 1.9.10__py3-none-any.whl → 1.10.0b1__py3-none-any.whl

folio_migration_tools/marc_rules_transformation/rules_mapper_base.py

@@ -52,7 +52,10 @@ class RulesMapperBase(MapperBase):
         self.mappings: dict = {}
         self.schema_properties = None
         self.create_source_records = all(
-            [self.task_configuration.create_source_records, (not getattr(self.task_configuration, "data_import_marc", False))]
+            [
+                self.task_configuration.create_source_records,
+                (not getattr(self.task_configuration, "data_import_marc", False)),
+            ]
         )
         if hasattr(self.task_configuration, "hrid_handling"):
             self.hrid_handler = HRIDHandler(
@@ -190,10 +193,10 @@ class RulesMapperBase(MapperBase):
     ):
         values: List[str] = []
         if mapping.get("subfield") and (custom_delimiters := mapping.get("subFieldDelimiter")):
-            delimiter_map = {sub_f: " " for sub_f in mapping.get("subfield")}
+            delimiter_map = dict.fromkeys(mapping.get("subfield"), " ")
             for custom_delimiter in custom_delimiters:
                 delimiter_map.update(
-                    {sub_f: custom_delimiter["value"] for sub_f in custom_delimiter["subfields"]}
+                    dict.fromkeys(custom_delimiter["subfields"], custom_delimiter["value"])
                 )
             custom_delimited_strings: List[Tuple[str, List[str]]] = []
             subfields = mapping.get("subfield")
@@ -505,7 +508,7 @@ class RulesMapperBase(MapperBase):
                 + i18n.t("Check mapping file against the schema.")
                 + " "
                 + i18n.t("Target type")
-                + f": {sch.get(target_string,{}).get('type','')} "
+                + f": {sch.get(target_string, {}).get('type', '')} "
                 + i18n.t("Value")
                 + f": {value}",
                 "",
@@ -529,7 +532,7 @@ class RulesMapperBase(MapperBase):
                 "",
                 (
                     f"Edge! Target string: {target_string} "
-                    f"Target type: {sch.get(target_string,{}).get('type','')} Value: {value}"
+                    f"Target type: {sch.get(target_string, {}).get('type', '')} Value: {value}"
                 ),
             )
 
@@ -564,8 +567,9 @@ class RulesMapperBase(MapperBase):
                     if subfield != "9":
                         Helper.log_data_issue(
                             index_or_legacy_id,
-                            f"authorityId mapping from ${subfield} is not supported. Data Import will fail. "
-                            "Use only $9 for authority id mapping in MARC-to-Instance mapping rules.",
+                            f"authorityId mapping from ${subfield} is not supported. Data Import "
+                            "will fail. Use only $9 for authority id mapping in MARC-to-Instance "
+                            "mapping rules.",
                             marc_field,
                         )
                         entity_mapping["subfield"] = ["9"]
@@ -599,7 +603,8 @@ class RulesMapperBase(MapperBase):
             entity = {}
             Helper.log_data_issue(
                 index_or_legacy_id,
-                f"Missing one or more required property in entity {entity_parent_key} ({missing_required_props})",
+                f"Missing one or more required property in entity {entity_parent_key} "
+                f"({missing_required_props})",
                 marc_field,
             )
         return entity
@@ -639,7 +644,8 @@ class RulesMapperBase(MapperBase):
                     )
                     or e_parent in ["electronicAccess", "publication"]
                     or (
-                        e_parent.startswith("holdingsStatements") and any(v for k, v in entity.items())
+                        e_parent.startswith("holdingsStatements")
+                        and any(v for k, v in entity.items())
                     )
                 ):
                     self.add_entity_to_record(entity, e_parent, folio_record, self.schema)
@@ -661,12 +667,12 @@ class RulesMapperBase(MapperBase):
         folio_record["discoverySuppress"] = file_def.discovery_suppressed
         self.migration_report.add(
             "Suppression",
-            i18n.t("Suppressed from discovery") + f' = {folio_record["discoverySuppress"]}',
+            i18n.t("Suppressed from discovery") + f" = {folio_record['discoverySuppress']}",
         )
         if not only_discovery_suppress:
             folio_record["staffSuppress"] = file_def.staff_suppressed
             self.migration_report.add(
-                "Suppression", i18n.t("Staff suppressed") + f' = {folio_record["staffSuppress"]} '
+                "Suppression", i18n.t("Staff suppressed") + f" = {folio_record['staffSuppress']} "
             )
 
     def create_preceding_succeeding_titles(
@@ -825,7 +831,6 @@ class RulesMapperBase(MapperBase):
             )
         data_import_marc_file.write(marc_record.as_marc())
 
-
     def map_statistical_codes(
         self,
         folio_record: dict,
@@ -854,11 +859,17 @@ class RulesMapperBase(MapperBase):
             for mapping in self.task_configuration.statistical_code_mapping_fields:
                 stat_code_marc_fields.append(mapping.split("$"))
             for field_map in stat_code_marc_fields:
-                mapped_codes = self.map_stat_codes_from_marc_field(field_map, marc_record, self.library_configuration.multi_field_delimiter)
-                folio_record['statisticalCodeIds'] = folio_record.get("statisticalCodeIds", []) + mapped_codes
+                mapped_codes = self.map_stat_codes_from_marc_field(
+                    field_map, marc_record, self.library_configuration.multi_field_delimiter
+                )
+                folio_record["statisticalCodeIds"] = (
+                    folio_record.get("statisticalCodeIds", []) + mapped_codes
+                )
 
     @staticmethod
-    def map_stat_codes_from_marc_field(field_map: List[str], marc_record: Record, multi_field_delimiter: str="<delimiter>") -> List[str]:
+    def map_stat_codes_from_marc_field(
+        field_map: List[str], marc_record: Record, multi_field_delimiter: str = "<delimiter>"
+    ) -> List[str]:
         """Map statistical codes from MARC field to FOLIO instance.
 
         This function extracts statistical codes from a MARC field based on the provided field map.
@@ -871,30 +882,26 @@ class RulesMapperBase(MapperBase):
 
         Returns:
             str: A string of statistical codes extracted from the MARC field, formatted as "<field>_<subfield>:<value>".
-        """
+        """  # noqa: E501
         field_values = []
         if len(field_map) == 2:
             subfields = []
             for mf in marc_record.get_fields(field_map[0]):
                 subfields.extend(
-                    multi_field_delimiter.join(
-                        mf.get_subfields(field_map[1])
-                    ).split(multi_field_delimiter)
+                    multi_field_delimiter.join(mf.get_subfields(field_map[1])).split(
+                        multi_field_delimiter
+                    )
                 )
-            field_values.extend(
-                [
-                    f"{field_map[0]}_{field_map[1]}:{x}" for
-                    x in subfields
-                ]
-            )
+            field_values.extend([f"{field_map[0]}_{field_map[1]}:{x}" for x in subfields])
         elif len(field_map) > 2:
             for mf in marc_record.get_fields(field_map[0]):
                 for sf in field_map[1:]:
                     field_values.extend(
                         [
-                            f"{field_map[0]}_{sf}:{x}" for x in multi_field_delimiter.join(
-                                mf.get_subfields(sf)
-                            ).split(multi_field_delimiter)
+                            f"{field_map[0]}_{sf}:{x}"
+                            for x in multi_field_delimiter.join(mf.get_subfields(sf)).split(
+                                multi_field_delimiter
+                            )
                         ]
                     )
         elif field_map:
@@ -960,11 +967,7 @@ class RulesMapperBase(MapperBase):
         }
 
         return str(
-            FolioUUID(
-                self.base_string_for_folio_uuid,
-                srs_types.get(record_type),
-                legacy_id
-            )
+            FolioUUID(self.base_string_for_folio_uuid, srs_types.get(record_type), legacy_id)
         )
 
     @staticmethod
@@ -1075,6 +1078,7 @@ def is_array_of_objects(schema_property):
     sc_prop_type = schema_property.get("type", "string")
     return sc_prop_type == "array" and schema_property["items"]["type"] == "object"
 
+
 def entity_indicators_match(entity_mapping, marc_field):
     """
     Check if the indicators of the entity mapping match the indicators of the MARC field.
@@ -1095,12 +1099,18 @@ def entity_indicators_match(entity_mapping, marc_field):
 
     Returns:
         bool: True if the indicators match, False otherwise.
-    """
+    """  # noqa: E501
     if indicator_rule := [x["indicators"] for x in entity_mapping if "indicators" in x]:
         return all(
             [
-                (marc_field.indicator1 == indicator_rule[0]['ind1'] or indicator_rule[0]['ind1'] == "*"),
-                (marc_field.indicator2 == indicator_rule[0]['ind2'] or indicator_rule[0]['ind2'] == "*"),
+                (
+                    marc_field.indicator1 == indicator_rule[0]["ind1"]
+                    or indicator_rule[0]["ind1"] == "*"
+                ),
+                (
+                    marc_field.indicator2 == indicator_rule[0]["ind2"]
+                    or indicator_rule[0]["ind2"] == "*"
+                ),
             ]
         )
     else:

folio_migration_tools/marc_rules_transformation/rules_mapper_bibs.py

@@ -67,7 +67,9 @@ class BibsRulesMapper(RulesMapperBase):
             self.hrid_handler.deactivate035_from001 = True
         self.start = time.time()
 
-    def perform_initial_preparation(self, file_def: FileDefinition, marc_record: Record, legacy_ids: List[str]):
+    def perform_initial_preparation(
+        self, file_def: FileDefinition, marc_record: Record, legacy_ids: List[str]
+    ):
         folio_instance = {}
         folio_instance["id"] = str(
             FolioUUID(
@@ -145,7 +147,13 @@ class BibsRulesMapper(RulesMapperBase):
         self.report_folio_mapping(clean_folio_instance, self.schema)
         return [clean_folio_instance]
 
-    def simple_bib_map(self, folio_instance: dict, marc_record: Record, ignored_subsequent_fields: set, legacy_ids: List[str]):
+    def simple_bib_map(
+        self,
+        folio_instance: dict,
+        marc_record: Record,
+        ignored_subsequent_fields: set,
+        legacy_ids: List[str],
+    ):
         """
         This method applies a much simplified MARC-to-instance
         mapping to create a minimal FOLIO Instance record to be
@@ -164,20 +172,24 @@ class BibsRulesMapper(RulesMapperBase):
         if len(main_entry_fields) > 1:
             Helper.log_data_issue(
                 legacy_ids,
-                "Multiple main entry fields in record. Record will fail Data Import. Creating Instance anyway.",
-                [str(field) for field in main_entry_fields]
+                "Multiple main entry fields in record. Record will fail Data Import. "
+                "Creating Instance anyway.",
+                [str(field) for field in main_entry_fields],
             )
         if not main_entry_fields:
             main_entry_fields += marc_record.get_fields("700", "710", "711", "730")
             main_entry_fields.sort(key=lambda x: int(x.tag))
         if main_entry_fields:
-            self.process_marc_field(folio_instance, main_entry_fields[0], ignored_subsequent_fields, legacy_ids)
+            self.process_marc_field(
+                folio_instance, main_entry_fields[0], ignored_subsequent_fields, legacy_ids
+            )
         try:
-            self.process_marc_field(folio_instance, marc_record['245'], ignored_subsequent_fields, legacy_ids)
+            self.process_marc_field(
+                folio_instance, marc_record["245"], ignored_subsequent_fields, legacy_ids
+            )
         except KeyError as ke:
             raise TransformationRecordFailedError(
-                legacy_ids,
-                "No 245 field in MARC record"
+                legacy_ids, "No 245 field in MARC record"
             ) from ke
 
     def perform_additional_parsing(
@@ -220,10 +232,8 @@ class BibsRulesMapper(RulesMapperBase):
 
     def handle_languages(self, folio_instance: Dict, marc_record: Record, legacy_ids: List[str]):
         if "languages" in folio_instance:
-            orig_languages = {lang: None for lang in folio_instance["languages"]}
-            orig_languages.update(
-                {lang: None for lang in self.get_languages(marc_record, legacy_ids)}
-            )
+            orig_languages = dict.fromkeys(folio_instance["languages"])
+            orig_languages.update(dict.fromkeys(self.get_languages(marc_record, legacy_ids)))
             folio_instance["languages"] = list(orig_languages.keys())
         else:
             folio_instance["languages"] = self.get_languages(marc_record, legacy_ids)
@@ -422,7 +432,7 @@ class BibsRulesMapper(RulesMapperBase):
             return True
         self.migration_report.add(
             "InstanceFormat",
-            ("InstanceFormat not mapped since 338$2 (Source) " f"is set to {field['2']}. "),
+            (f"InstanceFormat not mapped since 338$2 (Source) is set to {field['2']}. "),
         )
         return False
 
@@ -533,10 +543,10 @@ class BibsRulesMapper(RulesMapperBase):
         return ""
 
     def get_languages_041(self, marc_record: Record, legacy_id: List[str]) -> Dict[str, None]:
-        languages = dict()
+        languages = {}
         lang_fields = marc_record.get_fields("041")
         if not any(lang_fields):
-            return dict()
+            return {}
         subfields = "abdefghjkmn"
         for lang_tag in lang_fields:
             if "2" in lang_tag:

folio_migration_tools/marc_rules_transformation/rules_mapper_holdings.py

@@ -95,25 +95,21 @@ class RulesMapperHoldings(RulesMapperBase):
                         )
         self.mappings["852"] = new_852_mapping
 
-    def integrate_supplemental_mfhd_mappings(self, new_rules={}):
+    def integrate_supplemental_mfhd_mappings(self, new_rules=None):
         try:
-            self.mappings.update(new_rules)
+            self.mappings.update(new_rules or {})
             self.fix_853_bug_in_rules()
         except Exception as e:
             raise TransformationProcessError(
                 "",
                 "Failed to integrate supplemental mfhd mappings",
                 str(e),
-            )
+            ) from e
 
     def prep_852_notes(self, marc_record: Record):
         for field in marc_record.get_fields("852"):
             field.subfields.sort(key=lambda x: x[0])
-            new_952 = Field(
-                tag="952",
-                indicators=["f", "f"],
-                subfields=field.subfields
-            )
+            new_952 = Field(tag="952", indicators=["f", "f"], subfields=field.subfields)
             marc_record.add_ordered_field(new_952)
 
     def parse_record(
@@ -270,7 +266,11 @@ class RulesMapperHoldings(RulesMapperBase):
                 ignored_subsequent_fields.add(marc_field.tag)
 
     def perform_additional_mapping(
-        self, marc_record: Record, folio_holding: Dict, legacy_ids: List[str], file_def: FileDefinition
+        self,
+        marc_record: Record,
+        folio_holding: Dict,
+        legacy_ids: List[str],
+        file_def: FileDefinition,
     ):
         """_summary_
 
@@ -306,11 +306,13 @@ class RulesMapperHoldings(RulesMapperBase):
                 "",
             )
         self.handle_suppression(folio_holding, file_def, True)
-        # First, map statistical codes from MARC fields and FileDefinitions to FOLIO statistical codes.
-        # Then, convert the mapped statistical codes to their corresponding code IDs.
+        # First, map statistical codes from MARC fields and FileDefinitions to FOLIO statistical
+        # codes. Then, convert the mapped statistical codes to their corresponding code IDs.
         self.map_statistical_codes(folio_holding, file_def, marc_record)
         self.map_statistical_code_ids(legacy_ids, folio_holding)
-        self.set_source_id(self.create_source_records, folio_holding, self.holdingssources, file_def)
+        self.set_source_id(
+            self.create_source_records, folio_holding, self.holdingssources, file_def
+        )
 
     def pick_first_location_if_many(self, folio_holding: Dict, legacy_ids: List[str]):
         if " " in folio_holding.get("permanentLocationId", ""):
@@ -324,7 +326,12 @@ class RulesMapperHoldings(RulesMapperBase):
             ]
 
     @staticmethod
-    def set_source_id(create_source_records: bool, folio_rec: Dict, holdingssources: Dict, file_def: FileDefinition):
+    def set_source_id(
+        create_source_records: bool,
+        folio_rec: Dict,
+        holdingssources: Dict,
+        file_def: FileDefinition,
+    ):
         if file_def.create_source_records and create_source_records:
             folio_rec["sourceId"] = holdingssources.get("MARC")
         else:
@@ -371,10 +378,14 @@ class RulesMapperHoldings(RulesMapperBase):
         """
         if self.task_configuration.include_mrk_statements:
             mrk_statement_notes = []
-            for field in marc_record.get_fields("853", "854", "855", "863", "864", "865", "866", "867", "868"):
+            for field in marc_record.get_fields(
+                "853", "854", "855", "863", "864", "865", "866", "867", "868"
+            ):
                 mrk_statement_notes.append(str(field))
             if mrk_statement_notes:
-                folio_holding["notes"] = folio_holding.get("notes", []) + self.add_mrk_statements_note(mrk_statement_notes, legacy_ids)
+                folio_holding["notes"] = folio_holding.get(
+                    "notes", []
+                ) + self.add_mrk_statements_note(mrk_statement_notes, legacy_ids)
 
     def add_mrk_statements_note(self, mrk_statement_notes: List[str], legacy_ids) -> List[Dict]:
         """Creates a note from the MRK statements
@@ -386,7 +397,9 @@ class RulesMapperHoldings(RulesMapperBase):
             List: A list containing the FOLIO holdings note object (Dict)
         """
         holdings_note_type_tuple = self.conditions.get_ref_data_tuple_by_name(
-            self.folio.holding_note_types, "holding_note_types", self.task_configuration.mrk_holdings_note_type
+            self.folio.holding_note_types,
+            "holding_note_types",
+            self.task_configuration.mrk_holdings_note_type,
         )
         try:
             holdings_note_type_id = holdings_note_type_tuple[0]
@@ -394,7 +407,8 @@ class RulesMapperHoldings(RulesMapperBase):
             logging.error(ee)
             raise TransformationRecordFailedError(
                 legacy_ids,
-                f'Holdings note type mapping error.\tNote type name: {self.task_configuration.mrk_holdings_note_type}\t'
+                f"Holdings note type mapping error.\tNote type name: "
+                f"{self.task_configuration.mrk_holdings_note_type}\t"
                 f"MFHD holdings statement note type not found in FOLIO.",
                 self.task_configuration.mrk_holdings_note_type,
             ) from ee
@@ -403,7 +417,8 @@ class RulesMapperHoldings(RulesMapperBase):
                 "note": chunk,
                 "holdingsNoteTypeId": holdings_note_type_id,
                 "staffOnly": True,
-            } for chunk in self.split_mrk_by_max_note_size("\n".join(mrk_statement_notes))
+            }
+            for chunk in self.split_mrk_by_max_note_size("\n".join(mrk_statement_notes))
         ]
 
     @staticmethod
@@ -423,7 +438,9 @@ class RulesMapperHoldings(RulesMapperBase):
             chunks.append(current_chunk)
         return chunks
 
-    def add_mfhd_as_mrk_note(self, marc_record: Record, folio_holding: Dict, legacy_ids: List[str]):
+    def add_mfhd_as_mrk_note(
+        self, marc_record: Record, folio_holding: Dict, legacy_ids: List[str]
+    ):
         """Adds the MFHD as a note to the holdings record
 
         This is done to preserve the information in the MARC record for future reference.
@@ -434,7 +451,9 @@ class RulesMapperHoldings(RulesMapperBase):
         """
         if self.task_configuration.include_mfhd_mrk_as_note:
             holdings_note_type_tuple = self.conditions.get_ref_data_tuple_by_name(
-                self.folio.holding_note_types, "holding_note_types", self.task_configuration.mfhd_mrk_note_type
+                self.folio.holding_note_types,
+                "holding_note_types",
+                self.task_configuration.mfhd_mrk_note_type,
             )
             try:
                 holdings_note_type_id = holdings_note_type_tuple[0]
@@ -442,7 +461,8 @@ class RulesMapperHoldings(RulesMapperBase):
                 logging.error(ee)
                 raise TransformationRecordFailedError(
                     legacy_ids,
-                    f'Holdings note type mapping error.\tNote type name: {self.task_configuration.mfhd_mrk_note_type}\t'
+                    f"Holdings note type mapping error.\tNote type name: "
+                    f"{self.task_configuration.mfhd_mrk_note_type}\t"
                     f"Note type not found in FOLIO.",
                     self.task_configuration.mfhd_mrk_note_type,
                 ) from ee
@@ -451,13 +471,16 @@ class RulesMapperHoldings(RulesMapperBase):
                     "note": chunk,
                     "holdingsNoteTypeId": holdings_note_type_id,
                     "staffOnly": True,
-                } for chunk in self.split_mrk_by_max_note_size(str(marc_record))
+                }
+                for chunk in self.split_mrk_by_max_note_size(str(marc_record))
             ]
 
     @staticmethod
-    def split_mrc_by_max_note_size(data: bytes, sep: bytes = b"\x1e", max_chunk_size: int = 32000) -> List[bytes]:
+    def split_mrc_by_max_note_size(
+        data: bytes, sep: bytes = b"\x1e", max_chunk_size: int = 32000
+    ) -> List[bytes]:
         # Split data into segments, each ending with the separator (except possibly the last)
-        pattern = re.compile(b'(.*?' + re.escape(sep) + b'|.+?$)', re.DOTALL)
+        pattern = re.compile(b"(.*?" + re.escape(sep) + b"|.+?$)", re.DOTALL)
         parts = [m.group(0) for m in pattern.finditer(data) if m.group(0)]
         chunks = []
         current_chunk = b""
@@ -471,7 +494,9 @@ class RulesMapperHoldings(RulesMapperBase):
             chunks.append(current_chunk)
         return chunks
 
-    def add_mfhd_as_mrc_note(self, marc_record: Record, folio_holding: Dict, legacy_ids: List[str]):
+    def add_mfhd_as_mrc_note(
+        self, marc_record: Record, folio_holding: Dict, legacy_ids: List[str]
+    ):
         """Adds the MFHD as a note to the holdings record
 
         This is done to preserve the information in the MARC record for future reference.
@@ -482,7 +507,9 @@ class RulesMapperHoldings(RulesMapperBase):
         """
         if self.task_configuration.include_mfhd_mrc_as_note:
             holdings_note_type_tuple = self.conditions.get_ref_data_tuple_by_name(
-                self.folio.holding_note_types, "holding_note_types", self.task_configuration.mfhd_mrc_note_type
+                self.folio.holding_note_types,
+                "holding_note_types",
+                self.task_configuration.mfhd_mrc_note_type,
             )
             try:
                 holdings_note_type_id = holdings_note_type_tuple[0]
@@ -490,7 +517,8 @@ class RulesMapperHoldings(RulesMapperBase):
                 logging.error(ee)
                 raise TransformationRecordFailedError(
                     legacy_ids,
-                    f'Holdings note type mapping error.\tNote type name: {self.task_configuration.mfhd_mrc_note_type}\t'
+                    f"Holdings note type mapping error.\tNote type name: "
+                    f"{self.task_configuration.mfhd_mrc_note_type}\t"
                     f"Note type not found in FOLIO.",
                     self.task_configuration.mfhd_mrc_note_type,
                 ) from ee
@@ -499,7 +527,8 @@ class RulesMapperHoldings(RulesMapperBase):
                     "note": chunk.decode("utf-8"),
                     "holdingsNoteTypeId": holdings_note_type_id,
                     "staffOnly": True,
-                } for chunk in self.split_mrc_by_max_note_size(marc_record.as_marc())
+                }
+                for chunk in self.split_mrc_by_max_note_size(marc_record.as_marc())
             ]
 
     def wrap_up(self):
@@ -642,7 +671,7 @@ class RulesMapperHoldings(RulesMapperBase):
         Raises:
             TransformationProcessError: If MFHD_ID or BIB_ID is missing from the entry or if the instance_uuid is not in the parent_id_map.
             TransformationRecordFailedError: If BIB_ID is not in the instance id map.
-        """
+        """  # noqa: E501
         new_map = {}
         for idx, entry in enumerate(boundwith_relationship_map_list):
             self.verity_boundwith_map_entry(entry)
@@ -663,9 +692,10 @@ class RulesMapperHoldings(RulesMapperBase):
     def get_bw_instance_id_map_tuple(self, entry: Dict):
         try:
             return self.parent_id_map[entry["BIB_ID"]]
-        except KeyError:
+        except KeyError as e:
             raise TransformationRecordFailedError(
                 entry["MFHD_ID"],
-                "Boundwith relationship map contains a BIB_ID id not in the instance id map. No boundwith holdings created for this BIB_ID.",
+                "Boundwith relationship map contains a BIB_ID id not in the instance id map. "
+                "No boundwith holdings created for this BIB_ID.",
                 entry["BIB_ID"],
-            )
+            ) from e

folio_migration_tools/migration_report.py

@@ -76,7 +76,7 @@ class MigrationReport:
                 ]
             )
         )
-        logging.info(f"Elapsed time: {time_finished-time_started}")
+        logging.info(f"Elapsed time: {time_finished - time_started}")
         for a in self.report:
             blurb_id = self.report[a].get("blurb_id") or ""
             report_file.write(

folio_migration_tools/migration_tasks/authority_transformer.py

@@ -66,8 +66,7 @@ class AuthorityTransformer(MigrationTaskBase):
             Field(
                 title="Create source records",
                 description=(
-                    "Controls wheter or not to retain the MARC records in "
-                    "Source Record Storage."
+                    "Controls wheter or not to retain the MARC records in Source Record Storage."
                 ),
             ),
         ] = True