Hello community, here is the log from the commit of package python3-pytz for openSUSE:Factory checked in at 2014-05-09 06:58:43 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python3-pytz (Old) and /work/SRC/openSUSE:Factory/.python3-pytz.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python3-pytz" Changes: -------- --- /work/SRC/openSUSE:Factory/python3-pytz/python3-pytz.changes 2013-10-23 13:12:30.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.python3-pytz.new/python3-pytz.changes 2014-05-09 06:58:44.000000000 +0200 @@ -1,0 +2,12 @@ +Thu May 8 10:55:13 UTC 2014 - toddrme2...@gmail.com + +- Update to pytz 2014.2 + + Olson/IANA databse version 2014b + + No code changes in this release +- update to 2013.9: + - Olson database 2013i +- New upstream release 2013.8 + - IANA database version 2013h + - No code changes + +------------------------------------------------------------------- Old: ---- pytz-2013.7.tar.bz2 New: ---- pytz-2014.2.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python3-pytz.spec ++++++ --- /var/tmp/diff_new_pack.cUBRxg/_old 2014-05-09 06:58:44.000000000 +0200 +++ /var/tmp/diff_new_pack.cUBRxg/_new 2014-05-09 06:58:44.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package python3-pytz # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2015 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: python3-pytz -Version: 2013.7 +Version: 2014.2 Release: 0 Url: http://pytz.sourceforge.net Summary: World timezone definitions, modern and historical ++++++ pytz-2013.7.tar.bz2 -> pytz-2014.2.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/MANIFEST.in new/pytz-2014.2/MANIFEST.in --- old/pytz-2013.7/MANIFEST.in 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/MANIFEST.in 2014-03-25 07:57:03.000000000 +0100 @@ -1,5 +1,5 @@ include *.txt setup.py recursive-include pytz *.py -recursive-include pytz *.pot +#recursive-include pytz *.pot graft pytz/zoneinfo -exclude test_zdump.py +#exclude test_zdump.py diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/PKG-INFO new/pytz-2014.2/PKG-INFO --- old/pytz-2013.7/PKG-INFO 2013-10-02 06:28:19.000000000 +0200 +++ new/pytz-2014.2/PKG-INFO 2014-03-25 07:57:13.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: pytz -Version: 2013.7 +Version: 2014.2 Summary: World timezone definitions, modern and historical Home-page: http://pythonhosted.org/pytz Author: Stuart Bishop @@ -18,7 +18,7 @@ pytz brings the Olson tz database into Python. This library allows accurate and cross platform timezone calculations using Python 2.4 or higher. It also solves the issue of ambiguous times at the end - of daylight savings, which you can read more about in the Python + of daylight saving time, which you can read more about in the Python Library Reference (``datetime.tzinfo``). Almost all of the Olson timezones are supported. @@ -99,7 +99,7 @@ >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt) '2002-10-27 12:00:00 AMT+0020' - It is safe for timezones without daylight savings trasitions though, such + It is safe for timezones without daylight saving transitions though, such as UTC: >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt) @@ -116,9 +116,9 @@ This library also allows you to do date arithmetic using local times, although it is more complicated than working in UTC as you - need to use the ``normalize()`` method to handle daylight savings time + need to use the ``normalize()`` method to handle daylight saving time and other timezone transitions. In this example, ``loc_dt`` is set - to the instant when daylight savings time ends in the US/Eastern + to the instant when daylight saving time ends in the US/Eastern timezone. >>> before = loc_dt - timedelta(minutes=10) @@ -159,7 +159,7 @@ You can take shortcuts when dealing with the UTC side of timezone conversions. ``normalize()`` and ``localize()`` are not really - necessary when there are no daylight savings time transitions to + necessary when there are no daylight saving time transitions to deal with. >>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc) @@ -260,7 +260,7 @@ In fact, every instant between 01:00 and 02:00 occurs twice. This means that if you try and create a time in the 'US/Eastern' timezone using the standard datetime syntax, there is no way to specify if you meant - before of after the end-of-daylight-savings-time transition. + before of after the end-of-daylight-saving-time transition. >>> loc_dt = datetime(2002, 10, 27, 1, 30, 00, tzinfo=eastern) >>> loc_dt.strftime(fmt) @@ -297,12 +297,16 @@ >>> pytz.utc is pytz.UTC is pytz.timezone('UTC') True - Note that this instance is not the same instance (or implementation) as - other timezones with the same meaning (GMT, Greenwich, Universal, etc.). + Note that some other timezones are commonly thought of as the same (GMT, + Greenwich, Universal, etc.). The definition of UTC is distinct from these + other timezones, and they are not equivalent. For this reason, they will + not compare the same in Python. - >>> utc is pytz.timezone('GMT') + >>> utc == pytz.timezone('GMT') False + See the section `What is UTC`_, below. + If you insist on working with local times, this library provides a facility for constructing them unambiguously: @@ -317,7 +321,7 @@ times. For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern - timezone when the clocks where put back at the end of Daylight Savings + timezone when the clocks where put back at the end of Daylight Saving Time: >>> dt = datetime(2002, 10, 27, 1, 30, 00) @@ -348,13 +352,13 @@ Although ``localize()`` handles many cases, it is still not possible to handle all. In cases where countries change their timezone definitions, - cases like the end-of-daylight-savings-time occur with no way of resolving + cases like the end-of-daylight-saving-time occur with no way of resolving the ambiguity. For example, in 1915 Warsaw switched from Warsaw time to Central European time. So at the stroke of midnight on August 5th 1915 the clocks were wound back 24 minutes creating an ambiguous time period that cannot be specified without referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice, neither - time during a daylight savings time period: + time during a daylight saving time period: >>> warsaw = pytz.timezone('Europe/Warsaw') >>> loc_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False) @@ -368,7 +372,7 @@ The only way of creating a time during the missing 24 minutes is converting from another timezone - because neither of the timezones - involved where in daylight savings mode the API simply provides no way + involved where in daylight saving mode the API simply provides no way to express it: >>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc) @@ -424,13 +428,19 @@ What is UTC ~~~~~~~~~~~ - 'UTC' is Universal Time, also known as Greenwich Mean Time or GMT - in the United Kingdom. All other timezones are given as offsets from - UTC. No daylight savings time occurs in UTC, making it a useful timezone - to perform date arithmetic without worrying about the confusion and - ambiguities caused by daylight savings time transitions, your country - changing its timezone, or mobile computers that move roam through - multiple timezones. + 'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct + from, Greenwich Mean Time (GMT) and the various definitions of Universal + Time. UTC is now the worldwide standard for regulating clocks and time + measurement. + + All other timezones are defined relative to UTC, and include offsets like + UTC+0800 - hours to add or subtract from UTC to derive the local time. No + daylight saving time occurs in UTC, making it a useful timezone to perform + date arithmetic without worrying about the confusion and ambiguities caused + by daylight saving time transitions, your country changing its timezone, or + mobile computers that roam through multiple timezones. + + .. _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time Helpers @@ -526,6 +536,11 @@ bzr branch lp:pytz + Announcements of new releases are made on + `Launchpad <https://launchpad.net/pytz>`_, and the + `Atom feed <http://feeds.launchpad.net/pytz/announcements.atom>`_ + hosted there. + Bugs, Feature Requests & Patches ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/README.txt new/pytz-2014.2/README.txt --- old/pytz-2013.7/README.txt 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/README.txt 2014-03-25 07:57:03.000000000 +0100 @@ -9,7 +9,7 @@ pytz brings the Olson tz database into Python. This library allows accurate and cross platform timezone calculations using Python 2.4 or higher. It also solves the issue of ambiguous times at the end -of daylight savings, which you can read more about in the Python +of daylight saving time, which you can read more about in the Python Library Reference (``datetime.tzinfo``). Almost all of the Olson timezones are supported. @@ -90,7 +90,7 @@ >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt) '2002-10-27 12:00:00 AMT+0020' -It is safe for timezones without daylight savings trasitions though, such +It is safe for timezones without daylight saving transitions though, such as UTC: >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt) @@ -107,9 +107,9 @@ This library also allows you to do date arithmetic using local times, although it is more complicated than working in UTC as you -need to use the ``normalize()`` method to handle daylight savings time +need to use the ``normalize()`` method to handle daylight saving time and other timezone transitions. In this example, ``loc_dt`` is set -to the instant when daylight savings time ends in the US/Eastern +to the instant when daylight saving time ends in the US/Eastern timezone. >>> before = loc_dt - timedelta(minutes=10) @@ -150,7 +150,7 @@ You can take shortcuts when dealing with the UTC side of timezone conversions. ``normalize()`` and ``localize()`` are not really -necessary when there are no daylight savings time transitions to +necessary when there are no daylight saving time transitions to deal with. >>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc) @@ -251,7 +251,7 @@ In fact, every instant between 01:00 and 02:00 occurs twice. This means that if you try and create a time in the 'US/Eastern' timezone using the standard datetime syntax, there is no way to specify if you meant -before of after the end-of-daylight-savings-time transition. +before of after the end-of-daylight-saving-time transition. >>> loc_dt = datetime(2002, 10, 27, 1, 30, 00, tzinfo=eastern) >>> loc_dt.strftime(fmt) @@ -288,12 +288,16 @@ >>> pytz.utc is pytz.UTC is pytz.timezone('UTC') True -Note that this instance is not the same instance (or implementation) as -other timezones with the same meaning (GMT, Greenwich, Universal, etc.). +Note that some other timezones are commonly thought of as the same (GMT, +Greenwich, Universal, etc.). The definition of UTC is distinct from these +other timezones, and they are not equivalent. For this reason, they will +not compare the same in Python. ->>> utc is pytz.timezone('GMT') +>>> utc == pytz.timezone('GMT') False +See the section `What is UTC`_, below. + If you insist on working with local times, this library provides a facility for constructing them unambiguously: @@ -308,7 +312,7 @@ times. For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern -timezone when the clocks where put back at the end of Daylight Savings +timezone when the clocks where put back at the end of Daylight Saving Time: >>> dt = datetime(2002, 10, 27, 1, 30, 00) @@ -339,13 +343,13 @@ Although ``localize()`` handles many cases, it is still not possible to handle all. In cases where countries change their timezone definitions, -cases like the end-of-daylight-savings-time occur with no way of resolving +cases like the end-of-daylight-saving-time occur with no way of resolving the ambiguity. For example, in 1915 Warsaw switched from Warsaw time to Central European time. So at the stroke of midnight on August 5th 1915 the clocks were wound back 24 minutes creating an ambiguous time period that cannot be specified without referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice, neither -time during a daylight savings time period: +time during a daylight saving time period: >>> warsaw = pytz.timezone('Europe/Warsaw') >>> loc_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False) @@ -359,7 +363,7 @@ The only way of creating a time during the missing 24 minutes is converting from another timezone - because neither of the timezones -involved where in daylight savings mode the API simply provides no way +involved where in daylight saving mode the API simply provides no way to express it: >>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc) @@ -415,13 +419,19 @@ What is UTC ~~~~~~~~~~~ -'UTC' is Universal Time, also known as Greenwich Mean Time or GMT -in the United Kingdom. All other timezones are given as offsets from -UTC. No daylight savings time occurs in UTC, making it a useful timezone -to perform date arithmetic without worrying about the confusion and -ambiguities caused by daylight savings time transitions, your country -changing its timezone, or mobile computers that move roam through -multiple timezones. +'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct +from, Greenwich Mean Time (GMT) and the various definitions of Universal +Time. UTC is now the worldwide standard for regulating clocks and time +measurement. + +All other timezones are defined relative to UTC, and include offsets like +UTC+0800 - hours to add or subtract from UTC to derive the local time. No +daylight saving time occurs in UTC, making it a useful timezone to perform +date arithmetic without worrying about the confusion and ambiguities caused +by daylight saving time transitions, your country changing its timezone, or +mobile computers that roam through multiple timezones. + +.. _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time Helpers @@ -517,6 +527,11 @@ bzr branch lp:pytz +Announcements of new releases are made on +`Launchpad <https://launchpad.net/pytz>`_, and the +`Atom feed <http://feeds.launchpad.net/pytz/announcements.atom>`_ +hosted there. + Bugs, Feature Requests & Patches ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz/__init__.py new/pytz-2014.2/pytz/__init__.py --- old/pytz-2013.7/pytz/__init__.py 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/pytz/__init__.py 2014-03-25 07:57:04.000000000 +0100 @@ -9,8 +9,8 @@ ''' # The Olson database is updated several times a year. -OLSON_VERSION = '2013g' -VERSION = '2013.7' # Switching to pip compatible version numbering. +OLSON_VERSION = '2014b' +VERSION = '2014.2' # Switching to pip compatible version numbering. __version__ = VERSION OLSEN_VERSION = OLSON_VERSION # Old releases had this misspelling @@ -716,6 +716,7 @@ 'Antarctica/Rothera', 'Antarctica/South_Pole', 'Antarctica/Syowa', + 'Antarctica/Troll', 'Antarctica/Vostok', 'Arctic/Longyearbyen', 'Asia/Aden', @@ -1279,6 +1280,7 @@ 'Antarctica/Palmer', 'Antarctica/Rothera', 'Antarctica/Syowa', + 'Antarctica/Troll', 'Antarctica/Vostok', 'Arctic/Longyearbyen', 'Asia/Aden', diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz/lazy.py new/pytz-2014.2/pytz/lazy.py --- old/pytz-2013.7/pytz/lazy.py 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/pytz/lazy.py 2014-03-25 07:57:04.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.7/pytz/tests/test_docs.py new/pytz-2014.2/pytz/tests/test_docs.py --- old/pytz-2013.7/pytz/tests/test_docs.py 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/pytz/tests/test_docs.py 2014-03-25 07:57:04.000000000 +0100 @@ -1,35 +1,33 @@ # -*- coding: ascii -*- -from doctest import DocTestSuite -import unittest, os, os.path, sys -import warnings - -# We test the documentation this way instead of using DocFileSuite so -# we can run the tests under Python 2.3 -def test_README(): - pass - -this_dir = os.path.dirname(__file__) -locs = [ - os.path.join(this_dir, os.pardir, 'README.txt'), - os.path.join(this_dir, os.pardir, os.pardir, 'README.txt'), - ] -for loc in locs: - if os.path.exists(loc): - test_README.__doc__ = open(loc).read() - break -if test_README.__doc__ is None: - raise RuntimeError('README.txt not found') +from doctest import DocFileSuite +import unittest, os.path, sys + +THIS_DIR = os.path.dirname(__file__) + +README = os.path.join(THIS_DIR, os.pardir, os.pardir, 'README.txt') + + +class DocumentationTestCase(unittest.TestCase): + def test_readme_encoding(self): + '''Confirm the README.txt is pure ASCII.''' + f = open(README, 'rb') + try: + f.read().decode('US-ASCII') + finally: + f.close() def test_suite(): "For the Z3 test runner" - return DocTestSuite() + return unittest.TestSuite(( + DocumentationTestCase('test_readme_encoding'), + DocFileSuite(os.path.join(os.pardir, os.pardir, 'README.txt')))) if __name__ == '__main__': sys.path.insert(0, os.path.abspath(os.path.join( - this_dir, os.pardir, os.pardir + THIS_DIR, os.pardir, os.pardir ))) unittest.main(defaultTest='test_suite') diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz/tests/test_lazy.py new/pytz-2014.2/pytz/tests/test_lazy.py --- old/pytz-2013.7/pytz/tests/test_lazy.py 1970-01-01 01:00:00.000000000 +0100 +++ new/pytz-2014.2/pytz/tests/test_lazy.py 2014-03-25 07:57:04.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.7/pytz/tests/test_tzinfo.py new/pytz-2014.2/pytz/tests/test_tzinfo.py --- old/pytz-2013.7/pytz/tests/test_tzinfo.py 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/pytz/tests/test_tzinfo.py 2014-03-25 07:57:04.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.7' +EXPECTED_VERSION='2014.2' +EXPECTED_OLSON_VERSION='2014b' 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_OLSON_VERSION, pytz.OLSON_VERSION)) def testGMT(self): now = datetime.now(tz=GMT) @@ -563,8 +568,8 @@ def testHourBefore(self): # Python's datetime library has a bug, where the hour before - # a daylight savings transition is one hour out. For example, - # at the end of US/Eastern daylight savings time, 01:00 EST + # a daylight saving transition is one hour out. For example, + # at the end of US/Eastern daylight saving time, 01:00 EST # occurs twice (once at 05:00 UTC and once at 06:00 UTC), # whereas the first should actually be 01:00 EDT. # Note that this bug is by design - by accepting this ambiguity diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz/tzinfo.py new/pytz-2014.2/pytz/tzinfo.py --- old/pytz-2013.7/pytz/tzinfo.py 2013-10-02 06:26:07.000000000 +0200 +++ new/pytz-2014.2/pytz/tzinfo.py 2014-03-25 07:57:03.000000000 +0100 @@ -149,7 +149,7 @@ class DstTzInfo(BaseTzInfo): '''A timezone that has a variable offset from UTC - The offset might change if daylight savings time comes into effect, + The offset might change if daylight saving time comes into effect, or at a point in history when the region decides to change their timezone definition. ''' @@ -248,7 +248,7 @@ than passing a tzinfo argument to a datetime constructor. is_dst is used to determine the correct timezone in the ambigous - period at the end of daylight savings time. + period at the end of daylight saving time. >>> from pytz import timezone >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)' @@ -264,7 +264,7 @@ '1:00:00' Use is_dst=None to raise an AmbiguousTimeError for ambiguous - times at the end of daylight savings + times at the end of daylight saving time >>> try: ... loc_dt1 = amdam.localize(dt, is_dst=None) @@ -278,7 +278,7 @@ True is_dst is also used to determine the correct timezone in the - wallclock times jumped over at the start of daylight savings time. + wallclock times jumped over at the start of daylight saving time. >>> pacific = timezone('US/Pacific') >>> dt = datetime(2008, 3, 9, 2, 0, 0) Files old/pytz-2013.7/pytz/zoneinfo/Africa/Casablanca and new/pytz-2014.2/pytz/zoneinfo/Africa/Casablanca differ Files old/pytz-2013.7/pytz/zoneinfo/Africa/El_Aaiun and new/pytz-2014.2/pytz/zoneinfo/Africa/El_Aaiun differ Files old/pytz-2013.7/pytz/zoneinfo/Africa/Tripoli and new/pytz-2014.2/pytz/zoneinfo/Africa/Tripoli differ Files old/pytz-2013.7/pytz/zoneinfo/America/Eirunepe and new/pytz-2014.2/pytz/zoneinfo/America/Eirunepe differ Files old/pytz-2013.7/pytz/zoneinfo/America/Havana and new/pytz-2014.2/pytz/zoneinfo/America/Havana differ Files old/pytz-2013.7/pytz/zoneinfo/America/Porto_Acre and new/pytz-2014.2/pytz/zoneinfo/America/Porto_Acre differ Files old/pytz-2013.7/pytz/zoneinfo/America/Rio_Branco and new/pytz-2014.2/pytz/zoneinfo/America/Rio_Branco differ Files old/pytz-2013.7/pytz/zoneinfo/Antarctica/Troll and new/pytz-2014.2/pytz/zoneinfo/Antarctica/Troll differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Amman and new/pytz-2014.2/pytz/zoneinfo/Asia/Amman differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Gaza and new/pytz-2014.2/pytz/zoneinfo/Asia/Gaza differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Hebron and new/pytz-2014.2/pytz/zoneinfo/Asia/Hebron differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Istanbul and new/pytz-2014.2/pytz/zoneinfo/Asia/Istanbul differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Jerusalem and new/pytz-2014.2/pytz/zoneinfo/Asia/Jerusalem differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Riyadh87 and new/pytz-2014.2/pytz/zoneinfo/Asia/Riyadh87 differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Riyadh88 and new/pytz-2014.2/pytz/zoneinfo/Asia/Riyadh88 differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Riyadh89 and new/pytz-2014.2/pytz/zoneinfo/Asia/Riyadh89 differ Files old/pytz-2013.7/pytz/zoneinfo/Asia/Tel_Aviv and new/pytz-2014.2/pytz/zoneinfo/Asia/Tel_Aviv differ Files old/pytz-2013.7/pytz/zoneinfo/Brazil/Acre and new/pytz-2014.2/pytz/zoneinfo/Brazil/Acre differ Files old/pytz-2013.7/pytz/zoneinfo/Cuba and new/pytz-2014.2/pytz/zoneinfo/Cuba differ Files old/pytz-2013.7/pytz/zoneinfo/Europe/Istanbul and new/pytz-2014.2/pytz/zoneinfo/Europe/Istanbul differ Files old/pytz-2013.7/pytz/zoneinfo/Europe/Kiev and new/pytz-2014.2/pytz/zoneinfo/Europe/Kiev differ Files old/pytz-2013.7/pytz/zoneinfo/Europe/Simferopol and new/pytz-2014.2/pytz/zoneinfo/Europe/Simferopol differ Files old/pytz-2013.7/pytz/zoneinfo/Israel and new/pytz-2014.2/pytz/zoneinfo/Israel differ Files old/pytz-2013.7/pytz/zoneinfo/Libya and new/pytz-2014.2/pytz/zoneinfo/Libya differ Files old/pytz-2013.7/pytz/zoneinfo/Mideast/Riyadh87 and new/pytz-2014.2/pytz/zoneinfo/Mideast/Riyadh87 differ Files old/pytz-2013.7/pytz/zoneinfo/Mideast/Riyadh88 and new/pytz-2014.2/pytz/zoneinfo/Mideast/Riyadh88 differ Files old/pytz-2013.7/pytz/zoneinfo/Mideast/Riyadh89 and new/pytz-2014.2/pytz/zoneinfo/Mideast/Riyadh89 differ Files old/pytz-2013.7/pytz/zoneinfo/Pacific/Fiji and new/pytz-2014.2/pytz/zoneinfo/Pacific/Fiji differ Files old/pytz-2013.7/pytz/zoneinfo/Turkey and new/pytz-2014.2/pytz/zoneinfo/Turkey differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz/zoneinfo/zone.tab new/pytz-2014.2/pytz/zoneinfo/zone.tab --- old/pytz-2013.7/pytz/zoneinfo/zone.tab 2013-10-02 06:26:06.000000000 +0200 +++ new/pytz-2014.2/pytz/zoneinfo/zone.tab 2014-03-25 07:57:03.000000000 +0100 @@ -51,6 +51,7 @@ AQ -7824+10654 Antarctica/Vostok Vostok Station, Lake Vostok AQ -6640+14001 Antarctica/DumontDUrville Dumont-d'Urville Station, Terre Adelie AQ -690022+0393524 Antarctica/Syowa Syowa Station, E Ongul I +AQ -720041+0023206 Antarctica/Troll Troll Station, Queen Maud Land AR -3436-05827 America/Argentina/Buenos_Aires Buenos Aires (BA, CF) AR -3124-06411 America/Argentina/Cordoba most locations (CB, CC, CN, ER, FM, MN, SE, SF) AR -2447-06525 America/Argentina/Salta (SA, LP, NQ, RN) @@ -343,6 +344,7 @@ RU +5545+03735 Europe/Moscow Moscow+00 - west Russia RU +4844+04425 Europe/Volgograd Moscow+00 - Caspian Sea RU +5312+05009 Europe/Samara Moscow+00 - Samara, Udmurtia +RU +4457+03406 Europe/Simferopol Moscow+00 - Crimea RU +5651+06036 Asia/Yekaterinburg Moscow+02 - Urals RU +5500+07324 Asia/Omsk Moscow+03 - west Siberia RU +5502+08255 Asia/Novosibirsk Moscow+03 - Novosibirsk @@ -398,7 +400,6 @@ UA +5026+03031 Europe/Kiev most locations UA +4837+02218 Europe/Uzhgorod Ruthenia UA +4750+03510 Europe/Zaporozhye Zaporozh'ye, E Lugansk / Zaporizhia, E Luhansk -UA +4457+03406 Europe/Simferopol central Crimea UG +0019+03225 Africa/Kampala UM +1645-16931 Pacific/Johnston Johnston Atoll UM +2813-17722 Pacific/Midway Midway Islands diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz.egg-info/PKG-INFO new/pytz-2014.2/pytz.egg-info/PKG-INFO --- old/pytz-2013.7/pytz.egg-info/PKG-INFO 2013-10-02 06:28:12.000000000 +0200 +++ new/pytz-2014.2/pytz.egg-info/PKG-INFO 2014-03-25 07:57:08.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: pytz -Version: 2013.7 +Version: 2014.2 Summary: World timezone definitions, modern and historical Home-page: http://pythonhosted.org/pytz Author: Stuart Bishop @@ -18,7 +18,7 @@ pytz brings the Olson tz database into Python. This library allows accurate and cross platform timezone calculations using Python 2.4 or higher. It also solves the issue of ambiguous times at the end - of daylight savings, which you can read more about in the Python + of daylight saving time, which you can read more about in the Python Library Reference (``datetime.tzinfo``). Almost all of the Olson timezones are supported. @@ -99,7 +99,7 @@ >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt) '2002-10-27 12:00:00 AMT+0020' - It is safe for timezones without daylight savings trasitions though, such + It is safe for timezones without daylight saving transitions though, such as UTC: >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt) @@ -116,9 +116,9 @@ This library also allows you to do date arithmetic using local times, although it is more complicated than working in UTC as you - need to use the ``normalize()`` method to handle daylight savings time + need to use the ``normalize()`` method to handle daylight saving time and other timezone transitions. In this example, ``loc_dt`` is set - to the instant when daylight savings time ends in the US/Eastern + to the instant when daylight saving time ends in the US/Eastern timezone. >>> before = loc_dt - timedelta(minutes=10) @@ -159,7 +159,7 @@ You can take shortcuts when dealing with the UTC side of timezone conversions. ``normalize()`` and ``localize()`` are not really - necessary when there are no daylight savings time transitions to + necessary when there are no daylight saving time transitions to deal with. >>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc) @@ -260,7 +260,7 @@ In fact, every instant between 01:00 and 02:00 occurs twice. This means that if you try and create a time in the 'US/Eastern' timezone using the standard datetime syntax, there is no way to specify if you meant - before of after the end-of-daylight-savings-time transition. + before of after the end-of-daylight-saving-time transition. >>> loc_dt = datetime(2002, 10, 27, 1, 30, 00, tzinfo=eastern) >>> loc_dt.strftime(fmt) @@ -297,12 +297,16 @@ >>> pytz.utc is pytz.UTC is pytz.timezone('UTC') True - Note that this instance is not the same instance (or implementation) as - other timezones with the same meaning (GMT, Greenwich, Universal, etc.). + Note that some other timezones are commonly thought of as the same (GMT, + Greenwich, Universal, etc.). The definition of UTC is distinct from these + other timezones, and they are not equivalent. For this reason, they will + not compare the same in Python. - >>> utc is pytz.timezone('GMT') + >>> utc == pytz.timezone('GMT') False + See the section `What is UTC`_, below. + If you insist on working with local times, this library provides a facility for constructing them unambiguously: @@ -317,7 +321,7 @@ times. For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern - timezone when the clocks where put back at the end of Daylight Savings + timezone when the clocks where put back at the end of Daylight Saving Time: >>> dt = datetime(2002, 10, 27, 1, 30, 00) @@ -348,13 +352,13 @@ Although ``localize()`` handles many cases, it is still not possible to handle all. In cases where countries change their timezone definitions, - cases like the end-of-daylight-savings-time occur with no way of resolving + cases like the end-of-daylight-saving-time occur with no way of resolving the ambiguity. For example, in 1915 Warsaw switched from Warsaw time to Central European time. So at the stroke of midnight on August 5th 1915 the clocks were wound back 24 minutes creating an ambiguous time period that cannot be specified without referring to the timezone abbreviation or the actual UTC offset. In this case midnight happened twice, neither - time during a daylight savings time period: + time during a daylight saving time period: >>> warsaw = pytz.timezone('Europe/Warsaw') >>> loc_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False) @@ -368,7 +372,7 @@ The only way of creating a time during the missing 24 minutes is converting from another timezone - because neither of the timezones - involved where in daylight savings mode the API simply provides no way + involved where in daylight saving mode the API simply provides no way to express it: >>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc) @@ -424,13 +428,19 @@ What is UTC ~~~~~~~~~~~ - 'UTC' is Universal Time, also known as Greenwich Mean Time or GMT - in the United Kingdom. All other timezones are given as offsets from - UTC. No daylight savings time occurs in UTC, making it a useful timezone - to perform date arithmetic without worrying about the confusion and - ambiguities caused by daylight savings time transitions, your country - changing its timezone, or mobile computers that move roam through - multiple timezones. + 'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct + from, Greenwich Mean Time (GMT) and the various definitions of Universal + Time. UTC is now the worldwide standard for regulating clocks and time + measurement. + + All other timezones are defined relative to UTC, and include offsets like + UTC+0800 - hours to add or subtract from UTC to derive the local time. No + daylight saving time occurs in UTC, making it a useful timezone to perform + date arithmetic without worrying about the confusion and ambiguities caused + by daylight saving time transitions, your country changing its timezone, or + mobile computers that roam through multiple timezones. + + .. _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time Helpers @@ -526,6 +536,11 @@ bzr branch lp:pytz + Announcements of new releases are made on + `Launchpad <https://launchpad.net/pytz>`_, and the + `Atom feed <http://feeds.launchpad.net/pytz/announcements.atom>`_ + hosted there. + Bugs, Feature Requests & Patches ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.7/pytz.egg-info/SOURCES.txt new/pytz-2014.2/pytz.egg-info/SOURCES.txt --- old/pytz-2013.7/pytz.egg-info/SOURCES.txt 2013-10-02 06:28:12.000000000 +0200 +++ new/pytz-2014.2/pytz.egg-info/SOURCES.txt 2014-03-25 07:57:08.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 @@ -293,6 +294,7 @@ pytz/zoneinfo/Antarctica/Rothera pytz/zoneinfo/Antarctica/South_Pole pytz/zoneinfo/Antarctica/Syowa +pytz/zoneinfo/Antarctica/Troll pytz/zoneinfo/Antarctica/Vostok pytz/zoneinfo/Arctic/Longyearbyen pytz/zoneinfo/Asia/Aden @@ -362,9 +364,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 +546,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: opensuse-commit+unsubscr...@opensuse.org For additional commands, e-mail: opensuse-commit+h...@opensuse.org
