Fix #11: on win/lin 64 a compiled libpar2 is supplied

Author: brenthuisman

README.md

@@ -4,6 +4,8 @@ Analogous to the various *deep commands (md5deep, hashdeep...) this tool serves
 
 This tool will generate one parity file (plus a file for the recovery blocks) per file that you protect. This makes it simple to move files if you change your mind on how your file tree must be organized. Just move the `par2` files along.
 
+On Windows and Linux 64bit platforms, a compiled [libpar2](https://github.com/brenthuisman/libpar2) is provided and no external `par2` required.
+
 ## Motivation
 
 I chose to use the old but well tested and well known `par2` program to base this tool on, instead of similar tools such as `zfec`, `rsbep` or something like `pyFileFixity`. Some recent forks of `par2` have added recursive scanning abilities, but they're generally not cross-platform. They also do not offer an interactive way of diagnosing (parts of) your file tree, and different problem handling for different areas of your file tree.
@@ -12,22 +14,24 @@ I use `par2deep` to secure my photos and music across drives, machines and opera
 
 ## Install
 
-You can now use pip! Make sure to update pip before installation (PyQt5 won't install without a recent pip).
+You can now use pip! Make sure to update pip before installation (PyQt5 won't install without a recent pip). On Windows, you make have to run `python` for `python3` and `pip` for `pip3`.
 
-    $ pip(3) install -U pip
-    $ pip(3) install par2deep --user
+    $ pip3 install -U pip
+    $ pip3 install par2deep --user
 
 Or clone/download this repo and install manually with:
 
-    $ python(3) setup.py install --user
+    $ python3 setup.py install --user
 
 Or run directly with:
 
-    $ python(3) par2deep
+    $ python3 par2deep
 
 Alternatively, if you have installed the `cx_Freeze` package, you can generate an msi package for Windows. Adapt `setup_cx.py` to suit your needs (include the `par2` executable and, most importantly, the icon of your choice) and then build the `.msi` file in `/dist`:
 
-    $ python setup_cx.py bdist_msi
+    $ python3 setup_cx.py bdist_msi
+    
+Note this has not been tested since v1.0.5!
 
 ## Usage
 
@@ -47,10 +51,11 @@ Example `par2deep.ini`:
  * configargparse
  * Send2Trash
  * PyQt5
- * `par2` in path or specify a tool with the same interface.
+ * Optional, if you are not on Windows or Linux 64bit, `par2` in path or specify with `par_cmd`.
 
 ### Changelog
 
+ * 2020-04-26: Include libpar2 for win64 and lin64 platforms, no external `par2` needed anymore.
  * 2020-04-20: recreate verified_repairable creates backup. backups are shows upon init. orphans are shown upon init.
  * 2020-04-16: v1.9.3: Packaging still is a pain!
  * 2020-04-16: v1.9.0: GUI rewritten in with Qt (PyQt5). Open Issues should be solved for 2.0.0 release.

par2deep/gui_qt.py

@@ -105,9 +105,9 @@ def textchanged(text):
 		exex_fld.setToolTip("These extensions will be excluded from the analysis.")
 		exex_fld.textChanged.connect(lambda fldval : self.p2d.args.update({"extexcludes":fldval.split(',')}))
 
-		parpath_lb = QLabel("Path to par2(.exe):")
+		parpath_lb = QLabel("Fallback path to par2(.exe):")
 		parpath_fld = QLineEdit(self.p2d.args["par_cmd"])
-		parpath_fld.setToolTip("Should be set automatically and correctly, but can be overridden.")
+		parpath_fld.setToolTip("If you don't use Windows or Linux 64bit, and par2 is not in PATH, par2deep will fallback to using this command.")
 		parpath_fld.textChanged.connect(lambda fldval : self.p2d.args.update({"par_cmd":fldval}))
 
 		perc_sldr = BSlider("Percentage of protection",5,100,lambda fldval : self.p2d.args.update({"percentage":fldval}),self.p2d.args["percentage"])

par2deep/libpar2.dll

@@ -1,4 +1,4 @@
-import sys,os,subprocess,re,glob,shutil
+import sys,struct,ctypes,os,subprocess,re,glob,shutil
 from configargparse import ArgParser
 from send2trash import send2trash
 
@@ -24,21 +24,20 @@
 class par2deep():
 	def __init__(self,chosen_dir=None):
 		#CMD arguments and configfile
+
+		self.shell=False
+		self.par_cmd = 'par2'
 		if sys.platform == 'win32':
-			self.shell=True
+			self.shell=True #shell true because otherwise pythonw.exe pops up a cmd.exe for EVERY file.
 			locs = [os.path.join(sys.path[0],'phpar2.exe'),
 					'phpar2.exe',
 					os.path.join(sys.path[0],'par2.exe'),
 					'par2.exe',
 					]
-			par_cmd = 'par2'
 			for p in locs:
 				if os.path.isfile(p):
-					par_cmd = p
+					self.par_cmd = p
 					break
-		else:
-			self.shell=False
-			par_cmd = 'par2'
 
 		if chosen_dir == None or not os.path.isdir(chosen_dir):
 			current_data_dir = os.getcwd()
@@ -58,7 +57,7 @@ def __init__(self,chosen_dir=None):
 		parser.add_argument("-dir", "--directory", type=str, default=current_data_dir, help="Path to protect (default is current directory).")
 		#parser.add_argument("-pardir", "--parity_directory", type=str, default=os.getcwd(), help="Path to parity data store (default is current directory).")
 		parser.add_argument("-pc", "--percentage", type=int, default=5, help="Set the parity percentage (default 5%%).")
-		parser.add_argument("-pcmd", "--par_cmd", type=str, default=par_cmd, help="Set path to alternative par2 command (default \"par2\").")
+		parser.add_argument("-pcmd", "--par_cmd", type=str, default=self.par_cmd, help="Set path to alternative par2 command (default \"par2\").")
 
 		#lets get a nice dict of all o' that.
 		#FIXME: catch unrecognized arguments
@@ -76,16 +75,25 @@ def __init__(self,chosen_dir=None):
 		return
 
 
-	def runpar(self,command):
-		devnull = open(os.devnull, 'wb')
-		#shell true because otherwise pythonw.exe pops up a cmd.exe for EVERY file.
-		try:
-			subprocess.check_call(command,shell=self.shell,stdout=devnull,stderr=devnull)
-			return 0
-		except subprocess.CalledProcessError as e:
-			return e.returncode
-		except FileNotFoundError:
-			return 200
+	def runpar(self,command=""):
+		if self.fallback:
+			cmdcommand = [self.par_cmd]
+			cmdcommand.extend(command)
+			devnull = open(os.devnull, 'wb')
+			try:
+				subprocess.check_call(cmdcommand,shell=self.shell,stdout=devnull,stderr=devnull)
+				return 0
+			except subprocess.CalledProcessError as e:
+				return e.returncode
+			except FileNotFoundError:
+				return 200
+		else:
+			def strlist2charpp(stringlist):
+				argc = len(stringlist)
+				Args = ctypes.c_char_p * (len(stringlist)+1)
+				argv = Args(*[ctypes.c_char_p(arg.encode("utf-8")) for arg in stringlist])
+				return argc,argv
+			return self.libpar2.par2cmdline(*strlist2charpp(command))
 
 
 	def check_state(self):
@@ -94,7 +102,40 @@ def check_state(self):
 			setattr(self, k, v)
 		self.percentage = str(self.percentage)
 
-		if self.runpar([self.par_cmd]) == 200:
+		#we provide a win64 and lin64 library, use if on those platforms, otherwise fallback to par_cmd, and check if that is working
+		self.fallback = True
+		_void_ptr_size = struct.calcsize('P')
+		bit64 = _void_ptr_size * 8 == 64
+		
+		if bit64:
+			windows = 'win32' in str(sys.platform).lower()
+			linux = 'linux' in str(sys.platform).lower()
+			macos = 'darwin' in str(sys.platform).lower()
+			this_script_dir = os.path.dirname(os.path.abspath(__file__))
+			if windows:
+				try:
+					os.add_dll_directory(this_script_dir) #needed on python3.8 on win
+				except:
+					pass #not available or necesary on py37 and before
+				try:
+					self.libpar2 = ctypes.CDLL(os.path.join(this_script_dir,"libpar2.dll"))
+					self.fallback = False
+				except:
+					self.fallback = True
+			elif linux:
+				try:
+					self.libpar2 = ctypes.CDLL(os.path.join(this_script_dir,"libpar2.so"))
+					self.fallback = False
+				except:
+					self.fallback = True
+			elif macos:
+				pass #TODO if possible
+			else:
+				pass
+		else:
+			pass
+		
+		if self.fallback and self.runpar() == 200:
 			return 200
 			#if 200, then par2 doesnt exist.
 
@@ -213,7 +254,7 @@ def execute(self):
 				for p in pars:
 					send2trash(p)
 					#par2 does not delete preexisting parity data, so delete any possible data.
-				createdfiles.append([ f , self.runpar([self.par_cmd,"c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
+				createdfiles.append([ f , self.runpar(["c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
 			createdfiles_err=[ [i,j] for i,j in createdfiles if j != 0 and j != 100 ]
 
 		verifiedfiles=[]
@@ -224,7 +265,7 @@ def execute(self):
 			#print('Verifying ...')
 			for f in verify:
 				yield f
-				verifiedfiles.append([ f , self.runpar([self.par_cmd,"v",f]) ])
+				verifiedfiles.append([ f , self.runpar(["v",f]) ])
 			verifiedfiles_err=[ [i,j] for i,j in verifiedfiles if j != 0 and j != 100 and j != 1 ]
 			verifiedfiles_repairable=[ [i,j] for i,j in verifiedfiles if j == 1 ]
 			verifiedfiles_succes=[ [i,j] for i,j in verifiedfiles if j == 0 ]
@@ -273,7 +314,7 @@ def execute_repair(self):
 		if self.len_verified_actions>0:
 			for f,retcode in self.verifiedfiles_repairable:
 				yield f
-				retval = self.runpar([self.par_cmd,"r",f])
+				retval = self.runpar(["r",f])
 				if retval == 0:
 					if self.clean_backup:
 						#backups should just have been cleaned in the execute phase and therefore a .1 been created.
@@ -287,7 +328,7 @@ def execute_repair(self):
 				pars = glob.glob(glob.escape(f)+'*.par2')
 				for p in pars:
 					send2trash(p)
-				recreatedfiles.append([ f , self.runpar([self.par_cmd,"c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
+				recreatedfiles.append([ f , self.runpar(["c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
 
 		self.recreate = sorted(recreatedfiles)
 		self.recreate_err = sorted([f for f,err in recreatedfiles if err !=0])
@@ -311,7 +352,7 @@ def execute_recreate(self):
 					ftmp = f+".par2deep_tmpfile"
 					shutil.copyfile(f,ftmp)
 					# now that we have a backup of the repairable, repair to obtain the actual backup we want.
-					retval = self.runpar([self.par_cmd,"r",f])
+					retval = self.runpar(["r",f])
 					if retval == 0:
 						# f is now the file we actually want to backup.
 						shutil.copyfile(f,f+".0") # will overwrite acc. to docs
@@ -333,14 +374,14 @@ def execute_recreate(self):
 				pars = glob.glob(glob.escape(f)+'*.par2')
 				for p in pars:
 					send2trash(p)
-				recreatedfiles.append([ f , self.runpar([self.par_cmd,"c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
+				recreatedfiles.append([ f , self.runpar(["c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
 
 			for f,retcode in self.verifiedfiles_err:
 				yield f
 				pars = glob.glob(glob.escape(f)+'*.par2')
 				for p in pars:
 					send2trash(p)
-				recreatedfiles.append([ f , self.runpar([self.par_cmd,"c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
+				recreatedfiles.append([ f , self.runpar(["c","-r"+self.percentage,"-n"+self.nr_parfiles,f]) ])
 
 		self.recreate = sorted(recreatedfiles)
 		self.recreate_err = sorted([f for f,err in recreatedfiles if err !=0])

par2deep/libpar2.so

@@ -1,7 +1,7 @@
 #! /usr/bin/env python
 from setuptools import setup
 
-VERSION = '1.9.3'
+VERSION = '1.9.4'
 
 def main():
     setup(name='par2deep',
@@ -22,13 +22,14 @@ def main():
           ],
           keywords='par2 file integrity',
           author='Brent Huisman',
-          author_email='mail@brenthuisman.net',
+          author_email='brent@huisman.pl',
           url='https://github.com/brenthuisman/par2deep',
           license='LGPL',
           include_package_data=True,
           zip_safe=False,
           install_requires=['tqdm','configargparse','Send2Trash','PyQt5'],
           packages=['par2deep'],
+          package_data={'': ['libpar2.so','libpar2.dll']},
           entry_points={
               "console_scripts": ['par2deep = par2deep.gui_qt:main', 'par2deep-tk = par2deep.gui_tk:main', 'par2deep-cli = par2deep.cli:main'],
           }