Adds support for the alternative tokens in from_format()

sdispater · sdispater · commit 849699a630e7 · 2017-09-07T16:59:33.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Added
 
+- Added support for the alternative formatter's tokens in `from_format()`
 - Added a `timezones` module attribute to expose available timezones.
 
 
diff --git a/docs/_docs/instantiation.rst b/docs/_docs/instantiation.rst
@@ -110,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``.
diff --git a/pendulum/formatting/alternative_formatter.py b/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
diff --git a/pendulum/pendulum.py b/pendulum/pendulum.py
@@ -5,6 +5,8 @@
 import calendar
 import datetime
 
+import pendulum
+
 from .date import Date
 from .time import Time
 from .period import Period
@@ -13,6 +15,7 @@
 from .tz.timezone_info import TimezoneInfo
 from .parsing import parse
 from .helpers import add_duration
+from .formatting import FORMATTERS
 from .constants import (
     YEARS_PER_CENTURY, YEARS_PER_DECADE,
     MONTHS_PER_YEAR,
@@ -373,7 +376,7 @@ def create(cls, year=None, month=None, day=None,
         return cls.instance(dt, tz)
 
     @classmethod
-    def create_from_format(cls, time, fmt, tz=UTC):
+    def create_from_format(cls, time, fmt, tz=UTC, formatter='classic'):
         """
         Create a Pendulum instance from a specific format.
 
@@ -386,11 +389,83 @@ def create_from_format(cls, time, fmt, tz=UTC):
         :param tz: The timezone
         :type tz: tzinfo or str or int or None
 
+        :param formatter: The formatter to use. Default "classic"
+        :type formatter: str
+
         :rtype: Pendulum
         """
-        dt = datetime.datetime.strptime(time, fmt)
+        if formatter not in FORMATTERS:
+            raise ValueError('Invalid formatter [{}]'.format(formatter))
 
-        return cls.instance(dt, tz)
+        if formatter == 'classic':
+            dt = datetime.datetime.strptime(time, fmt)
+
+            return cls.instance(dt, tz)
+
+        formatter = FORMATTERS['alternative']
+
+        parts = formatter.parse(time, fmt)
+        actual_parts = {}
+
+        # If timestamp has been specified
+        # we use it and don't go any further
+        if parts['timestamp'] is not None:
+            return cls.create_from_timestamp(parts['timestamp'])
+
+        if parts['quarter'] is not None:
+            dt = cls.now().start_of('year')
+
+            while dt.quarter != parts['quarter']:
+                dt = dt.add(months=3)
+
+            actual_parts['year'] = dt.year
+            actual_parts['month'] = dt.month
+            actual_parts['day'] = dt.day
+
+        # If the date part has not been specified
+        # we default to today
+        if all([parts['year'] is None, parts['month'] is None, parts['day'] is None]):
+            now = cls.now()
+
+            parts['year'] = actual_parts['year'] = now.year
+            parts['month'] = actual_parts['month'] = now.month
+            parts['day'] = actual_parts['day'] = now.day
+
+        # We replace any not set month/day value
+        # with the first of each unit
+        if any([parts['month'] is None, parts['day'] is None]):
+            for part in ['month', 'day']:
+                if parts[part] is None and actual_parts.get(part) is None:
+                    actual_parts[part] = 1
+
+        for part in ['year', 'month', 'day']:
+            if parts[part] is not None:
+                actual_parts[part] = parts[part]
+
+        # If any of hour/minute/second/microsecond is not set
+        # We assume start of corresponding value
+        for part in ['hour', 'minute', 'second', 'microsecond']:
+            if parts[part] is None:
+                actual_parts[part] = 0
+            else:
+                actual_parts[part] = parts[part]
+
+        if parts['day_of_year'] is not None:
+            text = '{}-{}'.format(
+                actual_parts['year'], parts['day_of_year']
+            )
+            dt = parse(text)
+
+            actual_parts['month'] = dt['month']
+            actual_parts['day'] = dt['day']
+
+        # Meridiem
+        if parts['meridiem'] is not None:
+            pass
+
+        actual_parts['tz'] = parts['tz'] or tz
+
+        return cls.create(**actual_parts)
 
     @classmethod
     def create_from_timestamp(cls, timestamp, tz=UTC):
@@ -419,7 +494,7 @@ def create_from_timestamp(cls, timestamp, tz=UTC):
 
     @classmethod
     def strptime(cls, time, fmt):
-        return cls.create_from_format(time, fmt)
+        return cls.create_from_format(time, fmt, formatter='classic')
 
     def copy(self):
         """
diff --git a/tests/pendulum_tests/test_create_from_format.py b/tests/pendulum_tests/test_create_from_format.py
@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 
-import pytz
+import pytest
+import pendulum
+
 from pendulum import Pendulum, timezone
 from .. import AbstractTestCase
 
@@ -37,3 +39,30 @@ def test_strptime_is_create_from_format(self):
         self.assertPendulum(d, 1975, 5, 21, 22, 32, 11)
         self.assertIsInstanceOfPendulum(d)
         self.assertEqual('UTC', d.timezone_name)
+
+
+@pytest.mark.parametrize('text,fmt,expected', [
+    ('2014-4', 'YYYY-Q', '2014-10-01T00:00:00+00:00'),
+    ('12-02-1999', 'MM-DD-YYYY', '1999-12-02T00:00:00+00:00'),
+    ('12-02-1999', 'DD-MM-YYYY', '1999-02-12T00:00:00+00:00'),
+    ('12/02/1999', 'DD/MM/YYYY', '1999-02-12T00:00:00+00:00'),
+    ('12_02_1999', 'DD_MM_YYYY', '1999-02-12T00:00:00+00:00'),
+    ('12:02:1999', 'DD:MM:YYYY', '1999-02-12T00:00:00+00:00'),
+    ('2-2-99', 'D-M-YY', '1999-02-02T00:00:00+00:00'),
+    ('99', 'YY', '1999-01-01T00:00:00+00:00'),
+    ('300-1999', 'DDD-YYYY', '1999-10-27T00:00:00+00:00'),
+    ('12-02-1999 2:45:10', 'DD-MM-YYYY h:m:s', '1999-02-12T02:45:10+00:00'),
+    ('12-02-1999 12:45:10', 'DD-MM-YYYY h:m:s', '1999-02-12T12:45:10+00:00'),
+    ('12:00:00', 'HH:mm:ss', '2015-11-12T12:00:00+00:00'),
+    ('12:30:00', 'HH:mm:ss', '2015-11-12T12:30:00+00:00'),
+    ('00:00:00', 'HH:mm:ss', '2015-11-12T00:00:00+00:00'),
+    ('00:30:00 1', 'HH:mm:ss S', '2015-11-12T00:30:00.100000+00:00'),
+    ('00:30:00 12', 'HH:mm:ss SS', '2015-11-12T00:30:00.120000+00:00'),
+    ('00:30:00 123', 'HH:mm:ss SSS', '2015-11-12T00:30:00.123000+00:00'),
+    ('1234567890', 'X', '2009-02-13T23:31:30+00:00'),
+    ('1234567890123', 'x', '2009-02-13T23:31:30.123000+00:00'),
+    ('2016-10-06', 'YYYY-MM-DD', '2016-10-06T00:00:00+00:00'),
+])
+def test_from_format(text, fmt, expected):
+    with pendulum.test(pendulum.create(2015, 11, 12)):
+        assert pendulum.from_format(text, fmt, formatter='alternative').isoformat() == expected

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`
`5`	`5`	`### Added`
`6`	`6`
	`7`	+- Added support for the alternative formatter's tokens in `from_format()`
`7`	`8`	- Added a `timezones` module attribute to expose available timezones.
`8`	`9`
`9`	`10`