rlquantdata 0.1.0__py3-none-any.whl

src/rlquantdata/DateUtilities/Period.py

@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+
+import re
+from math import floor
+
+from src.rlquantdata.DateUtilities.Date_enum import TimeUnits
+from src.rlquantdata.DateUtilities.Asserts import require, ensureRaise
+
+_unitPattern = re.compile('[BbDdMmWwYy]{1}')
+_numberPattern = re.compile('[-+]*[0-9]+')
+
+_unitsDict = {'d': TimeUnits.Days,
+              'b': TimeUnits.BDays,
+              'w': TimeUnits.Weeks,
+              'm': TimeUnits.Months,
+              'y': TimeUnits.Years}
+
+
+class Period(object):
+
+    def __init__(self, reprStr=None, length=0, units=0):
+
+        n: int
+        unitsStr: str
+
+        if reprStr:
+            unitsPos = _unitPattern.search(reprStr)
+            numPos = _numberPattern.search(reprStr)
+            unitsStr = reprStr[unitsPos.start():unitsPos.end()].lower()
+            n = int(reprStr[numPos.start():numPos.end()])
+            self._length = n
+            self._units = _unitsDict[unitsStr]
+        else:
+            self._length = length
+            self._units = units
+
+    def length(self):
+        return self._length
+
+    def units(self):
+        return self._units
+
+    def normalize(self):
+        length = self.length()
+        units = self.units()
+        if length != 0:
+            if units == TimeUnits.BDays or units == TimeUnits.Weeks or units == TimeUnits.Years:
+                return Period(length=length, units=units)
+            elif units == TimeUnits.Months:
+                if length % 12 == 0:
+                    length //= 12
+                    units = TimeUnits.Years
+                return Period(length=length, units=units)
+            elif units == TimeUnits.Days:
+                if length % 7 == 0:
+                    length //= 7
+                    units = TimeUnits.Weeks
+                return Period(length=length, units=units)
+            else:
+                ensureRaise(TypeError, "wrong period units type {0}".format(units))
+
+    def __div__(self, n):
+
+        resunits = self.units()
+        reslength = self.length()
+
+        if reslength % n == 0:
+            reslength /= n
+        else:
+            if resunits == TimeUnits.Years:
+                reslength *= 12
+                resunits = TimeUnits.Months
+            elif resunits == TimeUnits.Weeks:
+                reslength *= 7
+                resunits = TimeUnits.Days
+
+            require(reslength % n == 0, ValueError, "{0} cannot be divided by {1:d}".format(self, n))
+
+            reslength //= n
+
+        return Period(length=reslength, units=resunits)
+
+    # only work for python 3
+    def __truediv__(self, n):
+
+        resunits = self.units()
+        reslength = self.length()
+
+        if reslength % n == 0:
+            reslength /= n
+        else:
+            if resunits == TimeUnits.Years:
+                reslength *= 12
+                resunits = TimeUnits.Months
+            elif resunits == TimeUnits.Weeks:
+                reslength *= 7
+                resunits = TimeUnits.Days
+
+            require(reslength % n == 0, ValueError, "{0} cannot be divided by {1:d}".format(self, n))
+            reslength //= n
+
+        return Period(length=reslength, units=resunits)
+
+    def __add__(self, p2):
+
+        reslength = self.length()
+        resunits = self.units()
+        p2length = p2.length()
+        p2units = p2.units()
+
+        if reslength == 0:
+            return Period(length=p2length, units=p2units)
+        elif resunits == p2units:
+            reslength += p2length
+            return Period(length=reslength, units=resunits)
+        else:
+            if resunits == TimeUnits.Years:
+                if p2units == TimeUnits.Months:
+                    resunits = TimeUnits.Months
+                    reslength = reslength * 12 + p2length
+                elif p2units == TimeUnits.Weeks or p2units == TimeUnits.Days or p2units == TimeUnits.BDays:
+                    require(p2length == 0, ValueError, "impossible addition between {0} and {1}".format(self, p2))
+                else:
+                    raise ValueError("unknown time unit ({0:d})".format(p2units))
+                return Period(length=reslength, units=resunits)
+            elif resunits == TimeUnits.Months:
+                if p2units == TimeUnits.Years:
+                    reslength += 12 * p2length
+                elif p2units == TimeUnits.Weeks or p2units == TimeUnits.Days or p2units == TimeUnits.BDays:
+                    require(p2length == 0, ValueError, "impossible addition between {0} and {1}".format(self, p2))
+                else:
+                    raise ValueError("unknown time unit ({0:d})".format(p2units))
+                return Period(length=reslength, units=resunits)
+            elif resunits == TimeUnits.Weeks:
+                if p2units == TimeUnits.Days:
+                    resunits = TimeUnits.Days
+                    reslength = reslength * 7 + p2length
+                elif p2units == TimeUnits.Years or p2units == TimeUnits.Months or p2units == TimeUnits.BDays:
+                    require(p2length == 0, ValueError, "impossible addition between {0} and {1}".format(self, p2))
+                else:
+                    raise ValueError("unknown time unit ({0:d})".format(p2units))
+                return Period(length=reslength, units=resunits)
+            elif resunits == TimeUnits.Days:
+                if p2units == TimeUnits.Weeks:
+                    reslength += 7 * p2length
+                elif p2units == TimeUnits.Years or p2units == TimeUnits.Months or p2units == TimeUnits.BDays:
+                    require(p2length == 0, ValueError, "impossible addition between {0} and {1}".format(self, p2))
+                else:
+                    raise ValueError("unknown time unit ({0:d})".format(p2units))
+                return Period(length=reslength, units=resunits)
+            elif resunits == TimeUnits.BDays:
+                if p2units == TimeUnits.Years or p2units == TimeUnits.Months or p2units == TimeUnits.Weeks or p2units == TimeUnits.Days:
+                    require(p2length == 0, ValueError, "impossible addition between {0} and {1}".format(self, p2))
+                else:
+                    raise ValueError("unknown time unit ({0:d})".format(p2units))
+                return Period(length=reslength, units=resunits)
+
+    def __neg__(self):
+        return Period(length=-self.length(), units=self.units())
+
+    def __sub__(self, p2):
+        return self + (-p2)
+
+    def __str__(self):
+        out = ""
+        n = self.length()
+        m = 0
+        units = self.units()
+
+        if units == TimeUnits.Days:
+            if n >= 7:
+                m = int(floor(n / 7, ))
+                out = '{0}W'.format(m)
+                n %= 7
+            if n != 0 or m == 0:
+                return '{0}{1}D'.format(out, n)
+            else:
+                return out
+        elif units == TimeUnits.Weeks:
+            return '{0}W'.format(n)
+        elif units == TimeUnits.Months:
+            if n >= 12:
+                m = int(floor(n / 12.))
+                out = '{0}Y'.format(m)
+                n %= 12
+            if n != 0 or m == 0:
+                return '{0}{1}M'.format(out, n)
+            else:
+                return out
+        elif units == TimeUnits.Years:
+            return '{0}Y'.format(n)
+        elif units == TimeUnits.BDays:
+            return '{0}B'.format(n)
+
+    def __deepcopy__(self, memo):
+        return Period(length=self.length(), units=self.units())
+
+    def __reduce__(self):
+        d = {}
+
+        return Period, (None, self.length(), self.units()), d
+
+    def __setstate__(self, state):
+        pass
+
+    def __lt__(self, right):
+        return _lt_cmp(self, right)
+
+    def __eq__(self, right):
+        return not (_lt_cmp(self, right) or _lt_cmp(right, self))
+
+    def __ne__(self, right):
+        return _lt_cmp(self, right) or _lt_cmp(right, self)
+
+    def __gt__(self, right):
+        return _lt_cmp(right, self)
+
+
+def check_period(p):
+    if isinstance(p, Period):
+        return p
+    else:
+        return Period(p)
+
+
+# implementation detail
+
+def _lt_cmp(p1, p2):
+    p1lim: tuple
+    p2lim: tuple
+    p1length = p1.length()
+    p1units = p1.units()
+    p2length = p2.length()
+    p2units = p2.units()
+
+    if p1length == 0:
+        return p2length > 0
+
+    if p2length == 0:
+        return p1length < 0
+
+    # exact comparisons
+    if p1units == p2units:
+        return p1length < p2length
+    elif p1units == TimeUnits.Months and p2units == TimeUnits.Years:
+        return p1length < (p2length * 12)
+    elif p1units == TimeUnits.Years and p2units == TimeUnits.Months:
+        return (p1length * 12) < p2length
+    elif p1units == TimeUnits.Days and p2units == TimeUnits.Weeks:
+        return p1length < (p2length * 7)
+    elif p1units == TimeUnits.Weeks and p2units == TimeUnits.Days:
+        return (p1length * 7) < p2length
+
+    # inexact comparisons (handled by converting to days and using limits)
+
+    p1lim = _daysMinMax(p1)
+    p2lim = _daysMinMax(p2)
+
+    if p1lim[1] < p2lim[0]:
+        return True
+    elif p1lim[0] >= p2lim[1]:
+        return False
+    else:
+        ensureRaise(ValueError, "undecidable comparison between {0} and {1}".format(p1, p2))
+
+
+def _daysMinMax(p):
+    units = p.units()
+    length = p.length()
+
+    if units == TimeUnits.Days:
+        return length, length
+    elif units == TimeUnits.Weeks:
+        return 7 * length, 7 * length
+    elif units == TimeUnits.Months:
+        return 28 * length, 31 * length
+    elif units == TimeUnits.Years:
+        return 365 * length, 366 * length
+    elif units == TimeUnits.BDays:
+        ensureRaise(ValueError, "Business days unit has not min max days")
+
+
+def _lt_cmp(p1, p2):
+    p1lim: tuple
+    p2lim: tuple
+    p1length = p1.length()
+    p1units = p1.units()
+    p2length = p2.length()
+    p2units = p2.units()
+
+    if p1length == 0:
+        return p2length > 0
+
+    if p2length == 0:
+        return p1length < 0
+
+    # exact comparisons
+    if p1units == p2units:
+        return p1length < p2length
+    elif p1units == TimeUnits.Months and p2units == TimeUnits.Years:
+        return p1length < (p2length * 12)
+    elif p1units == TimeUnits.Years and p2units == TimeUnits.Months:
+        return (p1length * 12) < p2length
+    elif p1units == TimeUnits.Days and p2units == TimeUnits.Weeks:
+        return p1length < (p2length * 7)
+    elif p1units == TimeUnits.Weeks and p2units == TimeUnits.Days:
+        return (p1length * 7) < p2length
+
+    # inexact comparisons (handled by converting to days and using limits)
+
+    p1lim = _daysMinMax(p1)
+    p2lim = _daysMinMax(p2)
+
+    if p1lim[1] < p2lim[0]:
+        return True
+    elif p1lim[0] >= p2lim[1]:
+        return False
+    else:
+        ensureRaise(ValueError, "undecidable comparison between {0} and {1}".format(p1, p2))

