Test on Linux and OSX

Implement method to get MayaDT instance as local timezone-aware datetime instance

.gitignore

@@ -24,6 +24,7 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+Pipfile.lock
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

.travis.yml

@@ -1,9 +1,22 @@
 language: python
+os:
+  - linux
+  - osx
+
 python:
   - "2.7"
   - "3.6"
+  - "3.7-dev"
+
+matrix:
+    allow_failures:
+        - python: "3.7-dev"
 
 # command to install dependencies
-install: pip install pipenv; pipenv lock; pipenv install --dev
+install:
+    - pip install pipenv
+    - pipenv install '-e .' --skip-lock --ignore-pipfile
+    - pipenv install --dev --skip-lock
+
 # command to run tests
 script: pipenv run pytest tests/

AUTHORS.rst

@@ -22,3 +22,5 @@ In chronological order:
 - Joshua Li <joshua.r.li.98@gmail.com> (`@JoshuaRLi <https://github.com/JoshuaRLi>`_)
 - Sébastien Eustace <sebastien@eustace.io> (`@sdispater <https://github.com/sdispater>`_)
 - Evan Mattiza <emattiza@gmail.com> (`@emattiza <https://github.com/emattiza>`_)
+- Dima Spivak <dima@spivak.ch> (`@dimaspivak <https://github.com/dimaspivak>`_)
+- Tom Barron <tusculum@gmail.com> (`@dtbarron <https://github.com/tbarron>`_)

Makefile

@@ -1,3 +1,5 @@
+.PHONY: tests docs
+
 tests:
 	pytest tests/
 docs:

Pipfile

@@ -1,11 +1,4 @@
 [dev-packages]
+freezegun = "*"
 pytest = "*"
-Sphinx = "*"
+sphinx = "*"
-
-[packages]
-humanize = "*"
-pytz = "*"
-dateparser = "*"
-"ruamel.yaml" = "*"
-tzlocal = "*"
-pendulum = ">=1.0"

Pipfile.lock

@@ -1,72 +0,0 @@
-{
-    "_meta": {
-        "hash": {
-            "sha256": "5617ff73ba51e60721267b24dc01e83f33d2a3692870b60e394b0f75ed2dc313"
-        },
-        "requires": {},
-        "sources": [
-            {
-                "url": "https://pypi.python.org/simple",
-                "verify_ssl": true
-            }
-        ]
-    },
-    "default": {
-        "dateparser": {
-            "version": "==0.6.0"
-        },
-        "humanize": {
-            "version": "==0.5.1"
-        },
-        "pendulum": {
-            "version": "==1.2.0"
-        },
-        "python-dateutil": {
-            "version": "==2.6.0"
-        },
-        "pytz": {
-            "version": "==2017.2"
-        },
-        "pytzdata": {
-            "version": "==2017.2"
-        },
-        "regex": {
-            "version": "==2017.04.29"
-        },
-        "ruamel.ordereddict": {
-            "version": "==0.4.9"
-        },
-        "ruamel.yaml": {
-            "version": "==0.14.12"
-        },
-        "six": {
-            "version": "==1.10.0"
-        },
-        "tzlocal": {
-            "version": "==1.4"
-        }
-    },
-    "develop": {
-        "appdirs": {
-            "version": "==1.4.3"
-        },
-        "packaging": {
-            "version": "==16.8"
-        },
-        "py": {
-            "version": "==1.4.33"
-        },
-        "pyparsing": {
-            "version": "==2.2.0"
-        },
-        "pytest": {
-            "version": "==3.0.7"
-        },
-        "setuptools": {
-            "version": "==35.0.2"
-        },
-        "six": {
-            "version": "==1.10.0"
-        }
-    }
-}

README.rst

@@ -10,7 +10,6 @@ Maya: Datetimes for Humans™
 .. image:: https://img.shields.io/badge/SayThanks-!-1EAEDB.svg
     :target: https://saythanks.io/to/kennethreitz
 
-test
 
 Datetimes are very frustrating to work with in Python, especially when dealing
 with different locales on different systems. This library exists to make the
@@ -21,6 +20,12 @@ Datetimes should be interacted with via an API written for humans.
 
 Maya is mostly built around the headaches and use-cases around parsing datetime data from websites.
 
+.. image:: https://farm4.staticflickr.com/3702/33288285996_5b69d2b8f7_k_d.jpg
+
+Art by `Sam Flores
+<https://www.instagram.com/samagram12/>`_ (Photo by `Kenneth Reitz
+<https://www.instagram.com/kennethreitz/>`_). 
+
 
 ☤ Basic Usage of Maya
 ---------------------
@@ -64,6 +69,15 @@ Behold, datetimes for humans!
     >>> rand_day = maya.when('2011-02-07', timezone='US/Eastern')
     <MayaDT epoch=1297036800.0>
 
+    # Maya speaks Python.
+    >>> m = maya.MayaDT.from_datetime(datetime.utcnow())
+    >>> print(m)
+    Wed, 20 Sep 2017 17:24:32 GMT
+
+    >>> m = maya.MayaDT.from_struct(time.gmtime())
+    >>> print(m)
+    Wed, 20 Sep 2017 17:24:32 GMT
+
     >>> rand_day.day
     7
 
@@ -75,13 +89,18 @@ Behold, datetimes for humans!
     UTC
 
     # Range of hours in a day:
-    >>> maya.interval(start=maya.now(), end=maya.now().add(days=1), interval=60*60)
+    >>> maya.intervals(start=maya.now(), end=maya.now().add(days=1), interval=60*60)
     <generator object intervals at 0x105ba5820>
 
+    # snap modifiers
+    >>> dt = maya.when('Mon, 21 Feb 1994 21:21:42 GMT')
+    >>> dt.snap('@d+3h').rfc2822()
+    'Mon, 21 Feb 1994 03:00:00 GMT'
+
 ☤ Advanced Usage of Maya
 ------------------------
 
-In addition to timestamps, Maya also includes a wonderfuly powerful ``MayaInterval`` class, which represents a range of time (e.g. an event). With this class, you can perform a multitude of advanced calendar calculations with finese and ease. 
+In addition to timestamps, Maya also includes a wonderfully powerful ``MayaInterval`` class, which represents a range of time (e.g. an event). With this class, you can perform a multitude of advanced calendar calculations with finesse and ease.
 
 For example:
 
@@ -95,7 +114,7 @@ For example:
 
     >>> event = MayaInterval(start=event_start, end=event_end)
 
-From here, there a a number of methods available to you, which you can use to compare this event to another event.
+From here, there are a number of methods available to you, which you can use to compare this event to another event.
 
 
 
@@ -114,7 +133,7 @@ From here, there a a number of methods available to you, which you can use to co
 ☤ What about Delorean, Arrow, & Pendulum?
 -----------------------------------------
 
-All these project complement eachother, and are friends. Pendulum, for example, helps power Maya's parsing. 
+All these project complement each other, and are friends. Pendulum, for example, helps power Maya's parsing.
 
 Arrow, for example, is a fantastic library, but isn't what I wanted in a datetime library. In many ways, it's better than Maya for certain things. In some ways, in my opinion, it's not.
 
@@ -126,9 +145,9 @@ I think these projects complement each-other, personally. Maya is great for pars
 ☤ Installing Maya
 -----------------
 
-Installation is easy, with pip::
+Installation is easy, with `pipenv <http://pipenv.org/>`_::
 
-    $ pip install maya
+    $ pipenv install maya
 
 ✨🍰✨
 

maya/__version__.py

@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = '0.4.2'

maya/compat.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 """
 maya.compat
 ~~~~~~~~~~~~~~~
@@ -12,24 +11,19 @@ import sys
 # -------
 # Pythons
 # -------
-
 # Syntax sugar.
 _ver = sys.version_info
-
+# : Python 2.x?
-#: Python 2.x?
 is_py2 = (_ver[0] == 2)
-
+# : Python 3.x?
-#: Python 3.x?
 is_py3 = (_ver[0] == 3)
-
 # ---------
 # Specifics
 # ---------
-
 if is_py2:
     cmp = cmp
-
 elif is_py3:
+
     def cmp(a, b):
         """
         Compare two objects.
@@ -38,8 +32,10 @@ elif is_py3:
         """
         if a < b:
             return -1
+
         elif a == b:
             return 0
+
         else:
             return 1
 
@@ -59,36 +55,42 @@ def comparable(klass):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c == 0
 
     def __ne__(self, other):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c != 0
 
     def __lt__(self, other):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c < 0
 
     def __le__(self, other):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c <= 0
 
     def __gt__(self, other):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c > 0
 
     def __ge__(self, other):
         c = self.__cmp__(other)
         if c is NotImplemented:
             return c
+
         return c >= 0
 
     klass.__lt__ = __lt__

maya/core.py

@@ -1,28 +1,22 @@
 # ___  __  ___  _  _  ___
 # || \/ | ||=|| \\// ||=||
 # ||    | || ||  //  || ||
-
-# Ignore warnings for yaml usage.
-import warnings
-import ruamel.yaml
-
-warnings.simplefilter('ignore', ruamel.yaml.error.UnsafeLoaderWarning)
-
 import email.utils
 import time
+import functools
 from datetime import timedelta, datetime as Datetime
 
-import functools
+import re
 import pytz
 import humanize
 import dateparser
 import pendulum
+import snaptime
 from tzlocal import get_localzone
+from dateutil.relativedelta import relativedelta
 
 from .compat import cmp, comparable
 
-_EPOCH_START = (1970, 1, 1)
-
 
 def validate_class_type_arguments(operator):
     """
