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

folio_data_import/UserImport.py

@@ -1,19 +1,32 @@
-import argparse
 import asyncio
 import datetime
-import getpass
 import json
-import os
+import logging
+import sys
 import time
 import uuid
 from datetime import datetime as dt
+from enum import Enum
 from pathlib import Path
-from typing import Tuple, List
+from typing import List, Tuple
 
 import aiofiles
 import folioclient
 import httpx
+import typer
 from aiofiles.threadpool.text import AsyncTextIOWrapper
+from rich.logging import RichHandler
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from typing_extensions import Annotated
+
+from folio_data_import._progress import ItemsPerSecondColumn, UserStatsColumn
 
 try:
     utc = datetime.UTC
@@ -22,6 +35,8 @@ except AttributeError:
 
     utc = zoneinfo.ZoneInfo("UTC")
 
+logger = logging.getLogger(__name__)
+
 # Mapping of preferred contact type IDs to their corresponding values
 PREFERRED_CONTACT_TYPES_MAP = {
     "001": "mail",
@@ -31,6 +46,26 @@ PREFERRED_CONTACT_TYPES_MAP = {
     "005": "mobile",
 }
 
+
+class PreferredContactType(Enum):
+    MAIL = "001"
+    EMAIL = "002"
+    TEXT = "003"
+    PHONE = "004"
+    MOBILE = "005"
+    _001 = "mail"
+    _002 = "email"
+    _003 = "text"
+    _004 = "phone"
+    _005 = "mobile"
+
+
+class UserMatchKeys(Enum):
+    USERNAME = "username"
+    EMAIL = "email"
+    EXTERNAL_SYSTEM_ID = "externalSystemId"
+
+
 class UserImporter:  # noqa: R0902
     """
     Class to import mod-user-import compatible user objects
@@ -38,20 +73,22 @@ class UserImporter:  # noqa: R0902
     from a JSON-lines file into FOLIO
     """
 
+    logfile: AsyncTextIOWrapper
+    errorfile: AsyncTextIOWrapper
+    http_client: httpx.AsyncClient
+
     def __init__(
         self,
         folio_client: folioclient.FolioClient,
         library_name: str,
         batch_size: int,
         limit_simultaneous_requests: asyncio.Semaphore,
-        logfile: AsyncTextIOWrapper,
-        errorfile: AsyncTextIOWrapper,
-        http_client: httpx.AsyncClient,
         user_file_path: Path = None,
         user_match_key: str = "externalSystemId",
         only_update_present_fields: bool = False,
         default_preferred_contact_type: str = "002",
-        fields_to_protect: List[str] =[],
+        fields_to_protect: List[str] = [],
+        no_progress: bool = False,
     ) -> None:
         self.limit_simultaneous_requests = limit_simultaneous_requests
         self.batch_size = batch_size
@@ -70,15 +107,13 @@ class UserImporter:  # noqa: R0902
         self.service_point_map: dict = self.build_ref_data_id_map(
             self.folio_client, "/service-points", "servicepoints", "code"
         )
-        self.logfile: AsyncTextIOWrapper = logfile
-        self.errorfile: AsyncTextIOWrapper = errorfile
-        self.http_client: httpx.AsyncClient = http_client
         self.only_update_present_fields: bool = only_update_present_fields
         self.default_preferred_contact_type: str = default_preferred_contact_type
         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)
