damage 0.3.14__py3-none-any.whl

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/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()

damage/gui/assets/LICENCE.txt

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright 2025 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/gui/damage_gui.py

@@ -0,0 +1,678 @@
+'''
+Damage GUI application
+'''
+#import base64
+import base64
+import json
+import os
+import pathlib
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+import webbrowser
+import FreeSimpleGUI as sg
+
+import damage
+#pylint: disable = possibly-used-before-assignment
+
+#TODO put the application into a class or function
+#Prettify the name
+PROGNAME = pathlib.Path(__file__).stem.capitalize().replace('_gui','')
+__version__ = '.'.join([str(x) for x in damage.VERSION])
+
+BASEDIR = pathlib.Path(__file__).parent
+
+with open(pathlib.Path(BASEDIR, 'assets', 'DamageAppIcon.png'),
+          'rb') as f:
+    ICON = base64.b64encode(f.read())
+
+with open(pathlib.Path(BASEDIR, 'assets', 'LICENCE.txt'),
+          mode='r', encoding='utf-8') as lic:
+    LICENCE = textwrap.fill(lic.read(), width=70,
+                            replace_whitespace=False)
+
+sg.DEFAULT_WINDOW_ICON = ICON
+
+if sg.running_mac():
+    import plistlib
+    TTK_THEME = 'aqua'
+    # make FONTSIZE dependent on homebrew in path because only brew python
+    # compiles successfully on MacOS on a case-insensitive file system
+    # and for some inconceivable reason the font size changes
+    FONTSIZE = 14
+    for hack in ['homebrew', 'MacOS']:
+        if hack in {y for x in sys.path for y in pathlib.Path(x).parts}:
+            FONTSIZE = 10
+    BASEFONT = 'System'
+    MOD = '\u2318' #CMD key unicode 2318 Place of Interest
+    CMDCTRL = 'Command' #tkinter bind string sans <>
+
+if sg.running_windows():
+    TTK_THEME =  'vista'
+    FONTSIZE = 9
+    BASEFONT = 'Arial' #GRR #TODO no longer basefont on Windows
+    MOD = 'Ctrl-'
+    CMDCTRL = 'Control'
+
+if sg.running_linux():
+    TTK_THEME =  'alt'
+    FONTSIZE = 9
+    BASEFONT = 'TkDefaultFont' #GRR
+    MOD = 'Ctrl-'
+    CMDCTRL = 'Control'
+sg.set_options(font=f'{BASEFONT} {FONTSIZE}')
+
+sg.theme('systemDefaultForReal')
+
+# I dislike having this as a global variable
+# TODO find a better way to store PREFDICT
+PREFDICT = None
+
+def debug_mode():
+    '''
+    Turn on debugger from the command line
+    '''
+    yes_to_debug = ['debug', 'd', '1']
+    if len(sys.argv) > 1:
+        debug = sys.argv[1]
+        if debug.lower() in yes_to_debug:
+            sg.show_debugger_window(location=(10,10))
+
+def is_csv(indict:dict)->bool:
+    '''
+    Convenience function to see if output is csv
+
+    '''
+    #I really need to redo the whole works from scratch
+    if indict.get('out') == 'csv':
+        return True
+    return False
+
+def pref_path()->pathlib.Path:
+    '''
+    Returns path to preferences directory and preferences
+    file name as a tuple
+    '''
+    if sg.running_mac():
+        return pathlib.Path(pathlib.Path('~/Library/Preferences').expanduser(),
+                'ca.ubc.library.damage.prefs.plist')
+    if sg.running_windows():
+        return pathlib.Path(pathlib.Path('~/AppData/Local/damage').expanduser(), 'damage.json')
+    #Linux and everything else
+    return pathlib.Path(pathlib.Path('~/.config/damage').expanduser(),
+                'damage.json')
+
+def get_prefs()->None:
+    '''
+    Gets preferences from JSON or default dict. If no preferences
+    file is found, one is written
+    '''
+    global PREFDICT
+    try:
+        if sg.running_mac():
+            with open(pref_path(), 'rb') as fn:
+                PREFDICT = plistlib.load(fn)
+        if sg.running_linux() or sg.running_windows():
+            with open(pref_path(), encoding='utf-8') as fn:
+                PREFDICT = sg.json.load(fn)
+
+
+    except FileNotFoundError:
+        PREFDICT = { 'flatfile' :False,
+                      'recurse' :False,
+                      'digest' :'md5',
+                      'out' :'txt',
+                      'short' :True,
+                      'headers' :True,
+                      'nonascii' :True,
+                      'hidden' : False}
+
+    fixflat = PREFDICT.get('flat')
+    if fixflat:
+        PREFDICT['flatfile'] = fixflat
+        del PREFDICT['flat']
+    # Add new keys here when expanding prefs
+    PREFDICT['hidden'] = PREFDICT.get('hidden', False)
+
+def set_prefs()->None:
+    '''
+    Sets preferences
+    '''
+    if not pref_path().parent.exists():
+        os.makedirs(pref_path().parent)
+    if sg.running_mac():
+        with open(pref_path(), 'wb') as fn:
+            plistlib.dump(PREFDICT, fn)
+    if sg.running_linux() or sg.running_windows():
+        with open(pref_path(), 'w', encoding='utf-8') as fn:
+            sg.json.dump(PREFDICT, fn)
+
+def damager(flist, **kwargs)->str:
+    '''
+    Text output from Damage utility
+    '''
+    output = []
+    for num, fil in enumerate(flist):
+        if not pathlib.Path(fil).is_file() or not pathlib.Path(fil).exists():
+            continue
+        testme = damage.Checker(fil)
+        if kwargs['out'] == 'csv' and num == 0:
+            kwargs['headers'] = True
+            output.append(testme.manifest(**kwargs))
+        else:
+            kwargs['headers'] = False
+            output.append(testme.manifest(**kwargs))
+    if kwargs['out'] =='txt':
+        return '\n\n'.join(output)
+    if kwargs['out'] == 'csv':
+        return ''.join(output)#Horrible hack; excel dialiect automatically adds \r\n
+    outjson = ('{"files" :' +
+               '[' + ','.join(output) + ']'
+               + '}')
+    outjson = json.dumps(json.loads(outjson)) #validate
+    return outjson
+
+def get_folder_files(direc:str, recursive:bool=False, hidden:bool=False)->list:
+    '''
+    Returns files in a folder, recursive or no
+    direc : str
+        path to directory
+    recursive : bool
+        Return a recursive result. Default False
+    hidden : bool
+        Show hidden files. Default False
+    '''
+    #HACKME
+    if not hidden:
+        hidden = PREFDICT.get('hidden', False)
+    if not direc:#Possible if window call cancelled, as I have discovered
+        #return None
+        return []
+    walker = pathlib.Path(direc).walk()
+    if not recursive:
+        walker = [next(walker)]
+    else:
+        walker = list(walker)
+    flist=[]
+    #Hidden is a property in the Checker object, but this comes before instantiation
+    if hidden:
+        #flist = [[x[0], pathlib.Path(x[0], y).name] for x in walker for y in x[2]
+        #         if pathlib.Path(x[0],y).is_file()]
+        flist = [pathlib.Path(x[0], y) for x in walker for y in x[2]
+                 if pathlib.Path(x[0],y).is_file()]
+
+    else:
+        #hidden defined as any part of the path starts with '.'
+        flist = [pathlib.Path(x[0],y) for x in walker for y in x[2]
+                if not any(z.startswith('.') for z in
+                            pathlib.Path(x[0], y).parts)]
+    return flist
+
+def send_to_file(outstring)->None:
+    '''
+    Sends string output to file
+
+    Creates a tk.asksaveasfile dialogue and saves
+    '''
+    #Because TK is just easier
+    outfile = sg.tk.filedialog.asksaveasfile(title='Save Output',
+                                       initialfile=f'output.{PREFDICT["out"]}',
+                                       confirmoverwrite=True)
+    if outfile:
+        outfile.write(outstring)
+        outfile.close()
+
+def send_to_printer(outstring:str)->None:
+    '''
+    Sends output to lpr on Mac/linux and to default printer in Windows
+    Data is unformatted. If you want formatting save to a file and use
+    a text editor. Assumes UTF-8 for Mac/linux.
+    '''
+    #https://stackoverflow.com/questions/12723818/print-to-standard-printer-from-python
+    #outfile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8',
+    #                                      suffix='.txt', delete=False)
+    #outfile.write(outstring)
+    #outfile.close()
+    with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8',
+                                     suffix='.txt', delete=False) as outfile:
+        outfile.write(outstring)
+
+    if sg.running_mac() or sg.running_linux():
+        #lpr =  subprocess.Popen(shutil.which('lpr'), stdin=subprocess.PIPE)
+        #lpr.stdin.write(bytes(outstring, 'utf-8'))
+        subprocess.run([shutil.which('lpr'), outfile.name], check=False)
+
+    if sg.running_windows():
+
+        #List of all printers names and shows default one
+        #wmic printer get name,default
+        #https://stackoverflow.com/questions/13311201/get-default-printer-name-from-command-line
+        subout = subprocess.run(shlex.split('wmic printer get name,default'),
+                                capture_output=True,
+                                check=False)
+        #the following only makes sense of you look at the output of the
+        #windows shell command above. stout is binary, hence decode.
+        printerinfo = [[x[:6].strip(), x[6:].strip()] for x in
+                        subout.stdout.decode().split('\n')[1:]]
+        default_printer = [x for x in printerinfo if x[0] == 'TRUE'][0][1]
+        subprocess.run(['print', f'/D:{default_printer}', outfile.name], check=False)
+        #tempfile must be removed manually because of delete=False above
+    os.remove(outfile.name)
+    sg.popup('Output sent to default printer', title='Job Completed', any_key_closes=True)
+
+def about_window()->sg.Window:
+    '''
+    Creates the "About" window
+    '''
+    about = { 'developers' : ['Paul Lesack'],
+             'user_testers' : ['Alex Alisauskas','Jeremy Buhler', 'Cheryl Niamath'],
+             'source_url' : 'https://github.com/ubc-library-rc/damage',
+             'documentation' : 'https://ubc-library-rc.github.io/damage'
+             }
+    #displayname = f'{PROGNAME[:PROGNAME.find("_")].capitalize()} v{__version__}'
+    displayname = f'{PROGNAME} v{__version__}'
+    name = [[sg.Text(displayname, font=f'{BASEFONT} {FONTSIZE+4} bold')]]
+    source =[[sg.Text('Source code', font=f'{BASEFONT} {FONTSIZE+2} bold')],
+              [sg.Text(about['source_url'], enable_events=True, text_color='blue', k='-SC-')]]
+    documentation =[[sg.Text('Documentation', font=f'{BASEFONT} {FONTSIZE+2} bold')],
+                     [sg.Text(about['source_url'], enable_events=True,
+                              text_color='blue', k='-DOC-')]]
+    devs =[[sg.Text('Developers', font=f'{BASEFONT} {FONTSIZE+2} bold',)],
+            [sg.Text(x) for x in about['developers']]]
+    testers = [[sg.Text('Testers', font=f'{BASEFONT} {FONTSIZE+2} bold')],
+               [sg.Text(x) for x in about['user_testers']]]
+    licence =[[sg.Text('Licence information', font=f'{BASEFONT} {FONTSIZE+2} bold')],
+              [sg.Text(LICENCE, font=f'{BASEFONT} {FONTSIZE-2}')]]
+    layout = name + documentation + devs + testers + source + licence
+    window = sg.Window('Credits & Details', modal=True,
+                       icon=ICON,
+                       keep_on_top=True,
+                       layout=layout,
+                       finalize=True)
+    while True:
+        #event, values = window.read()
+        # don't need values
+        event = window.read()[0]
+        if event == '-SC-':
+            webbrowser.open(about['source_url'])
+        if event == '-DOC-':
+            webbrowser.open(about['documentation'])
+        if event == sg.WIN_CLOSED:
+            break
+    window.close()
+
+def prefs_window()->sg.Window:
+    '''
+    Creates a preferences popup window.
+    Values from window  saved to the preferences dictionary PREFDICT
+    '''
+    #All the options
+    hashes =['md5','sha1', 'sha224', 'sha256', 'sha384', 'sha512',
+             'blake2b', 'blake2s']
+    outputs = ['txt','csv', 'json']
+    rectang = ('Text file rectangularity '
+                '& statistics file column check' )
+    layout = [[sg.Text('Damage Preferences', font=f'{BASEFONT} {FONTSIZE+4} bold')],
+             [sg.Checkbox('Shorten file paths in output',
+                           key= '-SHORT-',
+                           default=PREFDICT['short'], )],
+             [sg.Checkbox(text=rectang,
+                           key= '-FLATFILE-',
+                           default=PREFDICT['flatfile'], )],
+             [sg.Checkbox('Recursively add files from directories',
+                           key='-RECURSE-', default=PREFDICT['recurse'])],
+             [sg.Checkbox('Include hidden files',
+                           key='-HIDDEN-', default=PREFDICT['hidden'])],
+             [sg.Text('Hash type'),
+              sg.Combo(values=hashes, default_value=PREFDICT['digest'],
+                       key='-DIGEST-', readonly=True)],
+             [sg.Text('Output format'),
+              sg.Combo(values=outputs, default_value=PREFDICT['out'],
+                       key='-OUT-', readonly=True)],
+             [sg.Ok(bind_return_key=True, button_text='OK')]]
+    pwindow = sg.Window(title='Preferences',
+                    icon=ICON,
+                     resizable=True,
+                     layout=layout,
+                     ttk_theme=TTK_THEME,
+                     use_ttk_buttons=True,
+                     keep_on_top=True,
+                     modal=True, finalize=True)
+    pwindow.bind('<Escape>', 'Exit')
+    pevent, pvalues = pwindow.read()
+    if pevent:
+        for key in ['short', 'flatfile', 'recurse', 'digest', 'out', 'hidden']:
+            PREFDICT[key] = pvalues[f'-{key.upper()}-']
+    set_prefs()
+    if pevent == 'Exit':
+        pwindow.close()
+    pwindow.close()
+
+def window_binds(window:sg.Window)->None:
+    '''
+    Bind keys to main window
+    '''
+    window.bind(f'<{CMDCTRL}-v>', '-PASTE-')
+    window.bind(f'<{CMDCTRL}-s>', '-SAVE-')
+    window.bind(f'<{CMDCTRL}-p>', '-PRINT-')
+    window.bind(f'<{CMDCTRL}-m>', '-MANIFEST-')
+
+def main_window()->sg.Window:
+    '''
+    The main damage window
+    '''
+    #def get_folder_items()->list:
+    #    '''
+    #    Get all items from a folder listing
+    #    '''
+    #I gave up attaching preferences to the mac menu
+    #because there's too much hidden using sg.
+    #You may as well use straight tk if you want that.
+
+    #Menu section
+    debug_mode()
+    menu = sg.Menu([['File',['Add &Files',
+                             'Add Fol&der',
+                             'Remove Files::-DELETE-']],
+                     ['Edit', [f'&Copy     {MOD}C::-COPY-',
+                                 f'&Paste    {MOD}V::-PASTE-',
+                              'Preferences']],
+                     ['Actions', [f'Create &Manifest               {MOD}M::-MANIFEST-',
+                                  '---',
+                                  f'!&Save Output to File          {MOD}S::-SAVE-',
+                                  f'!&Print Output                      {MOD}P::-PRINT-']],
+                     ['Help', ['Damage Help', 'Credits and Details']]],
+                    key='-MENUBAR-')
+    #Chosen file (left) section
+    lbox = sg.Listbox(values=[], key='-SELECT-',
+                          enable_events=True,
+                          size=20,
+                          select_mode=sg.LISTBOX_SELECT_MODE_EXTENDED,
+                          horizontal_scroll=True,
+                          expand_y=True,
+                          expand_x=True)
+    left = [[lbox],
+            [sg.Input(visible=False, enable_events=True, key='-IN-'),
+             sg.FilesBrowse(button_text='Add Files', target='-IN-'),
+             sg.Input(visible=False, enable_events=True, key='-IFOLD-'),
+             sg.FolderBrowse(button_text='Add Folder', key='-FOLDER-',
+                             target='-IFOLD-',
+                             initial_folder=pathlib.Path('~').expanduser()),
+             sg.Button(button_text='Remove Files',
+                       enable_events=True, key='-DELETE-')]]
+
+    #Right side (output) section
+    #This is more complicated than it should be because psg doesn't
+    #flip correctly between Multiline and Table elements and doesn't hide
+    #the Table scrollbars, and resizing is also affected. The (a) solution
+    #is to put each of them in a Frame.
+    #But the best solution would be to use straight tkinter but it's too
+    #late for that, isn't it.
+
+    outbox = sg.Multiline(key='-OUTPUT-',
+                           size=10000, #Auto-expansion has a bug
+                           expand_x=True,
+                           expand_y=True,
+                           visible=True,
+                           auto_refresh=True)
+    frame_1=sg.Frame(title ='',
+                     layout=[[outbox]],
+                     expand_x=True,
+                     expand_y=True,
+                     border_width=0,
+                     key='F1',
+                     visible=not is_csv(PREFDICT))
+
+    #CSV/tabular output box
+    #hardcoding the headers seems dumb,
+    #but the headers have to be read *after* instantiation of a Checker object
+    #TODONE used these ones for now, not really happy about it
+    headers = ['filename', 'digestType', 'digest',
+                'min_cols', 'max_cols', 'numrec',
+                'constant', 'encoding', 'nonascii',
+                'null_chars', 'mimetype', 'dos']
+
+    #right side layout
+    csvout = sg.Table([['' for x in range(len(headers))]], #Need data to create the table
+                headings=headers,
+                key='-CSV-',
+                #num_rows=40, #not needed with expansion
+                alternating_row_color='#FFA805',
+                #size=(800,40),
+                expand_x=True,
+                expand_y=True,
+                hide_vertical_scroll=False,
+                vertical_scroll_only=False,
+                auto_size_columns=True,
+                #def_col_width=200,#If this is at default window expansion doesn't work
+                #max_col_width=2000,#This ought to be enough
+                #visible=is_csv(PREFDICT),
+                visible=True,
+                enable_events=True
+                )
+    frame_2=sg.Frame(title ='',
+                     layout=[[csvout]],
+                     expand_x=True,
+                     expand_y=True,
+                     border_width=0,
+                     key='F2',
+                     visible=True)
+
+
+    right = [[frame_1, frame_2],
+             [sg.Text(expand_x=True),
+              sg.Button('Generate Manifest',
+                         key='-MANIFEST-') ]]
+
+    #Main window layout using all the elements above
+    layout = [[menu],
+                [sg.Frame(title='File Section',
+                         layout=left,
+                         size=(400,800),
+                         expand_y=True,
+                         expand_x=True),
+                  sg.Frame(title='Output Section',
+                           size=(800,800),
+                           layout=right,
+                           expand_y=True,
+                           expand_x=True)]]
+
+    window = sg.Window(title='Damage', layout=layout, resizable=True,
+                      size = PREFDICT.get('main_size', (None, None)),
+                      icon=ICON,
+                      ttk_theme=TTK_THEME,
+                      use_ttk_buttons=True,
+                      location= PREFDICT.get('main_location', (None, None)),
+                      finalize=True, enable_close_attempted_event=True)
+    lbox.Widget.config(borderwidth=0)
+    window.set_min_size((875,400))
+    window_binds(window)
+    return window
+
+def main()->None:
+    '''
+    Main loop
+    '''
+    get_prefs()
+    window  = main_window()
+    #FFFFUUUUU
+    menulayout = window['-MENUBAR-'].MenuDefinition
+    #sg.easy_print(menulayout)
+    #Why don't I just do it all in TK? Jesus
+    #talk about undocumented.
+    #also: https://tkdocs.com/tutorial/menus.html
+    #window.TKroot.tk.createcommand('tk::mac::ShowPreferences', prefs_window )
+    # How to get root? What is the function where None is?
+    #root = window.hidden_master_root #(see PySimpleGUI.py.StartupTK, line 16008)
+    #sg.easy_print(type(poot))
+    #root.createcommand('tk::mac::ShowPreferences', prefs_window )
+    #root.createcommand('tk::mac::ShowPreferences', lambda:  None)
+    #Also, why does the window stop responding after calling the prefs? But only half? It's
+    #a fucking mystery. And it doesn't happen with straight TK so it's something to with psg.
+    #root.createcommand('tk::mac::standardAboutPanel', about_window)
+    while True:
+        event, values = window.read()
+
+        if event in (sg.WINDOW_CLOSE_ATTEMPTED_EVENT,):
+            PREFDICT['main_size'] = window.size
+            PREFDICT['main_location'] = window.current_location()
+            set_prefs()
+            break
+
+        if event in (sg.WINDOW_CLOSED,):
+            break
+
+        if event == '-IN-':
+            #sg.easy_print(f"Values=| {values['-IN-']} |", c='white on red')
+            upd_list = (window['-SELECT-'].get_list_values() +
+                        [x for x in values['-IN-'].split(';') if
+                         x not in window['-SELECT-'].get_list_values()])
+            if PREFDICT.get('hidden', False):
+                upd_list = [x for x in upd_list if pathlib.Path(x).is_file()]
+            else:
+                upd_list = [x for x in upd_list if pathlib.Path(x).is_file()
+                            and not any(z.startswith('.')
+                            for z in pathlib.Path(x).parts)]
+            window['-SELECT-'].update(upd_list)
+            window['-IN-'].update(value='')
+
+        if event in ('-IFOLD-', 'Add Folder'):
+            if event in ('Add Folder',):
+                #Not implementing same behaviour in button
+                #requires rewriting menu
+                #TODO find a way to have the menu item
+                #and button have the behaviour below
+                #probably by having the button replaced by a function call.
+                initiald = pathlib.Path('~').expanduser()
+                newfiles = get_folder_files(sg.popup_get_folder('',
+                                                                no_window=True,
+                                                                initial_folder=initiald),
+                                             PREFDICT['recurse'])
+            else:
+                newfiles = get_folder_files(values['-IFOLD-'], PREFDICT['recurse'])
+            upd_list = window['-SELECT-'].get_list_values()
+            #sg.easy_print('Used Add Folder Button')
+            upd_list = upd_list+ [x for x in newfiles if x not in upd_list]
+            window['-SELECT-'].update(upd_list)
+
+        if event.endswith('-DELETE-'):
+            nlist = [x for x in window['-SELECT-'].get_list_values() if
+                    x not in values['-SELECT-']]
+            window['-SELECT-'].update(nlist)
+
+        if event.endswith('-MANIFEST-'):
+            #sg.easy_print(event, values)
+            delme = ''
+            #Only clear manifest
+            window['-OUTPUT-'].update(delme)#clear first
+            window['-CSV-'].update(delme)#clear first
+            try:
+                upd_list = window['-SELECT-'].get_list_values()
+                if upd_list == ['']: #why
+                    upd_list = []
+                if upd_list:
+                    txt = damager(upd_list, **PREFDICT)
+                    if PREFDICT['short'] and len(upd_list) > 1:
+                        #commonpath does not include last sep, very annoying
+                        delme = os.path.commonpath(upd_list) + os.sep
+                        window['-OUTPUT-'].update(txt.replace(delme,''))
+                    elif PREFDICT['short'] and len(upd_list) == 1:
+                        #delme = os.path.split(upd_list[0])[0] + os.sep
+                        delme = pathlib.Path(upd_list[0]).parts[0] + os.sep #consistency
+                    txt = txt.replace(delme,'')
+                    window['-OUTPUT-'].update(txt)
+
+                if PREFDICT.get('out') == 'csv':
+                    txt = txt.split('\n')
+                    #reader=csv.reader(txt[1::2], delimiter=',')#Strip out the headers
+                    #window['-CSV-'].update(values=list(reader))
+                    #nout = [txt[0]] + txt[1::2]#combine header with data
+                    ##and send to output window for printing/saving
+                    #window['-OUTPUT-'].update('\n'.join(nout))
+
+                    #new
+                    #This is like it is because window['-CSV-'] takes lists
+                    #as values and window['-OUTPUT-] is text output
+                    #and csv.Reader adds windows \r\n.
+                    nout = [x.strip().split(',') for x in txt[1:]]
+                    nout = [x for x in nout if x !=['']]
+                    window['-CSV-'].update(nout)
+                    nout = [txt[0].strip()]+[','.join(z) for z in nout]
+                    nout = '\n'.join(nout)
+                    window['-OUTPUT-'].update(nout)
+
+
+
+            except (ValueError, NameError, AttributeError):
+                window['-OUTPUT-'].update(delme)
+
+        if event == 'Preferences':
+            #sg.easy_print(values)
+            prefs_window()
+            #Show correct window pane for output.
+            xpandr = is_csv(PREFDICT)
+            window['F1'].update(visible=not xpandr)
+            window['F2'].update(visible=xpandr)
+            window['F1'].expand(expand_x=not xpandr, expand_y=not xpandr)
+            window['F2'].expand(expand_x=xpandr, expand_y=xpandr)
+            window['-OUTPUT-'].update('')
+            #sg.easy_print(PREFDICT)
+            window.refresh()
+
+        if window['-OUTPUT-'].get():
+            #update menu. This is a PIA.
+            menulayout[2][1][2] = f'&Save Output to File          {MOD}S::-SAVE-'
+            menulayout[2][1][3] = f'&Print Output                      {MOD}P::-PRINT-'
+            window['-MENUBAR-'].update(menulayout)
+
+            if event.endswith('-SAVE-'):
+                send_to_file(values['-OUTPUT-'])
+
+            if event.endswith('-PRINT-'):
+                send_to_printer(values['-OUTPUT-'])
+        else:
+            menulayout[2][1][2] = f'!&Save Output to File          {MOD}S::-SAVE-'
+            menulayout[2][1][3] = f'!&Print Output                      {MOD}P::-PRINT-'
+            window['-MENUBAR-'].update(menulayout)
+
+        #Menubar events
+        if event == 'Add Files':
+            newfiles = sg.popup_get_file(message='', no_window=True,
+                                         multiple_files=True,
+                                         file_types = sg.FILE_TYPES_ALL_FILES)
+
+            upd_list = (window['-SELECT-'].get_list_values() +
+                   [x for x in newfiles if
+                    x not in window['-SELECT-'].get_list_values()])
+            window['-SELECT-'].update(upd_list)
+
+        if event == 'Credits and Details':
+            about_window()
+        if event == 'Damage Help':
+            webbrowser.open('https://ubc-library-rc.github.io/damage')
+
+        #Copypasta
+        if event.endswith(':-COPY-'):
+            #sg.clipboard_get()
+            #Oh look more straight Tkinter.
+            try:
+                sg.clipboard_set(window['-OUTPUT-'].Widget.selection_get())
+            except sg.tkinter.TclError:
+                pass
+            #sg.easy_print('COPY!!!', c='white on blue')
+            #sg.easy_print(sg.clipboard_get())
+        if event.endswith(':-PASTE-'):#Menu only because pastes by default
+            try:
+                #sg.easy_print('PASTE!!!', c='white on orange')
+                window['-OUTPUT-'].Widget.insert(sg.tk.INSERT,
+                                                    sg.clipboard_get())
+            except sg.tkinter.TclError:
+                pass
+
+    window.close()
+
+if __name__ == '__main__':
+    main()

