Mailman 3 March 2007 - Python-checkins

r54643 - sandbox/trunk/pybch
by sean.reifschneider 01 Apr '07

01 Apr '07

Author: sean.reifschneider Date: Sat Mar 31 23:32:37 2007 New Revision: 54643 Removed: sandbox/trunk/pybch/ Log: Removing pybch, since I could never get the results to stabilize.

1 0

r54642 - sandbox/trunk/pybch/Tests/stringbench2.py
by sean.reifschneider 01 Apr '07

01 Apr '07

Author: sean.reifschneider Date: Sat Mar 31 23:26:25 2007 New Revision: 54642 Added: sandbox/trunk/pybch/Tests/stringbench2.py (contents, props changed) Log: Adding files in preparation for removing pybch. Added: sandbox/trunk/pybch/Tests/stringbench2.py ============================================================================== --- (empty file) +++ sandbox/trunk/pybch/Tests/stringbench2.py Sat Mar 31 23:26:25 2007 @@ -0,0 +1,1199 @@ + +# Various microbenchmarks comparing unicode and byte string performance + +import timeit +import itertools +import operator +import re +import sys +import datetime +import optparse +from TestHelpers import Test + +REPEAT = 1 +REPEAT = 3 +#REPEAT = 7 + +_RANGE_1000 = range(1) +_RANGE_1000 = range(1) +_RANGE_100 = range(1) +_RANGE_10 = range(1) + +dups = {} +def bench(s, group, repeat_count): + def blah(f): + if f.__name__ in dups: + raise AssertionError("Multiple functions with same name: %r" % + (f.__name__,)) + dups[f.__name__] = 1 + f.comment = s + f.is_bench = True + f.group = group + f.repeat_count = repeat_count + return f + return blah + +def uses_re(f): + f.uses_re = True + +####### 'in' comparisons + +@bench('"A" in "A"*1000', "early match, single character", 1000) +def in_test_quick_match_single_character(STR): + s1 = STR("A" * 1000) + s2 = STR("A") + for x in _RANGE_1000: + s2 in s1 + +@bench('"B" in "A"*1000', "no match, single character", 1000) +def in_test_no_match_single_character(STR): + s1 = STR("A" * 1000) + s2 = STR("B") + for x in _RANGE_1000: + s2 in s1 + + +@bench('"AB" in "AB"*1000', "early match, two characters", 1000) +def in_test_quick_match_two_characters(STR): + s1 = STR("AB" * 1000) + s2 = STR("AB") + for x in _RANGE_1000: + s2 in s1 + +@bench('"BC" in "AB"*1000', "no match, two characters", 1000) +def in_test_no_match_two_character(STR): + s1 = STR("AB" * 1000) + s2 = STR("BC") + for x in _RANGE_1000: + s2 in s1 + +@bench('"BC" in ("AB"*300+"C")', "late match, two characters", 1000) +def in_test_slow_match_two_characters(STR): + s1 = STR("AB" * 300+"C") + s2 = STR("BC") + for x in _RANGE_1000: + s2 in s1 + +@bench('s="ABC"*33; (s+"E") in ((s+"D")*300+s+"E")', + "late match, 100 characters", 100) +def in_test_slow_match_100_characters(STR): + m = STR("ABC"*33) + s1 = (m+"D")*300 + m+"E" + s2 = m+"E" + for x in _RANGE_100: + s2 in s1 + +# Try with regex +@uses_re +@bench('s="ABC"*33; re.compile(s+"D").search((s+"D")*300+s+"E")', + "late match, 100 characters", 100) +def re_test_slow_match_100_characters(STR): + m = STR("ABC"*33) + s1 = (m+"D")*300 + m+"E" + s2 = m+"E" + pat = re.compile(s2) + search = pat.search + for x in _RANGE_100: + search(s1) + + +#### same tests as 'in' but use 'find' + +# XXX: TODO: Add rfind + + + +@bench('("A"*1000).find("A")', "early match, single character", 1000) +def find_quick_match_single_character(STR): + s1 = STR("A" * 1000) + s2 = STR("A") + s1_find = s1.find + for x in _RANGE_1000: + s1_find(s2) + +@bench('("A"*1000).find("B")', "no match, single character", 1000) +def find_test_no_match_single_character(STR): + s1 = STR("A" * 1000) + s2 = STR("B") + s1_find = s1.find + for x in _RANGE_1000: + s1_find(s2) + + +@bench('("AB"*1000).find("AB")', "early match, two characters", 1000) +def find_test_quick_match_two_characters(STR): + s1 = STR("AB" * 1000) + s2 = STR("AB") + s1_find = s1.find + for x in _RANGE_1000: + s1_find(s2) + +@bench('("AB"*1000).find("BC")', "no match, two characters", 1000) +def find_test_no_match_two_character(STR): + s1 = STR("AB" * 1000) + s2 = STR("BC") + s1_find = s1.find + for x in _RANGE_1000: + s1_find(s2) + +@bench('("AB"*300+"C").find("BC")', "late match, two characters", 1000) +def find_test_slow_match_two_characters(STR): + s1 = STR("AB" * 300+"C") + s2 = STR("BC") + s1_find = s1.find + for x in _RANGE_1000: + s1_find(s2) + +@bench('s="ABC"*33; ((s+"D")*500+s+"E").find(s)', + "late match, 100 characters", 100) +def find_test_slow_match_100_characters(STR): + m = STR("ABC"*33) + s1 = (m+"D")*500 + m+"E" + s2 = m+"E" + s1_find = s1.find + for x in _RANGE_100: + s1_find(s2) + +#### Now with index. +# Skip the ones which fail because that would include exception overhead. +# Add rindex tests. + + +@bench('("A"*1000).index("A")', "early match, single character", 1000) +def index_test_quick_match_single_character(STR): + s1 = STR("A" * 1000) + s2 = STR("A") + s1_index = s1.index + for x in _RANGE_1000: + s1_index(s2) + + +@bench('("AB"*1000).index("AB")', "early match, two characters", 1000) +def index_test_quick_match_two_characters(STR): + s1 = STR("AB" * 1000) + s2 = STR("AB") + s1_index = s1.index + for x in _RANGE_1000: + s1_index(s2) + +@bench('("AB"*300+"C").index("BC")', "late match, two characters", 1000) +def index_test_slow_match_two_characters(STR): + s1 = STR("AB" * 300+"C") + s2 = STR("BC") + s1_index = s1.index + for x in _RANGE_1000: + s1_index(s2) + +@bench('s="ABC"*33; ((s+"D")*500+s+"E").index(s)', + "late match, 100 characters", 100) +def index_test_slow_match_100_characters(STR): + m = STR("ABC"*33) + s1 = (m+"D")*500 + m+"E" + s2 = m+"E" + s1_index = s1.index + for x in _RANGE_100: + s1_index(s2) + +#### Benchmark the operator-based methods + +@bench('"A"*10', "repeat 1 character 10 times", 1000) +def repeat_single_10_times(STR): + s = STR("A") + for x in _RANGE_1000: + s * 10 + +@bench('"A"*1000', "repeat 1 character 1000 times", 1000) +def repeat_single_1000_times(STR): + s = STR("A") + for x in _RANGE_1000: + s * 1000 + +@bench('"ABCDE"*10', "repeat 5 characters 10 times", 1000) +def repeat_5_10_times(STR): + s = STR("ABCDE") + for x in _RANGE_1000: + s * 10 + +@bench('"ABCDE"*1000', "repeat 5 characters 1000 times", 1000) +def repeat_5_1000_times(STR): + s = STR("ABCDE") + for x in _RANGE_1000: + s * 1000 + +# + for concat + +@bench('"Andrew"+"Dalke"', "concat two strings", 1000) +def concat_two_strings(STR): + s1 = STR("Andrew") + s2 = STR("Dalke") + for x in _RANGE_1000: + s1+s2 + +@bench('s1+s2+s3+s4+...+s20', "concat 20 strings of words length 4 to 15", + 1000) +def concat_many_strings(STR): + s1=STR('TIXSGYNREDCVBHJ') + s2=STR('PUMTLXBZVDO') + s3=STR('FVZNJ') + s4=STR('OGDXUW') + s5=STR('WEIMRNCOYVGHKB') + s6=STR('FCQTNMXPUZH') + s7=STR('TICZJYRLBNVUEAK') + s8=STR('REYB') + s9=STR('PWUOQ') + s10=STR('EQHCMKBS') + s11=STR('AEVDFOH') + s12=STR('IFHVD') + s13=STR('JGTCNLXWOHQ') + s14=STR('ITSKEPYLROZAWXF') + s15=STR('THEK') + s16=STR('GHPZFBUYCKMNJIT') + s17=STR('JMUZ') + s18=STR('WLZQMTB') + s19=STR('KPADCBW') + s20=STR('TNJHZQAGBU') + for x in _RANGE_1000: + (s1 + s2+ s3+ s4+ s5+ s6+ s7+ s8+ s9+s10+ + s11+s12+s13+s14+s15+s16+s17+s18+s19+s20) + + +#### Benchmark join + +@bench('"A".join("")', + "join empty string, with 1 character sep", 100) +def join_empty_single(STR): + sep = STR("A") + s2 = STR("") + sep_join = sep.join + for x in _RANGE_100: + sep_join(s2) + +@bench('"ABCDE".join("")', + "join empty string, with 5 character sep", 100) +def join_empty_5(STR): + sep = STR("ABCDE") + s2 = STR("") + sep_join = sep.join + for x in _RANGE_100: + sep_join(s2) + +@bench('"A".join("ABC..Z")', + "join string with 26 characters, with 1 character sep", 1000) +def join_alphabet_single(STR): + sep = STR("A") + s2 = STR("ABCDEFGHIJKLMnOPQRSTUVWXYZ") + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +@bench('"ABCDE".join("ABC..Z")', + "join string with 26 characters, with 5 character sep", 1000) +def join_alphabet_5(STR): + sep = STR("ABCDE") + s2 = STR("ABCDEFGHIJKLMnOPQRSTUVWXYZ") + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +@bench('"A".join(list("ABC..Z"))', + "join list of 26 characters, with 1 character sep", 1000) +def join_alphabet_list_single(STR): + sep = STR("A") + s2 = list(STR("ABCDEFGHIJKLMnOPQRSTUVWXYZ")) + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +@bench('"ABCDE".join(list("ABC..Z"))', + "join list of 26 characters, with 5 character sep", 1000) +def join_alphabet_list_five(STR): + sep = STR("ABCDE") + s2 = list(STR("ABCDEFGHIJKLMnOPQRSTUVWXYZ")) + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +@bench('"A".join(["Bob"]*100))', + "join list of 100 words, with 1 character sep", 1000) +def join_100_words_single(STR): + sep = STR("A") + s2 = [STR("Bob")]*100 + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +@bench('"ABCDE".join(["Bob"]*100))', + "join list of 100 words, with 5 character sep", 1000) +def join_100_words_5(STR): + sep = STR("ABCDE") + s2 = [STR("Bob")]*100 + sep_join = sep.join + for x in _RANGE_1000: + sep_join(s2) + +#### split tests + +@bench('("Here are some words. "*2).split()', "split whitespace (small)", 1000) +def whitespace_split(STR): + s = STR("Here are some words. "*2) + s_split = s.split + for x in _RANGE_1000: + s_split() + +@bench('("Here are some words. "*2).rsplit()', "split whitespace (small)", 1000) +def whitespace_rsplit(STR): + s = STR("Here are some words. "*2) + s_rsplit = s.rsplit + for x in _RANGE_1000: + s_rsplit() + +@bench('("Here are some words. "*2).split(None, 1)', + "split 1 whitespace", 1000) +def whitespace_split_1(STR): + s = STR("Here are some words. "*2) + s_split = s.split + N = None + for x in _RANGE_1000: + s_split(N, 1) + +@bench('("Here are some words. "*2).rsplit(None, 1)', + "split 1 whitespace", 1000) +def whitespace_rsplit_1(STR): + s = STR("Here are some words. "*2) + s_rsplit = s.rsplit + N = None + for x in _RANGE_1000: + s_rsplit(N, 1) + +human_text = """\ +Python is a dynamic object-oriented programming language that can be +used for many kinds of software development. It offers strong support +for integration with other languages and tools, comes with extensive +standard libraries, and can be learned in a few days. Many Python +programmers report substantial productivity gains and feel the language +encourages the development of higher quality, more maintainable code. + +Python runs on Windows, Linux/Unix, Mac OS X, OS/2, Amiga, Palm +Handhelds, and Nokia mobile phones. Python has also been ported to the +Java and .NET virtual machines. + +Python is distributed under an OSI-approved open source license that +makes it free to use, even for commercial products. +"""*25 +human_text_unicode = unicode(human_text) +def _get_human_text(STR): + if STR is unicode: + return human_text_unicode + if STR is str: + return human_text + raise AssertionError + +@bench('human_text.split()', "split whitespace (huge)", 10) +def whitespace_split_huge(STR): + s = _get_human_text(STR) + s_split = s.split + for x in _RANGE_10: + s_split() + +@bench('human_text.rsplit()', "split whitespace (huge)", 10) +def whitespace_rsplit_huge(STR): + s = _get_human_text(STR) + s_rsplit = s.rsplit + for x in _RANGE_10: + s_rsplit() + + + +@bench('"this\\nis\\na\\ntest\\n".split("\\n")', "split newlines", 1000) +def newlines_split(STR): + s = STR("this\nis\na\ntest\n") + s_split = s.split + for x in _RANGE_1000: + s_split("\n") + + +@bench('"this\\nis\\na\\ntest\\n".rsplit("\\n")', "split newlines", 1000) +def newlines_rsplit(STR): + s = STR("this\nis\na\ntest\n") + s_rsplit = s.rsplit + for x in _RANGE_1000: + s_rsplit("\n") + +@bench('"this\\nis\\na\\ntest\\n".splitlines()', "split newlines", 1000) +def newlines_splitlines(STR): + s = STR("this\nis\na\ntest\n") + s_splitlines = s.splitlines + for x in _RANGE_1000: + s_splitlines() + +## split text with 2000 newlines + +def _make_2000_lines(): + import random + r = random.Random(100) + chars = map(chr, range(32, 128)) + i = 0 + while i < len(chars): + chars[i] = " " + i += r.randrange(9) + s = "".join(chars) + s = s*4 + words = [] + for i in range(2000): + start = r.randrange(96) + n = r.randint(5, 65) + words.append(s[start:start+n]) + return "\n".join(words)+"\n" + +_text_with_2000_lines = _make_2000_lines() +_text_with_2000_lines_unicode = unicode(_text_with_2000_lines) +def _get_2000_lines(STR): + if STR is unicode: + return _text_with_2000_lines_unicode + if STR is str: + return _text_with_2000_lines + raise AssertionError + + +@bench('"...text...".split("\\n")', "split 2000 newlines", 10) +def newlines_split_2000(STR): + s = _get_2000_lines(STR) + s_split = s.split + for x in _RANGE_10: + s_split("\n") + +@bench('"...text...".rsplit("\\n")', "split 2000 newlines", 10) +def newlines_rsplit_2000(STR): + s = _get_2000_lines(STR) + s_rsplit = s.rsplit + for x in _RANGE_10: + s_rsplit("\n") + +@bench('"...text...".splitlines()', "split 2000 newlines", 10) +def newlines_splitlines_2000(STR): + s = _get_2000_lines(STR) + s_splitlines = s.splitlines + for x in _RANGE_10: + s_splitlines() + + +## split text on "--" characters +@bench( + '"this--is--a--test--of--the--emergency--broadcast--system".split("--")', + "split on multicharacter separator (small)", 1000) +def split_multichar_sep_small(STR): + s = STR("this--is--a--test--of--the--emergency--broadcast--system") + s_split = s.split + for x in _RANGE_1000: + s_split("--") +@bench( + '"this--is--a--test--of--the--emergency--broadcast--system".rsplit("--")', + "split on multicharacter separator (small)", 1000) +def rsplit_multichar_sep_small(STR): + s = STR("this--is--a--test--of--the--emergency--broadcast--system") + s_rsplit = s.rsplit + for x in _RANGE_1000: + s_rsplit("--") + +## split dna text on "ACTAT" characters +@bench('dna.split("ACTAT")', + "split on multicharacter separator (dna)", 10) +def split_multichar_sep_dna(STR): + s = _get_dna(STR) + s_split = s.split + for x in _RANGE_10: + s_split("ACTAT") + +@bench('dna.rsplit("ACTAT")', + "split on multicharacter separator (dna)", 10) +def rsplit_multichar_sep_dna(STR): + s = _get_dna(STR) + s_rsplit = s.rsplit + for x in _RANGE_10: + s_rsplit("ACTAT") + + + +## split with limits + +GFF3_example = "\t".join([ + "I", "Genomic_canonical", "region", "357208", "396183", ".", "+", ".", + "ID=Sequence:R119;note=Clone R119%3B Genbank AF063007;Name=R119"]) + +@bench('GFF3_example.split("\\t")', "tab split", 1000) +def tab_split_no_limit(STR): + s = STR(GFF3_example) + s_split = s.split + for x in _RANGE_1000: + s_split("\t") + +@bench('GFF3_example.split("\\t", 8)', "tab split", 1000) +def tab_split_limit(STR): + s = STR(GFF3_example) + s_split = s.split + for x in _RANGE_1000: + s_split("\t", 8) + +@bench('GFF3_example.rsplit("\\t")', "tab split", 1000) +def tab_rsplit_no_limit(STR): + s = STR(GFF3_example) + s_rsplit = s.rsplit + for x in _RANGE_1000: + s_rsplit("\t") + +@bench('GFF3_example.rsplit("\\t", 8)', "tab split", 1000) +def tab_rsplit_limit(STR): + s = STR(GFF3_example) + s_rsplit = s.rsplit + for x in _RANGE_1000: + s_rsplit("\t", 8) + +#### Count characters + +@bench('...text.with.2000.newlines.count("\\n")', + "count newlines", 10) +def count_newlines(STR): + s = _get_2000_lines(STR) + s_count = s.count + for x in _RANGE_10: + s_count("\n") + +# Orchid sequences concatenated, from Biopython +_dna = """ +CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGGGTT +AATCTGGAGGATCTGTTTACTTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGAATTGCCATCG +AGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGCAGTTTTGCTCCAAGTCGTT +TGACACATAATTGGTGAAGGGGGTGGCATCCTTCCCTGACCCTCCCCCAACTATTTTTTTAACAACTCTC +AGCAACGGAGACTCAGTCTTCGGCAAATGCGATAAATGGTGTGAATTGCAGAATCCCGTGCACCATCGAG +TCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCATTGCGAGTCATAT +CTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCGGATGTGAGTTTGGCCCCTTGTTCTT +TGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAGGTGGACGAACTAT +GCTACAACAAAATTGTTGTGCAGAGGCCCCGGGTTGTCGTATTAGATGGGCCACCGTAATCTGAAGACCC +TTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGCGACCCCAGGTCAG +GTGAGCAACAGCTGTCGTAACAAGGTTTCCGTAGGGTGAACTGCGGAAGGATCATTGTTGAGATCACATA +ATAATTGATCGAGTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGAC +CTAGATTTGCCATCGAGCCTCCTTGGGAGCATCCTTGTTGGCGATATCTAAACCCTCAATTTTTCCCCCA +ATCAAATTACACAAAATTGGTGGAGGGGGTGGCATTCTTCCCTTACCCTCCCCCAAATATTTTTTTAACA +ACTCTCAGCAACGGATATCTCAGCTCTTGCATCGATGAAGAACCCACCGAAATGCGATAAATGGTGTGAA +TTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACG +CCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCG +GATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGATGCATGGGCTTTTGATGGTCCTAA +ATACGGCAAGAGGTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATAAG +ATGGGCCACCGATATCTGAAGACCCTTTTGGACCCCATTGGAGCCCATCAACCCATGTCAGTTGATGGCC +ATTCGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGA +GTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCA +TCGAGCCTCCTTGGGAGCTTTCTTGTTGGCGATATCTAAACCCTTGCCCGGCAGAGTTTTGGGAATCCCG +TGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCAT +TGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACACACCTGTTCAGCCGGTGCGGATGTGAGTTTG +GCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAG +GTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATTAGATGGGCCACCAT +AATCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGC +GACCCAGTCAGGTGAGGGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGAG +TTAATCTGGAGGATCTGTTTACTTTGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCAT +CGAGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTTGGCGCCAAGTCA +TATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAACAACTC +TCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGAATTGC +AGAATCCCGTGAACCATCGAGTCTTTGGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCT +GCCTGGGCATTGGGAATCATATCTCTCCCCTAACGAGGCTATCCAAACATACTGTTCATCCGGTGCGGAT +GTGAGTTTGGCCCCTTGTTCTTTGGTACCGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTCAAAA +CGGCAAGAGGTGGACGAACTATGCCACAACAAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTAGATG +GGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGACCA +TTTGTTGCGACCCCAGTCAGCTGAGCAACCCGCTGAGTGGAAGGTCATTGCCGATATCACATAATAATTG +ATCGAGTTAATCTGGAGGATCTGTTTACTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGATTT +GCCATCGAGCCTCCTTGGGAGTTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTGTGCGCCA +AGTCATATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAAC +AACTCTCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGA +ATTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCAC +GCCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCATCCGGTGC +GGATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTC +AAAACGGCAAGAGGTGGACGAACTATGCTACAACCAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTA +GATGGGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATG +ACCATGTGTTGCGACCCCAGTCAGCTGAGCAACGCGCTGAGCGTAACAAGGTTTCCGTAGGTGGACCTCC +GGGAGGATCATTGTTGAGATCACATAATAATTGATCGAGGTAATCTGGAGGATCTGCATATTTTGGTCAC +""" +_dna = "".join(_dna.splitlines()) +_dna = _dna * 25 +_dna_unicode = unicode(_dna) + +def _get_dna(STR): + if STR is unicode: + return _dna_unicode + if STR is str: + return _dna + raise AssertionError + +@bench('dna.count("AACT")', "count AACT substrings in DNA example", 10) +def count_aact(STR): + seq = _get_dna(STR) + seq_count = seq.count + for x in _RANGE_10: + seq_count("AACT") + +##### startswith and endswith + +@bench('"Andrew".startswith("A")', 'startswith single character', 1000) +def startswith_single(STR): + s1 = STR("Andrew") + s2 = STR("A") + s1_startswith = s1.startswith + for x in _RANGE_1000: + s1_startswith(s2) + +@bench('"Andrew".startswith("Andrew")', 'startswith multiple characters', + 1000) +def startswith_multiple(STR): + s1 = STR("Andrew") + s2 = STR("Andrew") + s1_startswith = s1.startswith + for x in _RANGE_1000: + s1_startswith(s2) + +@bench('"Andrew".startswith("Anders")', + 'startswith multiple characters - not!', 1000) +def startswith_multiple_not(STR): + s1 = STR("Andrew") + s2 = STR("Anders") + s1_startswith = s1.startswith + for x in _RANGE_1000: + s1_startswith(s2) + + +# endswith + +@bench('"Andrew".endswith("w")', 'endswith single character', 1000) +def endswith_single(STR): + s1 = STR("Andrew") + s2 = STR("w") + s1_endswith = s1.endswith + for x in _RANGE_1000: + s1_endswith(s2) + +@bench('"Andrew".endswith("Andrew")', 'endswith multiple characters', 1000) +def endswith_multiple(STR): + s1 = STR("Andrew") + s2 = STR("Andrew") + s1_endswith = s1.endswith + for x in _RANGE_1000: + s1_endswith(s2) + +@bench('"Andrew".endswith("Anders")', + 'endswith multiple characters - not!', 1000) +def endswith_multiple_not(STR): + s1 = STR("Andrew") + s2 = STR("Anders") + s1_endswith = s1.endswith + for x in _RANGE_1000: + s1_endswith(s2) + +#### Strip + +@bench('"Hello!\\n".strip()', 'strip terminal newline', 1000) +def terminal_newline_strip_right(STR): + s = STR("Hello!\n") + s_strip = s.strip + for x in _RANGE_1000: + s_strip() + +@bench('"Hello!\\n".rstrip()', 'strip terminal newline', 1000) +def terminal_newline_rstrip(STR): + s = STR("Hello!\n") + s_rstrip = s.rstrip + for x in _RANGE_1000: + s_rstrip() + +@bench('"\\nHello!".strip()', 'strip terminal newline', 1000) +def terminal_newline_strip_left(STR): + s = STR("\nHello!") + s_strip = s.strip + for x in _RANGE_1000: + s_strip() + +@bench('"\\nHello!\\n".strip()', 'strip terminal newline', 1000) +def terminal_newline_strip_both(STR): + s = STR("\nHello!\n") + s_strip = s.strip + for x in _RANGE_1000: + s_strip() + +@bench('"\\nHello!".rstrip()', 'strip terminal newline', 1000) +def terminal_newline_lstrip(STR): + s = STR("\nHello!") + s_lstrip = s.lstrip + for x in _RANGE_1000: + s_lstrip() + +# Strip multiple spaces or tabs + +@bench('"Hello\\t \\t".strip()', 'strip terminal spaces and tabs', 1000) +def terminal_space_strip(STR): + s = STR("Hello\t \t!") + s_strip = s.strip + for x in _RANGE_1000: + s_strip() + +@bench('"Hello\\t \\t".rstrip()', 'strip terminal spaces and tabs', 1000) +def terminal_space_rstrip(STR): + s = STR("Hello!\t \t") + s_rstrip = s.rstrip + for x in _RANGE_1000: + s_rstrip() + +@bench('"\\t \\tHello".rstrip()', 'strip terminal spaces and tabs', 1000) +def terminal_space_lstrip(STR): + s = STR("\t \tHello!") + s_lstrip = s.lstrip + for x in _RANGE_1000: + s_lstrip() + + +#### replace +@bench('"This is a test".replace(" ", "\\t")', 'replace single character', + 1000) +def replace_single_character(STR): + s = STR("This is a test!") + from_str = STR(" ") + to_str = STR("\t") + s_replace = s.replace + for x in _RANGE_1000: + s_replace(from_str, to_str) + +@uses_re +@bench('re.sub(" ", "\\t", "This is a test"', 'replace single character', + 1000) +def replace_single_character_re(STR): + s = STR("This is a test!") + pat = re.compile(STR(" ")) + to_str = STR("\t") + pat_sub = pat.sub + for x in _RANGE_1000: + pat_sub(to_str, s) + +@bench('"...text.with.2000.lines...replace("\\n", " ")', + 'replace single character, big string', 10) +def replace_single_character_big(STR): + s = _get_2000_lines(STR) + from_str = STR("\n") + to_str = STR(" ") + s_replace = s.replace + for x in _RANGE_10: + s_replace(from_str, to_str) + +@uses_re +@bench('re.sub("\\n", " ", "...text.with.2000.lines...")', + 'replace single character, big string', 10) +def replace_single_character_big_re(STR): + s = _get_2000_lines(STR) + pat = re.compile(STR("\n")) + to_str = STR(" ") + pat_sub = pat.sub + for x in _RANGE_10: + pat_sub(to_str, s) + + +@bench('dna.replace("ATC", "ATT")', + 'replace multiple characters, dna', 10) +def replace_multiple_characters_dna(STR): + seq = _get_dna(STR) + from_str = STR("ATC") + to_str = STR("ATT") + seq_replace = seq.replace + for x in _RANGE_10: + seq_replace(from_str, to_str) + +# This increases the character count +@bench('"...text.with.2000.newlines...replace("\\n", "\\r\\n")', + 'replace and expand multiple characters, big string', 10) +def replace_multiple_character_big(STR): + s = _get_2000_lines(STR) + from_str = STR("\n") + to_str = STR("\r\n") + s_replace = s.replace + for x in _RANGE_10: + s_replace(from_str, to_str) + + +# This decreases the character count +@bench('"When shall we three meet again?".replace("ee", "")', + 'replace/remove multiple characters', 1000) +def replace_multiple_character_remove(STR): + s = STR("When shall we three meet again?") + from_str = STR("ee") + to_str = STR("") + s_replace = s.replace + for x in _RANGE_1000: + s_replace(from_str, to_str) + + +big_s = "A" + ("Z"*128*1024) +big_s_unicode = unicode(big_s) +def _get_big_s(STR): + if STR is unicode: return big_s_unicode + if STR is str: return big_s + raise AssertionError + +# The older replace implementation counted all matches in +# the string even when it only neeed to make one replacement. +@bench('("A" + ("Z"*128*1024)).replace("A", "BB", 1)', + 'quick replace single character match', 10) +def quick_replace_single_match(STR): + s = _get_big_s(STR) + from_str = STR("A") + to_str = STR("BB") + s_replace = s.replace + for x in _RANGE_10: + s_replace(from_str, to_str, 1) + +@bench('("A" + ("Z"*128*1024)).replace("AZZ", "BBZZ", 1)', + 'quick replace multiple character match', 10) +def quick_replace_multiple_match(STR): + s = _get_big_s(STR) + from_str = STR("AZZ") + to_str = STR("BBZZ") + s_replace = s.replace + for x in _RANGE_10: + s_replace(from_str, to_str, 1) + + +#### + +# CCP does a lot of this, for internationalisation of ingame messages. +_format = "The %(thing)s is %(place)s the %(location)s." +_format_dict = { "thing":"THING", "place":"PLACE", "location":"LOCATION", } +_format_unicode = unicode(_format) +_format_dict_unicode = dict([ (unicode(k), unicode(v)) for (k,v) in _format_dict.iteritems() ]) + +def _get_format(STR): + if STR is unicode: + return _format_unicode + if STR is str: + return _format + raise AssertionError + +def _get_format_dict(STR): + if STR is unicode: + return _format_dict_unicode + if STR is str: + return _format_dict + raise AssertionError + +# Formatting. +@bench('"The %(k1)s is %(k2)s the %(k3)s."%{"k1":"x","k2":"y","k3":"z",}', + 'formatting a string type with a dict', 1000) +def format_with_dict(STR): + s = _get_format(STR) + d = _get_format_dict(STR) + for x in _RANGE_1000: + s % d + + +#### Upper- and lower- case conversion + +@bench('("Where in the world is Carmen San Deigo?"*10).lower()', + "case conversion -- rare", 1000) +def lower_conversion_rare(STR): + s = STR("Where in the world is Carmen San Deigo?"*10) + s_lower = s.lower + for x in _RANGE_1000: + s_lower() + +@bench('("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10).lower()', + "case conversion -- dense", 1000) +def lower_conversion_dense(STR): + s = STR("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10) + s_lower = s.lower + for x in _RANGE_1000: + s_lower() + + +@bench('("wHERE IN THE WORLD IS cARMEN sAN dEIGO?"*10).upper()', + "case conversion -- rare", 1000) +def upper_conversion_rare(STR): + s = STR("Where in the world is Carmen San Deigo?"*10) + s_upper = s.upper + for x in _RANGE_1000: + s_upper() + +@bench('("where in the world is carmen san deigo?"*10).upper()', + "case conversion -- dense", 1000) +def upper_conversion_dense(STR): + s = STR("where in the world is carmen san deigo?"*10) + s_upper = s.upper + for x in _RANGE_1000: + s_upper() + + +# end of benchmarks + +################# + +class BenchTimer(timeit.Timer): + def best(self, repeat=1): + for i in range(1, 10): + number = 10**i + try: + x = self.timeit(number) + except: + self.print_exc() + raise + if x > 0.2: + break + times = [x] + for i in range(1, repeat): + times.append(self.timeit(number)) + return min(times) / number + +def main(): + (options, test_names) = parser.parse_args() + if options.str_only and options.unicode_only: + raise SystemExit("Only one of --8-bit and --unicode are allowed") + + bench_functions = [] + for (k,v) in globals().items(): + if hasattr(v, "is_bench"): + if test_names: + for name in test_names: + if name in v.group: + break + else: + # Not selected, ignore + continue + if options.skip_re and hasattr(v, "uses_re"): + continue + + bench_functions.append( (v.group, k, v) ) + bench_functions.sort() + + print "string\tunicode" + print "(in ms)\t(in ms)\t%\tcomment" + + str_total = uni_total = 0.0 + + for title, group in itertools.groupby(bench_functions, + operator.itemgetter(0)): + print 'class', title.replace(' ', '_').replace('-', '_') + '_Str', '(Test):' + print ' def test(self):' + groupList = list(group) + for g in groupList: + s = repr(g).split('<function ')[1] + s = s.split()[0] + print ' ', s, '(str)' + + print 'class', title.replace(' ', '_').replace('-', '_') + '_Unicode', '(Test):' + print ' def test(self):' + for g in groupList: + s = repr(g).split('<function ')[1] + s = s.split()[0] + print ' ', s, '(unicode)' + sys.exit(0) + for title, group in itertools.groupby(bench_functions, + operator.itemgetter(0)): + print "="*10, title + for (_, k, v) in group: + if hasattr(v, "is_bench"): + if not options.unicode_only: + str_time = BenchTimer("__main__.%s(str)" % (k,), + "import __main__").best(REPEAT) + else: + str_time = 0.0 + if not options.str_only: + uni_time = BenchTimer("__main__.%s(unicode)" % (k,), + "import __main__").best(REPEAT) + else: + uni_time = 0.0 + try: + average = str_time/uni_time + except ZeroDivisionError: + average = 0.0 + print "%.2f\t%.2f\t%.1f\t%s (*%d)" % ( + 1000*str_time, 1000*uni_time, 100.*average, + v.comment, v.repeat_count) + + str_total += str_time + uni_total += uni_time + + if str_total == uni_total == 0.0: + print "That was zippy!" + else: + try: + ratio = str_time/uni_time + except ZeroDivisionError: + ratio = 0.0 + print "%.2f\t%.2f\t%.1f\t%s" % ( + 1000*str_total, 1000*uni_total, 100.*ratio, + "TOTAL") + +if __name__ == "__main__": + main() + + +class Stringbench_Part_1(Test): + def test(self): + for i in xrange(self.rounds): + lower_conversion_dense (str) + upper_conversion_dense (str) + lower_conversion_dense (unicode) + upper_conversion_dense (unicode) + lower_conversion_rare (str) + upper_conversion_rare (str) + lower_conversion_rare (unicode) + upper_conversion_rare (unicode) + concat_many_strings (str) + concat_many_strings (unicode) + concat_two_strings (str) + concat_two_strings (unicode) + count_aact (str) + count_aact (unicode) + count_newlines (str) + count_newlines (unicode) +class Stringbench_Part_2(Test): + def test(self): + for i in xrange(self.rounds): + find_quick_match_single_character (str) + in_test_quick_match_single_character (str) + index_test_quick_match_single_character (str) + find_quick_match_single_character (unicode) + in_test_quick_match_single_character (unicode) + index_test_quick_match_single_character (unicode) + find_test_quick_match_two_characters (str) + in_test_quick_match_two_characters (str) + index_test_quick_match_two_characters (str) + find_test_quick_match_two_characters (unicode) + in_test_quick_match_two_characters (unicode) + index_test_quick_match_two_characters (unicode) + endswith_multiple (str) + endswith_multiple (unicode) + endswith_multiple_not (str) + endswith_multiple_not (unicode) + endswith_single (str) + endswith_single (unicode) + format_with_dict (str) + format_with_dict (unicode) + join_empty_single (str) + join_empty_single (unicode) + join_empty_5 (str) + join_empty_5 (unicode) + join_100_words_single (str) + join_100_words_single (unicode) + join_100_words_5 (str) + join_100_words_5 (unicode) + join_alphabet_list_single (str) + join_alphabet_list_single (unicode) + join_alphabet_list_five (str) + join_alphabet_list_five (unicode) + join_alphabet_single (str) + join_alphabet_single (unicode) + join_alphabet_5 (str) + join_alphabet_5 (unicode) +class Stringbench_Part_3(Test): + def test(self): + for i in xrange(self.rounds): + find_test_slow_match_100_characters (str) + in_test_slow_match_100_characters (str) + index_test_slow_match_100_characters (str) + find_test_slow_match_100_characters (unicode) + in_test_slow_match_100_characters (unicode) + index_test_slow_match_100_characters (unicode) + find_test_slow_match_two_characters (str) + in_test_slow_match_two_characters (str) + index_test_slow_match_two_characters (str) + find_test_slow_match_two_characters (unicode) + in_test_slow_match_two_characters (unicode) +class Stringbench_Part_4(Test): + def test(self): + for i in xrange(self.rounds): + index_test_slow_match_two_characters (unicode) + find_test_no_match_single_character (str) + in_test_no_match_single_character (str) + find_test_no_match_single_character (unicode) + in_test_no_match_single_character (unicode) + find_test_no_match_two_character (str) + in_test_no_match_two_character (str) + find_test_no_match_two_character (unicode) + in_test_no_match_two_character (unicode) + quick_replace_multiple_match (str) + quick_replace_multiple_match (unicode) + quick_replace_single_match (str) + quick_replace_single_match (unicode) + repeat_single_10_times (str) + repeat_single_10_times (unicode) + repeat_single_1000_times (str) + repeat_single_1000_times (unicode) + repeat_5_10_times (str) + repeat_5_10_times (unicode) + repeat_5_1000_times (str) + repeat_5_1000_times (unicode) + replace_multiple_character_big (str) + replace_multiple_character_big (unicode) + replace_multiple_characters_dna (str) + replace_multiple_characters_dna (unicode) + replace_single_character (str) + replace_single_character (unicode) + replace_single_character_big (str) + replace_single_character_big (unicode) + replace_multiple_character_remove (str) + replace_multiple_character_remove (unicode) + whitespace_rsplit_1 (str) + whitespace_split_1 (str) + whitespace_rsplit_1 (unicode) + whitespace_split_1 (unicode) + newlines_rsplit_2000 (str) + newlines_split_2000 (str) + newlines_splitlines_2000 (str) + newlines_rsplit_2000 (unicode) + newlines_split_2000 (unicode) + newlines_splitlines_2000 (unicode) + newlines_rsplit (str) + newlines_split (str) + newlines_splitlines (str) + newlines_rsplit (unicode) + newlines_split (unicode) + newlines_splitlines (unicode) + rsplit_multichar_sep_dna (str) + split_multichar_sep_dna (str) + rsplit_multichar_sep_dna (unicode) + split_multichar_sep_dna (unicode) + rsplit_multichar_sep_small (str) + split_multichar_sep_small (str) + rsplit_multichar_sep_small (unicode) + split_multichar_sep_small (unicode) +class Stringbench_Part_5(Test): + def test(self): + for i in xrange(self.rounds): + whitespace_rsplit_huge (str) + whitespace_split_huge (str) + whitespace_rsplit_huge (unicode) + whitespace_split_huge (unicode) + whitespace_rsplit (str) + whitespace_split (str) + whitespace_rsplit (unicode) + whitespace_split (unicode) + startswith_multiple (str) + startswith_multiple (unicode) + startswith_multiple_not (str) + startswith_multiple_not (unicode) + startswith_single (str) + startswith_single (unicode) + terminal_newline_lstrip (str) + terminal_newline_rstrip (str) + terminal_newline_strip_both (str) + terminal_newline_strip_left (str) + terminal_newline_strip_right (str) + terminal_newline_lstrip (unicode) + terminal_newline_rstrip (unicode) + terminal_newline_strip_both (unicode) + terminal_newline_strip_left (unicode) + terminal_newline_strip_right (unicode) + terminal_space_lstrip (str) + terminal_space_rstrip (str) + terminal_space_strip (str) + terminal_space_lstrip (unicode) + terminal_space_rstrip (unicode) + terminal_space_strip (unicode) + tab_rsplit_limit (str) + tab_rsplit_no_limit (str) + tab_split_limit (str) + tab_split_no_limit (str) + tab_rsplit_limit (unicode) + tab_rsplit_no_limit (unicode) + tab_split_limit (unicode) + tab_split_no_limit (unicode)

