compress_config_writer() - Code Metrics - Inspection of "move configparser base to new module, refactor acc..." - thurask/bbarchivist - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d56c20...c7f92e )

by John

created 2016-09-30 06:51 UTC

compress_config_writer() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	2
c	2
b	0
f	0
dl	0
loc	13
rs	9.4285

#!/usr/bin/env python3
"""This module is used to operate with archives."""

import os  # filesystem read
import subprocess  # invocation of 7z, cap
import zipfile  # zip compresssion
import tarfile  # txz/tbz/tgz/tar compression
from bbarchivist import utilities  # platform determination
from bbarchivist import bbconstants  # premade stuff
from bbarchivist import decorators  # timer
from bbarchivist import iniconfig  # config parsing

__author__ = "Thurask"
__license__ = "WTFPL v2"
__copyright__ = "Copyright 2015-2016 Thurask"


def smart_is_tarfile(filepath):
    """
    :func:`tarfile.is_tarfile` plus error handling.

    :param filepath: Filename.
    :type filepath: str
    """
    try:
        istar = tarfile.is_tarfile(filepath)
    except (OSError, IOError):
        return False
    else:
        return istar


@decorators.timer
def sz_compress(filepath, filename, szexe=None, strength=5, errors=False):
    """
    Pack a file into a LZMA2 7z file.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str

    :param szexe: Path to 7z executable.
    :type szexe: str

    :param strength: Compression strength. 5 is normal, 9 is ultra.
    :type strength: int

    :param errors: Print completion status message. Default is false.
    :type errors: bool
    """
    szcodes = {
        0: "NO ERRORS",
        1: "COMPLETED WITH WARNINGS",
        2: "FATAL ERROR",
        7: "COMMAND LINE ERROR",
        8: "OUT OF MEMORY ERROR",
        255: "USER STOPPED PROCESS"
    }
    strength = str(strength)
    rawname = os.path.dirname(filepath)
    thr = str(utilities.get_core_count())
    fold = os.path.join(rawname, filename)
    cmd = '{0} a -mx{1} -m0=lzma2 -mmt{2} "{3}.7z" "{4}"'.format(szexe, strength,
                                                                 thr, filepath, fold)
    with open(os.devnull, 'wb') as dnull:
        excode = subprocess.call(cmd, stdout=dnull, stderr=subprocess.STDOUT, shell=True)
    if errors:
        print(szcodes[excode])


def sz_verify(filepath, szexe=None):
    """
    Verify that a .7z file is valid and working.

    :param filepath: Filename.
    :type filepath: str

    :param szexe: Path to 7z executable.
    :type szexe: str
    """
    filepath = os.path.abspath(filepath)
    cmd = '{0} t "{1}"'.format(szexe, filepath)
    with open(os.devnull, 'wb') as dnull:
        excode = subprocess.call(cmd, stdout=dnull, stderr=subprocess.STDOUT, shell=True)
    return excode == 0


@decorators.timer
def tar_compress(filepath, filename):
    """
    Pack a file into an uncompressed tarfile.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str
    """
    with tarfile.open("{0}.tar".format(filepath), 'w:') as tfile:
        tfile.add(filename, filter=None, arcname=os.path.basename(filename))


def tar_verify(filepath):
    """
    Verify that a tar file is valid and working.

    :param filepath: Filename.
    :type filepath: str
    """
    if smart_is_tarfile(filepath):
        with tarfile.open(filepath, "r:") as thefile:
            mems = thefile.getmembers()
        return False if not mems else True
    else:
        return False


@decorators.timer
def tgz_compress(filepath, filename, strength=5):
    """
    Pack a file into a gzip tarfile.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str

    :param strength: Compression strength. 5 is normal, 9 is ultra.
    :type strength: int
    """
    with tarfile.open("{0}.tar.gz".format(filepath), 'w:gz', compresslevel=strength) as gzfile:
        gzfile.add(filename, filter=None, arcname=os.path.basename(filename))


