Mailman 3 July 2008 - Python-Dev

Issue2944: need a review
by Alexander Shigin July 17, 2008

July 17, 2008

Can anyone look at the patch for Issue2944? I hope the issue can be fixed before the release of python 2.6.

4 3

PEP 3101: floats format 'f' and 'F'
by Eric Smith July 17, 2008

July 17, 2008

Does anyone know why 'F' is the same as 'f'? Wouldn't it make more sense to either drop it, or make it convert the exponent to upper case (like 'E' and 'G')? Compatibility with %-formatting is the only reason I can think of to keep up, but I get the sense we've given up on an automatic conversion from %-formatting to str.format(). Plus, I can find no uses of '%F' in the standard library. And really, if you could write something to automatically convert %-formatting to str.format(), … [View More]

7 17

Running Py2.6 with the -3 option
by Raymond Hettinger July 17, 2008

July 17, 2008

Some effort needs to be made to clear the standard library of -3 warnings. Running -3 on production code usually involves exercising library code so the useful result is obscured by Python complaining about itself. Since that use case involves the users own tests, I don't think the effort needs to be extended to our own unittest suite. But the rest of the library could likely benefit from a good -3 cleanup. Raymond

9 14

PEP: Frequently-requested additional features for the `unittest` module
by Ben Finney July 17, 2008

July 17, 2008

:PEP: XXX :Title: Frequently-requested additional features for the `unittest` module :Version: 0.3 :Last-Modified: 2008-07-16 :Author: Ben Finney <ben+python(a)benfinney.id.au> :Status: Draft :Type: Standards Track :Content-Type: test/x-rst :Requires: PEP XXX (Consolidating names in the `unittest` module) :Created: 2008-07-14 :Post-History: .. contents:: Abstract ======== This PEP proposes frequently-requested additions to … [View More]the standard library `unittest` module that are natural extensions of its existing functionality. Motivation ========== The `unittest` module is functionally complete. Nevertheless, many users request and devise extensions to perform functions that are so common they deserve to be in the standard module. Specification ============= New condition tests ------------------- The following test methods will be added to the ``TestCase`` class. The function signature is part of this specification. The body is to be treated as a reference implementation only; any functionally identical implementation also meets this specification. :: import operator import re class TestCase(object): # … def assert_compare_true(op, first, second, msg=None): if msg is None: msg = "%(first)r %(op)r %(second)" % vars() if not op(first, second): raise self.failure_exception(msg) def assert_in(container, member, msg=None): op = operator.__contains__ self.assert_compare_true(op, container, member, msg) def assert_is(first, second, msg=None): op = operator.is_ self.assert_compare_true(op, first, second, msg) def assert_less_than(first, second, msg=None): op = operator.lt self.assert_compare_true(op, first, second, msg) def assert_greater_than(first, second, msg=None): op = operator.gt self.assert_compare_true(op, first, second, msg) def assert_less_than_or_equal(first, second, msg=None): op = operator.le self.assert_compare_true(op, first, second, msg) def assert_greater_than_or_equal(first, second, msg=None): op = operator.ge self.assert_compare_true(op, first, second, msg) def assert_members_equal(first, second, msg=None): self.assert_equal(set(first), set(second), msg) def assert_sequence_equal(first, second, msg=None): self.assert_equal(list(first), list(second), msg) def assert_raises_with_message_regex( exc_class, message_regex, callable_obj, *args, **kwargs): exc_name = exc_class.__name__ message_pattern = re.compile(message_regex) try: callable_obj(*args, **kwargs) except exc_class, exc: exc_message = str(exc) if not message_pattern.match(exc_message): msg = ( "%(exc_name)s raised" " without message matching %(message_regex)r" " (got message %(exc_message)r)" ) % vars() raise self.failure_exception(msg) else: msg = "%(exc_name)s not raised" % vars() raise self.failure_exception(msg) The following test methods are also added. Their implementation in each case is simply the logical inverse of a corresponding method above. :: def assert_compare_false(op, first, second, msg=None): # Logical inverse of assert_compare_true def assert_not_in(container, member, msg=None): # Logical inverse of assert_in def assert_is_not(first, second, msg=None) # Logical inverse of assert_is def assert_not_less_than(first, second, msg=None) # Logical inverse of assert_less_than def assert_not_greater_than(first, second, msg=None) # Logical inverse of assert_greater_than def assert_not_less_than_or_equal(first, second, msg=None) # Logical inverse of assert_less_than_or_equal def assert_not_greater_than_or_equal(first, second, msg=None) # Logical inverse of assert_greater_than_or_equal def assert_members_not_equal(first, second, msg=None) # Logical inverse of assert_members_equal def assert_sequence_not_equal(first, second, msg=None) # Logical inverse of assert_sequence_equal Enhanced failure message for equality tests ------------------------------------------- The equality tests will change their behaviour such that the message always, even if overridden with a specific message when called, includes extra information: * For both ``assert_equal`` and ``assert_not_equal``: the ``repr()`` output of the objects that were compared. * For ``assert_equal`` comparisons of ``basestring`` instances that are multi-line text: the output of ``diff`` comparing the two texts. * For membership comparisons with ``assert_*_equal``: the ``repr()`` output of the members that were not equal in each collection. (This change is not done for the corresponding ``assert_*_not_equal`` tests, which only fail if the collection members are equal.) Simple invocation of test collection ------------------------------------ The following new functionality will be added to the `unittest` module. The function signature for ``run_tests`` is part of this specification; the implementation is to be considered a reference implementation only. :: def run_tests( tests, loader_class=TestLoader, suite_class=TestSuite, runner_class=TextTestRunner): """ Run a collection of tests with a test runner :param tests: A sequence of objects that can contain test cases: modules, `TestSuite` instances, or `TestCase` subclasses. :param loader_class: The type of test loader to use for collecting tests from the `tests` collection. :param suite_class: The type of test suite to use for accumulating the collected test cases. :param runner_class: The type of test runner to instantiate for running the collected test cases. :return: None. """ def iter_testcases_recursively(collection, loader): # Flatten and iterate over collection, generating # instances of TestCase loader = loader_class() suite = suite_class() for testcase in iter_testcases_recursively(tests, loader): suite.add_tests(testcase) runner = runner_class() runner.run(suite) Rationale ========= Names for logical-inverse tests ------------------------------- The simple pattern established by ``assert_foo`` having a logical inverse named ``assert_not_foo`` sometimes results in gramatically awkward names. The following names were chosen in exception of this pattern, in the interest of the API names being more intuitive: * ``assert_is_not`` * ``assert_members_not_equal`` * ``assert_sequence_not_equal`` Order of method parameters -------------------------- The methods ``assert_in``, ``assert_not_in`` have the container as the first parameter. This makes the grammatical object of the function name come immediately after the function name: "Assert in `container`". This matches the convention set by the existing ``assert_raises(exception, callable_obj, …)`` "(Assert the code raises `exception`"). Backwards Compatibility ======================= This PEP proposes only additional features. There are no backward-incompatible changes. Reference Implementation ======================== None yet. Copyright ========= This document is hereby placed in the public domain by its author. .. Local Variables: mode: rst coding: utf-8 End: vim: filetype=rst : [View Less]

8 14

defects submitted by me.
by Kristján Valur Jónsson July 17, 2008

July 17, 2008

Recently, I have submitted a number of defects (user krisvale) I do have checkin privileges but since I have been lurking for so long, I didn't want to actualhange anything. Is this the way to proceed? I notic e that a couple of the defects (3367, 3368, 3369) have received attention and are presumabely being worked on, but 3327, 3377 and 3378 have not. Not that for defect 3377 I have no patch, since I am unclear on where the logical error lies. Also, some of these problem Cheers, Kristján

2 1

accepted bytearray items -- integers or numbers?
by Georg Brandl July 16, 2008

July 16, 2008

Currently, most mutating bytearray methods only accept integers as items (in 3k, in 2.6 they also accept single-char strings, for a reason I can't remember). Single-index assignment accepts anything compatible with operator.index(). This should be made consistent, but in which direction? Georg

2 3

PEP: Consolidating names and classes in the `unittest` module
by Ben Finney July 16, 2008

July 16, 2008

:PEP: XXX :Title: Consolidating names and classes in the `unittest` module :Version: 0.0 :Last-Modified: 2008-07-14 :Author: Ben Finney <ben+python(a)benfinney.id.au> :Status: Draft :Type: Standards Track :Content-Type: test/x-rst :Created: 2008-07-14 :Post-History: .. contents:: Abstract ======== This PEP proposes to consolidate the names and classes that constitute the API of the standard library `unittest` module, with the … [View More]goal of removing redundant names, conforming with PEP 8, and eliminating classic classes. Motivation ========== The normal use case for the `unittest` module is to subclass its classes, overriding and re-using its functios and methods. This draws constant attention to the fact that the existing implementation fails several current Python standards: * It does not use new-style classes, preventing e.g. straightforward use of ``super`` for calling the fixture set-up and tear-down methods. * It does not conform to PEP 8, requiring users to write their own non-PEP-8 conformant names when overriding methods, and encouraging extensions to further depart from PEP 8. * It has many synonyms in its API, which goes against the Zen of Python (specifically, that "there should be one, and preferably only one, obvious way to do it"). Specification ============= Use new-style classes throughout -------------------------------- The following classes will inherit explicitly from the built-in `object` type, to make all classes in the module part of the new-style type hierarchy. * ``TestResult`` * ``TestCase`` * ``TestSuite`` * ``TestLoader`` * ``_WritelnDecorator`` * ``TextTestRunner`` * ``TestProgram`` Remove obsolete names --------------------- The following attributes are not documented as part of the API and are marked as obsolete in the implementation. They will be removed. * ``_makeLoader`` * ``getTestCaseNames`` * ``makeSuite`` * ``findTestCases`` Remove redundant names ---------------------- The following attribute names exist only as synonyms for other names. They are to be removed, leaving only one name for each attribute in the API. ``TestCase`` attributes ~~~~~~~~~~~~~~~~~~~~~~~ * ``assertEqual`` * ``assertEquals`` * ``assertNotEqual`` * ``assertNotEquals`` * ``assertAlmostEqual`` * ``assertAlmostEquals`` * ``assertNotAlmostEqual`` * ``assertNotAlmostEquals`` * ``assertRaises`` * ``assert_`` * ``assertTrue`` * ``assertFalse`` Conform API with PEP 8 ---------------------- The following names are to be introduced, each replacing an existing name, to make all names in the module conform with PEP 8. Each name is shown with the existing name that it replaces. Where function parameters are to be renamed also, they are shown. Where function parameters are not to be renamed, they are elided with the ellipse ("…") symbol. Module attributes ~~~~~~~~~~~~~~~~~ ``_make_loader(prefix, sort_using, suite_class)`` Replaces ``_makeLoader (prefix, sortUsing, suiteClass)`` ``find_test_cases(module, prefix, sort_using, suite_class)`` Replaces ``findTestCases(module, prefix, sortUsing, suiteClass)`` ``get_test_case_names(test_case_class, prefix, sort_using)`` Replaces ``getTestCaseNames(testCaseClass, prefix, sortUsing)`` ``make_suite(test_case_class, prefix, sort_using, suite_class)`` Replaces ``makeSuite(testCaseClass, prefix, sortUsing, suiteClass)`` ``default_test_loader`` Replaces ``defaultTestLoader`` ``TestResult`` atributes ~~~~~~~~~~~~~~~~~~~~~~~~ ``add_error(…)`` Replaces ``addError(…)`` ``add_result(…)`` Replaces ``addResult(…)`` ``add_success(…)`` Replaces ``addSuccess(…)`` ``should_stop`` Replaces ``shouldStop`` ``start_test(…)`` Replaces ``startTest(…)`` ``stop_test(…)`` Replaces ``stopTest(…)`` ``tests_run`` Replaces ``testsRun`` ``was_successful(…)`` Replaces ``wasSuccessful(…)`` ``TestCase`` attributes ~~~~~~~~~~~~~~~~~~~~~~~ ``__init__(self, method_name='run_test')`` Replaces ``__init__(self, methodName='runTest')`` ``_test_method_doc`` Replaces ``_testMethodDoc`` ``_test_method_name`` Replaces ``_testMethodName`` ``failure_exception`` Replaces ``failureException`` ``count_test_cases(…)`` Replaces ``countTestCases(…)`` ``default_test_result(…)`` Replaces ``defaultTestResult(…)`` ``fail_if(…)`` Replaces ``failIf(…)`` ``fail_if_almost_equal(…)`` Replaces ``failIfAlmostEqual(…)`` ``fail_if_equal(…)`` Replaces ``failIfEqual(…)`` ``fail_unless(…)`` Replaces ``failUnless(…)`` ``fail_unless_almost_equal(…)`` Replaces ``failUnlessAlmostEqual(…)`` ``fail_unless_equal(…)`` Replaces ``failUnlessEqual(…)`` ``fail_unless_raises(exc_class, callable_obj, *args, **kwargs)`` Replaces ``failUnlessRaises(excClass, callableObj, *args, **kwargs)`` ``run_test(…)`` Replaces ``runTest(…)`` ``set_up(…)`` Replaces ``setUp(…)`` ``short_description(…)`` Replaces ``shortDescription(…)`` ``tear_down(…)`` Replaces ``tearDown(…)`` ``FunctionTestCase`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``__init__(self, test_func, set_up, tear_down, description)`` Replaces ``__init__(self, testFunc, setUp, tearDown, description)`` ``run_test(…)`` Replaces ``runTest(…)`` ``set_up(…)`` Replaces ``setUp(…)`` ``short_description(…)`` Replaces ``shortDescription(…)`` ``tear_down(…)`` Replaces ``tearDown(…)`` ``TestSuite`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~ ``add_test(…)`` Replaces ``addTest(…)`` ``add_tests(…)`` Replaces ``addTests(…)`` ``count_test_cases(…)`` Replaces ``countTestCases(…)`` ``TestLoader`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~~ ``sort_test_methods_using`` Replaces ``sortTestMethodsUsing`` ``suite_class`` Replaces ``suiteClass`` ``test_method_prefix`` Replaces ``testMethodPrefix`` ``get_test_case_names(self, test_case_class)`` Replaces ``getTestCaseNames(self, testCaseClass)`` ``load_tests_from_module(…)`` Replaces ``loadTestsFromModule(…)`` ``load_tests_from_name(…)`` Replaces ``loadTestsFromName(…)`` ``load_tests_from_names(…)`` Replaces ``loadTestsFromNames(…)`` ``load_tests_from_test_case(self, test_case_class)`` Replaces ``loadTestsFromTestCase(self, testCaseClass)`` ``_TextTestResult`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``show_all`` Replaces ``showAll`` ``add_error(…)`` Replaces ``addError(…)`` ``add_failure(…)`` Replaces ``addFailure(…)`` ``add_success(…)`` Replaces ``addSuccess(…)`` ``get_description(…)`` Replaces ``getDescription(…)`` ``print_error_list(…)`` Replaces ``printErrorList(…)`` ``print_errors(…)`` Replaces ``printErrors(…)`` ``start_test(…)`` Replaces ``startTest(…)`` ``TextTestRunner`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``_make_result(…)`` Replaces ``_makeResult(…)`` ``TestProgram`` attributes ~~~~~~~~~~~~~~~~~~~~~~~~~~ ``__init__(self, module, default_test, argv, test_runner, test_loader)`` Replaces ``__init__(self, module, defaultTest, argv, testRunner, testLoader)`` ``create_tests(…)`` Replaces ``createTests(…)`` ``parse_args(…)`` Replaces ``parseArgs(…)`` ``run_tests(…)`` Replaces ``runTests(…)`` ``usage_exit(…)`` Replaces ``usageExit(…)`` Rationale ========= New-style classes ----------------- As a standard library module, `unittest` should not define any classic classes. Redundant names --------------- The current API, with two or in some cases three different names referencing exactly the same function, leads to an overbroad and redundant API that violates PEP 20 ("there should be one, and preferably only one, obvious way to do it"). PEP 8 names ----------- Although `unittest` (and its predecessor `PyUnit`) are intended to be familiar to users of other xUnit interfaces, there is no attempt at direct API compatibility since the only code that Python's `unittest` interfaces with is other Python code. The module is in the standard library and its names should all conform with PEP 8. Backwards Compatibility ======================= The names to be obsoleted should be deprecated and removed according to the schedule for modules in PEP 4. While deprecated, use of the deprecated attributes should raise a ``DeprecationWarning``, with a message stating which replacement name should be used. Reference Implementation ======================== None yet. Copyright ========= This document is hereby placed in the public domain by its author. .. Local Variables: mode: rst coding: utf-8 End: vim: filetype=rst : [View Less]

29 94

Reminder: beta 2's schedule for tomorrow
by Barry Warsaw July 16, 2008

July 16, 2008

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 A reminder: the second betas of Python 2.6 and 3.0 are schedule for tomorrow. I will try to hang out on #python-dev today and will start looking at the trackers and buildbots. Hopefully, we're on track to get the releases out! If there is anything you need a decision on, please follow up to this thread. I'm inundated with email so I can't watch every thread on the mailing lists. Or ping me on #python-dev. - -Barry -----BEGIN PGP … [View More]

5 9

Bug 3139
by Barry Warsaw July 16, 2008

July 16, 2008

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 But 3139 appears important enough to hold up beta 2. http://bugs.python.org/issue3139 bytearrays are not thread safe Can we get this fixed by tomorrow? Does anybody disagree that we should hold up the release for this one? We don't have much time left to fix things like this. - -Barry -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.9 (Darwin) iQCVAwUBSH0/MXEjvBPtnXfVAQJoHwP8CFYbafuSTbnVdBBydZJ5k8Fb1L4YYVG/ 0ee81N4AiQZ5uGQlk4ywAVBycPa+… [View More]

1 0

unittest's redundant assertions: asserts vs. failIf/Unlesses
by Gabriel Grant July 15, 2008

July 15, 2008

Hi all, This gem from unittest.py is pretty much the opposite of "one obvious way": # Synonyms for assertion methods assertEqual = assertEquals = failUnlessEqual assertNotEqual = assertNotEquals = failIfEqual assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual assertRaises = failUnlessRaises assert_ = assertTrue = failUnless assertFalse = failIf Could these be removed for 3k? … [View More]

25 52