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

folio_migration_tools/__main__.py

@@ -1,3 +1,4 @@
+from importlib import metadata
 import json
 import logging
 import sys
@@ -38,7 +39,7 @@ def parse_args(args):
         default=environ.get("FOLIO_MIGRATION_TOOLS_TASK_NAME"),
     )
     parser.add_argument(
-        "--okapi_password",
+        "--folio_password", "--okapi_password",
         help="password for the tenant in the configuration file",
         prompt="FOLIO_MIGRATION_TOOLS_OKAPI_PASSWORD" not in environ,
         default=environ.get("FOLIO_MIGRATION_TOOLS_OKAPI_PASSWORD"),
@@ -60,11 +61,17 @@ def parse_args(args):
         default=environ.get("FOLIO_MIGRATION_TOOLS_REPORT_LANGUAGE", "en"),
         prompt=False,
     )
+    parser.add_argument(
+        "--version", "-V",
+        help="Show the version of the FOLIO Migration Tools",
+        action="store_true",
+        prompt=False,
+    )
     return parser.parse_args(args)
 
 def prep_library_config(args):
         config_file_humped = merge_load(args.configuration_path)
-        config_file_humped["libraryInformation"]["okapiPassword"] = args.okapi_password
+        config_file_humped["libraryInformation"]["okapiPassword"] = args.folio_password
         config_file_humped["libraryInformation"]["baseFolder"] = args.base_folder_path
         config_file = humps.decamelize(config_file_humped)
         library_config = LibraryConfiguration(**config_file["library_information"])
@@ -78,11 +85,22 @@ def prep_library_config(args):
             sys.exit("ECS Central Iteration Identifier Not Found")
         return config_file, library_config
 
+def print_version(args):
+    if "-V" in args or "--version" in args:
+        print(
+            f"FOLIO Migration Tools: {metadata.version('folio_migration_tools')}"
+        )
+        sys.exit(0)
+    return None
+
 
 def main():
     try:
         task_classes = list(inheritors(migration_task_base.MigrationTaskBase))
+        # Check if the script is run with the --version or -V flag
+        print_version(sys.argv)
 
+        # Parse command line arguments
         args = parse_args(sys.argv[1:])
         try:
             i18n.load_config(
@@ -124,10 +142,10 @@ def main():
         try:
             logging.getLogger("httpx").setLevel(logging.WARNING) # Exclude info messages from httpx
             with FolioClient(
-                library_config.okapi_url,
+                library_config.gateway_url,
                 library_config.tenant_id,
-                library_config.okapi_username,
-                library_config.okapi_password,
+                library_config.folio_username,
+                library_config.folio_password,
             ) as folio_client:
                 task_config = task_class.TaskConfiguration(**migration_task_config)
                 task_obj = task_class(task_config, library_config, folio_client)

folio_migration_tools/circulation_helper.py

@@ -138,7 +138,7 @@ class CirculationHelper:
         if legacy_loan.proxy_patron_barcode:
             data.update({"proxyUserBarcode": legacy_loan.proxy_patron_barcode})
         path = "/circulation/check-out-by-barcode"
-        url = f"{self.folio_client.okapi_url}{path}"
+        url = f"{self.folio_client.gateway_url}{path}"
         try:
             if legacy_loan.patron_barcode in self.missing_patron_barcodes:
                 error_message = i18n.t("Patron barcode already detected as missing")
@@ -249,7 +249,7 @@ class CirculationHelper:
     ):
         try:
             path = "/circulation/requests"
