opex-manifest-generator 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

opex_manifest_generator/__init__.py

@@ -8,9 +8,9 @@ license: Apache License 2.0"
 from .opex_manifest import OpexManifestGenerator,OpexDir,OpexFile
 from .hash import HashGenerator
 from .common import *
-from .cli import parse_args,run_cli
-import importlib.metadata
+from .cli import create_parser,run_cli
+from importlib import metadata
 
 __author__ = "Christopher Prince (c.pj.prince@gmail.com)"
 __license__ = "Apache License Version 2.0"
-__version__ = importlib.metadata.version("opex_manifest_generator")
+__version__ = metadata.version("opex_manifest_generator")

opex_manifest_generator/cli.py

@@ -7,75 +7,77 @@ license: Apache License 2.0"
 
 import argparse, os, inspect, time, logging
 from opex_manifest_generator.opex_manifest import OpexManifestGenerator
-import importlib.metadata
+from importlib import metadata
 from datetime import datetime
-from opex_manifest_generator.common import running_time 
+from opex_manifest_generator.common import running_time
 
 logger = logging.getLogger(__name__)
 
-def parse_args():
-    parser = argparse.ArgumentParser(description = "OPEX Manifest Generator for Preservica Uploads")
+def _get_version():
+    try:
+        return metadata.version("opex_manifest_generator")
+    except metadata.PackageNotFoundError:
+        return "0.0.0"
+
+def create_parser():
+
+    parser = argparse.ArgumentParser(prog="Opex_Manifest_Generator", description = "OPEX Manifest Generator for Preservica Uploads")
+
+    parser.add_argument("-v", "--version", action = 'version', version = '%(prog)s {version}'.format(version =_get_version())),
     parser.add_argument('root', nargs='?', default = os.getcwd(),
                         help = """The root path to generate Opexes for, will recursively traverse all sub-directories.
                         Generates an Opex for each folder & (depending on options) file in the directory tree.""")
