folio-data-import 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

folio_data_import/MARCDataImport.py

@@ -15,7 +15,7 @@ from functools import cached_property
 from getpass import getpass
 from pathlib import Path
 from time import sleep
-from typing import Any, BinaryIO, Callable, Dict, List, Union
+from typing import BinaryIO, Callable, Dict, List, Union
 
 import folioclient
 import httpx
@@ -25,7 +25,7 @@ import tabulate
 from humps import decamelize
 from tqdm import tqdm
 
-from folio_data_import.custom_exceptions import FolioDataImportBatchError
+from folio_data_import.custom_exceptions import FolioDataImportBatchError, FolioDataImportJobError
 from folio_data_import.marc_preprocessors._preprocessors import MARCPreprocessor
 
 try:
@@ -38,21 +38,25 @@ except AttributeError:
 REPORT_SUMMARY_ORDERING = {"created": 0, "updated": 1, "discarded": 2, "error": 3}
 
 # Set default timeout and backoff values for HTTP requests when retrying job status and final summary checks
-RETRY_TIMEOUT_START = 1
-RETRY_TIMEOUT_RETRY_FACTOR = 2
+RETRY_TIMEOUT_START = 5
+RETRY_TIMEOUT_RETRY_FACTOR = 1.5
+RETRY_TIMEOUT_MAX = 25.32
 
 # Custom log level for data issues, set to 26
 DATA_ISSUE_LVL_NUM = 26
 logging.addLevelName(DATA_ISSUE_LVL_NUM, "DATA_ISSUES")
 
+
 def data_issues(self, msg, *args, **kws):
     if self.isEnabledFor(DATA_ISSUE_LVL_NUM):
         self._log(DATA_ISSUE_LVL_NUM, msg, args, **kws)
 
+
 logging.Logger.data_issues = data_issues
 
 logger = logging.getLogger(__name__)
 
+
 class MARCImportJob:
     """
     Class to manage importing MARC data (Bib, Authority) into FOLIO using the Change Manager
@@ -82,8 +86,10 @@ class MARCImportJob:
     finished: bool = False
     job_id: str = ""
     job_hrid: int = 0
-    current_file: Union[List[Path],List[io.BytesIO]] = []
+    current_file: Union[List[Path], List[io.BytesIO]] = []
     _max_summary_retries: int = 2
+    _max_job_retries: int = 2
+    _job_retries: int = 0
     _summary_retries: int = 0
 
     def __init__(
@@ -93,8 +99,8 @@ class MARCImportJob:
         import_profile_name: str,
         batch_size=10,
         batch_delay=0,
-        marc_record_preprocessor: Union[List[Callable], str]=[],
-        preprocessor_args: Dict[str,Dict]={},
+        marc_record_preprocessor: Union[List[Callable], str] = [],
+        preprocessor_args: Dict[str, Dict] = {},
         no_progress=False,
         let_summary_fail=False,
         split_files=False,
@@ -111,8 +117,10 @@ class MARCImportJob:
         self.import_profile_name = import_profile_name
         self.batch_size = batch_size
         self.batch_delay = batch_delay
-        self.current_retry_timeout = None
-        self.marc_record_preprocessor: MARCPreprocessor = MARCPreprocessor(marc_record_preprocessor, **preprocessor_args)
+        self.current_retry_timeout = 0
+        self.marc_record_preprocessor: MARCPreprocessor = MARCPreprocessor(
+            marc_record_preprocessor, **preprocessor_args
+        )
 
     async def do_work(self) -> None:
         """
@@ -161,10 +169,14 @@ class MARCImportJob:
         for file in self.import_files:
             with open(file, "rb") as f:
                 file_length = await self.read_total_records([f])
-            expected_batches = math.ceil(file_length /self.split_size)
-            logger.info(f"{file.name} contains {file_length} records. Splitting into {expected_batches} {self.split_size} record batches.")
+            expected_batches = math.ceil(file_length / self.split_size)
+            logger.info(
+                f"{file.name} contains {file_length} records. Splitting into {expected_batches} {self.split_size} record batches."
+            )
             zero_pad_parts = len(str(expected_batches)) if expected_batches > 1 else 2
-            for idx, batch in enumerate(self.split_marc_file(file, self.split_size), start=1):
+            for idx, batch in enumerate(
+                self.split_marc_file(file, self.split_size), start=1
+            ):
                 if idx > self.split_offset:
                     batch.name = f"{file.name} (Part {idx:0{zero_pad_parts}})"
                     self.current_file = [batch]
@@ -212,22 +224,29 @@ class MARCImportJob:
                 timeout=self.current_retry_timeout,
                 verify=self.folio_client.ssl_verify,
             ) as temp_client:
+                self.folio_client.httpx_client = temp_client
                 job_status = self.folio_client.folio_get(
                     "/metadata-provider/jobExecutions?statusNot=DISCARDED&uiStatusAny"
                     "=PREPARING_FOR_PREVIEW&uiStatusAny=READY_FOR_PREVIEW&uiStatusAny=RUNNING&limit=50"
                 )
                 self.current_retry_timeout = None
         except (httpx.ConnectTimeout, httpx.ReadTimeout, httpx.HTTPStatusError) as e:
-            if not hasattr(e, "response") or e.response.status_code in [502, 504, 401]:
-                error_text = e.response.text if hasattr(e, "response") else str(e)
-                logger.warning(f"SERVER ERROR fetching job status: {error_text}. Retrying.")
+            error_text = e.response.text if hasattr(e, "response") else str(e)
+            if self.current_retry_timeout <= RETRY_TIMEOUT_MAX and (
+                not hasattr(e, "response") or e.response.status_code in [502, 504, 401]
+            ):
+                logger.warning(
+                    f"SERVER ERROR fetching job status: {error_text}. Retrying."
+                )
                 sleep(0.25)
-                with httpx.Client(
-                    timeout=self.current_retry_timeout,
-                    verify=self.folio_client.ssl_verify,
-                ) as temp_client:
-                    self.folio_client.httpx_client = temp_client
-                    return await self.get_job_status()
+                return await self.get_job_status()
+            elif self.current_retry_timeout > RETRY_TIMEOUT_MAX and (
+                not hasattr(e, "response") or e.response.status_code in [502, 504, 401]
+            ):
+                logger.critical(
+                    f"SERVER ERROR fetching job status: {error_text}. Max retries exceeded."
+                )
+                raise FolioDataImportJobError(self.job_id, error_text, e)
             else:
                 raise e
         except Exception as e:
@@ -240,19 +259,29 @@ class MARCImportJob:
             self.pbar_imported.update(status["progress"]["current"] - self.last_current)
             self.last_current = status["progress"]["current"]
         except (IndexError, ValueError, KeyError):
-            logger.debug(f"No active job found with ID {self.job_id}. Checking for finished job.")
+            logger.debug(
+                f"No active job found with ID {self.job_id}. Checking for finished job."
+            )
             try:
                 job_status = self.folio_client.folio_get(
                     "/metadata-provider/jobExecutions?limit=100&sortBy=completed_date%2Cdesc&statusAny"
                     "=COMMITTED&statusAny=ERROR&statusAny=CANCELLED"
                 )
                 status = [
-                    job for job in job_status["jobExecutions"] if job["id"] == self.job_id
+                    job
+                    for job in job_status["jobExecutions"]
+                    if job["id"] == self.job_id
                 ][0]
-                self.pbar_imported.update(status["progress"]["current"] - self.last_current)
+                self.pbar_imported.update(
+                    status["progress"]["current"] - self.last_current
+                )
                 self.last_current = status["progress"]["current"]
                 self.finished = True
-            except (httpx.ConnectTimeout, httpx.ReadTimeout, httpx.HTTPStatusError) as e:
+            except (
+                httpx.ConnectTimeout,
+                httpx.ReadTimeout,
+                httpx.HTTPStatusError,
+            ) as e:
                 if not hasattr(e, "response") or e.response.status_code in [502, 504]:
                     error_text = e.response.text if hasattr(e, "response") else str(e)
                     logger.warning(
@@ -342,7 +371,7 @@ class MARCImportJob:
         )
         try:
             set_job_profile.raise_for_status()
-            self.job_hrid = set_job_profile.json()['hrId']
+            self.job_hrid = set_job_profile.json()["hrId"]
             logger.info(f"Job HRID: {self.job_hrid}")
         except httpx.HTTPError as e:
             logger.error(
@@ -410,9 +439,7 @@ class MARCImportJob:
                 for record in self.record_batch:
                     self.failed_batches_file.write(record)
                 raise FolioDataImportBatchError(
-                    batch_payload['id'],
-                    f"{e}\n{e.response.text}",
-                    e
+                    batch_payload["id"], f"{e}\n{e.response.text}", e
                 )
         await self.get_job_status()
         sleep(self.batch_delay)
@@ -472,12 +499,12 @@ class MARCImportJob:
     def move_file_to_complete(self, file_path: Path):
         import_complete_path = file_path.parent.joinpath("import_complete")
         if not import_complete_path.exists():
-            logger.debug(f"Creating import_complete directory: {import_complete_path.absolute()}")
+            logger.debug(
+                f"Creating import_complete directory: {import_complete_path.absolute()}"
+            )
             import_complete_path.mkdir(exist_ok=True)
         logger.debug(f"Moving {file_path} to {import_complete_path.absolute()}")
-        file_path.rename(
-                file_path.parent.joinpath("import_complete", file_path.name)
-            )
+        file_path.rename(file_path.parent.joinpath("import_complete", file_path.name))
 
     async def create_batch_payload(self, counter, total_records, is_last) -> dict:
         """
@@ -521,11 +548,15 @@ class MARCImportJob:
 
                 record_body = f.read(record_length - 24)
                 if len(record_body) != record_length - 24:
-                    raise ValueError("Unexpected end of file while reading MARC record.")
+                    raise ValueError(
+                        "Unexpected end of file while reading MARC record."
+                    )
 
                 # Verify record terminator
-                if record_body[-1:] != b'\x1D':
-                    raise ValueError("MARC record does not end with the expected terminator (0x1D).")
+                if record_body[-1:] != b"\x1d":
+                    raise ValueError(
+                        "MARC record does not end with the expected terminator (0x1D)."
+                    )
 
                 # Write the full record to the batch buffer
                 batch.write(leader + record_body)
@@ -566,12 +597,11 @@ class MARCImportJob:
             try:
                 if isinstance(self.current_file[0], Path):
                     files = [
-                        stack.enter_context(open(file, "rb")) for file in self.current_file
+                        stack.enter_context(open(file, "rb"))
+                        for file in self.current_file
                     ]
                 elif isinstance(self.current_file[0], io.BytesIO):
-                    files = [
-                        stack.enter_context(file) for file in self.current_file
-                        ]
+                    files = [stack.enter_context(file) for file in self.current_file]
                 else:
                     raise ValueError("Invalid file type. Must be Path or BytesIO.")
             except IndexError as e:
@@ -598,13 +628,26 @@ class MARCImportJob:
                     await self.process_records(files, total_records)
                     while not self.finished:
                         await self.get_job_status()
-                    sleep(1)
+                    await asyncio.sleep(5)
                 except FolioDataImportBatchError as e:
                     logger.error(
                         f"Unhandled error posting batch {e.batch_id}: {e.message}"
                     )
                     await self.cancel_job()
                     raise e
+                except FolioDataImportJobError as e:
+                    await self.cancel_job()
+                    if self._job_retries < self._max_job_retries:
+                        self._job_retries += 1
+                        logger.error(
+                            f"Unhandled error processing job {e.job_id}: {e.message}, cancelling and retrying."
+                        )
+                        await self.import_marc_file()
+                    else:
+                        logger.critical(
+                            f"Unhandled error processing job {e.job_id}: {e.message}, cancelling and exiting (maximum retries reached)."
+                        )
+                        raise e
             if self.finished:
                 await self.log_job_summary()
             self.last_current = 0
@@ -629,7 +672,9 @@ class MARCImportJob:
             self.finished = True
             logger.info(f"Cancelled job: {self.job_id}")
         except (httpx.ConnectTimeout, httpx.ReadTimeout):
-            logger.warning(f"CONNECTION ERROR cancelling job {self.job_id}. Retrying...")
+            logger.warning(
+                f"CONNECTION ERROR cancelling job {self.job_id}. Retrying..."
+            )
             sleep(0.25)
             await self.cancel_job()
 
@@ -651,22 +696,22 @@ class MARCImportJob:
                 table_data.append(table_row)
             table_data.sort(key=lambda x: REPORT_SUMMARY_ORDERING.get(x[0], 99))
             columns = columns[:1] + [
-                        " ".join(decamelize(x).split("_")[:-1]) for x in columns[1:]
-                    ]
+                " ".join(decamelize(x).split("_")[:-1]) for x in columns[1:]
+            ]
             logger.info(
-                        f"Results for {'file' if len(self.current_file) == 1 else 'files'}: "
-                        f"{', '.join([os.path.basename(x.name) for x in self.current_file])}"
-                    )
+                f"Results for {'file' if len(self.current_file) == 1 else 'files'}: "
+                f"{', '.join([os.path.basename(x.name) for x in self.current_file])}"
+            )
             logger.info(
-                        "\n"
-                        + tabulate.tabulate(
-                            table_data, headers=columns, tablefmt="fancy_grid"
-                        ),
-                    )
+                "\n"
+                + tabulate.tabulate(table_data, headers=columns, tablefmt="fancy_grid"),
+            )
             if total_errors:
                 logger.info(f"Total errors: {total_errors}. Job ID: {job_id}.")
         else:
-            logger.error(f"No job summary available for job #{self.job_hrid}({self.job_id}).")
+            logger.error(
+                f"No job summary available for job #{self.job_hrid}({self.job_id})."
+            )
 
     async def get_job_summary(self) -> dict:
         """
@@ -691,8 +736,10 @@ class MARCImportJob:
             self.current_retry_timeout = None
         except (httpx.ConnectTimeout, httpx.ReadTimeout, httpx.HTTPStatusError) as e:
             error_text = e.response.text if hasattr(e, "response") else str(e)
-            if (self._max_summary_retries > self._summary_retries) and (not hasattr(e, "response") or (
-                hasattr(e, "response") and e.response.status_code in [502, 504]) and not self.let_summary_fail
+            if (self._max_summary_retries > self._summary_retries) and (
+                not hasattr(e, "response")
+                or (hasattr(e, "response") and e.response.status_code in [502, 504])
+                and not self.let_summary_fail
             ):
                 logger.warning(f"SERVER ERROR fetching job summary: {e}. Retrying.")
                 sleep(0.25)
@@ -703,8 +750,9 @@ class MARCImportJob:
                     self.folio_client.httpx_client = temp_client
                     self._summary_retries += 1
                     return await self.get_job_summary()
-            elif (self._summary_retries >= self._max_summary_retries) or (hasattr(e, "response") and (
-                e.response.status_code in [502, 504] and self.let_summary_fail)
+            elif (self._summary_retries >= self._max_summary_retries) or (
+                hasattr(e, "response")
+                and (e.response.status_code in [502, 504] and self.let_summary_fail)
             ):
                 logger.warning(
                     f"SERVER ERROR fetching job summary: {error_text}. Skipping final summary check."
@@ -809,7 +857,7 @@ async def main() -> None:
             "to apply to each MARC record before sending to FOLIO. Function should take "
             "a pymarc.Record object as input and return a pymarc.Record object."
         ),
-        default=None,
+        default="",
     )
 
     parser.add_argument(

folio_data_import/UserImport.py

@@ -8,7 +8,7 @@ import time
 import uuid
 from datetime import datetime as dt
 from pathlib import Path
-from typing import Tuple
+from typing import Tuple, List
 
 import aiofiles
 import folioclient
@@ -51,6 +51,7 @@ class UserImporter:  # noqa: R0902
         user_match_key: str = "externalSystemId",
         only_update_present_fields: bool = False,
         default_preferred_contact_type: str = "002",
+        fields_to_protect: List[str] =[],
     ) -> None:
         self.limit_simultaneous_requests = limit_simultaneous_requests
         self.batch_size = batch_size
@@ -77,6 +78,7 @@ class UserImporter:  # noqa: R0902
         self.match_key = user_match_key
         self.lock: asyncio.Lock = asyncio.Lock()
         self.logs: dict = {"created": 0, "updated": 0, "failed": 0}
+        self.fields_to_protect = set(fields_to_protect)
 
     @staticmethod
     def build_ref_data_id_map(
@@ -334,6 +336,7 @@ class UserImporter:  # noqa: R0902
             None
 
         """
+
         await self.set_preferred_contact_type(user_obj, existing_user)
         preferred_contact_type = {"preferredContactTypeId": existing_user.get("personal", {}).pop("preferredContactTypeId")}
         if self.only_update_present_fields:
@@ -502,7 +505,9 @@ class UserImporter:  # noqa: R0902
 
     async def get_protected_fields(self, existing_user) -> dict:
         """
-        Retrieves the protected fields from the existing user object.
+        Retrieves the protected fields from the existing user object,
+        combining both the customFields.protectedFields list *and*
+        any fields_to_protect passed on the CLI.
 
         Args:
             existing_user (dict): The existing user object.
@@ -512,18 +517,19 @@ class UserImporter:  # noqa: R0902
         """
         protected_fields = {}
         protected_fields_list = existing_user.get("customFields", {}).get("protectedFields", "").split(",")
-        for field in protected_fields_list:
-            if len(field.split(".")) > 1:
-                field, subfield = field.split(".")
-                if field not in protected_fields:
-                    protected_fields[field] = {}
-                protected_fields[field][subfield] = existing_user.get(field, {}).pop(subfield, None)
-                if protected_fields[field][subfield] is None:
-                    protected_fields[field].pop(subfield)
+        cli_fields = list(self.fields_to_protect)
+        # combine and dedupe:
+        all_fields = list(dict.fromkeys(protected_fields_list + cli_fields))
+        for field in all_fields:
+            if "." in field:
+                fld, subfld = field.split(".", 1)
+                val = existing_user.get(fld, {}).pop(subfld, None)
+                if val is not None:
+                    protected_fields.setdefault(fld, {})[subfld] = val
             else:
-                protected_fields[field] = existing_user.pop(field, None)
-                if protected_fields[field] is None:
-                    protected_fields.pop(field)
+                val = existing_user.pop(field, None)
+                if val is not None:
+                    protected_fields[field] = val
         return protected_fields
 
     async def process_existing_user(self, user_obj) -> Tuple[dict, dict, dict, dict]:
@@ -896,6 +902,7 @@ async def main() -> None:
         --update_only_present_fields (bool): Only update fields that are present in the new user object.
         --default_preferred_contact_type (str): The default preferred contact type to use if the provided \
             value is not valid or not present. Default "002".
+        --fields_to_protect (str): Comma-separated list of top-level or nested (dot-notation) fields to protect.
 
     Raises:
         Exception: If an unknown error occurs during the import process.
@@ -953,7 +960,20 @@ async def main() -> None:
         choices=list(PREFERRED_CONTACT_TYPES_MAP.keys()) + list(PREFERRED_CONTACT_TYPES_MAP.values()),
         default="002",
     )
+    parser.add_argument(
+        "--fields-to-protect",  # new flag name
+        dest="fields_to_protect",  # sets args.fields_to_protect
+        help=(
+            "Comma-separated list of top-level user fields to protect "
+            "(e.g. type,expirationDate)"
+        ),
+        default="",
+    )
     args = parser.parse_args()
+    protect_fields = [
+        f.strip() for f in args.fields_to_protect.split(",")
+        if f.strip()
+    ]
 
     library_name = args.library_name
 
@@ -1005,6 +1025,7 @@ async def main() -> None:
                 args.user_match_key,
                 args.update_only_present_fields,
                 args.default_preferred_contact_type,
+                fields_to_protect=protect_fields,
             )
             await importer.do_import()
         except Exception as ee:

folio_data_import/custom_exceptions.py

@@ -15,3 +15,15 @@ class FolioDataImportBatchError(FolioDataImportError):
         self.batch_id = batch_id
         self.message = message
         super().__init__(f"Unhandled error posting batch {batch_id}: {message}")
+
+class FolioDataImportJobError(FolioDataImportError):
+    """Exception raised for errors in the Folio Data Import job process.
+
+    Attributes:
+        job_id -- ID of the job that caused the error
+        message -- explanation of the error
+    """
+    def __init__(self, job_id, message, exception=None):
+        self.job_id = job_id
+        self.message = message
+        super().__init__(f"Unhandled error processing job {job_id}: {message}")

folio_data_import/marc_preprocessors/_preprocessors.py

@@ -3,6 +3,7 @@ import sys
 from typing import Callable, Dict, List, Tuple, Union
 import pymarc
 import logging
+import re
 
 from pymarc.record import Record
 
@@ -47,6 +48,9 @@ class MARCPreprocessor:
         """
         Get the preprocessor functions based on the provided names.
 
+        Args:
+            func_list (Union[str, List[Callable]]): A string of comma-separated function names or a list of callable preprocessor functions.
+
         Returns:
             List[callable]: A list of preprocessor functions.
         """
@@ -358,7 +362,7 @@ def clean_empty_fields(record: Record, **kwargs) -> Record:
 
     for field in record.get_fields(*MAPPED_FIELDS.keys()):
         len_subs = len(field.subfields)
-        subfield_value = bool(field.subfields[0].value) if len_subs else False
+        subfield_value = bool(re.sub(r"[.,-]", "", field.subfields[0].value).strip()) if len_subs else False
         if int(field.tag) > 9 and len_subs == 0:
             logger.log(
                 26,
@@ -460,12 +464,12 @@ def move_authority_subfield_9_to_0_all_controllable_fields(record: Record, **kwa
             "100", "110", "111", "130",
             "600", "610", "611", "630", "650", "651", "655",
             "700", "710", "711", "730",
-            "800", "810", "811", "830"
+            "800", "810", "811", "830", "880"
         ]
     for field in record.get_fields(*controlled_fields):
         for subfield in list(field.get_subfields("9")):
             field.add_subfield("0", subfield)
-            field.delete_subfield("9", subfield)
+            field.delete_subfield("9")
             logger.log(
                 26,
                 "DATA ISSUE\t%s\t%s\t%s",

{folio_data_import-0.3.0.dist-info → folio_data_import-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: folio_data_import
-Version: 0.3.0
+Version: 0.3.2
 Summary: A python module to interact with the data importing capabilities of the open-source FOLIO ILS
 License: MIT
 Author: Brooks Travis

folio_data_import-0.3.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+folio_data_import/MARCDataImport.py,sha256=Qfpc3NtlQe4VUobXsFhmSnScBhiNRGEzBN7FZrdsBYc,37633
+folio_data_import/UserImport.py,sha256=4Bn_Z1xX5DvnodscW9NgGeBZgvFeShVoIbxDGrt6BMo,41748
+folio_data_import/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+folio_data_import/__main__.py,sha256=kav_uUsnrIjGjVxQkk3exLKrc1mah9t2x3G6bGS-5I0,3710
+folio_data_import/custom_exceptions.py,sha256=1xw1BI5fW7WDd37zUIOcw0DAvrFKtklnqmbRhZXSAiE,1093
+folio_data_import/marc_preprocessors/__init__.py,sha256=urExfNTQoZsDCtDPcUY9EEC5OFcUihxhYEQkQFVzbMY,30
+folio_data_import/marc_preprocessors/_preprocessors.py,sha256=HnW7hw7DFTxyiUxYtl-8v0liW4FDi0y5SvI2ZwhdWPU,16570
+folio_data_import-0.3.2.dist-info/LICENSE,sha256=qJX7wxMC7ky9Kq4v3zij8MjGEiC5wsB7pYeOhLj5TDk,1083
+folio_data_import-0.3.2.dist-info/METADATA,sha256=r8J3ZZm833GcuaCAAj-mBZ2bVPyq4Xa6rPgqSbgVBkE,6069
+folio_data_import-0.3.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+folio_data_import-0.3.2.dist-info/entry_points.txt,sha256=498SxWVXeEMRNw3PUf-eoReZvKewmYwPBtZhIUPr_Jg,192
+folio_data_import-0.3.2.dist-info/RECORD,,

folio_data_import-0.3.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-folio_data_import/MARCDataImport.py,sha256=je3TdCdaDR-gYA3Gh1k4AX9l3v83sCTt4Y9lOFxayu8,36220
-folio_data_import/UserImport.py,sha256=ZulGaGJhI_N5vmR69YF_qbzbGeVyzcthXklSjDpZCyA,40998
-folio_data_import/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-folio_data_import/__main__.py,sha256=kav_uUsnrIjGjVxQkk3exLKrc1mah9t2x3G6bGS-5I0,3710
-folio_data_import/custom_exceptions.py,sha256=xOeIbM86d2r5-z3ul4JFTJLT3vI3kwmEq62cWS-9dOc,646
-folio_data_import/marc_preprocessors/__init__.py,sha256=urExfNTQoZsDCtDPcUY9EEC5OFcUihxhYEQkQFVzbMY,30
-folio_data_import/marc_preprocessors/_preprocessors.py,sha256=4Zrp-9LdL7f5QqUTOjyMkK5IaHP2YOkmkqoY_4o585Q,16377
-folio_data_import-0.3.0.dist-info/LICENSE,sha256=qJX7wxMC7ky9Kq4v3zij8MjGEiC5wsB7pYeOhLj5TDk,1083
-folio_data_import-0.3.0.dist-info/METADATA,sha256=Aqf0PXhdwFyChMKvl9cOluKN60IyMAUPDKSpb8AOlXI,6069
-folio_data_import-0.3.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-folio_data_import-0.3.0.dist-info/entry_points.txt,sha256=498SxWVXeEMRNw3PUf-eoReZvKewmYwPBtZhIUPr_Jg,192
-folio_data_import-0.3.0.dist-info/RECORD,,