Merge branch 'logger'

StuntsPT · StuntsPT · commit 9ad929011605 · 2017-03-14T17:32:40.000Z
diff --git a/setup.py b/setup.py
@@ -55,7 +55,7 @@ def platform_detection(install_binaries=True):
 
 # Set some variables (PKGBUILD inspired)
 DATA_FILES = platform_detection()
-VERSION = "0.3.2"
+VERSION = "0.4.0"
 URL = "https://github.com/StuntsPT/Structure_threader"
 
 
@@ -65,7 +65,8 @@ def platform_detection(install_binaries=True):
     packages=["structure_threader",
               "structure_threader.evanno",
               "structure_threader.plotter",
-              "structure_threader.sanity_checks"],
+              "structure_threader.sanity_checks",
+              "structure_threader.colorer"],
     install_requires=["plotly",
                       "colorlover",
                       "numpy",
diff --git a/structure_threader/colorer/__init__.py b/structure_threader/colorer/__init__.py
diff --git a/structure_threader/colorer/colorer.py b/structure_threader/colorer/colorer.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+# Code taken from http://stackoverflow.com/a/1336640/3091595.
+# Thanks to @sorin for providing this coloring method!
+
+import logging
+# now we patch Python code to add color support to logging.StreamHandler
+def add_coloring_to_emit_windows(fn):
+        # add methods we need to the class
+    def _out_handle(self):
+        import ctypes
+        return ctypes.windll.kernel32.GetStdHandle(self.STD_OUTPUT_HANDLE)
+    out_handle = property(_out_handle)
+
+    def _set_color(self, code):
+        import ctypes
+        # Constants from the Windows API
+        self.STD_OUTPUT_HANDLE = -11
+        hdl = ctypes.windll.kernel32.GetStdHandle(self.STD_OUTPUT_HANDLE)
+        ctypes.windll.kernel32.SetConsoleTextAttribute(hdl, code)
+
+    setattr(logging.StreamHandler, '_set_color', _set_color)
+
+    def new(*args):
+        FOREGROUND_BLUE      = 0x0001 # text color contains blue.
+        FOREGROUND_GREEN     = 0x0002 # text color contains green.
+        FOREGROUND_RED       = 0x0004 # text color contains red.
+        FOREGROUND_INTENSITY = 0x0008 # text color is intensified.
+        FOREGROUND_WHITE     = FOREGROUND_BLUE|FOREGROUND_GREEN |FOREGROUND_RED
+       # winbase.h
+        STD_INPUT_HANDLE = -10
+        STD_OUTPUT_HANDLE = -11
+        STD_ERROR_HANDLE = -12
+
+        # wincon.h
+        FOREGROUND_BLACK     = 0x0000
+        FOREGROUND_BLUE      = 0x0001
+        FOREGROUND_GREEN     = 0x0002
+        FOREGROUND_CYAN      = 0x0003
+        FOREGROUND_RED       = 0x0004
+        FOREGROUND_MAGENTA   = 0x0005
+        FOREGROUND_YELLOW    = 0x0006
+        FOREGROUND_GREY      = 0x0007
+        FOREGROUND_INTENSITY = 0x0008 # foreground color is intensified.
+
+        BACKGROUND_BLACK     = 0x0000
+        BACKGROUND_BLUE      = 0x0010
+        BACKGROUND_GREEN     = 0x0020
+        BACKGROUND_CYAN      = 0x0030
+        BACKGROUND_RED       = 0x0040
+        BACKGROUND_MAGENTA   = 0x0050
+        BACKGROUND_YELLOW    = 0x0060
+        BACKGROUND_GREY      = 0x0070
+        BACKGROUND_INTENSITY = 0x0080 # background color is intensified.
+
+        levelno = args[1].levelno
+        if(levelno>=50):
+            color = BACKGROUND_YELLOW | FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_INTENSITY
+        elif(levelno>=40):
+            color = FOREGROUND_RED | FOREGROUND_INTENSITY
+        elif(levelno>=30):
+            color = FOREGROUND_YELLOW | FOREGROUND_INTENSITY
+        elif(levelno>=20):
+            color = FOREGROUND_GREEN
+        elif(levelno>=10):
+            color = FOREGROUND_MAGENTA
+        else:
+            color =  FOREGROUND_WHITE
+        args[0]._set_color(color)
+
+        ret = fn(*args)
+        args[0]._set_color( FOREGROUND_WHITE )
+        #print "after"
+        return ret
+    return new
+
+def add_coloring_to_emit_ansi(fn):
+    # add methods we need to the class
+    def new(*args):
+        levelno = args[1].levelno
+        if(levelno>=50):
+            color = '\x1b[31m' # red
+        elif(levelno>=40):
+            color = '\x1b[31m' # red
+        elif(levelno>=30):
+            color = '\x1b[33m' # yellow
+        elif(levelno>=20):
+            color = '\x1b[32m' # green
+        elif(levelno>=10):
+            color = '\x1b[35m' # pink
+        else:
+            color = '\x1b[0m' # normal
+        args[1].msg = color + args[1].msg +  '\x1b[0m'  # normal
+        #print "after"
+        return fn(*args)
+    return new
+
+import platform
+if platform.system()=='Windows':
+    # Windows does not support ANSI escapes and we are using API calls to set the console color
+    logging.StreamHandler.emit = add_coloring_to_emit_windows(logging.StreamHandler.emit)
+else:
+    # all non-Windows platforms are supporting ANSI escapes so we use them
+    logging.StreamHandler.emit = add_coloring_to_emit_ansi(logging.StreamHandler.emit)
+    #log = logging.getLogger()
+    #log.addFilter(log_filter())
+    #//hdlr = logging.StreamHandler()
+    #//hdlr.setFormatter(formatter())
diff --git a/structure_threader/sanity_checks/sanity.py b/structure_threader/sanity_checks/sanity.py
@@ -16,11 +16,15 @@
 # along with structure_threader. If not, see <http://www.gnu.org/licenses/>.
 
 import os
-import numpy as np
 import logging
 
 from collections import Counter
 
+import numpy as np
+
+# Set default log level and format
+logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
+
 
 class AuxSanity(object):
 
@@ -43,8 +47,8 @@ def ind_mismatch(self, exp_array, kvals):
             if exp_array.shape[0] != kobj.qvals.shape[0]:
                 mismatch.append("{}: {} individuas (expected from "
                                 "popfile: {})".format(kobj.file_path,
-                                    kobj.qvals.shape[0],
-                                    exp_array.shape[0]))
+                                                      kobj.qvals.shape[0],
+                                                      exp_array.shape[0]))
 
         return mismatch
 
diff --git a/structure_threader/structure_threader.py b/structure_threader/structure_threader.py
@@ -22,6 +22,7 @@
 import subprocess
 import itertools
 import argparse
+import logging
 
 from multiprocessing import Pool
 from random import randrange
@@ -30,24 +31,32 @@
 try:
     import plotter.structplot as sp
     import sanity_checks.sanity as sanity
+    import colorer.colorer as colorer
 except ImportError:
     import structure_threader.plotter.structplot as sp
     import structure_threader.sanity_checks.sanity as sanity
+    import structure_threader.colorer.colorer as colorer
 
 # Where are we?
 CWD = os.getcwd()
 
+# Set default log level and format
+logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
+
 
 def gracious_exit(*args):
-    """Graciously exit the program."""
-    print("\rExiting graciously, murdering child processes and cleaning output"
-          " directory.", end="")
+    """
+    Graciously exit the program.
+    """
+    logging.critical("\rExiting graciously, murdering child processes and "
+                     "cleaning output directory.")
     os.chdir(CWD)
     sys.exit(0)
 
 
 def runprogram(wrapped_prog, iterations, arg):
-    """Run each wrapped program job. Return the worker status.
+    """
+    Run each wrapped program job. Return the worker status.
     This attribute will be populated with the worker exit code and output file
     and returned. The first element is the exit code itself (0 if normal exit
     and -1 in case of errors). The second element contains the output file
@@ -108,7 +117,7 @@ def runprogram(wrapped_prog, iterations, arg):
         if arg.external_prog.endswith(".py") is False:
             cli = cli[1:]
 
-    print("Running: " + " ".join(cli))
+    logging.info("Running: " + " ".join(cli))
     program = subprocess.Popen(cli,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE)
@@ -130,8 +139,8 @@ def runprogram(wrapped_prog, iterations, arg):
 
         logfile = open(os.path.join(arg.outpath, "K" + str(K) + "_rep" +
                                     str(rep_num) + ".stlog"), "w")
-        print("Writing logfile for K" + str(K) + ", replicate " +
-              str(rep_num) + ". Please wait...")
+        logging.info("Writing logfile for K" + str(K) + ", replicate " +
+                     str(rep_num) + ". Please wait...")
         logfile.write(out)
         logfile.write(err)
         logfile.close()
@@ -140,7 +149,9 @@ def runprogram(wrapped_prog, iterations, arg):
 
 
 def structure_threader(Ks, replicates, threads, wrapped_prog, arg):
-    """Do the threading book-keeping to spawn jobs at the asked rate."""
+    """
+    Do the threading book-keeping to spawn jobs at the asked rate.
+    """
 
     if wrapped_prog != "structure":
         replicates = [1]
@@ -164,21 +175,24 @@ def structure_threader(Ks, replicates, threads, wrapped_prog, arg):
     # populated with the cli commands that generated the errors
     error_list = [x[1] for x in pool if x[0] == -1]
 
-    print("\n==============================\n")
+    logging.info("\n==============================\n")
     if error_list:
-        print("%s %s runs exited with errors. Check the log files of "
-              "the following output files:" % (len(error_list), wrapped_prog))
+        logging.critical("%s %s runs exited with errors. Check the log files of"
+                         " the following output files:",
+                         len(error_list), wrapped_prog)
         for out in error_list:
-            print(out)
+            logging.error(out)
     else:
-        print("All %s jobs finished successfully." % len(pool))
+        logging.info("All %s jobs finished successfully.", len(pool))
 
     os.chdir(CWD)
 
 
 def structure_harvester(resultsdir, wrapped_prog):
-    """Run structureHarvester or fastChooseK to perform the Evanno test or the
-    likelihood testing on the results."""
+    """
+    Run structureHarvester or fastChooseK to perform the Evanno test or the
+    likelihood testing on the results.
+    """
     outdir = os.path.join(resultsdir, "bestK")
     if not os.path.exists(outdir):
         os.mkdir(outdir)
@@ -201,8 +215,10 @@ def structure_harvester(resultsdir, wrapped_prog):
 
 
 def create_plts(resultsdir, wrapped_prog, Ks, bestk, arg):
-    """Create plots from result dir.
-    :param resultsdir: path to results directory"""
+    """
+    Create plots from result dir.
+    :param resultsdir: path to results directory
+    """
 
     plt_list = [x for x in Ks if x != 1]  # Don't plot K=1
 
@@ -468,9 +484,12 @@ def argument_parser(args):
 
     return arguments
 
+
 def main():
-    """Main function, where variables are set and other functions get called
-    from."""
+    """
+    Main function, where variables are set and other functions get called
+    from.
+    """
 
     arg = argument_parser(sys.argv[1:])
 
@@ -567,5 +586,6 @@ def main():
         sp.main(infiles, arg.format, arg.outpath, bestk, popfile=arg.popfile,
                 indfile=arg.indfile, filter_k=bestk)
 
+
 if __name__ == "__main__":
     main()
