Fix lint errors to enable stricter PyLint rules

webrtc/video/full_stack_tests_plot.py

 #!/usr/bin/env python
 # Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
 #
 # Use of this source code is governed by a BSD-style license
 # that can be found in the LICENSE file in the root of the source
 # tree. An additional intellectual property rights grant can be found
 # in the file PATENTS.  All contributing project authors may
 # be found in the AUTHORS file in the root of the source tree.
 
 """Generate graphs for data generated by loopback tests.
@@ skipping 39 matching lines @@
 END_TO_END = TOTAL_RAW_FIELDS + 2
 RENDERED_DELTA = TOTAL_RAW_FIELDS + 3
 
 FIELD_MASK = 255
 
 # Options
 HIDE_DROPPED = 256
 RIGHT_Y_AXIS = 512
 
 # internal field id, field name, title
-_fields = [
+_FIELDS = [
     # Raw
     (DROPPED, "dropped", "dropped"),
     (INPUT_TIME, "input_time_ms", "input time"),
     (SEND_TIME, "send_time_ms", "send time"),
     (RECV_TIME, "recv_time_ms", "recv time"),
     (ENCODED_FRAME_SIZE, "encoded_frame_size", "encoded frame size"),
     (PSNR, "psnr", "PSNR"),
     (SSIM, "ssim", "SSIM"),
     (RENDER_TIME, "render_time_ms", "render time"),
     (ENCODE_TIME, "encode_time_ms", "encode time"),
     # Auto-generated
     (SENDER_TIME, "sender_time", "sender time"),
     (RECEIVER_TIME, "receiver_time", "receiver time"),
     (END_TO_END, "end_to_end", "end to end"),
     (RENDERED_DELTA, "rendered_delta", "rendered delta"),
 ]
 
-name_to_id = {field[1]: field[0] for field in _fields}
-id_to_title = {field[0]: field[2] for field in _fields}
+NAME_TO_ID = {field[1]: field[0] for field in _FIELDS}
+ID_TO_TITLE = {field[0]: field[2] for field in _FIELDS}
 
-def field_arg_to_id(arg):
+def FieldArgToId(arg):
   if arg == "none":
     return None
-  if arg in name_to_id:
-    return name_to_id[arg]
-  if arg + "_ms" in name_to_id:
-    return name_to_id[arg + "_ms"]
+  if arg in NAME_TO_ID:
+    return NAME_TO_ID[arg]
+  if arg + "_ms" in NAME_TO_ID:
+    return NAME_TO_ID[arg + "_ms"]
   raise Exception("Unrecognized field name \"{}\"".format(arg))
 
 
 class PlotLine(object):
   """Data for a single graph line."""
 
   def __init__(self, label, values, flags):
     self.label = label
     self.values = values
     self.flags = flags
 
 
 class Data(object):
   """Object representing one full stack test."""
 
   def __init__(self, filename):
     self.title = ""
     self.length = 0
     self.samples = defaultdict(list)
 
-    self._read_samples(filename)
+    self._ReadSamples(filename)
 
-  def _read_samples(self, filename):
+  def _ReadSamples(self, filename):
     """Reads graph data from the given file."""
     f = open(filename)
     it = iter(f)
 
     self.title = it.next().strip()
     self.length = int(it.next())
     field_names = [name.strip() for name in it.next().split()]
-    field_ids = [name_to_id[name] for name in field_names]
+    field_ids = [NAME_TO_ID[name] for name in field_names]
 
     for field_id in field_ids:
       self.samples[field_id] = [0.0] * self.length
 
     for sample_id in xrange(self.length):
       for col, value in enumerate(it.next().split()):
         self.samples[field_ids[col]][sample_id] = float(value)
 
-    self._subtract_first_input_time()
-    self._generate_additional_data()
+    self._SubtractFirstInputTime()
+    self._GenerateAdditionalData()
 
     f.close()
 
-  def _subtract_first_input_time(self):
+  def _SubtractFirstInputTime(self):
     offset = self.samples[INPUT_TIME][0]
     for field in [INPUT_TIME, SEND_TIME, RECV_TIME, RENDER_TIME]:
       if field in self.samples:
         self.samples[field] = [x - offset for x in self.samples[field]]
 
-  def _generate_additional_data(self):
+  def _GenerateAdditionalData(self):
     """Calculates sender time, receiver time etc. from the raw data."""
     s = self.samples
     last_render_time = 0
     for field_id in [SENDER_TIME, RECEIVER_TIME, END_TO_END, RENDERED_DELTA]:
       s[field_id] = [0] * self.length
 
     for k in range(self.length):
       s[SENDER_TIME][k] = s[SEND_TIME][k] - s[INPUT_TIME][k]
 
       decoded_time = s[RENDER_TIME][k]
       s[RECEIVER_TIME][k] = decoded_time - s[RECV_TIME][k]
       s[END_TO_END][k] = decoded_time - s[INPUT_TIME][k]
       if not s[DROPPED][k]:
         if k > 0:
           s[RENDERED_DELTA][k] = decoded_time - last_render_time
         last_render_time = decoded_time
 
-  def _hide(self, values):
+  def _Hide(self, values):
     """
     Replaces values for dropped frames with None.