-    parser.add_argument("-fx", "--fixity", required = False, nargs = '*', default = None,
+
+
+    opexgroup = parser.add_argument_group('Opex Options', 'Options that control the generation of Opex Manifests')
+
+    opexgroup.add_argument("-fx", "--fixity", required = False, nargs = '*', default = None,
                         choices = ['SHA-1', 'MD5', 'SHA-256', 'SHA-512'], type = fixity_helper, action=EmptyIsTrueFixity,
-                        help="Generates a hash for each file and adds it to the opex, can select one or more algorithms to utilise. -fx SHA-1 MD5")
-    parser.add_argument("--pax-fixity", required = False, action = 'store_true', default = False,
+                        help="Generates a hash for each file and adds it to the opex.\n" \
+                        "Can select one or more algorithms to utilise: {-fx MD5 SHA-1}\n" \
+                        "If no algorithm is specified defaults to SHA-1.\n")
+    opexgroup.add_argument("--pax-fixity", required = False, action = 'store_true', default = False,
                         help="""Enables use of PAX fixity generation, in line with Preservica's Recommendation.
                         "Files / folders ending in .pax or .pax.zip will have individual files in folder / zip added to Opex.""")
-    parser.add_argument("--fixity-export", required = False, action = 'store_false', default = True,
-                        help="""Set whether to export the generated fixity list to a text file in the meta directory.
-                        Enabled by default, disable with this flag.""")
-    parser.add_argument("--prevent-all-exports", required = False, action = 'store_true', default = False,
-                        help="Set to prevent all exports (Fixity, Removal, Empty) from being created in the meta directory.")
-    parser.add_argument("-z", "--zip", required = False, action = 'store_true',
+    opexgroup.add_argument("-z", "--zip", required = False, action = 'store_true',
                         help="Set to zip files")
-    parser.add_argument("--zip-remove-files", required = False, action = 'store_true',
-                        help="Set to remove the files that have been zipped")
-    parser.add_argument("--remove-empty", required = False, action = 'store_true', default = False,
+    opexgroup.add_argument("--remove-zipped-files", required = False, action = 'store_true',
+                        help="Set to remove the original files that have been zipped")
+    opexgroup.add_argument("--remove-empty", required = False, action = 'store_true', default = False,
                         help = "Remove and log empty directories from root. Log will be exported to 'meta' / output folder.")
-    parser.add_argument("--empty-export", required = False, action = 'store_false', default = True,
-                        help="""Set whether to export the generated empty list to a text file in the meta directory.
-                        Enabled by default, disable with this flag.""")
-    parser.add_argument("--hidden", required = False, action = 'store_true', default = False,
+    opexgroup.add_argument("--hidden", required = False, action = 'store_true', default = False,
                         help="Set whether to include hidden files and folders")
-    parser.add_argument("-o", "--output", required = False, nargs = '?',
-                        help = "Sets the output to send any generated files (Remove Empty, Fixity List, Autoref Export) to. Will not affect creation of a meta dir.")
-    parser.add_argument("-clr", "--clear-opex", required = False, action = 'store_true', default = False,
-                        help = """Clears existing opex files from a directory. If set with no further options will only clear opexes; 
+    opexgroup.add_argument("-clr", "--clear-opex", required = False, action = 'store_true', default = False,
+                        help = """Clears existing opex files from a directory. If set with no further options will only clear opexes;
                         if multiple options are set will clear opexes and then run the program""")
-    parser.add_argument("-opt","--options-file", required = False, default=os.path.join(os.path.dirname(__file__),'options','options.properties'),
+    opexgroup.add_argument("-opt","--options-file", required = False, default=os.path.join(os.path.dirname(__file__),'options','options.properties'),
                         help="Specify a custom Options file, changing the set presets for column headers (Title,Description,etc)")
-    parser.add_argument("--autoref-options", required = False, default = None,
-                        help="Specify a custom Auto Reference Options file, changing the set presets for Auto Reference Generator")
-    parser.add_argument("--disable-meta-dir", required = False, action = 'store_false',
-                        help = """Set whether to disable the creation of a 'meta' directory for generated files,
-                        default behaviour is to always generate this directory""")
-    # Input Options
-    parser.add_argument("-i", "--input", required = False, nargs='?', 
+
+    inputgroup = parser.add_argument_group('Input Override Options', 'Options that control the Input Override features')
+    inputgroup.add_argument("-i", "--input", required = False, nargs='?',
                         help="Set to utilise a CSV / XLSX spreadsheet to import data from")
-    parser.add_argument("-rm", "--remove", required = False, action = "store_true", default = False,
-                        help="Set whether to enable removals of files and folders from a directory. ***Currently in testing")    
-    parser.add_argument("--removal-export", required = False, action = 'store_false', default = True,
-                        help="""Set whether to export the generated removals list to a text file in the meta directory.
-                        Enabled by default, disable with this flag.""")
-    parser.add_argument("-mdir","--metadata-dir", required=False, nargs= '?',
+    inputgroup.add_argument("-mdir","--metadata-dir", required=False, nargs= '?',
                         default = os.path.join(os.path.dirname(os.path.realpath(__file__)), "metadata"),
                         help="Specify the metadata directory to pull XML files from")
-    parser.add_argument("-m", "--metadata", required = False, const = 'e', default = None,
-                        nargs = '?', choices = ['exact', 'e', 'flat', 'f'], type = str.lower,
+    inputgroup.add_argument("-m", "--metadata", required = False, const = 'e', default = None,
+                        nargs = '?', choices = ['exact', 'flat'], type = metadata_helper,
                         help="Set whether to include xml metadata fields in the generation of the Opex")
-    parser.add_argument("--print-xmls", required = False, action = "store_true", default = False,
+    inputgroup.add_argument("-rm", "--remove", required = False, action = "store_true", default = False,
+                        help="Set whether to enable removals of files and folders from a directory. ***Currently in testing")
+    inputgroup.add_argument("--print-xmls", required = False, action = "store_true", default = False,
                         help="Prints the elements from your xmls to the consoles")
-    parser.add_argument("--convert-xmls", required=False, action ='store_true', default = False,
+    inputgroup.add_argument("--convert-xmls", required=False, action ='store_true', default = False,
                          help="Convert XMLs templates files in mdir to spreadsheets/csv files")
-    
+    inputgroup.add_argument("--autoref-options", required = False, default = None,
+                        help="Specify a custom Auto Reference Options file, changing the set presets for Input Override / Auto Reference Generator")
+
     # Auto Reference Options
-    parser.add_argument("-r", "--autoref", required = False,
-                        choices = ['catalog', 'c', 'accession', 'a', 'both', 'b', 'generic', 'g', 'catalog-generic', 'cg', "accession-generic", "ag", "both-generic", "bg"],
-                        type = str.lower,
-                        help="""Toggles whether to utilise the auto_reference_generator 
+    autorefgroup = parser.add_argument_group('Auto Reference Generator Options', 'Options that control the Auto Reference Generator features')
+
+    autorefgroup.add_argument("-r", "--autoref", required = False,
+                        choices = ['catalog', 'accession', 'both', 'generic', 'catalog-generic', "accession-generic", "both-generic"],
+                        type = autoref_helper,
+                        help="""Toggles whether to utilise the auto_reference_generator
                         to generate an on the fly Reference listing.\n
                         There are several options, {catalog} will generate
                         a Archival Reference following an ISAD(G) structure.\n
@@ -85,48 +87,71 @@ def parse_args():
                         if used in conjunction with one of the above options:
                         {generic-catalog,generic-accession, generic-both} it will do both simultaneously.
                         """)
-    parser.add_argument("-p", "--prefix", required = False, nargs = '+',
+    autorefgroup.add_argument("-p", "--prefix", required = False, nargs = '+',
                         help= """Assign a prefix when utilising the --autoref option. Prefix will append any text before all generated text.
-                        When utilising the {both} option fill in like: [catalog-prefix, accession-prefix] without square brackets.                        
+                        When utilising the {both} option fill in like: [catalog-prefix, accession-prefix] without square brackets.
                         """)
-    parser.add_argument("-s", "--suffix", required = False, nargs = '?', default = '',
+    autorefgroup.add_argument("-s", "--suffix", required = False, nargs = '?', default = '',
                         help= "Assign a suffix when utilising the --autoref option. Suffix will append any text after all generated text.")
-    parser.add_argument("--suffix-option", required = False, choices= ['apply_to_files','apply_to_folders','apply_to_both'], default = 'apply_to_files',
+    autorefgroup.add_argument("--suffix-option", required = False, choices= ['file', 'directory', 'both'], type = suffix_helper, default = 'apply_to_files',
                         help = "Set whether to apply the suffix to files, folders or both when utilising the --autoref option.")
-    parser.add_argument("--accession-mode", nargs = '?', required=False, const='file', default=None, choices=["file",'directory','both'],
+    autorefgroup.add_argument("--accession-mode", nargs = '?', required=False, const='file', default=None, choices=["file", 'directory', 'both'], type = suffix_helper,
                         help="""Set the mode when utilising the Accession option in autoref.
                         file - only adds on files, folder - only adds on folders, both - adds on files and folders""")
-    parser.add_argument("-str", "--start-ref", required = False, type=int, nargs = '?', default = 1, 
+    autorefgroup.add_argument("-str", "--start-ref", required = False, type=int, nargs = '?', default = 1,
                         help="Set a custom Starting reference for the Auto Reference Generator. The generated reference will")
-    parser.add_argument("-ex", "--export-autoref", required = False, action = 'store_true', default = False,
-                        help="Set whether to export the generated references to an AutoRef spreadsheet")
-    parser.add_argument("-fmt", "--output-format", required = False, default = "xlsx", choices = ['xlsx', 'csv','json','ods','xml'],
-                        help="Set whether to export AutoRef Spreadsheet to: xlsx, csv, json, ods or xml format")
-    parser.add_argument("-dlm", "--delimiter", required=False,nargs = '?', type = str, default = '/',
-                        help="Set a custom delimiter for generated references, default is '/'")    
-    parser.add_argument("-key","--keywords", nargs = '*', default = None,
+    autorefgroup.add_argument("-dlm", "--delimiter", required=False,nargs = '?', type = str, default = '/',
+                        help="Set a custom delimiter for generated references, default is '/'")
+    autorefgroup.add_argument("--sort-by", required=False, nargs = '?', default = 'folders_first', choices = ['folders_first','alphabetical'], type=str.lower,
+                        help = "Set the sorting method, 'folders_first' sorts folders first then files alphabetically; 'alphabetically' sorts alphabetically (ignoring folder distinction)")
+
+    keywordsgroup = parser.add_argument_group('Keyword Options', 'Options that control the Keyword features for Auto Reference Generation')
+
+    keywordsgroup.add_argument("-key","--keywords", nargs = '*', default = None,
                         help = "Set to replace reference numbers with given Keywords for folders (only Folders atm). Can be a list of keywords or a JSON file mapping folder names to keywords.")
-    parser.add_argument("-keym","--keywords-mode", nargs = '?', const = "initialise", choices = ['initialise','firstletters','from_json'], default = 'initialise',
+    keywordsgroup.add_argument("-keym","--keywords-mode", nargs = '?', const = "initialise", choices = ['initialise','firstletters','from_json'], default = 'initialise',
                         help = "Set to alternate keyword mode: 'initialise' will use initials of words; 'firstletters' will use the first letters of the string; 'from_json' will use a JSON file mapping names to keywords")
-    parser.add_argument("--keywords-case-sensitivity", required = False, action = 'store_false', default = True,
+    keywordsgroup.add_argument("--keywords-case-sensitivity", required = False, action = 'store_false', default = True,
                         help = "Set to change case keyword matching sensitivity. By default keyword matching is insensitive")
-    parser.add_argument("--keywords-retain-order", required = False, default = False, action = 'store_true', 
+    keywordsgroup.add_argument("--keywords-retain-order", required = False, default = False, action = 'store_true',
                         help = "Set when using keywords to continue reference numbering. If not used keywords don't 'count' to reference numbering, e.g. if using initials 'Project Alpha' -> 'PA' then the next folder/file will still be '001' not '003'")
-    parser.add_argument("--keywords-abbreviation-number", required = False, nargs='+', default = None, type = int,
+    keywordsgroup.add_argument("--keywords-abbreviation-number", required = False, nargs='+', default = None, type = int,
                         help = "Set to set the number of letters to abbreviate for 'firstletters' mode, does not impact 'initialise' mode.")
-    parser.add_argument("--sort-by", required=False, nargs = '?', default = 'folders_first', choices = ['folders_first','alphabetical'], type=str.lower,
-                        help = "Set the sorting method, 'folders_first' sorts folders first then files alphabetically; 'alphabetically' sorts alphabetically (ignoring folder distinction)")
-    parser.add_argument("--log-level", required=False, nargs='?', choices=['DEBUG','INFO','WARNING','ERROR'], default=None, type=str.upper,
+
+
+    exportgroup = parser.add_argument_group('Export Options', 'Options that control various export features')
+
+    exportgroup.add_argument("--log-level", required=False, nargs='?', choices=['DEBUG','INFO','WARNING','ERROR'], default=None, type=str.upper,
                         help="Set the logging level (default: INFO)")
-    parser.add_argument("--log-file", required=False, nargs='?', default=None,
+    exportgroup.add_argument("--log-file", required=False, nargs='?', default=None,
                         help="Optional path to write logs to a file (default: stdout)")
-    parser.add_argument("-v", "--version", action = 'version', version = '%(prog)s {version}'.format(version = importlib.metadata.version("opex_manifest_generator")))
 
-    args = parser.parse_args()
-    return args
 
-def run_cli():
-    args = parse_args()
+    exportgroup.add_argument("-o", "--output", required = False, nargs = '?',
+                        help = "Sets the output of the meta folder to send any generated files (Remove Empty, Fixity List, Autoref Export) to. Can be used in conjunction with --disable-meta-dir to set output location without generating meta directory.")
+
+    exportgroup.add_argument("--disable-meta-dir", required = False, action = 'store_false',
+                        help = """Set whether to disable the creation of a 'meta' directory for generated files,
+                        default behaviour is to always generate this directory""")
+    exportgroup.add_argument("--disable-all-exports", required = False, action = 'store_true', default = False,
+                        help="Set to prevent all exports (Fixity, Removal, Empty) from being created in the meta directory.")
+    exportgroup.add_argument("--disable-fixity-export", required = False, action = 'store_false', default = True,
+                        help="""Set whether to export the generated fixity list to a text file in the meta directory.
+                        Enabled by default, disable with this flag.""")
+    exportgroup.add_argument("--disable-empty-export", required = False, action = 'store_false', default = True,
+                        help="""Set whether to export the generated empty list to a text file in the meta directory.
+                        Enabled by default, disable with this flag.""")
+    exportgroup.add_argument("--disable-removal-export", required = False, action = 'store_false', default = True,
+                        help="""Set whether to export the generated removals list to a text file in the meta directory.
+                        Enabled by default, disable with this flag.""")
+    exportgroup.add_argument("-ex", "--export-autoref", required = False, action = 'store_true', default = False,
+                        help="Set whether to export the generated references to an AutoRef spreadsheet")
+    exportgroup.add_argument("-fmt", "--output-format", required = False, default = "xlsx", choices = ['xlsx', 'csv','json','ods','xml'], type=fmthelper,
+                        help="Set whether to export AutoRef Spreadsheet to: xlsx, csv, json, ods or xml format")
+
+    return parser
+
+def run_cli(args = None):
 
     # Configure logging early so other modules inherit the settings
     try:
@@ -145,14 +170,14 @@ def run_cli():
         'If you are utilising Windows ensure that the path does not end with \\\' or \\"')
         raise FileNotFoundError(f'Please ensure that root path {args.root} exists. \n' \
         'If you are utilising Windows ensure that the path does not end with \\\' or \\" ')
-    
+
     if isinstance(args.root, str):
         args.root = args.root.strip("\"").rstrip("\\")
     logger.info(f"Running Opex Generation on: {args.root}")
 
     if not args.output:
         args.output = os.path.abspath(args.root)
-        logger.debug(f'Output path set to root directory: {args.output}')        
+        logger.debug(f'Output path set to root directory: {args.output}')
     else:
         args.output = os.path.abspath(args.output)
         logger.info(f'Output path set to {args.output}')
@@ -165,7 +190,7 @@ def run_cli():
         raise ValueError('Removal flag has been given without input, please ensure an input file is utilised when using this option.')
     if args.metadata is not None and not args.input:
         logger.warning(f'Warning: Metadata Flag has been given without Input. Metadata won\'t be generated.')
-  
+
     if args.print_xmls:
         logger.info(f'Printing xmls in {args.metadata_dir} then ending')
         OpexManifestGenerator(root = args.root, metadata_dir=args.metadata_dir).print_descriptive_xmls()
@@ -175,21 +200,21 @@ def run_cli():
         OpexManifestGenerator(root = args.root, output_format=args.output_format, metadata_dir=args.metadata_dir).convert_descriptive_xmls()
         raise SystemExit()
 
-    if args.prevent_all_exports:
+    if args.disable_all_exports:
         args.fixity_export_flag = False
         args.removal_export_flag = False
         args.empty_export_flag = False
         logger.info('All exports have been prevented via --prevent-all-exports flag.')
 
     acc_prefix = None
-    if args.autoref in {"accession", "a", "accession-generic", "ag", "both", "b", "both-generic", "bg"} and args.accession_mode is None:
+    if args.autoref in {"accession", "accession-generic", "both", "both-generic"} and args.accession_mode is None:
             args.accession_mode = "file"
             logger.debug(f'Accession mode not set, defaulting to "file" mode for accession generation.')
 
     if args.prefix:
-        if args.autoref in {"both", "b", "both-generic", "bg"}:
+        if args.autoref in {"both", "both-generic"}:
             if len(args.prefix) < 2 or len(args.prefix) > 2:
-                logger.error('"Both" option is selected, please pass only two prefixes: [-p CATALOG_PREFIX ACCESSION_PREFIX]'); 
+                logger.error('"Both" option is selected, please pass only two prefixes: [-p CATALOG_PREFIX ACCESSION_PREFIX]');
                 raise ValueError('"Both" option is selected, please pass only two prefixes: [-p CATALOG_PREFIX ACCESSION_PREFIX]')
             for n, a in enumerate(args.prefix):
                 if n == 0:
@@ -197,29 +222,23 @@ def run_cli():
                 elif n == 1:
                     acc_prefix = str(a)
             logger.info(f"Prefixes are set as: \t Catalog: {args.prefix} \t Acc: {acc_prefix}")
-        elif args.autoref in {"accession", "a", "accession-generic", "ag"}:
+        elif args.autoref in {"accession", "accession-generic"}:
             for a in args.prefix:
                 acc_prefix = str(a)
-            logger.info('Prefix is set as: ' + acc_prefix)                        
-        elif args.autoref in {"catalog", "c", "catalog-generic", "cg"}:
+            logger.info('Prefix is set as: ' + acc_prefix)
+        elif args.autoref in {"catalog", "catalog-generic"}:
             acc_prefix = None
-            for a in args.prefix: 
+            for a in args.prefix:
                 args.prefix = str(a)
             logger.info('Prefix is set as: ' + args.prefix)
-        elif args.autoref in {"generic", "g"}:
+        elif args.autoref in {"generic"}:
             logger.info('Using Generic mode')
             pass
         else:
-            logger.error('''An invalid option has been selected, please select a valid option: 
-                  {c, catalog
-                   a, accession
-                   b, both
-                   g, generic
-                   cg, catalog-generic
-                   ag, accession-generic
-                   bg, both-generic}''')    
-            raise ValueError('An invalid option has been selected, please select a valid option.')   
-    
+            logger.error('''An invalid option has been selected, please select a valid option:
+                  {catalog, accession, both, generic, catalog-generic, accession-generic, both-generic}''')
+            raise ValueError('An invalid option has been selected, please select a valid option.')
+
     if args.fixity:
         logger.info(f'Fixity is activated, using {args.fixity} algorithm')
 
@@ -240,10 +259,10 @@ def run_cli():
                                 "\n***"))
         i = input(inspect.cleandoc("Please type Y if you wish to proceed, otherwise the program will close: "))
         if not i.lower() == "y":
-            logger.info("Y not typed, safetly aborted...")
+            logger.info("Y not typed, safely aborted...")
             raise SystemExit()
         else:
-            logger.info("Confirmation recieved proceeding to remove files")
+            logger.info("Confirmation received proceeding to remove files")
 
     if args.remove_empty:
         logger.warning(inspect.cleandoc("\n***WARNING***" \
@@ -253,35 +272,37 @@ def run_cli():
                                 "\n***"))
         i = input(inspect.cleandoc("Please type Y if you wish to proceed, otherwise the program will close: "))
         if not i.lower() == "y":
-            logger.info("Y not typed, safetly aborted...")
+            logger.info("Y not typed, safely aborted...")
             raise SystemExit()
         else:
-            logger.info("Confirmation recieved proceeding to remove empty folders...")
+            logger.info("Confirmation received proceeding to remove empty folders...")
 
     start_time = datetime.now()
-    OpexManifestGenerator(root = args.root, 
-                          output_path = args.output, 
-                          autoref_flag = args.autoref, 
-                          prefix = args.prefix, 
+    OpexManifestGenerator(root = args.root,
+                          output_path = args.output,
+                          autoref_flag = args.autoref,
+                          prefix = args.prefix,
+                          suffix = args.suffix,
+                          suffix_option = args.suffix_option,
                           accession_mode=args.accession_mode,
-                          acc_prefix = acc_prefix, 
-                          empty_flag = args.remove_empty, 
-                          empty_export_flag = args.empty_export,
-                          removal_flag = args.remove, 
-                          removal_export_flag = args.removal_export,
-                          clear_opex_flag = args.clear_opex, 
+                          acc_prefix = acc_prefix,
+                          empty_flag = args.remove_empty,
+                          empty_export_flag = args.disable_empty_export,
+                          removal_flag = args.remove,
+                          removal_export_flag = args.disable_removal_export,
+                          clear_opex_flag = args.clear_opex,
                           algorithm = args.fixity,
                           pax_fixity= args.pax_fixity,
-                          fixity_export_flag = args.fixity_export,
-                          start_ref = args.start_ref, 
-                          export_flag = args.export_autoref, 
-                          meta_dir_flag = args.disable_meta_dir, 
+                          fixity_export_flag = args.disable_fixity_export,
+                          start_ref = args.start_ref,
+                          export_flag = args.export_autoref,
+                          meta_dir_flag = args.disable_meta_dir,
                           metadata_flag = args.metadata,
                           metadata_dir = args.metadata_dir,
                           hidden_flag= args.hidden,
-                          zip_flag = args.zip, 
-                          zip_file_removal= args.zip_remove_files,
-                          input = args.input, 
+                          zip_flag = args.zip,
+                          zip_file_removal= args.remove_zipped_files,
+                          input = args.input,
                           output_format = args.output_format,
                           options_file=args.options_file,
                           keywords = args.keywords,
@@ -292,26 +313,86 @@ def run_cli():
                           keywords_abbreviation_number = args.keywords_abbreviation_number,
                           sort_key = sort_key,
                           ).main()
-    logger.info(f"Run Complete! Ran for: {running_time(start_time)}")    
+    logger.info(f"Run Complete! Ran for: {running_time(start_time)}")
 
 def fixity_helper(x: str):
     x = x.upper()
-    if x == 'SHA1':
+    if x in ('MD5', 'M5', 'M'):
+        x = 'MD5'
+    if x in ('SHA1', 'SHA-1', 'S1'):
         x = 'SHA-1'
-    if x == 'SHA256':
+    if x in ('SHA256', 'SHA-256', 'S256'):
         x = 'SHA-256'
-    if x == 'SHA512':
+    if x in ('SHA512', 'SHA-512', 'S512'):
         x = 'SHA-512'
     return x.upper()
 
+def autoref_helper(x: str):
+    x = x.lower()
+    if x in ('c', 'catalog', 'catalogue', 'cat'):
+        x = 'catalog'
+    if x == ('a', 'accession', 'acc'):
+        x = 'accession'
+    if x == ('b', 'both', 'all'):
+        x = 'both'
+    if x == ('g', 'generic', 'gen'):
+        x = 'generic'
+    if x == ('cg', 'catalog-generic', 'catalogue-generic', 'cat-generic', 'catalogue-gen', 'cat-gen', 'catalog-gen'):
+        x = 'catalog-generic'
+    if x == ('ag', 'accession-generic', 'acc-generic', 'accession-gen', 'acc-gen'):
+        x = 'accession-generic'
+    if x == ('bg', 'both-generic', 'all-generic', 'all-gen'):
+        x = 'both-generic'
+    return x.lower()
+
+def suffix_helper(x: str):
+    x = x.lower()
+    if x in ('f', 'file', 'files'):
+        x = 'file'
+    if x in ('d', 'dir', 'dirs', 'folders', 'folder', 'directory'):
+        x = 'directory'
+    if x in ('b', 'both'):
+        x = 'both'
+    return x.lower()
+
+def metadata_helper(x: str):
+    x = x.lower()
+    if x in ('e', 'exact'):
+        x = 'exact'
+    if x in ('f', 'flat'):
+        x = 'flat'
+    return x.lower()
+
+def fmthelper(x: str):
+    x = x.lower()
+    if x in ('xlsx', 'xlsm', 'xltx', 'xltm', 'xlsb', 'xls', 'excel', 'xl'):
+        x = 'xlsx'
+    if x in ('csv', 'txt', 'comma', 'comma_separated', 'c'):
+        x = 'csv'
+    if x in ('json', 'jsn', 'j'):
+        x = 'json'
+    if x in ('ods', 'open_document_spreadsheet', 'o'):
+        x = 'ods'
+    if x in ('xml', 'html', 'htm'):
+        x = 'xml'
+    if x in ('dict','dictionary', 'd'):
+        x = 'dict'
+    return x.lower()
+
+
 class EmptyIsTrueFixity(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
         if len(values) == 0:
             values = ["SHA-1"]
         setattr(namespace, self.dest, values)
 
-if __name__ == "__main__":
+def main():
     try:
-        run_cli()
+        parser = create_parser()
+        args = parser.parse_args()
+        run_cli(args)
     except KeyboardInterrupt:
-        logger.warning("Process interrupted by user, exiting...")
+        logger.warning("Process interrupted by user, exiting...")
+
+if __name__ == "__main__":
+    main()

opex_manifest_generator/common.py

@@ -7,6 +7,7 @@ license: Apache License 2.0"
 
 import zipfile, os, sys, stat, shutil, logging, lxml
 from datetime import datetime, timedelta
+from typing import Optional
 
 logger = logging.getLogger(__name__)
 
@@ -30,7 +31,7 @@ def remove_tree(path: str, removed_list: list) -> None:
         for dp,d,f in os.walk(path):
             for fn in f:
                 removed_list.append(win_256_check(dp+win_path_delimiter()+fn))
-                logger.info(f'Removing {dp + win_path_delimiter() + fn}')            
+                logger.info(f'Removing {dp + win_path_delimiter() + fn}')
             for dn in d:
                 removed_list.append(win_256_check(dp+win_path_delimiter()+dn))
                 logger.info(f'Removing {dp + win_path_delimiter() + dn}')
@@ -44,7 +45,7 @@ def win_256_check(path) -> str:
     if len(path) > 255 and sys.platform == "win32":
         logger.debug(f'Path: {path} is greater than 255 Characters')
         if path.startswith(u"\\\\?\\"):
-            path = path 
+            path = path
         else:
             path = u"\\\\?\\" + path
     return path
@@ -57,23 +58,23 @@ def filter_win_hidden(path: str) -> bool:
             return False
     else:
         return False
-    
+
 def win_path_delimiter() -> str:
     if sys.platform == "win32":
         return "\\"
     else:
         return "/"
 
-def check_nan(value) -> str | None:
+def check_nan(value) -> Optional[str]:
     if str(value).lower() in {"nan","nat"}:
         value = None
     return value
 
 def check_opex(opex_path:str) -> bool:
-    opex_path = opex_path + ".opex" 
+    opex_path = opex_path + ".opex"
     if os.path.exists(win_256_check(opex_path)):
         return False
-    else: 
+    else:
         return True
 
 def write_opex(path: str, opexxml: lxml.etree.Element) -> str:
@@ -86,5 +87,5 @@ def write_opex(path: str, opexxml: lxml.etree.Element) -> str:
     return opex_path
 
 def running_time(start_time) -> timedelta:
-    running_time = datetime.now() - start_time 
-    return running_time
+    running_time = datetime.now() - start_time
+    return running_time

opex_manifest_generator/hash.py

@@ -6,7 +6,7 @@ license: Apache License 2.0"
 """
 
 import hashlib, logging
-from opex_manifest_generator.common import win_256_check 
+from opex_manifest_generator.common import win_256_check
 
 logger = logging.getLogger(__name__)
 
@@ -47,7 +47,7 @@ class HashGenerator():
         except Exception as e:
             logger.exception(f'Error Generating Hash: {e}')
             raise
-        
+
     def hash_generator_pax_zip(self, filename: str, z):
         if self.algorithm in ("SHA1","SHA-1"):
             hash = hashlib.sha1()
@@ -61,7 +61,7 @@ class HashGenerator():
             hash = hashlib.sha1()
         logger.info(f'Generating Fixity using {self.algorithm} for: {filename}')
         try:
-            with z.open(filename, 'r') as data:            
+            with z.open(filename, 'r') as data:
                 while True:
                     buff = data.read(self.buffer)
                     if not buff:
@@ -77,4 +77,4 @@ class HashGenerator():
         except Exception as e:
             logger.exception(f'Error Generating Hash: {e}')
             raise
-        return str(hash.hexdigest().upper())
+        return str(hash.hexdigest().upper())

opex_manifest_generator/metadata/EAD Template.xml

@@ -99,4 +99,4 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:is
    <p></p>
   </processinfo>
  </archdesc>
-</ead:ead>
+</ead:ead>

opex_manifest_generator/metadata/GDPR Template.xml

@@ -6,4 +6,4 @@
     <recordobjecteddate></recordobjecteddate>
     <recipientdisclosurecategory></recipientdisclosurecategory>
     <timelimitforerasure></timelimitforerasure>
-</gdpr>
+</gdpr>

opex_manifest_generator/metadata/MODS Template.xml

@@ -64,4 +64,4 @@
     <note type="bibliography" displayLabel="Bibliography"></note>
     <note type="other" displayLabel="Other descriptive data"></note>
     <note type="processinfo" displayLabel="Processing Information"></note>
-</mods>
+</mods>