make version of ts_mon compatible with appengine

appengine/chromium_build_logs/third_party/googleapiclient/mimeparse.py

-# Copyright (C) 2007 Joe Gregorio
+# Copyright 2014 Joe Gregorio
 #
 # Licensed under the MIT License
 
 """MIME-Type Parser
 
 This module provides basic functions for handling mime-types. It can handle
 matching mime-types against a list of media-ranges. See section 14.1 of the
 HTTP specification [RFC 2616] for a complete explanation.
 
    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
 
 Contents:
  - parse_mime_type():   Parses a mime-type into its component parts.
  - parse_media_range(): Media-ranges are mime-types with wild-cards and a 'q'
                           quality parameter.
  - quality():           Determines the quality ('q') of a mime-type when
                           compared against a list of media-ranges.
  - quality_parsed():    Just like quality() except the second parameter must be
                           pre-parsed.
  - best_match():        Choose the mime-type with the highest quality ('q')
                           from a list of candidates.
 """
+from __future__ import absolute_import
+from functools import reduce
+import six
 
 __version__ = '0.1.3'
 __author__ = 'Joe Gregorio'
 __email__ = 'joe@bitworking.org'
 __license__ = 'MIT License'
 __credits__ = ''
 
 
 def parse_mime_type(mime_type):
     """Parses a mime-type into its component parts.
@@ skipping 27 matching lines @@
     range.  For example, the media range 'application/*;q=0.5' would get parsed
     into:
 
        ('application', '*', {'q', '0.5'})
 
     In addition this function also guarantees that there is a value for 'q'
     in the params dictionary, filling it in with a proper default if
     necessary.
     """
     (type, subtype, params) = parse_mime_type(range)
-    if not params.has_key('q') or not params['q'] or \
+    if 'q' not in params or not params['q'] or \
             not float(params['q']) or float(params['q']) > 1\
             or float(params['q']) < 0:
         params['q'] = '1'
 
     return (type, subtype, params)
 
 
 def fitness_and_quality_parsed(mime_type, parsed_ranges):
     """Find the best match for a mime-type amongst parsed media-ranges.
 
     Find the best match for a given mime-type against a list of media_ranges
     that have already been parsed by parse_media_range(). Returns a tuple of
     the fitness value and the value of the 'q' quality parameter of the best
     match, or (-1, 0) if no match was found. Just as for quality_parsed(),
     'parsed_ranges' must be a list of parsed media ranges.
     """
     best_fitness = -1
     best_fit_q = 0
     (target_type, target_subtype, target_params) =\
             parse_media_range(mime_type)
     for (type, subtype, params) in parsed_ranges:
         type_match = (type == target_type or\
                       type == '*' or\
                       target_type == '*')
         subtype_match = (subtype == target_subtype or\
                          subtype == '*' or\
                          target_subtype == '*')
         if type_match and subtype_match:
             param_matches = reduce(lambda x, y: x + y, [1 for (key, value) in \
-                    target_params.iteritems() if key != 'q' and \
-                    params.has_key(key) and value == params[key]], 0)
+                    six.iteritems(target_params) if key != 'q' and \
+                    key in params and value == params[key]], 0)
             fitness = (type == target_type) and 100 or 0
             fitness += (subtype == target_subtype) and 10 or 0
             fitness += param_matches
             if fitness > best_fitness:
                 best_fitness = fitness
                 best_fit_q = params['q']
 
     return best_fitness, float(best_fit_q)
 
 
@@ skipping 50 matching lines @@
         pos += 1
     weighted_matches.sort()
 
     return weighted_matches[-1][0][1] and weighted_matches[-1][2] or ''
 
 
 def _filter_blank(i):
     for s in i:
         if s.strip():
             yield s