folio-migration-tools 1.9.9__py3-none-any.whl → 1.10.0__py3-none-any.whl

folio_migration_tools/marc_rules_transformation/rules_mapper_base.py

@@ -15,6 +15,7 @@ from folio_uuid.folio_uuid import FOLIONamespaces, FolioUUID
 from folioclient import FolioClient
 from pymarc import Field, Optional, Record, Subfield
 
+from folio_migration_tools.i18n_cache import i18n_t
 from folio_migration_tools.custom_exceptions import (
     TransformationFieldMappingError,
     TransformationProcessError,
@@ -52,7 +53,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 +194,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")
@@ -296,13 +300,13 @@ class RulesMapperBase(MapperBase):
     def perform_proxy_mapping(self, marc_field):
         proxy_mapping = next(iter(self.mappings.get("880", [])), [])
         if "6" not in marc_field:
-            self.migration_report.add("Field880Mappings", i18n.t("Records without $6"))
+            self.migration_report.add("Field880Mappings", i18n_t("Records without $6"))
             return None
         if not proxy_mapping or not proxy_mapping.get("fieldReplacementBy3Digits", False):
             return None
         if not marc_field["6"][:3] or len(marc_field["6"][:3]) != 3:
             self.migration_report.add(
-                "Field880Mappings", i18n.t("Records with unexpected length in $6")
+                "Field880Mappings", i18n_t("Records with unexpected length in $6")
             )
             return None
         first_three = marc_field["6"][:3]
@@ -317,16 +321,16 @@ class RulesMapperBase(MapperBase):
         )
         self.migration_report.add(
             "Field880Mappings",
-            i18n.t("Source digits")
+            i18n_t("Source digits")
             + f": {marc_field['6']} "
-            + i18n.t("Target field")
+            + i18n_t("Target field")
             + f": {target_field}",
         )
         mappings = self.mappings.get(target_field, {})
         if not mappings:
             self.migration_report.add(
                 "Field880Mappings",
-                i18n.t("Mapping not set up for target field")
+                i18n_t("Mapping not set up for target field")
                 + f": {target_field} ({marc_field['6']})",
             )
         return mappings
@@ -334,7 +338,7 @@ class RulesMapperBase(MapperBase):
     def report_marc_stats(
         self, marc_field: Field, bad_tags, legacy_ids, ignored_subsequent_fields
     ):
-        self.migration_report.add("Trivia", i18n.t("Total number of Tags processed"))
+        self.migration_report.add("Trivia", i18n_t("Total number of Tags processed"))
         self.report_source_and_links(marc_field)
         self.report_bad_tags(marc_field, bad_tags, legacy_ids)
         mapped = marc_field.tag in self.mappings
@@ -348,7 +352,7 @@ class RulesMapperBase(MapperBase):
         for subfield_2 in marc_field.get_subfields("2"):
             self.migration_report.add(
                 "AuthoritySources",
-                i18n.t("Source of heading or term") + f": {subfield_2.split(' ')[0]}",
+                i18n_t("Source of heading or term") + f": {subfield_2.split(' ')[0]}",
             )
         for subfield_0 in marc_field.get_subfields("0"):
             code = ""
@@ -360,7 +364,7 @@ class RulesMapperBase(MapperBase):
                     code = subfield_0[: subfield_0.find(url.path)]
             if code:
                 self.migration_report.add(
-                    "AuthoritySources", i18n.t("$0 base uri or source code") + f": {code}"
+                    "AuthoritySources", i18n_t("$0 base uri or source code") + f": {code}"
                 )
 
     def apply_rules(self, marc_field: pymarc.Field, mapping, legacy_ids):
@@ -399,7 +403,7 @@ class RulesMapperBase(MapperBase):
             )
             trfe.log_it()
             self.migration_report.add_general_statistics(
-                i18n.t("Records failed due to an error. See data issues log for details")
+                i18n_t("Records failed due to an error. See data issues log for details")
             )
         except Exception as exception:
             self.handle_generic_exception(self.parsed_records, exception)
@@ -505,7 +509,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 +533,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 +568,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 +604,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 +645,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 +668,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 +832,6 @@ class RulesMapperBase(MapperBase):
             )
         data_import_marc_file.write(marc_record.as_marc())
 
-
     def map_statistical_codes(
         self,
         folio_record: dict,
@@ -854,11 +860,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 +883,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:
@@ -955,16 +963,11 @@ class RulesMapperBase(MapperBase):
         srs_types = {
             FOLIONamespaces.holdings: FOLIONamespaces.srs_records_holdingsrecord,
             FOLIONamespaces.instances: FOLIONamespaces.srs_records_bib,
-            FOLIONamespaces.authorities: FOLIONamespaces.srs_records_auth,
             FOLIONamespaces.edifact: FOLIONamespaces.srs_records_edifact,
         }
 
         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
@@ -1017,7 +1020,6 @@ class RulesMapperBase(MapperBase):
         record_types = {
             FOLIONamespaces.holdings: "MARC_HOLDING",
             FOLIONamespaces.instances: "MARC_BIB",
-            FOLIONamespaces.authorities: "MARC_AUTHORITY",
             FOLIONamespaces.edifact: "EDIFACT",
         }
 
@@ -1030,10 +1032,6 @@ class RulesMapperBase(MapperBase):
                 "holdingsId": folio_object["id"],
                 "holdingsHrid": folio_object.get("hrid", ""),
             },
-            FOLIONamespaces.authorities: {
-                "authorityId": folio_object["id"],
-                "authorityHrid": marc_record["001"].data,
-            },
             FOLIONamespaces.edifact: {},
         }
 
@@ -1075,6 +1073,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 +1094,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

@@ -17,6 +17,7 @@ from folioclient import FolioClient
 from pymarc.record import Leader, Record
 from pymarc.field import Field
 
+from folio_migration_tools.i18n_cache import i18n_t
 from folio_migration_tools.custom_exceptions import (
     TransformationProcessError,
     TransformationRecordFailedError,
@@ -67,7 +68,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(
@@ -95,7 +98,7 @@ class BibsRulesMapper(RulesMapperBase):
 
     def handle_leader_05(self, marc_record: Record, legacy_ids: List[str]):
         leader_05 = marc_record.leader[5] or "Empty"
-        self.migration_report.add("RecordStatus", i18n.t("Original value") + f": {leader_05}")
+        self.migration_report.add("RecordStatus", i18n_t("Original value") + f": {leader_05}")
         if leader_05 not in ["a", "c", "d", "n", "p"]:
             marc_record.leader = Leader(f"{marc_record.leader[:5]}c{marc_record.leader[6:]}")
             self.migration_report.add(
@@ -145,7 +148,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 +173,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 +233,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)
@@ -313,7 +324,7 @@ class BibsRulesMapper(RulesMapperBase):
             raise TransformationProcessError("", "No instance_types setup in tenant")
 
         if "336" in marc_record and "b" not in marc_record["336"]:
-            self.migration_report.add("RecourceTypeMapping", i18n.t("Subfield b not in 336"))
+            self.migration_report.add("RecourceTypeMapping", i18n_t("Subfield b not in 336"))
             if "a" in marc_record["336"]:
                 return_id = get_folio_id_by_name(marc_record["336"]["a"])
 
@@ -422,7 +433,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 +544,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: