damage 0.3.14__tar.gz

damage-0.3.14/LICENCE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2021 University of British Columbia Library
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

damage-0.3.14/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.3
+Name: damage
+Version: 0.3.14
+Summary: File manifest generator and python package for statistical data files and documentation'
+License: MIT
+Keywords: metadata,SAS,SPSS,Stata,rectangular files,manifest generator
+Author: Paul Lesack
+Author-email: paul.lesack@ubc.ca
+Requires-Python: >=3.12, <4
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: X11 Applications
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: Utilities
+Requires-Dist: chardet (>=5.2.0,<6.0.0)
+Requires-Dist: freesimplegui (>=5.2.0,<6.0.0)
+Requires-Dist: numpy (>=2.2.3,<3.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pyreadstat (>=1.2.8,<2.0.0)
+Project-URL: Homepage, https://ubc-library-rc.github.io/damage
+Project-URL: Issue Tracker, https://github.com/ubc-library-rc/damage/issues
+Project-URL: Repository, https://github.com/ubc-library-rc/damage
+Description-Content-Type: text/markdown
+
+# File manifest tools: Damage
+
+Damage is a simple command-line utility which outputs a file manifest in a variety of formats, with a special focus on statistical package files from SPSS, SAS and Stata. It's also the name of the Python package which you can use in your own code and which powers the _damage_ utility.
+
+Source code and documentation files are available at <https://github.com/ubc-library-rc/damage>. Documentation is in the intuitively named _docs_ subdirectory. 
+
+Binary versions of the *damage* utility for Windows and MacOS computers can be found on the project's Github release page: <https://github.com/ubc-library-rc/damage/releases>.
+
+A less utilitarian documentation viewing experience is available at <https://ubc-library-rc.github.io/damage/>.
+

damage-0.3.14/README.md

@@ -0,0 +1,9 @@
+# File manifest tools: Damage
+
+Damage is a simple command-line utility which outputs a file manifest in a variety of formats, with a special focus on statistical package files from SPSS, SAS and Stata. It's also the name of the Python package which you can use in your own code and which powers the _damage_ utility.
+
+Source code and documentation files are available at <https://github.com/ubc-library-rc/damage>. Documentation is in the intuitively named _docs_ subdirectory. 
+
+Binary versions of the *damage* utility for Windows and MacOS computers can be found on the project's Github release page: <https://github.com/ubc-library-rc/damage/releases>.
+
+A less utilitarian documentation viewing experience is available at <https://ubc-library-rc.github.io/damage/>.

damage-0.3.14/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "damage"
+version = "0.3.14"
+description = "File manifest generator and python package for statistical data files and documentation'"
+authors = [
+    {name = "Paul Lesack",email = "paul.lesack@ubc.ca"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.12, <4"
+dependencies = [
+    "freesimplegui (>=5.2.0,<6.0.0)",
+    "chardet (>=5.2.0,<6.0.0)",
+    "numpy (>=2.2.3,<3.0.0)",
+    "pandas (>=2.2.3,<3.0.0)",
+    "pyreadstat (>=1.2.8,<2.0.0)"
+]
+keywords =["metadata","SAS", "SPSS", "Stata", "rectangular files", "manifest generator"]
+
+[project.urls]
+homepage = "https://ubc-library-rc.github.io/damage"
+repository = "https://github.com/ubc-library-rc/damage"
+"Issue Tracker" = "https://github.com/ubc-library-rc/damage/issues"
+
+[tool.poetry]
+packages = [{"include" = "damage", "from"="src"}]
+classifiers = ["Development Status :: 4 - Beta",
+			   "Environment :: Console",
+			   "Environment :: MacOS X",
+			   "Environment :: Win32 (MS Windows)",
+			   "Environment :: X11 Applications",
+			   "Intended Audience :: Education",
+			   "License :: OSI Approved :: MIT License",
+			   "Topic :: Education",
+			   "Topic :: Utilities"]
+
+[tool.poetry.group.dev.dependencies]
+pylint = ">=3.3.4"
+mkdocs = ">=1.6.1"
+pydoc-markdown = ">=4.0.0"
+
+[project.scripts]
+damage = "damage.console.damage_cmd:main"
+damage-gui = "damage.gui.damage_gui:main"
+
+#windows only?
+[project.gui-scripts]
+damage-gui = "damage.gui.damage_gui:main"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

damage-0.3.14/src/damage/__init__.py

@@ -0,0 +1,444 @@
+'''
+Manifest generator for data files.
+
+Produces a text file with user specificied checksums for all files
+from the top of a specified tree and checks line length
+and ASCII character status for text files.
+
+For statistics program files:
+  SAS .sas7bdat
+  SPSS .sav
+  Stata .dta
+
+Checker() will report number of cases and variables as
+rows and columns respectively.
+
+'''
+
+import copy
+import csv
+import hashlib
+import io
+import json
+import logging
+import mimetypes
+import pathlib
+import string
+
+import chardet
+import pyreadstat
+
+LOGGER = logging.getLogger()
+
+VERSION = (0, 3, 14)
+__version__ = '.'.join([str(x) for x in VERSION])
+
+#PDB note check private variables with self._Checker__private_var
+#Note *single* underscore before Checker
+class Checker():
+    '''
+    A collection of various tools attached to a file
+    '''
+
+    def __init__(self, fname: str) -> None: #DONE
+        '''
+        Initializes Checker instance
+
+            fname : str
+                Path to file
+        '''
+        #Commercial stats files extensions
+        #I am aware that extension checking is not perfect
+        self.statfiles = ['.dta', '.sav', '.sas7bdat']
+        #brute force is best force
+        self.textfiles= ['.dat', '.txt', '.md', '.csv',
+                        '.tsv', '.asc', '.html', '.xml',
+                        '.xsd', '.htm', '.log', '.nfo',
+                        '.text', '.xsl', '.py', '.r',
+                         '.toml', '.yaml', '.yml']
+        self.fname = pathlib.Path(fname)
+        #self._ext = fname.suffix
+        self.__istext = self.__istextfile()
+        self.__text_obj = None
+        with open(self.fname, 'rb') as fil:
+            self.__fobj_bin = io.BytesIO(fil.read())
+        self.encoding = self.__encoding()
+        if self.__istext:
+            with open(self.fname, encoding=self.encoding.get('encoding')) as f:
+                self.__text_obj = io.StringIO(f.read())
+
+
+    @property
+    def hidden(self)->bool:
+        '''
+        Returns True if file is hidden (ie, startswith '.')
+        or is in in a hidden directory (ie, any directory on the path
+        starts with '.')
+        '''
+        if any([x.startswith('.') for x in self.fname.parts]):
+            return True
+        return False
+
+    def __istextfile(self):
+        '''
+        Check to see if file is a text file based on mimetype.
+        Works with extensions only which is not ideal
+        '''
+        try:
+            if ('text' in mimetypes.guess_file_type(self.fname)
+                or self.fname.suffix.lower() in self.textfiles):
+                return True
+        except AttributeError: #soft deprecation fix
+            if ('text' in mimetypes.guess_type(self.fname)
+                or self.fname.suffix.lower() in self.textfiles):
+                return True
+
+        return False
+
+    def __encoding(self) -> dict: #DONE
+        '''
+        Returns most likely encoding of self.fname, dict with keys
+        encoding, confidence, language (the output of chardet.detect)
+        and sets Checker.__is_text
+        '''
+        enc = chardet.detect(self.__fobj_bin.read())
+        self.__fobj_bin.seek(0) #leave it as you found it
+        if self.__istext:
+            return enc
+
+        return {'encoding': None,
+                    'confidence': 0.0,
+                    'language' : ''}
+
+    def __del__(self) -> None:#DONE
+        '''
+        Destructor closes file
+        '''
+        self.__fobj_bin.close()
+
+    def produce_digest(self, prot: str = 'md5', blocksize: int = 2*16) -> str: #DONE
+        '''
+        Returns hex digest for object
+
+            fname : str
+               Path to a file object
+
+            prot : str
+               Hash type. Supported hashes: 'sha1', 'sha224', 'sha256',
+                  'sha384', 'sha512', 'blake2b', 'blake2s', 'md5'.
+                  Default: 'md5'
+
+            blocksize : int
+               Read block size in bytes
+        '''
+        ok_hash = {'sha1' : hashlib.sha1(),
+                   'sha224' : hashlib.sha224(),
+                   'sha256' : hashlib.sha256(),
+                   'sha384' : hashlib.sha384(),
+                   'sha512' : hashlib.sha512(),
+                   'blake2b' : hashlib.blake2b(),
+                   'blake2s' : hashlib.blake2s(),
+                   'md5': hashlib.md5()}
+
+        self.__fobj_bin.seek(0)
+        try:
+            _hash = ok_hash[prot]
+        except (UnboundLocalError, KeyError):
+            message = ('Unsupported hash type. Valid values are '
+                       f'{list(ok_hash)}.')
+            LOGGER.exception('Unsupported hash type. Valid values are %s', message)
+            raise
+
+        fblock = self.__fobj_bin.read(blocksize)
+        while fblock:
+            _hash.update(fblock)
+            fblock = self.__fobj_bin.read(blocksize)
+        return _hash.hexdigest()
+
+    def flat_tester(self, **kwargs) -> dict: #DONE
+        '''
+        Checks file for line length and number of records.
+
+        Returns a dictionary:
+
+        `{'min_cols': int, 'max_cols' : int, 'numrec':int, 'constant' : bool}`
+        '''
+        if not kwargs.get('flatfile'):
+            return {'min_cols': 'N/A', 'max_cols': 'N/A', 'numrec' : 'N/A',
+                    'constant': 'N/A', 'encoding' : 'N/A'}
+
+        if self.fname.suffix.lower() in self.statfiles:
+            return self._flat_tester_commercial(**kwargs)
+
+        if self.__istext:
+            return self._flat_tester_txt()
+        #this should not happen but you never know
+        return {'min_cols': 'N/A', 'max_cols': 'N/A', 'numrec' : 'N/A',
+                'constant': 'N/A', 'encoding' : 'N/A'}
+
+    def _flat_tester_commercial(self, **kwargs) -> dict: #DONE
+        '''
+        Checks SPSS sav, SAS sas7bdat and Stata .dta files for rectangularity
+
+        Returns a dictionary:
+
+        `{'min_cols': int, 'max_cols': int, 'numrec' : int,
+                    'constant': True, 'encoding': str}`
+
+        These files are by definition rectanglar, at least as checked here
+        by pyreadstat/pandas, so constant will always == True.
+        '''
+        if not kwargs.get('flatfile'):
+            return {'min_cols': 'N/A', 'max_cols': 'N/A', 'numrec' : 'N/A',
+                    'constant': 'N/A', 'encoding': 'N/A'}
+        options = {'.sav' : pyreadstat.read_sav,
+                   '.dta' : pyreadstat.read_dta,
+                   '.sas7bdat' : pyreadstat.read_sas7bdat}
+        meta = options[self.fname.suffix.lower()](self.fname)[1]
+        #self._encoding = meta.file_encoding
+        self.encoding['encoding'] = meta.file_encoding
+        return {'min_cols':meta.number_columns,
+                'max_cols':meta.number_columns,
+                'numrec': meta.number_rows,
+                'constant':True,
+                'encoding': self.encoding['encoding']}
+
+    def _flat_tester_txt(self) -> dict: #DONE
+        '''
+        Checks file for line length and number of records.
+
+        Returns a dictionary:
+
+        `{'min_cols': int, 'max_cols' : int, 'numrec':int, 'constant' : bool}`
+        '''
+        linecount = 0
+        self.__text_obj.seek(0)
+        if not self.__istext:
+            raise TypeError('Not a text file')
+        maxline = len(self.__text_obj.readline())
+        minline = maxline
+        orig = maxline   # baseline to which new values are compared
+        for row in self.__text_obj.readlines():
+            linecount += 1
+            maxline = max(maxline, len(row))
+            minline = min(minline, len(row))
+        constant = bool(maxline == orig == minline)
+        self.__text_obj.seek(0)
+        return {'min_cols': minline, 'max_cols': maxline, 'numrec' : linecount,
+                'constant': constant, 'encoding': self.encoding['encoding']}
+
+    def non_ascii_tester(self, **kwargs) -> list: #DONE
+        '''
+        Returns a list of dicts of positions of non-ASCII characters in a text file.
+
+        `[{'row': int, 'col':int, 'char':str}...]`
+
+            fname : str
+               Path/filename
+
+            Keyword arguments:
+
+                #flatfile : bool
+                asctest : bool
+                   — Perform character check (assuming it is text)
+        '''
+        if (kwargs.get('asctest', False)
+            or not self.__istext
+            or not kwargs.get('flatfile')):
+            return []
+        outlist = []
+        self.__text_obj.seek(0)
+        for rown, row in enumerate(self.__text_obj):
+            for coln, char in enumerate(row):
+                if char not in string.printable and char != '\x00':
+                    non_asc = {'row':rown+1, 'col': coln+1, 'char':char}
+                    outlist.append(non_asc)
+        self.__text_obj.seek(0)
+        return outlist
+
+    def null_count(self, **kwargs) -> dict: #DONE
+        '''
+        Returns an integer count of null characters in the file
+        ('\x00') or None if skipped
+
+        Keyword arguments:
+
+                flatfile : bool
+                   — Test is useless if not a text file. If False, returns 'N/A'
+        '''
+        if (not kwargs.get('flatfile')
+                or not self.__istext
+                or not kwargs.get('null_chars')):
+            return None
+        self.__text_obj.seek(0)
+        count = self.__text_obj.read().count('\x00')
+        if not count:
+            return None
+        return count
+
+    def dos(self, **kwargs) -> bool: #DONE
+        '''
+        Checks for presence of carriage returns in file
+
+        Returns True if a carriage return ie, ord(13) is present
+
+        Keyword arguments:
+
+            flatfile : bool
+                — Perform rectangularity check. If False, returns dictionary
+                  with all values as 'N/A'
+        '''
+        if not kwargs.get('flatfile') or not self.__istext:
+            return None
+        self.__fobj_bin.seek(0)
+        for text in self.__fobj_bin:
+            if b'\r\n' in text:
+                return True
+        return False
+
+    def _mime_type(self, fname:pathlib.Path)->tuple:
+        '''
+        Returns mimetype or 'application/octet-stream'
+        '''
+        try:
+            out = mimetypes.guess_file_type(fname, strict=False)[0]
+        except AttributeError:
+            #soft deprecation
+            out = mimetypes.guess_type(fname)[0]
+        if not out:
+            out = 'application/octet-stream'
+        return out
+
+    def _report(self, **kwargs) -> dict: #DONE
+        '''
+        Returns a dictionary of outputs based on keywords below.
+        Performs each test and returns the appropriate values. A convenience
+        function so that you don't have to run the tests individually.
+
+        Sample output:
+
+        ```
+        {'filename':'/tmp/test.csv',
+        'flat': True,
+        'min_cols': 100, 'max_cols': 100, 'numrec' : 101, 'constant': True,
+        'nonascii':False,
+        'dos':False}
+        ```
+        Accepted keywords and defaults:
+            digest : str
+                — Hash algorithm. Default 'md5'
+
+            flat : bool
+                — Flat file checking.
+
+            nonascii : bool
+                — Check for non-ASCII characters.
+
+            flatfile : bool
+                — Perform rectangularity check. If False, returns dictionary
+                  with all values as 'N/A'
+
+            null_chars : bool
+                - check for null characters
+        '''
+        out = {'filename': self.fname}
+        digest = kwargs.get('digest', 'md5')
+        #dos = kwargs.get('dos')
+
+        out.update({'digestType' : digest})
+        out.update({'digest' : self.produce_digest(digest)})
+        #out.update({'flat': self.flat_tester(**kwargs)})
+        out.update(self.flat_tester(**kwargs))
+        #out.update({'flat':'FFFFFFFFFFFF'})
+        out.update({'nonascii': self.non_ascii_tester(**kwargs)})
+        out.update({'encoding': self.encoding['encoding']})
+        out.update({'null_chars': self.null_count(**kwargs)})
+        out.update({'mimetype': self._mime_type(self.fname)})
+        #if dos:
+        #    out.update({'dos' : self.dos(**kwargs)})
+        #else:
+        #    out.update({'dos': None})
+        out.update({'dos': self.dos(**kwargs)})
+        return out
+
+    def _manifest_txt(self, **kwargs)->str:
+        '''
+        Returns manifest as plain text
+        '''
+        return '\n'.join([f'{k}: {v}' for k,v in kwargs['report'].items()
+                          if v not in ['', None]])
+
+    def _manifest_json(self, **kwargs)->str:
+        '''
+        Returns manifest as JSON
+        '''
+        out = kwargs['report'].copy()
+        out['filename'] = str(kwargs['report']['filename'])
+        return json.dumps(out)
+
+    def _manifest_csv(self, **kwargs)->str:
+        '''
+        Returns manifest as [whatever]-separated value
+        '''
+        outstr = io.StringIO(newline='')
+        writer = csv.DictWriter(outstr, fieldnames=kwargs['report'].keys(),
+                                delimiter=kwargs.get('sep', ','),
+                                quoting=csv.QUOTE_MINIMAL)
+        if kwargs.get('headers'):
+            writer.writeheader()
+        writer.writerow(kwargs['report'])
+        outstr.seek(0)
+        return outstr.read()
+
+    def manifest(self, **kwargs) -> str: #really as str #DONE
+        '''
+        Returns desired output type as string
+
+        out : str
+            — Acceptable values are 'txt', 'json', 'csv'
+              'txt' Plain text
+              'json' JSON
+              'csv' Comma-separated value
+
+        Accepted keywords and defaults:
+
+            digest : str
+                — Hash algorithm. Default 'md5'
+
+            flat : bool
+                — Flat file checking. Default True
+
+            nonascii : bool
+                — Check for non-ASCII characters. Default True
+
+            dos : bool
+                — check for Windows CR/LF combo. Default True
+
+            flatfile : bool
+                — Perform rectangularity check. If False, returns dictionary
+                  with all values as 'N/A'
+
+            headers : bool
+               —  Include csv header (only has any effect with out='csv')
+                  Default is False
+
+            sep: str
+              —  Separator if you want a different plain text separator like a
+                tab (\t) or pipe (|). Only functional with csv output, obviously.
+
+        '''
+        report = self._report(**kwargs)
+        report_type={'txt': self._manifest_txt,
+                    'json': self._manifest_json,
+                    'csv': self._manifest_csv,
+                    'tsv': self._manifest_csv,
+                    'psv': self._manifest_csv}
+
+        try:
+            return report_type[kwargs['out']](report=report, **kwargs)
+        except KeyError:
+            LOGGER.error('Unsupported manifest type %s; defaulting to text', kwargs['out'])
+            return report_type[kwargs['out']](report=report, out='txt', **kwargs)
+
+if __name__ == '__main__':
+    pass

damage-0.3.14/src/damage/console/damage_cmd.py

@@ -0,0 +1,126 @@
+'''
+Manifest generator for data files.
+
+Produces a text file with user specified checksums for all files
+from the top of a specified tree and checks line length
+and ASCII character status for text files.
+
+For statistics program files:
+  SAS .sas7bdat
+  SPSS .sav
+  Stata .dta
+
+Checker() will report number of cases and variables as
+rows and columns respectively.
+
+'''
+
+import argparse
+import glob #God I hate Windows
+import json
+import os
+import pathlib
+import sys
+
+import damage
+
+def parse() -> argparse.ArgumentParser(): #DONE
+    '''
+    Separates argparser into function. Returns arparse.ArgumentParser()
+    '''
+    desc = ('Produces a text, csv or JSON output with checksums for files, '
+            'testing for Windows CRLF combinations, '
+            'as well as checking text files for regularity and non/ASCII characters')
+    parser = argparse.ArgumentParser(description=desc)
+    parser.add_argument('files', help='Files to check. Wildcards acceptable (eg, *)',
+                        nargs='+', default=' ')
+    #note 'prog' is built into argparse
+    parser.add_argument('-v', '--version', action='version', version='%(prog)s '+damage.__version__,
+                        help='Show version number and exit')
+    parser.add_argument('-o', '--output', dest='out',
+                        help='Output format. One of txt, csv, json, tsv',
+                        default='txt',
+                        choices = ['txt', 'csv', 'tsv', 'json'],
+                        type=str.lower)
+    parser.add_argument('-n', '--no-flat', action='store_false', dest='flatfile',
+                        help="Don't check text files for rectangularity")
+    parser.add_argument('-r', '--recursive', action='store_true', dest='recur',
+                        help='Recursive *directory* processing of file tree. Assumes that the '
+                             'arguments point to a directory (eg, tmp/), and a slash will '
+                             'be appended if one does not exist')
+    parser.add_argument('-t', '--hash-type', dest='digest', default='md5',
+                        help="Checksum hash type. Supported hashes: 'sha1', "
+                             "'sha224', 'sha256', 'sha384', 'sha512', 'blake2b', "
+                             "'blake2s', 'md5'.  Default: 'md5'",
+                        choices = ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512',
+                                   'blake2b', 'blake2s'],
+                        type=str.lower)
+    parser.add_argument('-a', '--no-ascii', action='store_true', dest='asctest',
+                        help="Don't check text files for non-ASCII characters")
+    parser.add_argument('-f', '--to-file',
+                        help='Output to -f [file] instead of stdout')
+    return parser
+
+def recurse_files(inlist) -> map:
+    '''
+    Returns a map object with pathlib.Paths of files
+    '''
+    outlist = []
+    for flist in inlist:
+        rec = os.walk(flist)
+        outlist += [pathlib.Path(x[0], y) for x in rec for y in x[2]]
+    return outlist #includes hidden files
+
+def main(): #pylint: disable=too-many-branches
+    '''
+    Main function to output manifests to stdout.
+    '''
+    separator_types = {'csv': ',', 'tsv': '\t'}
+    #Purely for formatting output
+    line_spacer = {'txt':'\n\n', 'csv':'', 'tsv': ''}
+    parser = parse()
+    args = parser.parse_args()
+    if not args.recur:
+        #Windows does not do wildcard expansion at the shell level
+        if sys.platform.startswith('win'): #Maybe they will have win64 sometime:
+            files = map(pathlib.Path, [y for x in args.files for y in glob.glob(x)])
+        else:
+            files = map(pathlib.Path, list(args.files))
+    else:
+        files = recurse_files(args.files)
+
+
+    output = []
+    try: ###
+        for num, fil in enumerate(files):
+            if not fil.is_file() or not fil.exists():
+                continue
+            testme = damage.Checker(fil)
+            if args.out in separator_types and num == 0:
+                output.append(testme.manifest(headers=True,
+                                              sep=separator_types.get(args.out),
+                                              **vars(args)))
+            else:
+                output.append(testme.manifest(sep=separator_types.get(args.out),
+                                              **vars(args)))
+        if not args.out == 'json':
+            #print(line_spacer[args.out].join(output).strip())
+            out_info =line_spacer[args.out].join(output).strip()
+        else:
+            outjson = ('{"files" :' +
+                       '[' + ','.join(output) + ']'
+                       + '}')
+            out_info = json.dumps(json.loads(outjson)) #validate
+    except Exception as err: #pylint: disable=broad-exception-caught
+        print(f'Abnormal program termination {err}')
+        sys.exit()
+
+    if args.to_file:
+        with open(pathlib.Path(args.to_file), mode='w',
+                  encoding='utf-8') as outf:
+            outf.write(out_info)
+    else:
+        print(out_info)
+
+if __name__ == '__main__':
+    main()