From: SourceForge.net <no...@so...> - 2007-08-16 00:28:57
|
Patches item #1775078, was opened at 2007-08-16 01:28 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Philip Jenvey (pjenvey) Assigned to: Nobody/Anonymous (nobody) Summary: Fix binary operations on str/unicode/lists/tuples Initial Comment: These 4 classes have binary op bugs against subclasses that implement their own custom __add__/__radd__/__mul__ etc methods (see the example below) PyObject._binop_rule calls into the __xxx__/__rxxx__ methods when at least one of the objects involved isn't a built in type. It expects those methods to return Py.NotImplemented when the binary operation doesn't succeed -- signaling that _binop_rule can try a different means (e.g. if __add__ fails, try the other object's __radd__) The str/unicode/list/tuple methods weren't marked as binary in their .expose files; fixing this ensures that Py.NotImplemented is automatically returned to _binop_rule when these methods return null. Some of these methods were taking it upon themselves to incorrectly throw an exception when the bin op failed; doing so short circuits _binop_rule, preventing it from trying different means. These have also been fixed The methods that did correctly return null would end up (without being defined as a binary op in the expose file) returning a null back into the Python object space, causing evilness such as: Jython 2.3a0 on java1.5.0_07 Type "copyright", "credits" or "license" for more information. >>> class Hi(object): ... def __radd__(self, o): ... return '%r + Hi()' % o ... >>> a = [1, 2] + Hi() >>> a Traceback (innermost last): File "<console>", line 1, in ? NameError: a This patch also corrects the TypeError messages used when certain binary ops fail; they've been changed to match Python 2.5.1's. I also added a subclass_binop test to test_descr.py to ensure the return values for + and * ops, and their TypeError messages List's __iadd__/__imul__ don't have to be defined as binary ops in the .expose file because they don't ever utilize _binop_rule ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 |
From: SourceForge.net <no...@so...> - 2007-08-31 01:32:56
|
Patches item #1775078, was opened at 2007-08-16 01:28 Message generated for change (Comment added) made by pjenvey You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Philip Jenvey (pjenvey) Assigned to: Nobody/Anonymous (nobody) Summary: Fix binary operations on str/unicode/lists/tuples Initial Comment: These 4 classes have binary op bugs against subclasses that implement their own custom __add__/__radd__/__mul__ etc methods (see the example below) PyObject._binop_rule calls into the __xxx__/__rxxx__ methods when at least one of the objects involved isn't a built in type. It expects those methods to return Py.NotImplemented when the binary operation doesn't succeed -- signaling that _binop_rule can try a different means (e.g. if __add__ fails, try the other object's __radd__) The str/unicode/list/tuple methods weren't marked as binary in their .expose files; fixing this ensures that Py.NotImplemented is automatically returned to _binop_rule when these methods return null. Some of these methods were taking it upon themselves to incorrectly throw an exception when the bin op failed; doing so short circuits _binop_rule, preventing it from trying different means. These have also been fixed The methods that did correctly return null would end up (without being defined as a binary op in the expose file) returning a null back into the Python object space, causing evilness such as: Jython 2.3a0 on java1.5.0_07 Type "copyright", "credits" or "license" for more information. >>> class Hi(object): ... def __radd__(self, o): ... return '%r + Hi()' % o ... >>> a = [1, 2] + Hi() >>> a Traceback (innermost last): File "<console>", line 1, in ? NameError: a This patch also corrects the TypeError messages used when certain binary ops fail; they've been changed to match Python 2.5.1's. I also added a subclass_binop test to test_descr.py to ensure the return values for + and * ops, and their TypeError messages List's __iadd__/__imul__ don't have to be defined as binary ops in the .expose file because they don't ever utilize _binop_rule ---------------------------------------------------------------------- >Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 02:32 Message: Logged In: YES user_id=145787 Originator: YES There's a problem with this change, returning null instead of throwing TypeErrors in the binop methods breaks calling them directly from python, which is expected to work from some tests: >>> 'abc'.__mul__('') NotImplemented _binop_rule may need to be changed to catch TypeErrors (maybe any python exception) and handle it as if NotImplemented was returned, instead ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 |
From: SourceForge.net <no...@so...> - 2007-08-31 19:52:33
|
Patches item #1775078, was opened at 2007-08-16 01:28 Message generated for change (Comment added) made by pjenvey You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: None Status: Open Resolution: None Priority: 5 Private: No Submitted By: Philip Jenvey (pjenvey) Assigned to: Nobody/Anonymous (nobody) Summary: Fix binary operations on str/unicode/lists/tuples Initial Comment: These 4 classes have binary op bugs against subclasses that implement their own custom __add__/__radd__/__mul__ etc methods (see the example below) PyObject._binop_rule calls into the __xxx__/__rxxx__ methods when at least one of the objects involved isn't a built in type. It expects those methods to return Py.NotImplemented when the binary operation doesn't succeed -- signaling that _binop_rule can try a different means (e.g. if __add__ fails, try the other object's __radd__) The str/unicode/list/tuple methods weren't marked as binary in their .expose files; fixing this ensures that Py.NotImplemented is automatically returned to _binop_rule when these methods return null. Some of these methods were taking it upon themselves to incorrectly throw an exception when the bin op failed; doing so short circuits _binop_rule, preventing it from trying different means. These have also been fixed The methods that did correctly return null would end up (without being defined as a binary op in the expose file) returning a null back into the Python object space, causing evilness such as: Jython 2.3a0 on java1.5.0_07 Type "copyright", "credits" or "license" for more information. >>> class Hi(object): ... def __radd__(self, o): ... return '%r + Hi()' % o ... >>> a = [1, 2] + Hi() >>> a Traceback (innermost last): File "<console>", line 1, in ? NameError: a This patch also corrects the TypeError messages used when certain binary ops fail; they've been changed to match Python 2.5.1's. I also added a subclass_binop test to test_descr.py to ensure the return values for + and * ops, and their TypeError messages List's __iadd__/__imul__ don't have to be defined as binary ops in the .expose file because they don't ever utilize _binop_rule ---------------------------------------------------------------------- >Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 20:52 Message: Logged In: YES user_id=145787 Originator: YES Actually, returning NotImplemented here is inline with pypy PyPy 1.0.0 in StdObjSpace on top of Python 2.5.1 (startuptime: 11.98 secs) >>>> 'abc'.__mul__('') NotImplemented The test that fails with this patch applied: self.checkraises(TypeError, 'abc', '__mul__', '') pypy modifies this to: self.checkopraises(TypeError, operator.mul, 'abc', '') which we'd pass ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 02:32 Message: Logged In: YES user_id=145787 Originator: YES There's a problem with this change, returning null instead of throwing TypeErrors in the binop methods breaks calling them directly from python, which is expected to work from some tests: >>> 'abc'.__mul__('') NotImplemented _binop_rule may need to be changed to catch TypeErrors (maybe any python exception) and handle it as if NotImplemented was returned, instead ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 |
From: SourceForge.net <no...@so...> - 2007-08-31 21:46:45
|
Patches item #1775078, was opened at 2007-08-16 01:28 Message generated for change (Comment added) made by pjenvey You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: None >Status: Closed >Resolution: Fixed Priority: 5 Private: No Submitted By: Philip Jenvey (pjenvey) Assigned to: Nobody/Anonymous (nobody) Summary: Fix binary operations on str/unicode/lists/tuples Initial Comment: These 4 classes have binary op bugs against subclasses that implement their own custom __add__/__radd__/__mul__ etc methods (see the example below) PyObject._binop_rule calls into the __xxx__/__rxxx__ methods when at least one of the objects involved isn't a built in type. It expects those methods to return Py.NotImplemented when the binary operation doesn't succeed -- signaling that _binop_rule can try a different means (e.g. if __add__ fails, try the other object's __radd__) The str/unicode/list/tuple methods weren't marked as binary in their .expose files; fixing this ensures that Py.NotImplemented is automatically returned to _binop_rule when these methods return null. Some of these methods were taking it upon themselves to incorrectly throw an exception when the bin op failed; doing so short circuits _binop_rule, preventing it from trying different means. These have also been fixed The methods that did correctly return null would end up (without being defined as a binary op in the expose file) returning a null back into the Python object space, causing evilness such as: Jython 2.3a0 on java1.5.0_07 Type "copyright", "credits" or "license" for more information. >>> class Hi(object): ... def __radd__(self, o): ... return '%r + Hi()' % o ... >>> a = [1, 2] + Hi() >>> a Traceback (innermost last): File "<console>", line 1, in ? NameError: a This patch also corrects the TypeError messages used when certain binary ops fail; they've been changed to match Python 2.5.1's. I also added a subclass_binop test to test_descr.py to ensure the return values for + and * ops, and their TypeError messages List's __iadd__/__imul__ don't have to be defined as binary ops in the .expose file because they don't ever utilize _binop_rule ---------------------------------------------------------------------- >Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 22:46 Message: Logged In: YES user_id=145787 Originator: YES applied in r3461 ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 20:52 Message: Logged In: YES user_id=145787 Originator: YES Actually, returning NotImplemented here is inline with pypy PyPy 1.0.0 in StdObjSpace on top of Python 2.5.1 (startuptime: 11.98 secs) >>>> 'abc'.__mul__('') NotImplemented The test that fails with this patch applied: self.checkraises(TypeError, 'abc', '__mul__', '') pypy modifies this to: self.checkopraises(TypeError, operator.mul, 'abc', '') which we'd pass ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 02:32 Message: Logged In: YES user_id=145787 Originator: YES There's a problem with this change, returning null instead of throwing TypeErrors in the binop methods breaks calling them directly from python, which is expected to work from some tests: >>> 'abc'.__mul__('') NotImplemented _binop_rule may need to be changed to catch TypeErrors (maybe any python exception) and handle it as if NotImplemented was returned, instead ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 |
From: SourceForge.net <no...@so...> - 2007-08-31 21:48:51
|
Patches item #1775078, was opened at 2007-08-16 01:28 Message generated for change (Comment added) made by pjenvey You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: None Status: Closed Resolution: Fixed Priority: 5 Private: No Submitted By: Philip Jenvey (pjenvey) Assigned to: Nobody/Anonymous (nobody) Summary: Fix binary operations on str/unicode/lists/tuples Initial Comment: These 4 classes have binary op bugs against subclasses that implement their own custom __add__/__radd__/__mul__ etc methods (see the example below) PyObject._binop_rule calls into the __xxx__/__rxxx__ methods when at least one of the objects involved isn't a built in type. It expects those methods to return Py.NotImplemented when the binary operation doesn't succeed -- signaling that _binop_rule can try a different means (e.g. if __add__ fails, try the other object's __radd__) The str/unicode/list/tuple methods weren't marked as binary in their .expose files; fixing this ensures that Py.NotImplemented is automatically returned to _binop_rule when these methods return null. Some of these methods were taking it upon themselves to incorrectly throw an exception when the bin op failed; doing so short circuits _binop_rule, preventing it from trying different means. These have also been fixed The methods that did correctly return null would end up (without being defined as a binary op in the expose file) returning a null back into the Python object space, causing evilness such as: Jython 2.3a0 on java1.5.0_07 Type "copyright", "credits" or "license" for more information. >>> class Hi(object): ... def __radd__(self, o): ... return '%r + Hi()' % o ... >>> a = [1, 2] + Hi() >>> a Traceback (innermost last): File "<console>", line 1, in ? NameError: a This patch also corrects the TypeError messages used when certain binary ops fail; they've been changed to match Python 2.5.1's. I also added a subclass_binop test to test_descr.py to ensure the return values for + and * ops, and their TypeError messages List's __iadd__/__imul__ don't have to be defined as binary ops in the .expose file because they don't ever utilize _binop_rule ---------------------------------------------------------------------- >Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 22:48 Message: Logged In: YES user_id=145787 Originator: YES r3461 also includes that pypy string_test modification I previously mentioned ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 22:46 Message: Logged In: YES user_id=145787 Originator: YES applied in r3461 ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 20:52 Message: Logged In: YES user_id=145787 Originator: YES Actually, returning NotImplemented here is inline with pypy PyPy 1.0.0 in StdObjSpace on top of Python 2.5.1 (startuptime: 11.98 secs) >>>> 'abc'.__mul__('') NotImplemented The test that fails with this patch applied: self.checkraises(TypeError, 'abc', '__mul__', '') pypy modifies this to: self.checkopraises(TypeError, operator.mul, 'abc', '') which we'd pass ---------------------------------------------------------------------- Comment By: Philip Jenvey (pjenvey) Date: 2007-08-31 02:32 Message: Logged In: YES user_id=145787 Originator: YES There's a problem with this change, returning null instead of throwing TypeErrors in the binop methods breaks calling them directly from python, which is expected to work from some tests: >>> 'abc'.__mul__('') NotImplemented _binop_rule may need to be changed to catch TypeErrors (maybe any python exception) and handle it as if NotImplemented was returned, instead ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=312867&aid=1775078&group_id=12867 |