alpcentaur
/
basabuuka_prototyp


								Metadata-Version: 2.0

								Name: pytz

								Version: 2018.7

								Summary: World timezone definitions, modern and historical

								Home-page: http://pythonhosted.org/pytz

								Author: Stuart Bishop

								Author-email: stuart@stuartbishop.net

								Maintainer: Stuart Bishop

								Maintainer-email: stuart@stuartbishop.net

								License: MIT

								Download-URL: https://pypi.org/project/pytz/

								Keywords: timezone,tzinfo,datetime,olson,time

								Platform: Independent

								Classifier: Development Status :: 6 - Mature

								Classifier: Intended Audience :: Developers

								Classifier: License :: OSI Approved :: MIT License

								Classifier: Natural Language :: English

								Classifier: Operating System :: OS Independent

								Classifier: Programming Language :: Python

								Classifier: Programming Language :: Python :: 2

								Classifier: Programming Language :: Python :: 2.4

								Classifier: Programming Language :: Python :: 2.5

								Classifier: Programming Language :: Python :: 2.6

								Classifier: Programming Language :: Python :: 2.7

								Classifier: Programming Language :: Python :: 3

								Classifier: Programming Language :: Python :: 3.0

								Classifier: Programming Language :: Python :: 3.1

								Classifier: Programming Language :: Python :: 3.2

								Classifier: Programming Language :: Python :: 3.3

								Classifier: Programming Language :: Python :: 3.4

								Classifier: Programming Language :: Python :: 3.5

								Classifier: Programming Language :: Python :: 3.6

								Classifier: Topic :: Software Development :: Libraries :: Python Modules


								pytz - World Timezone Definitions for Python

								============================================


								:Author: Stuart Bishop <stuart@stuartbishop.net>


								Introduction

								~~~~~~~~~~~~


								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 saving time, which you can read more about in the Python

								Library Reference (``datetime.tzinfo``).


								Almost all of the Olson timezones are supported.


								.. note::


								    This library differs from the documented Python API for

								    tzinfo implementations; if you want to create local wallclock

								    times you need to use the ``localize()`` method documented in this

								    document. In addition, if you perform date arithmetic on local

								    times that cross DST boundaries, the result may be in an incorrect

								    timezone (ie. subtract 1 minute from 2002-10-27 1:00 EST and you get

								    2002-10-27 0:59 EST instead of the correct 2002-10-27 1:59 EDT). A

								    ``normalize()`` method is provided to correct this. Unfortunately these

								    issues cannot be resolved without modifying the Python datetime

								    implementation (see PEP-431).


								Installation

								~~~~~~~~~~~~


								This package can either be installed from a .egg file using setuptools,

								or from the tarball using the standard Python distutils.


								If you are installing from a tarball, run the following command as an

								administrative user::


								    python setup.py install


								If you are installing using setuptools, you don't even need to download

								anything as the latest version will be downloaded for you

								from the Python package index::


								    easy_install --upgrade pytz


								If you already have the .egg file, you can use that too::


								    easy_install pytz-2008g-py2.6.egg


								Example & Usage

								~~~~~~~~~~~~~~~


								Localized times and date arithmetic

								-----------------------------------


								>>> from datetime import datetime, timedelta

								>>> from pytz import timezone

								>>> import pytz

								>>> utc = pytz.utc

								>>> utc.zone

								'UTC'

								>>> eastern = timezone('US/Eastern')

								>>> eastern.zone

								'US/Eastern'

								>>> amsterdam = timezone('Europe/Amsterdam')

								>>> fmt = '%Y-%m-%d %H:%M:%S %Z%z'


								This library only supports two ways of building a localized time. The

								first is to use the ``localize()`` method provided by the pytz library.

								This is used to localize a naive datetime (datetime with no timezone

								information):


								>>> loc_dt = eastern.localize(datetime(2002, 10, 27, 6, 0, 0))

								>>> print(loc_dt.strftime(fmt))

								2002-10-27 06:00:00 EST-0500


								The second way of building a localized time is by converting an existing

								localized time using the standard ``astimezone()`` method:


								>>> ams_dt = loc_dt.astimezone(amsterdam)

								>>> ams_dt.strftime(fmt)

								'2002-10-27 12:00:00 CET+0100'


								Unfortunately using the tzinfo argument of the standard datetime

								constructors ''does not work'' with pytz for many timezones.


								>>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt)  # /!\ Does not work this way!

								'2002-10-27 12:00:00 LMT+0020'


								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)  # /!\ Not recommended except for UTC

								'2002-10-27 12:00:00 UTC+0000'


								The preferred way of dealing with times is to always work in UTC,

								converting to localtime only when generating output to be read

								by humans.


								>>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)

								>>> loc_dt = utc_dt.astimezone(eastern)

								>>> loc_dt.strftime(fmt)

								'2002-10-27 01:00:00 EST-0500'


								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 saving time

								and other timezone transitions. In this example, ``loc_dt`` is set

								to the instant when daylight saving time ends in the US/Eastern

								timezone.


								>>> before = loc_dt - timedelta(minutes=10)

								>>> before.strftime(fmt)

								'2002-10-27 00:50:00 EST-0500'

								>>> eastern.normalize(before).strftime(fmt)

								'2002-10-27 01:50:00 EDT-0400'

								>>> after = eastern.normalize(before + timedelta(minutes=20))

								>>> after.strftime(fmt)

								'2002-10-27 01:10:00 EST-0500'


								Creating local times is also tricky, and the reason why working with

								local times is not recommended. Unfortunately, you cannot just pass

								a ``tzinfo`` argument when constructing a datetime (see the next

								section for more details)


								>>> dt = datetime(2002, 10, 27, 1, 30, 0)

								>>> dt1 = eastern.localize(dt, is_dst=True)

								>>> dt1.strftime(fmt)

								'2002-10-27 01:30:00 EDT-0400'

								>>> dt2 = eastern.localize(dt, is_dst=False)

								>>> dt2.strftime(fmt)

								'2002-10-27 01:30:00 EST-0500'


								Converting between timezones is more easily done, using the

								standard astimezone method.


								>>> utc_dt = utc.localize(datetime.utcfromtimestamp(1143408899))

								>>> utc_dt.strftime(fmt)

								'2006-03-26 21:34:59 UTC+0000'

								>>> au_tz = timezone('Australia/Sydney')

								>>> au_dt = utc_dt.astimezone(au_tz)

								>>> au_dt.strftime(fmt)

								'2006-03-27 08:34:59 AEDT+1100'

								>>> utc_dt2 = au_dt.astimezone(utc)

								>>> utc_dt2.strftime(fmt)

								'2006-03-26 21:34:59 UTC+0000'

								>>> utc_dt == utc_dt2

								True


								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 saving time transitions to

								deal with.


								>>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc)

								>>> utc_dt.strftime(fmt)

								'2006-03-26 21:34:59 UTC+0000'

								>>> au_tz = timezone('Australia/Sydney')

								>>> au_dt = au_tz.normalize(utc_dt.astimezone(au_tz))

								>>> au_dt.strftime(fmt)

								'2006-03-27 08:34:59 AEDT+1100'

								>>> utc_dt2 = au_dt.astimezone(utc)

								>>> utc_dt2.strftime(fmt)

								'2006-03-26 21:34:59 UTC+0000'


								``tzinfo`` API

								--------------


								The ``tzinfo`` instances returned by the ``timezone()`` function have

								been extended to cope with ambiguous times by adding an ``is_dst``

								parameter to the ``utcoffset()``, ``dst()`` && ``tzname()`` methods.


								>>> tz = timezone('America/St_Johns')


								>>> normal = datetime(2009, 9, 1)

								>>> ambiguous = datetime(2009, 10, 31, 23, 30)


								The ``is_dst`` parameter is ignored for most timestamps. It is only used

								during DST transition ambiguous periods to resolve that ambiguity.


								>>> tz.utcoffset(normal, is_dst=True)

								datetime.timedelta(-1, 77400)

								>>> tz.dst(normal, is_dst=True)

								datetime.timedelta(0, 3600)

								>>> tz.tzname(normal, is_dst=True)

								'NDT'


								>>> tz.utcoffset(ambiguous, is_dst=True)

								datetime.timedelta(-1, 77400)

								>>> tz.dst(ambiguous, is_dst=True)

								datetime.timedelta(0, 3600)

								>>> tz.tzname(ambiguous, is_dst=True)

								'NDT'


								>>> tz.utcoffset(normal, is_dst=False)

								datetime.timedelta(-1, 77400)

								>>> tz.dst(normal, is_dst=False)

								datetime.timedelta(0, 3600)

								>>> tz.tzname(normal, is_dst=False)

								'NDT'


								>>> tz.utcoffset(ambiguous, is_dst=False)

								datetime.timedelta(-1, 73800)

								>>> tz.dst(ambiguous, is_dst=False)

								datetime.timedelta(0)

								>>> tz.tzname(ambiguous, is_dst=False)

								'NST'


								If ``is_dst`` is not specified, ambiguous timestamps will raise

								an ``pytz.exceptions.AmbiguousTimeError`` exception.


								>>> tz.utcoffset(normal)

								datetime.timedelta(-1, 77400)

								>>> tz.dst(normal)

								datetime.timedelta(0, 3600)

								>>> tz.tzname(normal)

								'NDT'


								>>> import pytz.exceptions

								>>> try:

								...     tz.utcoffset(ambiguous)

								... except pytz.exceptions.AmbiguousTimeError:

								...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)

								pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00

								>>> try:

								...     tz.dst(ambiguous)

								... except pytz.exceptions.AmbiguousTimeError:

								...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)

								pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00

								>>> try:

								...     tz.tzname(ambiguous)

								... except pytz.exceptions.AmbiguousTimeError:

								...     print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)

								pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00


								Problems with Localtime

								~~~~~~~~~~~~~~~~~~~~~~~


								The major problem we have to deal with is that certain datetimes

								may occur twice in a year. For example, in the US/Eastern timezone

								on the last Sunday morning in October, the following sequence

								happens:


								    - 01:00 EDT occurs

								    - 1 hour later, instead of 2:00am the clock is turned back 1 hour

								      and 01:00 happens again (this time 01:00 EST)


								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

								the standard datetime syntax, there is no way to specify if you meant

								before of after the end-of-daylight-saving-time transition. Using the

								pytz custom syntax, the best you can do is make an educated guess:


								>>> loc_dt = eastern.localize(datetime(2002, 10, 27, 1, 30, 00))

								>>> loc_dt.strftime(fmt)

								'2002-10-27 01:30:00 EST-0500'


								As you can see, the system has chosen one for you and there is a 50%

								chance of it being out by one hour. For some applications, this does

								not matter. However, if you are trying to schedule meetings with people

								in different timezones or analyze log files it is not acceptable.


								The best and simplest solution is to stick with using UTC.  The pytz

								package encourages using UTC for internal timezone representation by

								including a special UTC implementation based on the standard Python

								reference implementation in the Python documentation.


								The UTC timezone unpickles to be the same instance, and pickles to a

								smaller size than other pytz tzinfo instances.  The UTC implementation

								can be obtained as pytz.utc, pytz.UTC, or pytz.timezone('UTC').


								>>> import pickle, pytz

								>>> dt = datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc)

								>>> naive = dt.replace(tzinfo=None)

								>>> p = pickle.dumps(dt, 1)

								>>> naive_p = pickle.dumps(naive, 1)

								>>> len(p) - len(naive_p)

								17

								>>> new = pickle.loads(p)

								>>> new == dt

								True

								>>> new is dt

								False

								>>> new.tzinfo is dt.tzinfo

								True

								>>> pytz.utc is pytz.UTC is pytz.timezone('UTC')

								True


								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 == 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:


								>>> loc_dt = datetime(2002, 10, 27, 1, 30, 00)

								>>> est_dt = eastern.localize(loc_dt, is_dst=True)

								>>> edt_dt = eastern.localize(loc_dt, is_dst=False)

								>>> print(est_dt.strftime(fmt) + ' / ' + edt_dt.strftime(fmt))

								2002-10-27 01:30:00 EDT-0400 / 2002-10-27 01:30:00 EST-0500


								If you pass None as the is_dst flag to localize(), pytz will refuse to

								guess and raise exceptions if you try to build ambiguous or non-existent

								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 Saving

								Time:


								>>> dt = datetime(2002, 10, 27, 1, 30, 00)

								>>> try:

								...     eastern.localize(dt, is_dst=None)

								... except pytz.exceptions.AmbiguousTimeError:

								...     print('pytz.exceptions.AmbiguousTimeError: %s' % dt)

								pytz.exceptions.AmbiguousTimeError: 2002-10-27 01:30:00


								Similarly, 2:30am on 7th April 2002 never happened at all in the

								US/Eastern timezone, as the clocks where put forward at 2:00am skipping

								the entire hour:


								>>> dt = datetime(2002, 4, 7, 2, 30, 00)

								>>> try:

								...     eastern.localize(dt, is_dst=None)

								... except pytz.exceptions.NonExistentTimeError:

								...     print('pytz.exceptions.NonExistentTimeError: %s' % dt)

								pytz.exceptions.NonExistentTimeError: 2002-04-07 02:30:00


								Both of these exceptions share a common base class to make error handling

								easier:


								>>> isinstance(pytz.AmbiguousTimeError(), pytz.InvalidTimeError)

								True

								>>> isinstance(pytz.NonExistentTimeError(), pytz.InvalidTimeError)

								True


								A special case is where countries change their timezone definitions

								with no daylight savings time switch. For example, in 1915 Warsaw

								switched from Warsaw time to Central European time with no daylight savings

								transition. 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 saving time period. pytz handles this transition by

								treating the ambiguous period before the switch as daylight savings

								time, and the ambiguous period after as standard time.


								>>> warsaw = pytz.timezone('Europe/Warsaw')

								>>> amb_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=True)

								>>> amb_dt1.strftime(fmt)

								'1915-08-04 23:59:59 WMT+0124'

								>>> amb_dt2 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False)

								>>> amb_dt2.strftime(fmt)

								'1915-08-04 23:59:59 CET+0100'

								>>> switch_dt = warsaw.localize(datetime(1915, 8, 5, 00, 00, 00), is_dst=False)

								>>> switch_dt.strftime(fmt)

								'1915-08-05 00:00:00 CET+0100'

								>>> str(switch_dt - amb_dt1)

								'0:24:01'

								>>> str(switch_dt - amb_dt2)

								'0:00:01'


								The best way of creating a time during an ambiguous time period is

								by converting from another timezone such as UTC:


								>>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc)

								>>> utc_dt.astimezone(warsaw).strftime(fmt)

								'1915-08-04 23:36:00 CET+0100'


								The standard Python way of handling all these ambiguities is not to

								handle them, such as demonstrated in this example using the US/Eastern

								timezone definition from the Python documentation (Note that this

								implementation only works for dates between 1987 and 2006 - it is

								included for tests only!):


								>>> from pytz.reference import Eastern # pytz.reference only for tests

								>>> dt = datetime(2002, 10, 27, 0, 30, tzinfo=Eastern)

								>>> str(dt)

								'2002-10-27 00:30:00-04:00'

								>>> str(dt + timedelta(hours=1))

								'2002-10-27 01:30:00-05:00'

								>>> str(dt + timedelta(hours=2))

								'2002-10-27 02:30:00-05:00'

								>>> str(dt + timedelta(hours=3))

								'2002-10-27 03:30:00-05:00'


								Notice the first two results? At first glance you might think they are

								correct, but taking the UTC offset into account you find that they are

								actually two hours appart instead of the 1 hour we asked for.


								>>> from pytz.reference import UTC # pytz.reference only for tests

								>>> str(dt.astimezone(UTC))

								'2002-10-27 04:30:00+00:00'

								>>> str((dt + timedelta(hours=1)).astimezone(UTC))

								'2002-10-27 06:30:00+00:00'


								Country Information

								~~~~~~~~~~~~~~~~~~~


								A mechanism is provided to access the timezones commonly in use

								for a particular country, looked up using the ISO 3166 country code.

								It returns a list of strings that can be used to retrieve the relevant

								tzinfo instance using ``pytz.timezone()``:


								>>> print(' '.join(pytz.country_timezones['nz']))

								Pacific/Auckland Pacific/Chatham


								The Olson database comes with a ISO 3166 country code to English country

								name mapping that pytz exposes as a dictionary:


								>>> print(pytz.country_names['nz'])

								New Zealand


								What is UTC

								~~~~~~~~~~~


								'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

								~~~~~~~


								There are two lists of timezones provided.


								``all_timezones`` is the exhaustive list of the timezone names that can

								be used.


								>>> from pytz import all_timezones

								>>> len(all_timezones) >= 500

								True

								>>> 'Etc/Greenwich' in all_timezones

								True


								``common_timezones`` is a list of useful, current timezones. It doesn't

								contain deprecated zones or historical zones, except for a few I've

								deemed in common usage, such as US/Eastern (open a bug report if you

								think other timezones are deserving of being included here). It is also

								a sequence of strings.


								>>> from pytz import common_timezones

								>>> len(common_timezones) < len(all_timezones)

								True

								>>> 'Etc/Greenwich' in common_timezones

								False

								>>> 'Australia/Melbourne' in common_timezones

								True

								>>> 'US/Eastern' in common_timezones

								True

								>>> 'Canada/Eastern' in common_timezones

								True

								>>> 'Australia/Yancowinna' in all_timezones

								True

								>>> 'Australia/Yancowinna' in common_timezones

								False


								Both ``common_timezones`` and ``all_timezones`` are alphabetically

								sorted:


								>>> common_timezones_dupe = common_timezones[:]

								>>> common_timezones_dupe.sort()

								>>> common_timezones == common_timezones_dupe

								True

								>>> all_timezones_dupe = all_timezones[:]

								>>> all_timezones_dupe.sort()

								>>> all_timezones == all_timezones_dupe

								True


								``all_timezones`` and ``common_timezones`` are also available as sets.


								>>> from pytz import all_timezones_set, common_timezones_set

								>>> 'US/Eastern' in all_timezones_set

								True

								>>> 'US/Eastern' in common_timezones_set

								True

								>>> 'Australia/Victoria' in common_timezones_set

								False


								You can also retrieve lists of timezones used by particular countries

								using the ``country_timezones()`` function. It requires an ISO-3166

								two letter country code.


								>>> from pytz import country_timezones

								>>> print(' '.join(country_timezones('ch')))

								Europe/Zurich

								>>> print(' '.join(country_timezones('CH')))

								Europe/Zurich


								Internationalization - i18n/l10n

								~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


								Pytz is an interface to the IANA database, which uses ASCII names. The `Unicode  Consortium's Unicode Locales (CLDR) <http://cldr.unicode.org>`_

								project provides translations. Thomas Khyn's

								`l18n <https://pypi.org/project/l18n/>`_ package can be used to access

								these translations from Python.


								License

								~~~~~~~


								MIT license.


								This code is also available as part of Zope 3 under the Zope Public

								License,  Version 2.1 (ZPL).


								I'm happy to relicense this code if necessary for inclusion in other

								open source projects.


								Latest Versions

								~~~~~~~~~~~~~~~


								This package will be updated after releases of the Olson timezone

								database.  The latest version can be downloaded from the `Python Package

								Index <https://pypi.org/project/pytz/>`_.  The code that is used

								to generate this distribution is hosted on launchpad.net and available

								using git::


								    git clone https://git.launchpad.net/pytz


								A mirror on github is also available at https://github.com/stub42/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

								~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


								Bugs can be reported using `Launchpad <https://bugs.launchpad.net/pytz>`__.


								Issues & Limitations

								~~~~~~~~~~~~~~~~~~~~


								- Offsets from UTC are rounded to the nearest whole minute, so timezones

								  such as Europe/Amsterdam pre 1937 will be up to 30 seconds out. This

								  is a limitation of the Python datetime library.


								- If you think a timezone definition is incorrect, I probably can't fix

								  it. pytz is a direct translation of the Olson timezone database, and

								  changes to the timezone definitions need to be made to this source.

								  If you find errors they should be reported to the time zone mailing

								  list, linked from http://www.iana.org/time-zones.


								Further Reading

								~~~~~~~~~~~~~~~


								More info than you want to know about timezones:

								http://www.twinsun.com/tz/tz-link.htm


								Contact

								~~~~~~~


								Stuart Bishop <stuart@stuartbishop.net>