folio-migration-tools 1.2.1__py3-none-any.whl → 1.9.10__py3-none-any.whl

folio_migration_tools/marc_rules_transformation/marc_file_processor.py

@@ -0,0 +1,300 @@
+import logging
+import os
+import sys
+import time
+import traceback
+from typing import BinaryIO, Dict, List, Set, TextIO
+
+import i18n
+from folio_uuid.folio_namespaces import FOLIONamespaces
+from pymarc import Field, Record, Subfield
+
+from folio_migration_tools.custom_exceptions import (
+    TransformationProcessError,
+    TransformationRecordFailedError,
+)
+from folio_migration_tools.folder_structure import FolderStructure
+from folio_migration_tools.helper import Helper
+from folio_migration_tools.library_configuration import FileDefinition, HridHandling
+from folio_migration_tools.marc_rules_transformation.rules_mapper_base import (
+    RulesMapperBase,
+)
+from folio_migration_tools.migration_report import MigrationReport
+
+
+class MarcFileProcessor:
+    def __init__(
+        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: 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: 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[str] = set()
+        if (
+            self.object_type == FOLIONamespaces.holdings
+            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()}
+
+    def process_record(self, idx: int, marc_record: Record, file_def: FileDefinition):
+        """processes a marc holdings record and saves it
+
+        Args:
+            idx (int): Index in file being parsed
+            marc_record (Record): _description_
+            file_def (FileDefinition): _description_
+
+        Raises:
+            TransformationProcessError: _description_
+            TransformationRecordFailedError: _description_
+        """
+        success = True
+        folio_recs = []
+        self.records_count += 1
+        try:
+            # Transform the MARC21 to a FOLIO record
+            try:
+                legacy_ids = self.mapper.get_legacy_ids(marc_record, idx)
+            except ValueError as e:
+                raise TransformationRecordFailedError(
+                    f"{idx} in {file_def.file_name}", str(e), idx
+                ) from e
+            if not legacy_ids:
+                raise TransformationRecordFailedError(
+                    f"Index in file: {idx}", "No legacy id found", idx
+                )
+            folio_recs = self.mapper.parse_record(marc_record, file_def, legacy_ids)
+            for idx, folio_rec in enumerate(folio_recs):
+                if idx == 0:
+                    filtered_legacy_ids = self.get_valid_folio_record_ids(
+                        legacy_ids, self.legacy_ids, self.mapper.migration_report
+                    )
+                    self.add_legacy_ids_to_map(folio_rec, filtered_legacy_ids)
+
+                    if (
+                        file_def.create_source_records
+                        and self.mapper.create_source_records
+                    ):
+                        self.save_srs_record(
+                            marc_record,
+                            file_def,
+                            folio_rec,
+                            legacy_ids,
+                            self.object_type,
+                        )
+                    if getattr(self.mapper.task_configuration, "data_import_marc", False):
+                        self.save_marc_record(
+                            marc_record,
+                            folio_rec,
+                            self.object_type
+                        )
+                Helper.write_to_file(self.created_objects_file, folio_rec)
+                self.mapper.migration_report.add_general_statistics(
+                    i18n.t("Inventory records written to disk")
+                )
+                self.exit_on_too_many_exceptions()
+
+        except TransformationRecordFailedError as error:
+            success = False
+            raise TransformationRecordFailedError(
+                f"{error.index_or_id} in {file_def.file_name}", error.message, error.data_value
+            ) from error
+        except TransformationProcessError as tpe:
+            raise TransformationProcessError(
+                f"{tpe.index_or_id} in {file_def.file_name}", tpe.message, tpe.data_value
+            ) from tpe
+        except Exception as inst:
+            success = False
+            traceback.print_exc()
+            logging.error(type(inst))
+            logging.error(inst.args)
+            logging.error(inst)
+            logging.error(marc_record)
+            logging.error(folio_recs)
+            raise TransformationProcessError("", inst.args, "") from inst
+        finally:
+            if not success:
+                self.failed_records_count += 1
+                remove_from_id_map = getattr(self.mapper, "remove_from_id_map", None)
+                for folio_rec in folio_recs:
+                    if (
+                        callable(remove_from_id_map)
+                        and "folio_rec" in locals()
+                        and folio_rec.get("formerIds", "")
+                    ):
+                        self.mapper.remove_from_id_map(folio_rec.get("formerIds", []))
+
+    def save_marc_record(
+        self,
+        marc_record: Record,
+        folio_rec: Dict,
+        object_type: FOLIONamespaces
+    ):
+        self.mapper.save_data_import_marc_record(
+            self.data_import_marc_file,
+            object_type,
+            marc_record,
+            folio_rec,
+        )
+
+    def save_srs_record(
+        self,
+        marc_record: Record,
+        file_def: FileDefinition,
+        folio_rec: Dict,
+        legacy_ids: List[str],
+        object_type: FOLIONamespaces,
+    ):
+        if object_type in [FOLIONamespaces.holdings]:
+            if "008" in marc_record and len(marc_record["008"].data) > 32:
+                remain, rest = (
+                    marc_record["008"].data[:32],
+                    marc_record["008"].data[32:],
+                )
+                marc_record["008"].data = remain
+                self.mapper.migration_report.add(
+                    "MarcValidation",
+                    i18n.t("008 length invalid. '%{rest}' was stripped out", rest=rest),
+                )
+            self.add_mapped_location_code_to_record(marc_record, folio_rec)
+            new_004 = Field(tag="004", data=self.parent_hrids[folio_rec["instanceId"]])
+            marc_record.remove_fields("004")
+            marc_record.add_ordered_field(new_004)
+            for former_id in legacy_ids:
+                if self.mapper.task_configuration.hrid_handling == HridHandling.default:
+                    new_035 = Field(
+                        tag="035",
+                        indicators=[" ", " "],
+                        subfields=[Subfield(code="a", value=former_id)],
+                    )
+                    marc_record.add_ordered_field(new_035)
+        self.mapper.save_source_record(
+            self.srs_records_file,
+            self.object_type,
+            self.mapper.folio_client,
+            marc_record,
+            folio_rec,
+            legacy_ids,
+            file_def.discovery_suppressed,
+        )
+        self.mapper.migration_report.add_general_statistics(i18n.t("SRS records written to disk"))
+
+    def add_mapped_location_code_to_record(self, marc_record: Record, folio_rec: Dict):
+        location_code = next(
+            (
+                location["code"]
+                for location in self.mapper.folio_client.locations
+                if location["id"] == folio_rec["permanentLocationId"]
+            ),
+            None,
+        )
+        if "852" not in marc_record:
+            raise TransformationRecordFailedError(
+                "", "No 852 in record when storing new location code", ""
+            )
+        first_852 = marc_record.get_fields("852")[0]
+        first_852.delete_subfield("b")
+        while old_b := first_852.delete_subfield("b"):
+            first_852.add_subfield("x", old_b, 0)
+            self.mapper.migration_report.add(
+                "LocationMapping", i18n.t("Additional 852$b was moved to 852$x")
+            )
+        first_852.add_subfield("b", location_code, 0)
+        self.mapper.migration_report.add(
+            "LocationMapping", i18n.t("Set 852 to FOLIO location code")
+        )
+
+    def exit_on_too_many_exceptions(self):
+        if (
+            self.failed_records_count / (self.records_count + 1)
+            > (self.mapper.library_configuration.failed_percentage_threshold / 100)
+            and self.failed_records_count
+            > self.mapper.library_configuration.failed_records_threshold
+        ):
+            logging.critical("More than 20 percent of the records have failed. Halting")
+            sys.exit(1)
+
+    @staticmethod
+    def get_valid_folio_record_ids(
+        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)
+            else:
+                migration_report.add_general_statistics(
+                    i18n.t("Duplicate MARC record identifiers ")
+                )
+        if not any(new_ids):
+            s = i18n.t("Failed records. No unique record identifiers in legacy record")
+            migration_report.add_general_statistics(s)
+            raise TransformationRecordFailedError(
+                "-".join(legacy_ids),
+                "Duplicate recod identifier(s). See logs. Record Failed",
+                "-".join(legacy_ids),
+            )
+        return list(new_ids)
+
+    def wrap_up(self):
+        """Finalizes the mapping by writing things out."""
+        logging.info(
+            "Saving map of %s old and new IDs to %s",
+            len(self.mapper.id_map),
+            self.folder_structure.id_map_path,
+        )
+        self.mapper.save_id_map_file(self.folder_structure.id_map_path, self.mapper.id_map)
+        logging.info("%s records processed", self.records_count)
+        with open(self.folder_structure.migration_reports_file, "w+") as report_file:
+            self.mapper.migration_report.write_migration_report(
+                i18n.t("MFHD records transformation report"),
+                report_file,
+                self.mapper.start_datetime,
+            )
+            Helper.print_mapping_report(
+                report_file,
+                self.mapper.parsed_records,
+                self.mapper.mapped_folio_fields,
+                self.mapper.mapped_legacy_fields,
+            )
+        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 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)
+            self.data_import_marc_file.close()
+        self.mapper.wrap_up()
+
+        logging.info("Transformation report written to %s", report_file.name)
+        logging.info("Processor is done.")
+
+    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:
+                self.mapper.id_map[legacy_id] = self.mapper.get_id_map_tuple(
+                    legacy_id, folio_rec, self.object_type
+                )
+
+            else:
+                raise TransformationRecordFailedError(
+                    legacy_id,
+                    "Legacy ID already added to Legacy Id map.",
+                    ",".join(filtered_legacy_ids),
+                )

folio_migration_tools/marc_rules_transformation/marc_reader_wrapper.py

@@ -0,0 +1,136 @@
+import logging
+import sys
+from io import IOBase
+from pathlib import Path
+
+import i18n
+from pymarc import Leader, MARCReader, Record
+
+from folio_migration_tools.custom_exceptions import (
+    TransformationProcessError,
+    TransformationRecordFailedError,
+)
+from folio_migration_tools.folder_structure import FolderStructure
+from folio_migration_tools.library_configuration import FileDefinition
+from folio_migration_tools.marc_rules_transformation.marc_file_processor import (
+    MarcFileProcessor,
+)
+from folio_migration_tools.migration_report import MigrationReport
+
+
+class MARCReaderWrapper:
+    @staticmethod
+    def process_single_file(
+        file_def: FileDefinition,
+        processor,
+        failed_records_path: Path,
+        folder_structure: FolderStructure,
+    ):
+        try:
+            with open(failed_records_path, "ab") as failed_marc_records_file:
+                with open(
+                    folder_structure.legacy_records_folder / file_def.file_name,
+                    "rb",
+                ) as marc_file:
+                    reader = MARCReader(marc_file, to_unicode=True, permissive=True)
+                    reader.hide_utf8_warnings = True
+                    reader.force_utf8 = False
+                    logging.info("Running %s", file_def.file_name)
+                    MARCReaderWrapper.read_records(
+                        reader, file_def, failed_marc_records_file, processor
+                    )
+        except TransformationProcessError as tpe:
+            logging.critical(tpe)
+            sys.exit(1)
+        except Exception:
+            logging.exception("Failure in Main: %s", file_def.file_name, stack_info=True)
+
+    @staticmethod
+    def read_records(
+        reader,
+        source_file: FileDefinition,
+        failed_records_file: IOBase,
+        processor: MarcFileProcessor,
+    ):
+        for idx, record in enumerate(reader):
+            processor.mapper.migration_report.add_general_statistics(
+                i18n.t("Records in file before parsing")
+            )
+            try:
+                # None = Something bad happened
+                if record is None:
+                    report_failed_parsing(
+                        reader,
+                        source_file,
+                        failed_records_file,
+                        idx,
+                        processor.mapper.migration_report,
+                    )
+                # The normal case
+                else:
+                    MARCReaderWrapper.set_leader(record, processor.mapper.migration_report)
+                    processor.mapper.migration_report.add_general_statistics(
+                        i18n.t("Records successfully decoded from MARC21"),
+                    )
+                    processor.process_record(idx, record, source_file)
+            except TransformationRecordFailedError as error:
+                error.log_it()
+                processor.mapper.migration_report.add_general_statistics(
+                    i18n.t("Records that failed transformation. Check log for details"),
+                )
+            except ValueError as error:
+                logging.error(error)
+        logging.info("Done reading %s records from file", idx + 1)
+
+    @staticmethod
+    def set_leader(marc_record: Record, migration_report: MigrationReport):
+        if marc_record.leader[9] != "a":
+            migration_report.add(
+                "LeaderManipulation",
+                i18n.t(
+                    "Set leader 09 (Character coding scheme) from %{field} to a",
+                    field=marc_record.leader[9],
+                ),
+            )
+            marc_record.leader = Leader(f"{marc_record.leader[:9]}a{marc_record.leader[10:]}")
+
+        if not str(marc_record.leader).endswith("4500"):
+            migration_report.add(
+                "LeaderManipulation",
+                i18n.t("Set leader 20-23 from %{field} to 4500", field=marc_record.leader[-4:]),
+            )
+            marc_record.leader = Leader(f"{marc_record.leader[:-4]}4500")
+
+        if marc_record.leader[10] != "2":
+            migration_report.add(
+                "LeaderManipulation",
+                i18n.t(
+                    "Set leader 10 (Indicator count) from %{field} to 2",
+                    field=marc_record.leader[10],
+                ),
+            )
+            marc_record.leader = Leader(f"{marc_record.leader[:10]}2{marc_record.leader[11:]}")
+
+        if marc_record.leader[11] != "2":
+            migration_report.add(
+                "LeaderManipulation",
+                i18n.t(
+                    "Set leader 11 (Subfield code count) from %{record} to 2",
+                    record=marc_record.leader[11],
+                ),
+            )
+            marc_record.leader = Leader(f"{marc_record.leader[:11]}2{marc_record.leader[12:]}")
+
+
+def report_failed_parsing(
+    reader, source_file, failed_bibs_file, idx, migration_report: MigrationReport
+):
+    migration_report.add_general_statistics(
+        i18n.t("Records with encoding errors - parsing failed"),
+    )
+    failed_bibs_file.write(reader.current_chunk)
+    raise TransformationRecordFailedError(
+        f"Index in {source_file.file_name}:{idx}",
+        f"MARC parsing error: {reader.current_exception}",
+        "Failed records stored in results/failed_bib_records.mrc",
+    )

folio_migration_tools/marc_rules_transformation/rules_mapper_authorities.py

@@ -0,0 +1,241 @@
+"""The default mapper, responsible for parsing MARC21 records acording to the
+FOLIO community specifications"""
+import logging
+import re
+import time
+import uuid
+from typing import List
+
+import i18n
+import pymarc
+from folio_uuid.folio_namespaces import FOLIONamespaces
+from folio_uuid.folio_uuid import FolioUUID
+from folioclient import FolioClient
+from pymarc import Leader, Record
+
+from folio_migration_tools.custom_exceptions import TransformationProcessError
+from folio_migration_tools.helper import Helper
+from folio_migration_tools.library_configuration import (
+    FileDefinition,
+    IlsFlavour,
+    LibraryConfiguration,
+)
+from folio_migration_tools.marc_rules_transformation.conditions import Conditions
+from folio_migration_tools.marc_rules_transformation.hrid_handler import HRIDHandler
+from folio_migration_tools.marc_rules_transformation.rules_mapper_base import (
+    RulesMapperBase,
+)
+
+
+class AuthorityMapper(RulesMapperBase):
+    non_repatable_fields = [
+        "100",
+        "110",
+        "111",
+        "130",
+        "147",
+        "148",
+        "150",
+        "151",
+        "155",
+        "162",
+        "180",
+        "181",
+        "182",
+        "185",
+        "378",
+        "384",
+    ]
+    """_summary_
+
+    Args:
+        RulesMapperBase (_type_): _description_
+    """
+
+    def __init__(
+        self,
+        folio_client,
+        library_configuration: LibraryConfiguration,
+        task_configuration,
+    ):
+        super().__init__(
+            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),
+        )
+        self.srs_recs: list = []
+        logging.info("Fetching mapping rules from the tenant")
+        rules_endpoint = "/mapping-rules/marc-authority"
+        self.mappings = self.folio_client.folio_get_single_object(rules_endpoint)
+        self.source_file_mapping: dict = {}
+        self.setup_source_file_mapping()
+        self.start = time.time()
+
+    def get_legacy_ids(self, marc_record: Record, idx: int) -> List[str]:
+        ils_flavour: IlsFlavour = self.task_configuration.ils_flavour
+        if ils_flavour in {IlsFlavour.sierra, IlsFlavour.millennium}:
+            raise TransformationProcessError("", f"ILS {ils_flavour} not configured")
+        elif ils_flavour == IlsFlavour.tag907y:
+            return RulesMapperBase.get_bib_id_from_907y(marc_record, idx)
+        elif ils_flavour == IlsFlavour.tagf990a:
+            return RulesMapperBase.get_bib_id_from_990a(marc_record, idx)
+        elif ils_flavour == IlsFlavour.aleph:
+            raise TransformationProcessError("", f"ILS {ils_flavour} not configured")
+        elif ils_flavour in {IlsFlavour.voyager, "voyager", IlsFlavour.tag001}:
+            return RulesMapperBase.get_bib_id_from_001(marc_record, idx)
+        elif ils_flavour == IlsFlavour.koha:
+            raise TransformationProcessError("", f"ILS {ils_flavour} not configured")
+        elif ils_flavour == IlsFlavour.none:
+            return [str(uuid.uuid4())]
+        else:
+            raise TransformationProcessError("", f"ILS {ils_flavour} not configured")
+
+    def parse_record(
+        self, marc_record: pymarc.Record, file_def: FileDefinition, legacy_ids: List[str]
+    ) -> list[dict]:
+        """Parses an auth recod into a FOLIO Authority object
+         This is the main function
+
+        Args:
+            legacy_ids (_type_): _description_
+            marc_record (Record): _description_
+            file_def (FileDefinition): _description_
+
+        Returns:
+            dict: _description_
+        """
+        self.print_progress()
+        ignored_subsequent_fields: set = set()
+        bad_tags = set(self.task_configuration.tags_to_delete)  # "907"
+        folio_authority = self.perform_initial_preparation(marc_record, legacy_ids)
+        for marc_field in marc_record:
+            self.report_marc_stats(marc_field, bad_tags, legacy_ids, ignored_subsequent_fields)
+            if marc_field.tag not in ignored_subsequent_fields:
+                self.process_marc_field(
+                    folio_authority,
+                    marc_field,
+                    ignored_subsequent_fields,
+                    legacy_ids,
+                )
+
+        self.perform_additional_parsing(folio_authority)
+        clean_folio_authority = self.validate_required_properties(
+            "-".join(legacy_ids), folio_authority, self.schema, FOLIONamespaces.instances
+        )
+        self.dedupe_rec(clean_folio_authority)
+        marc_record.remove_fields(*list(bad_tags))
+        self.report_folio_mapping(clean_folio_authority, self.schema)
+        return [clean_folio_authority]
+
+    def perform_initial_preparation(self, marc_record: pymarc.Record, legacy_ids):
+        folio_authority = {}
+        folio_authority["id"] = str(
+            FolioUUID(
+                self.base_string_for_folio_uuid,
+                FOLIONamespaces.authorities,
+                str(legacy_ids[-1]),
+            )
+        )
+        HRIDHandler.handle_035_generation(
+            marc_record, legacy_ids, self.migration_report, False, False
+        )
+        self.map_source_file_and_natural_id(marc_record, folio_authority)
+        self.handle_leader_17(marc_record, legacy_ids)
+        return folio_authority
+
+    def map_source_file_and_natural_id(self, marc_record, folio_authority):
+        """Implement source file and natural ID mappings according to MODDICORE-283"""
+        match_prefix_patt = re.compile("^[A-Za-z]+")
+        natural_id = None
+        source_file_id = None
+        has_010 = marc_record.get("010")
+        if has_010 and (has_010a := has_010.get_subfields("a")):
+            for a_subfield in has_010a:
+                natural_id_prefix = match_prefix_patt.match(a_subfield)
+                if natural_id_prefix and (
+                    source_file := self.source_file_mapping.get(natural_id_prefix.group(0), None)
+                ):
+                    natural_id = "".join(a_subfield.split())
+                    source_file_id = source_file["id"]
+                    self.migration_report.add_general_statistics(
+                        i18n.t("naturalId mapped from %{fro}", fro="010$a")
+                    )
+                    self.migration_report.add(
+                        "AuthoritySourceFileMapping",
+                        f"{source_file['name']} -- {natural_id_prefix.group(0)} -- 010$a",
+                        number=1,
+                    )
+                    break
+        if not source_file_id:
+            natural_id = "".join(marc_record["001"].data.split())
+            self.migration_report.add_general_statistics(
+                i18n.t("naturalId mapped from %{fro}", fro="001")
+            )
+            natural_id_prefix = match_prefix_patt.match(natural_id)
+            if natural_id_prefix:
+                if source_file := self.source_file_mapping.get(natural_id_prefix.group(0), None):
+                    source_file_id = source_file["id"]
+                    self.migration_report.add(
+                        "AuthoritySourceFileMapping",
+                        f"{source_file['name']} -- {natural_id_prefix.group(0)} -- 001",
+                        number=1,
+                    )
+        folio_authority["naturalId"] = natural_id
+        if source_file_id:
+            folio_authority["sourceFileId"] = source_file_id
+
+    def setup_source_file_mapping(self):
+        if self.folio_client.authority_source_files:
+            logging.info(
+                f"{len(self.folio_client.authority_source_files)} \tAuthority source files"
+            )
+            for source_file in self.folio_client.authority_source_files:
+                for sf_code in source_file.get("codes", []):
+                    self.source_file_mapping[sf_code] = source_file
+
+    def handle_leader_17(self, marc_record, legacy_ids):
+        leader_17 = marc_record.leader[17] or "Empty"
+        self.migration_report.add(
+            "AuthorityEncodingLevel", i18n.t("Original value") + f": {leader_17}"
+        )
+        if leader_17 not in ["n", "o"]:
+            Helper.log_data_issue(
+                legacy_ids,
+                f"LDR pos. 17 is '{leader_17}'. Is this correct? Value has been changed to 'n'.",
+                marc_record.leader,
+            )
+            marc_record.leader = Leader(f"{marc_record.leader[:17]}n{marc_record.leader[18:]}")
+            self.migration_report.add(
+                "AuthorityEncodingLevel", i18n.t("Changed %{a} to %{b}", a=leader_17, b="n")
+            )
+
+    def perform_additional_parsing(
+        self,
+        folio_authority: dict,
+    ) -> None:
+        """Do stuff not easily captured by the mapping rules
+
+        Args:
+            folio_authority (dict): _description_
+        """
+        folio_authority["source"] = "MARC"
+
+    def get_authority_json_schema(self, folio_client: FolioClient, library_configuration):
+        """Fetches the JSON Schema for autorities"""
+        if library_configuration.folio_release.name.lower()[0] < "p":
+            schema = folio_client.get_from_github(
+                "folio-org", "mod-inventory-storage", "/ramls/authorities/authority.json"
+            )
+        else:
+            schema = folio_client.get_from_github(
+                "folio-org",
+                "mod-entities-links",
+                "/src/main/resources/swagger.api/schemas/authority-storage/authorityDto.yaml",
+            )
+        return schema
+
+    def wrap_up(self):
+        logging.info("Mapper wrapping up")