Hello community, here is the log from the commit of package python-pytz for openSUSE:Factory checked in at 2014-04-13 13:17:24 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 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 2014-01-16 15:12:37.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-pytz.new/python-pytz.changes 2014-04-13 13:17:25.000000000 +0200 @@ -1,0 +2,7 @@ +Sat Apr 12 16:35:55 UTC 2014 - [email protected] + +- Update to pytz 2014.2 + + Olson/IANA databse version 2014b + + No code changes in this release + +------------------------------------------------------------------- Old: ---- pytz-2013.9.tar.bz2 New: ---- pytz-2014.2.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-pytz.spec ++++++ --- /var/tmp/diff_new_pack.V9xp7Y/_old 2014-04-13 13:17:25.000000000 +0200 +++ /var/tmp/diff_new_pack.V9xp7Y/_new 2014-04-13 13:17:25.000000000 +0200 @@ -17,25 +17,26 @@ Name: python-pytz -Version: 2013.9 +Version: 2014.2 Release: 0 -Url: http://pytz.sourceforge.net Summary: World timezone definitions, modern and historical License: MIT Group: Development/Languages/Python +Url: http://pytz.sourceforge.net Source: http://pypi.python.org/packages/source/p/pytz/pytz-%{version}.tar.bz2 -BuildRoot: %{_tmppath}/%{name}-%{version}-build -Provides: python-tz = 2013b -Obsoletes: python-tz < 2013b BuildRequires: fdupes BuildRequires: python-devel #BuildRequires: python-nose +BuildRoot: %{_tmppath}/%{name}-%{version}-build %if 0%{?suse_version} && 0%{?suse_version} <= 1110 %{!?python_sitelib: %global python_sitelib %(python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")} %else BuildArch: noarch %endif +Provides: python-tz = 2014b +Obsoletes: python-tz < 2014b + %description pytz - World Timezone Definitions for Python pytz brings the Olson tz database into Python. This library allows ++++++ pytz-2013.9.tar.bz2 -> pytz-2014.2.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.9/MANIFEST.in new/pytz-2014.2/MANIFEST.in --- old/pytz-2013.9/MANIFEST.in 2014-01-03 11:30:24.000000000 +0100 +++ 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.9/PKG-INFO new/pytz-2014.2/PKG-INFO --- old/pytz-2013.9/PKG-INFO 2014-01-03 11:33:58.000000000 +0100 +++ 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.9 +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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.9/README.txt new/pytz-2014.2/README.txt --- old/pytz-2013.9/README.txt 2014-01-03 11:30:24.000000000 +0100 +++ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.9/pytz/__init__.py new/pytz-2014.2/pytz/__init__.py --- old/pytz-2013.9/pytz/__init__.py 2014-01-03 11:30:24.000000000 +0100 +++ 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 = '2013i' -VERSION = '2013.9' # 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.9/pytz/tests/test_docs.py new/pytz-2014.2/pytz/tests/test_docs.py --- old/pytz-2013.9/pytz/tests/test_docs.py 2014-01-03 11:30:24.000000000 +0100 +++ 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.9/pytz/tests/test_tzinfo.py new/pytz-2014.2/pytz/tests/test_tzinfo.py --- old/pytz-2013.9/pytz/tests/test_tzinfo.py 2014-01-03 11:30:24.000000000 +0100 +++ new/pytz-2014.2/pytz/tests/test_tzinfo.py 2014-03-25 07:57:04.000000000 +0100 @@ -21,8 +21,8 @@ # I test for expected version to ensure the correct version of pytz is # actually being tested. -EXPECTED_VERSION='2013.9' -EXPECTED_OLSON_VERSION='2013i' +EXPECTED_VERSION='2014.2' +EXPECTED_OLSON_VERSION='2014b' fmt = '%Y-%m-%d %H:%M:%S %Z%z' @@ -70,7 +70,7 @@ 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__)) + % (EXPECTED_OLSON_VERSION, pytz.OLSON_VERSION)) def testGMT(self): now = datetime.now(tz=GMT) @@ -568,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.9/pytz/tzinfo.py new/pytz-2014.2/pytz/tzinfo.py --- old/pytz-2013.9/pytz/tzinfo.py 2014-01-03 11:30:24.000000000 +0100 +++ 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.9/pytz/zoneinfo/Antarctica/Troll and new/pytz-2014.2/pytz/zoneinfo/Antarctica/Troll differ Files old/pytz-2013.9/pytz/zoneinfo/Asia/Gaza and new/pytz-2014.2/pytz/zoneinfo/Asia/Gaza differ Files old/pytz-2013.9/pytz/zoneinfo/Asia/Hebron and new/pytz-2014.2/pytz/zoneinfo/Asia/Hebron differ Files old/pytz-2013.9/pytz/zoneinfo/Asia/Istanbul and new/pytz-2014.2/pytz/zoneinfo/Asia/Istanbul differ Files old/pytz-2013.9/pytz/zoneinfo/Asia/Jerusalem and new/pytz-2014.2/pytz/zoneinfo/Asia/Jerusalem differ Files old/pytz-2013.9/pytz/zoneinfo/Asia/Tel_Aviv and new/pytz-2014.2/pytz/zoneinfo/Asia/Tel_Aviv differ Files old/pytz-2013.9/pytz/zoneinfo/Europe/Istanbul and new/pytz-2014.2/pytz/zoneinfo/Europe/Istanbul differ Files old/pytz-2013.9/pytz/zoneinfo/Europe/Kiev and new/pytz-2014.2/pytz/zoneinfo/Europe/Kiev differ Files old/pytz-2013.9/pytz/zoneinfo/Europe/Simferopol and new/pytz-2014.2/pytz/zoneinfo/Europe/Simferopol differ Files old/pytz-2013.9/pytz/zoneinfo/Israel and new/pytz-2014.2/pytz/zoneinfo/Israel differ Files old/pytz-2013.9/pytz/zoneinfo/Pacific/Fiji and new/pytz-2014.2/pytz/zoneinfo/Pacific/Fiji differ Files old/pytz-2013.9/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.9/pytz/zoneinfo/zone.tab new/pytz-2014.2/pytz/zoneinfo/zone.tab --- old/pytz-2013.9/pytz/zoneinfo/zone.tab 2014-01-03 11:30:23.000000000 +0100 +++ 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.9/pytz.egg-info/PKG-INFO new/pytz-2014.2/pytz.egg-info/PKG-INFO --- old/pytz-2013.9/pytz.egg-info/PKG-INFO 2014-01-03 11:33:53.000000000 +0100 +++ 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.9 +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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/pytz-2013.9/pytz.egg-info/SOURCES.txt new/pytz-2014.2/pytz.egg-info/SOURCES.txt --- old/pytz-2013.9/pytz.egg-info/SOURCES.txt 2014-01-03 11:33:53.000000000 +0100 +++ new/pytz-2014.2/pytz.egg-info/SOURCES.txt 2014-03-25 07:57:08.000000000 +0100 @@ -294,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 -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