1 0

r54641 - python/branches/release25-maint/Lib/distutils/__init__.py
by marc-andre.lemburg 01 Apr '07

01 Apr '07

Author: marc-andre.lemburg Date: Sat Mar 31 23:02:43 2007 New Revision: 54641 Modified: python/branches/release25-maint/Lib/distutils/__init__.py Log: Bump the patch level version of distutils since there were a few bug fixes since the 2.5.0 release. Backport of r54615. Modified: python/branches/release25-maint/Lib/distutils/__init__.py ============================================================================== --- python/branches/release25-maint/Lib/distutils/__init__.py (original) +++ python/branches/release25-maint/Lib/distutils/__init__.py Sat Mar 31 23:02:43 2007 @@ -20,4 +20,4 @@ # In general, major and minor version should loosely follow the Python # version number the distutils code was shipped with. # -__version__ = "2.5.0" +__version__ = "2.5.1"

1 0

buildbot warnings in ia64 Ubuntu trunk trunk
by buildbot＠python.org 01 Apr '07

01 Apr '07

The Buildbot has detected a new failure of ia64 Ubuntu trunk trunk. Full details are available at: http://www.python.org/dev/buildbot/all/ia64%2520Ubuntu%2520trunk%2520trunk/… Buildbot URL: http://www.python.org/dev/buildbot/all/ Build Reason: Build Source Stamp: [branch trunk] HEAD Blamelist: collin.winter Build had warnings: warnings failed slave lost sincerely, -The Buildbot

1 0

r54640 - sandbox/trunk/abc
by guido.van.rossum 01 Apr '07

01 Apr '07

Author: guido.van.rossum Date: Sat Mar 31 22:45:45 2007 New Revision: 54640 Modified: sandbox/trunk/abc/ (props changed) Log: Set the standard svn:ignore property.

1 0

r54639 - sandbox/trunk/abc/abc.py
by guido.van.rossum 01 Apr '07

01 Apr '07

Author: guido.van.rossum Date: Sat Mar 31 22:31:05 2007 New Revision: 54639 Modified: sandbox/trunk/abc/abc.py Log: Reindent using 4-space indents. Modified: sandbox/trunk/abc/abc.py ============================================================================== --- sandbox/trunk/abc/abc.py (original) +++ sandbox/trunk/abc/abc.py Sat Mar 31 22:31:05 2007 @@ -18,82 +18,82 @@ def abstractmethod(funcobj): - """A decorator indicating abstract methods. + """A decorator indicating abstract methods. - Requires that the class (directly or indirectly) derives from - Abstract, and that the metaclass is AbstractClass or derived from it - (deriving from Abstract ensure this). A class deriving from - Abstract cannot be instantiated unless all of its abstract methods - are overridden. The abstract methods can be called using any of the - the normal 'super' call mechanisms. - - Usage: - - class C(Abstract): - @abstractmethod - def my_abstract_method(self, ...): - ... - - When combining this with other decorators, this should come last: - - class C(Abstract): - @classmethod - @abstractmethod - def my_abstract_class_method(self, ...): - ... - """ - funcobj.__abstractmethod__ = True - return funcobj + Requires that the class (directly or indirectly) derives from + Abstract, and that the metaclass is AbstractClass or derived from it + (deriving from Abstract ensure this). A class deriving from + Abstract cannot be instantiated unless all of its abstract methods + are overridden. The abstract methods can be called using any of the + the normal 'super' call mechanisms. + + Usage: + + class C(Abstract): + @abstractmethod + def my_abstract_method(self, ...): + ... + + When combining this with other decorators, this should come last: + + class C(Abstract): + @classmethod + @abstractmethod + def my_abstract_class_method(self, ...): + ... + """ + funcobj.__abstractmethod__ = True + return funcobj class AbstractClass(type): - """Metaclass to support the abstractmethod decorator.""" + """Metaclass to support the abstractmethod decorator.""" - def __new__(mcls, name, bases, namespace): - cls = super(AbstractClass, mcls).__new__(mcls, name, bases, namespace) - abstracts = set() - for base in bases: - abstracts.update(getattr(base, "__abstractmethods__", set())) - for name, value in namespace.items(): - if getattr(value, "__abstractmethod__", False): - abstracts.add(name) - cls.__abstractmethods__ = abstracts - return cls + def __new__(mcls, name, bases, namespace): + cls = super(AbstractClass, mcls).__new__(mcls, name, bases, namespace) + abstracts = set() + for base in bases: + abstracts.update(getattr(base, "__abstractmethods__", set())) + for name, value in namespace.items(): + if getattr(value, "__abstractmethod__", False): + abstracts.add(name) + cls.__abstractmethods__ = abstracts + return cls class AbstractInstantiationError(TypeError): - """Exception raised when an abstract class is instantiated.""" + """Exception raised when an abstract class is instantiated.""" - def __init__(self, abstract_methods): - TypeError.__init__(self) - self.abstract_methods = abstract_methods - - def __str__(self): - msg = ", ".join(sorted(self.abstract_methods)) - return "Can't instantiate class with abstract method(s) %s" % msg + def __init__(self, abstract_methods): + TypeError.__init__(self) + self.abstract_methods = abstract_methods + + def __str__(self): + msg = ", ".join(sorted(self.abstract_methods)) + return "Can't instantiate class with abstract method(s) %s" % msg - def __repr__(self): - return "AbstractInstantiationError(%r)" % (self.abstract_methods,) + def __repr__(self): + return "AbstractInstantiationError(%r)" % (self.abstract_methods,) class Abstract(metaclass=AbstractClass): - """Base class to support the abstractmethod decorator. + """Base class to support the abstractmethod decorator. - This implicitly sets the metaclass to AbstractClass. - """ + This implicitly sets the metaclass to AbstractClass. + """ - def __new__(cls): - bad = set() - for name in cls.__abstractmethods__: - value = getattr(cls, name, None) - if getattr(value, "__abstractmethod__", False): - bad.add(name) - if bad: - raise AbstractInstantiationError(bad) - return super(Abstract, cls).__new__(cls) + def __new__(cls): + bad = set() + for name in cls.__abstractmethods__: + value = getattr(cls, name, None) + if getattr(value, "__abstractmethod__", False): + bad.add(name) + if bad: + raise AbstractInstantiationError(bad) + return super(Abstract, cls).__new__(cls) ### BASICS ### @@ -101,39 +101,39 @@ class Hashable(Abstract): - """A hashable has one method, __hash__().""" + """A hashable has one method, __hash__().""" - @abstractmethod - def __hash__(self): - return 0 + @abstractmethod + def __hash__(self): + return 0 class Iterable(Abstract): - """An iterable has one method, __iter__().""" + """An iterable has one method, __iter__().""" - @abstractmethod - def __iter__(self): - return Iterator() + @abstractmethod + def __iter__(self): + return Iterator() class Iterator(Iterable): - """An iterator has two methods, __iter__() and next().""" + """An iterator has two methods, __iter__() and next().""" - @abstractmethod - def next(self): - raise StopIteration + @abstractmethod + def next(self): + raise StopIteration - def __iter__(self): - return self + def __iter__(self): + return self class Sizeable(Abstract): - @abstractmethod - def __len__(self): - return 0 + @abstractmethod + def __len__(self): + return 0 ### SETS ### @@ -141,101 +141,101 @@ class BasicSet(Abstract): - # XXX Alternative name: Container? Oracle (as in Delphi's Oracle)? + # XXX Alternative name: Container? Oracle (as in Delphi's Oracle)? - """A basic set has __contains__() and that's it.""" + """A basic set has __contains__() and that's it.""" - @abstractmethod - def __contains__(self, elem): - return False + @abstractmethod + def __contains__(self, elem): + return False class IterableSet(BasicSet, Iterable): - """An iterable set is a basic set that is also iterable. + """An iterable set is a basic set that is also iterable. - It may not have a length though; it may be infinite! + It may not have a length though; it may be infinite! - XXX Do we care about potentially infinite sets, or sets of - indeterminate size? - """ + XXX Do we care about potentially infinite sets, or sets of + indeterminate size? + """ class SizeableSet(IterableSet, Sizeable): - """A sizeable set is an iterable set that has a finite, known size. + """A sizeable set is an iterable set that has a finite, known size. - This enables a generic implementation of equality and ordering based - on set inclusion. + This enables a generic implementation of equality and ordering based + on set inclusion. - I don't see a use case for a non-iterable set that has a size. + I don't see a use case for a non-iterable set that has a size. - The idea here is that all you have to do is redefine __le__ and then - the other operations will automatically follow suit. - """ - - def __le__(self, other): - if not isinstance(other, SizeableSet): - return NotImplemented - if len(self) > len(other): - return False - for elem in self: - if elem not in other: - return False - return True + The idea here is that all you have to do is redefine __le__ and then + the other operations will automatically follow suit. + """ - def __lt__(self, other): - if not isinstance(other, SizeableSet): - return NotImplemented - return len(self) < len(other) and self.__le__(other) - - def __eq__(self, other): - if not isinstance(other, SizeableSet): - return NotImplemented - return len(self) == len(other) and self.__le__(other) - - # XXX Should we define __ge__ and __gt__ too? - - # XXX The following implementations of &, |, ^, - return frozen sets - # because we have to pick a concrete type. They are allowed to - # return any subclass of SizeableSet (but SizeableSet is not a - # concrete implementation). - - def __and__(self, other): - new = set(self) - new.intersection_update(other) - return frozenset(new) - - def __or__(self, other): - new = set(self) - new.update(other) - return frozenset(new) - - def __xor__(self, other): - new = set(self) - new.symmetric_difference_update(other) - return frozenset(new) - - def __sub__(self, other): - new = set(self) - new.difference_update(other) - return frozenset(new) + def __le__(self, other): + if not isinstance(other, SizeableSet): + return NotImplemented + if len(self) > len(other): + return False + for elem in self: + if elem not in other: + return False + return True + + def __lt__(self, other): + if not isinstance(other, SizeableSet): + return NotImplemented + return len(self) < len(other) and self.__le__(other) + + def __eq__(self, other): + if not isinstance(other, SizeableSet): + return NotImplemented + return len(self) == len(other) and self.__le__(other) + + # XXX Should we define __ge__ and __gt__ too? + + # XXX The following implementations of &, |, ^, - return frozen sets + # because we have to pick a concrete type. They are allowed to + # return any subclass of SizeableSet (but SizeableSet is not a + # concrete implementation). + + def __and__(self, other): + new = set(self) + new.intersection_update(other) + return frozenset(new) + + def __or__(self, other): + new = set(self) + new.update(other) + return frozenset(new) + + def __xor__(self, other): + new = set(self) + new.symmetric_difference_update(other) + return frozenset(new) + + def __sub__(self, other): + new = set(self) + new.difference_update(other) + return frozenset(new) class HashableSet(SizeableSet, Hashable): - def __hash__(self): - """The hash value must match __eq__. + def __hash__(self): + """The hash value must match __eq__. - All sets ought to compare equal if they contain the same elements, - regardless of how they are implemented, and regardless of the - order of the elements; so there's not much freedom for __eq__ or - __hash__. We just XOR the hash of the elements. - """ - h = 0 - for elem in self: - h ^= hash(elem) - return h + All sets ought to compare equal if they contain the same elements, + regardless of how they are implemented, and regardless of the + order of the elements; so there's not much freedom for __eq__ or + __hash__. We just XOR the hash of the elements. + """ + h = 0 + for elem in self: + h ^= hash(elem) + return h # class set(SizeableSet) @@ -247,157 +247,157 @@ class BasicMapping(Abstract): - # XXX derive from (BasicSet)? + # XXX derive from (BasicSet)? - """A basic mapping has __getitem__(), __contains__() and get(). + """A basic mapping has __getitem__(), __contains__() and get(). - The idea is that you only need to override __getitem__(). + The idea is that you only need to override __getitem__(). - Other dict methods are not supported. - """ + Other dict methods are not supported. + """ - @abstractmethod - def __getitem__(self, key): - raise KeyError - - def get(self, key, default=None): - try: - return self[key] - except KeyError: - return default - - def __contains__(self, key): - try: - self[key] - return True - except KeyError: - return False + @abstractmethod + def __getitem__(self, key): + raise KeyError + + def get(self, key, default=None): + try: + return self[key] + except KeyError: + return default + + def __contains__(self, key): + try: + self[key] + return True + except KeyError: + return False class IterableMapping(BasicMapping, Iterable): - def keys(self): - return KeysView(self) + def keys(self): + return KeysView(self) - def items(self): - return ItemsView(self) + def items(self): + return ItemsView(self) - def values(self): - return ValuesView(self) + def values(self): + return ValuesView(self) class _MappingView: - def __init__(self, mapping): - self._mapping = mapping + def __init__(self, mapping): + self._mapping = mapping class KeysView(_MappingView, BasicSet): - def __iter__(self): - for key in self._mapping: - yield key + def __iter__(self): + for key in self._mapping: + yield key - def __contains__(self, key): - return key in self._mapping + def __contains__(self, key): + return key in self._mapping class ItemsView(_MappingView, BasicSet): - def __iter__(self): - for key in self._mapping: - yield key, self._mapping[key] - - def __contains__(self, item): - try: - key, value = item - except: - return False - try: - val = self._mapping[key] - except KeyError: - return False - return value == val + def __iter__(self): + for key in self._mapping: + yield key, self._mapping[key] + + def __contains__(self, item): + try: + key, value = item + except: + return False + try: + val = self._mapping[key] + except KeyError: + return False + return value == val class ValuesView(_MappingView): - # Note: does not derive from BasicSet, and does not implement __contains__! + # Note: does not derive from BasicSet, and does not implement __contains__! - def __iter__(self): - for key in self._mapping: - yield self._mapping[key] + def __iter__(self): + for key in self._mapping: + yield self._mapping[key] class SizeableMapping(IterableMapping, Sizeable): - def keys(self): - return SizeableKeysView(self) + def keys(self): + return SizeableKeysView(self) - def items(self): - return SizeableItemsView(self) + def items(self): + return SizeableItemsView(self) - def values(self): - return SizeableValuesView(self) + def values(self): + return SizeableValuesView(self) - def __eq__(self, other): - if not isinstance(other, SizeableMapping): - return NotImplemented - if len(other) != len(self): - return False - # XXX Or: for key, value1 in self.items(): ? - for key in self: - value1 = self[key] - try: - value2 = other[key] - except KeyError: - return False - if value1 != value2: - return False - return True + def __eq__(self, other): + if not isinstance(other, SizeableMapping): + return NotImplemented + if len(other) != len(self): + return False + # XXX Or: for key, value1 in self.items(): ? + for key in self: + value1 = self[key] + try: + value2 = other[key] + except KeyError: + return False + if value1 != value2: + return False + return True class _SizeableMappingView(_MappingView, Sizeable): - def __len__(self): - return len(self._mapping) + def __len__(self): + return len(self._mapping) class SizeableKeysView(_SizeableMappingView, KeysView, SizeableSet): - pass + pass class SizeableItemsView(_SizeableMappingView, ItemsView, SizeableSet): - pass + pass class SizeableValuesView(_SizeableMappingView, ValuesView): - def __eq__(self, other): - if not (isinstance(other, Sizeable) and isinstance(other, Iterable)): - return NotImplemented - if len(self) != len(other): - return False - # XXX This is slow. Sometimes this could be optimized, but these - # are the semantics: we can't depend on the values to be hashable - # or comparable. - o_values = list(other) - for value in self: - for i, o_value in enumerate(o_values): - if value == o_value: - del o_values[i] - break - else: - return False - assert not o_values # self must have mutated somehow - return True - - def __contains__(self, value): - # This is slow, but these are the semantics. - for elem in self: - if elem == value: + def __eq__(self, other): + if not (isinstance(other, Sizeable) and isinstance(other, Iterable)): + return NotImplemented + if len(self) != len(other): + return False + # XXX This is slow. Sometimes this could be optimized, but these + # are the semantics: we can't depend on the values to be hashable + # or comparable. + o_values = list(other) + for value in self: + for i, o_value in enumerate(o_values): + if value == o_value: + del o_values[i] + break + else: + return False + assert not o_values # self must have mutated somehow return True - return False + + def __contains__(self, value): + # This is slow, but these are the semantics. + for elem in self: + if elem == value: + return True + return False ### SEQUENCES ### @@ -405,142 +405,142 @@ class Sequence(Sizeable, Iterable): - """A minimal sequence. + """A minimal sequence. - I'm not bothering with an unsized version; I don't see a use case. + I'm not bothering with an unsized version; I don't see a use case. - Concrete subclasses must override __new__ or __init__, __getitem__, - and __len__; they might want to override __add__ and __mul__. The - constructor signature is expected to support a single argument - giving an iterable providing the elements. - """ - - def __index(self, i): - # Internal helper to raise TypeError for non-integer(-castable) values - if not isinstance(i, int): - if not hasattr(i, "__index__"): - raise TypeError - i = i.__index__() - if not isinstance(i, int): - raise TypeError - return i - - @abstractmethod - def __getitem__(self, index): - if isinstance(index, slice): - return self.__getslice(index) - index = self.__index(index) - raise IndexError - - def __getslice(self, slc): - # XXX Would be nice to make this generally available? - start, stop, step = slc.start, slc.stop, slc.step - for index in start, stop, step: - if index is not None: - self.__index(index) - if step is None: - step = 1 - if step == 0: - raise ValueError - if step < 0: - if start is None: - start = len(self) - 1 - if stop is None: - stop = -1 - else: - if start is None: - start = 0 - if stop is None: - stop = len(self) - return self.__class__(self[i] for i in range(start, stop, step)) - - @abstractmethod - def __len__(self): - return 0 - - def __iter__(self): - i = 0 - while i < len(self): - yield self[i] - i += 1 - - def __reversed__(self): - i = len(self) - while i > 0: - i -= 1 - yield self[i] - - def index(self, value): - for i, elem in enumerate(self): - if elem == value: - return i - raise ValueError + Concrete subclasses must override __new__ or __init__, __getitem__, + and __len__; they might want to override __add__ and __mul__. The + constructor signature is expected to support a single argument + giving an iterable providing the elements. + """ - def count(self, value): - return sum(1 for elem in self if elem == value) + def __index(self, i): + # Internal helper to raise TypeError for non-integer(-castable) values + if not isinstance(i, int): + if not hasattr(i, "__index__"): + raise TypeError + i = i.__index__() + if not isinstance(i, int): + raise TypeError + return i - def __add__(self, other): - if not isinstance(other, Sequence): - return NotImplemented - return self.__class__(elem for seq in (self, other) for elem in seq) - - def __mul__(self, repeat): - # XXX Looks like we need an ABC to indicate integer-ness... - if not isinstance(repeat, int) and not hasattr(repeat, "__index__"): - return NotImplemented - repeat = self.__index(repeat) - return self.__class__(elem for i in range(repeat) for elem in self) - - def __eq__(self, other): - if not isinstance(other, Sequence): - return NotImplemented - if len(self) != len(other): - return False - for a, b in zip(self, other): - if a == b: - continue - return False - return len(self) == len(other) - - def __lt__(self, other): - if not isinstance(other, Sequence): - return NotImplemented - for a, b in zip(self, other): - if a == b: - continue - return a < b - return len(self) < len(other) - - def __le__(self, other): - if not isinstance(other, Sequence): - return NotImplemented - for a, b in zip(self, other): - if a == b: - continue - return a < b - return len(self) <= len(other) + @abstractmethod + def __getitem__(self, index): + if isinstance(index, slice): + return self.__getslice(index) + index = self.__index(index) + raise IndexError + + def __getslice(self, slc): + # XXX Would be nice to make this generally available? + start, stop, step = slc.start, slc.stop, slc.step + for index in start, stop, step: + if index is not None: + self.__index(index) + if step is None: + step = 1 + if step == 0: + raise ValueError + if step < 0: + if start is None: + start = len(self) - 1 + if stop is None: + stop = -1 + else: + if start is None: + start = 0 + if stop is None: + stop = len(self) + return self.__class__(self[i] for i in range(start, stop, step)) + + @abstractmethod + def __len__(self): + return 0 + + def __iter__(self): + i = 0 + while i < len(self): + yield self[i] + i += 1 + + def __reversed__(self): + i = len(self) + while i > 0: + i -= 1 + yield self[i] + + def index(self, value): + for i, elem in enumerate(self): + if elem == value: + return i + raise ValueError + + def count(self, value): + return sum(1 for elem in self if elem == value) + + def __add__(self, other): + if not isinstance(other, Sequence): + return NotImplemented + return self.__class__(elem for seq in (self, other) for elem in seq) + + def __mul__(self, repeat): + # XXX Looks like we need an ABC to indicate integer-ness... + if not isinstance(repeat, int) and not hasattr(repeat, "__index__"): + return NotImplemented + repeat = self.__index(repeat) + return self.__class__(elem for i in range(repeat) for elem in self) + + def __eq__(self, other): + if not isinstance(other, Sequence): + return NotImplemented + if len(self) != len(other): + return False + for a, b in zip(self, other): + if a == b: + continue + return False + return len(self) == len(other) + + def __lt__(self, other): + if not isinstance(other, Sequence): + return NotImplemented + for a, b in zip(self, other): + if a == b: + continue + return a < b + return len(self) < len(other) + + def __le__(self, other): + if not isinstance(other, Sequence): + return NotImplemented + for a, b in zip(self, other): + if a == b: + continue + return a < b + return len(self) <= len(other) class HashableSequence(Sequence, Hashable): - def __hash__(self): - """The hash value must match __eq__. + def __hash__(self): + """The hash value must match __eq__. - Since we want sequences to be equal iff their elements are equal - (regardless of the sequence type), this algorithm is (XXX - hopefully) identical to tuple.__hash__(). - """ - mask = sys.maxint*2 + 1 - mult = 1000003 - h = 0x345678 - n = len(self) - for i, elem in enumerate(self): - h = ((h ^ hash(elem)) * mult) & mask - mult = (mult + (82520 - 2 + 2*(n-i))) & mask - h += 97531 - h &= mask - if h > sys.maxint: - h -= mask + 1 - if h == -1: - h = -2 - return h + Since we want sequences to be equal iff their elements are equal + (regardless of the sequence type), this algorithm is (XXX + hopefully) identical to tuple.__hash__(). + """ + mask = sys.maxint*2 + 1 + mult = 1000003 + h = 0x345678 + n = len(self) + for i, elem in enumerate(self): + h = ((h ^ hash(elem)) * mult) & mask + mult = (mult + (82520 - 2 + 2*(n-i))) & mask + h += 97531 + h &= mask + if h > sys.maxint: + h -= mask + 1 + if h == -1: + h = -2 + return h

