folio-migration-tools 1.9.0rc11__py3-none-any.whl → 1.9.0rc13__py3-none-any.whl

folio_migration_tools/__main__.py

@@ -157,7 +157,6 @@ def main():
             print("Task failure. Halting.")
             sys.exit(1)
         logging.info("Work done. Shutting down")
-        sys.exit(0)
     except json.decoder.JSONDecodeError as json_error:
         logging.critical(json_error)
         print(json_error.doc)
@@ -198,7 +197,7 @@ def main():
         logging.exception("Unhandled exception")
         print(f"\n{ee}")
         sys.exit(ee.__class__.__name__)
-
+    sys.exit(0)
 
 def inheritors(base_class):
     subclasses = set()

folio_migration_tools/library_configuration.py

@@ -32,7 +32,27 @@ class FileDefinition(BaseModel):
     ] = ""
     discovery_suppressed: Annotated[bool, Field(title="Discovery suppressed")] = False
     staff_suppressed: Annotated[bool, Field(title="Staff suppressed")] = False
-    service_point_id: Annotated[str, Field(title="Service point ID")] = ""
+    service_point_id: Annotated[
+        str,
+        Field(
+            title="Service point ID",
+            description=(
+                "Service point to be used for "
+                "transactions created from this file (Loans-only)."
+            ),
+        )
+    ] = ""
+    statistical_code: Annotated[
+        str,
+        Field(
+            title="Statistical code",
+            description=(
+                "Statistical code (code) to be used inventory records created from "
+                "this file (Instances, Holdings, Items). Specify multiple codes using "
+                "multi_field_delimiter."
+            ),
+        )
+    ] = ""
     create_source_records: Annotated[
         bool,
         Field(

folio_migration_tools/mapper_base.py

@@ -6,12 +6,13 @@ import sys
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple, Union
 
 import i18n
 from folio_uuid.folio_namespaces import FOLIONamespaces
 from folio_uuid.folio_uuid import FolioUUID
 from folioclient import FolioClient
+from pymarc import Record
 
 from folio_migration_tools.custom_exceptions import (
     TransformationFieldMappingError,
@@ -19,7 +20,8 @@ from folio_migration_tools.custom_exceptions import (
     TransformationRecordFailedError,
 )
 from folio_migration_tools.extradata_writer import ExtradataWriter
-from folio_migration_tools.library_configuration import LibraryConfiguration
+from folio_migration_tools.helper import Helper
+from folio_migration_tools.library_configuration import FileDefinition, LibraryConfiguration
 from folio_migration_tools.mapping_file_transformation.ref_data_mapping import (
     RefDataMapping,
 )
@@ -34,8 +36,9 @@ class MapperBase:
     def __init__(
         self,
         library_configuration: LibraryConfiguration,
+        task_configuration: AbstractTaskConfiguration,
         folio_client: FolioClient,
-        parent_id_map: dict[str, tuple] = {},
+        parent_id_map: Dict[str, Tuple] = {},
     ):
         logging.info("MapperBase initiating")
         self.parent_id_map: dict[str, tuple] = parent_id_map
@@ -43,7 +46,7 @@ class MapperBase:
         self.start_datetime = datetime.now(timezone.utc)
         self.folio_client: FolioClient = folio_client
         self.library_configuration: LibraryConfiguration = library_configuration
-        self.task_configuration: AbstractTaskConfiguration
+        self.task_configuration: AbstractTaskConfiguration = task_configuration
         self.mapped_folio_fields: dict = {}
         self.migration_report: MigrationReport = MigrationReport()
         self.num_criticalerrors = 0
@@ -440,6 +443,74 @@ class MapperBase:
             )
         )
 
+    def map_statistical_codes(self, folio_record: dict, file_def: FileDefinition, legacy_record: Optional[Union[dict, Record]] = None):
+        """Map statistical codes to the folio record.
+
+        This method checks if the file definition contains statistical codes and
+        if so, it splits the codes by the multi-field delimiter and adds them to
+        the folio record's 'statisticalCodeIds' field. If the field does not exist,
+        it initializes it as an empty list before appending the codes.
+
+        Args:
+            folio_record (dict): The FOLIO record to which the statistical codes will be added.
+            file_def (FileDefinition): The file definition containing the statistical codes.
+            legacy_record (Optional[Union[dict, Record]]): The legacy record from which the statistical codes are derived.
+        """
+        if file_def.statistical_code:
+            code_strings = file_def.statistical_code.split(
+                self.library_configuration.multi_field_delimiter
+            )
+            folio_record["statisticalCodeIds"] = folio_record.get("statisticalCodeIds", []) + code_strings
+
+    def setup_statistical_codes_map(self, statistical_codes_map):
+        if statistical_codes_map:
+            self.statistical_codes_mapping = RefDataMapping(
+                self.folio_client,
+                "/statistical-codes",
+                "statisticalCodes",
+                statistical_codes_map,
+                "code",
+                "StatisticalCodeMapping",
+            )
+            logging.info(f"Statistical codes mapping set up {self.statistical_codes_mapping.mapped_legacy_keys}")
+        else:
+            self.statistical_codes_mapping = None
+            logging.info("Statistical codes map is not set up")
+
+    def get_statistical_code(self, legacy_item: dict, folio_prop_name: str, index_or_id):
+        if self.statistical_codes_mapping:
+            return self.get_mapped_ref_data_value(
+                self.statistical_codes_mapping,
+                legacy_item,
+                index_or_id,
+                folio_prop_name,
+                True,
+            )
+        self.migration_report.add(
+            "StatisticalCodeMapping",
+            i18n.t("Mapping not set up"),
+        )
+        return ""
+
+    def map_statistical_code_ids(
+        self, legacy_ids, folio_record: dict
+    ):
+        if stat_codes := {x: None for x in folio_record.pop("statisticalCodeIds", [])}:
+            folio_code_ids = set()
+            for stat_code in stat_codes:
+                if stat_code_id := self.get_statistical_code({"legacy_stat_code": stat_code}, "statisticalCodeId", legacy_ids):
+                    folio_code_ids.add(stat_code_id)
+                else:
+                    Helper.log_data_issue(
+                        legacy_ids,
+                        i18n.t(
+                            "Statistical code '%{code}' not found in FOLIO",
+                            code=stat_code,
+                        ),
+                        stat_code,
+                    )
+            folio_record["statisticalCodeIds"] = list(folio_code_ids)
+
     @property
     def base_string_for_folio_uuid(self):
         if self.library_configuration.use_gateway_url_for_uuids and not self.library_configuration.is_ecs:
@@ -462,6 +533,9 @@ class MapperBase:
             )
         return location_map
 