def tgz_verify(filepath):
    """
    Verify that a tar.gz file is valid and working.

    :param filepath: Filename.
    :type filepath: str
    """
    if smart_is_tarfile(filepath):
        with tarfile.open(filepath, "r:gz") as thefile:
            mems = thefile.getmembers()
        return False if not mems else True
    else:
        return False


@decorators.timer
def tbz_compress(filepath, filename, strength=5):
    """
    Pack a file into a bzip2 tarfile.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str

    :param strength: Compression strength. 5 is normal, 9 is ultra.
    :type strength: int
    """
    with tarfile.open("{0}.tar.bz2".format(filepath), 'w:bz2', compresslevel=strength) as bzfile:
        bzfile.add(filename, filter=None, arcname=os.path.basename(filename))


def tbz_verify(filepath):
    """
    Verify that a tar.bz2 file is valid and working.

    :param filepath: Filename.
    :type filepath: str
    """
    if smart_is_tarfile(filepath):
        with tarfile.open(filepath, "r:bz2") as thefile:
            mems = thefile.getmembers()
        return False if not mems else True
    else:
        return False


@decorators.timer
def txz_compress(filepath, filename):
    """
    Pack a file into a LZMA tarfile.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str
    """
    if not utilities.new_enough(3):
        pass
    else:
        with tarfile.open("{0}.tar.xz".format(filepath), 'w:xz') as xzfile:
            xzfile.add(filename, filter=None, arcname=os.path.basename(filename))


def txz_verify(filepath):
    """
    Verify that a tar.xz file is valid and working.

    :param filepath: Filename.
    :type filepath: str
    """
    if not utilities.new_enough(3):
        return None
    else:
        if smart_is_tarfile(filepath):
            with tarfile.open(filepath, "r:xz") as thefile:
                mems = thefile.getmembers()
            return False if not mems else True
        else:
            return False


@decorators.timer
def zip_compress(filepath, filename):
    """
    Pack a file into a DEFLATE zipfile.

    :param filepath: Basename of file, no extension.
    :type filepath: str

    :param filename: Name of file to pack.
    :type filename: str
    """
    with zipfile.ZipFile("{0}.zip".format(filepath), 'w', zipfile.ZIP_DEFLATED, allowZip64=True) as zfile:
        zfile.write(filename, arcname=os.path.basename(filename))


def zip_verify(filepath):
    """
    Verify that a .zip file is valid and working.

    :param filepath: Filename.
    :type filepath: str
    """
    if zipfile.is_zipfile(filepath):
        try:
            with zipfile.ZipFile(filepath, "r") as zfile:
                brokens = zfile.testzip()
        except zipfile.BadZipFile:
            brokens = filepath
        return brokens != filepath
    else:
        return False


def filter_method(method, szexe=None):
    """
    Make sure methods are OK.

    :param method: Compression method to use.
    :type method: str

    :param szexe: Path to 7z executable, if needed.
    :type szexe: str
    """
    if not utilities.new_enough(3) and method == "txz":
        method = "zip"  # fallback
    if method == "7z" and szexe is None:
        ifexists = utilities.prep_seven_zip()  # see if 7z exists
        if not ifexists:
            method = "zip"  # fallback
        else:
            szexe = utilities.get_seven_zip(False)
    return method


def calculate_strength():
    """
    Determine zip/gzip/bzip2 strength by OS bit setting.
    """
    strength = 9 if utilities.is_amd64() else 5
    return strength


def filtercomp(files, criterion, critargs, boolfilt=True):
    """
    :param files: Files to work on.
    :type files: list(str)

    :param criterion: Function to use for evaluation.
    :type criterion: func

    :param critargs: Arguments for function, other than file.
    :type critargs: list

    :param boolfilt: True if comparing criterion, False if comparing not criterion.
    :type boolfilt: bool
    """
    if boolfilt:
        fx2 = [file for file in files if criterion(file, *critargs)]
    else:
        fx2 = [file for file in files if not criterion(file, *critargs)]
    return fx2


def compressfilter(filepath, selective=False):
    """
    Filter directory listing of working directory.

    :param filepath: Working directory. Required.
    :type filepath: str

    :param selective: Only compress autoloaders. Default is false.
    :type selective: bool/str
    """
    arx = bbconstants.ARCS
    pfx = bbconstants.PREFIXES
    files = [file for file in os.listdir(filepath) if not os.path.isdir(file)]
    if selective is None:
        filt2 = os.listdir(filepath)
    elif selective == "arcsonly":
        filt2 = filtercomp(files, utilities.prepends, ("", arx))
    elif selective:
        filt0 = filtercomp(files, utilities.prepends, (pfx, ""))
        filt1 = filtercomp(filt0, utilities.prepends, ("", arx), False)  # pop archives
        filt2 = filtercomp(filt1, utilities.prepends, ("", ".exe"))  # include exes
    else:
        filt2 = filtercomp(files, utilities.prepends, ("", arx), False)  # pop archives
    filt3 = [os.path.join(filepath, file) for file in filt2]
    return filt3


def compress(filepath, method="7z", szexe=None, selective=False, errors=False):
    """
    Compress all autoloader files in a given folder, with a given method.

    :param filepath: Working directory. Required.
    :type filepath: str

    :param method: Compression type. Default is "7z".
    :type method: str

    :param szexe: Path to 7z executable, if needed.
    :type szexe: str

    :param selective: Only compress autoloaders. Default is false.
    :type selective: bool

    :param errors: Print completion status message. Default is false.
    :type errors: bool
    """
    method = filter_method(method, szexe)
    files = compressfilter(filepath, selective)
    for file in files:
        fname = os.path.basename(file)
        filename = os.path.splitext(fname)[0]
        fileloc = os.path.join(filepath, filename)
        print("COMPRESSING: {0}".format(fname))
        if method == "7z":
            sz_compress(fileloc, file, szexe, calculate_strength(), errors)
        elif method == "tgz":
            tgz_compress(fileloc, file, calculate_strength())
        elif method == "txz":
            txz_compress(fileloc, file)
        elif method == "tbz":
            tbz_compress(fileloc, file, calculate_strength())
        elif method == "tar":
            tar_compress(fileloc, file)
        elif method == "zip":
            zip_compress(fileloc, file)
    return True


def tarzip_verifier(file):
    """
    Assign .tar.xxx, .tar and .zip verifiers.

    :param file: Filename.
    :type file: str
    """
    maps = {".tar.gz": tgz_verify, ".tar.xz": txz_verify,
            ".tar.bz2": tbz_verify, ".tar": tar_verify,
            ".zip": zip_verify, ".bar": zip_verify}
    for key, value in maps.items():
        if file.endswith(key):
            return value(file)


def decide_verifier(file, szexe=None):
    """
    Decide which verifier function to use.

    :param file: Filename.
    :type file: str

    :param szexe: Path to 7z executable, if needed.
    :type szexe: str
    """
    print("VERIFYING: {0}".format(file))
    if file.endswith(".7z") and szexe is not None:
        verif = sz_verify(os.path.abspath(file), szexe)
    else:
        verif = tarzip_verifier(file)
    if not verif:
        print("{0} IS BROKEN!".format(os.path.basename(file)))
    else:
        print("{0} OK".format(os.path.basename(file)))
    return verif


def verify(filepath, method="7z", szexe=None, selective=False):
    """
    Verify specific archive files in a given folder.

    :param filepath: Working directory. Required.
    :type filepath: str

    :param method: Compression type. Default is "7z". Defined in source.
    :type method: str

    :param szexe: Path to 7z executable, if needed.
    :type szexe: str

    :param selective: Only verify autoloaders. Default is false.
    :type selective: bool
    """
    method = filter_method(method, szexe)
    files = compressfilter(filepath, selective)
    for file in files:
        decide_verifier(file, szexe)


