This file is indexed.

/usr/lib/python2.7/dist-packages/pytz-2014.10.egg-info/PKG-INFO is in python-tz 2014.10~dfsg1-0ubuntu2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
Metadata-Version: 1.1
Name: pytz
Version: 2014.10
Summary: World timezone definitions, modern and historical
Home-page: http://pythonhosted.org/pytz
Author: Stuart Bishop
Author-email: stuart@stuartbishop.net
License: MIT
Download-URL: http://pypi.python.org/pypi/pytz
Description: 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)
        '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)
        '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 also needs special attention. We also need
        to use the ``normalize()`` method to ensure the conversion is correct.
        
        >>> 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 = au_tz.normalize(utc_dt.astimezone(au_tz))
        >>> au_dt.strftime(fmt)
        '2006-03-27 08:34:59 AEDT+1100'
        >>> utc_dt2 = utc.normalize(au_dt.astimezone(utc))
        >>> utc_dt2.strftime(fmt)
        '2006-03-26 21:34:59 UTC+0000'
        
        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 resulve 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
        >>> 'US/Pacific-New' in all_timezones
        True
        >>> 'US/Pacific-New' 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
        
        
        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 <http://pypi.python.org/pypi/pytz/>`_.  The code that is used
        to generate this distribution is hosted on launchpad.net and available
        using the `Bazaar version control system <http://bazaar-vcs.org>`_
        using::
        
            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
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        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>
        
        
        
Keywords: timezone,tzinfo,datetime,olson,time
Platform: Independant
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 :: 3
Classifier: Topic :: Software Development :: Libraries :: Python Modules