Howdy Lars, Here (attached) is a Bazaar patch against your branch 'python-coverage/upstream', updating the branch to upstream's version 2.78.
-- \ "Democracy is the art of running the circus from the monkey | `\ cage." -- Henry L. Mencken | _o__) | Ben Finney <[EMAIL PROTECTED]>
# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: [EMAIL PROTECTED] # target_branch: http://liw.iki.fi/bzr/python-coverage/upstream/ # testament_sha1: 0337edce955af792b929bc7bedc9192070d9a28e # timestamp: 2008-05-10 11:06:01 +1000 # base_revision_id: [EMAIL PROTECTED] # # Begin patch === modified file 'coverage.py' --- coverage.py 2007-07-30 17:16:45 +0000 +++ coverage.py 2008-05-10 00:34:32 +0000 @@ -54,18 +54,27 @@ Coverage data is saved in the file .coverage by default. Set the COVERAGE_FILE environment variable to save it somewhere else.""" -__version__ = "2.6.20060823" # see detailed history at the end of this file. +__version__ = "2.78.20070930" # see detailed history at the end of this file. import compiler import compiler.visitor +import glob import os import re import string +import symbol import sys import threading +import token import types from socket import gethostname +# Python version compatibility +try: + strclass = basestring # new to 2.3 +except: + strclass = str + # 2. IMPLEMENTATION # # This uses the "singleton" pattern. @@ -87,6 +96,9 @@ # names to increase speed. class StatementFindingAstVisitor(compiler.visitor.ASTVisitor): + """ A visitor for a parsed Abstract Syntax Tree which finds executable + statements. + """ def __init__(self, statements, excluded, suite_spots): compiler.visitor.ASTVisitor.__init__(self) self.statements = statements @@ -95,7 +107,6 @@ self.excluding_suite = 0 def doRecursive(self, node): - self.recordNodeLine(node) for n in node.getChildNodes(): self.dispatch(n) @@ -131,12 +142,35 @@ def doStatement(self, node): self.recordLine(self.getFirstLine(node)) - visitAssert = visitAssign = visitAssTuple = visitDiscard = visitPrint = \ + visitAssert = visitAssign = visitAssTuple = visitPrint = \ visitPrintnl = visitRaise = visitSubscript = visitDecorators = \ doStatement + def visitPass(self, node): + # Pass statements have weird interactions with docstrings. If this + # pass statement is part of one of those pairs, claim that the statement + # is on the later of the two lines. + l = node.lineno + if l: + lines = self.suite_spots.get(l, [l,l]) + self.statements[lines[1]] = 1 + + def visitDiscard(self, node): + # Discard nodes are statements that execute an expression, but then + # discard the results. This includes function calls, so we can't + # ignore them all. But if the expression is a constant, the statement + # won't be "executed", so don't count it now. + if node.expr.__class__.__name__ != 'Const': + self.doStatement(node) + def recordNodeLine(self, node): - return self.recordLine(node.lineno) + # Stmt nodes often have None, but shouldn't claim the first line of + # their children (because the first child might be an ignorable line + # like "global a"). + if node.__class__.__name__ != 'Stmt': + return self.recordLine(self.getFirstLine(node)) + else: + return 0 def recordLine(self, lineno): # Returns a bool, whether the line is included or excluded. @@ -145,7 +179,7 @@ # keyword. if lineno in self.suite_spots: lineno = self.suite_spots[lineno][0] - # If we're inside an exluded suite, record that this line was + # If we're inside an excluded suite, record that this line was # excluded. if self.excluding_suite: self.excluded[lineno] = 1 @@ -197,6 +231,8 @@ self.doSuite(node, node.body) self.doElse(node.body, node) + visitWhile = visitFor + def visitIf(self, node): # The first test has to be handled separately from the rest. # The first test is credited to the line with the "if", but the others @@ -206,10 +242,6 @@ self.doSuite(t, n) self.doElse(node.tests[-1][1], node) - def visitWhile(self, node): - self.doSuite(node, node.body) - self.doElse(node.body, node) - def visitTryExcept(self, node): self.doSuite(node, node.body) for i in range(len(node.handlers)): @@ -229,6 +261,9 @@ self.doSuite(node, node.body) self.doPlainWordSuite(node.body, node.final) + def visitWith(self, node): + self.doSuite(node, node.body) + def visitGlobal(self, node): # "global" statements don't execute like others (they don't call the # trace function), so don't record their line numbers. @@ -265,14 +300,16 @@ def __init__(self): global the_coverage if the_coverage: - raise CoverageException, "Only one coverage object allowed." + raise CoverageException("Only one coverage object allowed.") self.usecache = 1 self.cache = None + self.parallel_mode = False self.exclude_re = '' self.nesting = 0 self.cstack = [] self.xstack = [] - self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.path.sep) + self.relative_dir = os.path.normcase(os.path.abspath(os.curdir)+os.sep) + self.exclude('# *pragma[: ]*[nN][oO] *[cC][oO][vV][eE][rR]') # t(f, x, y). This method is passed to sys.settrace as a trace function. # See [van Rossum 2001-07-20b, 9.2] for an explanation of sys.settrace and @@ -280,23 +317,24 @@ # See [van Rossum 2001-07-20a, 3.2] for a description of frame and code # objects. - def t(self, f, w, a): #pragma: no cover + def t(self, f, w, unused): #pragma: no cover if w == 'line': + #print "Executing %s @ %d" % (f.f_code.co_filename, f.f_lineno) self.c[(f.f_code.co_filename, f.f_lineno)] = 1 for c in self.cstack: c[(f.f_code.co_filename, f.f_lineno)] = 1 return self.t - def help(self, error=None): + def help(self, error=None): #pragma: no cover if error: print error print print __doc__ sys.exit(1) - def command_line(self, argv, help=None): + def command_line(self, argv, help_fn=None): import getopt - help = help or self.help + help_fn = help_fn or self.help settings = {} optmap = { '-a': 'annotate', @@ -327,12 +365,12 @@ pass # Can't get here, because getopt won't return anything unknown. if settings.get('help'): - help() + help_fn() for i in ['erase', 'execute']: for j in ['annotate', 'report', 'collect']: if settings.get(i) and settings.get(j): - help("You can't specify the '%s' and '%s' " + help_fn("You can't specify the '%s' and '%s' " "options at the same time." % (i, j)) args_needed = (settings.get('execute') @@ -342,18 +380,18 @@ or settings.get('collect') or args_needed) if not action: - help("You must specify at least one of -e, -x, -c, -r, or -a.") + help_fn("You must specify at least one of -e, -x, -c, -r, or -a.") if not args_needed and args: - help("Unexpected arguments: %s" % " ".join(args)) + help_fn("Unexpected arguments: %s" % " ".join(args)) - self.get_ready(settings.get('parallel-mode')) - self.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]') + self.parallel_mode = settings.get('parallel-mode') + self.get_ready() if settings.get('erase'): self.erase() if settings.get('execute'): if not args: - help("Nothing to do.") + help_fn("Nothing to do.") sys.argv = args self.start() import __main__ @@ -387,13 +425,13 @@ def get_ready(self, parallel_mode=False): if self.usecache and not self.cache: self.cache = os.environ.get(self.cache_env, self.cache_default) - if parallel_mode: + if self.parallel_mode: self.cache += "." + gethostname() + "." + str(os.getpid()) self.restore() self.analysis_cache = {} def start(self, parallel_mode=False): - self.get_ready(parallel_mode) + self.get_ready() if self.nesting == 0: #pragma: no cover sys.settrace(self.t) if hasattr(threading, 'settrace'): @@ -408,12 +446,12 @@ threading.settrace(None) def erase(self): + self.get_ready() self.c = {} self.analysis_cache = {} self.cexecuted = {} if self.cache and os.path.exists(self.cache): os.remove(self.cache) - self.exclude_re = "" def exclude(self, re): if self.exclude_re: @@ -464,11 +502,11 @@ def collect(self): cache_dir, local = os.path.split(self.cache) - for file in os.listdir(cache_dir): - if not file.startswith(local): + for f in os.listdir(cache_dir or '.'): + if not f.startswith(local): continue - full_path = os.path.join(cache_dir, file) + full_path = os.path.join(cache_dir, f) cexecuted = self.restore_file(full_path) self.merge_data(cexecuted) @@ -508,6 +546,9 @@ def canonicalize_filenames(self): for filename, lineno in self.c.keys(): + if filename == '<string>': + # Can't do anything useful with exec'd strings, so skip them. + continue f = self.canonical_filename(filename) if not self.cexecuted.has_key(f): self.cexecuted[f] = {} @@ -519,41 +560,85 @@ def morf_filename(self, morf): if isinstance(morf, types.ModuleType): if not hasattr(morf, '__file__'): - raise CoverageException, "Module has no __file__ attribute." - file = morf.__file__ + raise CoverageException("Module has no __file__ attribute.") + f = morf.__file__ else: - file = morf - return self.canonical_filename(file) + f = morf + return self.canonical_filename(f) # analyze_morf(morf). Analyze the module or filename passed as # the argument. If the source code can't be found, raise an error. # Otherwise, return a tuple of (1) the canonical filename of the # source code for the module, (2) a list of lines of statements - # in the source code, and (3) a list of lines of excluded statements. - + # in the source code, (3) a list of lines of excluded statements, + # and (4), a map of line numbers to multi-line line number ranges, for + # statements that cross lines. + def analyze_morf(self, morf): if self.analysis_cache.has_key(morf): return self.analysis_cache[morf] filename = self.morf_filename(morf) ext = os.path.splitext(filename)[1] if ext == '.pyc': - if not os.path.exists(filename[0:-1]): - raise CoverageException, ("No source for compiled code '%s'." - % filename) - filename = filename[0:-1] - elif ext != '.py': - raise CoverageException, "File '%s' not Python source." % filename + if not os.path.exists(filename[:-1]): + raise CoverageException( + "No source for compiled code '%s'." % filename + ) + filename = filename[:-1] source = open(filename, 'r') - lines, excluded_lines = self.find_executable_statements( - source.read(), exclude=self.exclude_re - ) + try: + lines, excluded_lines, line_map = self.find_executable_statements( + source.read(), exclude=self.exclude_re + ) + except SyntaxError, synerr: + raise CoverageException( + "Couldn't parse '%s' as Python source: '%s' at line %d" % + (filename, synerr.msg, synerr.lineno) + ) source.close() - result = filename, lines, excluded_lines + result = filename, lines, excluded_lines, line_map self.analysis_cache[morf] = result return result + def first_line_of_tree(self, tree): + while True: + if len(tree) == 3 and type(tree[2]) == type(1): + return tree[2] + tree = tree[1] + + def last_line_of_tree(self, tree): + while True: + if len(tree) == 3 and type(tree[2]) == type(1): + return tree[2] + tree = tree[-1] + + def find_docstring_pass_pair(self, tree, spots): + for i in range(1, len(tree)): + if self.is_string_constant(tree[i]) and self.is_pass_stmt(tree[i+1]): + first_line = self.first_line_of_tree(tree[i]) + last_line = self.last_line_of_tree(tree[i+1]) + self.record_multiline(spots, first_line, last_line) + + def is_string_constant(self, tree): + try: + return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.expr_stmt + except: + return False + + def is_pass_stmt(self, tree): + try: + return tree[0] == symbol.stmt and tree[1][1][1][0] == symbol.pass_stmt + except: + return False + + def record_multiline(self, spots, i, j): + for l in range(i, j+1): + spots[l] = (i, j) + def get_suite_spots(self, tree, spots): - import symbol, token + """ Analyze a parse tree to find suite introducers which span a number + of lines. + """ for i in range(1, len(tree)): if type(tree[i]) == type(()): if tree[i][0] == symbol.suite: @@ -561,7 +646,9 @@ lineno_colon = lineno_word = None for j in range(i-1, 0, -1): if tree[j][0] == token.COLON: - lineno_colon = tree[j][2] + # Colons are never executed themselves: we want the + # line number of the last token before the colon. + lineno_colon = self.last_line_of_tree(tree[j-1]) elif tree[j][0] == token.NAME: if tree[j][1] == 'elif': # Find the line number of the first non-terminal @@ -583,8 +670,18 @@ if lineno_colon and lineno_word: # Found colon and keyword, mark all the lines # between the two with the two line numbers. - for l in range(lineno_word, lineno_colon+1): - spots[l] = (lineno_word, lineno_colon) + self.record_multiline(spots, lineno_word, lineno_colon) + + # "pass" statements are tricky: different versions of Python + # treat them differently, especially in the common case of a + # function with a doc string and a single pass statement. + self.find_docstring_pass_pair(tree[i], spots) + + elif tree[i][0] == symbol.simple_stmt: + first_line = self.first_line_of_tree(tree[i]) + last_line = self.last_line_of_tree(tree[i]) + if first_line != last_line: + self.record_multiline(spots, first_line, last_line) self.get_suite_spots(tree[i], spots) def find_executable_statements(self, text, exclude=None): @@ -598,10 +695,13 @@ if reExclude.search(lines[i]): excluded[i+1] = 1 + # Parse the code and analyze the parse tree to find out which statements + # are multiline, and where suites begin and end. import parser tree = parser.suite(text+'\n\n').totuple(1) self.get_suite_spots(tree, suite_spots) - + #print "Suite spots:", suite_spots + # Use the compiler module to parse the text and find the executable # statements. We add newlines to be impervious to final partial lines. statements = {} @@ -613,7 +713,7 @@ lines.sort() excluded_lines = excluded.keys() excluded_lines.sort() - return lines, excluded_lines + return lines, excluded_lines, suite_spots # format_lines(statements, lines). Format a list of line numbers # for printing by coalescing groups of lines as long as the lines @@ -646,7 +746,8 @@ return "%d" % start else: return "%d-%d" % (start, end) - return string.join(map(stringify, pairs), ", ") + ret = string.join(map(stringify, pairs), ", ") + return ret # Backward compatibility with version 1. def analysis(self, morf): @@ -654,13 +755,17 @@ return f, s, m, mf def analysis2(self, morf): - filename, statements, excluded = self.analyze_morf(morf) + filename, statements, excluded, line_map = self.analyze_morf(morf) self.canonicalize_filenames() if not self.cexecuted.has_key(filename): self.cexecuted[filename] = {} missing = [] for line in statements: - if not self.cexecuted[filename].has_key(line): + lines = line_map.get(line, [line, line]) + for l in range(lines[0], lines[1]+1): + if self.cexecuted[filename].has_key(l): + break + else: missing.append(line) return (filename, statements, excluded, missing, self.format_lines(statements, missing)) @@ -698,6 +803,15 @@ def report(self, morfs, show_missing=1, ignore_errors=0, file=None, omit_prefixes=[]): if not isinstance(morfs, types.ListType): morfs = [morfs] + # On windows, the shell doesn't expand wildcards. Do it here. + globbed = [] + for morf in morfs: + if isinstance(morf, strclass): + globbed.extend(glob.glob(morf)) + else: + globbed.append(morf) + morfs = globbed + morfs = self.filter_by_prefix(morfs, omit_prefixes) morfs.sort(self.morf_name_compare) @@ -735,8 +849,8 @@ raise except: if not ignore_errors: - type, msg = sys.exc_info()[0:2] - print >>file, fmt_err % (name, type, msg) + typ, msg = sys.exc_info()[:2] + print >>file, fmt_err % (name, typ, msg) if len(morfs) > 1: print >>file, "-" * len(header) if total_statements > 0: @@ -816,18 +930,41 @@ the_coverage = coverage() # Module functions call methods in the singleton object. -def use_cache(*args, **kw): return the_coverage.use_cache(*args, **kw) -def start(*args, **kw): return the_coverage.start(*args, **kw) -def stop(*args, **kw): return the_coverage.stop(*args, **kw) -def erase(*args, **kw): return the_coverage.erase(*args, **kw) -def begin_recursive(*args, **kw): return the_coverage.begin_recursive(*args, **kw) -def end_recursive(*args, **kw): return the_coverage.end_recursive(*args, **kw) -def exclude(*args, **kw): return the_coverage.exclude(*args, **kw) -def analysis(*args, **kw): return the_coverage.analysis(*args, **kw) -def analysis2(*args, **kw): return the_coverage.analysis2(*args, **kw) -def report(*args, **kw): return the_coverage.report(*args, **kw) -def annotate(*args, **kw): return the_coverage.annotate(*args, **kw) -def annotate_file(*args, **kw): return the_coverage.annotate_file(*args, **kw) +def use_cache(*args, **kw): + return the_coverage.use_cache(*args, **kw) + +def start(*args, **kw): + return the_coverage.start(*args, **kw) + +def stop(*args, **kw): + return the_coverage.stop(*args, **kw) + +def erase(*args, **kw): + return the_coverage.erase(*args, **kw) + +def begin_recursive(*args, **kw): + return the_coverage.begin_recursive(*args, **kw) + +def end_recursive(*args, **kw): + return the_coverage.end_recursive(*args, **kw) + +def exclude(*args, **kw): + return the_coverage.exclude(*args, **kw) + +def analysis(*args, **kw): + return the_coverage.analysis(*args, **kw) + +def analysis2(*args, **kw): + return the_coverage.analysis2(*args, **kw) + +def report(*args, **kw): + return the_coverage.report(*args, **kw) + +def annotate(*args, **kw): + return the_coverage.annotate(*args, **kw) + +def annotate_file(*args, **kw): + return the_coverage.annotate_file(*args, **kw) # Save coverage data when Python exits. (The atexit module wasn't # introduced until Python 2.0, so use sys.exitfunc when it's not @@ -918,11 +1055,41 @@ # # 2006-08-23 NMB Refactorings to improve testability. Fixes to command-line # logic for parallel mode and collect. +# +# 2006-08-25 NMB "#pragma: nocover" is excluded by default. +# +# 2006-09-10 NMB Properly ignore docstrings and other constant expressions that +# appear in the middle of a function, a problem reported by Tim Leslie. +# Minor changes to avoid lint warnings. +# +# 2006-09-17 NMB coverage.erase() shouldn't clobber the exclude regex. +# Change how parallel mode is invoked, and fix erase() so that it erases the +# cache when called programmatically. +# +# 2007-07-21 NMB In reports, ignore code executed from strings, since we can't +# do anything useful with it anyway. +# Better file handling on Linux, thanks Guillaume Chazarain. +# Better shell support on Windows, thanks Noel O'Boyle. +# Python 2.2 support maintained, thanks Catherine Proulx. +# +# 2007-07-22 NMB Python 2.5 now fully supported. The method of dealing with +# multi-line statements is now less sensitive to the exact line that Python +# reports during execution. Pass statements are handled specially so that their +# disappearance during execution won't throw off the measurement. +# +# 2007-07-23 NMB Now Python 2.5 is *really* fully supported: the body of the +# new with statement is counted as executable. +# +# 2007-07-29 NMB Better packaging. +# +# 2007-09-30 NMB Don't try to predict whether a file is Python source based on +# the extension. Extensionless files are often Pythons scripts. Instead, simply +# parse the file and catch the syntax errors. Hat tip to Ben Finney. # C. COPYRIGHT AND LICENCE # # Copyright 2001 Gareth Rees. All rights reserved. -# Copyright 2004-2006 Ned Batchelder. All rights reserved. +# Copyright 2004-2007 Ned Batchelder. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -949,4 +1116,4 @@ # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH # DAMAGE. # -# $Id: coverage.py 47 2006-08-24 01:08:48Z Ned $ +# $Id: coverage.py 79 2007-10-01 01:01:52Z nedbat $ # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWbAsG9UACXV/gGRUREJ///// f/f//r////BgFCXVfcz1iaoDed3e7uc9O2pse2s54C9Xtrm1O87gOsRXo1s27e9oQCRZjLpoAEpq CaTTTQCYExTyaJp4piI9J6J6MiBtTTQ0aPKaZqBpoRoJomk0aRlPU9CYQ9TaCPUAA0AANBpoAaaa TRGinoiaPVM1NPU2gajamm0jCGCDRkMAhk0yYSFCNCjJgTVT/Qqep6n6o2U9qmnptQhkaMEaNHqG j1GgNA4GjRiDRpkwgxAYjE0aNGgDTTQAAABIkEEyNCZMmiYEaah6T0k/U1PImIYTTRkaaekNNNCh hgwMkyABr3ae52vTezv/CrR3O22qK6pS4+1+NA9CUex13s3p1PHWvc6mz8f87ZWbknlFY7voYVFm NyjbF493Jhrxcy5htGbw15wE2iWmnF+nK0ta056re2/LjyfytTAUYaw46q8osaYOXxhRVM9VgtY/ xMGqB1WDg6SHF0aSRwPAt3x3nSC5uQsE7/Lw9N4FaDLK8jpD9solOkAijPf68Ns+un/eom35fQGt qj+mbtVfSpX5Wl2sQdjEie6QAF4uLc3ZJqi9zSrqbUrWlFJYRCkibNIitoublWyV1zlWrsanZFPO +LsQkI4At0IABXJcaYZoJgZryBmB3bHKNyGPo8Hr3FPVUSNVd7otqUeuqzc3RHqVdqY4+C1HC6YB uGzuohtRbKO3fTDAkDC38wGCiAdo8/Ypzt2nUyTz8npU7cUyoskINWiJSdEFt9cpZ+Ajr57wBjTS gaodgBhBJrzGmonNonnpscmZwIsHcSaWsKxJk1mkQxJIgUvIk2N4qzDE1hWstYtWkgllWhYihqYs tTOi2itjy0WYmbC7zwDTjLeW5kT3XljPLu3+ckEpOU/geQe5vCUsIfNnscDnZs2tRUyoQgT4cVOh NrnmJSlpl4o5N/Hm33asxVbqy16feOtKM2bDDvjQPuX/2Z8ije1brBWxcYq+S1Vq1P0T1qIvz4M9 yaVEujd2pC9s8WHMHuNge0EgZTyXcp7dMbrDO2W6eQyGIDj/FfdYwoaYFZqZjxzvgT5MSNdkm4dB M0tPfvhZHTLYcdaNBDy+tAYwKzr2BKrvFWSWdVxY7ojaDZTC2BzUWe/V3eGPR8mOHWuy6bZ6PpO8 aO9FxeKj1eISwnK9jqXCss6KlYybcfkHRshSyGpKjiNzClHeiGMgQQ5ydrPntoao2tsG9BXKnJt1 87yGzkSqak5aasN0NtsEYia9EhntEp7jDdeGhb0xuD5iokJWvPY2YyZtz1ulrZRyqaztJdyT4pT0 nJUtdmQuszWeY7GBnoobVbUkvHiomk8ESwCdhbQ0iNF8C7ZI4n6fBsGdEE0mtuHMSTOZGuDiz1vx 0G2dOGNsxdoJa+TVXgm4CPSF30WYJOgO+WzWgXVZiyjCDbgHAUYlBnMTCysPupSBIkn7IrIjg3TY XkuatbIvwjXR+4BwDoWtD3u/4oOzRl5cflhX49C3UB9vSK3aZLhdcyu0CQUX9j/ZHp9KHJoCjbfw gVfusRg/1PX8kiY9kjG8ZRlq3ZR1HLP9f6N+VbpGiPGcg1xH5/PytXzn6Z8bPdyv5kK7Sln5zIfL xOJl26x5xUJBkIcC7YHoulstioN8AuO3THySpCiCMmnaUnBGRAnZFRyhdQ3W37NW9hVI0GCd3Nyg 3DejW1SotWPnNDBYLKLyOuvSPNiuE0Klefyxpj5WU0QjLLwwrEMs2ArOTNs4IFbIBfEApGM/iMcd D3QAb5N9aGm9ot0qy1SgN2JQJ+BGbIcgrEkvpvCiNW6xGwijwSz+g9I1mOaiCe9dv0BAPwToTw+Q DqQ/8dDlz9+Z2rCZGOQCduJVuhjU2mRdybI7gEjFv1LKz+DK/1Zqk+fO+fRCaMCqzOEUqeNefdPD PbwriRkTPsS4PYYZEmYiGQPRBCiIc4ypM3oYVPPAeHdG1AzuzbpLDPe6TWMwoiSHEokQRD5j/cb8 0cn3or4Lp6oochgHfWCraBTsgDYj8DS7rQjDBuzpKUsnEwNnmmBekL3qXJTLq2k5gUunJnkAzVmu YaV4MCxBbYTmBUmWTUV5yO4XXB0fIfutyBJIjW6hmUAYcY2ZtnKK/iPGnhnEgQBePnVN2QVHxxxp bmYXGHHgQhs6cblErHTsSjPgl799DPCjh7VpvewcAXGq9VxzCNrCjI4TslGfx7C0C8uDTtldIGpi aWTAg9JnsMS3F6GC68699cGb3cdyIOoshTDBFv6XbDoZwM5cjTjCva2rS9tOQw2k7CnNFzcrdWy1 KpanJ6wHyvAZhZAe2uGcCeDDEyVOsUvEmgpkXvVhxgxwCo7wAehRrUgYXZGwRHNum/AtobLF6ncZ 4eYNQE3vOl7orbE7DDhaO+zLI3GzgMO1HoRbPNNthJwmt6ZWhSV3m8si9sYum7m8Dtg9JexER9jy rFUZd5M2DPs1Zl+1HuACReaLVpjlRcqK50UUawwQdA74TjCQ+gsHTMWG9mAuZQFa96OHOqdcUH9f 34soSxOR3HFVfEtJK5fYka8yJQeNKpWeVkttoYwuyoy1rdQef7Mh6ExxCo0zzAvpozG1dgIA5hYj s3E9422hxZneouSgtsVkZ40Aic6O9AMBtNFimskkDdULX2Azg9lAi9pnIaxOQ5oA+2Cfq2JgOnAc cFOCJHXgGSZsU4gSsi3092Jpv3qVpQ46wyNxxawZrCe4mimR5PYczF8zNnD6vaQQMCGgIQ0xho9z cZjk37SAplIYrxmm/sxYdhBxNudWhbmfMwedh3d3VtnV8DzS+KM283+gWi+mTdhNRhuPDKobHHNe svaZSQYMta5vxto+nwXfcdLmLt/073Ugt0+GlzFR/V+4dLdMGmM3zvPsQa+fKAe/s9vf6Y2/Hufl ARgulgvKAC2Ois4nLQsVkdCTfm9raayJmMHV7TLzZscguVO4bL3nq6qB43hw+Iu1vJt2/X+XDxeL HUo3rXrsGD0c62djI3knA4cg9SOur9JtkWCEkoxB/O3XS3L7JutjolXjgeicTihSfM8cg8ng6cNi PuZp28iuHWsWc8ypw858xNJbjocFTZX9QGJR+XPJFyLmCzRUDJOBmRLA0GWpissW3b56/I8Ar6WR miWmfShfwrejk6T0dwZH2mjQzj3G1HGU+V5xMQcQ0HvMMuRJ03CgY/szJ5eFLIkoVnzrsSptAcAN KG1UoOc7WJBnMsESeN6OhJSciYjpKMkBOVeCMdxx4olmCwUhft7gFIxn4NGdSmaC67IHth9+4zNB uKIxgh3w3QM0yrvUz+bpEjLMXB4Uz470G2d+BW9acNFOhevR6j3Sd5w7ZI+g9JQ4YBBrft/co8Wd 8mDE0lwU6QU9ERqqP3l5pFZEwwzVtG3sNpWMx5t/bX5DAU1QEmu7GyPvq23GcKQj0WAFWobXM6e4 xBxWClW6GS1kzQr5UCqaTH9WQoGt1E2Pn3OgaZ0DGx4xmUs0gCQ0xg2xrGnbFlKMbZ8slRwX+SZU K0TpKMLoH5Du8YdOCqDPWY/ReBfFAagIPOeoCeVck2t7aaEzBpYI/FppNNtSrlWrn58AL/AmcZy5 RI8lhgpLcOgwmTdbo4ZcIesMy8Rzd9N8uPqV6aEw4C7RYOJAfFNx1RwXeOjfjB0TjDOIhqlqkKEO 2+KmQ9nagdpIzo8KkS7VImQ7yiMnxGcBTlXKYrjJsLvdVFVRCLW6zp1s06M7w6BhiRGVCEcigSeE WXRFK3wkqZ3yulcEMYMYYMK08DpPeIPH2F2neMywe3IrnLtLyO+YfRQRYNBdGljwNoLjZeTuRYGL SxoqHv7JWwFGtxUwl38PEqExfTEBRIoZfLgs2aHtpBMmS55Za6c95BRUwVrEHI0gmgGwKzJQtRb0 4IpN1SEeEgXt9rnIq8RWMFGhy8Sc5xRYIGkdstkdzog1CoZt6MGnxKAUDYSaNgEyzAiyTG3HEcOp FCYkY4tlp0mEaO7JVMc9vjIrQAwNuzMsX52QkJHdCpwf7yaXHEJJkt2AuiZaqblWqSMGgZZfs5PQ yUhjYja147YJu2CFoCSnYxGrb0vtGvvibT4xsreFBsqmDiiakfY/FlKhTDD8cXJJtFJEqUgkNnL/ e32e4eJ8W81pezX47QrtDBGv62cz6Z3UIdbg+7jH4wMh9iBr3PlhTGWpbwHUkrle9Ug7x8pqJld5 RGtXHW0DGWgP82j1tMEmaEr7FKFPq4Tvs2eSWnYXBmF7hqv0IE0f9g8qPM22NNhrhowMpTUsoAhW JB62gsmCZwhMTHHqfVx5spdHqY5JyavOqCaMXViMGyI3I7l8gHQkhU6Dlh9aLS1Cm2yGwWSLsTos 9605MLB6NQbbuyuYsayoQjKjemsBpN2WDwLAs/ejXwYbgXT1wC1I+D4+ehMwOVY5MDkVZFJ3nMhr o0RpS1MD0sbSRe0Iw4UztT1p55JZ2vI6/WYIP76bKhdjPqd2g78pk7k0mmwT3PPw7mzQZIajWwNu aGNtZg+9u/qbuFfeSDUW+yYXIOUDelySOi3VIHCNEotXbHp6NS9aNPYOM47k0tp+7pYgw9izwN7Q Gnn2Z7Fu6PcYiGsvxjOxSF7f8visdEsPw+3A4p4YbSalOt+DRR07+VAp80CYY5VMrtGFVUFxmCQj a4dbYemA2TAGcZDY5oaWTf5yPAY3NNWOufbItu9XiFPHPzuXHZAECEIwAY6soYJxhTM5pHPAcBIZ oOxbo4kGtVRHxQMbsFYAeYGmYG7u8aLqt0fQDmCNVGKBIuEMSk/r+DPVsu0WszE/JFJEYhHY7LN4 7kYUOGxAcKFwCKCrHXZNJ3IFAibyggEHLxEkDuJqlGyAE9bMB+Qc76SiLthislREa/8YosBIbog6 oCo7A6GUA4tBCyMqWse9QlRybYooBIdAEKLawNGhjBMY2DaFkxc00lF+/tSMkFQObSMhMC9OFVTh 5MEioY5poewabFSvUHKp0A1mi11Iw5ekqVDKG5x0cTJsVZjUINIPZMgtBYrlpvHzJB8WeOeCX0sh 2VLOTgQSOx9iDRyUlOA8a9Qxk0Q02Qyp8XvGi29B7rF1JNWer6k9ZcLFfNWEaC1rKDdpamScG3Q+ OQWNNpFVpXw8U6O5mOCMdA0S9m7Ad7KsJVJzRZnaJFXkIgIrm7EK0Oy9tfnStgp6em5I/EsMrc55 EXQhEwuvK2Rr2n1R0BtNBKXX2EaEbY92oGk5xlf2R93cvT6fAKAfDcVaugMVnDgTDCNKOcr7rO90 GcSgY7UjiVUXH6L48pKR7JHFxD8bcAN+sNXwHT9iJdthDs6pESghwNs1NQUpCjVEe/SteGBF7bCO 3jaZVSREUDH1fmHEannvC6NiM1qw0YxVn26E8rDGhJbdgs+ea0s2qBomHzsQEqUdvmvMwqURcvXA 9Kaf3Amazh85XlalrEfYBgkLHTpfltnI1DSMj+z9+mZFUkX0sH25rpBzK+XozB+DDmMcBSDEJpET U2DbagakOY6GpsHWKx5teBPq+hWxflv6rkdY/JhMrWoCVDzQOKKjAuIG2FjQsKSCjhLooAMnqxBI IKHVXYBgiLy8Da2JINiNFYkg+fJ2QcaEqShQMYb86wrMHfI1skiikSlFWfrBQujqP8981SagTGf+ 7HKyfpfb46decpVRQ7ewojmtndNbDXQirkxsIiXIE0E3MLa8YYliO8CYGp9SH4YRXGcBuTdtLc3E vjaUINajXXm9lQgMY223Yojdm2C0Z10ytYoNO3FFpr8Ceczh6MjuNbmO6AzOwYZs+6SRnKM4FO8k QccdFeKVMdLuGdrcqpBdVpx2Et7iZIi07Q7A0rSrtJ6gSLl5SoXVuphYDK53Qazv8tCn2UxNAXPM wrCAkvExUZpiMgYfk0KSuIrcSGRaSJKeVcrEx1EHtF1vo1hltWslmJthQQlq1UflKqsQQwK2MCSJ mF9+JLUEQ6YXV0BkNeNUiCrFRNKXQM4JcFCE0DeMUQqkdfQtRNamcGrJkDU3GvXKTY3Ng9i0PUNJ GEpnlkiwqgs7u4zCUrT58do0cC9WwiV/KlFLgnzVUzHvsR980cu6eBCSJBf13YMx+PtM1oQ0qmiz 4fRm3No2WK83tJFvO900EdzQ2XWWIoeACpK9HF7ZrzMKNLpGBu/A3yMqmr7QyxcLz+D4tU6QLxBi Q2AOeEvLw6d8OpXbAUnWasdCkycroQVRx2x5gNOxB1t0FfK8PqRwPUgclMxXA2t/MjjNP/xdyRTh QkLAsG9U
signature.asc
Description: Digital signature