1 0

r54638 - sandbox/trunk/abc/abc.py sandbox/trunk/abc/test_abc.py
by guido.van.rossum 01 Apr '07

01 Apr '07

Author: guido.van.rossum Date: Sat Mar 31 22:27:51 2007 New Revision: 54638 Added: sandbox/trunk/abc/test_abc.py (contents, props changed) Modified: sandbox/trunk/abc/abc.py Log: Create some unit tests. Add some docs to the abstractmethod decorator. Modified: sandbox/trunk/abc/abc.py ============================================================================== --- sandbox/trunk/abc/abc.py (original) +++ sandbox/trunk/abc/abc.py Sat Mar 31 22:27:51 2007 @@ -3,8 +3,8 @@ """Abstract Base Classes experiment. Note: this depends on the brand new Py3k feature that object.__ne__() -is implemented by calling object.__eq__() and reversing the outcome -(unless NotImplemented). +is implemented by calling __eq__() and reversing the outcome (unless +NotImplemented). XXX Should we use argument annotations here? @@ -18,27 +18,73 @@ def abstractmethod(funcobj): - """A decorator indicating abstract methods.""" + """A decorator indicating abstract methods. + + Requires that the class (directly or indirectly) derives from + Abstract, and that the metaclass is AbstractClass or derived from it + (deriving from Abstract ensure this). A class deriving from + Abstract cannot be instantiated unless all of its abstract methods + are overridden. The abstract methods can be called using any of the + the normal 'super' call mechanisms. + + Usage: + + class C(Abstract): + @abstractmethod + def my_abstract_method(self, ...): + ... + + When combining this with other decorators, this should come last: + + class C(Abstract): + @classmethod + @abstractmethod + def my_abstract_class_method(self, ...): + ... + """ funcobj.__abstractmethod__ = True return funcobj class AbstractClass(type): + """Metaclass to support the abstractmethod decorator.""" + def __new__(mcls, name, bases, namespace): - obj = super(AbstractClass, mcls).__new__(mcls, name, bases, namespace) + cls = super(AbstractClass, mcls).__new__(mcls, name, bases, namespace) abstracts = set() for base in bases: abstracts.update(getattr(base, "__abstractmethods__", set())) for name, value in namespace.items(): if getattr(value, "__abstractmethod__", False): abstracts.add(name) - obj.__abstractmethods__ = abstracts - return obj + cls.__abstractmethods__ = abstracts + return cls + + +class AbstractInstantiationError(TypeError): + + """Exception raised when an abstract class is instantiated.""" + + def __init__(self, abstract_methods): + TypeError.__init__(self) + self.abstract_methods = abstract_methods + + def __str__(self): + msg = ", ".join(sorted(self.abstract_methods)) + return "Can't instantiate class with abstract method(s) %s" % msg + + def __repr__(self): + return "AbstractInstantiationError(%r)" % (self.abstract_methods,) class Abstract(metaclass=AbstractClass): + """Base class to support the abstractmethod decorator. + + This implicitly sets the metaclass to AbstractClass. + """ + def __new__(cls): bad = set() for name in cls.__abstractmethods__: @@ -46,8 +92,7 @@ if getattr(value, "__abstractmethod__", False): bad.add(name) if bad: - raise TypeError("Can't instantiate class with abstract methods %s" % - ", ".join(sorted(bad))) + raise AbstractInstantiationError(bad) return super(Abstract, cls).__new__(cls) @@ -499,29 +544,3 @@ if h == -1: h = -2 return h - - -### test ### - - -def _test(): - # Test that HashableSequence.__hash__() emulates tuple.__hash__(). - class C(HashableSequence): - def __new__(cls, values): - obj = super(C, cls).__new__(cls) - obj.__values = list(values) - return obj - def __len__(self): - return len(self.__values) - def __getitem__(self, i): - return self.__values[i] - for l in ([], [0], [1], [0, 1], - list(range(-sys.maxint, sys.maxint, 100000)), - "The quick brown fox jumps over the lazy dog".split()): - a = C(l) - ha = hash(a) - htl = hash(tuple(l)) - assert ha == htl, (l, ha, htl) - -if __name__ == "__main__": - _test() Added: sandbox/trunk/abc/test_abc.py ============================================================================== --- (empty file) +++ sandbox/trunk/abc/test_abc.py Sat Mar 31 22:27:51 2007 @@ -0,0 +1,43 @@ +#!/usr/bin/env python3.0 +"""Unit tests for abc.py.""" + +import sys +import unittest + +import abc + +class ABCTestCase(unittest.TestCase): + + def test_abstract_method_machinery(self): + class C(abc.Abstract): + @abc.abstractmethod + def foo(self): pass + def bar(self): pass + self.assertRaises(abc.AbstractInstantiationError, C) + class D(C): + def bar(self): pass + self.assertRaises(abc.AbstractInstantiationError, D) + class E(D): + def foo(self): pass + E() + + def test_hashable_sequence_hash_matches_tuple_hash(self): + class C(abc.HashableSequence): + def __new__(cls, values): + obj = super(C, cls).__new__(cls) + obj.__values = list(values) + return obj + def __len__(self): + return len(self.__values) + def __getitem__(self, i): + return self.__values[i] + for l in ([], [0], [1], [0, 1], + list(range(-sys.maxint, sys.maxint, 100000)), + "The quick brown fox jumps over the lazy dog".split()): + hcl = hash(C(l)) + htl = hash(tuple(l)) + self.assertEqual(hcl, htl, repr((l, hcl, htl))) + + +if __name__ == "__main__": + unittest.main()

1 0

buildbot warnings in x86 Ubuntu edgy (icc) trunk
by buildbot＠python.org 01 Apr '07

01 Apr '07

The Buildbot has detected a new failure of x86 Ubuntu edgy (icc) trunk. Full details are available at: http://www.python.org/dev/buildbot/all/x86%2520Ubuntu%2520edgy%2520%2528icc… Buildbot URL: http://www.python.org/dev/buildbot/all/ Build Reason: Build Source Stamp: [branch trunk] HEAD Blamelist: andrew.kuchling,georg.brandl,neal.norwitz Build had warnings: warnings test Excerpt from the test logfile: 1 test failed: test_timeout sincerely, -The Buildbot

1 0

buildbot warnings in x86 W2k trunk
by buildbot＠python.org 01 Apr '07

01 Apr '07

The Buildbot has detected a new failure of x86 W2k trunk. Full details are available at: http://www.python.org/dev/buildbot/all/x86%2520W2k%2520trunk/builds/170 Buildbot URL: http://www.python.org/dev/buildbot/all/ Build Reason: Build Source Stamp: [branch trunk] HEAD Blamelist: andrew.kuchling,georg.brandl,neal.norwitz Build had warnings: warnings test Excerpt from the test logfile: 6 tests failed: test_os test_pep277 test_pkg test_rgbimg test_urllib test_winreg ====================================================================== ERROR: test_makedir (test.test_os.MakedirTests) ---------------------------------------------------------------------- Traceback (most recent call last): File "C:\trentm\data\buildbot\python-slave\trunk.mick-windows\build\lib\test\test_os.py", line 376, in setUp os.mkdir(test_support.TESTFN) WindowsError: [Error 183] Cannot create a file when that file already exists: '@test' ====================================================================== ERROR: test_access (test.test_os.Win32ErrorTests) ---------------------------------------------------------------------- Traceback (most recent call last): File "C:\trentm\data\buildbot\python-slave\trunk.mick-windows\build\lib\test\test_os.py", line 443, in test_access self.assertRaises(WindowsError, os.utime, test_support.TESTFN, 0) File "C:\trentm\data\buildbot\python-slave\trunk.mick-windows\build\lib\unittest.py", line 329, in failUnlessRaises callableObj(*args, **kwargs) TypeError: utime() arg 2 must be a tuple (atime, mtime) ====================================================================== FAIL: test_traversal (test.test_os.WalkTests) ---------------------------------------------------------------------- Traceback (most recent call last): File "C:\trentm\data\buildbot\python-slave\trunk.mick-windows\build\lib\test\test_os.py", line 313, in test_traversal self.assertEqual(len(all), 4) AssertionError: 5 != 4 ====================================================================== FAIL: test_chdir (test.test_os.Win32ErrorTests) ---------------------------------------------------------------------- Traceback (most recent call last): File "C:\trentm\data\buildbot\python-slave\trunk.mick-windows\build\lib\test\test_os.py", line 434, in test_chdir self.assertRaises(WindowsError, os.chdir, test_support.TESTFN) AssertionError: WindowsError not raised sincerely, -The Buildbot

2 1

r54637 - python/trunk/Lib/test/test_os.py
by collin.winter 01 Apr '07

01 Apr '07

Author: collin.winter Date: Sat Mar 31 21:31:34 2007 New Revision: 54637 Modified: python/trunk/Lib/test/test_os.py Log: Shut up an occaisonal buildbot error due to test files being left around. Modified: python/trunk/Lib/test/test_os.py ============================================================================== --- python/trunk/Lib/test/test_os.py (original) +++ python/trunk/Lib/test/test_os.py Sat Mar 31 21:31:34 2007 @@ -373,6 +373,14 @@ class MakedirTests (unittest.TestCase): def setUp(self): + try: + os.rmdir(test_support.TESTFN) + except OSError: + pass + try: + os.unlink(test_support.TESTFN) + except OSError: + pass os.mkdir(test_support.TESTFN) def test_makedir(self):

1 0