Switch from print to logging

gitstats/datacollector.py

 import datetime
+import logging
 import os
 import pickle
 import time
     def loadCache(self, cachefile):
         if not os.path.exists(cachefile):
             return
-        print('Loading cache...')
+        logging.info('Loading cache...')
         f = open(cachefile, 'rb')
         try:
             self.cache = pickle.loads(zlib.decompress(f.read()))
     ##
     # Save cacheable data
     def saveCache(self, cachefile):
-        print('Saving cache...')
+        logging.info('Saving cache...')
         tempfile = cachefile + '.tmp'
         f = open(tempfile, 'wb')
         # pickle.dump(self.cache, f)

gitstats/gitdatacollector.py

 import datetime
+import logging
 import re
 import os
 
             try:
                 self.files_by_stamp[int(stamp)] = int(files)
             except ValueError:
-                print(f'Warning: failed to parse line "{line}"')
+                logging.warning(f'Failed to parse line "{line}"')
 
         # extensions and size of files
         lines = getpipeoutput(['git ls-tree -r -l -z %s' % getcommitrange(self.conf, 'HEAD', end_only=True)]).split('\000')
 
                         files, inserted, deleted = 0, 0, 0
                     except ValueError:
-                        print(f'Warning: unexpected line "{line}')
+                        logging.warning(f'unexpected line "{line}')
                 else:
-                    print(f'Warning: unexpected line "{line}')
+                    logging.warning(f'unexpected line "{line}')
             else:
                 numbers = getstatsummarycounts(line)
 
                     self.total_lines_removed += deleted
 
                 else:
-                    print(f'Warning: failed to handle line "{line}"')
+                    logging.warning(f'Failed to handle line "{line}"')
                     (files, inserted, deleted) = (0, 0, 0)
             # self.changes_by_date[stamp] = { 'files': files, 'ins': inserted, 'del': deleted }
         self.total_lines += total_lines
                         self.changes_by_date_by_author[stamp][author]['commits'] = self.authors[author]['commits']
                         files, inserted, deleted = 0, 0, 0
                     except ValueError:
-                        print(f'Warning: unexpected line "{line}')
+                        logging.warning(f'unexpected line "{line}')
                 else:
-                    print(f'Warning: unexpected line "{line}')
+                    logging.warning(f'unexpected line "{line}')
             else:
                 numbers = getstatsummarycounts(line)
 
                 if len(numbers) == 3:
                     (files, inserted, deleted) = map(lambda el: int(el), numbers)
                 else:
-                    print(f'Warning: failed to handle line "{line}"')
+                    logging.warning(f'Failed to handle line "{line}"')
                     (files, inserted, deleted) = (0, 0, 0)
 
     def refine(self):

gitstats/gitstats.py

 #!/usr/bin/python
 # Copyright (c) 2007-2014 Heikki Hokkanen <hoxu@users.sf.net> & others (see doc/AUTHOR)
 # GPLv2 / GPLv3
-import argparse
+import getopt
+import logging
 import os
 import sys
 import time
 
+import multiprocessing_logging
+
 from .gitdatacollector import GitDataCollector
 from .htmlreportcreator import HTMLReportCreator
 from .miscfuncs import getgnuplotversion
     'linear_linestats': 1,
     'project_name': '',
     'processes': 8,