+        self.no_progress = no_progress
 
     @staticmethod
     def build_ref_data_id_map(
@@ -114,17 +149,36 @@ class UserImporter:  # noqa: R0902
         except ValueError:
             return False
 
+    async def setup(self, error_file_path: Path) -> None:
+        """
+        Sets up the importer by initializing necessary resources.
+
+        Args:
+            log_file_path (Path): The path to the log file.
+            error_file_path (Path): The path to the error file.
+        """
+        self.errorfile = await aiofiles.open(error_file_path, "w", encoding="utf-8")
+
+    async def close(self) -> None:
+        """
+        Closes the importer by releasing any resources.
+
+        """
+        await self.errorfile.close()
+
     async def do_import(self) -> None:
         """
         Main method to import users.
 
         This method triggers the process of importing users by calling the `process_file` method.
         """
-        if self.user_file_path:
-            with open(self.user_file_path, "r", encoding="utf-8") as openfile:
-                await self.process_file(openfile)
-        else:
-            raise FileNotFoundError("No user objects file provided")
+        async with httpx.AsyncClient() as client:
+            self.http_client = client
+            if self.user_file_path:
+                with open(self.user_file_path, "r", encoding="utf-8") as openfile:
+                    await self.process_file(openfile)
+            else:
+                raise FileNotFoundError("No user objects file provided")
 
     async def get_existing_user(self, user_obj) -> dict:
         """
@@ -227,7 +281,7 @@ class UserImporter:  # noqa: R0902
                         self.validate_uuid(address["addressTypeId"])
                         and address["addressTypeId"] in self.address_type_map.values()
                     ):
-                        await self.logfile.write(
+                        logger.debug(
                             f"Row {line_number}: Address type {address['addressTypeId']} is a UUID, "
                             f"skipping mapping\n"
                         )
@@ -239,11 +293,7 @@ class UserImporter:  # noqa: R0902
                         mapped_addresses.append(address)
                 except KeyError:
                     if address["addressTypeId"] not in self.address_type_map.values():
-                        print(
-                            f"Row {line_number}: Address type {address['addressTypeId']} not found"
-                            f", removing address"
-                        )
-                        await self.logfile.write(
+                        logger.error(
                             f"Row {line_number}: Address type {address['addressTypeId']} not found"
                             f", removing address\n"
                         )
@@ -266,7 +316,7 @@ class UserImporter:  # noqa: R0902
                 self.validate_uuid(user_obj["patronGroup"])
                 and user_obj["patronGroup"] in self.patron_group_map.values()
             ):
-                await self.logfile.write(
+                logger.debug(
                     f"Row {line_number}: Patron group {user_obj['patronGroup']} is a UUID, "
                     f"skipping mapping\n"
                 )
@@ -274,11 +324,7 @@ class UserImporter:  # noqa: R0902
                 user_obj["patronGroup"] = self.patron_group_map[user_obj["patronGroup"]]
         except KeyError:
             if user_obj["patronGroup"] not in self.patron_group_map.values():
-                print(
-                    f"Row {line_number}: Patron group {user_obj['patronGroup']} not found, "
-                    f"removing patron group"
-                )
-                await self.logfile.write(
+                logger.error(
                     f"Row {line_number}: Patron group {user_obj['patronGroup']} not found in, "
                     f"removing patron group\n"
                 )
@@ -302,25 +348,23 @@ class UserImporter:  # noqa: R0902
                     self.validate_uuid(department)
                     and department in self.department_map.values()
                 ):
-                    await self.logfile.write(
+                    logger.debug(
                         f"Row {line_number}: Department {department} is a UUID, skipping mapping\n"
                     )
                     mapped_departments.append(department)
                 else:
                     mapped_departments.append(self.department_map[department])
             except KeyError:
-                print(
-                    f'Row {line_number}: Department "{department}" not found, '  # noqa: B907
-                    f"excluding department from user"
-                )
-                await self.logfile.write(
+                logger.error(
                     f'Row {line_number}: Department "{department}" not found, '  # noqa: B907
                     f"excluding department from user\n"
                 )
         if mapped_departments:
             user_obj["departments"] = mapped_departments
 
-    async def update_existing_user(self, user_obj, existing_user, protected_fields) -> Tuple[dict, dict]:
+    async def update_existing_user(
+        self, user_obj, existing_user, protected_fields
+    ) -> Tuple[dict, dict]:
         """
         Updates an existing user with the provided user object.
 
@@ -338,7 +382,11 @@ class UserImporter:  # noqa: R0902
         """
 
         await self.set_preferred_contact_type(user_obj, existing_user)
-        preferred_contact_type = {"preferredContactTypeId": existing_user.get("personal", {}).pop("preferredContactTypeId")}
+        preferred_contact_type = {
+            "preferredContactTypeId": existing_user.get("personal", {}).pop(
+                "preferredContactTypeId"
+            )
+        }
         if self.only_update_present_fields:
             new_personal = user_obj.pop("personal", {})
             existing_personal = existing_user.pop("personal", {})
@@ -412,30 +460,39 @@ class UserImporter:  # noqa: R0902
             current_pref_contact = user_obj["personal"].get(
                 "preferredContactTypeId", ""
             )
-            if mapped_contact_type := dict([(v, k) for k, v in PREFERRED_CONTACT_TYPES_MAP.items()]).get(
+            if mapped_contact_type := dict(
+                [(v, k) for k, v in PREFERRED_CONTACT_TYPES_MAP.items()]
+            ).get(
                 current_pref_contact,
                 "",
             ):
-                existing_user["personal"]["preferredContactTypeId"] = mapped_contact_type
+                existing_user["personal"]["preferredContactTypeId"] = (
+                    mapped_contact_type
+                )
             else:
-                existing_user["personal"]["preferredContactTypeId"] = current_pref_contact if current_pref_contact in PREFERRED_CONTACT_TYPES_MAP else self.default_preferred_contact_type
+                existing_user["personal"]["preferredContactTypeId"] = (
+                    current_pref_contact
+                    if current_pref_contact in PREFERRED_CONTACT_TYPES_MAP
+                    else self.default_preferred_contact_type
+                )
         else:
-            print(
-                f"Preferred contact type not provided or is not a valid option: {PREFERRED_CONTACT_TYPES_MAP}\n"
+            logger.warning(
+                f"Preferred contact type not provided or is not a valid option: {PREFERRED_CONTACT_TYPES_MAP} "
                 f"Setting preferred contact type to {self.default_preferred_contact_type} or using existing value"
             )
-            await self.logfile.write(
-                f"Preferred contact type not provided or is not a valid option: {PREFERRED_CONTACT_TYPES_MAP}\n"
-                f"Setting preferred contact type to {self.default_preferred_contact_type} or using existing value\n"
+            mapped_contact_type = (
+                existing_user.get("personal", {}).get("preferredContactTypeId", "")
+                or self.default_preferred_contact_type
             )
-            mapped_contact_type = existing_user.get("personal", {}).get(
-                "preferredContactTypeId", ""
-            ) or self.default_preferred_contact_type
             if "personal" not in existing_user:
                 existing_user["personal"] = {}
-            existing_user["personal"]["preferredContactTypeId"] = mapped_contact_type or self.default_preferred_contact_type
+            existing_user["personal"]["preferredContactTypeId"] = (
+                mapped_contact_type or self.default_preferred_contact_type
+            )
 
-    async def create_or_update_user(self, user_obj, existing_user, protected_fields, line_number) -> dict:
+    async def create_or_update_user(
+        self, user_obj, existing_user, protected_fields, line_number
+    ) -> dict:
         """
         Creates or updates a user based on the given user object and existing user.
 
@@ -456,11 +513,7 @@ class UserImporter:  # noqa: R0902
                 self.logs["updated"] += 1
                 return existing_user
             except Exception as ee:
-                print(
-                    f"Row {line_number}: User update failed: "
-                    f"{str(getattr(getattr(ee, 'response', str(ee)), 'text', str(ee)))}"
-                )
-                await self.logfile.write(
+                logger.error(
                     f"Row {line_number}: User update failed: "
                     f"{str(getattr(getattr(ee, 'response', str(ee)), 'text', str(ee)))}\n"
                 )
@@ -474,11 +527,7 @@ class UserImporter:  # noqa: R0902
                 new_user = await self.create_new_user(user_obj)
                 return new_user
             except Exception as ee:
-                print(
-                    f"Row {line_number}: User creation failed: "
-                    f"{str(getattr(getattr(ee, 'response', str(ee)), 'text', str(ee)))}"
-                )
-                await self.logfile.write(
+                logger.error(
                     f"Row {line_number}: User creation failed: "
                     f"{str(getattr(getattr(ee, 'response', str(ee)), 'text', str(ee)))}\n"
                 )
@@ -516,7 +565,9 @@ class UserImporter:  # noqa: R0902
             dict: A dictionary containing the protected fields and their values.
         """
         protected_fields = {}
-        protected_fields_list = existing_user.get("customFields", {}).get("protectedFields", "").split(",")
+        protected_fields_list = (
+            existing_user.get("customFields", {}).get("protectedFields", "").split(",")
+        )
         cli_fields = list(self.fields_to_protect)
         # combine and dedupe:
         all_fields = list(dict.fromkeys(protected_fields_list + cli_fields))
@@ -557,7 +608,15 @@ class UserImporter:  # noqa: R0902
             existing_pu = {}
             existing_spu = {}
             protected_fields = {}
-        return rp_obj, spu_obj, existing_user, protected_fields, existing_rp, existing_pu, existing_spu
+        return (
+            rp_obj,
+            spu_obj,
+            existing_user,
+            protected_fields,
+            existing_rp,
+            existing_pu,
+            existing_spu,
+        )
 
     async def create_or_update_rp(self, rp_obj, existing_rp, new_user_obj):
         """
@@ -572,10 +631,8 @@ class UserImporter:  # noqa: R0902
             None
         """
         if existing_rp:
-            # print(existing_rp)
             await self.update_existing_rp(rp_obj, existing_rp)
         else:
-            # print(new_user_obj)
             await self.create_new_rp(new_user_obj)
 
     async def create_new_rp(self, new_user_obj):
@@ -593,7 +650,6 @@ class UserImporter:  # noqa: R0902
         """
         rp_obj = {"holdShelf": True, "delivery": False}
         rp_obj["userId"] = new_user_obj["id"]
-        # print(rp_obj)
         response = await self.http_client.post(
             self.folio_client.gateway_url
             + "/request-preference-storage/request-preference",
@@ -617,7 +673,6 @@ class UserImporter:  # noqa: R0902
             None
         """
         existing_rp.update(rp_obj)
-        # print(existing_rp)
         response = await self.http_client.put(
             self.folio_client.gateway_url
             + f"/request-preference-storage/request-preference/{existing_rp['id']}",
@@ -668,9 +723,15 @@ class UserImporter:  # noqa: R0902
         """
         async with self.limit_simultaneous_requests:
             user_obj = await self.process_user_obj(user)
-            rp_obj, spu_obj, existing_user, protected_fields, existing_rp, existing_pu, existing_spu = (
-                await self.process_existing_user(user_obj)
-            )
+            (
+                rp_obj,
+                spu_obj,
+                existing_user,
+                protected_fields,
+                existing_rp,
+                existing_pu,
+                existing_spu,
+            ) = await self.process_existing_user(user_obj)
             await self.map_address_types(user_obj, line_number)
             await self.map_patron_groups(user_obj, line_number)
             await self.map_departments(user_obj, line_number)
@@ -684,11 +745,7 @@ class UserImporter:  # noqa: R0902
                             rp_obj, existing_rp, new_user_obj
                         )
                     else:
-                        print(
-                            f"Row {line_number}: Creating default request preference object"
-                            f" for {new_user_obj['id']}"
-                        )
-                        await self.logfile.write(
+                        logger.debug(
                             f"Row {line_number}: Creating default request preference object"
                             f" for {new_user_obj['id']}\n"
                         )
@@ -699,8 +756,7 @@ class UserImporter:  # noqa: R0902
                         f"{new_user_obj['id']}: "
                         f"{str(getattr(getattr(ee, 'response', ee), 'text', str(ee)))}"
                     )
-                    print(rp_error_message)
-                    await self.logfile.write(rp_error_message + "\n")
+                    logger.error(rp_error_message)
                 if not existing_pu:
                     try:
                         await self.create_perms_user(new_user_obj)
@@ -710,9 +766,10 @@ class UserImporter:  # noqa: R0902
                             f"{new_user_obj['id']}: "
                             f"{str(getattr(getattr(ee, 'response', str(ee)), 'text', str(ee)))}"
                         )
-                        print(pu_error_message)
-                        await self.logfile.write(pu_error_message + "\n")
-                await self.handle_service_points_user(spu_obj, existing_spu, new_user_obj)
+                        logger.error(pu_error_message)
+                await self.handle_service_points_user(
+                    spu_obj, existing_spu, new_user_obj
+                )
 
     async def map_service_points(self, spu_obj, existing_user):
         """
@@ -730,40 +787,43 @@ class UserImporter:  # noqa: R0902
             for sp in spu_obj.pop("servicePointsIds", []):
                 try:
                     if self.validate_uuid(sp) and sp in self.service_point_map.values():
-                        await self.logfile.write(
+                        logger.debug(
                             f"Service point {sp} is a UUID, skipping mapping\n"
                         )
                         mapped_service_points.append(sp)
                     else:
                         mapped_service_points.append(self.service_point_map[sp])
                 except KeyError:
-                    print(
+                    logger.error(
                         f'Service point "{sp}" not found, excluding service point from user: '
-                        f'{self.service_point_map}'
+                        f"{self.service_point_map}"
                     )
             if mapped_service_points:
                 spu_obj["servicePointsIds"] = mapped_service_points
         if "defaultServicePointId" in spu_obj:
-            sp_code = spu_obj.pop('defaultServicePointId', '')
+            sp_code = spu_obj.pop("defaultServicePointId", "")
             try:
-                if self.validate_uuid(sp_code) and sp_code in self.service_point_map.values():
-                    await self.logfile.write(
+                if (
+                    self.validate_uuid(sp_code)
+                    and sp_code in self.service_point_map.values()
+                ):
+                    logger.debug(
                         f"Default service point {sp_code} is a UUID, skipping mapping\n"
                     )
                     mapped_sp_id = sp_code
                 else:
                     mapped_sp_id = self.service_point_map[sp_code]
-                if mapped_sp_id not in spu_obj.get('servicePointsIds', []):
-                    print(
+                if mapped_sp_id not in spu_obj.get("servicePointsIds", []):
+                    logger.warning(
                         f'Default service point "{sp_code}" not found in assigned service points, '
-                        'excluding default service point from user'
+                        "excluding default service point from user"
                     )
                 else:
-                    spu_obj['defaultServicePointId'] = mapped_sp_id
+                    spu_obj["defaultServicePointId"] = mapped_sp_id
             except KeyError:
-                print(
+                logger.error(
                     f'Default service point "{sp_code}" not found, excluding default service '
-                    f'point from user: {existing_user["id"]}'
+                    f"point from user: {existing_user['id']}"
                 )
 
     async def handle_service_points_user(self, spu_obj, existing_spu, existing_user):
@@ -837,7 +897,8 @@ class UserImporter:  # noqa: R0902
         """
         existing_spu.update(spu_obj)
         response = await self.http_client.put(
-            self.folio_client.gateway_url + f"/service-points-users/{existing_spu['id']}",
+            self.folio_client.gateway_url
+            + f"/service-points-users/{existing_spu['id']}",
             headers=self.folio_client.okapi_headers,
             json=existing_spu,
         )
@@ -850,199 +911,269 @@ class UserImporter:  # noqa: R0902
         Args:
             openfile: The file or file-like object to process.
         """
-        tasks = []
-        for line_number, user in enumerate(openfile):
-            tasks.append(self.process_line(user, line_number))
-            if len(tasks) == self.batch_size:
+        with Progress(  # Set up the progress bar
+            "{task.description}",
+            SpinnerColumn(),
+            BarColumn(),
+            MofNCompleteColumn(),
+            UserStatsColumn(),
+            "[",
+            TimeElapsedColumn(),
+            "<",
+            TimeRemainingColumn(),
+            "/",
+            ItemsPerSecondColumn(),
+            "]",
+        ) as progress:
+            with open(openfile.name, "rb") as f:
+                total_lines = sum(
+                    buf.count(b"\n") for buf in iter(lambda: f.read(1024 * 1024), b"")
+                )
+            self.progress = progress
+            self.task_progress = progress.add_task(
+                "Importing users: ", total=total_lines, created=0, updated=0, failed=0, visible=not self.no_progress
+            )  # Add a task to the progress bar
+            openfile.seek(0)
+            tasks = []
+            for line_number, user in enumerate(openfile):
+                tasks.append(self.process_line(user, line_number))
+                if len(tasks) == self.batch_size:
+                    start = time.time()
+                    await asyncio.gather(*tasks)
+                    duration = time.time() - start
+                    async with self.lock:
+                        progress.update(
+                            self.task_progress,
+                            advance=len(tasks),
+                            created=self.logs["created"],
+                            updated=self.logs["updated"],
+                            failed=self.logs["failed"],
+                        )
+                        message = (
+                            f"{dt.now().isoformat(sep=' ', timespec='milliseconds')}: "
+                            f"Batch of {self.batch_size} users processed in {duration:.2f} "
+                            f"seconds. - Users created: {self.logs['created']} - Users updated: "
+                            f"{self.logs['updated']} - Users failed: {self.logs['failed']}"
+                        )
+                        logger.info(message)
+                    tasks = []
+            if tasks:
                 start = time.time()
                 await asyncio.gather(*tasks)
                 duration = time.time() - start
                 async with self.lock:
+                    progress.update(
+                        self.task_progress,
+                        advance=len(tasks),
+                        created=self.logs["created"],
+                        updated=self.logs["updated"],
+                        failed=self.logs["failed"],
+                    )
                     message = (
                         f"{dt.now().isoformat(sep=' ', timespec='milliseconds')}: "
-                        f"Batch of {self.batch_size} users processed in {duration:.2f} "
-                        f"seconds. - Users created: {self.logs['created']} - Users updated: "
+                        f"Batch of {len(tasks)} users processed in {duration:.2f} seconds. - "
+                        f"Users created: {self.logs['created']} - Users updated: "
                         f"{self.logs['updated']} - Users failed: {self.logs['failed']}"
                     )
-                    print(message)
-                    await self.logfile.write(message + "\n")
-                tasks = []
-        if tasks:
-            start = time.time()
-            await asyncio.gather(*tasks)
-            duration = time.time() - start
-            async with self.lock:
-                message = (
-                    f"{dt.now().isoformat(sep=' ', timespec='milliseconds')}: "
-                    f"Batch of {len(tasks)} users processed in {duration:.2f} seconds. - "
-                    f"Users created: {self.logs['created']} - Users updated: "
-                    f"{self.logs['updated']} - Users failed: {self.logs['failed']}"
-                )
-                print(message)
-                await self.logfile.write(message + "\n")
+                    logger.info(message)
 
 
-async def main() -> None:
+def set_up_cli_logging():
     """
-    Entry point of the user import script.
-
-    Parses command line arguments, initializes necessary objects, and starts the import process.
-
-    Args:
-        --tenant_id (str): The tenant id.
-        --library_name (str): The name of the library.
-        --username (str): The FOLIO username.
-        --okapi_url (str): The Okapi URL.
-        --user_file_path (str): The path to the user file.
-        --limit_async_requests (int): Limit how many http requests can be made at once. Default 10.
-        --batch_size (int): How many records to process before logging statistics. Default 250.
-        --folio_password (str): The FOLIO password.
-        --user_match_key (str): The key to use to match users. Default "externalSystemId".
-        --report_file_base_path (str): The base path for the log and error files. Default "./".
-        --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.
-
-    Returns:
-        None
+    This function sets up logging for the CLI.
     """
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--tenant_id", help="The tenant id")
-    parser.add_argument(
-        "--member_tenant_id",
-        help="The FOLIO ECS member tenant id (if applicable)",
-        default="",
-    )
-    parser.add_argument("--library_name", help="The name of the library")
-    parser.add_argument("--username", help="The FOLIO username")
-    parser.add_argument("--okapi_url", help="The Okapi URL")
-    parser.add_argument("--user_file_path", help="The path to the user file")
-    parser.add_argument(
-        "--limit_async_requests",
-        help="Limit how many http requests can be made at once",
-        type=int,
-        default=10,
-    )
-    parser.add_argument(
-        "--batch_size",
-        help="How many user records to process before logging statistics",
-        type=int,
-        default=250,
-    )
-    parser.add_argument("--folio_password", help="The FOLIO password")
-    parser.add_argument(
-        "--user_match_key",
-        help="The key to use to match users",
-        choices=["externalSystemId", "barcode", "username"],
-        default="externalSystemId",
-    )
-    parser.add_argument(
-        "--report_file_base_path",
-        help="The base path for the log and error files",
-        default="./",
-    )
-    parser.add_argument(
-        "--update_only_present_fields",
-        help="Only update fields that are present in the user object",
-        action="store_true",
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+
+    # Set up file and stream handlers
+    file_handler = logging.FileHandler(
+        "folio_user_import_{}.log".format(dt.now().strftime("%Y%m%d%H%M%S"))
     )
-    parser.add_argument(
-        "--default_preferred_contact_type",
-        help=(
-            "The default preferred contact type to use if the provided value is not present or not valid. "
-            "Note: '002' is the default, and will be used if the provided value is not valid or not present, "
-            "unless the existing user object being updated has a valid preferred contact type set."
+    file_handler.setLevel(logging.INFO)
+    file_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    file_handler.setFormatter(file_formatter)
+    logger.addHandler(file_handler)
+
+    if not any(
+        isinstance(h, logging.StreamHandler) and h.stream == sys.stderr
+        for h in logger.handlers
+    ):
+        stream_handler = RichHandler(
+            show_level=False,
+            show_time=False,
+            omit_repeated_times=False,
+            show_path=False,
+        )
+        stream_handler.setLevel(logging.WARNING)
+        stream_formatter = logging.Formatter("%(message)s")
+        stream_handler.setFormatter(stream_formatter)
+        logger.addHandler(stream_handler)
+
+    # Stop httpx from logging info messages to the console
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    gateway_url: Annotated[
+        str,
+        typer.Option(
+            ...,
+            prompt="Please enter the FOLIO API Gateway URL",
+            help="The FOLIO API Gateway URL",
+            envvar="FOLIO_GATEWAY_URL",
         ),
-        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)"
+    ],
+    tenant_id: Annotated[
+        str,
+        typer.Option(
+            ...,
+            prompt="Please enter the FOLIO tenant id",
+            help="The tenant id",
+            envvar="FOLIO_TENANT_ID",
         ),
-        default="",
-    )
-    args = parser.parse_args()
-    protect_fields = [
-        f.strip() for f in args.fields_to_protect.split(",")
-        if f.strip()
-    ]
+    ],
+    username: Annotated[
+        str,
+        typer.Option(
+            ...,
+            prompt="Please enter your FOLIO username",
+            help="The FOLIO username",
+            envvar="FOLIO_USERNAME",
+        ),
+    ],
+    password: Annotated[
+        str,
+        typer.Option(
+            ...,
+            prompt="Please enter your FOLIO Password",
+            hide_input=True,
+            help="The FOLIO password",
+            envvar="FOLIO_PASSWORD",
+        ),
+    ],
+    library_name: Annotated[
+        str,
+        typer.Option(
+            ...,
+            prompt="Please enter the library name",
+            help="The name of the library",
+            envvar="FOLIO_LIBRARY_NAME",
+        ),
+    ],
+    user_file_path: Annotated[
+        Path, typer.Option(..., help="The path to the user file")
+    ],
+    member_tenant_id: Annotated[
+        str,
+        typer.Option(
+            help="The FOLIO ECS member tenant id (if applicable)",
+            envvar="FOLIO_MEMBER_TENANT_ID",
+        ),
+    ] = "",
+    fields_to_protect: Annotated[
+        str,
+        typer.Option(
+            help="Comma-separated list of top-level or nested (dot-notation) fields to protect"
+        ),
+    ] = "",
+    update_only_present_fields: bool = typer.Option(
+        False,
+        "--update-only-present-fields",
+        help="Only update fields that are present in the new user object",
+    ),
+    limit_async_requests: Annotated[
+        int,
+        typer.Option(
+            help="Limit how many http requests can be made at once",
+            envvar="FOLIO_LIMIT_ASYNC_REQUESTS",
+        ),
+    ] = 10,
+    batch_size: Annotated[
+        int,
+        typer.Option(
+            help="How many user records to process before logging statistics",
+            envvar="FOLIO_USER_IMPORT_BATCH_SIZE",
+        ),
+    ] = 250,
+    report_file_base_path: Annotated[
+        Path, typer.Option(help="The base path for the log and error files")
+    ] = Path.cwd(),
+    user_match_key: UserMatchKeys = typer.Option(
+        UserMatchKeys.EXTERNAL_SYSTEM_ID.value, help="The key to use to match users"
+    ),
+    default_preferred_contact_type: PreferredContactType = typer.Option(
+        PreferredContactType.EMAIL.value,
+        case_sensitive=False,
+        help="The default preferred contact type to use if the provided value is not valid or not present",
+    ),
+    no_progress: bool = typer.Option(
+        False,
+        "--no-progress",
+        help="Disable progress bar display during user import",
+    ),
+) -> None:
+    """
+    Command-line interface to batch import users into FOLIO
+    """
+    set_up_cli_logging()
+    protect_fields = [f.strip() for f in fields_to_protect.split(",") if f.strip()]
 
-    library_name = args.library_name
+    library_name = library_name
 
     # Semaphore to limit the number of async HTTP requests active at any given time
-    limit_async_requests = asyncio.Semaphore(args.limit_async_requests)
-    batch_size = args.batch_size
-
-    folio_client = folioclient.FolioClient(
-        args.okapi_url,
-        args.tenant_id,
-        args.username,
-        args.folio_password
-        or os.environ.get("FOLIO_PASS", "")
-        or getpass.getpass(
-            "Enter your FOLIO password: ",
-        ),
-    )
+    limit_async_requests = asyncio.Semaphore(limit_async_requests)
+    batch_size = batch_size
+
+    folio_client = folioclient.FolioClient(gateway_url, tenant_id, username, password)
 
     # Set the member tenant id if provided to support FOLIO ECS multi-tenant environments
-    if args.member_tenant_id:
-        folio_client.okapi_headers["x-okapi-tenant"] = args.member_tenant_id
+    if member_tenant_id:
+        folio_client.okapi_headers["x-okapi-tenant"] = member_tenant_id
 
-    user_file_path = Path(args.user_file_path)
-    report_file_base_path = Path(args.report_file_base_path)
-    log_file_path = (
-        report_file_base_path
-        / f"log_user_import_{dt.now(utc).strftime('%Y%m%d_%H%M%S')}.log"
-    )
+    user_file_path = user_file_path
+    report_file_base_path = report_file_base_path
     error_file_path = (
         report_file_base_path
         / f"failed_user_import_{dt.now(utc).strftime('%Y%m%d_%H%M%S')}.txt"
     )
-    async with aiofiles.open(
-        log_file_path,
-        "w",
-    ) as logfile, aiofiles.open(
-        error_file_path, "w"
-    ) as errorfile, httpx.AsyncClient(timeout=None) as http_client:
-        try:
-            importer = UserImporter(
-                folio_client,
-                library_name,
-                batch_size,
-                limit_async_requests,
-                logfile,
-                errorfile,
-                http_client,
-                user_file_path,
-                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:
-            print(f"An unknown error occurred: {ee}")
-            await logfile.write(f"An error occurred {ee}\n")
-            raise ee
+    try:
+        importer = UserImporter(
+            folio_client,
+            library_name,
+            batch_size,
+            limit_async_requests,
+            user_file_path,
+            user_match_key.value,
+            update_only_present_fields,
+            default_preferred_contact_type.value,
+            fields_to_protect=protect_fields,
+            no_progress=no_progress
+        )
+        asyncio.run(run_user_importer(importer, error_file_path))
+    except Exception as ee:
+        logger.critical(f"An unknown error occurred: {ee}")
+        raise typer.Exit(1)
 
 
-def sync_main() -> None:
-    """
-    Synchronous version of the main function.
+async def run_user_importer(importer: UserImporter, error_file_path: Path):
+    try:
+        await importer.setup(error_file_path)
+        await importer.do_import()
+    except Exception as ee:
+        logger.critical(f"An unknown error occurred: {ee}")
+        typer.Exit(1)
+    finally:
+        await importer.close()
 
-    This function is used to run the main function in a synchronous context.
-    """
-    asyncio.run(main())
+
+def _main():
+    typer.run(main)
 
 
 # Run the main function
 if __name__ == "__main__":
-    asyncio.run(main())
+    app()