damage-0.3.14.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+damage/__init__.py,sha256=HTjQQenVmw0ilI8WHQb1mISvx-NWtUvicKX4xezMSWw,14872
+damage/console/damage_cmd.py,sha256=5CPh_HpbDRSuUybxvGDLxAcW6Aec4HW5hJeMAsb5PU4,5079
+damage/gui/assets/DamageAppIcon.icns,sha256=_ObyYd-c8D7zlQosQnOVqv12zteMzIykzzZkmkZg3Mk,91447
+damage/gui/assets/DamageAppIcon.ico,sha256=tnf5VUkYXV27R34DhM0GqBXkbMoz2DwbCD9vM9vpzxM,622678
+damage/gui/assets/DamageAppIcon.jpg,sha256=kBEFy52EUWlLY3HDphQSFd2wIUHAEbT750E5HassNUk,76307
+damage/gui/assets/DamageAppIcon.png,sha256=E0HIRi8i7Isa3vCr7pT6fVXQ9qHgkzuOs_ZJ52HQTao,52486
+damage/gui/assets/LICENCE.txt,sha256=W3g7rf2LtjFk4Fhp740RSuB_cHgVR5p2Gq61JyufvmI,1092
+damage/gui/damage_gui.py,sha256=0X3dkfhSVpmFQZLhiNYP33jJ9WnUuebm3LkRR5-Mr-g,27198
+damage-0.3.14.dist-info/LICENCE.md,sha256=oVoR07zgulhKIi0J7RA518_QhHqqfdq9p9B8aYCMVd8,1091
+damage-0.3.14.dist-info/METADATA,sha256=T4YBN0J-dVFcEYyT3qoWZ_ZIyd7mNu93D5AOJkLa6yU,2045
+damage-0.3.14.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+damage-0.3.14.dist-info/entry_points.txt,sha256=K-F6BbGVbvPIRvbQCCE-TZWDymgmGgFUmaQG5UP1QuI,148
+damage-0.3.14.dist-info/RECORD,,

damage-0.3.14.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.1
+Root-Is-Purelib: true
+Tag: py3-none-any

damage-0.3.14.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+damage=damage.console.damage_cmd:main
+damage-gui=damage.gui.damage_gui:main
+
+[gui_scripts]
+damage-gui=damage.gui.damage_gui:main
+