Merge branch 'develop'

Author: sdispater

.travis.yml

@@ -6,14 +6,6 @@ matrix:
       env: PENDULUM_EXTENSIONS=1
     - python: 2.7
       env: PENDULUM_EXTENSIONS=0
-    - python: 3.2
-      env: PENDULUM_EXTENSIONS=1
-    - python: 3.2
-      env: PENDULUM_EXTENSIONS=0
-    - python: 3.3
-      env: PENDULUM_EXTENSIONS=1
-    - python: 3.3
-      env: PENDULUM_EXTENSIONS=0
     - python: 3.4
       env: PENDULUM_EXTENSIONS=1
     - python: 3.4

CHANGELOG.md

@@ -1,5 +1,23 @@
 # Change Log
 
+## [Unreleased]
+
+### Added
+
+- Added support for the alternative formatter's tokens in `from_format()`.
+- Added a `timezones` module attribute to expose available timezones.
+- Added the `exact` keyword to `parse()` which behaves exactly like `strict`.
+
+### Changed
+
+- Dropped support for Python 3.2 and 3.3.
+- The `classic` formatter in `from_format()` is now deprecated.
+
+### Fixed
+
+- Fixed `th` locale. (Thanks to [idxn](https://github.com/idxn))
+
+
 ## [1.2.5] - 2017-09-04
 
 ### Fixed
@@ -394,7 +412,7 @@ Initial release
 
 
 
-[Unreleased]: https://github.com/sdispater/pendulum/compare/1.2.5...master
+[Unreleased]: https://github.com/sdispater/pendulum/compare/master...develop
 [1.2.5]: https://github.com/sdispater/pendulum/releases/tag/1.2.5
 [1.2.4]: https://github.com/sdispater/pendulum/releases/tag/1.2.4
 [1.2.3]: https://github.com/sdispater/pendulum/releases/tag/1.2.3

README.rst

@@ -16,7 +16,7 @@ Pendulum
 
 Python datetimes made easy.
 
-Supports Python **2.7+**, **3.2+** and **PyPy**.
+Supports Python **2.7+**, **3.4+** and **PyPy**.
 
 
 .. code-block:: python

appveyor.yml

@@ -4,8 +4,6 @@ environment:
   matrix:
     - PYTHON: "C:/Python27"
     - PYTHON: "C:/Python27-x64"
-    - PYTHON: "C:/Python33"
-    - PYTHON: "C:/Python33-x64"
     - PYTHON: "C:/Python34"
     - PYTHON: "C:/Python34-x64"
     - PYTHON: "C:/Python35"

docs/_docs/instantiation.rst

@@ -24,6 +24,26 @@ and the timezone will be created for you.
     Supported strings for timezones are the one provided by the `IANA time zone database <https://www.iana.org/time-zones>`_.
     The special ``local`` string is also supported and will return your current timezone.
 
+    As of release 1.3.0, available timezones are exposed via the ``timezones`` attribute.
+
+    .. code-block:: python
+
+        import pendulum
+
+        pendulum.timezones
+        ('CET',
+         'CST6CDT',
+         'Cuba',
+         'EET',
+         'Egypt',
+         'Eire',
+         ...,
+         'US/Michigan',
+         'US/Mountain',
+         'US/Pacific',
+         'US/Pacific-New',
+         'US/Samoa')
+
 This is again shown in the next example which also introduces the ``now()`` function.
 
 .. code-block:: python
@@ -90,12 +110,25 @@ The difference being the addition the ``tz`` argument that can be a ``tzinfo`` i
 
     pendulum.from_format('1975-05-21 22', '%Y-%m-%d %H').to_datetime_string()
     '1975-05-21 22:00:00'
-    pendulum.from_format('1975-05-21 22', '%Y-%m-%d %H', 'Europe/London').isoformat()
+    pendulum.from_format('1975-05-21 22', '%Y-%m-%d %H', tz='Europe/London').isoformat()
     '1975-05-21T22:00:00+01:00'
 
     # Using strptime is also possible (the timezone will be UTC)
     pendulum.strptime('1975-05-21 22', '%Y-%m-%d %H').isoformat()
 
+ .. note::
+
+    ``from_format()`` also accepts a ``formatter`` keyword argument to use the
+    `Alternative Formatter`_'s tokens.
+
+    .. code-block:: python
+
+        import pendulum
+
+        pendulum.from_format('1975-05-21 22', 'YYYY-MM-DD HH', formatter='alternative')
+
+    Note that it will be the only one supported in the next major version.
+
 The final ``create`` function is for working with unix timestamps.
 ``from_timestamp()`` will create a ``Pendulum`` instance equal to the given timestamp
 and will set the timezone as well or default it to ``UTC``.
@@ -241,15 +274,15 @@ When passing only time information the date will default to today.
 
 .. note::
 
-    You can pass the ``strict`` keyword argument to ``parse()`` to get the exact type
+    You can pass the ``exact`` keyword argument to ``parse()`` to get the exact type
     that the string represents:
 
     .. code-block:: python
 
         import pendulum
 
-        pendulum.parse('2012-05-03', strict=True)
+        pendulum.parse('2012-05-03', exact=True)
         # <Date [2012-05-03]>
 
-        pendulum.parse('12:04:23', strict=True)
+        pendulum.parse('12:04:23', exact=True)
         # <Time [12:04:23]>

pendulum/__init__.py

@@ -77,4 +77,4 @@
 period = Period
 
 # Timezones
-from .tz import timezone, local_timezone, UTC
+from .tz import timezone, timezones, local_timezone, UTC

pendulum/formatting/alternative_formatter.py

@@ -6,6 +6,26 @@
 from .formatter import Formatter
 
 
+_MATCH_1 = re.compile('\d')
+_MATCH_2 = re.compile('\d\d')
+_MATCH_3 = re.compile('\d{3}')
+_MATCH_4 = re.compile('\d{4}')
+_MATCH_6 = re.compile('[+-]?\d{6}')
+_MATCH_1_TO_2 = re.compile('\d\d?')
+_MATCH_1_TO_3 = re.compile('\d{1,3}')
+_MATCH_1_TO_4 = re.compile('\d{1,4}')
+_MATCH_1_TO_6 = re.compile('[+-]?\d{1,6}')
+_MATCH_3_TO_4 = re.compile('\d{3}\d?')
+_MATCH_5_TO_6 = re.compile('\d{5}\d?')
+_MATCH_UNSIGNED = re.compile('\d+')
+_MATCH_SIGNED = re.compile('[+-]?\d+')
+_MATCH_OFFSET = re.compile('(?i)Z|[+-]\d\d:?\d\d')
+_MATCH_SHORT_OFFSET = re.compile('(?i)Z|[+-]\d\d(?::?\d\d)?')
+_MATCH_TIMESTAMP = re.compile('[+-]?\d+(\.\d{1,3})?')
+_MATCH_WORD = re.compile("[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}")
+
+
+
 class AlternativeFormatter(Formatter):
 
     _TOKENS = '\[([^\[]*)\]|\\\(.)|' \
@@ -99,6 +119,71 @@ class AlternativeFormatter(Formatter):
         'LLLL': 'dddd, MMMM D, YYYY h:mm A',
     }
 
+    _REGEX_TOKENS = {
+        'Y': _MATCH_SIGNED,
+        'YY': (_MATCH_1_TO_2, _MATCH_2),
+        'YYYY': (_MATCH_1_TO_4, _MATCH_4),
+        'Q': _MATCH_1,
+        'Qo': None,
+        'M': _MATCH_1_TO_2,
+        'MM': (_MATCH_1_TO_2, _MATCH_2),
+        'MMM': None,
+        'MMMM': None,
+        'D': _MATCH_1_TO_2,
+        'DD': (_MATCH_1_TO_2, _MATCH_2),
+        'DDD': _MATCH_1_TO_3,
+        'DDDD': _MATCH_3,
+        'Do': None,
+        'H': _MATCH_1_TO_2,
+        'HH': (_MATCH_1_TO_2, _MATCH_2),
+        'h': _MATCH_1_TO_2,
+        'hh': (_MATCH_1_TO_2, _MATCH_2),
+        'm': _MATCH_1_TO_2,
+        'mm': (_MATCH_1_TO_2, _MATCH_2),
+        's': _MATCH_1_TO_2,
+        'ss': (_MATCH_1_TO_2, _MATCH_2),
+        'S': (_MATCH_1_TO_3, _MATCH_1),
+        'SS': (_MATCH_1_TO_3, _MATCH_2),
+        'SSS': (_MATCH_1_TO_3, _MATCH_3),
+        'SSSS': _MATCH_UNSIGNED,
+        'SSSSS': _MATCH_UNSIGNED,
+        'SSSSSS': _MATCH_UNSIGNED,
+        'a': None,
+        'x': _MATCH_SIGNED,
+        'X': re.compile('[+-]?\d+(\.\d{1,3})?')
+    }
+
+    _PARSE_TOKENS = {
+        'YYYY': lambda year: int(year),
+        'YY': lambda year: 1900 + int(year),
+        'Q': lambda quarter: int(quarter),
+        'MMMM': lambda month: None,
+        'MMM': lambda month: None,
+        'MM': lambda month: int(month),
+        'M': lambda month: int(month),
+        'DDDD': lambda day: int(day),
+        'DDD': lambda day: int(day),
+        'DD': lambda day: int(day),
+        'D': lambda day: int(day),
+        'HH': lambda hour: int(hour),
+        'H': lambda hour: int(hour),
+        'hh': lambda hour: int(hour),
+        'h': lambda hour: int(hour),
+        'mm': lambda minute: int(minute),
+        'm': lambda minute: int(minute),
+        'ss': lambda second: int(second),
+        's': lambda second: int(second),
+        'S': lambda us: int(us) * 100000,
+        'SS': lambda us: int(us) * 10000,
+        'SSS': lambda us: int(us) * 1000,
+        'SSSS': lambda us: int(us) * 100,
+        'SSSSS': lambda us: int(us) * 10,
+        'SSSSSS': lambda us: int(us),
+        'a': lambda meridiem: None,
+        'X': lambda ts: float(ts),
+        'x': lambda ts: float(ts) / 1e3,
+    }
+
     def format(self, dt, fmt, locale=None):
         """
         Formats a Pendulum instance with a given format and locale.
@@ -232,3 +317,97 @@ def _format_localizable_token(self, dt, token, locale):
             return self._format_localizable_token(dt, token, 'en')
 
         return trans
+
+    def parse(self, time, fmt):
+        """
+        Parses a time string matching a given format as a tuple.
+
+        :param time: The timestring
+        :type time: str
+
+        :param fmt: The format
+        :type fmt: str
+
+        :rtype: tuple
+        """
+        tokens = self._FORMAT_RE.findall(fmt)
+        if not tokens:
+            return time
+
+        parsed = {
+            'year': None,
+            'month': None,
+            'day': None,
+            'hour': None,
+            'minute': None,
+            'second': None,
+            'microsecond': None,
+            'tz': None,
+            'quarter': None,
+            'day_of_week': None,
+            'day_of_year': None,
+            'meridiem': None,
+            'timestamp': None
+        }
+
+        pattern = self._FORMAT_RE.sub(lambda m: self._replace_tokens(m.group(0)), fmt)
+
+        if not re.match(pattern, time):
+            raise ValueError('String does not match format {}'.format(fmt))
+
+        re.sub(pattern, lambda m: self._get_parsed_values(m, parsed), time)
+
+        return parsed
+
+    def _get_parsed_values(self, m, parsed):
+        for token, index in m.re.groupindex.items():
+            self._get_parsed_value(token, m.group(index), parsed)
+
+    def _get_parsed_value(self, token, value, parsed):
+        parsed_token = self._PARSE_TOKENS[token](value)
+
+        if 'Y' in token:
+            parsed['year'] = parsed_token
+        elif 'Q' == token:
+            parsed['quarter'] = parsed_token
+        elif 'M' in token:
+            parsed['month'] = parsed_token
+        elif token in ['DDDD', 'DDD']:
+            parsed['day_of_year'] = parsed_token
+        elif 'D' in token:
+            parsed['day'] = parsed_token
+        elif 'H' in token:
+            parsed['hour'] = parsed_token
+        elif token in ['hh', 'h']:
+            parsed['hour'] = parsed_token
+        elif 'm' in token:
+            parsed['minute'] = parsed_token
+        elif 's' in token:
+            parsed['second'] = parsed_token
+        elif 'S' in token:
+            parsed['microsecond'] = parsed_token
+        elif token in ['MMM', 'MMMM']:
+            parsed['day_of_week'] = parsed_token
+        elif token == 'a':
+            pass
+        elif token in ['X', 'x']:
+            parsed['timestamp'] = parsed_token
+
+    def _replace_tokens(self, token):
+        if token.startswith('[') and token.endswith(']'):
+            return token[1:-1]
+        elif token.startswith('\\'):
+            return token[1:]
+        elif token not in self._REGEX_TOKENS:
+            raise ValueError('Unsupported token: {}'.format(token))
+
+        candidates = self._REGEX_TOKENS[token]
+        if not candidates:
+            raise ValueError('Unsupported token: {}'.format(token))
+
+        if not isinstance(candidates, tuple):
+            candidates = (candidates,)
+
+        pattern = '(?P<{}>{})'.format(token, '|'.join([p.pattern for p in candidates]))
+
+        return pattern

pendulum/parser.py

@@ -30,7 +30,7 @@ def parse(self, text):
 
         parsed = super(Parser, self).parse(text)
 
-        if not self.is_strict():
+        if not self.is_exact():
             return self._create_pendulum_object(parsed)
 
         # Checking for date

pendulum/parsing/parser.py

@@ -2,6 +2,7 @@
 
 import re
 import copy
+import warnings
 
 from datetime import datetime, date, time
 from dateutil import parser
@@ -58,16 +59,35 @@ class Parser(object):
     DEFAULT_OPTIONS = {
         'day_first': False,
         'year_first': True,
-        'strict': False,
+        'exact': False,
         'now': None
     }
 
     def __init__(self, **options):
+        if 'strict' in options:
+            warnings.warn(
+                'The "strict" keyword when parsing will have '
+                'another meaning in version 2.0. Use "exact" instead.',
+                DeprecationWarning,
+                stacklevel=2
+            )
+
+            options['exact'] = options['strict']
+
         self._options = copy.copy(self.DEFAULT_OPTIONS)
         self._options.update(options)
 
     def is_strict(self):
-        return self._options['strict']
+        warnings.warn(
+            'is_strict() is deprecated. Use is_exact() instead.',
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        return self.is_exact()
+
+    def is_exact(self):
+        return self._options['exact']
 
     def now(self):
         return self._options['now'] or datetime.now()