src/rlquantdata/DateUtilities/Schedule.py

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*-
+
+from src.rlquantdata.DateUtilities.Date_enum import BizDayConventions, DateGeneration, TimeUnits
+from src.rlquantdata.DateUtilities.Date import Date
+from src.rlquantdata.DateUtilities.Period import Period
+from src.rlquantdata.DateUtilities.Calendar import Calendar
+from src.rlquantdata.DateUtilities.Settings import Settings
+from src.rlquantdata.DateUtilities.Asserts import require
+
+
+class Schedule(object):
+
+    def __init__(self,
+                 effectiveDate,
+                 terminationDate,
+                 tenor,
+                 calendar,
+                 convention=BizDayConventions.Following,
+                 terminationConvention=BizDayConventions.Following,
+                 dateGenerationRule=DateGeneration.Forward,
+                 endOfMonth=False,
+                 firstDate=None,
+                 nextToLastDate=None):
+
+        i: int
+        dateLen: int
+        nullCalendar: Calendar
+        evalDate: Date
+        y: int
+        periods: int
+        seed: Date
+        temp: Date
+        exitDate: Date
+
+        # Initialize private data
+        self._effectiveDate = effectiveDate
+        self._terminationDate = terminationDate
+        self._tenor = tenor
+        self._cal = calendar
+        self._convention = convention
+        self._terminationConvention = terminationConvention
+        self._rule = dateGenerationRule
+        self._dates = []
+        self._isRegular = []
+
+        if tenor < Period("1M"):
+            self._endOfMonth = False
+        else:
+            self._endOfMonth = endOfMonth
+
+        if not firstDate or firstDate == effectiveDate:
+            self._firstDate = None
+        else:
+            self._firstDate = firstDate
+
+        if not nextToLastDate or nextToLastDate == terminationDate:
+            self._nextToLastDate = None
+        else:
+            self._nextToLastDate = nextToLastDate
+
+        # in many cases (e.g. non-expired bonds) the effective date is not
+        # really necessary. In these cases a decent placeholder is enough
+        if not effectiveDate and not firstDate and dateGenerationRule == DateGeneration.Backward:
+            evalDate = Settings.evaluationDate
+            require(evalDate < terminationDate, ValueError, "null effective date")
+            if nextToLastDate:
+                y = int((nextToLastDate - evalDate) / 366) + 1
+                effectiveDate = nextToLastDate - Period(length=y, units=TimeUnits.Years)
+            else:
+                y = int((terminationDate - evalDate) / 366) + 1
+                effectiveDate = terminationDate - Period(length=y, units=TimeUnits.Years)
+        else:
+            require(effectiveDate, ValueError, "null effective date")
+
+        require(effectiveDate < terminationDate, ValueError, "effective date ({0}) "
+                                                             "later than or equal to termination date ({1}"
+                .format(effectiveDate, terminationDate))
+
+        if tenor.length() == 0:
+            self._rule = DateGeneration.Zero
+        else:
+            require(tenor.length() > 0, ValueError, "non positive tenor ({0:d}) not allowed".format(tenor.length()))
+
+        if self._firstDate:
+            if self._rule == DateGeneration.Backward or self._rule == DateGeneration.Forward:
+                require(effectiveDate < self._firstDate < terminationDate, ValueError,
+                        "first date ({0}) out of effective-termination date range [{1}, {2})"
+                        .format(self._firstDate, effectiveDate, terminationDate))
+                # we should ensure that the above condition is still
+                # verified after adjustment
+            elif self._rule == DateGeneration.Zero:
+                raise ValueError("first date incompatible with {0:d} date generation rule".format(self._rule))
+            else:
+                raise ValueError("unknown rule ({0:d})".format(self._rule))
+
+        if self._nextToLastDate:
+            if self._rule == DateGeneration.Backward or self._rule == DateGeneration.Forward:
+                require(effectiveDate < self._nextToLastDate < terminationDate, ValueError,
+                        "next to last date ({0}) out of effective-termination date range [{1}, {2})"
+                        .format(self._nextToLastDate, effectiveDate, terminationDate))
+                # we should ensure that the above condition is still
+                # verified after adjustment
+            elif self._rule == DateGeneration.Zero:
+                raise ValueError("next to last date incompatible with {0:d} date generation rule".format(self._rule))
+            else:
+                raise ValueError("unknown rule ({0:d})".format(self._rule))
+
+        # calendar needed for endOfMonth adjustment
+        nullCalendar = Calendar("Null")
+        periods = 1
+
+        if self._rule == DateGeneration.Zero:
+            self._tenor = Period(length=0, units=TimeUnits.Years)
+            self._dates.extend([effectiveDate, terminationDate])
+            self._isRegular.append(True)
+        elif self._rule == DateGeneration.Backward:
+            self._dates.append(terminationDate)
+            seed = terminationDate
+            if self._nextToLastDate:
+                self._dates.insert(0, self._nextToLastDate)
+                temp = nullCalendar.advanceDate(seed,
+                                                Period(length=-periods * self._tenor.length(),
+                                                       units=self._tenor.units()),
+                                                convention, self._endOfMonth)
+                if temp != self._nextToLastDate:
+                    self._isRegular.insert(0, False)
+                else:
+                    self._isRegular.insert(0, True)
+                seed = self._nextToLastDate
+
+            exitDate = effectiveDate
+            if self._firstDate:
+                exitDate = self._firstDate
+
+            while True:
+                temp = nullCalendar.advanceDate(seed,
+                                                Period(length=-periods * self._tenor.length(),
+                                                       units=self._tenor.units()),
+                                                convention, self._endOfMonth)
+                if temp < exitDate:
+                    if self._firstDate and self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate(
+                            self._firstDate, convention):
+                        self._dates.insert(0, self._firstDate)
+                        self._isRegular.insert(0, False)
+                    break
+                else:
+                    # skip dates that would result in duplicates
+                    # after adjustment
+                    if self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate(temp, convention):
+                        self._dates.insert(0, temp)
+                        self._isRegular.insert(0, True)
+                    periods += 1
+
+            if self._cal.adjustDate(self._dates[0], convention) != self._cal.adjustDate(effectiveDate, convention):
+                self._dates.insert(0, effectiveDate)
+                self._isRegular.insert(0, False)
+
+        elif self._rule == DateGeneration.Forward:
+            self._dates.append(effectiveDate)
+
+            seed = self._dates[-1]
+
+            if self._firstDate:
+                self._dates.append(self._firstDate)
+                temp = nullCalendar.advanceDate(seed,
+                                                Period(length=periods * self._tenor.length(),
+                                                       units=self._tenor.units()),
+                                                convention, self._endOfMonth)
+                if temp != self._firstDate:
+                    self._isRegular.append(False)
+                else:
+                    self._isRegular.append(True)
+                seed = self._firstDate
+
+            exitDate = terminationDate
+            if self._nextToLastDate:
+                exitDate = self._nextToLastDate
+
+            while True:
+                temp = nullCalendar.advanceDate(seed,
+                                                Period(length=periods * self._tenor.length(),
+                                                       units=self._tenor.units()),
+                                                convention, self._endOfMonth)
+                if temp > exitDate:
+                    if self._nextToLastDate and self._cal.adjustDate(self._dates[-1],
+                                                                     convention) != self._cal.adjustDate(
+                        self._nextToLastDate, convention):
+                        self._dates.append(self._nextToLastDate)
+                        self._isRegular.append(False)
+                    break
+                else:
+                    # skip dates that would result in duplicates
+                    # after adjustment
+                    if self._cal.adjustDate(self._dates[-1], convention) != self._cal.adjustDate(temp, convention):
+                        self._dates.append(temp)
+                        self._isRegular.append(True)
+                    periods += 1
+
+            if self._cal.adjustDate(self._dates[-1], terminationConvention) != self._cal.adjustDate(terminationDate,
+                                                                                                    terminationConvention):
+                self._dates.append(terminationDate)
+                self._isRegular.append(False)
+        else:
+            raise ValueError("unknown rule ({0:d})".format(self._rule))
+
+        # adjustments
+        if self._endOfMonth and self._cal.isEndOfMonth(seed):
+            # adjust to end of month
+            if convention == BizDayConventions.Unadjusted:
+                for i in range(len(self._dates) - 1):
+                    self._dates[i] = Date.endOfMonth(self._dates[i])
+            else:
+                for i in range(len(self._dates) - 1):
+                    self._dates[i] = self._cal.endOfMonth(self._dates[i])
+
+            if terminationConvention != BizDayConventions.Unadjusted:
+                self._dates[0] = self._cal.endOfMonth(self._dates[0])
+                self._dates[-1] = self._cal.endOfMonth(self._dates[-1])
+            else:
+                if self._rule == DateGeneration.Backward:
+                    self._dates[-1] = Date.endOfMonth(self._dates[-1])
+                else:
+                    self._dates[0] = Date.endOfMonth(self._dates[0])
+        else:
+            for i in range(len(self._dates) - 1):
+                self._dates[i] = self._cal.adjustDate(self._dates[i], convention)
+
+            if terminationConvention != BizDayConventions.Unadjusted:
+                self._dates[-1] = self._cal.adjustDate(self._dates[-1], terminationConvention)
+
+        # Final safety checks to remove extra next-to-last date, if
+        # necessary.  It can happen to be equal or later than the end
+        # date due to EOM adjustments (see the Schedule test suite
+        # for an example).
+
+        dateLen = len(self._dates)
+
+        if dateLen >= 2 and self._dates[dateLen - 2] >= self._dates[-1]:
+            self._isRegular[dateLen - 2] = (self._dates[dateLen - 2] == self._dates[-1])
+            self._dates[dateLen - 2] = self._dates[-1]
+            self._dates.pop()
+            self._isRegular.pop()
+
+        if len(self._dates) >= 2 and self._dates[1] <= self._dates[0]:
+            self._isRegular[1] = (self._dates[1] == self._dates[0])
+            self._dates[1] = self._dates[0]
+            self._dates = self._dates[1:]
+            self._isRegular = self._isRegular[1:]
+
+        require(len(self._dates) >= 1, ValueError, "degenerate single date ({0}) schedule\n"
+                                                   "seed date: {1}\n"
+                                                   "exit date: {2}\n"
+                                                   "effective date: {3}\n"
+                                                   "first date: {4}\n"
+                                                   "next to last date: {5}\n"
+                                                   "termination date: {6}\n"
+                                                   "generation rule: {7}\n"
+                                                   "end of month: {8}\n"
+                .format(self._dates[0],
+                        seed, exitDate,
+                        effectiveDate,
+                        firstDate,
+                        nextToLastDate,
+                        terminationDate,
+                        self._rule, self._endOfMonth))
+
+    def size(self):
+        return len(self._dates)
+
+    def calendar(self):
+        return self._cal
+
+    def tenor(self):
+        return self._tenor
+
+    def endOfMonth(self):
+        return self._endOfMonth
+
+    def isRegular(self, i):
+        return self._isRegular[i - 1]
+
+    def __getitem__(self, item):
+        return self._dates[item]
+
+    def __deepcopy__(self, memo):
+        return Schedule(self._effectiveDate,
+                        self._terminationDate,
+                        self._tenor,
+                        self._cal,
+                        self._convention,
+                        self._terminationConvention,
+                        self._rule,
+                        self._endOfMonth,
+                        self._firstDate,
+                        self._nextToLastDate)
+
+    def __reduce__(self):
+        d = {}
+
+        return Schedule, (self._effectiveDate,
+                          self._terminationDate,
+                          self._tenor,
+                          self._cal,
+                          self._convention,
+                          self._terminationConvention,
+                          self._rule,
+                          self._endOfMonth,
+                          self._firstDate,
+                          self._nextToLastDate), d

