METADATA 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619
  1. Metadata-Version: 2.0
  2. Name: pytz
  3. Version: 2019.1
  4. Summary: World timezone definitions, modern and historical
  5. Home-page: http://pythonhosted.org/pytz
  6. Author: Stuart Bishop
  7. Author-email: stuart@stuartbishop.net
  8. Maintainer: Stuart Bishop
  9. Maintainer-email: stuart@stuartbishop.net
  10. License: MIT
  11. Download-URL: https://pypi.org/project/pytz/
  12. Keywords: timezone,tzinfo,datetime,olson,time
  13. Platform: Independent
  14. Classifier: Development Status :: 6 - Mature
  15. Classifier: Intended Audience :: Developers
  16. Classifier: License :: OSI Approved :: MIT License
  17. Classifier: Natural Language :: English
  18. Classifier: Operating System :: OS Independent
  19. Classifier: Programming Language :: Python
  20. Classifier: Programming Language :: Python :: 2
  21. Classifier: Programming Language :: Python :: 2.4
  22. Classifier: Programming Language :: Python :: 2.5
  23. Classifier: Programming Language :: Python :: 2.6
  24. Classifier: Programming Language :: Python :: 2.7
  25. Classifier: Programming Language :: Python :: 3
  26. Classifier: Programming Language :: Python :: 3.0
  27. Classifier: Programming Language :: Python :: 3.1
  28. Classifier: Programming Language :: Python :: 3.2
  29. Classifier: Programming Language :: Python :: 3.3
  30. Classifier: Programming Language :: Python :: 3.4
  31. Classifier: Programming Language :: Python :: 3.5
  32. Classifier: Programming Language :: Python :: 3.6
  33. Classifier: Topic :: Software Development :: Libraries :: Python Modules
  34. pytz - World Timezone Definitions for Python
  35. ============================================
  36. :Author: Stuart Bishop <stuart@stuartbishop.net>
  37. Introduction
  38. ~~~~~~~~~~~~
  39. pytz brings the Olson tz database into Python. This library allows
  40. accurate and cross platform timezone calculations using Python 2.4
  41. or higher. It also solves the issue of ambiguous times at the end
  42. of daylight saving time, which you can read more about in the Python
  43. Library Reference (``datetime.tzinfo``).
  44. Almost all of the Olson timezones are supported.
  45. .. note::
  46. This library differs from the documented Python API for
  47. tzinfo implementations; if you want to create local wallclock
  48. times you need to use the ``localize()`` method documented in this
  49. document. In addition, if you perform date arithmetic on local
  50. times that cross DST boundaries, the result may be in an incorrect
  51. timezone (ie. subtract 1 minute from 2002-10-27 1:00 EST and you get
  52. 2002-10-27 0:59 EST instead of the correct 2002-10-27 1:59 EDT). A
  53. ``normalize()`` method is provided to correct this. Unfortunately these
  54. issues cannot be resolved without modifying the Python datetime
  55. implementation (see PEP-431).
  56. Installation
  57. ~~~~~~~~~~~~
  58. This package can either be installed using ``pip`` or from a tarball using the
  59. standard Python distutils.
  60. If you are installing using ``pip``, you don't need to download anything as the
  61. latest version will be downloaded for you from PyPI::
  62. pip install pytz
  63. If you are installing from a tarball, run the following command as an
  64. administrative user::
  65. python setup.py install
  66. Example & Usage
  67. ~~~~~~~~~~~~~~~
  68. Localized times and date arithmetic
  69. -----------------------------------
  70. >>> from datetime import datetime, timedelta
  71. >>> from pytz import timezone
  72. >>> import pytz
  73. >>> utc = pytz.utc
  74. >>> utc.zone
  75. 'UTC'
  76. >>> eastern = timezone('US/Eastern')
  77. >>> eastern.zone
  78. 'US/Eastern'
  79. >>> amsterdam = timezone('Europe/Amsterdam')
  80. >>> fmt = '%Y-%m-%d %H:%M:%S %Z%z'
  81. This library only supports two ways of building a localized time. The
  82. first is to use the ``localize()`` method provided by the pytz library.
  83. This is used to localize a naive datetime (datetime with no timezone
  84. information):
  85. >>> loc_dt = eastern.localize(datetime(2002, 10, 27, 6, 0, 0))
  86. >>> print(loc_dt.strftime(fmt))
  87. 2002-10-27 06:00:00 EST-0500
  88. The second way of building a localized time is by converting an existing
  89. localized time using the standard ``astimezone()`` method:
  90. >>> ams_dt = loc_dt.astimezone(amsterdam)
  91. >>> ams_dt.strftime(fmt)
  92. '2002-10-27 12:00:00 CET+0100'
  93. Unfortunately using the tzinfo argument of the standard datetime
  94. constructors ''does not work'' with pytz for many timezones.
  95. >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=amsterdam).strftime(fmt) # /!\ Does not work this way!
  96. '2002-10-27 12:00:00 LMT+0020'
  97. It is safe for timezones without daylight saving transitions though, such
  98. as UTC:
  99. >>> datetime(2002, 10, 27, 12, 0, 0, tzinfo=pytz.utc).strftime(fmt) # /!\ Not recommended except for UTC
  100. '2002-10-27 12:00:00 UTC+0000'
  101. The preferred way of dealing with times is to always work in UTC,
  102. converting to localtime only when generating output to be read
  103. by humans.
  104. >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
  105. >>> loc_dt = utc_dt.astimezone(eastern)
  106. >>> loc_dt.strftime(fmt)
  107. '2002-10-27 01:00:00 EST-0500'
  108. This library also allows you to do date arithmetic using local
  109. times, although it is more complicated than working in UTC as you
  110. need to use the ``normalize()`` method to handle daylight saving time
  111. and other timezone transitions. In this example, ``loc_dt`` is set
  112. to the instant when daylight saving time ends in the US/Eastern
  113. timezone.
  114. >>> before = loc_dt - timedelta(minutes=10)
  115. >>> before.strftime(fmt)
  116. '2002-10-27 00:50:00 EST-0500'
  117. >>> eastern.normalize(before).strftime(fmt)
  118. '2002-10-27 01:50:00 EDT-0400'
  119. >>> after = eastern.normalize(before + timedelta(minutes=20))
  120. >>> after.strftime(fmt)
  121. '2002-10-27 01:10:00 EST-0500'
  122. Creating local times is also tricky, and the reason why working with
  123. local times is not recommended. Unfortunately, you cannot just pass
  124. a ``tzinfo`` argument when constructing a datetime (see the next
  125. section for more details)
  126. >>> dt = datetime(2002, 10, 27, 1, 30, 0)
  127. >>> dt1 = eastern.localize(dt, is_dst=True)
  128. >>> dt1.strftime(fmt)
  129. '2002-10-27 01:30:00 EDT-0400'
  130. >>> dt2 = eastern.localize(dt, is_dst=False)
  131. >>> dt2.strftime(fmt)
  132. '2002-10-27 01:30:00 EST-0500'
  133. Converting between timezones is more easily done, using the
  134. standard astimezone method.
  135. >>> utc_dt = utc.localize(datetime.utcfromtimestamp(1143408899))
  136. >>> utc_dt.strftime(fmt)
  137. '2006-03-26 21:34:59 UTC+0000'
  138. >>> au_tz = timezone('Australia/Sydney')
  139. >>> au_dt = utc_dt.astimezone(au_tz)
  140. >>> au_dt.strftime(fmt)
  141. '2006-03-27 08:34:59 AEDT+1100'
  142. >>> utc_dt2 = au_dt.astimezone(utc)
  143. >>> utc_dt2.strftime(fmt)
  144. '2006-03-26 21:34:59 UTC+0000'
  145. >>> utc_dt == utc_dt2
  146. True
  147. You can take shortcuts when dealing with the UTC side of timezone
  148. conversions. ``normalize()`` and ``localize()`` are not really
  149. necessary when there are no daylight saving time transitions to
  150. deal with.
  151. >>> utc_dt = datetime.utcfromtimestamp(1143408899).replace(tzinfo=utc)
  152. >>> utc_dt.strftime(fmt)
  153. '2006-03-26 21:34:59 UTC+0000'
  154. >>> au_tz = timezone('Australia/Sydney')
  155. >>> au_dt = au_tz.normalize(utc_dt.astimezone(au_tz))
  156. >>> au_dt.strftime(fmt)
  157. '2006-03-27 08:34:59 AEDT+1100'
  158. >>> utc_dt2 = au_dt.astimezone(utc)
  159. >>> utc_dt2.strftime(fmt)
  160. '2006-03-26 21:34:59 UTC+0000'
  161. ``tzinfo`` API
  162. --------------
  163. The ``tzinfo`` instances returned by the ``timezone()`` function have
  164. been extended to cope with ambiguous times by adding an ``is_dst``
  165. parameter to the ``utcoffset()``, ``dst()`` && ``tzname()`` methods.
  166. >>> tz = timezone('America/St_Johns')
  167. >>> normal = datetime(2009, 9, 1)
  168. >>> ambiguous = datetime(2009, 10, 31, 23, 30)
  169. The ``is_dst`` parameter is ignored for most timestamps. It is only used
  170. during DST transition ambiguous periods to resolve that ambiguity.
  171. >>> tz.utcoffset(normal, is_dst=True)
  172. datetime.timedelta(-1, 77400)
  173. >>> tz.dst(normal, is_dst=True)
  174. datetime.timedelta(0, 3600)
  175. >>> tz.tzname(normal, is_dst=True)
  176. 'NDT'
  177. >>> tz.utcoffset(ambiguous, is_dst=True)
  178. datetime.timedelta(-1, 77400)
  179. >>> tz.dst(ambiguous, is_dst=True)
  180. datetime.timedelta(0, 3600)
  181. >>> tz.tzname(ambiguous, is_dst=True)
  182. 'NDT'
  183. >>> tz.utcoffset(normal, is_dst=False)
  184. datetime.timedelta(-1, 77400)
  185. >>> tz.dst(normal, is_dst=False)
  186. datetime.timedelta(0, 3600)
  187. >>> tz.tzname(normal, is_dst=False)
  188. 'NDT'
  189. >>> tz.utcoffset(ambiguous, is_dst=False)
  190. datetime.timedelta(-1, 73800)
  191. >>> tz.dst(ambiguous, is_dst=False)
  192. datetime.timedelta(0)
  193. >>> tz.tzname(ambiguous, is_dst=False)
  194. 'NST'
  195. If ``is_dst`` is not specified, ambiguous timestamps will raise
  196. an ``pytz.exceptions.AmbiguousTimeError`` exception.
  197. >>> tz.utcoffset(normal)
  198. datetime.timedelta(-1, 77400)
  199. >>> tz.dst(normal)
  200. datetime.timedelta(0, 3600)
  201. >>> tz.tzname(normal)
  202. 'NDT'
  203. >>> import pytz.exceptions
  204. >>> try:
  205. ... tz.utcoffset(ambiguous)
  206. ... except pytz.exceptions.AmbiguousTimeError:
  207. ... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  208. pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
  209. >>> try:
  210. ... tz.dst(ambiguous)
  211. ... except pytz.exceptions.AmbiguousTimeError:
  212. ... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  213. pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
  214. >>> try:
  215. ... tz.tzname(ambiguous)
  216. ... except pytz.exceptions.AmbiguousTimeError:
  217. ... print('pytz.exceptions.AmbiguousTimeError: %s' % ambiguous)
  218. pytz.exceptions.AmbiguousTimeError: 2009-10-31 23:30:00
  219. Problems with Localtime
  220. ~~~~~~~~~~~~~~~~~~~~~~~
  221. The major problem we have to deal with is that certain datetimes
  222. may occur twice in a year. For example, in the US/Eastern timezone
  223. on the last Sunday morning in October, the following sequence
  224. happens:
  225. - 01:00 EDT occurs
  226. - 1 hour later, instead of 2:00am the clock is turned back 1 hour
  227. and 01:00 happens again (this time 01:00 EST)
  228. In fact, every instant between 01:00 and 02:00 occurs twice. This means
  229. that if you try and create a time in the 'US/Eastern' timezone
  230. the standard datetime syntax, there is no way to specify if you meant
  231. before of after the end-of-daylight-saving-time transition. Using the
  232. pytz custom syntax, the best you can do is make an educated guess:
  233. >>> loc_dt = eastern.localize(datetime(2002, 10, 27, 1, 30, 00))
  234. >>> loc_dt.strftime(fmt)
  235. '2002-10-27 01:30:00 EST-0500'
  236. As you can see, the system has chosen one for you and there is a 50%
  237. chance of it being out by one hour. For some applications, this does
  238. not matter. However, if you are trying to schedule meetings with people
  239. in different timezones or analyze log files it is not acceptable.
  240. The best and simplest solution is to stick with using UTC. The pytz
  241. package encourages using UTC for internal timezone representation by
  242. including a special UTC implementation based on the standard Python
  243. reference implementation in the Python documentation.
  244. The UTC timezone unpickles to be the same instance, and pickles to a
  245. smaller size than other pytz tzinfo instances. The UTC implementation
  246. can be obtained as pytz.utc, pytz.UTC, or pytz.timezone('UTC').
  247. >>> import pickle, pytz
  248. >>> dt = datetime(2005, 3, 1, 14, 13, 21, tzinfo=utc)
  249. >>> naive = dt.replace(tzinfo=None)
  250. >>> p = pickle.dumps(dt, 1)
  251. >>> naive_p = pickle.dumps(naive, 1)
  252. >>> len(p) - len(naive_p)
  253. 17
  254. >>> new = pickle.loads(p)
  255. >>> new == dt
  256. True
  257. >>> new is dt
  258. False
  259. >>> new.tzinfo is dt.tzinfo
  260. True
  261. >>> pytz.utc is pytz.UTC is pytz.timezone('UTC')
  262. True
  263. Note that some other timezones are commonly thought of as the same (GMT,
  264. Greenwich, Universal, etc.). The definition of UTC is distinct from these
  265. other timezones, and they are not equivalent. For this reason, they will
  266. not compare the same in Python.
  267. >>> utc == pytz.timezone('GMT')
  268. False
  269. See the section `What is UTC`_, below.
  270. If you insist on working with local times, this library provides a
  271. facility for constructing them unambiguously:
  272. >>> loc_dt = datetime(2002, 10, 27, 1, 30, 00)
  273. >>> est_dt = eastern.localize(loc_dt, is_dst=True)
  274. >>> edt_dt = eastern.localize(loc_dt, is_dst=False)
  275. >>> print(est_dt.strftime(fmt) + ' / ' + edt_dt.strftime(fmt))
  276. 2002-10-27 01:30:00 EDT-0400 / 2002-10-27 01:30:00 EST-0500
  277. If you pass None as the is_dst flag to localize(), pytz will refuse to
  278. guess and raise exceptions if you try to build ambiguous or non-existent
  279. times.
  280. For example, 1:30am on 27th Oct 2002 happened twice in the US/Eastern
  281. timezone when the clocks where put back at the end of Daylight Saving
  282. Time:
  283. >>> dt = datetime(2002, 10, 27, 1, 30, 00)
  284. >>> try:
  285. ... eastern.localize(dt, is_dst=None)
  286. ... except pytz.exceptions.AmbiguousTimeError:
  287. ... print('pytz.exceptions.AmbiguousTimeError: %s' % dt)
  288. pytz.exceptions.AmbiguousTimeError: 2002-10-27 01:30:00
  289. Similarly, 2:30am on 7th April 2002 never happened at all in the
  290. US/Eastern timezone, as the clocks where put forward at 2:00am skipping
  291. the entire hour:
  292. >>> dt = datetime(2002, 4, 7, 2, 30, 00)
  293. >>> try:
  294. ... eastern.localize(dt, is_dst=None)
  295. ... except pytz.exceptions.NonExistentTimeError:
  296. ... print('pytz.exceptions.NonExistentTimeError: %s' % dt)
  297. pytz.exceptions.NonExistentTimeError: 2002-04-07 02:30:00
  298. Both of these exceptions share a common base class to make error handling
  299. easier:
  300. >>> isinstance(pytz.AmbiguousTimeError(), pytz.InvalidTimeError)
  301. True
  302. >>> isinstance(pytz.NonExistentTimeError(), pytz.InvalidTimeError)
  303. True
  304. A special case is where countries change their timezone definitions
  305. with no daylight savings time switch. For example, in 1915 Warsaw
  306. switched from Warsaw time to Central European time with no daylight savings
  307. transition. So at the stroke of midnight on August 5th 1915 the clocks
  308. were wound back 24 minutes creating an ambiguous time period that cannot
  309. be specified without referring to the timezone abbreviation or the
  310. actual UTC offset. In this case midnight happened twice, neither time
  311. during a daylight saving time period. pytz handles this transition by
  312. treating the ambiguous period before the switch as daylight savings
  313. time, and the ambiguous period after as standard time.
  314. >>> warsaw = pytz.timezone('Europe/Warsaw')
  315. >>> amb_dt1 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=True)
  316. >>> amb_dt1.strftime(fmt)
  317. '1915-08-04 23:59:59 WMT+0124'
  318. >>> amb_dt2 = warsaw.localize(datetime(1915, 8, 4, 23, 59, 59), is_dst=False)
  319. >>> amb_dt2.strftime(fmt)
  320. '1915-08-04 23:59:59 CET+0100'
  321. >>> switch_dt = warsaw.localize(datetime(1915, 8, 5, 00, 00, 00), is_dst=False)
  322. >>> switch_dt.strftime(fmt)
  323. '1915-08-05 00:00:00 CET+0100'
  324. >>> str(switch_dt - amb_dt1)
  325. '0:24:01'
  326. >>> str(switch_dt - amb_dt2)
  327. '0:00:01'
  328. The best way of creating a time during an ambiguous time period is
  329. by converting from another timezone such as UTC:
  330. >>> utc_dt = datetime(1915, 8, 4, 22, 36, tzinfo=pytz.utc)
  331. >>> utc_dt.astimezone(warsaw).strftime(fmt)
  332. '1915-08-04 23:36:00 CET+0100'
  333. The standard Python way of handling all these ambiguities is not to
  334. handle them, such as demonstrated in this example using the US/Eastern
  335. timezone definition from the Python documentation (Note that this
  336. implementation only works for dates between 1987 and 2006 - it is
  337. included for tests only!):
  338. >>> from pytz.reference import Eastern # pytz.reference only for tests
  339. >>> dt = datetime(2002, 10, 27, 0, 30, tzinfo=Eastern)
  340. >>> str(dt)
  341. '2002-10-27 00:30:00-04:00'
  342. >>> str(dt + timedelta(hours=1))
  343. '2002-10-27 01:30:00-05:00'
  344. >>> str(dt + timedelta(hours=2))
  345. '2002-10-27 02:30:00-05:00'
  346. >>> str(dt + timedelta(hours=3))
  347. '2002-10-27 03:30:00-05:00'
  348. Notice the first two results? At first glance you might think they are
  349. correct, but taking the UTC offset into account you find that they are
  350. actually two hours appart instead of the 1 hour we asked for.
  351. >>> from pytz.reference import UTC # pytz.reference only for tests
  352. >>> str(dt.astimezone(UTC))
  353. '2002-10-27 04:30:00+00:00'
  354. >>> str((dt + timedelta(hours=1)).astimezone(UTC))
  355. '2002-10-27 06:30:00+00:00'
  356. Country Information
  357. ~~~~~~~~~~~~~~~~~~~
  358. A mechanism is provided to access the timezones commonly in use
  359. for a particular country, looked up using the ISO 3166 country code.
  360. It returns a list of strings that can be used to retrieve the relevant
  361. tzinfo instance using ``pytz.timezone()``:
  362. >>> print(' '.join(pytz.country_timezones['nz']))
  363. Pacific/Auckland Pacific/Chatham
  364. The Olson database comes with a ISO 3166 country code to English country
  365. name mapping that pytz exposes as a dictionary:
  366. >>> print(pytz.country_names['nz'])
  367. New Zealand
  368. What is UTC
  369. ~~~~~~~~~~~
  370. 'UTC' is `Coordinated Universal Time`_. It is a successor to, but distinct
  371. from, Greenwich Mean Time (GMT) and the various definitions of Universal
  372. Time. UTC is now the worldwide standard for regulating clocks and time
  373. measurement.
  374. All other timezones are defined relative to UTC, and include offsets like
  375. UTC+0800 - hours to add or subtract from UTC to derive the local time. No
  376. daylight saving time occurs in UTC, making it a useful timezone to perform
  377. date arithmetic without worrying about the confusion and ambiguities caused
  378. by daylight saving time transitions, your country changing its timezone, or
  379. mobile computers that roam through multiple timezones.
  380. .. _Coordinated Universal Time: https://en.wikipedia.org/wiki/Coordinated_Universal_Time
  381. Helpers
  382. ~~~~~~~
  383. There are two lists of timezones provided.
  384. ``all_timezones`` is the exhaustive list of the timezone names that can
  385. be used.
  386. >>> from pytz import all_timezones
  387. >>> len(all_timezones) >= 500
  388. True
  389. >>> 'Etc/Greenwich' in all_timezones
  390. True
  391. ``common_timezones`` is a list of useful, current timezones. It doesn't
  392. contain deprecated zones or historical zones, except for a few I've
  393. deemed in common usage, such as US/Eastern (open a bug report if you
  394. think other timezones are deserving of being included here). It is also
  395. a sequence of strings.
  396. >>> from pytz import common_timezones
  397. >>> len(common_timezones) < len(all_timezones)
  398. True
  399. >>> 'Etc/Greenwich' in common_timezones
  400. False
  401. >>> 'Australia/Melbourne' in common_timezones
  402. True
  403. >>> 'US/Eastern' in common_timezones
  404. True
  405. >>> 'Canada/Eastern' in common_timezones
  406. True
  407. >>> 'Australia/Yancowinna' in all_timezones
  408. True
  409. >>> 'Australia/Yancowinna' in common_timezones
  410. False
  411. Both ``common_timezones`` and ``all_timezones`` are alphabetically
  412. sorted:
  413. >>> common_timezones_dupe = common_timezones[:]
  414. >>> common_timezones_dupe.sort()
  415. >>> common_timezones == common_timezones_dupe
  416. True
  417. >>> all_timezones_dupe = all_timezones[:]
  418. >>> all_timezones_dupe.sort()
  419. >>> all_timezones == all_timezones_dupe
  420. True
  421. ``all_timezones`` and ``common_timezones`` are also available as sets.
  422. >>> from pytz import all_timezones_set, common_timezones_set
  423. >>> 'US/Eastern' in all_timezones_set
  424. True
  425. >>> 'US/Eastern' in common_timezones_set
  426. True
  427. >>> 'Australia/Victoria' in common_timezones_set
  428. False
  429. You can also retrieve lists of timezones used by particular countries
  430. using the ``country_timezones()`` function. It requires an ISO-3166
  431. two letter country code.
  432. >>> from pytz import country_timezones
  433. >>> print(' '.join(country_timezones('ch')))
  434. Europe/Zurich
  435. >>> print(' '.join(country_timezones('CH')))
  436. Europe/Zurich
  437. Internationalization - i18n/l10n
  438. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  439. Pytz is an interface to the IANA database, which uses ASCII names. The `Unicode Consortium's Unicode Locales (CLDR) <http://cldr.unicode.org>`_
  440. project provides translations. Thomas Khyn's
  441. `l18n <https://pypi.org/project/l18n/>`_ package can be used to access
  442. these translations from Python.
  443. License
  444. ~~~~~~~
  445. MIT license.
  446. This code is also available as part of Zope 3 under the Zope Public
  447. License, Version 2.1 (ZPL).
  448. I'm happy to relicense this code if necessary for inclusion in other
  449. open source projects.
  450. Latest Versions
  451. ~~~~~~~~~~~~~~~
  452. This package will be updated after releases of the Olson timezone
  453. database. The latest version can be downloaded from the `Python Package
  454. Index <https://pypi.org/project/pytz/>`_. The code that is used
  455. to generate this distribution is hosted on launchpad.net and available
  456. using git::
  457. git clone https://git.launchpad.net/pytz
  458. A mirror on github is also available at https://github.com/stub42/pytz
  459. Announcements of new releases are made on
  460. `Launchpad <https://launchpad.net/pytz>`_, and the
  461. `Atom feed <http://feeds.launchpad.net/pytz/announcements.atom>`_
  462. hosted there.
  463. Bugs, Feature Requests & Patches
  464. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  465. Bugs can be reported using `Launchpad <https://bugs.launchpad.net/pytz>`__.
  466. Issues & Limitations
  467. ~~~~~~~~~~~~~~~~~~~~
  468. - Offsets from UTC are rounded to the nearest whole minute, so timezones
  469. such as Europe/Amsterdam pre 1937 will be up to 30 seconds out. This
  470. is a limitation of the Python datetime library.
  471. - If you think a timezone definition is incorrect, I probably can't fix
  472. it. pytz is a direct translation of the Olson timezone database, and
  473. changes to the timezone definitions need to be made to this source.
  474. If you find errors they should be reported to the time zone mailing
  475. list, linked from http://www.iana.org/time-zones.
  476. Further Reading
  477. ~~~~~~~~~~~~~~~
  478. More info than you want to know about timezones:
  479. http://www.twinsun.com/tz/tz-link.htm
  480. Contact
  481. ~~~~~~~
  482. Stuart Bishop <stuart@stuartbishop.net>