@@ -31,14 +25,20 @@ def validate_class_type_arguments(operator):
     """
 
     def inner(function):
+
         def wrapper(self, *args, **kwargs):
             for arg in args + tuple(kwargs.values()):
                 if not isinstance(arg, self.__class__):
-                    raise TypeError('unorderable types: {}() {} {}()'.format(
+                    raise TypeError(
-                        type(self).__name__, operator, type(arg).__name__))
+                        'unorderable types: {}() {} {}()'.format(
+                            type(self).__name__, operator, type(arg).__name__
+                        )
+                    )
+
             return function(self, *args, **kwargs)
 
         return wrapper
+
     return inner
 
 
@@ -51,26 +51,34 @@ def validate_arguments_type_of_function(param_type=None):
 
     Note: Use this decorator on the functions of the class.
     """
+
     def inner(function):
+
         def wrapper(self, *args, **kwargs):
             type_ = param_type or type(self)
             for arg in args + tuple(kwargs.values()):
                 if not isinstance(arg, type_):
-                    raise TypeError(('Invalid Type: {}.{}() accepts only the '
+                    raise TypeError(
-                                     'arguments of type "<{}>"').format(
+                        (
-                                            type(self).__name__,
+                            'Invalid Type: {}.{}() accepts only the '
-                                            function.__name__,
+                            'arguments of type "<{}>"'
-                                            type_.__name__,
+                        ).format(
-                                        )
+                            type(self).__name__,
-                                    )
+                            function.__name__,
+                            type_.__name__,
+                        )
+                    )
+
             return function(self, *args, **kwargs)
 
         return wrapper
+
     return inner
 
 
 class MayaDT(object):
     """The Maya Datetime object."""
+    __EPOCH_START = (1970, 1, 1)
 
     def __init__(self, epoch):
         super(MayaDT, self).__init__()
@@ -114,26 +122,49 @@ class MayaDT(object):
         return hash(int(self.epoch))
 
     def __add__(self, duration):
-        return self.add(seconds=seconds_or_timedelta(duration).total_seconds())
+        return self.add(
+            seconds=_seconds_or_timedelta(duration).total_seconds()
+        )
 
     def __radd__(self, duration):
         return self + duration
 
-    def __sub__(self, duration):
+    def __sub__(self, duration_or_date):
-        return self.subtract(
+        if isinstance(duration_or_date, MayaDT):
-            seconds=seconds_or_timedelta(duration).total_seconds())
+            return self.subtract_date(dt=duration_or_date)
+
+        else:
+            return self.subtract(
+                seconds=_seconds_or_timedelta(duration_or_date).total_seconds()
+            )
 
     def add(self, **kwargs):
-        """"Returns a new MayaDT object with the given offsets."""
+        """Returns a new MayaDT object with the given offsets."""
-        return self.from_datetime(pendulum.instance(self.datetime()).add(**kwargs))
+        return self.from_datetime(
+            pendulum.instance(self.datetime()).add(**kwargs)
+        )
 
     def subtract(self, **kwargs):
-        """"Returns a new MayaDT object with the given offsets."""
+        """Returns a new MayaDT object with the given offsets."""
-        return self.from_datetime(pendulum.instance(self.datetime()).subtract(**kwargs))
+        return self.from_datetime(
+            pendulum.instance(self.datetime()).subtract(**kwargs)
+        )
+
+    def subtract_date(self, **kwargs):
+        """Returns a timedelta object with the duration between the dates"""
+        return timedelta(seconds=self.epoch - kwargs['dt'].epoch)
+
+    def snap(self, instruction):
+        """
+        Returns a new MayaDT object modified by the given instruction.
+
+        Powered by snaptime.  See https://github.com/zartstrom/snaptime
+        for a complete documentation about the snaptime instructions.
+        """
+        return self.from_datetime(snaptime.snap(self.datetime(), instruction))
 
     # Timezone Crap
     # -------------
-
     @property
     def timezone(self):
         """Returns the UTC tzinfo name. It's always UTC. Always."""
@@ -146,8 +177,11 @@ class MayaDT(object):
 
     @property
     def local_timezone(self):
-        """Returns the name of the local timezone, for informational purposes."""
+        """Returns the name of the local timezone."""
-        return self._local_tz.zone
+        if self._local_tz.zone in pytz.all_timezones:
+            return self._local_tz.zone
+
+        return self.timezone
 
     @property
     def _local_tz(self):
@@ -158,23 +192,31 @@ class MayaDT(object):
     @validate_arguments_type_of_function(Datetime)
     def __dt_to_epoch(dt):
         """Converts a datetime into an epoch."""
-
         # Assume UTC if no datetime is provided.
         if dt.tzinfo is None:
             dt = dt.replace(tzinfo=pytz.utc)
-
+        epoch_start = Datetime(*MayaDT.__EPOCH_START, tzinfo=pytz.timezone('UTC'))
-        epoch_start = Datetime(*_EPOCH_START, tzinfo=pytz.timezone('UTC'))
         return (dt - epoch_start).total_seconds()
 
     # Importers
     # ---------
-
     @classmethod
     @validate_arguments_type_of_function(Datetime)
     def from_datetime(klass, dt):
         """Returns MayaDT instance from datetime."""
         return klass(klass.__dt_to_epoch(dt))
 
+    @classmethod
+    @validate_arguments_type_of_function(time.struct_time)
+    def from_struct(klass, struct, timezone=pytz.UTC):
+        """Returns MayaDT instance from a 9-tuple struct
+
+        It's assumed to be from gmtime().
+        """
+        struct_time = time.mktime(struct) - utc_offset(struct)
+        dt = Datetime.fromtimestamp(struct_time, timezone)
+        return klass(klass.__dt_to_epoch(dt))
+
     @classmethod
     def from_iso8601(klass, iso8601_string):
         """Returns MayaDT instance from iso8601 string."""
@@ -192,30 +234,37 @@ class MayaDT(object):
 
     # Exporters
     # ---------
-
     def datetime(self, to_timezone=None, naive=False):
         """Returns a timezone-aware datetime...
         Defaulting to UTC (as it should).
 
         Keyword Arguments:
-            to_timezone {string} -- timezone to convert to (default: None/UTC)
+            to_timezone {str} -- timezone to convert to (default: None/UTC)
-            naive {boolean} -- if True, the tzinfo is simply dropped (default: False)
+            naive {bool} -- if True,
+                            the tzinfo is simply dropped (default: False)
         """
         if to_timezone:
             dt = self.datetime().astimezone(pytz.timezone(to_timezone))
         else:
             dt = Datetime.utcfromtimestamp(self._epoch)
             dt.replace(tzinfo=self._tz)
-
         # Strip the timezone info if requested to do so.
         if naive:
             return dt.replace(tzinfo=None)
+
         else:
             if dt.tzinfo is None:
                 dt = dt.replace(tzinfo=self._tz)
-
         return dt
 
+    def local_datetime(self):
+        """Returns a local timezone-aware datetime object
+
+        It's the same as:
+        mayaDt.datetime(to_timezone=mayaDt.local_timezone)
+        """
+        return self.datetime(to_timezone=self.local_timezone, naive=False)
+
     def iso8601(self):
         """Returns an ISO 8601 representation of the MayaDT."""
         # Get a timezone-naive datetime.
@@ -232,7 +281,6 @@ class MayaDT(object):
 
     # Properties
     # ----------
-
     @property
     def year(self):
         return self.datetime().year
@@ -245,13 +293,20 @@ class MayaDT(object):
     def day(self):
         return self.datetime().day
 
+    @property
+    def date(self):
+        return self.datetime().date()
+
     @property
     def week(self):
         return self.datetime().isocalendar()[1]
 
     @property
     def weekday(self):
-        """Return the day of the week as an integer. Monday is 1 and Sunday is 7"""
+        """Return the day of the week as an integer.
+
+        Monday is 1 and Sunday is 7.
+        """
         return self.datetime().isoweekday()
 
     @property
@@ -276,7 +331,6 @@ class MayaDT(object):
 
     # Human Slang Extras
     # ------------------
-
     def slang_date(self):
         """"Returns human slang representation of date."""
         dt = self.datetime(naive=True, to_timezone=self.local_timezone)
@@ -288,15 +342,38 @@ class MayaDT(object):
         return humanize.naturaltime(dt)
 
 
+def utc_offset(time_struct=None):
+    """
+    Returns the time offset from UTC accounting for DST
+
+    Keyword Arguments:
+        time_struct {time.struct_time} -- the struct time for which to
+                                          return the UTC offset.
+                                          If None, use current local time.
+    """
+    if time_struct:
+        ts = time_struct
+    else:
+        ts = time.localtime()
+
+    if ts[-1]:
+        offset = time.altzone
+    else:
+        offset = time.timezone
+    return offset
+
+
 def to_utc_offset_naive(dt):
     if dt.tzinfo is None:
         return dt
+
     return dt.astimezone(pytz.utc).replace(tzinfo=None)
 
 
 def to_utc_offset_aware(dt):
     if dt.tzinfo is not None:
         return dt
+
     return pytz.utc.localize(dt)
 
 
@@ -305,40 +382,46 @@ def to_iso8601(dt):
 
 
 def end_of_day_midnight(dt):