-    These values are then skipped by the plot() method.
+    These values are then skipped by the Plot() method.
     """
 
     return [None if self.samples[DROPPED][k] else values[k]
             for k in range(len(values))]
 
-  def add_samples(self, config, target_lines_list):
+  def AddSamples(self, config, target_lines_list):
     """Creates graph lines from the current data set with given config."""
     for field in config.fields:
       # field is None means the user wants just to skip the color.
       if field is None:
         target_lines_list.append(None)
         continue
 
       field_id = field & FIELD_MASK
       values = self.samples[field_id]
 
       if field & HIDE_DROPPED:
-        values = self._hide(values)
+        values = self._Hide(values)
 
       target_lines_list.append(PlotLine(
-          self.title + " " + id_to_title[field_id],
+          self.title + " " + ID_TO_TITLE[field_id],
           values, field & ~FIELD_MASK))
 
 
-def average_over_cycle(values, length):
+def AverageOverCycle(values, length):
   """
   Returns the list:
     [
         avg(values[0], values[length], ...),
         avg(values[1], values[length + 1], ...),
         ...
         avg(values[length - 1], values[2 * length - 1], ...),
     ]
 
   Skips None values when calculating the average value.
@@ skipping 18 matching lines @@
   def __init__(self, fields, data_list, cycle_length=None, frames=None,
                offset=0, output_filename=None, title="Graph"):
     self.fields = fields
     self.data_list = data_list
     self.cycle_length = cycle_length
     self.frames = frames
     self.offset = offset
     self.output_filename = output_filename
     self.title = title
 
-  def plot(self, ax1):
+  def Plot(self, ax1):
     lines = []
     for data in self.data_list:
       if not data:
         # Add None lines to skip the colors.
         lines.extend([None] * len(self.fields))
       else:
-        data.add_samples(self, lines)
+        data.AddSamples(self, lines)
 
-    def _slice_values(values):
+    def _SliceValues(values):
       if self.offset:
         values = values[self.offset:]
       if self.frames:
         values = values[:self.frames]
       return values
 
     length = None
     for line in lines:
       if line is None:
         continue
 
-      line.values = _slice_values(line.values)
+      line.values = _SliceValues(line.values)
       if self.cycle_length:
-        line.values = average_over_cycle(line.values, self.cycle_length)
+        line.values = AverageOverCycle(line.values, self.cycle_length)
 
       if length is None:
         length = len(line.values)
       elif length != len(line.values):
         raise Exception("All arrays should have the same length!")
 
     ax1.set_xlabel("Frame", fontsize="large")
     if any(line.flags & RIGHT_Y_AXIS for line in lines if line):
       ax2 = ax1.twinx()
       ax2.set_xlabel("Frame", fontsize="large")
     else:
       ax2 = None
 
     # Have to implement color_cycle manually, due to two scales in a graph.
     color_cycle = ["b", "r", "g", "c", "m", "y", "k"]
     color_iter = itertools.cycle(color_cycle)
 
     for line in lines:
       if not line:
         color_iter.next()
         continue
 
       if self.cycle_length:
         x = numpy.array(range(self.cycle_length))
       else:
         x = numpy.array(range(self.offset, self.offset + len(line.values)))
       y = numpy.array(line.values)
       ax = ax2 if line.flags & RIGHT_Y_AXIS else ax1