-    'start_date': ''
+    'start_date': '',
+    'logging': logging.INFO
 }
 
 class GitStats:
     """)
 
     def run(self):
-        if len(sys.argv) < 2:
+        optlist, args = getopt.getopt(sys.argv[1:], 'hc:', ["help"])
+        for o, v in optlist:
+            if o == '-c':
+                key, value = v.split('=', 1)
+                if key not in conf:
+                    raise KeyError('no such key "%s" in config' % key)
+                if isinstance(conf[key], int):
+                    conf[key] = int(value)
+                else:
+                    conf[key] = value
+            elif o in ('-h', '--help'):
+                self._usage()
+                sys.exit()
+
+        if len(args) < 2:
             self._usage()
             sys.exit(0)
 
-        parser = argparse.ArgumentParser(description='GitStats')
-#        parser.add_argument('-c', '--config', dest='config')
-
-        (args, remaining_args) = parser.parse_known_args()
-#        if args.config:
-#            self.conf.load(args.config)
+        outputpath = os.path.abspath(args[-1])
+        paths = args[0:-1]
+        outputpath = os.path.abspath(outputpath)
 
+        logging.basicConfig(level=conf['logging'], format='%(message)s')
+        multiprocessing_logging.install_mp_handler()
         time_start = time.time()
 
-        outputpath = remaining_args[-1]
-        paths = remaining_args[0:-1]
-        outputpath = os.path.abspath(outputpath)
 
         rundir = os.getcwd()
 
         except OSError:
             pass
         if not os.path.isdir(outputpath):
-            print('FATAL: Output path is not a directory or does not exist')
+            logging.fatal('Output path is not a directory or does not exist')
             sys.exit(1)
 
         if not getgnuplotversion():
-            print('gnuplot not found')
+            logging.error('gnuplot not found')
             sys.exit(1)
 
-        print(f'Output path: {outputpath}')
+        logging.info(f'Output path: {outputpath}')
         cachefile = os.path.join(outputpath, 'gitstats.cache')
 
         data = GitDataCollector(conf)
         data.loadCache(cachefile)
 
         for gitpath in paths:
-            print(f'Git path: {gitpath}')
+            logging.info(f'Git path: {gitpath}')
 
             prevdir = os.getcwd()
             os.chdir(gitpath)
 
-            print('Collecting data...')
+            logging.info('Collecting data...')
             data.collect(gitpath)
 
             os.chdir(prevdir)
 
-        print('Refining data...')
+            logging.info('Refining data...')
         data.saveCache(cachefile)
         data.refine()
 
         os.chdir(rundir)
 
-        print('Generating report...')
+        logging.info('Generating report...')
         report = HTMLReportCreator(conf)
         report.create(data, outputpath)
 
         time_end = time.time()
         calculated_exectime_internal = time_end - time_start
-        print(
-            f'Execution time {calculated_exectime_internal} secs, {exectime_external} secs ({(100.0 * exectime_external) / calculated_exectime_internal}%) in external commands)')
-        if sys.stdin.isatty():
-            print('You may now run:')
-            print()
-            print('   sensible-browser \'%s\'' % os.path.join(outputpath, 'index.html').replace("'", "'\\''"))
-            print()
+        logging.info(f'Execution time {calculated_exectime_internal} secs, {exectime_external} secs ({(100.0 * exectime_external) / calculated_exectime_internal}%) in external commands)')
+
+        print('You may now run:')
+        print()
+        print('   sensible-browser \'%s\'' % os.path.join(outputpath, 'index.html').replace("'", "'\\''"))
+        print()
 
 
 if __name__ == '__main__':

gitstats/htmlreportcreator.py

 import datetime
 import glob
+import logging
 import pkg_resources
 import os
 import shutil
             if os.path.exists(resource_file):
                 shutil.copyfile(resource_file, os.path.join(path, resource))
             else:
-                print(f'Warning: "{resource}" not found, so not copied')
+                logging.warning(f'"{resource}" not found, so not copied')
 
         f = open(path + "/index.html", 'w')
         format = '%Y-%m-%d %H:%M:%S'
         self.createGraphs(path)
 
     def createGraphs(self, path):
-        print('Generating graphs...')
+        logging.info('Generating graphs...')
 
         # hour of day
         f = open(path + '/hour_of_day.plot', 'w')

gitstats/miscfuncs.py

+import logging
 import os
-import platform
 import re
 import subprocess
-import sys
 import time
 
 os.environ['LC_ALL'] = 'C'
 
-ON_LINUX = (platform.system() == 'Linux')
-
 # By default, gnuplot is searched from path, but can be overridden with the
 # environment variable "GNUPLOT"
 gnuplot_cmd = 'gnuplot'
     gnuplot_cmd = os.environ['GNUPLOT']
 
 
-def getpipeoutput(cmds, quiet=False):
+def getpipeoutput(cmds):
     start = time.time()
-    if not quiet and ON_LINUX and os.isatty(1):
-        print('>> ' + ' | '.join(cmds), sys.stdout.flush())
     p = subprocess.Popen(cmds[0], stdout=subprocess.PIPE, shell=True)
     processes = [p]
     for x in cmds[1:]:
     for p in processes:
         p.wait()
     end = time.time()
-    if not quiet:
-        if ON_LINUX and os.isatty(1):
-            print(f'\r[{end - start}] >> {" | ".join(cmds)}')
+    logging.info(f'\r[{end - start:.4f}] >> {" | ".join(cmds)}')
     return output.rstrip('\n')
 
 

setup.py

         'setuptools>=18.0'
     ],
     install_requires=[
+        'multiprocessing_logging'
     ],
 
     extras_require={