-    return dt if dt.time() == time.min else \
+    if dt.time() == time.min:
-        (dt.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1))
+        return dt
+
+    else:
+        return (
+            dt.replace(hour=0, minute=0, second=0, microsecond=0) +
+            timedelta(days=1)
+        )
 
 
 @comparable
 class MayaInterval(object):
     """
-    A MayaInterval represents a range between two datetimes, inclusive of the start
+    A MayaInterval represents a range between two datetimes,
-    and exclusive of the end.
+    inclusive of the start and exclusive of the end.
     """
 
     def __init__(self, start=None, end=None, duration=None):
         try:
             # Ensure that proper arguments were passed.
-            assert any((
+            assert any(
-                (start and end),
+                (
-                (start and duration is not None),
+                    (start and end),
-                (end and duration is not None),
+                    (start and duration is not None),
-            ))
+                    (end and duration is not None),
+                )
+            )
             assert not all((start, end, duration is not None))
         except AssertionError:
             raise ValueError(
-                'Exactly 2 of start, end, and duration must be specified')
+                'Exactly 2 of start, end, and duration must be specified'
+            )
 
         # Convert duration to timedelta if seconds were provided.
         if duration:
-            duration = seconds_or_timedelta(duration)
+            duration = _seconds_or_timedelta(duration)
-
         if not start:
             start = end - duration
-
         if not end:
             end = start + duration
-
         if start > end:
             raise ValueError('MayaInterval cannot end before it starts')
 
@@ -346,28 +429,56 @@ class MayaInterval(object):
         self.end = end
 
     def __repr__(self):
-        return '<MayaInterval start={0!r} end={1!r}>'.format(self.start, self.end)
+        return '<MayaInterval start={0!r} end={1!r}>'.format(
+            self.start, self.end
+        )
 
     def iso8601(self):
         """Returns an ISO 8601 representation of the MayaInterval."""
-        return '{0}/{1}'.format(self.start.iso6801, self.end.iso8601)
+        return '{0}/{1}'.format(self.start.iso8601(), self.end.iso8601())
+
+    @classmethod
+    def parse_iso8601_duration(cls, duration, start=None, end=None):
+        match = re.match(
+            r'(?:P(?P<weeks>\d+)W)|(?:P(?:(?:(?P<years>\d+)Y)?(?:(?P<months>\d+)M)?(?:(?P<days>\d+)D))?(?:T(?:(?P<hours>\d+)H)?(?:(?P<minutes>\d+)M)?(?:(?P<seconds>\d+)S)?)?)',
+            duration
+        )
+
+        time_components = {}
+        if match:
+            time_components = match.groupdict(0)
+            for key, value in time_components.items():
+                time_components[key] = int(value)
+
+            duration = relativedelta(**time_components)
+
+            if start:
+                return parse(start.datetime() + duration)
+
+            if end:
+                return parse(end.datetime() - duration)
+
+        return None
 
     @classmethod
     def from_iso8601(cls, s):
         # # Start and end, such as "2007-03-01T13:00:00Z/2008-05-11T15:30:00Z"
-        # start, end = s.split('/')
+        start, end = s.split('/')
-        # try:
+        try:
-        #     start = parse(start)
+            start = parse(start)
-        # except pendulum.parsing.exceptions.ParserError:
+        except pendulum.parsing.exceptions.ParserError:
-        #     start = self._parse_iso8601_duration(start)
+            # start = self._parse_iso8601_duration(start, end=end)
-        # try:
+            raise NotImplementedError()
-        #     end = parse(start)
+
-        # except pendulum.parsing.exceptions.ParserError as e:
+        try:
-        #     end = self._parse_iso8601_duration(start)
+            end = parse(end)
+        except pendulum.parsing.exceptions.ParserError as e:
+            end = cls.parse_iso8601_duration(end, start=start)
+
+        return cls(start=start, end=end)
 
         # # Start and duration, such as "2007-03-01T13:00:00Z/P1Y2M10DT2H30M"
         # # Duration and end, such as "P1Y2M10DT2H30M/2008-05-11T15:30:00Z"
-        raise NotImplementedError()
 
     @validate_arguments_type_of_function()
     def __and__(self, maya_interval):
@@ -380,8 +491,7 @@ class MayaInterval(object):
     @validate_arguments_type_of_function()
     def __eq__(self, maya_interval):
         return (
-            self.start == maya_interval.start and
+            self.start == maya_interval.start and self.end == maya_interval.end
-            self.end == maya_interval.end
         )
 
     def __hash__(self):
@@ -394,8 +504,8 @@ class MayaInterval(object):
     @validate_arguments_type_of_function()
     def __cmp__(self, maya_interval):
         return (
-            cmp(self.start, maya_interval.start) or
+            cmp(self.start, maya_interval.start)
-            cmp(self.end, maya_interval.end)
+            or cmp(self.end, maya_interval.end)
         )
 
     @property
@@ -426,8 +536,9 @@ class MayaInterval(object):
                 MayaInterval(
                     interval_list[0].start,
                     max(interval_list[0].end, interval_list[1].end),
-                ),
+                )
             ]
+
         return interval_list
 
     @validate_arguments_type_of_function()
@@ -435,6 +546,7 @@ class MayaInterval(object):
         """"Removes the given interval."""
         if not self & maya_interval:
             return [self]
+
         elif maya_interval.contains(self):
             return []
 
@@ -446,10 +558,8 @@ class MayaInterval(object):
         return interval_list
 
     def split(self, duration, include_remainder=True):
-
         # Convert seconds to timedelta, if appropriate.
-        duration = seconds_or_timedelta(duration)
+        duration = _seconds_or_timedelta(duration)
-
         if duration <= timedelta(seconds=0):
             raise ValueError('cannot call split with a non-positive timedelta')
 
@@ -457,38 +567,36 @@ class MayaInterval(object):
         while start < self.end:
             if start + duration <= self.end:
                 yield MayaInterval(start, start + duration)
+
             elif include_remainder:
                 yield MayaInterval(start, self.end)
+
             start += duration
 
     def quantize(self, duration, snap_out=False, timezone='UTC'):
         """Returns a quanitzed interval."""
-
         # Convert seconds to timedelta, if appropriate.
-        duration = seconds_or_timedelta(duration)
+        duration = _seconds_or_timedelta(duration)
         timezone = pytz.timezone(timezone)
-
-
         if duration <= timedelta(seconds=0):
             raise ValueError('cannot quantize by non-positive timedelta')
 
         epoch = timezone.localize(Datetime(1970, 1, 1))
         seconds = int(duration.total_seconds())
-
+        start_seconds = int(
-        start_seconds = int((self.start.datetime(naive=False) - epoch).total_seconds())
+            (self.start.datetime(naive=False) - epoch).total_seconds()
-        end_seconds = int((self.end.datetime(naive=False) - epoch).total_seconds())
+        )
-
+        end_seconds = int(
+            (self.end.datetime(naive=False) - epoch).total_seconds()
+        )
         if start_seconds % seconds and not snap_out:
             start_seconds += seconds
         if end_seconds % seconds and snap_out:
             end_seconds += seconds
-
         start_seconds -= start_seconds % seconds
         end_seconds -= end_seconds % seconds
-
         if start_seconds > end_seconds:
             start_seconds = end_seconds