-      ax.plot(x, y, "o-", label=line.label, markersize=3.0, linewidth=1.0,
+      ax.Plot(x, y, "o-", label=line.label, markersize=3.0, linewidth=1.0,
               color=color_iter.next())
 
     ax1.grid(True)
     if ax2:
       ax1.legend(loc="upper left", shadow=True, fontsize="large")
       ax2.legend(loc="upper right", shadow=True, fontsize="large")
     else:
       ax1.legend(loc="best", shadow=True, fontsize="large")
 
 
-def load_files(filenames):
+def LoadFiles(filenames):
   result = []
   for filename in filenames:
-    if filename in load_files.cache:
-      result.append(load_files.cache[filename])
+    if filename in LoadFiles.cache:
+      result.append(LoadFiles.cache[filename])
     else:
       data = Data(filename)
-      load_files.cache[filename] = data
+      LoadFiles.cache[filename] = data
       result.append(data)
   return result
-load_files.cache = {}
+LoadFiles.cache = {}
 
 
-def get_parser():
+def GetParser():
   class CustomAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
       if "ordered_args" not in namespace:
         namespace.ordered_args = []
       namespace.ordered_args.append((self.dest, values))
 
   parser = argparse.ArgumentParser(
       description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
 
   parser.add_argument(
@@ skipping 18 matching lines @@
   parser.add_argument(
       "-O", "--output_filename", nargs=1, action=CustomAction,
       help="Use to save the graph into a file. "
            "Otherwise, a window will be shown.")
   parser.add_argument(
       "files", nargs="+", action=CustomAction,
       help="List of text-based files generated by loopback tests.")
   return parser
 
 
-def _plot_config_from_args(args, graph_num):
+def _PlotConfigFromArgs(args, graph_num):
   # Pylint complains about using kwargs, so have to do it this way.
   cycle_length = None
   frames = None
   offset = 0
   output_filename = None
   title = "Graph"
 
   fields = []
   files = []
   mask = 0
   for key, values in args:
     if key == "cycle_length":
       cycle_length = values[0]
     elif key == "frames":
       frames = values[0]
     elif key == "offset":
       offset = values[0]
     elif key == "output_filename":
       output_filename = values[0]
     elif key == "title":
       title = values[0]
     elif key == "drop":
       mask |= HIDE_DROPPED
     elif key == "right":
       mask |= RIGHT_Y_AXIS
     elif key == "field":
-      field_id = field_arg_to_id(values[0])
+      field_id = FieldArgToId(values[0])
       fields.append(field_id | mask if field_id is not None else None)
       mask = 0  # Reset mask after the field argument.
     elif key == "files":
       files.extend(values)
 
   if not files:
     raise Exception("Missing file argument(s) for graph #{}".format(graph_num))
   if not fields:
     raise Exception("Missing field argument(s) for graph #{}".format(graph_num))
 
-  return PlotConfig(fields, load_files(files), cycle_length=cycle_length,
+  return PlotConfig(fields, LoadFiles(files), cycle_length=cycle_length,
       frames=frames, offset=offset, output_filename=output_filename,
       title=title)
 
 
-def plot_configs_from_args(args):
+def PlotConfigsFromArgs(args):
   """Generates plot configs for given command line arguments."""
   # The way it works:
   #   First we detect separators -n/--next and split arguments into groups, one
   #   for each plot. For each group, we partially parse it with
   #   argparse.ArgumentParser, modified to remember the order of arguments.
   #   Then we traverse the argument list and fill the PlotConfig.
   args = itertools.groupby(args, lambda x: x in ["-n", "--next"])
   args = list(list(group) for match, group in args if not match)
 
-  parser = get_parser()
+  parser = GetParser()
   plot_configs = []
   for index, raw_args in enumerate(args):
     graph_args = parser.parse_args(raw_args).ordered_args
-    plot_configs.append(_plot_config_from_args(graph_args, index))
+    plot_configs.append(_PlotConfigFromArgs(graph_args, index))
   return plot_configs
 
 
-def show_or_save_plots(plot_configs):
+def ShowOrSavePlots(plot_configs):
   for config in plot_configs:
     fig = plt.figure(figsize=(14.0, 10.0))
-    ax = fig.add_subplot(1, 1, 1)
+    ax = fig.add_subPlot(1, 1, 1)
 
     plt.title(config.title)
-    config.plot(ax)
+    config.Plot(ax)
     if config.output_filename:
       print "Saving to", config.output_filename
       fig.savefig(config.output_filename)
       plt.close(fig)
 
   plt.show()
 
 if __name__ == "__main__":
-  show_or_save_plots(plot_configs_from_args(sys.argv[1:]))
+  ShowOrSavePlots(PlotConfigsFromArgs(sys.argv[1:]))