src/rlquantdata/DateUtilities/Settings.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+from src.rlquantdata.DateUtilities import Date
+from src.rlquantdata.DateUtilities import require
+
+
+class SettingsFactory(object):
+    def __init__(self):
+        self._evaluationDate = None
+        self._includeToday = None
+
+    @property
+    def evaluationDate(self):
+        if not self._evaluationDate:
+            return Date.todaysDate()
+        return self._evaluationDate
+
+    @evaluationDate.setter
+    def evaluationDate(self, value):
+        require(isinstance(value, Date), ValueError, "{0} is not a valid PyFin date object".format(value))
+        self._evaluationDate = value
+
+    @property
+    def includeTodaysCashFlows(self):
+        return self._includeToday
+
+    @includeTodaysCashFlows.setter
+    def includeTodaysCashFlows(self, value):
+        self._evaluationDate = value
+
+    def resetEvaluationDate(self):
+        self._evaluationDate = None
+
+    def anchorEvaluationDate(self):
+        if self._evaluationDate is None:
+            self._evaluationDate = Date.todaysDate()
+
+
+Settings = SettingsFactory()

src/rlquantdata/DateUtilities/__init__.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+u"""
+Created on 2015-7-9
+
+@author: cheng.li
+"""
+
+from src.rlquantdata.DateUtilities.Asserts import require
+from src.rlquantdata.DateUtilities.Date import Date
+from src.rlquantdata.DateUtilities.Date import check_date
+from src.rlquantdata.DateUtilities.Period import Period
+from src.rlquantdata.DateUtilities.Period import check_period
+from src.rlquantdata.DateUtilities.Schedule import Schedule
+from src import rlquantdata
+import src.rlquantdata.DateUtilities.Date_enum
+
+__all__ = ['require',
+           'Date',
+           'Period',
+           'Schedule',
+           'check_date',
+           'check_period',
+           'DateUtilities',
+           'Date_enum']