+    @staticmethod
+    def get_object_type() -> FOLIONamespaces:
+        raise NotImplementedError("This method should be overridden in subclasses")
 
 def flatten(my_dict: dict, path=""):
     for k, v in iter(my_dict.items()):

folio_migration_tools/mapping_file_transformation/courses_mapper.py

@@ -31,13 +31,13 @@ class CoursesMapper(MappingFileMapperBase):
         self.user_cache: dict = {}
         self.notes_mapper: NotesMapper = NotesMapper(
             library_configuration,
+            None,
             self.folio_client,
             course_map,
             FOLIONamespaces.note,
             True,
         )
         self.composite_course_schema = self.get_composite_course_schema()
-        self.task_configuration = task_configuration
         super().__init__(
             folio_client,
             self.composite_course_schema,
@@ -45,6 +45,7 @@ class CoursesMapper(MappingFileMapperBase):
             None,
             FOLIONamespaces.course,
             library_configuration,
+            task_configuration
         )
         self.course_map = course_map
         if terms_map:

folio_migration_tools/mapping_file_transformation/holdings_mapper.py

@@ -15,7 +15,7 @@ from folio_migration_tools.mapping_file_transformation.mapping_file_mapper_base
 from folio_migration_tools.mapping_file_transformation.ref_data_mapping import (
     RefDataMapping,
 )