-
         return MayaInterval(
             start=MayaDT.from_datetime(epoch).add(seconds=start_seconds),
             end=MayaDT.from_datetime(epoch).add(seconds=end_seconds),
@@ -497,23 +605,17 @@ class MayaInterval(object):
     @validate_arguments_type_of_function()
     def intersection(self, maya_interval):
         """Returns the intersection between two intervals."""
-
         start = max(self.start, maya_interval.start)
         end = min(self.end, maya_interval.end)
-
         either_instant = self.is_instant or maya_interval.is_instant
-        instant_overlap = (
+        instant_overlap = (self.start == maya_interval.start or start <= end)
-            self.start == maya_interval.start or
-            start <= end
-        )
         if (either_instant and instant_overlap) or (start < end):
             return MayaInterval(start, end)
 
     @validate_arguments_type_of_function()
     def contains(self, maya_interval):
         return (
-            self.start <= maya_interval.start and
+            self.start <= maya_interval.start and self.end >= maya_interval.end
-            self.end >= maya_interval.end
         )
 
     def __contains__(self, maya_dt):
@@ -528,8 +630,7 @@ class MayaInterval(object):
     @validate_arguments_type_of_function()
     def is_adjacent(self, maya_interval):
         return (
-            self.start == maya_interval.end or
+            self.start == maya_interval.end or self.end == maya_interval.start
-            self.end == maya_interval.start
         )
 
     @property
@@ -546,14 +647,28 @@ class MayaInterval(object):
         """.format(
             self.start.datetime().strftime(ical_dt_format),
             self.end.datetime().strftime(ical_dt_format),
-        ).replace(' ', '').strip('\r\n').replace('\n', '\r\n')
+        ).replace(
+            ' ', ''
+        ).strip(
+            '\r\n'
+        ).replace(
+            '\n', '\r\n'
+        )
 
     @staticmethod
     def flatten(interval_list):
-        return functools.reduce(lambda reduced, maya_interval: (
+        return functools.reduce(
-            (reduced[:-1] + maya_interval.combine(reduced[-1]))
+            lambda reduced,
-            if reduced else [maya_interval]
+            maya_interval: (
-        ), sorted(interval_list), [])
+                (
+                    reduced[:-1] + maya_interval.combine(reduced[-1])
+                ) if reduced else [
+                    maya_interval
+                ]
+            ),
+            sorted(interval_list),
+            [],
+        )
 
     @classmethod
     def from_datetime(cls, start_dt=None, end_dt=None, duration=None):
@@ -568,7 +683,7 @@ def now():
     return MayaDT(epoch=epoch)
 
 
-def when(string, timezone='UTC'):
+def when(string, timezone='UTC', prefer_dates_from='current_period'):
     """"Returns a MayaDT instance for the human moment specified.
 
     Powered by dateparser. Useful for scraping websites.
@@ -579,31 +694,53 @@ def when(string, timezone='UTC'):
     Keyword Arguments:
         string -- string to be parsed
         timezone -- timezone referenced from (default: 'UTC')
+        prefer_dates_from -- what dates are prefered when `string` is ambigous.
+                             options are 'past', 'future', and 'current_period'
+                             (default: 'current_period'). see: [1]
 
+    Reference:
+        [1] dateparser.readthedocs.io/en/latest/usage.html#handling-incomplete-dates
     """
-    dt = dateparser.parse(string,
+    settings = {
-                          settings={'TIMEZONE': timezone, 'RETURN_AS_TIMEZONE_AWARE': True, 'TO_TIMEZONE': 'UTC'})
+        'TIMEZONE': timezone,
+        'RETURN_AS_TIMEZONE_AWARE': True,
+        'TO_TIMEZONE': 'UTC',
+        'PREFER_DATES_FROM': prefer_dates_from,
+    }
 
+    dt = dateparser.parse(string, settings=settings)
     if dt is None:
         raise ValueError('invalid datetime input specified.')
 
     return MayaDT.from_datetime(dt)
 
 
-def parse(string, day_first=False):
+def parse(string, timezone='UTC', day_first=False, year_first=True):
     """"Returns a MayaDT instance for the machine-produced moment specified.
 
-    Powered by pendulum. Accepts most known formats. Useful for working with data.
+    Powered by pendulum.
+    Accepts most known formats. Useful for working with data.
 
     Keyword Arguments:
         string -- string to be parsed
-        day_first -- if true, the first value (e.g. 01/05/2016) is parsed as day (default: False)
+        timezone -- timezone referenced from (default: 'UTC')
+        day_first -- if true, the first value (e.g. 01/05/2016)
+                     is parsed as day.
+                     if year_first is set to True, this distinguishes
+                     between YDM and YMD. (default: False)
+        year_first -- if true, the first value (e.g. 2016/05/01)
+                      is parsed as year (default: True)
     """
-    dt = pendulum.parse(string, day_first=day_first)
+    options = {}
+    options['tz'] = timezone
+    options['day_first'] = day_first
+    options['year_first'] = year_first
+
+    dt = pendulum.parse(str(string), **options)
     return MayaDT.from_datetime(dt)
 
 
-def seconds_or_timedelta(duration):
+def _seconds_or_timedelta(duration):
     """Returns `datetime.timedelta` object for the passed duration.
 
     Keyword Arguments:
@@ -614,17 +751,22 @@ def seconds_or_timedelta(duration):
     elif isinstance(duration, timedelta):
         dt_timedelta = duration
     else:
-        raise TypeError('Expects argument as `datetime.timedelta` object '
+        raise TypeError(
-                        'or seconds in `int` format')
+            'Expects argument as `datetime.timedelta` object '
+            'or seconds in `int` format'
+        )
+
     return dt_timedelta
 
 
 def intervals(start, end, interval):
-    """Yields MayaDT objects between the start and end MayaDTs given, at a given interval (seconds or timedelta)."""
+    """
-
+    Yields MayaDT objects between the start and end MayaDTs given,
-    interval = seconds_or_timedelta(interval)
+    at a given interval (seconds or timedelta).
-
+    """
+    interval = _seconds_or_timedelta(interval)
     current_timestamp = start
     while current_timestamp.epoch < end.epoch:
         yield current_timestamp
+
         current_timestamp = current_timestamp.add(seconds=interval.seconds)

setup.py

@@ -1,20 +1,16 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import io
 import os
 import sys
 import codecs
+from shutil import rmtree
 
-from setuptools import setup
+from setuptools import find_packages, setup, Command
 
-try:
-    # Python 3
-    from os import dirname
-except ImportError:
-    # Python 2
-    from os.path import dirname
 
-here = os.path.abspath(dirname(__file__))
+here = os.path.abspath(os.path.dirname(__file__))
 
 with codecs.open(os.path.join(here, 'README.rst'), encoding='utf-8') as f:
     long_description = '\n' + f.read()
@@ -27,19 +23,56 @@ if sys.argv[-1] == "publish":
 required = [
     'humanize',
     'pytz',
-    'dateparser',
+    'dateparser>=0.7.0',
-    'ruamel.yaml',
     'tzlocal',
-    'pendulum'
+    'pendulum>=1.0, <=1.5.1',
+    'snaptime'
 ]
 
 packages = [
     'maya',
 ]
 
+class UploadCommand(Command):
+    """Support setup.py upload."""
+
+    description = 'Build and publish the package.'
+    user_options = []
+
+    @staticmethod
+    def status(s):
+        """Prints things in bold."""
+        print('\033[1m{0}\033[0m'.format(s))
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        try:
+            self.status('Removing previous builds…')
+            rmtree(os.path.join(here, 'dist'))
+        except OSError:
+            pass
+
+        self.status('Building Source and Wheel (universal) distribution…')
+        os.system('{0} setup.py sdist bdist_wheel --universal'.format(sys.executable))
+
+        self.status('Uploading the package to PyPi via Twine…')
+        os.system('twine upload dist/*')
+
+        self.status('Pushing git tags…')
+        os.system('git tag v{0}'.format(about['__version__']))
+        os.system('git push --tags')
+
+        sys.exit()
+
+
 # About dict to store version and package info
 about = dict()
-with open(os.path.join(here, 'maya', '__version__.py'), 'r', 'utf-8') as f:
+with codecs.open(os.path.join(here, 'maya', '__version__.py'), 'r', encoding='utf-8') as f:
     exec(f.read(), about)
 
 setup(
@@ -67,4 +100,7 @@ setup(
         'Programming Language :: Python :: Implementation :: CPython',
         'Topic :: Software Development :: Libraries :: Python Modules'
     ),
+    cmdclass={
+        'upload': UploadCommand,
+    },
 )

tests/conftest.py

@@ -0,0 +1,24 @@
+from freezegun import freeze_time
+import pytest
+
+
+@pytest.fixture(params=[
+    ("2018-03-25T00:00:00", 2),
+    ("2018-03-25T01:00:00", 2),
+    ("2018-03-25T02:00:00", 2),
+    ("2018-03-25T02:30:00", 2),
+    ("2018-03-25T03:00:00", 2),
+    ("2018-03-25T04:00:00", 2),
+
+    ("2018-10-28T00:00:00", 2),
+    ("2018-10-28T01:00:00", 2),
+    ("2018-10-28T02:00:00", 2),
+    ("2018-10-28T02:30:00", 2),
+    ("2018-10-28T03:00:00", 2),
+    ("2018-10-28T04:00:00", 2),
+
+], ids=lambda x: x[0] + "_off_" + str(x[1]))
+def frozen_now(request):
+    now_string, tz_offset = request.param
+    with freeze_time(now_string, tz_offset=tz_offset):
+        yield

tests/test_maya.py

@@ -1,100 +1,121 @@
-import pytest
 import copy
-from datetime import timedelta
+import time
+import calendar
+from datetime import timedelta, datetime as Datetime
+
+import pytz
+import pytest
 
 import maya
+from maya.core import _seconds_or_timedelta  # import private function
 
 
-def test_rfc2822():
+@pytest.mark.parametrize("string,expected", [
-    r = maya.parse('February 21, 1994').rfc2822()
+    ('February 21, 1994',
+     'Mon, 21 Feb 1994 00:00:00 GMT'),
+])
+def test_rfc2822(string, expected):
+    r = maya.parse(string).rfc2822()
     d = maya.MayaDT.from_rfc2822(r)
-    assert r == 'Mon, 21 Feb 1994 00:00:00 GMT'
+    assert r == expected
     assert r == d.rfc2822()
 
 
-def test_iso8601():
+@pytest.mark.parametrize("string,expected", [
-    r = maya.parse('February 21, 1994').iso8601()
+    ('February 21, 1994',
+     '1994-02-21T00:00:00Z'),
+])
+def test_iso8601(string, expected):
+    r = maya.parse(string).iso8601()
     d = maya.MayaDT.from_iso8601(r)
-    assert r == '1994-02-21T00:00:00Z'
+    assert r == expected
     assert r == d.iso8601()
 
 
-def test_parse_iso8601():
+@pytest.mark.parametrize("string,expected", [
-    string = '20161001T1430.4+05:30'
+    ('20161001T1430.4+05:30',
-    expected = '2016-10-01T09:00:00.400000Z'
+     '2016-10-01T09:00:00.400000Z'),
-    d = maya.MayaDT.from_iso8601(string)
 
+    ('2016T14',
+     '2016-01-01T14:00:00Z'),
+
+    ('2016-10T14',
+     '2016-10-01T14:00:00Z'),
+
+    ('2012W05',
+     '2012-01-30T00:00:00Z'),
+
+    ('2012W055',
+     '2012-02-03T00:00:00Z'),
+
+    ('2012007',
+     '2012-01-07T00:00:00Z'),
+
+    ('2016-W07T09',
+     '2016-02-15T09:00:00Z'),
+])
+def test_parse_iso8601(string, expected):
+    d = maya.MayaDT.from_iso8601(string)
     assert expected == d.iso8601()
 
-    string = '2016T14'
-    expected = '2016-01-01T14:00:00Z'
-    d = maya.MayaDT.from_iso8601(string)
 
-    assert expected == d.iso8601()
+@pytest.mark.usefixtures("frozen_now")
+def test_struct():
+    now = round(time.time())
+    ts = time.gmtime(now)
+    m = maya.MayaDT.from_struct(ts)
+    dt = Datetime.fromtimestamp(now, pytz.UTC)
+    assert m._epoch is not None
+    assert m.datetime() == dt
+    ts = time.localtime(now)
+    m = maya.MayaDT.from_struct(ts)
+    dt = Datetime.fromtimestamp(
+        time.mktime(ts) - maya.core.utc_offset(ts), pytz.UTC
+    )
+    assert m._epoch is not None
+    assert m.datetime() == dt
 
-    string = '2016-10T14'
-    expected = '2016-10-01T14:00:00Z'
-    d = maya.MayaDT.from_iso8601(string)
 
-    assert expected == d.iso8601()
+def test_issue_104():
-
+    e = 1507756331
-    string = '2012W05'
+    t = Datetime.utcfromtimestamp(e)
-    expected = '2012-01-30T00:00:00Z'
+    t = maya.MayaDT.from_datetime(t)
-    d = maya.MayaDT.from_iso8601(string)
+    assert str(t) == 'Wed, 11 Oct 2017 21:12:11 GMT'
-
+    t = time.gmtime(e)
-    assert expected == d.iso8601()
+    t = maya.MayaDT.from_struct(t)
-
+    assert str(t) == 'Wed, 11 Oct 2017 21:12:11 GMT'
-    string = '2012W055'
-    expected = '2012-02-03T00:00:00Z'
-    d = maya.MayaDT.from_iso8601(string)
-
-    assert expected == d.iso8601()
-
-    string = '2012007'
-    expected = '2012-01-07T00:00:00Z'
-    d = maya.MayaDT.from_iso8601(string)
-
-    assert expected == d.iso8601()
-
-    string = '2016-W07T09'
-    expected = '2016-02-15T09:00:00Z'
-    d = maya.MayaDT.from_iso8601(string)
-
-    assert expected == d.iso8601()
 
 
 def test_human_when():
     r1 = maya.when('yesterday')
     r2 = maya.when('today')
-
     assert (r2.day - r1.day) in (1, -30, -29, -28, -27)
 
 
 def test_machine_parse():
     r1 = maya.parse('August 14, 2015')
     assert r1.day == 14
-
     r2 = maya.parse('August 15, 2015')
     assert r2.day == 15
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_dt_tz_translation():
     d1 = maya.now().datetime()
     d2 = maya.now().datetime(to_timezone='EST')
     assert (d1.hour - d2.hour) % 24 == 5
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_dt_tz_naive():
     d1 = maya.now().datetime(naive=True)
     assert d1.tzinfo is None
-
     d2 = maya.now().datetime(to_timezone='EST', naive=True)
     assert d2.tzinfo is None
     assert (d1.hour - d2.hour) % 24 == 5
 
 
 def test_random_date():
-
     # Test properties for maya.when()
     d1 = maya.when('11-17-11 08:09:10')
     assert d1.year == 2011
@@ -106,7 +127,6 @@ def test_random_date():
     assert d1.minute == 9
     assert d1.second == 10
     assert d1.microsecond == 0
-
     # Test properties for maya.parse()
     d2 = maya.parse('February 29, 1992 13:12:34')
     assert d2.year == 1992
@@ -122,10 +142,8 @@ def test_random_date():
 
 def test_print_date(capsys):
     d = maya.when('11-17-11')
-
     print(d)
     out, err = capsys.readouterr()
-
     assert out == 'Thu, 17 Nov 2011 00:00:00 GMT\n'
     assert repr(d) == '<MayaDT epoch=1321488000.0>'
 
@@ -141,55 +159,110 @@ def test_slang_date():
 
 
 def test_slang_time():
-    d = maya.when('one hour ago')
+    d = maya.when('1 hour ago')
     assert d.slang_time() == 'an hour ago'
 
 
-def test_parse():
+@pytest.mark.parametrize("string,kwds,expected", [
-    d = maya.parse('February 21, 1994')
+    ('February 21, 1994', {},
-    assert format(d) == '1994-02-21 00:00:00+00:00'
+     '1994-02-21 00:00:00+00:00'),
 
-    d = maya.parse('01/05/2016')
+    ('01/05/2016', {},
-    assert format(d) == '2016-01-05 00:00:00+00:00'
+     '2016-01-05 00:00:00+00:00'),
 
-    d = maya.parse('01/05/2016', day_first=True)
+    ('01/05/2016', dict(day_first=True),
-    assert format(d) == '2016-05-01 00:00:00+00:00'
+     '2016-05-01 00:00:00+00:00'),
+
+    ('2016/05/01', dict(year_first=True, day_first=False),
+     '2016-05-01 00:00:00+00:00'),
+
+    ('2016/01/05', dict(year_first=True, day_first=True),
+     '2016-05-01 00:00:00+00:00'),
+
+    ('01/05/2016', dict(timezone='UTC'),
+     '2016-01-05 00:00:00+00:00'),
+
+    ('01/05/2016', dict(timezone='US/Central'),
+     '2016-01-05 06:00:00+00:00'),
+])
+def test_parse(string, kwds, expected):
+    d = maya.parse(string, **kwds)
+    assert format(d) == expected
+
+
+@pytest.mark.usefixtures("frozen_now")
+def test_when_past():
+    two_days_away = maya.now().add(days=2)
+
+    past_date = maya.when(
+            two_days_away.slang_date(),
+            prefer_dates_from='past')
+
+    assert past_date < maya.now()
+
+
+@pytest.mark.usefixtures("frozen_now")
+def test_when_future():
+    two_days_away = maya.now().add(days=2)
+
+    future_date = maya.when(
+            two_days_away.slang_date(),
+            prefer_dates_from='future')
+
+    assert future_date > maya.now()
+
+
+@pytest.mark.usefixtures("frozen_now")
+def test_when_past_day_name():
+    two_days_away = maya.now().add(days=2)
+
+    past_date = maya.when(
+            calendar.day_name[two_days_away.weekday],
+            prefer_dates_from='past')
+
+    assert past_date < maya.now()
+
+
+@pytest.mark.usefixtures("frozen_now")
+def test_when_future_day_name():
+    two_days_away = maya.now().add(days=2)
+
+    future_date = maya.when(
+            calendar.day_name[two_days_away.weekday],
+            prefer_dates_from='future')
+
+    assert future_date > maya.now()
 
 
 def test_datetime_to_timezone():
     dt = maya.when('2016-01-01').datetime(to_timezone='US/Eastern')
     assert dt.tzinfo.zone == 'US/Eastern'
 
+
 def test_rfc3339():
-    mdt =  maya.when('2016-01-01')
+    mdt = maya.when('2016-01-01')
     out = mdt.rfc3339()
     mdt2 = maya.MayaDT.from_rfc3339(out)
     assert mdt.epoch == mdt2.epoch
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_comparison_operations():
     now = maya.now()
     now_copy = copy.deepcopy(now)
     tomorrow = maya.when('tomorrow')
-
     assert (now == now_copy) is True
     assert (now == tomorrow) is False
-
     assert (now != now_copy) is False
     assert (now != tomorrow) is True
-
     assert (now < now_copy) is False
     assert (now < tomorrow) is True
-
     assert (now <= now_copy) is True
     assert (now <= tomorrow) is True
-
     assert (now > now_copy) is False
     assert (now > tomorrow) is False
-
     assert (now >= now_copy) is True
     assert (now >= tomorrow) is False
-
     # Check Exceptions
     with pytest.raises(TypeError):
         now == 1
@@ -207,34 +280,98 @@ def test_comparison_operations():
 
 def test_seconds_or_timedelta():
     # test for value in seconds
-    assert maya.seconds_or_timedelta(1234) == timedelta(0, 1234)
+    assert _seconds_or_timedelta(1234) == timedelta(0, 1234)
     # test for value as `datetime.timedelta`
-    assert maya.seconds_or_timedelta(timedelta(0, 1234)) == timedelta(0, 1234)
+    assert _seconds_or_timedelta(timedelta(0, 1234)) == timedelta(0, 1234)
     # test for invalid value
     with pytest.raises(TypeError):
-        maya.seconds_or_timedelta('invalid interval')
+        _seconds_or_timedelta('invalid interval')
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_intervals():
     now = maya.now()
     tomorrow = now.add(days=1)
-
+    assert len(list(maya.intervals(now, tomorrow, 60 * 60))) == 24
-    assert len(list(maya.intervals(now, tomorrow, 60*60))) == 24
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_dunder_add():
     now = maya.now()
     assert now + 1 == now.add(seconds=1)
     assert now + timedelta(seconds=1) == now.add(seconds=1)
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_dunder_radd():
     now = maya.now()
     assert now.add(seconds=1) == now + 1
     assert now.add(seconds=1) == now + timedelta(seconds=1)
 
 
+@pytest.mark.usefixtures("frozen_now")
 def test_dunder_sub():
     now = maya.now()
     assert now - 1 == now.subtract(seconds=1)
     assert now - timedelta(seconds=1) == now.subtract(seconds=1)
+
+
+@pytest.mark.usefixtures("frozen_now")
+def test_mayaDT_sub():
+    now = maya.now()
+    then = now.add(days=1)
+    assert then - now == timedelta(seconds=24 * 60 * 60)
+    assert now - then == timedelta(seconds=-24 * 60 * 60)
+
+
+def test_core_local_timezone(monkeypatch):
+
+    @property
+    def mock_local_tz(self):
+
+        class StaticTzInfo(object):
+            zone = 'local'
+
+            def __repr__(self):
+                return "<StaticTzInfo 'local'>"
+
+        return StaticTzInfo()
+
+    monkeypatch.setattr(maya.MayaDT, '_local_tz', mock_local_tz)
+    mdt = maya.MayaDT(0)
+    assert mdt.local_timezone == 'UTC'
+
+
+def test_getting_datetime_for_local_timezone(monkeypatch):
+
+    @property
+    def mock_local_tz(self):
+        class StaticTzInfo(object):
+            zone = 'Europe/Zurich'
+
+            def __repr__(self):
+                return "<StaticTzInfo 'Europe/Zurich'>"
+
+        return StaticTzInfo()
+
+    monkeypatch.setattr(maya.MayaDT, '_local_tz', mock_local_tz)
+
+    d = maya.parse('1994-02-21T12:00:00+05:30')
+
+    dt = pytz.timezone('Europe/Zurich').localize(
+            Datetime(1994, 2, 21, 7, 30))
+
+    assert d.local_datetime() == dt
+
+
+@pytest.mark.parametrize("when_str,snap_str,expected_when", [
+    ('Mon, 21 Feb 1994 21:21:42 GMT', '@d',
+     'Mon, 21 Feb 1994 00:00:00 GMT'),
+])
+def test_snaptime(when_str, snap_str, expected_when):
+    # given
+    dt = maya.when(when_str)
+    # when
+    dt = dt.snap(snap_str)
+    # then
+    assert dt == maya.when(expected_when)

tests/test_maya_interval.py

@@ -15,26 +15,20 @@ Melbourne = pytz.timezone('Australia/Melbourne')
 def test_interval_requires_2_of_start_end_duration():
     start = maya.now()
     end = start.add(hours=1)
-
     with pytest.raises(ValueError):
         maya.MayaInterval(start=start)
-
     with pytest.raises(ValueError):
         maya.MayaInterval(end=end)
-
     with pytest.raises(ValueError):
         maya.MayaInterval(duration=60)
-
     with pytest.raises(ValueError):
         maya.MayaInterval(start=start, end=end, duration=60)
-
     maya.MayaInterval(start=start, end=end)
     maya.MayaInterval(start=start, duration=60)
     maya.MayaInterval(end=end, duration=60)
 
 
 def test_interval_requires_end_time_after_or_on_start_time():
-
     with pytest.raises(ValueError):
         maya.MayaInterval(start=maya.now(), duration=0)
         maya.MayaInterval(start=maya.now(), duration=-1)
@@ -64,7 +58,9 @@ def test_interval_init_end_duration():
     assert interval.start == end.subtract(seconds=duration)
 
 
-@pytest.mark.parametrize('start_doy1,end_doy1,start_doy2,end_doy2,intersection_doys', (
+@pytest.mark.parametrize(
+    'start_doy1,end_doy1,start_doy2,end_doy2,intersection_doys',
+    (
         (0, 2, 1, 3, (1, 2)),
         (0, 2, 3, 4, None),
         (0, 2, 2, 3, None),
@@ -76,7 +72,8 @@ def test_interval_init_end_duration():
         (1, 3, 1, 1, (1, 1)),
         (2, 3, 1, 1, None),
         (1, 3, 2, 2, (2, 2)),
-), ids=(
+    ),
+    ids=(
         'overlapping',
         'non-overlapping',
         'adjacent',
@@ -87,21 +84,19 @@ def test_interval_init_end_duration():
         'instant overlapping',
         'instant overlapping start only (left)',
         'instant disjoint (left)',
-        'instant overlapping (left)'
+        'instant overlapping (left)',
-))
+    ),
+)
 def test_interval_intersection(
-        start_doy1, end_doy1, start_doy2, end_doy2, intersection_doys
+    start_doy1, end_doy1, start_doy2, end_doy2, intersection_doys
 ):
     base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
     interval1 = maya.MayaInterval(
-        base.add(days=start_doy1),
+        base.add(days=start_doy1), base.add(days=end_doy1)
-        base.add(days=end_doy1),
     )
     interval2 = maya.MayaInterval(
-        base.add(days=start_doy2),
+        base.add(days=start_doy2), base.add(days=end_doy2)
-        base.add(days=end_doy2),
     )
-
     if intersection_doys:
         start_doy_intersection, end_doy_intersection = intersection_doys
         assert interval1 & interval2 == maya.MayaInterval(
@@ -110,7 +105,6 @@ def test_interval_intersection(
         )
     else:
         assert (interval1 & interval2) is None
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval1 & 'invalid type'
@@ -119,13 +113,10 @@ def test_interval_intersection(
 def test_interval_intersects():
     base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
     interval = maya.MayaInterval(base, base.add(days=1))
-
     assert interval.intersects(interval)
-    assert not interval.intersects(maya.MayaInterval(
+    assert not interval.intersects(
-        base.add(days=2),
+        maya.MayaInterval(base.add(days=2), base.add(days=3))
-        base.add(days=3),
+    )
-    ))
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval.intersects('invalid type')
@@ -135,13 +126,11 @@ def test_and_operator():
     base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
     interval1 = maya.MayaInterval(base, base.add(days=2))
     interval2 = maya.MayaInterval(base.add(days=1), base.add(days=3))
-
     assert (
         interval1 & interval2 ==
         interval2 & interval1 ==
         interval1.intersection(interval2)
     )
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval1.intersection('invalid type')
@@ -151,14 +140,11 @@ def test_interval_eq_operator():
     start = maya.now()
     end = start.add(hours=1)
     interval = maya.MayaInterval(start=start, end=end)
-
     assert interval == maya.MayaInterval(start=start, end=end)
     assert interval != maya.MayaInterval(start=start, end=end.add(days=1))
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval == 'invalid type'
-
     with pytest.raises(TypeError):
         interval != 'invalid type'
 
@@ -167,7 +153,6 @@ def test_interval_timedelta():
     start = maya.now()
     delta = timedelta(hours=1)
     interval = maya.MayaInterval(start=start, duration=delta)
-
     assert interval.timedelta == delta
 
 
@@ -175,69 +160,55 @@ def test_interval_duration():
     start = maya.now()
     delta = timedelta(hours=1)
     interval = maya.MayaInterval(start=start, duration=delta)
-
     assert interval.duration == delta.total_seconds()
 
 
-@pytest.mark.parametrize('start_doy1,end_doy1,start_doy2,end_doy2,expected', (
+@pytest.mark.parametrize(
+    'start_doy1,end_doy1,start_doy2,end_doy2,expected',
+    (
         (0, 2, 1, 3, False),
         (0, 2, 3, 4, False),
         (0, 2, 2, 3, False),
         (0, 1, 0, 1, True),
         (0, 3, 1, 2, True),
-), ids=(
+    ),
-        'overlapping',
+    ids=('overlapping', 'non-overlapping', 'adjacent', 'equal', 'subset'),
-        'non-overlapping',
+)
-        'adjacent',
-        'equal',
-        'subset',
-))
 def test_interval_contains(
-        start_doy1, end_doy1, start_doy2, end_doy2, expected
+    start_doy1, end_doy1, start_doy2, end_doy2, expected
 ):
     base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
     interval1 = maya.MayaInterval(
-        base.add(days=start_doy1),
+        base.add(days=start_doy1), base.add(days=end_doy1)
-        base.add(days=end_doy1),
     )
     interval2 = maya.MayaInterval(
-        base.add(days=start_doy2),
+        base.add(days=start_doy2), base.add(days=end_doy2)
-        base.add(days=end_doy2),
     )
-
     assert interval1.contains(interval2) is expected
     assert (interval2 in interval1) is expected
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval1.contains('invalid type')
 
 
-@pytest.mark.parametrize('start_doy,end_doy,dt_doy,expected', (
+@pytest.mark.parametrize(
+    'start_doy,end_doy,dt_doy,expected',
+    (
         (2, 4, 1, False),
         (2, 4, 2, True),
         (2, 4, 3, True),
         (2, 4, 4, False),
         (2, 4, 5, False),
-), ids=(
+    ),
-        'before-start',
+    ids=('before-start', 'on-start', 'during', 'on-end', 'after-end'),
-        'on-start',
+)
-        'during',
+def test_interval_in_operator_maya_dt(start_doy, end_doy, dt_doy, expected):
-        'on-end',
-        'after-end',
-))
-def test_interval_in_operator_maya_dt(
-        start_doy, end_doy, dt_doy, expected
-):
     base = maya.MayaDT.from_datetime(datetime(2016, 1, 1))
     interval = maya.MayaInterval(
-        start=base.add(days=start_doy),
+        start=base.add(days=start_doy), end=base.add(days=end_doy)
-        end=base.add(days=end_doy),
     )
     dt = base.add(days=dt_doy)
-
     assert (dt in interval) is expected
-
     # check invalid argument
     with pytest.raises(TypeError):
         'invalid type' in interval
@@ -247,91 +218,84 @@ def test_interval_hash():
     start = maya.now()
     end = start.add(hours=1)
     interval = maya.MayaInterval(start=start, end=end)
-
     assert hash(interval) == hash(maya.MayaInterval(start=start, end=end))
-    assert hash(interval) != hash(maya.MayaInterval(
+    assert hash(interval) != hash(
-        start=start, end=end.add(days=1)))
+        maya.MayaInterval(start=start, end=end.add(days=1))
+    )
 
 
 def test_interval_iter():
     start = maya.now()
     end = start.add(days=1)
-
     assert tuple(maya.MayaInterval(start=start, end=end)) == (start, end)
 
 
-@pytest.mark.parametrize('start1,end1,start2,end2,expected', [
+@pytest.mark.parametrize(
-    (1, 2, 1, 2, 0),
+    'start1,end1,start2,end2,expected',
-    (1, 3, 2, 4, -1),
+    [(1, 2, 1, 2, 0), (1, 3, 2, 4, -1), (2, 4, 1, 3, 1), (1, 2, 1, 3, -1)],
-    (2, 4, 1, 3, 1),
+    ids=(
-    (1, 2, 1, 3, -1),
-], ids=(
         'equal',
         'less-than',
         'greater-than',
         'use-end-time-if-start-time-identical',
-))
+    ),
+)
 def test_interval_cmp(start1, end1, start2, end2, expected):
     base = maya.now()
     interval1 = maya.MayaInterval(
-        start=base.add(days=start1),
+        start=base.add(days=start1), end=base.add(days=end1)
-        end=base.add(days=end1),
     )
     interval2 = maya.MayaInterval(
-        start=base.add(days=start2),
+        start=base.add(days=start2), end=base.add(days=end2)
-        end=base.add(days=end2),
     )
     assert cmp(interval1, interval2) == expected
-
     # check invalid argument
     with pytest.raises(TypeError):
         cmp(interval1, 'invalid type')
 
 
-@pytest.mark.parametrize('start1,end1,start2,end2,expected', [
+@pytest.mark.parametrize(
-    (1, 2, 2, 3, [(1, 3)]),
+    'start1,end1,start2,end2,expected',
-    (1, 3, 2, 4, [(1, 4)]),
+    [
-    (1, 2, 3, 4, [(1, 2), (3, 4)]),
+        (1, 2, 2, 3, [(1, 3)]),
-    (1, 5, 2, 3, [(1, 5)]),
+        (1, 3, 2, 4, [(1, 4)]),
-], ids=(
+        (1, 2, 3, 4, [(1, 2), (3, 4)]),
-        'adjacent',
+        (1, 5, 2, 3, [(1, 5)]),
-        'overlapping',
+    ],
-        'non-overlapping',
+    ids=('adjacent', 'overlapping', 'non-overlapping', 'contains'),
-        'contains',
+)
-))
 def test_interval_combine(start1, end1, start2, end2, expected):
     base = maya.now()
     interval1 = maya.MayaInterval(
-        start=base.add(days=start1),
+        start=base.add(days=start1), end=base.add(days=end1)
-        end=base.add(days=end1),
     )
     interval2 = maya.MayaInterval(
-        start=base.add(days=start2),
+        start=base.add(days=start2), end=base.add(days=end2)
-        end=base.add(days=end2),
     )
-    expected_intervals = [maya.MayaInterval(
+    expected_intervals = [
-        start=base.add(days=start),
+        maya.MayaInterval(start=base.add(days=start), end=base.add(days=end))
-        end=base.add(days=end),
+        for start, end in expected
-    ) for start, end in expected]
+    ]
-
     assert interval1.combine(interval2) == expected_intervals
     assert interval2.combine(interval1) == expected_intervals
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval2.combine('invalid type')
 
 
-@pytest.mark.parametrize('start1,end1,start2,end2,expected', [
+@pytest.mark.parametrize(
-    (1, 2, 3, 4, [(1, 2)]),
+    'start1,end1,start2,end2,expected',
-    (1, 2, 2, 4, [(1, 2)]),
+    [
-    (2, 3, 1, 4, []),
+        (1, 2, 3, 4, [(1, 2)]),
-    (1, 4, 2, 3, [(1, 2), (3, 4)]),
+        (1, 2, 2, 4, [(1, 2)]),
-    (1, 4, 0, 2, [(2, 4)]),
+        (2, 3, 1, 4, []),
-    (1, 4, 3, 5, [(1, 3)]),
+        (1, 4, 2, 3, [(1, 2), (3, 4)]),
-    (1, 4, 1, 2, [(2, 4)]),
+        (1, 4, 0, 2, [(2, 4)]),
-    (1, 4, 3, 4, [(1, 3)]),
+        (1, 4, 3, 5, [(1, 3)]),
-], ids=(
+        (1, 4, 1, 2, [(2, 4)]),
+        (1, 4, 3, 4, [(1, 3)]),
+    ],
+    ids=(
         'non-overlapping',
         'adjacent',
         'contains',
@@ -340,115 +304,109 @@ def test_interval_combine(start1, end1, start2, end2, expected):
         'overlaps-right',
         'overlaps-left-identical-start',
         'overlaps-right-identical-end',
-))
+    ),
+)
 def test_interval_subtract(start1, end1, start2, end2, expected):
     base = maya.now()
     interval1 = maya.MayaInterval(
-        start=base.add(days=start1),
+        start=base.add(days=start1), end=base.add(days=end1)
-        end=base.add(days=end1),
     )
     interval2 = maya.MayaInterval(
-        start=base.add(days=start2),
+        start=base.add(days=start2), end=base.add(days=end2)
-        end=base.add(days=end2),
     )
-    expected_intervals = [maya.MayaInterval(
+    expected_intervals = [
-        start=base.add(days=start),
+        maya.MayaInterval(start=base.add(days=start), end=base.add(days=end))
-        end=base.add(days=end),
+        for start, end in expected
-    ) for start, end in expected]
+    ]
-
     assert interval1.subtract(interval2) == expected_intervals
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval1.subtract('invalid type')
 
 
-@pytest.mark.parametrize('start1,end1,start2,end2,expected', [
+@pytest.mark.parametrize(
-    (1, 2, 2, 3, True),
+    'start1,end1,start2,end2,expected',
-    (2, 3, 1, 2, True),
+    [
-    (1, 3, 2, 3, False),
+        (1, 2, 2, 3, True),
-    (2, 3, 4, 5, False),
+        (2, 3, 1, 2, True),
-], ids=(
+        (1, 3, 2, 3, False),
-        'adjacent-right',
+        (2, 3, 4, 5, False),
-        'adjacent-left',
+    ],
-        'overlapping',
+    ids=('adjacent-right', 'adjacent-left', 'overlapping', 'non-overlapping'),
-        'non-overlapping',
+)
-))
 def test_interval_is_adjacent(start1, end1, start2, end2, expected):
     base = maya.now()
     interval1 = maya.MayaInterval(
-        start=base.add(days=start1),
+        start=base.add(days=start1), end=base.add(days=end1)
-        end=base.add(days=end1),
     )
     interval2 = maya.MayaInterval(
-        start=base.add(days=start2),
+        start=base.add(days=start2), end=base.add(days=end2)
-        end=base.add(days=end2),
     )
     assert interval1.is_adjacent(interval2) == expected
-
     # check invalid argument
     with pytest.raises(TypeError):
         interval1.is_adjacent('invalid type')
 
 
-@pytest.mark.parametrize('start,end,delta,include_remainder,expected', [
+@pytest.mark.parametrize(
-    (0, 10, 5, False, [(0, 5), (5, 10)]),
+    'start,end,delta,include_remainder,expected',
-    (0, 10, 5, True, [(0, 5), (5, 10)]),
+    [
-    (0, 10, 3, False, [(0, 3), (3, 6), (6, 9)]),
+        (0, 10, 5, False, [(0, 5), (5, 10)]),
-    (0, 10, 3, True, [(0, 3), (3, 6), (6, 9), (9, 10)]),
+        (0, 10, 5, True, [(0, 5), (5, 10)]),
-    (0, 2, 5, False, []),
+        (0, 10, 3, False, [(0, 3), (3, 6), (6, 9)]),
-    (0, 2, 5, True, [(0, 2)]),
+        (0, 10, 3, True, [(0, 3), (3, 6), (6, 9), (9, 10)]),
-], ids=(
+        (0, 2, 5, False, []),
+        (0, 2, 5, True, [(0, 2)]),
+    ],
+    ids=(
         'even-split',
         'even-split-include-partial',
         'uneven-split-do-not-include-partial',
         'uneven-split-include-partial',
         'delta-larger-than-timepsan-do-not-include-partial',
         'delta-larger-than-timepsan-include-partial',
-))
+    ),
+)
 def test_interval_split(start, end, delta, include_remainder, expected):
     base = maya.now()
     interval = maya.MayaInterval(
-        start=base.add(days=start),
+        start=base.add(days=start), end=base.add(days=end)
-        end=base.add(days=end),
     )
     delta = timedelta(days=delta)
-
     expected_intervals = [
-        maya.MayaInterval(
+        maya.MayaInterval(start=base.add(days=s), end=base.add(days=e))
-            start=base.add(days=s),
+        for s, e in expected
-            end=base.add(days=e),
-        ) for s, e in expected
     ]
-
+    assert expected_intervals == list(
-    assert expected_intervals == list(interval.split(
+        interval.split(delta, include_remainder=include_remainder)
-        delta, include_remainder=include_remainder))
+    )
 
 
 def test_interval_split_non_positive_delta():
     start = maya.now()
     end = start.add(days=1)
     interval = maya.MayaInterval(start=start, end=end)
-
     with pytest.raises(ValueError):
         list(interval.split(timedelta(seconds=0)))
-
     with pytest.raises(ValueError):
         list(interval.split(timedelta(seconds=-10)))
 
 
-@pytest.mark.parametrize('start,end,minutes,timezone,snap_out,expected_start,expected_end', [
+@pytest.mark.parametrize(
-    ((5, 12), (8, 48), 30, None, False, (5, 30), (8, 30)),
+    'start,end,minutes,timezone,snap_out,expected_start,expected_end',
-    ((5, 12), (8, 48), 30, None, True, (5, 0), (9, 0)),
+    [
-    ((5, 15), (9, 0), 15, None, False, (5, 15), (9, 0)),
+        ((5, 12), (8, 48), 30, None, False, (5, 30), (8, 30)),
-    ((5, 15), (9, 0), 15, None, True, (5, 15), (9, 0)),
+        ((5, 12), (8, 48), 30, None, True, (5, 0), (9, 0)),
-    ((6, 50), (9, 15), 60, 'America/New_York', False, (7, 0), (9, 0)),
+        ((5, 15), (9, 0), 15, None, False, (5, 15), (9, 0)),
-    ((6, 50), (9, 15), 60, 'America/New_York', True, (6, 0), (10, 0)),
+        ((5, 15), (9, 0), 15, None, True, (5, 15), (9, 0)),
-    ((6, 20), (6, 50), 60, None, False, (6, 0), (6, 0)),
+        ((6, 50), (9, 15), 60, 'America/New_York', False, (7, 0), (9, 0)),
-    ((6, 20), (6, 50), 60, None, True, (6, 0), (7, 0)),
+        ((6, 50), (9, 15), 60, 'America/New_York', True, (6, 0), (10, 0)),
-    ((6, 20), (6, 50), 60, 'America/Chicago', False, (6, 0), (6, 0)),
+        ((6, 20), (6, 50), 60, None, False, (6, 0), (6, 0)),
-    ((6, 20), (6, 50), 60, 'America/Chicago', True, (6, 0), (7, 0)),
+        ((6, 20), (6, 50), 60, None, True, (6, 0), (7, 0)),
-], ids=(
+        ((6, 20), (6, 50), 60, 'America/Chicago', False, (6, 0), (6, 0)),
+        ((6, 20), (6, 50), 60, 'America/Chicago', True, (6, 0), (7, 0)),
+    ],
+    ids=(
         'normal',
         'normal-snap_out',
         'already-quantized',
@@ -459,21 +417,20 @@ def test_interval_split_non_positive_delta():
         'too-small-snap_out',
         'too-small-with-timezone',
         'too-small-with-timezone-snap_out',
-))
+    ),
-def test_quantize(start, end, minutes, timezone, snap_out, expected_start, expected_end):
+)
+def test_quantize(
+    start, end, minutes, timezone, snap_out, expected_start, expected_end
+):
     base = maya.MayaDT.from_datetime(datetime(2017, 1, 1))
     interval = maya.MayaInterval(
         start=base.add(hours=start[0], minutes=start[1]),
         end=base.add(hours=end[0], minutes=end[1]),
     )
-
     kwargs = {'timezone': timezone} if timezone is not None else {}
     quantized_interval = interval.quantize(
-        timedelta(minutes=minutes),
+        timedelta(minutes=minutes), snap_out=snap_out, **kwargs
-        snap_out=snap_out,
-        **kwargs
     )
-
     assert quantized_interval == maya.MayaInterval(
         start=base.add(hours=expected_start[0], minutes=expected_start[1]),
         end=base.add(hours=expected_end[0], minutes=expected_end[1]),
@@ -484,7 +441,6 @@ def test_quantize_invalid_delta():
     start = maya.now()
     end = start.add(days=1)
     interval = maya.MayaInterval(start=start, end=end)
-
     with pytest.raises(ValueError):
         interval.quantize(timedelta(minutes=0))
     with pytest.raises(ValueError):
@@ -495,12 +451,13 @@ def test_interval_flatten_non_overlapping():
     step = 2
     max_hour = 20
     base = maya.now()
-    intervals = [maya.MayaInterval(
+    intervals = [
-        start=base.add(hours=hour),
+        maya.MayaInterval(
-        duration=timedelta(hours=step - 1),
+            start=base.add(hours=hour), duration=timedelta(hours=step - 1)
-    ) for hour in range(0, max_hour, step)]
+        )
+        for hour in range(0, max_hour, step)
+    ]
     random.shuffle(intervals)
-
     assert maya.MayaInterval.flatten(intervals) == sorted(intervals)
 
 
@@ -508,35 +465,35 @@ def test_interval_flatten_adjacent():
     step = 2
     max_hour = 20
     base = maya.when('jan/1/2011')
-
     intervals = [
         maya.MayaInterval(
-            start=base.add(hours=hour),
+            start=base.add(hours=hour), duration=timedelta(hours=step)
-            duration=timedelta(hours=step),
+        )
-        ) for hour in range(0, max_hour, step)
+        for hour in range(0, max_hour, step)
     ]
     random.shuffle(intervals)
-
+    assert maya.MayaInterval.flatten(intervals) == [
-    assert maya.MayaInterval.flatten(intervals) == [maya.MayaInterval(
+        maya.MayaInterval(start=base, duration=timedelta(hours=max_hour))
-        start=base,
+    ]
-        duration=timedelta(hours=max_hour),
-    )]
 
 
 def test_interval_flatten_intersecting():
     step = 2
     max_hour = 20
     base = maya.now()
-    intervals = [maya.MayaInterval(
+    intervals = [
-        start=base.add(hours=hour),
+        maya.MayaInterval(
-        duration=timedelta(hours=step, minutes=30),
+            start=base.add(hours=hour),
-    ) for hour in range(0, max_hour, step)]
+            duration=timedelta(hours=step, minutes=30),
+        )
+        for hour in range(0, max_hour, step)
+    ]
     random.shuffle(intervals)
-
+    assert maya.MayaInterval.flatten(intervals) == [
-    assert maya.MayaInterval.flatten(intervals) == [maya.MayaInterval(
+        maya.MayaInterval(
-        start=base,
+            start=base, duration=timedelta(hours=max_hour, minutes=30)
-        duration=timedelta(hours=max_hour, minutes=30),
+        )
-    )]
+    ]
 
 
 def test_interval_flatten_containing():
@@ -544,16 +501,16 @@ def test_interval_flatten_containing():
     max_hour = 20
     base = maya.now()
     containing_interval = maya.MayaInterval(
-        start=base,
+        start=base, end=base.add(hours=max_hour + step)
-        end=base.add(hours=max_hour + step),
     )
-    intervals = [maya.MayaInterval(
+    intervals = [
-        start=base.add(hours=hour),
+        maya.MayaInterval(
-        duration=timedelta(hours=step - 1),
+            start=base.add(hours=hour), duration=timedelta(hours=step - 1)
-    ) for hour in range(2, max_hour, step)]
+        )
+        for hour in range(2, max_hour, step)
+    ]
     intervals.append(containing_interval)
     random.shuffle(intervals)
-
     assert maya.MayaInterval.flatten(intervals) == [containing_interval]
 
 
@@ -561,24 +518,55 @@ def test_interval_from_datetime():
     start = maya.now()
     duration = timedelta(hours=1)
     end = start + duration
-
     interval = maya.MayaInterval.from_datetime(
-        start_dt=start.datetime(naive=False),
+        start_dt=start.datetime(naive=False), end_dt=end.datetime(naive=False)
-        end_dt=end.datetime(naive=False),
     )
     assert interval.start == start
     assert interval.end == end
-
     interval2 = maya.MayaInterval.from_datetime(
-        start_dt=start.datetime(naive=False),
+        start_dt=start.datetime(naive=False), duration=duration
-        duration=duration,
     )
     assert interval2.start == start
     assert interval2.end == end
-
     interval3 = maya.MayaInterval.from_datetime(
-        end_dt=end.datetime(naive=False),
+        end_dt=end.datetime(naive=False), duration=duration
-        duration=duration,
     )
     assert interval3.start == start
     assert interval3.end == end
+
+
+def test_interval_iso8601():
+    start = maya.when('11-17-11 08:09:10')
+    interval = maya.MayaInterval(start=start, duration=1)
+    assert interval.iso8601() == '2011-11-17T08:09:10Z/2011-11-17T08:09:11Z'
+
+
+def test_interval_from_iso8601():
+    interval = maya.MayaInterval.from_iso8601(
+        "2018-03-18T14:27:18Z/2018-04-01T04:15:27Z"
+    )
+    s = maya.when("2018-03-18T14:27:18Z")
+    e = maya.when("2018-04-01T04:15:27Z")
+
+    assert interval.start == s
+    assert interval.end == e
+
+
+def test_interval_from_iso8601_duration():
+    interval = maya.MayaInterval.from_iso8601(
+        "2018-03-18T14:27:18Z/P13DT13H48M9S"
+    )
+    s = maya.when("2018-03-18T14:27:18Z")
+    e = maya.when("2018-04-01T04:15:27Z")
+
+    assert interval.start == s
+    assert interval.end == e
+
+    interval = maya.MayaInterval.from_iso8601(
+        "2018-03-05T14:27:18Z/P2W"
+    )
+    s = maya.when("2018-03-05T14:27:18Z")
+    e = maya.when("2018-03-19T14:27:18Z")
+
+    assert interval.start == s
+    assert interval.end == e

tox.ini

@@ -0,0 +1,14 @@
+[tox]
+envlist = py27, py34, py35, py36
+
+[testenv]
+deps = pipenv
+commands=
+    pipenv install --dev --skip-lock
+    pytest tests/ {posargs}
+
+[testenv:py27]
+basepython = python2.7
+deps =
+    {[testenv]deps}
+    funcsigs