def compress_config_loader(homepath=None):
    """
    Read a ConfigParser file to get compression preferences.

    :param homepath: Folder containing ini file. Default is user directory.
    :type homepath: str
    """
    compini = iniconfig.generic_loader('compression', homepath)
    method = compini.get('method', fallback="7z")
    if not utilities.new_enough(3) and method == "txz":
        method = "zip"  # for 3.2 compatibility
    return method


def compress_config_writer(method=None, homepath=None):
    """
    Write a ConfigParser file to store compression preferences.

    :param method: Method to use.
    :type method: str

    :param homepath: Folder containing ini file. Default is user directory.
    :type homepath: str
    """
    method = compress_config_loader() if method is None else method
    results = {"method": method}
    iniconfig.generic_writer("compression", results, homepath)


1			#!/usr/bin/env python3
2			"""This module is used to operate with archives."""
3
4			import os # filesystem read
5			import subprocess # invocation of 7z, cap
6			import zipfile # zip compresssion
7			import tarfile # txz/tbz/tgz/tar compression
8			from bbarchivist import utilities # platform determination
9			from bbarchivist import bbconstants # premade stuff
10			from bbarchivist import decorators # timer
11			from bbarchivist import iniconfig # config parsing
12
13			__author__ = "Thurask"
14			__license__ = "WTFPL v2"
15			__copyright__ = "Copyright 2015-2016 Thurask"
16
17
18			def smart_is_tarfile(filepath):
19			"""
20			:func:`tarfile.is_tarfile` plus error handling.
21
22			:param filepath: Filename.
23			:type filepath: str
24			"""
25			try:
26			istar = tarfile.is_tarfile(filepath)
27			except (OSError, IOError):
28			return False
29			else:
30			return istar
31
32
33			@decorators.timer
34			def sz_compress(filepath, filename, szexe=None, strength=5, errors=False):
35			"""
36			Pack a file into a LZMA2 7z file.
37
38			:param filepath: Basename of file, no extension.
39			:type filepath: str
40
41			:param filename: Name of file to pack.
42			:type filename: str
43
44			:param szexe: Path to 7z executable.
45			:type szexe: str
46
47			:param strength: Compression strength. 5 is normal, 9 is ultra.
48			:type strength: int
49
50			:param errors: Print completion status message. Default is false.
51			:type errors: bool
52			"""
53			szcodes = {
54			0: "NO ERRORS",
55			1: "COMPLETED WITH WARNINGS",
56			2: "FATAL ERROR",
57			7: "COMMAND LINE ERROR",
58			8: "OUT OF MEMORY ERROR",
59			255: "USER STOPPED PROCESS"
60			}
61			strength = str(strength)
62			rawname = os.path.dirname(filepath)
63			thr = str(utilities.get_core_count())
64			fold = os.path.join(rawname, filename)
65			cmd = '{0} a -mx{1} -m0=lzma2 -mmt{2} "{3}.7z" "{4}"'.format(szexe, strength,
66			thr, filepath, fold)
67			with open(os.devnull, 'wb') as dnull:
68			excode = subprocess.call(cmd, stdout=dnull, stderr=subprocess.STDOUT, shell=True)
69			if errors:
70			print(szcodes[excode])
71
72
73			def sz_verify(filepath, szexe=None):
74			"""
75			Verify that a .7z file is valid and working.
76
77			:param filepath: Filename.
78			:type filepath: str
79
80			:param szexe: Path to 7z executable.
81			:type szexe: str
82			"""
83			filepath = os.path.abspath(filepath)
84			cmd = '{0} t "{1}"'.format(szexe, filepath)
85			with open(os.devnull, 'wb') as dnull:
86			excode = subprocess.call(cmd, stdout=dnull, stderr=subprocess.STDOUT, shell=True)
87			return excode == 0
88
89
90			@decorators.timer
91			def tar_compress(filepath, filename):
92			"""
93			Pack a file into an uncompressed tarfile.
94
95			:param filepath: Basename of file, no extension.
96			:type filepath: str
97
98			:param filename: Name of file to pack.
99			:type filename: str
100			"""
101			with tarfile.open("{0}.tar".format(filepath), 'w:') as tfile:
102			tfile.add(filename, filter=None, arcname=os.path.basename(filename))
103
104
105			def tar_verify(filepath):
106			"""
107			Verify that a tar file is valid and working.
108
109			:param filepath: Filename.
110			:type filepath: str
111			"""
112			if smart_is_tarfile(filepath):
113			with tarfile.open(filepath, "r:") as thefile:
114			mems = thefile.getmembers()
115			return False if not mems else True
116			else:
117			return False
118
119
120			@decorators.timer
121			def tgz_compress(filepath, filename, strength=5):
122			"""
123			Pack a file into a gzip tarfile.
124
125			:param filepath: Basename of file, no extension.
126			:type filepath: str
127
128			:param filename: Name of file to pack.
129			:type filename: str
130
131			:param strength: Compression strength. 5 is normal, 9 is ultra.
132			:type strength: int
133			"""
134			with tarfile.open("{0}.tar.gz".format(filepath), 'w:gz', compresslevel=strength) as gzfile:
135			gzfile.add(filename, filter=None, arcname=os.path.basename(filename))
136
137
138			def tgz_verify(filepath):
139			"""
140			Verify that a tar.gz file is valid and working.
141
142			:param filepath: Filename.
143			:type filepath: str
144			"""
145			if smart_is_tarfile(filepath):
146			with tarfile.open(filepath, "r:gz") as thefile:
147			mems = thefile.getmembers()
148			return False if not mems else True
149			else:
150			return False
151
152
153			@decorators.timer
154			def tbz_compress(filepath, filename, strength=5):
155			"""
156			Pack a file into a bzip2 tarfile.
157
158			:param filepath: Basename of file, no extension.
159			:type filepath: str
160
161			:param filename: Name of file to pack.
162			:type filename: str
163
164			:param strength: Compression strength. 5 is normal, 9 is ultra.
165			:type strength: int
166			"""
167			with tarfile.open("{0}.tar.bz2".format(filepath), 'w:bz2', compresslevel=strength) as bzfile:
168			bzfile.add(filename, filter=None, arcname=os.path.basename(filename))
169
170
171			def tbz_verify(filepath):
172			"""
173			Verify that a tar.bz2 file is valid and working.
174
175			:param filepath: Filename.
176			:type filepath: str
177			"""
178			if smart_is_tarfile(filepath):
179			with tarfile.open(filepath, "r:bz2") as thefile:
180			mems = thefile.getmembers()
181			return False if not mems else True
182			else:
183			return False
184
185
186			@decorators.timer
187			def txz_compress(filepath, filename):
188			"""
189			Pack a file into a LZMA tarfile.
190
191			:param filepath: Basename of file, no extension.
192			:type filepath: str
193
194			:param filename: Name of file to pack.
195			:type filename: str
196			"""
197			if not utilities.new_enough(3):
198			pass
199			else:
200			with tarfile.open("{0}.tar.xz".format(filepath), 'w:xz') as xzfile:
201			xzfile.add(filename, filter=None, arcname=os.path.basename(filename))
202
203
204			def txz_verify(filepath):
205			"""
206			Verify that a tar.xz file is valid and working.
207
208			:param filepath: Filename.
209			:type filepath: str
210			"""
211			if not utilities.new_enough(3):
212			return None
213			else:
214			if smart_is_tarfile(filepath):
215			with tarfile.open(filepath, "r:xz") as thefile:
216			mems = thefile.getmembers()
217			return False if not mems else True
218			else:
219			return False
220
221
222			@decorators.timer
223			def zip_compress(filepath, filename):
224			"""
225			Pack a file into a DEFLATE zipfile.
226
227			:param filepath: Basename of file, no extension.
228			:type filepath: str
229
230			:param filename: Name of file to pack.
231			:type filename: str
232			"""
233			with zipfile.ZipFile("{0}.zip".format(filepath), 'w', zipfile.ZIP_DEFLATED, allowZip64=True) as zfile:
234			zfile.write(filename, arcname=os.path.basename(filename))
235
236
237			def zip_verify(filepath):
238			"""
239			Verify that a .zip file is valid and working.
240
241			:param filepath: Filename.
242			:type filepath: str
243			"""
244			if zipfile.is_zipfile(filepath):
245			try:
246			with zipfile.ZipFile(filepath, "r") as zfile:
247			brokens = zfile.testzip()
248			except zipfile.BadZipFile:
249			brokens = filepath
250			return brokens != filepath
251			else:
252			return False
253
254
255			def filter_method(method, szexe=None):
256			"""
257			Make sure methods are OK.
258
259			:param method: Compression method to use.
260			:type method: str
261
262			:param szexe: Path to 7z executable, if needed.
263			:type szexe: str
264			"""
265			if not utilities.new_enough(3) and method == "txz":
266			method = "zip" # fallback
267			if method == "7z" and szexe is None:
268			ifexists = utilities.prep_seven_zip() # see if 7z exists
269			if not ifexists:
270			method = "zip" # fallback
271			else:
272			szexe = utilities.get_seven_zip(False)
273			return method
274
275
276			def calculate_strength():
277			"""
278			Determine zip/gzip/bzip2 strength by OS bit setting.
279			"""
280			strength = 9 if utilities.is_amd64() else 5
281			return strength
282
283
284			def filtercomp(files, criterion, critargs, boolfilt=True):
285			"""
286			:param files: Files to work on.
287			:type files: list(str)
288
289			:param criterion: Function to use for evaluation.
290			:type criterion: func
291
292			:param critargs: Arguments for function, other than file.
293			:type critargs: list
294
295			:param boolfilt: True if comparing criterion, False if comparing not criterion.
296			:type boolfilt: bool
297			"""
298			if boolfilt:
299			fx2 = [file for file in files if criterion(file, *critargs)]
300			else:
301			fx2 = [file for file in files if not criterion(file, *critargs)]
302			return fx2
303
304
305			def compressfilter(filepath, selective=False):
306			"""
307			Filter directory listing of working directory.
308
309			:param filepath: Working directory. Required.
310			:type filepath: str
311
312			:param selective: Only compress autoloaders. Default is false.
313			:type selective: bool/str
314			"""
315			arx = bbconstants.ARCS
316			pfx = bbconstants.PREFIXES
317			files = [file for file in os.listdir(filepath) if not os.path.isdir(file)]
318			if selective is None:
319			filt2 = os.listdir(filepath)
320			elif selective == "arcsonly":
321			filt2 = filtercomp(files, utilities.prepends, ("", arx))
322			elif selective:
323			filt0 = filtercomp(files, utilities.prepends, (pfx, ""))
324			filt1 = filtercomp(filt0, utilities.prepends, ("", arx), False) # pop archives
325			filt2 = filtercomp(filt1, utilities.prepends, ("", ".exe")) # include exes
326			else:
327			filt2 = filtercomp(files, utilities.prepends, ("", arx), False) # pop archives
328			filt3 = [os.path.join(filepath, file) for file in filt2]
329			return filt3
330
331
332			def compress(filepath, method="7z", szexe=None, selective=False, errors=False):
333			"""
334			Compress all autoloader files in a given folder, with a given method.
335
336			:param filepath: Working directory. Required.
337			:type filepath: str
338
339			:param method: Compression type. Default is "7z".
340			:type method: str
341
342			:param szexe: Path to 7z executable, if needed.
343			:type szexe: str
344
345			:param selective: Only compress autoloaders. Default is false.
346			:type selective: bool
347
348			:param errors: Print completion status message. Default is false.
349			:type errors: bool
350			"""
351			method = filter_method(method, szexe)
352			files = compressfilter(filepath, selective)
353			for file in files:
354			fname = os.path.basename(file)
355			filename = os.path.splitext(fname)[0]
356			fileloc = os.path.join(filepath, filename)
357			print("COMPRESSING: {0}".format(fname))
358			if method == "7z":
359			sz_compress(fileloc, file, szexe, calculate_strength(), errors)
360			elif method == "tgz":
361			tgz_compress(fileloc, file, calculate_strength())
362			elif method == "txz":
363			txz_compress(fileloc, file)
364			elif method == "tbz":
365			tbz_compress(fileloc, file, calculate_strength())
366			elif method == "tar":
367			tar_compress(fileloc, file)
368			elif method == "zip":
369			zip_compress(fileloc, file)
370			return True
371
372
373			def tarzip_verifier(file):
374			"""
375			Assign .tar.xxx, .tar and .zip verifiers.
376
377			:param file: Filename.
378			:type file: str
379			"""
380			maps = {".tar.gz": tgz_verify, ".tar.xz": txz_verify,
381			".tar.bz2": tbz_verify, ".tar": tar_verify,
382			".zip": zip_verify, ".bar": zip_verify}
383			for key, value in maps.items():
384			if file.endswith(key):
385			return value(file)
386
387
388			def decide_verifier(file, szexe=None):
389			"""
390			Decide which verifier function to use.
391
392			:param file: Filename.
393			:type file: str
394
395			:param szexe: Path to 7z executable, if needed.
396			:type szexe: str
397			"""
398			print("VERIFYING: {0}".format(file))
399			if file.endswith(".7z") and szexe is not None:
400			verif = sz_verify(os.path.abspath(file), szexe)
401			else:
402			verif = tarzip_verifier(file)
403			if not verif:
404			print("{0} IS BROKEN!".format(os.path.basename(file)))
405			else:
406			print("{0} OK".format(os.path.basename(file)))
407			return verif
408
409
410			def verify(filepath, method="7z", szexe=None, selective=False):
411			"""
412			Verify specific archive files in a given folder.
413
414			:param filepath: Working directory. Required.
415			:type filepath: str
416
417			:param method: Compression type. Default is "7z". Defined in source.
418			:type method: str
419
420			:param szexe: Path to 7z executable, if needed.
421			:type szexe: str
422
423			:param selective: Only verify autoloaders. Default is false.
424			:type selective: bool
425			"""
426			method = filter_method(method, szexe)
427			files = compressfilter(filepath, selective)
428			for file in files:
429			decide_verifier(file, szexe)
430
431
432			def compress_config_loader(homepath=None):
433			"""
434			Read a ConfigParser file to get compression preferences.
435
436			:param homepath: Folder containing ini file. Default is user directory.
437			:type homepath: str
438			"""
439			compini = iniconfig.generic_loader('compression', homepath)
440			method = compini.get('method', fallback="7z")
441			if not utilities.new_enough(3) and method == "txz":
442			method = "zip" # for 3.2 compatibility
443			return method
444
445
446			def compress_config_writer(method=None, homepath=None):
447			"""
448			Write a ConfigParser file to store compression preferences.
449
450			:param method: Method to use.
451			:type method: str
452
453			:param homepath: Folder containing ini file. Default is user directory.
454			:type homepath: str
455			"""
456			method = compress_config_loader() if method is None else method
457			results = {"method": method}
458			iniconfig.generic_writer("compression", results, homepath)
459

thurask / bbarchivist

Push — master ( d56c20...c7f92e )

compress_config_writer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like