-
+from folio_migration_tools.task_configuration import AbstractTaskConfiguration
 
 class HoldingsMapper(MappingFileMapperBase):
     def __init__(
@@ -26,6 +26,7 @@ class HoldingsMapper(MappingFileMapperBase):
         call_number_type_map,
         instance_id_map,
         library_configuration: LibraryConfiguration,
+        task_config: AbstractTaskConfiguration,
         statistical_codes_map=None,
     ):
         holdings_schema = folio_client.get_holdings_schema()
@@ -37,6 +38,7 @@ class HoldingsMapper(MappingFileMapperBase):
             statistical_codes_map,
             FOLIONamespaces.holdings,
             library_configuration,
+            task_config
         )
         self.holdings_map = holdings_map
 
@@ -58,8 +60,10 @@ class HoldingsMapper(MappingFileMapperBase):
                 "CallNumberTypeMapping",
             )
 
-    def perform_additional_mappings(self, folio_rec, file_def):
+    def perform_additional_mappings(self, legacy_ids, folio_rec, file_def):
         self.handle_suppression(folio_rec, file_def)
+        self.map_statistical_codes(folio_rec, file_def)
+        self.map_statistical_code_ids(legacy_ids, folio_rec)
 
     def handle_suppression(self, folio_record, file_def: FileDefinition):
         folio_record["discoverySuppress"] = file_def.discovery_suppressed
@@ -73,8 +77,8 @@ class HoldingsMapper(MappingFileMapperBase):
             return self.get_location_id(legacy_item, index_or_id, folio_prop_name)
         elif folio_prop_name == "callNumberTypeId":
             return self.get_call_number_type_id(legacy_item, folio_prop_name, index_or_id)
-        elif folio_prop_name.startswith("statisticalCodeIds"):
-            return self.get_statistical_code(legacy_item, folio_prop_name, index_or_id)
+        # elif folio_prop_name.startswith("statisticalCodeIds"):
+        #     return self.get_statistical_code(legacy_item, folio_prop_name, index_or_id)
 
         mapped_value = super().get_prop(
             legacy_item, folio_prop_name, index_or_id, schema_default_value

folio_migration_tools/mapping_file_transformation/item_mapper.py

@@ -52,8 +52,8 @@ class ItemMapper(MappingFileMapperBase):
             statistical_codes_map,
             FOLIONamespaces.items,
             library_configuration,
+            task_configuration,
         )
-        self.task_configuration = task_configuration
         self.item_schema = self.folio_client.get_item_schema()
         self.items_map = items_map
         self.holdings_id_map = holdings_id_map
@@ -117,8 +117,10 @@ class ItemMapper(MappingFileMapperBase):
             "LocationMapping",
         )
 
-    def perform_additional_mappings(self, folio_rec, file_def):
+    def perform_additional_mappings(self, legacy_ids, folio_rec, file_def):
         self.handle_suppression(folio_rec, file_def)
+        self.map_statistical_codes(folio_rec, file_def)
+        self.map_statistical_code_ids(legacy_ids, folio_rec)
 
     def handle_suppression(self, folio_record, file_def: FileDefinition):
         folio_record["discoverySuppress"] = file_def.discovery_suppressed
@@ -219,15 +221,6 @@ class ItemMapper(MappingFileMapperBase):
             return self.get_mapped_ref_data_value(
                 self.loan_type_mapping, legacy_item, folio_prop_name, index_or_id
             )
-        elif folio_prop_name.startswith("statisticalCodeIds"):
-            statistical_code_id = self.get_statistical_code(
-                legacy_item, folio_prop_name, index_or_id
-            )
-            self.migration_report.add(
-                "StatisticalCodeMapping",
-                f"{folio_prop_name} -> {statistical_code_id}",
-            )
-            return statistical_code_id
 
         mapped_value = super().get_prop(
             legacy_item, folio_prop_name, index_or_id, schema_default_value

folio_migration_tools/mapping_file_transformation/manual_fee_fines_mapper.py

@@ -46,6 +46,7 @@ class ManualFeeFinesMapper(MappingFileMapperBase):
             None,
             FOLIONamespaces.fees_fines,
             library_configuration,
+            task_configuration,
             ignore_legacy_identifier,
         )
 

folio_migration_tools/mapping_file_transformation/mapping_file_mapper_base.py

@@ -20,10 +20,8 @@ from folio_migration_tools.custom_exceptions import (
 )
 from folio_migration_tools.library_configuration import LibraryConfiguration
 from folio_migration_tools.mapper_base import MapperBase
-from folio_migration_tools.mapping_file_transformation.ref_data_mapping import (
-    RefDataMapping,
-)
 from folio_migration_tools.migration_report import MigrationReport
+from folio_migration_tools.task_configuration import AbstractTaskConfiguration
 
 empty_vals = ["Not mapped", None, ""]
 
@@ -37,9 +35,10 @@ class MappingFileMapperBase(MapperBase):
         statistical_codes_map,
         uuid_namespace: UUID,
         library_configuration: LibraryConfiguration,
+        task_config: AbstractTaskConfiguration,
         ignore_legacy_identifier=False,
     ):
-        super().__init__(library_configuration, folio_client)
+        super().__init__(library_configuration, task_config, folio_client)
         self.uuid_namespace = uuid_namespace
         self.ignore_legacy_identifier = ignore_legacy_identifier
         self.schema = schema
@@ -101,21 +100,6 @@ class MappingFileMapperBase(MapperBase):
         )
         csv.register_dialect("tsv", delimiter="\t")
 
-    def setup_statistical_codes_map(self, statistical_codes_map):
-        if statistical_codes_map:
-            self.statistical_codes_mapping = RefDataMapping(
-                self.folio_client,
-                "/statistical-codes",
-                "statisticalCodes",
-                statistical_codes_map,
-                "code",
-                "StatisticalCodeMapping",
-            )
-            logging.info("Statistical codes mapping set up")
-        else:
-            self.statistical_codes_mapping = None
-            logging.info("Statistical codes map is not set up")
-
     def setup_field_map(self, ignore_legacy_identifier):
         field_map = {}  # Map of folio_fields and source fields as an array
         for k in self.record_map["data"]:

folio_migration_tools/mapping_file_transformation/notes_mapper.py

@@ -14,6 +14,7 @@ class NotesMapper(MappingFileMapperBase):
     def __init__(
         self,
         library_configuration: LibraryConfiguration,
+        task_configuration,
         folio_client: FolioClient,
         record_map: dict,
         object_type: FOLIONamespaces,
@@ -28,6 +29,7 @@ class NotesMapper(MappingFileMapperBase):
             None,
             object_type,
             library_configuration,
+            task_configuration,
             ignore_legacy_identifier,
         )
 

folio_migration_tools/mapping_file_transformation/order_mapper.py

@@ -30,6 +30,7 @@ class CompositeOrderMapper(MappingFileMapperBase):
         self,
         folio_client: FolioClient,
         library_configuration: LibraryConfiguration,
+        task_configuration,
         composite_order_map: dict,
         organizations_id_map: dict,
         instance_id_map: dict,
@@ -53,6 +54,7 @@ class CompositeOrderMapper(MappingFileMapperBase):
             None,
             FOLIONamespaces.orders,
             library_configuration,
+            task_configuration,
         )
         logging.info("Loading Instance ID map...")
         self.instance_id_map = instance_id_map
