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

folio_migration_tools/migration_report.py

@@ -1,5 +1,7 @@
 import logging
-from folio_migration_tools.report_blurbs import Blurbs
+import i18n
+from datetime import datetime
+from datetime import timezone
 
 
 class MigrationReport:
@@ -9,58 +11,103 @@ class MigrationReport:
         self.report = {}
         self.stats = {}
 
-    def add(self, blurb_tuple: tuple, measure_to_add, number=1):
-        """Add section header and values to migration report."""
+    def add(self, blurb_id, measure_to_add, number=1):
+        """Add section header and values to migration report.
+
+        Args:
+            blurb_id (string): ID of Blurb in translations file
+            measure_to_add (_type_): _description_
+            number (int, optional): _description_. Defaults to 1.
+        """
         try:
-            self.report[blurb_tuple[0]][measure_to_add] += number
+            self.report[blurb_id][measure_to_add] += number
         except KeyError:
-            if blurb_tuple[0] not in self.report:
-                self.report[blurb_tuple[0]] = {"blurb_tuple": blurb_tuple}
-            if measure_to_add not in self.report[blurb_tuple[0]]:
-                self.report[blurb_tuple[0]][measure_to_add] = number
+            if blurb_id not in self.report:
+                self.report[blurb_id] = {"blurb_id": blurb_id}
+            if measure_to_add not in self.report[blurb_id]:
+                self.report[blurb_id][measure_to_add] = number
+
+    def set(self, blurb_id, measure_to_add: str, number: int):
+        """Set a section value  to a specific number
 
-    def set(self, blurb, measure_to_add: str, number: int):
-        """set a section value  to a specific number"""
-        if blurb[0] not in self.report:
-            self.report[blurb[0]] = {}
-        self.report[blurb[0]][measure_to_add] = number
+        Args:
+            blurb (_type_): _description_
+            measure_to_add (str): _description_
+            number (int): _description_
+        """
+        if blurb_id not in self.report:
+            self.report[blurb_id] = {}
+        self.report[blurb_id][measure_to_add] = number
 
     def add_general_statistics(self, measure_to_add: str):
-        """Shortcut for adding to the first breakdown"""
-        self.add(Blurbs.GeneralStatistics, measure_to_add)
+        """Shortcut for adding to the first breakdown
+
+        Args:
+            measure_to_add (str): _description_
+        """
+        self.add("GeneralStatistics", measure_to_add)
 
-    def write_migration_report(self, report_file):
-        """Writes the migration report, including section headers, section blurbs, and values."""
-        report_file.write(f"{Blurbs.Introduction[1]}\n")
+    def write_migration_report(
+        self,
+        report_title,
+        report_file,
+        time_started: datetime,
+    ):
+        """Writes the migration report, including section headers, section blurbs, and values.
 
+        Args:
+            report_title (_type_):the header of the report.
+            report_file (_type_):path to file
+            time_started (datetime): The datetime stamp (in utc), of when the process started
+        """
+        time_finished = datetime.now(timezone.utc)
+        report_file.write(
+            "\n".join(
+                [
+                    "# " + report_title,
+                    i18n.t("blurbs.Introduction.description"),
+                    "## " + i18n.t("Timings"),
+                    "",
+                    i18n.t("Measure") + " | " + i18n.t("Value"),
+                    "--- | ---:",
+                    i18n.t("Time Started:") + " | " + datetime.isoformat(time_started),
+                    i18n.t("Time Finished:") + " | " + datetime.isoformat(time_finished),
+                    i18n.t("Elapsed time:") + " | " + str(time_finished - time_started),
+                ]
+            )
+        )
+        logging.info(f"Elapsed time: {time_finished-time_started}")
         for a in self.report:
-            blurb = self.report[a].get("blurb_tuple") or ("", "")
-            report_file.write("   \n")
-            report_file.write(f"## {blurb[0]}    \n")
-            report_file.write(f"{blurb[1]}    \n")
+            blurb_id = self.report[a].get("blurb_id") or ""
             report_file.write(
-                f"<details><summary>Click to expand all {len(self.report[a])} things</summary>     \n"
+                "\n".join(
+                    [
+                        "",
+                        "## " + i18n.t(f"blurbs.{blurb_id}.title"),
+                        i18n.t(f"blurbs.{blurb_id}.description"),
+                        "<details><summary>"
+                        + i18n.t("Click to expand all %{count} things", count=len(self.report[a]))
+                        + "</summary>",
+                        "",
+                        i18n.t("Measure") + " | " + i18n.t("Count"),
+                        "--- | ---:",
+                    ]
+                    + [
+                        f"{k or 'EMPTY'} | {self.report[a][k]:,}"
+                        for k in sorted(self.report[a], key=as_str)
+                        if k != "blurb_id"
+                    ]
+                    + ["</details>", ""]
+                )
             )
-            report_file.write("   \n")
-            report_file.write("Measure | Count   \n")
-            report_file.write("--- | ---:   \n")
-            b = self.report[a]
-            sortedlist = [
-                (k, b[k]) for k in sorted(b, key=as_str) if k != "blurb_tuple"
-            ]
-            for b in sortedlist:
-                report_file.write(f"{b[0] or 'EMPTY'} | {b[1]:,}   \n")
-            report_file.write("</details>   \n")
 
     def log_me(self):
         for a in self.report:
-            blurb = self.report[a].get("blurb_tuple") or ("", "")
-            logging.info(f"{blurb[0]}    ")
+            blurb_id = self.report[a].get("blurb_id") or ""
+            logging.info(f"{blurb_id}    ")
             logging.info("_______________")
             b = self.report[a]
-            sortedlist = [
-                (k, b[k]) for k in sorted(b, key=as_str) if k != "blurb_tuple"
-            ]
+            sortedlist = [(k, b[k]) for k in sorted(b, key=as_str) if k != "blurb_id"]
             for b in sortedlist:
                 logging.info(f"{b[0] or 'EMPTY'} \t\t{b[1]:,}   ")
 

folio_migration_tools/migration_tasks/__init__.py

@@ -2,6 +2,4 @@ from os.path import dirname, basename, isfile, join
 import glob
 
 modules = glob.glob(join(dirname(__file__), "*.py"))
-__all__ = [
-    basename(f)[:-3] for f in modules if isfile(f) and not f.endswith("__init__.py")
-]
+__all__ = [basename(f)[:-3] for f in modules if isfile(f) and not f.endswith("__init__.py")]

folio_migration_tools/migration_tasks/authority_transformer.py

@@ -0,0 +1,119 @@
+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()