-            url = f"{folio_client.okapi_url}{path}"
+            url = f"{folio_client.gateway_url}{path}"
             data = legacy_request.serialize()
             data["requestProcessingParameters"] = {
                 "overrideBlocks": {
@@ -313,7 +313,7 @@ class CirculationHelper:
             del loan_to_put["metadata"]
             loan_to_put["dueDate"] = extension_due_date.isoformat()
             loan_to_put["loanDate"] = extend_out_date.isoformat()
-            url = f"{folio_client.okapi_url}/circulation/loans/{loan_to_put['id']}"
+            url = f"{folio_client.gateway_url}/circulation/loans/{loan_to_put['id']}"
 
             req = httpx.put(
                 url, headers=folio_client.okapi_headers, json=loan_to_put, timeout=None

folio_migration_tools/library_configuration.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Annotated, Optional
+from typing import Annotated
 
 from pydantic import BaseModel, Field
 from pydantic.types import DirectoryPath
@@ -68,8 +68,28 @@ class FolioRelease(str, Enum):
 
 
 class LibraryConfiguration(BaseModel):
-    okapi_url: str
-    tenant_id: str
+    gateway_url: Annotated[
+        str,
+        Field(
+            title="FOLIO API Gateway URL",
+            description=(
+                "The URL of the FOLIO API gateway instance. "
+                "You can find this in Settings > Software versions > API gateway services."
+            ),
+            alias="okapi_url"
+        ),
+    ]
+    tenant_id: Annotated[
+        str,
+        Field(
+            title="FOLIO tenant ID",
+            description=(
+                "The ID of the FOLIO tenant instance. "
+                "You can find this in Settings > Software versions > API gateway services. "
+                "In an ECS environment, this is the ID of the central tenant, for all configurations."
+            ),
+        ),
+    ]
     ecs_tenant_id: Annotated[
         str,
         Field(
@@ -80,15 +100,43 @@ class LibraryConfiguration(BaseModel):
             ),
         ),
     ] = ""
-    okapi_username: str
-    okapi_password: str
+    folio_username: Annotated[
+        str,
+        Field(
+            title="FOLIO API Gateway username",
+            description=(
+                "The username for the FOLIO user account performing the migration. "
+                "User should have a full admin permissions/roles in FOLIO. "
+            ),
+            alias="okapi_username"
+        ),
+    ]
+    folio_password: Annotated[
+        str,
+        Field(
+            title="FOLIO API Gateway password",
+            description=(
+                "The password for the FOLIO user account performing the migration. "
+            ),
+            alias="okapi_password"
+        )
+    ]
     base_folder: DirectoryPath = Field(
         description=(
             "The base folder for migration. "
             "Should ideally be a github clone of the migration_repo_template"
         )
     )
-    multi_field_delimiter: Optional[str] = "<delimiter>"
+    multi_field_delimiter: Annotated[
+        str,
+        Field(
+            title="Multi field delimiter",
+            description=(
+                "The delimiter used to separate multiple values in a single field. "
+                "This is used for delimited text (CSV/TSV) fields with multiple sub-delimited values."
+            ),
+        ),
+    ] = "<delimiter>"
     failed_records_threshold: Annotated[
         int,
         Field(description=("Number of failed records until the process shuts down")),

folio_migration_tools/mapper_base.py

@@ -272,7 +272,7 @@ class MapperBase:
             [
                 object_type == FOLIONamespaces.instances,
                 (not getattr(self.task_configuration, "data_import_marc", False)),
-                getattr(self.task_configuration, "create_source_records", True),
+                getattr(self, "create_source_records", True),
             ]
         ):
             return (legacy_id, folio_record["id"], folio_record["hrid"])
@@ -443,7 +443,7 @@ class MapperBase:
     @property
     def base_string_for_folio_uuid(self):
         if self.library_configuration.use_gateway_url_for_uuids and not self.library_configuration.is_ecs:
-            return str(self.folio_client.okapi_url)
+            return str(self.folio_client.gateway_url)
         elif self.library_configuration.ecs_tenant_id:
             return str(self.library_configuration.ecs_tenant_id)
         else:

folio_migration_tools/marc_rules_transformation/hrid_handler.py

@@ -160,7 +160,7 @@ class HRIDHandler:
             self.hrid_settings["instances"]["startNumber"] = self.instance_hrid_counter
             self.hrid_settings["holdings"]["startNumber"] = self.holdings_hrid_counter
             self.hrid_settings["items"]["startNumber"] = self.items_hrid_counter
-            url = self.folio_client.okapi_url + self.hrid_path
+            url = self.folio_client.gateway_url + self.hrid_path
             resp = httpx.put(
                 url,
                 json=self.hrid_settings,

folio_migration_tools/marc_rules_transformation/marc_file_processor.py

@@ -3,7 +3,7 @@ import os
 import sys
 import time
 import traceback
-from typing import List
+from typing import BinaryIO, Dict, List, Set, TextIO
 
 import i18n
 from folio_uuid.folio_namespaces import FOLIONamespaces
@@ -24,24 +24,26 @@ from folio_migration_tools.migration_report import MigrationReport
 
 class MarcFileProcessor:
     def __init__(
-        self, mapper: RulesMapperBase, folder_structure: FolderStructure, created_objects_file
+        self, mapper: RulesMapperBase, folder_structure: FolderStructure, created_objects_file: TextIO
     ):
         self.object_type: FOLIONamespaces = folder_structure.object_type
         self.folder_structure: FolderStructure = folder_structure
         self.mapper: RulesMapperBase = mapper
-        self.created_objects_file = created_objects_file
-        if mapper.task_configuration.create_source_records:
-            self.srs_records_file = open(self.folder_structure.srs_records_path, "w+")
+        self.created_objects_file: TextIO = created_objects_file
+        if mapper.create_source_records and any(
+            x.create_source_records for x in mapper.task_configuration.files
+        ):
+            self.srs_records_file: TextIO = open(self.folder_structure.srs_records_path, "w+")
         if getattr(mapper.task_configuration, "data_import_marc", False):
-            self.data_import_marc_file = open(self.folder_structure.data_import_marc_path, "wb+")
-        self.unique_001s: set = set()
+            self.data_import_marc_file: BinaryIO = open(self.folder_structure.data_import_marc_path, "wb+")
+        self.unique_001s: Set[str] = set()
         self.failed_records_count: int = 0
         self.records_count: int = 0
         self.start: float = time.time()
-        self.legacy_ids: set = set()
+        self.legacy_ids: Set[str] = set()
         if (
             self.object_type == FOLIONamespaces.holdings
-            and self.mapper.task_configuration.create_source_records
+            and self.mapper.create_source_records
         ):
             logging.info("Loading Parent HRID map for SRS creation")
             self.parent_hrids = {entity[1]: entity[2] for entity in mapper.parent_id_map.values()}
@@ -78,7 +80,7 @@ class MarcFileProcessor:
 
                     if (
                         file_def.create_source_records
-                        and self.mapper.task_configuration.create_source_records
+                        and self.mapper.create_source_records
                     ):
                         self.save_srs_record(
                             marc_record,
@@ -132,7 +134,7 @@ class MarcFileProcessor:
     def save_marc_record(
         self,
         marc_record: Record,
-        folio_rec: dict,
+        folio_rec: Dict,
         object_type: FOLIONamespaces
     ):
         self.mapper.save_data_import_marc_record(
@@ -146,14 +148,10 @@ class MarcFileProcessor:
         self,
         marc_record: Record,
         file_def: FileDefinition,
-        folio_rec,
+        folio_rec: Dict,
         legacy_ids: List[str],
         object_type: FOLIONamespaces,
     ):
-        if not all(
-            [file_def.create_source_records, self.mapper.task_configuration.create_source_records]
-        ):
-            return
         if object_type in [FOLIONamespaces.holdings]:
             if "008" in marc_record and len(marc_record["008"].data) > 32:
                 remain, rest = (
@@ -188,7 +186,7 @@ class MarcFileProcessor:
         )
         self.mapper.migration_report.add_general_statistics(i18n.t("SRS records written to disk"))
 
-    def add_mapped_location_code_to_record(self, marc_record, folio_rec):
+    def add_mapped_location_code_to_record(self, marc_record: Record, folio_rec: Dict):
         location_code = next(
             (
                 location["code"]
@@ -225,9 +223,9 @@ class MarcFileProcessor:
 
     @staticmethod
     def get_valid_folio_record_ids(
-        legacy_ids, folio_record_identifiers, migration_report: MigrationReport
-    ):
-        new_ids = set()
+        legacy_ids: List[str], folio_record_identifiers: Set[str], migration_report: MigrationReport
+    ) -> List[str]:
+        new_ids: Set[str] = set()
         for legacy_id in legacy_ids:
             if legacy_id not in folio_record_identifiers:
                 new_ids.add(legacy_id)
@@ -266,12 +264,12 @@ class MarcFileProcessor:
                 self.mapper.mapped_folio_fields,
                 self.mapper.mapped_legacy_fields,
             )
-        if self.mapper.task_configuration.create_source_records:
+        if hasattr(self, "srs_records_file"):
             self.srs_records_file.seek(0)
             if not self.srs_records_file.seek(0):
                 os.remove(self.srs_records_file.name)
             self.srs_records_file.close()
-        if getattr(self.mapper.task_configuration, "data_import_marc", False):
+        if hasattr(self, "data_import_marc_file"):
             self.data_import_marc_file.seek(0)
             if not self.data_import_marc_file.read(1):
                 os.remove(self.data_import_marc_file.name)
@@ -281,7 +279,7 @@ class MarcFileProcessor:
         logging.info("Transformation report written to %s", report_file.name)
         logging.info("Processor is done.")
 
-    def add_legacy_ids_to_map(self, folio_rec, filtered_legacy_ids):
+    def add_legacy_ids_to_map(self, folio_rec: Dict, filtered_legacy_ids: List[str]):
         for legacy_id in filtered_legacy_ids:
             self.legacy_ids.add(legacy_id)
             if legacy_id not in self.mapper.id_map:

folio_migration_tools/marc_rules_transformation/rules_mapper_base.py

@@ -51,6 +51,9 @@ class RulesMapperBase(MapperBase):
         self.item_json_schema = ""
         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))]
+        )
         if hasattr(self.task_configuration, "hrid_handling"):
             self.hrid_handler = HRIDHandler(
                 folio_client,

folio_migration_tools/marc_rules_transformation/rules_mapper_bibs.py

@@ -7,7 +7,7 @@ import time
 import typing
 import uuid
 from pathlib import Path
-from typing import Generator, List
+from typing import Dict, Generator, List
 
 import i18n
 import pymarc
@@ -16,6 +16,7 @@ from folio_uuid.folio_namespaces import FOLIONamespaces
 from folio_uuid.folio_uuid import FolioUUID
 from folioclient import FolioClient
 from pymarc.record import Leader, Record
+from pymarc.field import Field
 
 from folio_migration_tools.custom_exceptions import (
     TransformationProcessError,
@@ -32,6 +33,7 @@ from folio_migration_tools.marc_rules_transformation.conditions import Condition
 from folio_migration_tools.marc_rules_transformation.rules_mapper_base import (
     RulesMapperBase,
 )
+from folio_migration_tools.migration_tasks.migration_task_base import MarcTaskConfigurationBase
 
 
 class BibsRulesMapper(RulesMapperBase):
@@ -40,9 +42,9 @@ class BibsRulesMapper(RulesMapperBase):
 
     def __init__(
         self,
-        folio_client,
+        folio_client: FolioClient,
         library_configuration: LibraryConfiguration,
-        task_configuration,
+        task_configuration: MarcTaskConfigurationBase,
     ):
         super().__init__(
             folio_client,
@@ -59,15 +61,12 @@ class BibsRulesMapper(RulesMapperBase):
         self.instance_relationships: dict = {}
         self.instance_relationship_types: dict = {}
         self.other_mode_of_issuance_id = get_unspecified_mode_of_issuance(self.folio_client)
-        self.create_source_records = all(
-            [self.task_configuration.create_source_records, (not getattr(self.task_configuration, "data_import_marc", False))]
-        )
         self.data_import_marc = self.task_configuration.data_import_marc
         if self.data_import_marc:
             self.hrid_handler.deactivate035_from001 = True
         self.start = time.time()
 
-    def perform_initial_preparation(self, marc_record: pymarc.Record, legacy_ids):
+    def perform_initial_preparation(self, file_def: FileDefinition, marc_record: Record, legacy_ids: List[str]):
         folio_instance = {}
         folio_instance["id"] = str(
             FolioUUID(
@@ -76,7 +75,10 @@ class BibsRulesMapper(RulesMapperBase):
                 str(legacy_ids[-1]),
             )
         )
-        if self.create_source_records or self.hrid_handler.handling == HridHandling.preserve001:
+        if (
+            all([self.create_source_records, file_def.create_source_records])
+            or self.hrid_handler.handling == HridHandling.preserve001
+        ):
             self.hrid_handler.handle_hrid(
                 FOLIONamespaces.instances,
                 folio_instance,
@@ -90,7 +92,7 @@ class BibsRulesMapper(RulesMapperBase):
 
         return folio_instance
 
-    def handle_leader_05(self, marc_record, legacy_ids):
+    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}")
         if leader_05 not in ["a", "c", "d", "n", "p"]:
@@ -102,14 +104,14 @@ class BibsRulesMapper(RulesMapperBase):
             Helper.log_data_issue(legacy_ids, "d in leader. Is this correct?", marc_record.leader)
 
     def parse_record(
-        self, marc_record: pymarc.Record, file_def: FileDefinition, legacy_ids: List[str]
+        self, marc_record: Record, file_def: FileDefinition, legacy_ids: List[str]
     ) -> list[dict]:
         """Parses a bib recod into a FOLIO Inventory instance object
         Community mapping suggestion: https://bit.ly/2S7Gyp3
          This is the main function
 
         Args:
-            marc_record (pymarc.Record): _description_
+            marc_record (Record): _description_
             file_def (FileDefinition): _description_
             legacy_ids (List[str]): List of legacy ids in record
 
@@ -119,7 +121,7 @@ class BibsRulesMapper(RulesMapperBase):
         self.print_progress()
         ignored_subsequent_fields: set = set()
         bad_tags = set(self.task_configuration.tags_to_delete)  # "907"
-        folio_instance = self.perform_initial_preparation(marc_record, legacy_ids)
+        folio_instance = self.perform_initial_preparation(file_def, marc_record, legacy_ids)
         if self.data_import_marc:
             self.simple_bib_map(folio_instance, marc_record, ignored_subsequent_fields, legacy_ids)
         else:
@@ -155,6 +157,19 @@ class BibsRulesMapper(RulesMapperBase):
             legacy_ids (List[str]): _description_
             file_def (FileDefinition): _description_
         """
+        main_entry_field_tags = ["100", "110", "111", "130"]
+        main_entry_fields = marc_record.get_fields(*main_entry_field_tags)
+        main_entry_fields.sort(key=lambda x: int(x.tag))
+        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.",
+                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))
+        self.process_marc_field(folio_instnace, main_entry_fields[0], ignored_subsequent_fields, legacy_ids)
         try:
             self.process_marc_field(folio_instnace, marc_record['245'], ignored_subsequent_fields, legacy_ids)
         except KeyError:
@@ -178,7 +193,7 @@ class BibsRulesMapper(RulesMapperBase):
             legacy_ids (List[str]): _description_
             file_def (FileDefinition): _description_
         """
-        if file_def.create_source_records and self.task_configuration.create_source_records:
+        if file_def.create_source_records and self.create_source_records:
             folio_instance["source"] = "MARC"
         else:
             folio_instance["source"] = "FOLIO"
@@ -198,7 +213,7 @@ class BibsRulesMapper(RulesMapperBase):
             del folio_instance["succeedingTitles"]
             self.migration_report.add("PrecedingSuccedingTitles", f"{len(succ_titles)}")
 
-    def handle_languages(self, folio_instance, marc_record, legacy_ids):
+    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(
@@ -255,7 +270,7 @@ class BibsRulesMapper(RulesMapperBase):
             if self.task_configuration.update_hrid_settings:
                 self.hrid_handler.store_hrid_settings()
 
-    def get_instance_type_id(self, marc_record, legacy_id):
+    def get_instance_type_id(self, marc_record: Record, legacy_ids: List[str]) -> str:
         return_id = ""
 
         def get_folio_id_by_name(f336a: str):
@@ -283,7 +298,7 @@ class BibsRulesMapper(RulesMapperBase):
                     + f" ({f336a})",
                 )
                 Helper.log_data_issue(
-                    legacy_id,
+                    legacy_ids,
                     "instance type name (336$a) -Unsuccessful matching",
                     f336a,
                 )
@@ -316,7 +331,7 @@ class BibsRulesMapper(RulesMapperBase):
                     ),
                 )
                 Helper.log_data_issue(
-                    legacy_id,
+                    legacy_ids,
                     i18n.t("instance type code (%{code}) not found in FOLIO", code="336$b"),
                     f336_b,
                 )
@@ -337,7 +352,7 @@ class BibsRulesMapper(RulesMapperBase):
             return_id = t[0]
         return return_id
 
-    def get_instance_format_id_by_code(self, legacy_id: str, code: str):
+    def get_instance_format_id_by_code(self, legacy_ids: List[str], code: str):
         try:
             match = next(f for f in self.folio_client.instance_formats if f["code"] == code)
             self.migration_report.add(
@@ -347,14 +362,14 @@ class BibsRulesMapper(RulesMapperBase):
             return match["id"]
         except Exception:
             # TODO: Distinguish between generated codes and proper 338bs
-            Helper.log_data_issue(legacy_id, "Instance format Code not found in FOLIO", code)
+            Helper.log_data_issue(legacy_ids, "Instance format Code not found in FOLIO", code)
             self.migration_report.add(
                 "InstanceFormat",
                 i18n.t("Code '%{code}' not found in FOLIO", code=code),
             )
             return ""
 
-    def get_instance_format_id_by_name(self, f337a: str, f338a: str, legacy_id: str):
+    def get_instance_format_id_by_name(self, f337a: str, f338a: str, legacy_ids: List[str]):
         f337a = f337a.lower().strip()
         f338a = f338a.lower().strip()
         match_template = f"{f337a} -- {f338a}"
@@ -376,7 +391,7 @@ class BibsRulesMapper(RulesMapperBase):
             return match["id"]
         except Exception:
             Helper.log_data_issue(
-                legacy_id,
+                legacy_ids,
                 "Unsuccessful matching on 337$a and 338$a",
                 match_template,
             )
@@ -391,7 +406,7 @@ class BibsRulesMapper(RulesMapperBase):
             )
             return ""
 
-    def f338_source_is_rda_carrier(self, field: pymarc.Field):
+    def f338_source_is_rda_carrier(self, field: Field):
         if "2" not in field:
             self.migration_report.add(
                 "InstanceFormat",
@@ -407,7 +422,7 @@ class BibsRulesMapper(RulesMapperBase):
         return False
 
     def get_instance_format_ids_from_a(
-        self, field_index, f_338: pymarc.Field, all_337s, legacy_id
+        self, field_index: int, f_338: Field, all_337s: List[Field], legacy_id: List[str]
     ):
         self.migration_report.add(
             "InstanceFormat",
@@ -421,7 +436,7 @@ class BibsRulesMapper(RulesMapperBase):
                 ):
                     yield fmt_id
 
-    def get_instance_format_ids(self, marc_record, legacy_id):
+    def get_instance_format_ids(self, marc_record: Record, legacy_id: List[str]):
         all_337s = marc_record.get_fields("337")
         all_338s = marc_record.get_fields("338")
         for fidx, f_338 in enumerate(all_338s):
@@ -466,7 +481,7 @@ class BibsRulesMapper(RulesMapperBase):
                                         legacy_id, combined_code
                                     )
 
-    def get_mode_of_issuance_id(self, marc_record: Record, legacy_id: List[str]) -> str:
+    def get_mode_of_issuance_id(self, marc_record: Record, legacy_ids: List[str]) -> str:
         level = marc_record.leader[7]
         try:
             name = "unspecified"
@@ -496,7 +511,7 @@ class BibsRulesMapper(RulesMapperBase):
             return ret
         except IndexError:
             self.migration_report.add(
-                "PossibleCleaningTasks", i18n.t("No Leader[7] in") + f" {legacy_id}"
+                "PossibleCleaningTasks", i18n.t("No Leader[7] in") + f" {legacy_ids}"
             )
 
             return self.other_mode_of_issuance_id
@@ -512,7 +527,7 @@ class BibsRulesMapper(RulesMapperBase):
             return "".join(marc_record["008"].data[35:38])
         return ""
 
-    def get_languages_041(self, marc_record, legacy_id):
+    def get_languages_041(self, marc_record: Record, legacy_id: List[str]) -> Dict[str, None]:
         languages = dict()
         lang_fields = marc_record.get_fields("041")
         if not any(lang_fields):
@@ -543,21 +558,21 @@ class BibsRulesMapper(RulesMapperBase):
         }
         return languages
 
-    def get_languages(self, marc_record: Record, legacy_id: str) -> List[str]:
+    def get_languages(self, marc_record: Record, legacy_id: List[str]) -> List[str]:
         """Get languages and tranforms them to correct codes
 
         Args:
-            marc_record (Record): _description_
-            legacy_id (str): _description_
+            marc_record (Record): A pymarc Record object
+            legacy_id (List[str]): A list of legacy ids from the legacy record
 
         Returns:
-            List[str]: _description_
+            List[str]: List of language codes
         """
         languages = self.get_languages_041(marc_record, legacy_id)
         languages[self.get_languages_008(marc_record)] = None
-        for lang in languages.keys():
+        for lang in languages:
             self.migration_report.add("LanguagesInRecords", lang)
-        return list(languages.keys())
+        return list(languages)
 
     def fetch_language_codes(self) -> Generator[str, None, None]:
         """Loads the  list of standardized language codes from LoC
@@ -575,7 +590,7 @@ class BibsRulesMapper(RulesMapperBase):
             yield code.text
 
     def filter_langs(
-        self, language_values: List[str], marc_record: Record, index_or_legacy_id
+        self, language_values: List[str], marc_record: Record, index_or_legacy_id: List[str]
     ) -> typing.Generator:
         forbidden_values = ["###", "zxx", "n/a", "N/A", "|||"]
         for language_value in language_values:
@@ -629,7 +644,7 @@ class BibsRulesMapper(RulesMapperBase):
         else:
             raise TransformationProcessError("", f"ILS {ils_flavour} not configured")
 
-    def get_aleph_bib_id(self, marc_record: Record):
+    def get_aleph_bib_id(self, marc_record: Record) -> List[str]:
         res = {f["b"].strip(): None for f in marc_record.get_fields("998") if "b" in f}
         if any(res):
             self.migration_report.add_general_statistics(
@@ -651,7 +666,7 @@ class BibsRulesMapper(RulesMapperBase):
                 ) from e
 
 
-def get_unspecified_mode_of_issuance(folio_client: FolioClient):
+def get_unspecified_mode_of_issuance(folio_client: FolioClient) -> str:
     m_o_is = list(folio_client.modes_of_issuance)
     if not any(m_o_is):
         logging.critical("No Modes of issuance set up in tenant. Quitting...")
@@ -684,7 +699,7 @@ def get_custom_bib_id(marc_record: Record, field_string: str):
         )
 
 
-def get_iii_bib_id(marc_record: Record):
+def get_iii_bib_id(marc_record: Record) -> List[str]:
     try:
         return [marc_record["907"]["a"]]
     except Exception as e: