folio-migration-tools 1.10.0b3__py3-none-any.whl → 1.10.0b4__py3-none-any.whl

folio_migration_tools/__main__.py

@@ -4,6 +4,7 @@ import logging
 import sys
 from os import environ
 from pathlib import Path
+from warnings import warn
 
 import httpx
 import humps
@@ -126,6 +127,14 @@ def main():
         i18n.set("locale", args.report_language)
         config_file, library_config = prep_library_config(args)
         try:
+            if args.task_name == "AuthorityTransformer":
+                warn(
+                    "The AuthorityTransformer has been removed."
+                    " Please update your configuration accordingly."
+                    " Use Data Import to load authority records.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
             migration_task_config = next(
                 t for t in config_file["migration_tasks"] if t["name"] == args.task_name
             )

folio_migration_tools/folder_structure.py

@@ -110,9 +110,6 @@ class FolderStructure:
         self.instance_id_map_path = (
             self.results_folder / f"{str(FOLIONamespaces.instances.name).lower()}_id_map.json"
         )
-        self.auth_id_map_path = (
-            self.results_folder / f"{str(FOLIONamespaces.authorities.name).lower()}_id_map.json"
-        )
 
         self.holdings_id_map_path = (
             self.results_folder / f"{str(FOLIONamespaces.holdings.name).lower()}_id_map.json"

folio_migration_tools/marc_rules_transformation/conditions.py

@@ -47,8 +47,6 @@ class Conditions:
         if object_type == "bibs":
             self.setup_reference_data_for_all()
             self.setup_reference_data_for_bibs()
-        elif object_type == "auth":
-            self.setup_reference_data_for_auth()
         else:
             self.setup_reference_data_for_all()
             self.setup_reference_data_for_items_and_holdings(default_call_number_type_name)
@@ -150,15 +148,6 @@ class Conditions:
         if not self.folio.class_types:
             raise TransformationProcessError("", "No class_types in FOLIO")
 
-    def setup_reference_data_for_auth(self):
-        self.authority_note_types = list(
-            self.folio.folio_get_all(
-                "/authority-note-types", "authorityNoteTypes", self.folio.cql_all, 1000
-            )
-        )
-        logging.info(f"{len(self.authority_note_types)} \tAuthority note types")
-        logging.info(f"{len(self.folio.identifier_types)} \tidentifier types")  # type: ignore
-
     def get_condition(
         self, name, legacy_id, value, parameter=None, marc_field: field.Field | None = None
     ):
@@ -430,24 +419,6 @@ class Conditions:
                 parameter.get("name", ""),
             ) from ee
 
-    def condition_set_authority_note_type_id(
-        self, legacy_id, _, parameter, marc_field: field.Field
-    ):
-        try:
-            t = self.get_ref_data_tuple_by_name(
-                self.authority_note_types, "authority_note_types", parameter["name"]
-            )
-            self.mapper.migration_report.add("MappedNoteTypes", t[1])
-            return t[0]
-        except Exception as ee:
-            logging.error(ee)
-            raise TransformationProcessError(
-                legacy_id,
-                f"Authority note type mapping error.\tParameter: {parameter.get('name', '')}\t"
-                f"MARC Field: {marc_field}. Is mapping rules and ref data aligned?",
-                parameter.get("name", ""),
-            ) from ee
-
     def condition_set_classification_type_id(
         self, legacy_id, value, parameter, marc_field: field.Field
     ):

folio_migration_tools/marc_rules_transformation/rules_mapper_base.py

@@ -962,7 +962,6 @@ 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,
         }
 
@@ -1020,7 +1019,6 @@ class RulesMapperBase(MapperBase):
         record_types = {
             FOLIONamespaces.holdings: "MARC_HOLDING",
             FOLIONamespaces.instances: "MARC_BIB",
-            FOLIONamespaces.authorities: "MARC_AUTHORITY",
             FOLIONamespaces.edifact: "EDIFACT",
         }
 
@@ -1033,10 +1031,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: {},
         }
 

folio_migration_tools/migration_tasks/batch_poster.py

@@ -7,11 +7,14 @@ import sys
 import time
 import traceback
 from datetime import datetime, timezone
-from typing import Annotated, List, Optional
+from typing import TYPE_CHECKING, Annotated, List, Optional
 from uuid import uuid4
 
-import httpx
+import folioclient
 import i18n
+
+if TYPE_CHECKING:
+    from httpx import Response
 from folio_uuid.folio_namespaces import FOLIONamespaces
 from pydantic import Field
 
@@ -73,7 +76,7 @@ class BatchPoster(MigrationTaskBase):
                 description=(
                     "The type of object being migrated"
                     "Examples of possible values: "
-                    "'Extradata', 'SRS', Instances', 'Holdings', 'Items'"
+                    "'Extradata', 'Instances', 'Holdings', 'Items'"
                 ),
             ),
         ]
@@ -245,90 +248,80 @@ class BatchPoster(MigrationTaskBase):
         self.failed_fields: set = set()
         self.num_failures = 0
         self.num_posted = 0
-        self.okapi_headers = self.folio_client.okapi_headers
-        self.http_client = None
         self.starting_record_count_in_folio: Optional[int] = None
         self.finished_record_count_in_folio: Optional[int] = None
 
     def do_work(self):  # noqa: C901
-        with self.folio_client.get_folio_http_client() as httpx_client:
-            self.http_client = httpx_client
-            with open(
-                self.folder_structure.failed_recs_path, "w", encoding="utf-8"
-            ) as failed_recs_file:
-                self.get_starting_record_count()
-                try:
-                    batch = []
-                    if self.task_configuration.object_type == "SRS":
-                        self.create_snapshot()
-                    for idx, file_def in enumerate(self.task_configuration.files):  # noqa: B007
-                        path = self.folder_structure.results_folder / file_def.file_name
-                        with open(path) as rows:
-                            logging.info("Running %s", path)
-                            last_row = ""
-                            for self.processed, row in enumerate(rows, start=1):
-                                last_row = row
-                                if row.strip():
-                                    try:
-                                        if self.task_configuration.object_type == "Extradata":
-                                            self.post_extra_data(
-                                                row, self.processed, failed_recs_file
-                                            )
-                                        elif not self.api_info["is_batch"]:
-                                            self.post_single_records(
-                                                row, self.processed, failed_recs_file
-                                            )
-                                        else:
-                                            batch = self.post_record_batch(
-                                                batch, failed_recs_file, row
-                                            )
-                                    except UnicodeDecodeError as unicode_error:
-                                        self.handle_unicode_error(unicode_error, last_row)
-                                    except TransformationProcessError as tpe:
-                                        self.handle_generic_exception(
-                                            tpe,
-                                            last_row,
-                                            batch,
-                                            self.processed,
-                                            failed_recs_file,
+        with open(
+            self.folder_structure.failed_recs_path, "w", encoding="utf-8"
+        ) as failed_recs_file:
+            self.get_starting_record_count()
+            try:
+                batch = []
+                for idx, file_def in enumerate(self.task_configuration.files):  # noqa: B007
+                    path = self.folder_structure.results_folder / file_def.file_name
+                    with open(path) as rows:
+                        logging.info("Running %s", path)
+                        last_row = ""
+                        for self.processed, row in enumerate(rows, start=1):
+                            last_row = row
+                            if row.strip():
+                                try:
+                                    if self.task_configuration.object_type == "Extradata":
+                                        self.post_extra_data(row, self.processed, failed_recs_file)
+                                    elif not self.api_info["is_batch"]:
+                                        self.post_single_records(
+                                            row, self.processed, failed_recs_file
                                         )
-                                        batch = []
-                                        raise
-                                    except TransformationRecordFailedError as exception:
-                                        self.handle_generic_exception(
-                                            exception,
-                                            last_row,
-                                            batch,
-                                            self.processed,
-                                            failed_recs_file,
+                                    else:
+                                        batch = self.post_record_batch(
+                                            batch, failed_recs_file, row
                                         )
-                                        batch = []
-                                    except (FileNotFoundError, PermissionError) as ose:
-                                        logging.error("Error reading file: %s", ose)
-
-                except Exception as ee:
-                    if "idx" in locals() and self.task_configuration.files[idx:]:
-                        for file_def in self.task_configuration.files[idx:]:
-                            path = self.folder_structure.results_folder / file_def.file_name
-                            try:
-                                with open(path, "r") as failed_file:
-                                    failed_file.seek(self.processed)
-                                    failed_recs_file.write(failed_file.read())
-                                    self.processed = 0
-                            except (FileNotFoundError, PermissionError) as ose:
-                                logging.error("Error reading file: %s", ose)
-                    raise ee
-                finally:
-                    if self.task_configuration.object_type != "Extradata" and any(batch):
+                                except UnicodeDecodeError as unicode_error:
+                                    self.handle_unicode_error(unicode_error, last_row)
+                                except TransformationProcessError as tpe:
+                                    self.handle_generic_exception(
+                                        tpe,
+                                        last_row,
+                                        batch,
+                                        self.processed,
+                                        failed_recs_file,
+                                    )
+                                    batch = []
+                                    raise
+                                except TransformationRecordFailedError as exception:
+                                    self.handle_generic_exception(
+                                        exception,
+                                        last_row,
+                                        batch,
+                                        self.processed,
+                                        failed_recs_file,
+                                    )
+                                    batch = []
+                                except (FileNotFoundError, PermissionError) as ose:
+                                    logging.error("Error reading file: %s", ose)
+
+            except Exception as ee:
+                if "idx" in locals() and self.task_configuration.files[idx:]:
+                    for file_def in self.task_configuration.files[idx:]:
+                        path = self.folder_structure.results_folder / file_def.file_name
                         try:
-                            self.post_batch(batch, failed_recs_file, self.processed)
-                        except Exception as exception:
-                            self.handle_generic_exception(
-                                exception, last_row, batch, self.processed, failed_recs_file
-                            )
-                    logging.info("Done posting %s records. ", self.processed)
-                    if self.task_configuration.object_type == "SRS":
-                        self.commit_snapshot()
+                            with open(path, "r") as failed_file:
+                                failed_file.seek(self.processed)
+                                failed_recs_file.write(failed_file.read())
+                                self.processed = 0
+                        except (FileNotFoundError, PermissionError) as ose:
+                            logging.error("Error reading file: %s", ose)
+                raise ee
+            finally:
+                if self.task_configuration.object_type != "Extradata" and any(batch):
+                    try:
+                        self.post_batch(batch, failed_recs_file, self.processed)
+                    except Exception as exception:
+                        self.handle_generic_exception(
+                            exception, last_row, batch, self.processed, failed_recs_file
+                        )
+                logging.info("Done posting %s records. ", self.processed)
 
     @staticmethod
     def set_consortium_source(json_rec):
@@ -366,26 +359,26 @@ class BatchPoster(MigrationTaskBase):
         fetch_batch_size = 90
         fetch_tasks = []
         existing_records = {}
-        async with httpx.AsyncClient(base_url=self.folio_client.gateway_url) as client:
-            for i in range(0, len(batch), fetch_batch_size):
-                batch_slice = batch[i : i + fetch_batch_size]
-                fetch_tasks.append(
-                    self.get_with_retry(
-                        client,
-                        query_api,
-                        params={
-                            "query": (
-                                f"id==({' OR '.join([r['id'] for r in batch_slice if 'id' in r])})"
-                            ),
-                            "limit": fetch_batch_size,
-                        },
-                    )
+
+        for i in range(0, len(batch), fetch_batch_size):
+            batch_slice = batch[i : i + fetch_batch_size]
+            fetch_tasks.append(
+                self.get_with_retry(
+                    query_api,
+                    params={
+                        "query": (
+                            f"id==({' OR '.join([r['id'] for r in batch_slice if 'id' in r])})"
+                        ),
+                        "limit": fetch_batch_size,
+                    },
                 )
+            )
+
+        responses = await asyncio.gather(*fetch_tasks)
 
-            responses = await asyncio.gather(*fetch_tasks)
+        for response in responses:
+            self.collect_existing_records_for_upsert(object_type, response, existing_records)
 
-            for response in responses:
-                self.collect_existing_records_for_upsert(object_type, response, existing_records)
         for record in batch:
             if record["id"] in existing_records:
                 self.prepare_record_for_upsert(record, existing_records[record["id"]])
@@ -421,18 +414,18 @@ class BatchPoster(MigrationTaskBase):
 
     @staticmethod
     def collect_existing_records_for_upsert(
-        object_type: str, response: httpx.Response, existing_records: dict
+        object_type: str, response_json: dict, existing_records: dict
     ):
-        if response.status_code == 200:
-            response_json = response.json()
-            for record in response_json[object_type]:
-                existing_records[record["id"]] = record
-        else:
-            logging.error(
-                "Failed to fetch current records. HTTP %s\t%s",
-                response.status_code,
-                response.text,
-            )
+        """
+        Collects existing records from API response into existing_records dict.
+
+        Args:
+            object_type: The key in response containing the records array
+            response_json: Parsed JSON response from API
+            existing_records: Dict to populate with {record_id: record_data}
+        """
+        for record in response_json.get(object_type, []):
+            existing_records[record["id"]] = record
 
     def handle_upsert_for_statistical_codes(self, updates: dict, keep_existing: dict):
         if not self.task_configuration.preserve_statistical_codes:
@@ -510,31 +503,66 @@ class BatchPoster(MigrationTaskBase):
             updates.update(keep_new)
             new_record.update(updates)
 
-    async def get_with_retry(self, client: httpx.AsyncClient, url: str, params=None):
+    async def get_with_retry(self, url: str, params=None):
+        """
+        Wrapper around folio_get_async with selective retry logic.
+
+        Retries on:
+        - Connection errors (FolioConnectionError): Always retry
+        - Server errors (5xx): Transient failures
+        - Rate limiting (429): Too many requests
+
+        Does NOT retry on:
+        - Client errors (4xx except 429): Bad request, won't succeed on retry
+        """
         if params is None:
             params = {}
         retries = 3
+
         for attempt in range(retries):
             try:
-                response = await client.get(
-                    url, params=params, headers=self.folio_client.okapi_headers
-                )
-                response.raise_for_status()
-                return response
-            except httpx.HTTPError as e:
+                return await self.folio_client.folio_get_async(url, query_params=params)
+
+            except folioclient.FolioConnectionError as e:
+                # Network/connection errors - always retry
                 if attempt < retries - 1:
-                    logging.warning(f"Retrying due to {e}")
-                    await asyncio.sleep(2**attempt)
+                    wait_time = 2**attempt
+                    logging.warning(
+                        f"Connection error, retrying in {wait_time}s "
+                        f"(attempt {attempt + 1}/{retries}): {e}"
+                    )
+                    await asyncio.sleep(wait_time)
                 else:
-                    logging.error(f"Failed to connect after {retries} attempts: {e}")
+                    logging.error(f"Connection failed after {retries} attempts: {e}")
+                    raise
+
+            except folioclient.FolioHTTPError as e:
+                # HTTP errors - selective retry based on status code
+                status_code = e.response.status_code
+                should_retry = status_code >= 500 or status_code == 429
+
+                if should_retry and attempt < retries - 1:
+                    # Longer wait for rate limiting
+                    wait_time = 5 if status_code == 429 else 2**attempt
+                    logging.warning(
+                        f"HTTP {status_code} error, retrying in {wait_time}s "
+                        f"(attempt {attempt + 1}/{retries}): {e}"
+                    )
+                    await asyncio.sleep(wait_time)
+                else:
+                    # Either not retryable or out of attempts
+                    if should_retry:
+                        logging.error(
+                            f"HTTP {status_code} error persisted after {retries} attempts: {e}"
+                        )
+                    else:
+                        logging.error(f"HTTP {status_code} error (not retryable): {e}")
                     raise
 
     def post_record_batch(self, batch, failed_recs_file, row):
         json_rec = json.loads(row.split("\t")[-1])
         if self.task_configuration.object_type == "ShadowInstances":
             self.set_consortium_source(json_rec)
-        if self.task_configuration.object_type == "SRS":
-            json_rec["snapshotId"] = self.snapshot_id
         if self.processed == 1:
             logging.info(json.dumps(json_rec, indent=True))
         batch.append(json_rec)
@@ -545,22 +573,29 @@ class BatchPoster(MigrationTaskBase):
 
     def post_extra_data(self, row: str, num_records: int, failed_recs_file):
         (object_name, data) = row.split("\t")
-        endpoint = self.get_extradata_endpoint(self.task_configuration, object_name, data)
-        url = f"{self.folio_client.gateway_url}/{endpoint}"
+        url = self.get_extradata_endpoint(self.task_configuration, object_name, data)
         body = data
-        response = self.post_objects(url, body)
-        if response.status_code == 201:
+        try:
+            _ = self.folio_client.folio_post(url, payload=body)
             self.num_posted += 1
-        elif response.status_code == 422:
-            self.num_failures += 1
-            error_msg = json.loads(response.text)["errors"][0]["message"]
-            logging.error("Row %s\tHTTP %s\t %s", num_records, response.status_code, error_msg)
-            if "id value already exists" not in json.loads(response.text)["errors"][0]["message"]:
+        except folioclient.FolioHTTPError as fhe:
+            if fhe.response.status_code == 422:
+                self.num_failures += 1
+                error_msg = json.loads(fhe.response.text)["errors"][0]["message"]
+                logging.error(
+                    "Row %s\tHTTP %s\t %s", num_records, fhe.response.status_code, error_msg
+                )
+                if (
+                    "id value already exists"
+                    not in json.loads(fhe.response.text)["errors"][0]["message"]
+                ):
+                    failed_recs_file.write(row)
+            else:
+                self.num_failures += 1
+                logging.error(
+                    "Row %s\tHTTP %s\t%s", num_records, fhe.response.status_code, fhe.response.text
+                )
                 failed_recs_file.write(row)
-        else:
-            self.num_failures += 1
-            logging.error("Row %s\tHTTP %s\t%s", num_records, response.status_code, response.text)
-            failed_recs_file.write(row)
         if num_records % 50 == 0:
             logging.info(
                 "%s records posted successfully. %s failed",
@@ -600,37 +635,37 @@ class BatchPoster(MigrationTaskBase):
     def post_single_records(self, row: str, num_records: int, failed_recs_file):
         if self.api_info["is_batch"]:
             raise TypeError("This record type supports batch processing, use post_batch method")
-        api_endpoint = self.api_info.get("api_endpoint")
-        url = f"{self.folio_client.gateway_url}{api_endpoint}"
-        response = self.post_objects(url, row)
-        if response.status_code == 201:
+        url = self.api_info.get("api_endpoint")
+        try:
+            _ = self.folio_client.folio_post(url, payload=row)
             self.num_posted += 1
-        elif response.status_code == 422:
-            self.num_failures += 1
-            error_msg = json.loads(response.text)["errors"][0]["message"]
-            logging.error("Row %s\tHTTP %s\t %s", num_records, response.status_code, error_msg)
-            if "id value already exists" not in json.loads(response.text)["errors"][0]["message"]:
+        except folioclient.FolioHTTPError as fhe:
+            if fhe.response.status_code == 422:
+                self.num_failures += 1
+                error_msg = json.loads(fhe.response.text)["errors"][0]["message"]
+                logging.error(
+                    "Row %s\tHTTP %s\t %s", num_records, fhe.response.status_code, error_msg
+                )
+                if (
+                    "id value already exists"
+                    not in json.loads(fhe.response.text)["errors"][0]["message"]
+                ):
+                    failed_recs_file.write(row)
+            else:
+                self.num_failures += 1
+                logging.error(
+                    "Row %s\tHTTP %s\t%s",
+                    num_records,
+                    fhe.response.status_code,
+                    fhe.response.text,
+                )
                 failed_recs_file.write(row)
-        else:
-            self.num_failures += 1
-            logging.error("Row %s\tHTTP %s\t%s", num_records, response.status_code, response.text)
-            failed_recs_file.write(row)
-        if num_records % 50 == 0:
-            logging.info(
-                "%s records posted successfully. %s failed",
-                self.num_posted,
-                self.num_failures,
-            )
-
-    def post_objects(self, url, body):
-        if self.http_client and not self.http_client.is_closed:
-            return self.http_client.post(
-                url, data=body.encode("utf-8"), headers=self.folio_client.okapi_headers
-            )
-        else:
-            return httpx.post(
-                url, headers=self.okapi_headers, data=body.encode("utf-8"), timeout=None
-            )
+            if num_records % 50 == 0:
+                logging.info(
+                    "%s records posted successfully. %s failed",
+                    self.num_posted,
+                    self.num_failures,
+                )
 
     def handle_generic_exception(self, exception, last_row, batch, num_records, failed_recs_file):
         logging.error("%s", exception)
@@ -662,7 +697,7 @@ class BatchPoster(MigrationTaskBase):
         traceback.logging.info_exc()  # type: ignore
         logging.info("=======================")
 
-    def post_batch(self, batch, failed_recs_file, num_records, recursion_depth=0):
+    def post_batch(self, batch, failed_recs_file, num_records):
         if self.query_params.get("upsert", False) and self.api_info.get("query_endpoint", ""):
             self.set_version(batch, self.api_info["query_endpoint"], self.api_info["object_name"])
         response = self.do_post(batch)
@@ -733,24 +768,6 @@ class BatchPoster(MigrationTaskBase):
             # Likely a json parsing error
             logging.error(response.text)
             raise TransformationProcessError("", "HTTP 400. Something is wrong. Quitting")
-        elif self.task_configuration.object_type == "SRS" and response.status_code >= 500:
-            logging.info(
-                "Post failed. Size: %s Waiting 30s until reposting. Number of tries: %s of 5",
-                get_req_size(response),
-                recursion_depth,
-            )
-            logging.info(response.text)
-            time.sleep(30)
-            if recursion_depth > 4:
-                raise TransformationRecordFailedError(
-                    "",
-                    f"HTTP {response.status_code}\t"
-                    f"Request size: {get_req_size(response)}"
-                    f"{datetime.now(timezone.utc).isoformat()}\n",
-                    response.text,
-                )
-            else:
-                self.post_batch(batch, failed_recs_file, num_records, recursion_depth + 1)
         elif (
             response.status_code == 413 and "DB_ALLOW_SUPPRESS_OPTIMISTIC_LOCKING" in response.text
         ):
@@ -775,50 +792,35 @@ class BatchPoster(MigrationTaskBase):
             )
 
     def do_post(self, batch):
-        path = self.api_info["api_endpoint"]
-        url = self.folio_client.gateway_url + path
+        url = self.api_info["api_endpoint"]
         if self.api_info["object_name"] == "users":
             payload = {self.api_info["object_name"]: list(batch), "totalRecords": len(batch)}
         elif self.api_info["total_records"]:
             payload = {"records": list(batch), "totalRecords": len(batch)}
         else:
             payload = {self.api_info["object_name"]: batch}
-        if self.http_client and not self.http_client.is_closed:
-            return self.http_client.post(
-                url,
-                json=payload,
-                headers=self.folio_client.okapi_headers,
-                params=self.query_params,
-            )
-        else:
-            return httpx.post(
-                url,
-                headers=self.okapi_headers,
-                json=payload,
-                params=self.query_params,
-                timeout=None,
-            )
+        return self.folio_client.folio_post(
+            url,
+            payload,
+            query_params=self.query_params,
+        )
 
     def get_current_record_count_in_folio(self):
         if "query_endpoint" in self.api_info:
-            url = f"{self.folio_client.gateway_url}{self.api_info['query_endpoint']}"
+            url = self.api_info["query_endpoint"]
             query_params = {"query": "cql.allRecords=1", "limit": 0}
-            if self.http_client and not self.http_client.is_closed:
-                res = self.http_client.get(
-                    url, headers=self.folio_client.okapi_headers, params=query_params
-                )
-            else:
-                res = httpx.get(url, headers=self.okapi_headers, params=query_params, timeout=None)
             try:
-                res.raise_for_status()
-                return res.json()["totalRecords"]
-            except httpx.HTTPStatusError:
-                logging.error("Failed to get current record count. HTTP %s", res.status_code)
+                res = self.folio_client.folio_get(url, query_params=query_params)
+                return res["totalRecords"]
+            except folioclient.FolioHTTPError as fhe:
+                logging.error(
+                    "Failed to get current record count. HTTP %s", fhe.response.status_code
+                )
                 return 0
             except KeyError:
                 logging.error(
                     "Failed to get current record count. "
-                    f"No 'totalRecords' in response: {res.json()}"
+                    f"No 'totalRecords' in response: {json.dumps(res, indent=2)}"
                 )
                 return 0
         else:
@@ -850,8 +852,6 @@ class BatchPoster(MigrationTaskBase):
     def wrap_up(self):
         logging.info("Done. Wrapping up")
         self.extradata_writer.flush()
-        if self.task_configuration.object_type == "SRS":
-            self.commit_snapshot()
         if self.task_configuration.object_type != "Extradata":
             logging.info(
                 (
@@ -938,69 +938,6 @@ class BatchPoster(MigrationTaskBase):
                 str(self.folder_structure.failed_recs_path),
             )
 
-    def create_snapshot(self):
-        snapshot = {
-            "jobExecutionId": self.snapshot_id,
-            "status": "PARSING_IN_PROGRESS",
-            "processingStartedDate": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
-        }
-        try:
-            url = f"{self.folio_client.gateway_url}/source-storage/snapshots"
-            if self.http_client and not self.http_client.is_closed:
-                res = self.http_client.post(
-                    url, json=snapshot, headers=self.folio_client.okapi_headers
-                )
-            else:
-                res = httpx.post(url, headers=self.okapi_headers, json=snapshot, timeout=None)
-            res.raise_for_status()
-            logging.info("Posted Snapshot to FOLIO: %s", json.dumps(snapshot, indent=4))
-            get_url = (
-                f"{self.folio_client.gateway_url}/source-storage/snapshots/{self.snapshot_id}"
-            )
-            got = False
-            while not got:
-                logging.info("Sleeping while waiting for the snapshot to get created")
-                time.sleep(5)
-                if self.http_client and not self.http_client.is_closed:
-                    res = self.http_client.get(get_url, headers=self.folio_client.okapi_headers)
-                else:
-                    res = httpx.get(get_url, headers=self.okapi_headers, timeout=None)
-                if res.status_code == 200:
-                    got = True
-                else:
-                    logging.info(res.status_code)
-        except httpx.HTTPStatusError as exc:
-            logging.exception("HTTP error occurred while posting the snapshot: %s", exc)
-            sys.exit(1)
-        except Exception as exc:
-            logging.exception("Could not post the snapshot: %s", exc)
-            sys.exit(1)
-
-    def commit_snapshot(self):
-        snapshot = {"jobExecutionId": self.snapshot_id, "status": "COMMITTED"}
-        try:
-            url = f"{self.folio_client.gateway_url}/source-storage/snapshots/{self.snapshot_id}"
-            if self.http_client and not self.http_client.is_closed:
-                res = self.http_client.put(
-                    url, json=snapshot, headers=self.folio_client.okapi_headers
-                )
-            else:
-                res = httpx.put(url, headers=self.okapi_headers, json=snapshot, timeout=None)
-            res.raise_for_status()
-            logging.info("Posted Committed snapshot to FOLIO: %s", json.dumps(snapshot, indent=4))
-        except httpx.HTTPStatusError as exc:
-            logging.exception("HTTP error occurred while posting the snapshot: %s", exc)
-            sys.exit(1)
-        except Exception as exc:
-            logging.exception(
-                "Could not commit snapshot with id %s. Post this to /source-storage/snapshots/%s:",
-                self.snapshot_id,
-                self.snapshot_id,
-                exc,
-            )
-            logging.info("%s", json.dumps(snapshot, indent=4))
-            sys.exit(1)
-
 
 def get_api_info(object_type: str, use_safe: bool = True):
     choices = {
@@ -1062,22 +999,6 @@ def get_api_info(object_type: str, use_safe: bool = True):
             "addSnapshotId": False,
             "supports_upsert": True,
         },
-        "Authorities": {
-            "object_name": "",
-            "api_endpoint": "/authority-storage/authorities",
-            "is_batch": False,
-            "total_records": False,
-            "addSnapshotId": False,
-            "supports_upsert": False,
-        },
-        "SRS": {
-            "object_name": "records",
-            "api_endpoint": "/source-storage/batch/records",
-            "is_batch": True,
-            "total_records": True,
-            "addSnapshotId": True,
-            "supports_upsert": False,
-        },
         "Users": {
             "object_name": "users",
             "api_endpoint": "/user-import",
@@ -1124,7 +1045,7 @@ def get_human_readable(size, precision=2):
     return "%.*f%s" % (precision, size, suffixes[suffix_index])
 
 
-def get_req_size(response: httpx.Response):
+def get_req_size(response: "Response"):
     size = response.request.method
     size += str(response.request.url)
     size += "\r\n".join(f"{k}{v}" for k, v in response.request.headers.items())

folio_migration_tools/translations/en.json

@@ -24,7 +24,6 @@
   "Aged to lost and checked out": "Aged to lost and checked out",
   "Already set to %{value}. %{leader_key} was %{leader}": "Already set to %{value}. %{leader_key} was %{leader}",
   "An Unmapped": "An Unmapped",
-  "Authority records transformation report": "Authority records transformation report",
   "BW Items found tied to previously created BW Holdings": "BW Items found tied to previously created BW Holdings",
   "Bib identifier not in instances_id_map, no instance linked": "Bib identifier not in instances_id_map, no instance linked",
   "Bib ids referenced in bound-with items": "Bib ids referenced in bound-with items",
@@ -264,12 +263,6 @@
   "blurbs.AcquisitionMethodMapping.title": "POL Acquisition Method Mapping",
   "blurbs.AddedValueFromParameter.description": "",
   "blurbs.AddedValueFromParameter.title": "Added value from parameter since value is empty",
-  "blurbs.AuthorityEncodingLevel.description": "Library action: **All values that are not n or o will be set to n. If this is not what you want, you need to correct these values in your system. **<br/>An overview of the Encoding levels (Leader position 17) present in your source data.  Allowed values according to the MARC standard are n or o",
-  "blurbs.AuthorityEncodingLevel.title": "Encoding level (leader pos 17)",
-  "blurbs.AuthoritySourceFileMapping.description": "Mappings based on FOLIO authority `naturalId` alpha prefix",
-  "blurbs.AuthoritySourceFileMapping.title": "Authority Source File Mapping Results",
-  "blurbs.AuthoritySources.description": "",
-  "blurbs.AuthoritySources.title": "Authorization sources and related information",
   "blurbs.BoundWithMappings.description": "",
   "blurbs.BoundWithMappings.title": "Bound-with mapping",
   "blurbs.CallNumberTypeMapping.description": "Call number types in MFHDs are mapped from 852, Indicator 1 according to a certain scheme. (LOC documentation)[https://www.loc.gov/marc/holdings/hd852.html]",

{folio_migration_tools-1.10.0b3.dist-info → folio_migration_tools-1.10.0b4.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: folio-migration-tools
-Version: 1.10.0b3
+Version: 1.10.0b4
 Summary: A tool allowing you to migrate data from legacy ILS:s (Library systems) into FOLIO LSP
 Keywords: FOLIO,ILS,LSP,Library Systems,MARC21,Library data
 Author: Theodor Tolstoy, Lisa Sjögren, Brooks Travis, Jeremy Nelson, Clinton Bradford
 Author-email: Theodor Tolstoy <github.teddes@tolstoy.se>, Brooks Travis <brooks.travis@gmail.com>
 License-Expression: MIT
-Requires-Dist: folioclient>=1.0.1
+Requires-Dist: folioclient>=1.0.4
 Requires-Dist: pyhumps>=3.7.3,<4.0.0
 Requires-Dist: defusedxml>=0.7.1,<1.0.0
 Requires-Dist: python-dateutil>=2.8.2,<3.0.0

{folio_migration_tools-1.10.0b3.dist-info → folio_migration_tools-1.10.0b4.dist-info}/RECORD

@@ -1,12 +1,12 @@
 folio_migration_tools/__init__.py,sha256=lnYgqA47l0iA-iORkVH3dgevk7gyGxVwg3MnLltA-U8,223
-folio_migration_tools/__main__.py,sha256=MlF8Fj_E4EcW6rU0posfj3ZyPzSWzSm6zXz2jlN7OGw,8835
+folio_migration_tools/__main__.py,sha256=KJdmLkKwAygTKuIKfvDL3M0JdVgsCbf2_LTL1FP6GxU,9233
 folio_migration_tools/circulation_helper.py,sha256=r1zpOKy47VFRHyXHvwUEjPfQ4jyJpjMAYc1IktJ94WU,14661
 folio_migration_tools/colors.py,sha256=GP0wdI_GZ2WD5SjrbPN-S3u8vvN_u6rGQIBBcWv_0ZM,227
 folio_migration_tools/config_file_load.py,sha256=zHHa6NDkN6EJiQE4DgjrFQPVKsd70POsfbGkB8308jg,2822
 folio_migration_tools/custom_dict.py,sha256=rRd9_RQqI85171p7wTfpMM0Mladh-LChbgMSmLvN7N0,680
 folio_migration_tools/custom_exceptions.py,sha256=BLP1gMPbTHSN-rqxzTawT4sRLiyAU3blBdkUBwiiPRk,2642
 folio_migration_tools/extradata_writer.py,sha256=fuchNcMc6BYb9IyfAcvXg7X4J2TfX6YiROfT2hr0JMw,1678
-folio_migration_tools/folder_structure.py,sha256=yqeeB1uADw9J6TCHUxKOv7wrTglfAeX9KpwNgOHjTg0,6917
+folio_migration_tools/folder_structure.py,sha256=ExrXNEWvCB5QMH17kQSyTDQ04thq--t8_p3F_iuyf0k,6776
 folio_migration_tools/helper.py,sha256=Jb-9PrMkgOUGYScRf8jMmGGTcPIohm3eFHenGSi3cUA,2979
 folio_migration_tools/holdings_helper.py,sha256=yJpz6aJrKRBiJ1MtT5bs2vXAc88uJuGh2_KDuCySOKc,7559
 folio_migration_tools/i18n_config.py,sha256=3AH_2b9zTsxE4XTe4isM_zYtPJSlK0ix6eBmV7kAYUM,228
@@ -24,20 +24,18 @@ folio_migration_tools/mapping_file_transformation/organization_mapper.py,sha256=
 folio_migration_tools/mapping_file_transformation/ref_data_mapping.py,sha256=rROcBiL5TE7bWsJ95A6shurPZ1e4In6PTwR5BN9amzU,8991
 folio_migration_tools/mapping_file_transformation/user_mapper.py,sha256=13cvFr7Vp6uxZNpAmLxGvPVLC1_En2NVvLtuP75HAzU,8846
 folio_migration_tools/marc_rules_transformation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-folio_migration_tools/marc_rules_transformation/conditions.py,sha256=zzl18PsqUaXsT5mcolPC89ar4RpQTs_beKAgVg4bttI,48190
+folio_migration_tools/marc_rules_transformation/conditions.py,sha256=-5U6nBGcBO49C9MMyxOL2wMhHGxUawkIM9e-MwNaM_4,46938
 folio_migration_tools/marc_rules_transformation/holdings_statementsparser.py,sha256=-mOGtoPa3qmEqGWtyBTN-fQ743ZmT8caDLc9ES9J74Y,13667
 folio_migration_tools/marc_rules_transformation/hrid_handler.py,sha256=WudBOzCwcJAuhEm4urLhAk5OQWGfbKz9_4Ou8fmjm1E,10022
 folio_migration_tools/marc_rules_transformation/loc_language_codes.xml,sha256=ztn2_yKws6qySL4oSsZh7sOjxq5bCC1PhAnXJdtgmJ0,382912
 folio_migration_tools/marc_rules_transformation/marc_file_processor.py,sha256=o03d_G-4MR4e5VPfu7ljxAVDl79o2ONpQIqQ-V2RCdA,12523
 folio_migration_tools/marc_rules_transformation/marc_reader_wrapper.py,sha256=9ATjYMRAjy0QcXtmNZaHVhHLJ5hE1WUgOcF6KMJjbgo,5309
-folio_migration_tools/marc_rules_transformation/rules_mapper_authorities.py,sha256=fhe1vTt9F5u5PJliklSGP3TPZHRO3KV8GHeb-pdLdnA,9622
-folio_migration_tools/marc_rules_transformation/rules_mapper_base.py,sha256=ijOs9r0Mcx0XyNhDAq7fw1aFJ-JnAEhHx98-t262uRo,46158
+folio_migration_tools/marc_rules_transformation/rules_mapper_base.py,sha256=KxyZjizbLwwAY2PfMSyh6u_mVTpfhyvdaii_PlpLscw,45857
 folio_migration_tools/marc_rules_transformation/rules_mapper_bibs.py,sha256=F8tKn59zHUV3Gqa9NY-JvTbWgfDjNTcPvQONk8gzwGs,30428
 folio_migration_tools/marc_rules_transformation/rules_mapper_holdings.py,sha256=YILyEfO-LkQPk-4OjiuY68X5xDA0LlI7UUp7_mvzLUE,29184
 folio_migration_tools/migration_report.py,sha256=B8e4tMfT0xCJ3BxkSg7ZZJYmg0VLQVXmmVnWwmojZD4,4260
 folio_migration_tools/migration_tasks/__init__.py,sha256=ZkbY_yGyB84Ke8OMlYUzyyBj4cxxNrhMTwQlu_GbdDs,211
-folio_migration_tools/migration_tasks/authority_transformer.py,sha256=tB9XBJn5BPJ1Xa79R9blDz31jN4UvLB1VFbyFjFjfM4,4228
-folio_migration_tools/migration_tasks/batch_poster.py,sha256=x3DQPrI1QnRtg9Bdf-e3ztv4llWPt5JpeCIyE7mMNWU,50634
+folio_migration_tools/migration_tasks/batch_poster.py,sha256=dIsqqjizuJN0BOj98uK4EsAQgdCcQwMwvK2CUtifd7w,46120
 folio_migration_tools/migration_tasks/bibs_transformer.py,sha256=zPxh2tjyqx88fuH1FuKLwhT6lhZ5fVTQAqE08IggYgM,6351
 folio_migration_tools/migration_tasks/courses_migrator.py,sha256=sKIeyUlc7o189lw88XbGILVkwnR9krqO0PgS-vLCCm8,7039
 folio_migration_tools/migration_tasks/holdings_csv_transformer.py,sha256=JzOufqjSR2V-gUvOq0pdQFsXjpxk1ldGJBQWIWGfCps,21915
@@ -57,8 +55,8 @@ folio_migration_tools/transaction_migration/legacy_loan.py,sha256=A5qvThfP3g62Yn
 folio_migration_tools/transaction_migration/legacy_request.py,sha256=Kv7jpBIuZ_qyay8BdaeCPJID67l43Cl6x-ws9Lt49NI,6121
 folio_migration_tools/transaction_migration/legacy_reserve.py,sha256=qzw0okg4axAE_ezXopP9gFsQ_e60o0zh7zqRzFBSWHY,1806
 folio_migration_tools/transaction_migration/transaction_result.py,sha256=cTdCN0BnlI9_ZJB2Z3Fdkl9gpymIi-9mGZsRFlQcmDk,656
-folio_migration_tools/translations/en.json,sha256=4Ac66PR5Y78ll4_grhBm2IdTMsoZUv0q3IJvX8SQiJI,41778
-folio_migration_tools-1.10.0b3.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-folio_migration_tools-1.10.0b3.dist-info/entry_points.txt,sha256=mJRRiCNP9j7_NpVXamHEiW8pDEjWQs1vEqD89G354cM,79
-folio_migration_tools-1.10.0b3.dist-info/METADATA,sha256=SgteVRYKSUGrgKVAHV8y4706ylBe7LiFsp4tXtyBxOg,7162
-folio_migration_tools-1.10.0b3.dist-info/RECORD,,
+folio_migration_tools/translations/en.json,sha256=pS7dhHmj4XBqTcFNIcqFgRMY557fQan1RomdNg6PtdA,40941
+folio_migration_tools-1.10.0b4.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+folio_migration_tools-1.10.0b4.dist-info/entry_points.txt,sha256=mJRRiCNP9j7_NpVXamHEiW8pDEjWQs1vEqD89G354cM,79
+folio_migration_tools-1.10.0b4.dist-info/METADATA,sha256=JlJpqIeLAOLOFk0kqT7_ZcS5pO-0o-NgaXlBPt2Kh7A,7162
+folio_migration_tools-1.10.0b4.dist-info/RECORD,,

folio_migration_tools/marc_rules_transformation/rules_mapper_authorities.py

@@ -1,242 +0,0 @@
-"""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")

folio_migration_tools/migration_tasks/authority_transformer.py

@@ -1,118 +0,0 @@
-import logging
-from typing import Annotated
-from typing import List
-import i18n
-
-from folio_uuid.folio_namespaces import FOLIONamespaces
-from pydantic import Field
-
-from folio_migration_tools.helper import Helper
-from folio_migration_tools.library_configuration import FileDefinition
-from folio_migration_tools.library_configuration import IlsFlavour
-from folio_migration_tools.library_configuration import LibraryConfiguration
-from folio_migration_tools.marc_rules_transformation.marc_file_processor import (
-    MarcFileProcessor,
-)
-from folio_migration_tools.marc_rules_transformation.rules_mapper_authorities import (
-    AuthorityMapper,
-)
-from folio_migration_tools.migration_tasks.migration_task_base import MigrationTaskBase
-from folio_migration_tools.task_configuration import AbstractTaskConfiguration
-
-
-class AuthorityTransformer(MigrationTaskBase):
-    class TaskConfiguration(AbstractTaskConfiguration):
-        name: Annotated[
-            str,
-            Field(
-                description=(
-                    "Name of this migration task. The name is being used to call the specific "
-                    "task, and to distinguish tasks of similar types"
-                )
-            ),
-        ]
-        migration_task_type: Annotated[
-            str,
-            Field(
-                title="Migration task type",
-                description=("The type of migration task you want to perform"),
-            ),
-        ]
-        files: Annotated[
-            List[FileDefinition],
-            Field(
-                title="Source files", description=("List of MARC21 files with authority records")
-            ),
-        ]
-        ils_flavour: Annotated[
-            IlsFlavour,
-            Field(
-                title="ILS flavour", description="The type of ILS you are migrating records from."
-            ),
-        ]
-        tags_to_delete: Annotated[
-            List[str],
-            Field(
-                title="Tags to delete from MARC record",
-                description=(
-                    "Tags in the incoming MARC authority that the process should remove "
-                    "before adding them into FOLIO. These tags will be used in the "
-                    "transformation before getting removed."
-                ),
-            ),
-        ] = []
-        create_source_records: Annotated[
-            bool,
-            Field(
-                title="Create source records",
-                description=(
-                    "Controls wheter or not to retain the MARC records in Source Record Storage."
-                ),
-            ),
-        ] = True
-
-    @staticmethod
-    def get_object_type() -> FOLIONamespaces:
-        return FOLIONamespaces.authorities
-
-    def __init__(
-        self,
-        task_config: TaskConfiguration,
-        library_config: LibraryConfiguration,
-        use_logging: bool = True,
-    ):
-        super().__init__(library_config, task_config, use_logging)
-        self.processor: MarcFileProcessor
-        self.check_source_files(
-            self.folder_structure.legacy_records_folder, self.task_configuration.files
-        )
-        self.mapper: AuthorityMapper = AuthorityMapper(
-            self.folio_client, library_config, task_config
-        )
-        self.auth_ids: set = set()
-        logging.info("Init done")
-
-    def do_work(self):
-        self.do_work_marc_transformer()
-
-    def wrap_up(self):
-        logging.info("Done. Transformer Wrapping up...")
-        self.extradata_writer.flush()
-        self.processor.wrap_up()
-        with open(self.folder_structure.migration_reports_file, "w+") as report_file:
-            self.mapper.migration_report.write_migration_report(
-                i18n.t("Authority records transformation report"),
-                report_file,
-                self.start_datetime,
-            )
-            Helper.print_mapping_report(
-                report_file,
-                self.mapper.parsed_records,
-                self.mapper.mapped_folio_fields,
-                self.mapper.mapped_legacy_fields,
-            )
-        logging.info(
-            "Done. Transformation report written to %s",
-            self.folder_structure.migration_reports_file.name,
-        )
-        self.clean_out_empty_logs()