opex-manifest-generator 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

opex_manifest_generator/cli.py

@@ -30,9 +30,11 @@ def parse_args():
                         help= """Assign a prefix when utilising the --autoclass 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.                        
                         """)
-    parser.add_argument("-fx", "--fixity", required = False, const = "SHA-1", default = None,
-                        nargs = '?', choices = ['NONE', 'SHA-1', 'MD5', 'SHA-256', 'SHA-512'], type = str.upper,
-                        help="Generates a hash for each file and adds it to the opex, can select the algorithm to utilise.")
+    parser.add_argument("-fx", "--fixity", required = False, nargs = '*', default = None,
+                        choices = ['NONE', 'SHA-1', 'MD5', 'SHA-256', 'SHA-512'], type = str.upper, 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="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("-rme", "--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("-o", "--output", required = False, nargs = 1,
@@ -92,11 +94,14 @@ def run_cli():
     if args.input and args.autoclass:
         print(f'Both Input and Auto-Class options have been selected, please use only one...')
         time.sleep(5); raise SystemExit()
+    if args.remove and not args.input:
+        print('Removal flag has been given without input, please ensure an input file is utilised when using this option.')
+        time.sleep(5); raise SystemExit()
     if not args.metadata in {'none', 'n'} and not args.input:
         print(f'Warning: Metadata Flag has been given without Input. Metadata won\'t be generated.')
         time.sleep(5)
     if args.print_xmls:
-        OpexManifestGenerator.print_descriptive_xmls()
+        OpexManifestGenerator(root = args.root).print_descriptive_xmls()
     acc_prefix = None
     if args.autoclass in {"accession", "a", "accession-generic", "ag", "both", "b", "both-generic", "bg"} and args.accession_mode is None:
             args.accession_mode = "file"
@@ -159,9 +164,10 @@ def run_cli():
                           accession_mode=args.accession_mode,
                           acc_prefix = acc_prefix, 
                           empty_flag = args.remove_empty, 
-                          remove_flag = args.remove, 
+                          removal_flag = args.remove, 
                           clear_opex_flag = args.clear_opex, 
-                          algorithm = args.fixity, 
+                          algorithm = args.fixity,
+                          pax_fixity= args.pax_fixity,
                           startref = args.start_ref, 
                           export_flag = args.export, 
                           meta_dir_flag = args.disable_meta_dir, 
@@ -178,6 +184,12 @@ def run_cli():
                           sort_key = sort_key,
                           delimiter = args.delimiter,
                           keywords_abbreviation_number = args.keywords_abbreviation_number).main()
-    
+
+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__":
     run_cli()

opex_manifest_generator/common.py

@@ -5,8 +5,7 @@ author: Christopher Prince
 license: Apache License 2.0"
 """
 
-import zipfile, os, sys, time, stat
-import datetime
+import zipfile, os, sys, time, stat, datetime, shutil
 from lxml import etree
 
 def zip_opex(file_path,opex_path):
@@ -17,10 +16,26 @@ def zip_opex(file_path,opex_path):
             z.write(opex_path,os.path.basename(opex_path))
     else: print(f'A zip file already exists for: {zip_file}')
 
-def win_256_check(path: str):
+def remove_tree(path: str, removed_list: list):
+    removed_list.append(path)
+    print(f"Removing: {path}")
+    if os.path.isdir(path):
+        for dp,d,f in os.walk(path):
+            for fn in f:
+                removed_list.append(win_256_check(dp+win_path_delimiter()+fn))
+            for dn in d:
+                removed_list.append(win_256_check(dp+win_path_delimiter()+dn))
+        shutil.rmtree(path)
+    else:
+        if os.path.exists(path):
+            os.remove(path)
+
+def win_256_check(path):
     if len(path) > 255 and sys.platform == "win32":
-        if path.startswith(u'\\\\?\\'): path = path
-        else: path = u"\\\\?\\" + path
+        if path.startswith(u"\\\\?\\"):
+            path = path 
+        else:
+            path = u"\\\\?\\" + path
     return path
 
 def filter_win_hidden(path: str):

opex_manifest_generator/hash.py

@@ -6,13 +6,16 @@ license: Apache License 2.0"
 """
 
 import hashlib
+from opex_manifest_generator.common import win_256_check 
+import os, io
 
 class HashGenerator():
-    def __init__(self,algorithm="SHA-1"):
+    def __init__(self, algorithm: str = "SHA-1", buffer: int = 4096):
         self.algorithm = algorithm
-        self.buffer = 4096
+        self.buffer = buffer
 
-    def hash_generator(self,file_path: str):
+    def hash_generator(self, file_path: str):
+        file_path = win_256_check(file_path)
         if self.algorithm == "SHA-1":
             hash = hashlib.sha1()
         elif self.algorithm == "MD5":
@@ -24,11 +27,39 @@ class HashGenerator():
         else:
             hash = hashlib.sha1()
         print(f'Generating Fixity using {self.algorithm} for: {file_path}')
-        with open(file_path, "rb") as f:
-            while True:
-                buff = f.read(self.buffer)
-                if not buff:
-                    break
-                hash.update(buff)
-            f.close()
+        try:
+            with open(file_path, 'rb', buffering = 0) as f:
+                while True:
+                    buff = f.read(self.buffer)
+                    if not buff:
+                        break
+                    hash.update(buff)
+                f.close()
+        except Exception as e:
+            print(e)
+            raise SystemError()
+        return hash.hexdigest().upper()
+        
+    def hash_generator_pax_zip(self, filename, z):
+        if self.algorithm == "SHA-1":
+            hash = hashlib.sha1()
+        elif self.algorithm == "MD5":
+            hash = hashlib.md5()
+        elif self.algorithm == "SHA-256":
+            hash = hashlib.sha256()
+        elif self.algorithm == "SHA-512":
+            hash = hashlib.sha512()
+        else:
+            hash = hashlib.sha1()
+        print(f'Generating Fixity using {self.algorithm} for: {filename}')
+        try:
+            with z.open(filename, 'r') as data:            
+                while True:
+                    buff = data.read(self.buffer)
+                    if not buff:
+                        break
+                    hash.update(buff)
+        except Exception as e:
+            print(e)
+            raise SystemError()
         return hash.hexdigest().upper()

opex_manifest_generator/opex_manifest.py

@@ -8,11 +8,10 @@ license: Apache License 2.0"
 """
 
 import lxml.etree as ET
-import os, time, shutil
+import pandas as pd
+import os, time, datetime
 from auto_classification_generator import ClassificationGenerator
 from auto_classification_generator.common import export_list_txt, export_xl, export_csv, define_output_file
-import datetime
-import pandas as pd
 from pandas.api.types import is_datetime64_any_dtype
 from opex_manifest_generator.hash import HashGenerator
 from opex_manifest_generator.common import *
@@ -34,7 +33,7 @@ class OpexManifestGenerator():
     :param startref: set to set the starting reference number
     :param algorithm: set whether to generate fixities and the algorithm to use {MD5, SHA-1, SHA-256, SHA-512}
     :param empty_flag: set whether to delete and log empty directories
-    :param remove_flag: set whether to enable removals; data must also contain removals column and cell be set to True 
+    :param removal_flag: set whether to enable removals; data must also contain removals column and cell be set to True 
     :param clear_opex_flag: set whether clear existing opexes
     :param export_flag: set whether to export the spreadsheet when using autoclass
     :param output_format: set output format when using autoclass {xlsx, csv}
@@ -60,9 +59,10 @@ class OpexManifestGenerator():
                  acc_prefix: str = None,
                  accession_mode: str = False,
                  startref: int = 1,
-                 algorithm: str = None,
+                 algorithm: list[str] = None,
+                 pax_fixity: bool = False,
                  empty_flag: bool = False,
-                 remove_flag: bool = False,
+                 removal_flag: bool = False,
                  clear_opex_flag: bool = False,
                  export_flag: bool = False,
                  input: str = None,
@@ -84,10 +84,11 @@ class OpexManifestGenerator():
         self.list_fixity = []
         self.start_time = datetime.datetime.now()
         self.algorithm = algorithm
+        self.pax_fixity_flag = pax_fixity
         self.empty_flag = empty_flag
-        self.remove_flag = remove_flag
-        if self.remove_flag:
-            self.remove_list = []
+        self.removal_flag = removal_flag
+        if self.removal_flag:
+            self.removal_list = []
         self.export_flag = export_flag
         self.startref = startref
         self.autoclass_flag = autoclass_flag
@@ -153,23 +154,26 @@ class OpexManifestGenerator():
             root_element = ET.QName(xml_file.find('.'))
             root_element_ln = root_element.localname
             for elem in xml_file.findall(".//"):
-                elem_path = xml_file.getelementpath(elem)
-                elem = ET.QName(elem)
-                elem_lnpath = elem_path.replace(f"{{{elem.namespace}}}", root_element_ln + ":")
-                print(elem_lnpath)
+                if elem.getchildren():
+                    pass
+                else:
+                    elem_path = xml_file.getelementpath(elem)
+                    elem = ET.QName(elem)
+                    elem_lnpath = elem_path.replace(f"{{{elem.namespace}}}", root_element_ln + ":")
+                    print(elem_lnpath)
     
     def set_input_flags(self):
-        if 'Title' in self.column_headers:
+        if TITLE_FIELD in self.column_headers:
             self.title_flag = True
-        if 'Description' in self.column_headers:
+        if DESCRIPTION_FIELD in self.column_headers:
             self.description_flag = True
-        if 'Security' in self.column_headers:
+        if SECUIRTY_FIELD in self.column_headers:
             self.security_flag = True
-        if 'SourceID' in self.column_headers:
+        if SOURCEID_FIELD in self.column_headers:
             self.sourceid_flag = True
-        if 'Ignore' in self.column_headers:
+        if IGNORE_FIELD in self.column_headers:
             self.ignore_flag = True
-        if 'Hash' in self.column_headers and 'Algorithm' in self.column_headers:
+        if HASH_FIELD in self.column_headers and ALGORITHM_FIELD in self.column_headers:
             self.hash_from_spread = True
             print("Hash detected in Spreadsheet; taking hashes from spreadsheet")
             time.sleep(3)
@@ -243,32 +247,20 @@ class OpexManifestGenerator():
             print('Error Looking up XIP Metadata')
             print(e)
     
-    def remove_df_lookup(self, path: str, removed_list: list, idx: pd.Index):
+    def removal_df_lookup(self, idx: pd.Index):
         try:
             if idx.empty:
                 return False
             else:
                 remove = check_nan(self.df[REMOVAL_FIELD].loc[idx].item())
                 if remove is not None:
-                    removed_list.append(path)
-                    print(f"Removing: {path}")
-                    if os.path.isdir(path):
-                        for dp,d,f in os.walk(path):
-                            for fn in f:
-                                removed_list.append(win_256_check(dp+win_path_delimiter()+fn))
-                            for dn in d:
-                                removed_list.append(win_256_check(dp+win_path_delimiter()+dn))
-                        shutil.rmtree(path)
-                    else:
-                        if os.path.exists(path):
-                            os.remove(path)
                     return True
                 else:
                     return False
         except Exception as e:
             print('Error looking up Removals')
             print(e)
-                
+
     def ignore_df_lookup(self, idx: pd.Index):
         try:
             if idx.empty:
@@ -298,11 +290,12 @@ class OpexManifestGenerator():
             if idx.empty:
                 pass
             else:
-                self.fixity = ET.SubElement(xml_fixities,f"{{{self.opexns}}}Fixity")  
-                self.hash = self.df[HASH_FIELD].loc[idx].item()
-                self.algorithm = self.df[ALGORITHM_FIELD].loc[idx].item()
-                self.fixity.set('type', self.algorithm)
-                self.fixity.set('value',self.hash)
+                for algorithm_type in self.algorithm:
+                    self.fixity = ET.SubElement(xml_fixities,f"{{{self.opexns}}}Fixity")  
+                    self.hash = self.df[HASH_FIELD].loc[idx].item()
+                    self.algorithm = self.df[ALGORITHM_FIELD].loc[idx].item()
+                    self.fixity.set('type', algorithm_type)
+                    self.fixity.set('value',self.hash)
         except Exception as e:
             print('Error looking up Hash')
             print(e)
@@ -386,13 +379,15 @@ class OpexManifestGenerator():
                         ns = elem_dict.get('Namespace')
                         try:
                             if self.metadata_flag in {'e', 'exact'}:
-                                val = check_nan(self.df[path].loc[idx].item())
+                                val_series = self.df[path].loc[idx]
+                                val = check_nan(val_series.item())
                             elif self.metadata_flag in {'f', 'flat'}:
-                                val = check_nan(self.df[name].loc[idx].item())
+                                val_series = self.df[name].loc[idx]
+                                val = check_nan(val_series.item())
                             if val is None:
                                 continue
                             else:
-                                if is_datetime64_any_dtype(str(val)):
+                                if is_datetime64_any_dtype(val_series):
                                     val = pd.to_datetime(val)
                                     val = datetime.datetime.strftime(val, "%Y-%m-%dT%H:%M:%S.000Z")
                             if self.metadata_flag in {'e','exact'}:
@@ -435,13 +430,26 @@ class OpexManifestGenerator():
         if self.properties is None:
             xmlroot.remove(self.properties)
 
-    def genererate_opex_fixity(self, file_path: str):
-        self.fixity = ET.SubElement(self.fixities, f"{{{self.opexns}}}Fixity")        
-        self.hash = HashGenerator(algorithm = self.algorithm).hash_generator(file_path)
-        self.fixity.set("type", self.algorithm)
-        self.fixity.set("value", self.hash)
-        self.OMG.list_fixity.append([self.algorithm, self.hash, file_path])
-        self.OMG.list_path.append(file_path)
+    def generate_opex_fixity(self, file_path: str):
+        for algorithm_type in self.OMG.algorithm:
+            self.fixity = ET.SubElement(self.fixities, f"{{{self.opexns}}}Fixity")
+            self.hash = HashGenerator(algorithm = algorithm_type).hash_generator(file_path)
+            self.fixity.set("type", algorithm_type)
+            self.fixity.set("value", self.hash)
+            self.OMG.list_fixity.append([algorithm_type, self.hash, file_path])
+            self.OMG.list_path.append(file_path)
+
+    def generate_pax_zip_opex_fixity(self, file_path):
+        for algorithm_type in self.OMG.algorithm:
+            z = zipfile.ZipFile(file_path,'r')
+            for file in z.filelist:
+                self.fixity = ET.SubElement(self.fixities, f"{{{self.opexns}}}Fixity")        
+                self.hash = HashGenerator(algorithm = algorithm_type).hash_generator_pax_zip(file.filename, z)
+                self.fixity.set("path", file.filename)
+                self.fixity.set("type", algorithm_type)
+                self.fixity.set("value", self.hash)
+                self.OMG.list_fixity.append([algorithm_type, self.hash, file_path + file.filename])
+            self.OMG.list_path.append(file_path)
 
     def main(self):
         if self.print_xmls_flag:
@@ -468,9 +476,9 @@ class OpexManifestGenerator():
         if self.algorithm:
             output_path = define_output_file(self.output_path, self.root, self.meta_dir_flag, output_suffix = "_Fixities", output_format = "txt")
             export_list_txt(self.list_fixity, output_path)
-        if self.remove_flag:
-            output_path = define_output_file(self.output_path, self.root, self.meta_dir_flag, output_suffix = "_Removed", output_format = "txt")
-            export_list_txt(self.remove_list, output_path)
+        if self.removal_flag:
+            output_path = define_output_file(self.output_path, self.root, self.meta_dir_flag, output_suffix = "_Removals", output_format = "txt")
+            export_list_txt(self.removal_list, output_path)
         print_running_time(self.start_time)
 
 class OpexDir(OpexManifestGenerator):
@@ -482,11 +490,10 @@ class OpexDir(OpexManifestGenerator):
             self.folder_path = folder_path.replace(u'\\\\?\\', "")
         else:
             self.folder_path = folder_path
-        print(self.folder_path)
         if any([self.OMG.input,
                 self.OMG.autoclass_flag in {"c","catalog","a","accession","b","both","cg","catalog-generic","ag","accession-generic","bg","both-generic"},
                 self.OMG.ignore_flag,
-                self.OMG.remove_flag,
+                self.OMG.removal_flag,
                 self.OMG.sourceid_flag,
                 self.OMG.title_flag,
                 self.OMG.description_flag,
@@ -502,16 +509,16 @@ class OpexDir(OpexManifestGenerator):
             self.ignore = self.OMG.ignore_df_lookup(index)
             if self.ignore:
                 return
-        if self.OMG.remove_flag:
-            self.removal = self.OMG.remove_df_lookup(self.folder_path, self.OMG.remove_list, index)
+        if self.OMG.removal_flag:
+            self.removal = self.OMG.removal_df_lookup(index)
             if self.removal:
+                remove_tree(self.folder_path, self.OMG.removal_list)
                 return
         self.xmlroot = ET.Element(f"{{{self.opexns}}}OPEXMetadata", nsmap={"opex":self.opexns})
         self.transfer = ET.SubElement(self.xmlroot, f"{{{self.opexns}}}Transfer")
         self.manifest = ET.SubElement(self.transfer, f"{{{self.opexns}}}Manifest")
         self.folders = ET.SubElement(self.manifest, f"{{{self.opexns}}}Folders")
         self.files = ET.SubElement(self.manifest, f"{{{self.opexns}}}Files")
-
         if self.OMG.title_flag or self.OMG.description_flag or self.OMG.security_flag:
             self.title, self.description, self.security = self.OMG.xip_df_lookup(index) 
         elif self.OMG.autoclass_flag in {"generic", "g", "catalog-generic", "cg", "accession-generic", "ag", "both-generic", "bg"}:
@@ -524,6 +531,19 @@ class OpexDir(OpexManifestGenerator):
             self.security = security
         if self.OMG.sourceid_flag:
             self.OMG.sourceid_df_lookup(self.transfer, self.folder_path, index)
+        if self.OMG.algorithm and self.OMG.pax_fixity_flag is True and self.folder_path.endswith(".pax"):
+            self.fixities = ET.SubElement(self.transfer, f"{{{self.opexns}}}Fixities")
+            for dir,_,files in os.walk(folder_path):
+                for filename in files:
+                    rel_path = os.path.relpath(dir,folder_path)
+                    rel_file = os.path.join(rel_path, filename)
+                    abs_file = os.path.abspath(os.path.join(dir,filename))
+                    self.generate_opex_fixity(abs_file)
+                    self.fixity.set("path",rel_file)
+                    file = ET.SubElement(self.files, f"{{{self.opexns}}}File")
+                    file.set("type", "content")
+                    file.set("size", str(os.path.getsize(abs_file)))
+                    file.text = str(rel_file)
         if self.OMG.autoclass_flag or self.OMG.input:
             self.OMG.generate_opex_properties(self.xmlroot, index, 
                                               title = self.title,
@@ -554,27 +574,53 @@ class OpexDir(OpexManifestGenerator):
             raise SystemError()
         
     def generate_opex_dirs(self, path: str):
+        """"
+        This function loops recursively through a given directory.
+        
+        There are two loops to first generate Opexes for Files; 
+        """    
         self = OpexDir(self.OMG, path)
-        opex_path = os.path.join(os.path.abspath(self.folder_path), os.path.basename(self.folder_path))
+        if self.OMG.algorithm and self.OMG.pax_fixity_flag is True and self.folder_path.endswith(".pax"):
+            opex_path = os.path.abspath(self.folder_path)
+        else:
+            opex_path = os.path.join(os.path.abspath(self.folder_path), os.path.basename(self.folder_path))
+        #First Loop to Generate Folder Manifest Opexes & Individual File Opexes.
         if self.removal is True:
+            #If removal is True for Folder, then it will be removed - Does not need to descend.
             pass
         else:
             for f_path in self.filter_directories(path):
                 if f_path.endswith('.opex'):
+                    #Ignores OPEX files / directories...
                     pass
                 elif os.path.isdir(f_path):
-                    if self.ignore is True:
+                    if self.ignore is True or \
+                    (self.OMG.removal_flag is True and \
+                     self.OMG.removal_df_lookup(self.OMG.index_df_lookup(f_path)) is True):
+                        #If Ignore is True, or the Folder below is marked for Removal: Don't add to Opex 
                         pass
                     else:
+                        #Add Folder to OPEX Manifest (doesn't get written yet...)
                         self.folder = ET.SubElement(self.folders, f"{{{self.opexns}}}Folder")
                         self.folder.text = str(os.path.basename(f_path))
-                    self.generate_opex_dirs(f_path)
+                    if self.OMG.algorithm and self.OMG.pax_fixity_flag is True and self.folder_path.endswith(".pax"):
+                        #If using fixity, but the folder is a PAX & using PAX Fixity: End descent. 
+                        pass
+                    else:
+                        #Recurse Descent.
+                        self.generate_opex_dirs(f_path)
+                elif os.path.isfile(f_path):
+                    #Processes OPEXes for individual Files: this gets written.
+                    OpexFile(self.OMG, f_path)
                 else:
-                    OpexFile(self.OMG, f_path, self.OMG.algorithm)
+                    print('Unknown File Type?')
+                    pass
+        #Second Loop to add previously generated Opexes to Folder Manifest.
         if self.removal is True or self.ignore is True:
             pass
         else:
             if check_opex(opex_path):
+                #Only processing Opexes.
                 for f_path in self.filter_directories(path):
                     if os.path.isfile(f_path):
                         file = ET.SubElement(self.files, f"{{{self.opexns}}}File")
@@ -584,12 +630,14 @@ class OpexDir(OpexManifestGenerator):
                             file.set("type", "content")
                             file.set("size", str(os.path.getsize(f_path)))
                         file.text = str(os.path.basename(f_path))
+                #Writes Folder OPEX 
                 write_opex(opex_path, self.xmlroot)
             else:
+                #Avoids Override if exists, lets you continue where left off. 
                 print(f"Avoiding override, Opex exists at: {opex_path}")
 
 class OpexFile(OpexManifestGenerator):
-    def __init__(self, OMG: OpexManifestGenerator, file_path: str, algorithm: str = None, title: str = None, description: str = None, security: str = None):
+    def __init__(self, OMG: OpexManifestGenerator, file_path: str, title: str = None, description: str = None, security: str = None):
         self.OMG = OMG
         self.opexns = self.OMG.opexns  
         if file_path.startswith(u'\\\\?\\'):
@@ -600,7 +648,7 @@ class OpexFile(OpexManifestGenerator):
             if any([self.OMG.input,
                     self.OMG.autoclass_flag in {"c","catalog","a","accession","b","both","cg","catalog-generic","ag","accession-generic","bg","both-generic"},
                     self.OMG.ignore_flag,
-                    self.OMG.remove_flag,
+                    self.OMG.removal_flag,
                     self.OMG.sourceid_flag,
                     self.OMG.title_flag,
                     self.OMG.description_flag,
@@ -616,11 +664,10 @@ class OpexFile(OpexManifestGenerator):
                 self.ignore = self.OMG.ignore_df_lookup(index)
                 if self.ignore:
                     return                    
-            if self.OMG.remove_flag:
-                self.removal = self.OMG.remove_df_lookup(self.file_path, self.OMG.remove_list, index)
+            if self.OMG.removal_flag:
+                self.removal = self.OMG.removal_df_lookup(index)
                 if self.removal:
                     return
-            self.algorithm = algorithm
             if self.OMG.title_flag or self.OMG.description_flag or self.OMG.security_flag:
                 self.title, self.description, self.security = self.OMG.xip_df_lookup(index) 
             elif self.OMG.autoclass_flag in {"generic", "g", "catalog-generic", "cg", "accession-generic", "ag", "both-generic", "bg"}:
@@ -641,7 +688,10 @@ class OpexFile(OpexManifestGenerator):
                     if self.OMG.hash_from_spread:
                         self.OMG.hash_df_lookup(self.fixities, index)  
                     else:
-                        self.genererate_opex_fixity(self.file_path)
+                        if self.OMG.pax_fixity_flag is True and (self.file_path.endswith("pax.zip") or self.file_path.endswith(".pax")):
+                            self.generate_pax_zip_opex_fixity(self.file_path)
+                        else:
+                            self.generate_opex_fixity(self.file_path)
                 if self.transfer is None:
                     self.xmlroot.remove(self.transfer)
                 if self.OMG.autoclass_flag or self.OMG.input: