Hello community, here is the log from the commit of package python-pytz for openSUSE:Factory checked in at 2014-01-16 15:12:36 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-pytz (Old) and /work/SRC/openSUSE:Factory/.python-pytz.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-pytz" Changes: -------- --- /work/SRC/openSUSE:Factory/python-pytz/python-pytz.changes 2013-11-10 20:37:03.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-pytz.new/python-pytz.changes 2014-01-16 15:12:37.000000000 +0100 @@ -1,0 +2,6 @@ +Mon Jan 13 13:26:58 UTC 2014 - [email protected] + +- update to 2013.9: + - Olson database 2013i + +------------------------------------------------------------------- Old: ---- pytz-2013.8.tar.bz2 New: ---- pytz-2013.9.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-pytz.spec ++++++ --- /var/tmp/diff_new_pack.W4d7Sx/_old 2014-01-16 15:12:38.000000000 +0100 +++ /var/tmp/diff_new_pack.W4d7Sx/_new 2014-01-16 15:12:38.000000000 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-pytz # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,7 +17,7 @@ Name: python-pytz -Version: 2013.8 +Version: 2013.9 Release: 0 Url: http://pytz.sourceforge.net Summary: World timezone definitions, modern and historical ++++++ pytz-2013.8.tar.bz2 -> pytz-2013.9.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/PKG-INFO new/pytz-2013.9/PKG-INFO --- old/pytz-2013.8/PKG-INFO 2013-11-05 13:50:00.000000000 +0100 +++ new/pytz-2013.9/PKG-INFO 2014-01-03 11:33:58.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: pytz -Version: 2013.8 +Version: 2013.9 Summary: World timezone definitions, modern and historical Home-page: http://pythonhosted.org/pytz Author: Stuart Bishop diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz/__init__.py new/pytz-2013.9/pytz/__init__.py --- old/pytz-2013.8/pytz/__init__.py 2013-11-05 13:49:48.000000000 +0100 +++ new/pytz-2013.9/pytz/__init__.py 2014-01-03 11:30:24.000000000 +0100 @@ -9,8 +9,8 @@ ''' # The Olson database is updated several times a year. -OLSON_VERSION = '2013h' -VERSION = '2013.8' # Switching to pip compatible version numbering. +OLSON_VERSION = '2013i' +VERSION = '2013.9' # Switching to pip compatible version numbering. __version__ = VERSION OLSEN_VERSION = OLSON_VERSION # Old releases had this misspelling diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz/lazy.py new/pytz-2013.9/pytz/lazy.py --- old/pytz-2013.8/pytz/lazy.py 2013-11-05 13:49:48.000000000 +0100 +++ new/pytz-2013.9/pytz/lazy.py 2014-01-03 11:30:24.000000000 +0100 @@ -66,6 +66,17 @@ class LazyList(list): """List populated on first use.""" + + _props = [ + '__str__', '__repr__', '__unicode__', + '__hash__', '__sizeof__', '__cmp__', + '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', + 'append', 'count', 'index', 'extend', 'insert', 'pop', 'remove', + 'reverse', 'sort', '__add__', '__radd__', '__iadd__', '__mul__', + '__rmul__', '__imul__', '__contains__', '__len__', '__nonzero__', + '__getitem__', '__setitem__', '__delitem__', '__iter__', + '__reversed__', '__getslice__', '__setslice__', '__delslice__'] + def __new__(cls, fill_iter=None): if fill_iter is None: @@ -76,16 +87,6 @@ class LazyList(list): pass - _props = ( - '__str__', '__repr__', '__unicode__', - '__hash__', '__sizeof__', '__cmp__', - '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', - 'append', 'count', 'index', 'extend', 'insert', 'pop', 'remove', - 'reverse', 'sort', '__add__', '__radd__', '__iadd__', '__mul__', - '__rmul__', '__imul__', '__contains__', '__len__', '__nonzero__', - '__getitem__', '__setitem__', '__delitem__', '__iter__', - '__reversed__', '__getslice__', '__setslice__', '__delslice__') - fill_iter = [fill_iter] def lazy(name): @@ -94,22 +95,43 @@ try: if len(fill_iter) > 0: list.extend(self, fill_iter.pop()) - for method_name in _props: + for method_name in cls._props: delattr(LazyList, method_name) finally: _fill_lock.release() return getattr(list, name)(self, *args, **kw) return _lazy - for name in _props: + for name in cls._props: setattr(LazyList, name, lazy(name)) new_list = LazyList() return new_list +# Not all versions of Python declare the same magic methods. +# Filter out properties that don't exist in this version of Python +# from the list. +LazyList._props = [prop for prop in LazyList._props if hasattr(list, prop)] + class LazySet(set): """Set populated on first use.""" + + _props = ( + '__str__', '__repr__', '__unicode__', + '__hash__', '__sizeof__', '__cmp__', + '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', + '__contains__', '__len__', '__nonzero__', + '__getitem__', '__setitem__', '__delitem__', '__iter__', + '__sub__', '__and__', '__xor__', '__or__', + '__rsub__', '__rand__', '__rxor__', '__ror__', + '__isub__', '__iand__', '__ixor__', '__ior__', + 'add', 'clear', 'copy', 'difference', 'difference_update', + 'discard', 'intersection', 'intersection_update', 'isdisjoint', + 'issubset', 'issuperset', 'pop', 'remove', + 'symmetric_difference', 'symmetric_difference_update', + 'union', 'update') + def __new__(cls, fill_iter=None): if fill_iter is None: @@ -118,21 +140,6 @@ class LazySet(set): pass - _props = ( - '__str__', '__repr__', '__unicode__', - '__hash__', '__sizeof__', '__cmp__', - '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', - '__contains__', '__len__', '__nonzero__', - '__getitem__', '__setitem__', '__delitem__', '__iter__', - '__sub__', '__and__', '__xor__', '__or__', - '__rsub__', '__rand__', '__rxor__', '__ror__', - '__isub__', '__iand__', '__ixor__', '__ior__', - 'add', 'clear', 'copy', 'difference', 'difference_update', - 'discard', 'intersection', 'intersection_update', 'isdisjoint', - 'issubset', 'issuperset', 'pop', 'remove', - 'symmetric_difference', 'symmetric_difference_update', - 'union', 'update') - fill_iter = [fill_iter] def lazy(name): @@ -142,15 +149,20 @@ if len(fill_iter) > 0: for i in fill_iter.pop(): set.add(self, i) - for method_name in _props: + for method_name in cls._props: delattr(LazySet, method_name) finally: _fill_lock.release() return getattr(set, name)(self, *args, **kw) return _lazy - for name in _props: + for name in cls._props: setattr(LazySet, name, lazy(name)) new_set = LazySet() return new_set + +# Not all versions of Python declare the same magic methods. +# Filter out properties that don't exist in this version of Python +# from the list. +LazySet._props = [prop for prop in LazySet._props if hasattr(set, prop)] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz/tests/test_lazy.py new/pytz-2013.9/pytz/tests/test_lazy.py --- old/pytz-2013.8/pytz/tests/test_lazy.py 1970-01-01 01:00:00.000000000 +0100 +++ new/pytz-2013.9/pytz/tests/test_lazy.py 2014-01-03 11:30:24.000000000 +0100 @@ -0,0 +1,313 @@ +from operator import * +import os.path +import sys +import unittest +import warnings + + +if __name__ == '__main__': + # Only munge path if invoked as a script. Testrunners should have setup + # the paths already + sys.path.insert(0, os.path.abspath(os.path.join(os.pardir, os.pardir))) + + +from pytz.lazy import LazyList, LazySet + + +class LazyListTestCase(unittest.TestCase): + initial_data = [3,2,1] + + def setUp(self): + self.base = [3, 2, 1] + self.lesser = [2, 1, 0] + self.greater = [4, 3, 2] + + self.lazy = LazyList(iter(list(self.base))) + + def test_unary_ops(self): + unary_ops = [str, repr, len, bool, not_] + try: + unary_ops.append(unicode) + except NameError: + pass # unicode no longer exists in Python 3. + + for op in unary_ops: + self.assertEqual( + op(self.lazy), + op(self.base), str(op)) + + def test_binary_ops(self): + binary_ops = [eq, ge, gt, le, lt, ne, add, concat] + try: + binary_ops.append(cmp) + except NameError: + pass # cmp no longer exists in Python 3. + + for op in binary_ops: + self.assertEqual( + op(self.lazy, self.lazy), + op(self.base, self.base), str(op)) + for other in [self.base, self.lesser, self.greater]: + self.assertEqual( + op(self.lazy, other), + op(self.base, other), '%s %s' % (op, other)) + self.assertEqual( + op(other, self.lazy), + op(other, self.base), '%s %s' % (op, other)) + + # Multiplication + self.assertEqual(self.lazy * 3, self.base * 3) + self.assertEqual(3 * self.lazy, 3 * self.base) + + # Contains + self.assertTrue(2 in self.lazy) + self.assertFalse(42 in self.lazy) + + def test_iadd(self): + self.lazy += [1] + self.base += [1] + self.assertEqual(self.lazy, self.base) + + def test_bool(self): + self.assertTrue(bool(self.lazy)) + self.assertFalse(bool(LazyList())) + self.assertFalse(bool(LazyList(iter([])))) + + def test_hash(self): + self.assertRaises(TypeError, hash, self.lazy) + + def test_isinstance(self): + self.assertTrue(isinstance(self.lazy, list)) + self.assertFalse(isinstance(self.lazy, tuple)) + + def test_callable(self): + try: + callable + except NameError: + return # No longer exists with Python 3. + self.assertFalse(callable(self.lazy)) + + def test_append(self): + self.base.append('extra') + self.lazy.append('extra') + self.assertEqual(self.lazy, self.base) + + def test_count(self): + self.assertEqual(self.lazy.count(2), 1) + + def test_index(self): + self.assertEqual(self.lazy.index(2), 1) + + def test_extend(self): + self.base.extend([6, 7]) + self.lazy.extend([6, 7]) + self.assertEqual(self.lazy, self.base) + + def test_insert(self): + self.base.insert(0, 'ping') + self.lazy.insert(0, 'ping') + self.assertEqual(self.lazy, self.base) + + def test_pop(self): + self.assertEqual(self.lazy.pop(), self.base.pop()) + self.assertEqual(self.lazy, self.base) + + def test_remove(self): + self.base.remove(2) + self.lazy.remove(2) + self.assertEqual(self.lazy, self.base) + + def test_reverse(self): + self.base.reverse() + self.lazy.reverse() + self.assertEqual(self.lazy, self.base) + + def test_reversed(self): + self.assertEqual(list(reversed(self.lazy)), list(reversed(self.base))) + + def test_sort(self): + self.base.sort() + self.assertNotEqual(self.lazy, self.base, 'Test data already sorted') + self.lazy.sort() + self.assertEqual(self.lazy, self.base) + + def test_sorted(self): + self.assertEqual(sorted(self.lazy), sorted(self.base)) + + def test_getitem(self): + for idx in range(-len(self.base), len(self.base)): + self.assertEqual(self.lazy[idx], self.base[idx]) + + def test_setitem(self): + for idx in range(-len(self.base), len(self.base)): + self.base[idx] = idx + 1000 + self.assertNotEqual(self.lazy, self.base) + self.lazy[idx] = idx + 1000 + self.assertEqual(self.lazy, self.base) + + def test_delitem(self): + del self.base[0] + self.assertNotEqual(self.lazy, self.base) + del self.lazy[0] + self.assertEqual(self.lazy, self.base) + + del self.base[-2] + self.assertNotEqual(self.lazy, self.base) + del self.lazy[-2] + self.assertEqual(self.lazy, self.base) + + def test_iter(self): + self.assertEqual(list(iter(self.lazy)), list(iter(self.base))) + + def test_getslice(self): + for i in range(-len(self.base), len(self.base)): + for j in range(-len(self.base), len(self.base)): + for step in [-1, 1]: + self.assertEqual(self.lazy[i:j:step], self.base[i:j:step]) + + def test_setslice(self): + for i in range(-len(self.base), len(self.base)): + for j in range(-len(self.base), len(self.base)): + for step in [-1, 1]: + replacement = range(0, len(self.base[i:j:step])) + self.base[i:j:step] = replacement + self.lazy[i:j:step] = replacement + self.assertEqual(self.lazy, self.base) + + def test_delslice(self): + del self.base[0:1] + del self.lazy[0:1] + self.assertEqual(self.lazy, self.base) + + del self.base[-1:1:-1] + del self.lazy[-1:1:-1] + self.assertEqual(self.lazy, self.base) + + +class LazySetTestCase(unittest.TestCase): + initial_data = set([3,2,1]) + + def setUp(self): + self.base = set([3, 2, 1]) + self.lazy = LazySet(iter(set(self.base))) + + def test_unary_ops(self): + # These ops just need to work. + unary_ops = [str, repr] + try: + unary_ops.append(unicode) + except NameError: + pass # unicode no longer exists in Python 3. + + for op in unary_ops: + op(self.lazy) # These ops just need to work. + + # These ops should return identical values as a real set. + unary_ops = [len, bool, not_] + + for op in unary_ops: + self.assertEqual( + op(self.lazy), + op(self.base), '%s(lazy) == %r' % (op, op(self.lazy))) + + def test_binary_ops(self): + binary_ops = [eq, ge, gt, le, lt, ne, sub, and_, or_, xor] + try: + binary_ops.append(cmp) + except NameError: + pass # cmp no longer exists in Python 3. + + for op in binary_ops: + self.assertEqual( + op(self.lazy, self.lazy), + op(self.base, self.base), str(op)) + self.assertEqual( + op(self.lazy, self.base), + op(self.base, self.base), str(op)) + self.assertEqual( + op(self.base, self.lazy), + op(self.base, self.base), str(op)) + + # Contains + self.assertTrue(2 in self.lazy) + self.assertFalse(42 in self.lazy) + + def test_iops(self): + try: + iops = [isub, iand, ior, ixor] + except NameError: + return # Don't exist in older Python versions. + for op in iops: + # Mutating operators, so make fresh copies. + lazy = LazySet(self.base) + base = self.base.copy() + op(lazy, set([1])) + op(base, set([1])) + self.assertEqual(lazy, base, str(op)) + + def test_bool(self): + self.assertTrue(bool(self.lazy)) + self.assertFalse(bool(LazySet())) + self.assertFalse(bool(LazySet(iter([])))) + + def test_hash(self): + self.assertRaises(TypeError, hash, self.lazy) + + def test_isinstance(self): + self.assertTrue(isinstance(self.lazy, set)) + + def test_callable(self): + try: + callable + except NameError: + return # No longer exists with Python 3. + self.assertFalse(callable(self.lazy)) + + def test_add(self): + self.base.add('extra') + self.lazy.add('extra') + self.assertEqual(self.lazy, self.base) + + def test_copy(self): + self.assertEqual(self.lazy.copy(), self.base) + + def test_method_ops(self): + ops = [ + 'difference', 'intersection', 'isdisjoint', + 'issubset', 'issuperset', 'symmetric_difference', 'union', + 'difference_update', 'intersection_update', + 'symmetric_difference_update', 'update'] + for op in ops: + if not hasattr(set, op): + continue # Not in this version of Python. + # Make a copy, as some of the ops are mutating. + lazy = LazySet(set(self.base)) + base = set(self.base) + self.assertEqual( + getattr(self.lazy, op)(set([1])), + getattr(self.base, op)(set([1])), op) + self.assertEqual(self.lazy, self.base, op) + + def test_discard(self): + self.base.discard(1) + self.assertNotEqual(self.lazy, self.base) + self.lazy.discard(1) + self.assertEqual(self.lazy, self.base) + + def test_pop(self): + self.assertEqual(self.lazy.pop(), self.base.pop()) + self.assertEqual(self.lazy, self.base) + + def test_remove(self): + self.base.remove(2) + self.lazy.remove(2) + self.assertEqual(self.lazy, self.base) + + def test_clear(self): + self.lazy.clear() + self.assertEqual(self.lazy, set()) + + +if __name__ == '__main__': + warnings.simplefilter("error") # Warnings should be fatal in tests. + unittest.main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz/tests/test_tzinfo.py new/pytz-2013.9/pytz/tests/test_tzinfo.py --- old/pytz-2013.8/pytz/tests/test_tzinfo.py 2013-11-05 13:49:48.000000000 +0100 +++ new/pytz-2013.9/pytz/tests/test_tzinfo.py 2014-01-03 11:30:24.000000000 +0100 @@ -21,7 +21,8 @@ # I test for expected version to ensure the correct version of pytz is # actually being tested. -EXPECTED_VERSION='2013.8' +EXPECTED_VERSION='2013.9' +EXPECTED_OLSON_VERSION='2013i' fmt = '%Y-%m-%d %H:%M:%S %Z%z' @@ -64,8 +65,12 @@ self.assertEqual(EXPECTED_VERSION, pytz.__version__, 'Incorrect pytz version loaded. Import path is stuffed ' 'or this test needs updating. (Wanted %s, got %s)' - % (EXPECTED_VERSION, pytz.__version__) - ) + % (EXPECTED_VERSION, pytz.__version__)) + + self.assertEqual(EXPECTED_OLSON_VERSION, pytz.OLSON_VERSION, + 'Incorrect pytz version loaded. Import path is stuffed ' + 'or this test needs updating. (Wanted %s, got %s)' + % (EXPECTED_VERSION, pytz.__version__)) def testGMT(self): now = datetime.now(tz=GMT) Files old/pytz-2013.8/pytz/zoneinfo/America/Havana and new/pytz-2013.9/pytz/zoneinfo/America/Havana differ Files old/pytz-2013.8/pytz/zoneinfo/Asia/Amman and new/pytz-2013.9/pytz/zoneinfo/Asia/Amman differ Files old/pytz-2013.8/pytz/zoneinfo/Asia/Riyadh87 and new/pytz-2013.9/pytz/zoneinfo/Asia/Riyadh87 differ Files old/pytz-2013.8/pytz/zoneinfo/Asia/Riyadh88 and new/pytz-2013.9/pytz/zoneinfo/Asia/Riyadh88 differ Files old/pytz-2013.8/pytz/zoneinfo/Asia/Riyadh89 and new/pytz-2013.9/pytz/zoneinfo/Asia/Riyadh89 differ Files old/pytz-2013.8/pytz/zoneinfo/Cuba and new/pytz-2013.9/pytz/zoneinfo/Cuba differ Files old/pytz-2013.8/pytz/zoneinfo/Mideast/Riyadh87 and new/pytz-2013.9/pytz/zoneinfo/Mideast/Riyadh87 differ Files old/pytz-2013.8/pytz/zoneinfo/Mideast/Riyadh88 and new/pytz-2013.9/pytz/zoneinfo/Mideast/Riyadh88 differ Files old/pytz-2013.8/pytz/zoneinfo/Mideast/Riyadh89 and new/pytz-2013.9/pytz/zoneinfo/Mideast/Riyadh89 differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz.egg-info/PKG-INFO new/pytz-2013.9/pytz.egg-info/PKG-INFO --- old/pytz-2013.8/pytz.egg-info/PKG-INFO 2013-11-05 13:49:55.000000000 +0100 +++ new/pytz-2013.9/pytz.egg-info/PKG-INFO 2014-01-03 11:33:53.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: pytz -Version: 2013.8 +Version: 2013.9 Summary: World timezone definitions, modern and historical Home-page: http://pythonhosted.org/pytz Author: Stuart Bishop diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.8/pytz.egg-info/SOURCES.txt new/pytz-2013.9/pytz.egg-info/SOURCES.txt --- old/pytz-2013.8/pytz.egg-info/SOURCES.txt 2013-11-05 13:49:55.000000000 +0100 +++ new/pytz-2013.9/pytz.egg-info/SOURCES.txt 2014-01-03 11:33:53.000000000 +0100 @@ -15,6 +15,7 @@ pytz.egg-info/top_level.txt pytz.egg-info/zip-safe pytz/tests/test_docs.py +pytz/tests/test_lazy.py pytz/tests/test_tzinfo.py pytz/zoneinfo/CET pytz/zoneinfo/CST6CDT @@ -362,9 +363,6 @@ pytz/zoneinfo/Asia/Qyzylorda pytz/zoneinfo/Asia/Rangoon pytz/zoneinfo/Asia/Riyadh -pytz/zoneinfo/Asia/Riyadh87 -pytz/zoneinfo/Asia/Riyadh88 -pytz/zoneinfo/Asia/Riyadh89 pytz/zoneinfo/Asia/Saigon pytz/zoneinfo/Asia/Sakhalin pytz/zoneinfo/Asia/Samarkand @@ -547,9 +545,6 @@ pytz/zoneinfo/Mexico/BajaNorte pytz/zoneinfo/Mexico/BajaSur pytz/zoneinfo/Mexico/General -pytz/zoneinfo/Mideast/Riyadh87 -pytz/zoneinfo/Mideast/Riyadh88 -pytz/zoneinfo/Mideast/Riyadh89 pytz/zoneinfo/Pacific/Apia pytz/zoneinfo/Pacific/Auckland pytz/zoneinfo/Pacific/Chatham -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
