Python3: PAL

- files renamed:
  - utils.py --> pal_utils.py
  - errors.py --> pal_errors.py
- functions/methods renamed:
  - plot_service_density_reconf_box_name --> plot_nf_reconf_box_name
  - plot_performance_box_name --> plot_perf_box_name
  - plot_latency_error_bars_name --> plot_lat_err_bars_name
  - plot_throughput_speedup_analysis_name --> plot_tsa_name
  - plot_service_density_heatmap --> plot_nf_heatmap
  - table_performance_comparison --> table_perf_comparison
  - table_performance_comparison_nic --> table_perf_comparison_nic
  - table_performance_trending_dashboard_html --> table_perf_trending_dash_html

- functions/methods removed:
  - plot_service_density_heatmap_compare
  - plot_throughput_speedup_analysis
  - plot_latency_error_bars
  - plot_soak_boxes
  - plot_soak_bars

Change-Id: Icddc01d3ccb451abb92b9e5d912b642d01866033
Signed-off-by: Tibor Frank <tifrank@cisco.com>

1 files changed, 73 insertions, 78 deletions

diff --git a/resources/tools/presentation/pal.py b/resources/tools/presentation/pal.py
index 94742b07da..01eb8f64ff 100644
--- a/resources/tools/presentation/pal.py
+++ b/resources/tools/presentation/pal.py
@@ -18,7 +18,7 @@ import sys
 import argparse
 import logging
 
-from errors import PresentationError
+from pal_errors import PresentationError
 from environment import Environment, clean_environment
 from specification_parser import Specification
 from input_data_parser import InputData
@@ -27,7 +27,7 @@ from generator_plots import generate_plots
 from generator_files import generate_files
 from static_content import prepare_static_content
 from generator_report import generate_report
-from generator_CPTA import generate_cpta
+from generator_cpta import generate_cpta
 from generator_alerts import Alerting, AlertingError
 
 
@@ -41,26 +41,26 @@ def parse_args():
     parser = argparse.ArgumentParser(description=__doc__,
                                      formatter_class=argparse.
                                      RawDescriptionHelpFormatter)
-    parser.add_argument("-s", "--specification",
+    parser.add_argument(u"-s", u"--specification",
                         required=True,
-                        type=argparse.FileType('r'),
-                        help="Specification YAML file.")
-    parser.add_argument("-r", "--release",
-                        default="master",
+                        type=argparse.FileType(u'r'),
+                        help=u"Specification YAML file.")
+    parser.add_argument(u"-r", u"--release",
+                        default=u"master",
                         type=str,
-                        help="Release string of the product.")
-    parser.add_argument("-w", "--week",
-                        default="1",
+                        help=u"Release string of the product.")
+    parser.add_argument(u"-w", u"--week",
+                        default=u"1",
                         type=str,
-                        help="Calendar week when the report is published.")
-    parser.add_argument("-l", "--logging",
-                        choices=["DEBUG", "INFO", "WARNING",
-                                 "ERROR", "CRITICAL"],
-                        default="ERROR",
-                        help="Logging level.")
-    parser.add_argument("-f", "--force",
-                        action='store_true',
-                        help="Force removing the old build(s) if present.")
+                        help=u"Calendar week when the report is published.")
+    parser.add_argument(u"-l", u"--logging",
+                        choices=[u"DEBUG", u"INFO", u"WARNING",
+                                 u"ERROR", u"CRITICAL"],
+                        default=u"ERROR",
+                        help=u"Logging level.")
+    parser.add_argument(u"-f", u"--force",
+                        action=u"store_true",
+                        help=u"Force removing the old build(s) if present.")
 
     return parser.parse_args()
 
@@ -68,75 +68,70 @@ def parse_args():
 def main():
     """Main function."""
 
-    log_levels = {"NOTSET": logging.NOTSET,
-                  "DEBUG": logging.DEBUG,
-                  "INFO": logging.INFO,
-                  "WARNING": logging.WARNING,
-                  "ERROR": logging.ERROR,
-                  "CRITICAL": logging.CRITICAL}
+    log_levels = {u"NOTSET": logging.NOTSET,
+                  u"DEBUG": logging.DEBUG,
+                  u"INFO": logging.INFO,
+                  u"WARNING": logging.WARNING,
+                  u"ERROR": logging.ERROR,
+                  u"CRITICAL": logging.CRITICAL}
 
     args = parse_args()
-    logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s',
-                        datefmt='%Y/%m/%d %H:%M:%S',
+    logging.basicConfig(format=u"%(asctime)s: %(levelname)s: %(message)s",
+                        datefmt=u"%Y/%m/%d %H:%M:%S",
                         level=log_levels[args.logging])
 
-    logging.info("Application started.")
+    logging.info(u"Application started.")
     try:
         spec = Specification(args.specification)
         spec.read_specification()
     except PresentationError:
-        logging.critical("Finished with error.")
+        logging.critical(u"Finished with error.")
         return 1
 
-    if spec.output["output"] not in ("report", "CPTA"):
-        logging.critical("The output '{0}' is not supported.".
-                         format(spec.output["output"]))
+    if spec.output[u"output"] not in (u"report", u"CPTA"):
+        logging.critical(
+            f"The output {spec.output[u'output']} is not supported."
+        )
         return 1
 
-    # ret_code = 1
-    # try:
-    env = Environment(spec.environment, args.force)
-    env.set_environment()
-
-    prepare_static_content(spec)
-
-    data = InputData(spec)
-    data.download_and_parse_data(repeat=1)
-
-    generate_tables(spec, data)
-    generate_plots(spec, data)
-    generate_files(spec, data)
-
-    if spec.output["output"] == "report":
-        generate_report(args.release, spec, args.week)
-        logging.info("Successfully finished.")
-    elif spec.output["output"] == "CPTA":
-        sys.stdout.write(generate_cpta(spec, data))
-        try:
-            alert = Alerting(spec)
-            alert.generate_alerts()
-        except AlertingError as err:
-            logging.warning(repr(err))
-        logging.info("Successfully finished.")
-    ret_code = 0
-
-    # except AlertingError as err:
-    #     logging.critical("Finished with an alerting error.")
-    #     logging.critical(repr(err))
-    # except PresentationError as err:
-    #     logging.critical("Finished with an PAL error.")
-    #     logging.critical(repr(err))
-    # except (KeyError, ValueError) as err:
-    #     logging.critical("Finished with an error.")
-    #     logging.critical(repr(err))
-    # except Exception as err:
-    #     logging.critical("Finished with an unexpected error.")
-    #     logging.critical(repr(err))
-    # finally:
-    #     if spec is not None:
-    #         clean_environment(spec.environment)
-    #     return ret_code
-
-
-if __name__ == '__main__':
+    ret_code = 1
+    try:
+        env = Environment(spec.environment, args.force)
+        env.set_environment()
+
+        prepare_static_content(spec)
+
+        data = InputData(spec)
+        data.download_and_parse_data(repeat=1)
+
+        generate_tables(spec, data)
+        generate_plots(spec, data)
+        generate_files(spec, data)
+
+        if spec.output[u"output"] == u"report":
+            generate_report(args.release, spec, args.week)
+        elif spec.output[u"output"] == u"CPTA":
+            sys.stdout.write(generate_cpta(spec, data))
+            try:
+                alert = Alerting(spec)
+                alert.generate_alerts()
+            except AlertingError as err:
+                logging.warning(repr(err))
+
+        logging.info(u"Successfully finished.")
+        ret_code = 0
+
+    except AlertingError as err:
+        logging.critical(f"Finished with an alerting error.\n{repr(err)}")
+    except PresentationError as err:
+        logging.critical(f"Finished with an PAL error.\n{repr(err)}")
+    except (KeyError, ValueError) as err:
+        logging.critical(f"Finished with an error.\n{repr(err)}")
+    finally:
+        if spec is not None:
+            clean_environment(spec.environment)
+    return ret_code
+
+
+if __name__ == u"__main__":
     sys.exit(main())