@@ -80,6 +82,7 @@ class CompositeOrderMapper(MappingFileMapperBase):
         self.folio_client: FolioClient = folio_client
         self.notes_mapper: NotesMapper = NotesMapper(
             library_configuration,
+            None,
             self.folio_client,
             composite_order_map,
             FOLIONamespaces.note,
@@ -366,7 +369,7 @@ class CompositeOrderMapper(MappingFileMapperBase):
 
     def perform_additional_mapping(self, index_or_id, composite_order):
         self.validate_po_number(index_or_id, composite_order.get("poNumber"))
-        
+
         # Get organization UUID from FOLIO
         composite_order["vendor"] = self.get_folio_organization_uuid(
             index_or_id, composite_order.get("vendor")

folio_migration_tools/mapping_file_transformation/organization_mapper.py

@@ -23,6 +23,7 @@ class OrganizationMapper(MappingFileMapperBase):
         self,
         folio_client: FolioClient,
         library_configuration: LibraryConfiguration,
+        task_config,
         organization_map: dict,
         organization_types_map,
         address_categories_map,
@@ -43,6 +44,7 @@ class OrganizationMapper(MappingFileMapperBase):
             None,
             FOLIONamespaces.organizations,
             library_configuration,
+            task_config,
         )
         self.organization_schema = organization_schema
         # Set up reference data maps
@@ -56,6 +58,7 @@ class OrganizationMapper(MappingFileMapperBase):
         self.folio_client: FolioClient = folio_client
         self.notes_mapper: NotesMapper = NotesMapper(
             library_configuration,
+            None,
             self.folio_client,
             organization_map,
             FOLIONamespaces.note,
@@ -79,28 +82,28 @@ class OrganizationMapper(MappingFileMapperBase):
                 False,
             )
 
-        elif re.compile("addresses\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
+        elif re.compile(r"addresses\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
             return self.get_mapped_ref_data_value(
                 self.address_categories_map,
                 *value_tuple,
                 False,
             )
 
-        elif re.compile("emails\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
+        elif re.compile(r"emails\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
             return self.get_mapped_ref_data_value(
                 self.email_categories_map,
                 *value_tuple,
                 False,
             )
 
-        elif re.compile("phoneNumbers\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
+        elif re.compile(r"phoneNumbers\[(\d+)\]\.categories\[(\d+)\]").fullmatch(folio_prop_name):
             return self.get_mapped_ref_data_value(
                 self.phone_categories_map,
                 *value_tuple,
                 False,
             )
 
-        elif re.compile("interfaces\[(\d+)\]\.interfaceCredential.interfaceId").fullmatch(
+        elif re.compile(r"interfaces\[(\d+)\]\.interfaceCredential.interfaceId").fullmatch(
             folio_prop_name
         ):
             return "replace_with_interface_id"

folio_migration_tools/mapping_file_transformation/user_mapper.py

@@ -47,10 +47,12 @@ class UserMapper(MappingFileMapperBase):
                 None,
                 FOLIONamespaces.users,
                 library_config,
+                task_config
             )
-            self.task_config = task_config
+            self.task_config = self.task_configuration
             self.notes_mapper: NotesMapper = NotesMapper(
                 self.library_configuration,
+                None,
                 self.folio_client,
                 self.record_map,
                 FOLIONamespaces.users,

folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py

@@ -165,23 +165,16 @@ class HoldingsStatementsParser:
             TransformationFieldMappingError: _description_
         """
         for f in marc_record.get_fields(field_textual):
-            codes = [sf.code for sf in f.subfields]
-            if "a" not in codes and "z" not in codes and "x" not in codes:
-                raise TransformationFieldMappingError(
-                    legacy_ids,
-                    i18n.t(
-                        "%{field} subfields a, x, and z missing from field", field=field_textual
-                    ),
-                    f,
-                )
-            if not (
-                len(f.get_subfields("a")) == 0
-                or len(f.get_subfields("z")) == 0
-                or len(f.get_subfields("x")) == 0
+            if all(
+                [
+                    len("".join(f.get_subfields("a")).strip()) == 0,
+                    len("".join(f.get_subfields("z")).strip()) == 0,
+                    len("".join(f.get_subfields("x")).strip()) == 0,
+                ]
             ):
                 raise TransformationFieldMappingError(
                     legacy_ids,
-                    i18n.t("%{field} a,x and z are all empty", field=field_textual),
+                    i18n.t("%{field} a, x and z are missing or empty", field=field_textual),
                     f,
                 )
             return_dict["statements"].append(

folio_migration_tools/marc_rules_transformation/rules_mapper_authorities.py

@@ -62,6 +62,7 @@ class AuthorityMapper(RulesMapperBase):
             folio_client,
             library_configuration,
             task_configuration,
+            None,
             self.get_authority_json_schema(folio_client, library_configuration),
             Conditions(folio_client, self, "auth", library_configuration.folio_release),
         )

folio_migration_tools/marc_rules_transformation/rules_mapper_base.py

@@ -6,14 +6,14 @@ import urllib.parse
 import uuid
 from abc import abstractmethod
 from textwrap import wrap
-from typing import List, Tuple
+from typing import Dict, List, Tuple
 
 import i18n
 import pymarc
 from dateutil.parser import parse
 from folio_uuid.folio_uuid import FOLIONamespaces, FolioUUID
 from folioclient import FolioClient
-from pymarc import Field, Record, Subfield
+from pymarc import Field, Optional, Record, Subfield
 
 from folio_migration_tools.custom_exceptions import (
     TransformationFieldMappingError,
@@ -35,18 +35,18 @@ class RulesMapperBase(MapperBase):
         folio_client: FolioClient,
         library_configuration: LibraryConfiguration,
         task_configuration,
+        statistical_codes_map: Optional[Dict],
         schema: dict,
         conditions=None,
         parent_id_map: dict[str, tuple] = None,
     ):
-        super().__init__(library_configuration, folio_client, parent_id_map)
+        super().__init__(library_configuration, task_configuration, folio_client, parent_id_map)
         self.parsed_records = 0
         self.id_map: dict[str, tuple] = {}
         self.start = time.time()
         self.last_batch_time = time.time()
         self.folio_client: FolioClient = folio_client
         self.schema: dict = schema
-        self.task_configuration = task_configuration
         self.conditions = conditions
         self.item_json_schema = ""
         self.mappings: dict = {}
@@ -61,6 +61,8 @@ class RulesMapperBase(MapperBase):
                 self.migration_report,
                 self.task_configuration.deactivate035_from001,
             )
+
+        self.setup_statistical_codes_map(statistical_codes_map)
         logging.info("Current user id is %s", self.folio_client.current_user)
 
     def print_progress(self):
@@ -813,6 +815,83 @@ class RulesMapperBase(MapperBase):
             )
         data_import_marc_file.write(marc_record.as_marc())
 
+
+    def map_statistical_codes(
+        self,
+        folio_record: dict,
+        file_def: FileDefinition,
+        marc_record: Record,
+    ):
+        """Map statistical codes to FOLIO instance
+
+        This method first calls the base class method to map statistical codes
+        from the file_def. Then, it checks to see if there are any MARC field
+        mappings defined in the task configuration. If so, it creates a list
+        of lists where the first element is the MARC field tag, and the remaining
+        elements are the subfields to be used for mapping. It then iterates
+        through the MARC fields, retrieves the values based on the subfields.
+        Finally, it adds the mapped codes to the folio_record's statisticalCodeIds.
+
+        Args:
+            legacy_ids (List[str]): The legacy IDs of the folio record
+            folio_record (dict): The Dictionary representation of the FOLIO record
+            marc_record (Record): The pymarc Record object
+            file_def (FileDefinition): The file definition object from which marc_record was read
+        """
+        super().map_statistical_codes(folio_record, file_def)
+        if self.task_configuration.statistical_code_mapping_fields:
+            stat_code_marc_fields = []
+            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
+
+    @staticmethod
+    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.
+        It supports multiple subfields and uses a delimiter to handle concatenated values.
+
+        Args:
+            field_map (List[str]): A list where the first element is the MARC field tag, and the remaining elements are subfields to extract values from.
+            marc_record (Record): The MARC record to process.
+            multi_field_delimiter (str): A delimiter used to concatenate multiple subfield values that should be individual mapped values.
+
+        Returns:
+            str: A string of statistical codes extracted from the MARC field, formatted as "<field>_<subfield>:<value>".
+        """
+        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)
+                )
+            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)
+                        ]
+                    )
+        elif field_map:
+            for mf in marc_record.get_fields(field_map[0]):
+                field_values.append(f"{field_map[0]}:{mf.value()}")
+        return field_values
+
     def save_source_record(
         self,
         srs_records_file,