def test_constructor(self):
cdate_range(START, END, freq=CDay())
cdate_range(START, periods=20, freq=CDay())
cdate_range(end=START, periods=20, freq=CDay())
msg = 'periods must be a number, got C'
with tm.assert_raises_regex(TypeError, msg):
date_range('2011-1-1', '2012-1-1', 'C')
with tm.assert_raises_regex(TypeError, msg):
cdate_range('2011-1-1', '2012-1-1', 'C')
def test_constructor(self):
bdate_range(START, END, freq=CDay())
bdate_range(START, periods=20, freq=CDay())
bdate_range(end=START, periods=20, freq=CDay())
msg = 'periods must be a number, got C'
with pytest.raises(TypeError, match=msg):
date_range('2011-1-1', '2012-1-1', 'C')
with pytest.raises(TypeError, match=msg):
bdate_range('2011-1-1', '2012-1-1', 'C')
def get_not_workdays(start_date, end_date):
workdays = pd.DatetimeIndex(start=start_date,
end=end_date,
freq=CDay(calendar=cal))
all_days = pd.date_range(start_date, end_date)
days = all_days - workdays
return list(days.strftime('%Y-%m-%d'))
def test_daterange_bug_456(self):
# GH #456
rng1 = cdate_range('12/5/2011', '12/5/2011')
rng2 = cdate_range('12/2/2011', '12/5/2011')
rng2.offset = CDay()
result = rng1.union(rng2)
tm.assertIsInstance(result, DatetimeIndex)
def test_daterange_bug_456(self):
# GH #456
rng1 = bdate_range("12/5/2011", "12/5/2011", freq="C")
rng2 = bdate_range("12/2/2011", "12/5/2011", freq="C")
assert rng2._data.freq == CDay()
result = rng1.union(rng2)
assert isinstance(result, DatetimeIndex)
def test_daterange_bug_456(self):
# GH #456
rng1 = bdate_range("12/5/2011", "12/5/2011", freq="C")
rng2 = bdate_range("12/2/2011", "12/5/2011", freq="C")
rng2._data.freq = CDay() # TODO: shouldn't this already be set?
result = rng1.union(rng2)
assert isinstance(result, DatetimeIndex)
def test_misc(self):
end = datetime(2009, 5, 13)
dr = bdate_range(end=end, periods=20, freq='C')
firstDate = end - 19 * CDay()
assert len(dr) == 20
assert dr[0] == firstDate
assert dr[-1] == end
def test_daterange_bug_456(self):
# GH #456
rng1 = bdate_range('12/5/2011', '12/5/2011', freq='C')
rng2 = bdate_range('12/2/2011', '12/5/2011', freq='C')
rng2.freq = CDay()
result = rng1.union(rng2)
assert isinstance(result, DatetimeIndex)
def get_previous_sweden_business_day_before_today():
sweden = SwedenHolidayCalendar(rules=holidays_sw)
return date_offset_foll(
dt.date.today() - dt.timedelta(days=1),
calendar=CDay(calendar=sweden),
months_offset=0,
adjust=True,
following=False,
)
def test_shift(self):
shifted = self.rng.shift(5)
self.assertEqual(shifted[0], self.rng[5])
self.assertEqual(shifted.offset, self.rng.offset)
shifted = self.rng.shift(-5)
self.assertEqual(shifted[5], self.rng[0])
self.assertEqual(shifted.offset, self.rng.offset)
shifted = self.rng.shift(0)
self.assertEqual(shifted[0], self.rng[0])
self.assertEqual(shifted.offset, self.rng.offset)
with tm.assert_produces_warning(com.PerformanceWarning):
rng = date_range(START, END, freq=BMonthEnd())
shifted = rng.shift(1, freq=CDay())
self.assertEqual(shifted[0], rng[0] + CDay())
def test_shift(self):
shifted = self.rng.shift(5)
assert shifted[0] == self.rng[5]
assert shifted.offset == self.rng.offset
shifted = self.rng.shift(-5)
assert shifted[5] == self.rng[0]
assert shifted.offset == self.rng.offset
shifted = self.rng.shift(0)
assert shifted[0] == self.rng[0]
assert shifted.offset == self.rng.offset
# PerformanceWarning
with warnings.catch_warnings(record=True):
rng = date_range(START, END, freq=BMonthEnd())
shifted = rng.shift(1, freq=CDay())
assert shifted[0] == rng[0] + CDay()
def test_shift(self):
shifted = self.rng.shift(5)
assert shifted[0] == self.rng[5]
assert shifted.freq == self.rng.freq
shifted = self.rng.shift(-5)
assert shifted[5] == self.rng[0]
assert shifted.freq == self.rng.freq
shifted = self.rng.shift(0)
assert shifted[0] == self.rng[0]
assert shifted.freq == self.rng.freq
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", pd.errors.PerformanceWarning)
rng = date_range(START, END, freq=BMonthEnd())
shifted = rng.shift(1, freq=CDay())
assert shifted[0] == rng[0] + CDay()
def process_stress_matrix(str_data):
recent_date = datetime.date.today() - CDay(1, calendar=USTradingCalendar())
stress_period_df = pd.read_csv(StringIO(str_data))
stress_period_df.loc[pd.isnull(stress_period_df['EndDate']), 'EndDate'] = recent_date
for index, row in stress_period_df.iterrows():
if row['Type'] == 'Relative':
if row['Units'] == 'D':
stress_period_df.at[index, 'StartDate'] = recent_date - CDay(row['Offset'], calendar=USTradingCalendar())
elif row['Units'] == 'W':
stress_period_df.at[index, 'StartDate'] = recent_date - relativedelta(weeks=row['Offset'])
elif row['Units'] == 'M':
stress_period_df.at[index, 'StartDate'] = recent_date - relativedelta(months=row['Offset'])
elif row['Units'] == 'Y':
stress_period_df.at[index, 'StartDate'] = recent_date - relativedelta(years=row['Offset'])
stress_period_df.at[index, 'EndDate'] = recent_date
stress_period_df['StartDate'] = pd.to_datetime(stress_period_df['StartDate'])
stress_period_df['EndDate'] = pd.to_datetime(stress_period_df['EndDate'])
stress_period_df = stress_period_df[['Label', 'StartDate', 'EndDate']]
return stress_period_df
def numberOfDay():
now = datetime.datetime.now()
start = datetime.datetime(year=now.year, month=now.month, day=1)
end = start + pd.offsets.Day(now.day)
# Creating a custom calendar
cal = NYSECalendar()
# Getting the holidays (off-days) between two dates
cal.holidays(start=start, end=end)
se = pd.bdate_range(start=start, end=end,
freq=CDay(calendar=cal)).to_series()
# Counting the number of working days in range
num = se.count() - 1
return num
def numOfTradingDaysTotal():
now = datetime.datetime.now()
start = datetime.datetime(year=now.year, month=now.month, day=1)
end = start + pd.offsets.MonthEnd(1)
# Creating a custom calendar
cal = NYSECalendar()
# Getting the holidays (off-days) between two dates
cal.holidays(start=start, end=end)
se = pd.bdate_range(start=start, end=end,
freq=CDay(calendar=cal)).to_series()
# Counting the number of working days by month
num = se.count()
print(num)
return num
def get_totals(self, data):
pos_order_obj = self.env['pos.order']
rng = date_range(datetime.strptime(data['form']['date_start'], DF),
datetime.strptime(data['form']['date_end'], DF),
freq=CDay(weekmask='Mon Tue Wed Thu Fri Sat'))
result = []
totals = {}
total_total = total_bank = total_cash = total_tax = 0
for date in rng:
total = bank = cash = tax = 0
date_start = date + timedelta(hours=10)
date_start_utc = self.get_date_in_utc(date_start)
date_end = date + timedelta(hours=18)
date_end_utc = self.get_date_in_utc(date_end)
pos_order = pos_order_obj.search([
('date_order', '>=', date_start_utc),
('date_order', '<=', date_end_utc),
('session_id.config_id', '=', data['form']['pos_config_id'][0])
])
for order in pos_order:
tax += order.amount_tax
total_tax += order.amount_tax
total += order.amount_total
total_total += order.amount_total
for statement in order.statement_ids:
if statement.journal_id.type == 'cash':
cash += statement.amount
total_cash += statement.amount
elif statement.journal_id.type == 'bank':
bank += statement.amount
total_bank += statement.amount
result.append({
'date': date.strftime(DF),
'cash': cash,
'bank': bank,
'subtotal': total - tax,
'tax': tax,
'total': total,
})
totals['total_total'] = total_total,
totals['total_bank'] = total_bank,
totals['total_cash'] = total_cash,
totals['total_tax'] = total_tax,
totals['total_subtotal'] = total_total - total_tax,
return {
'result': result,
'totals': totals,
}
def test_getitem(self):
smaller = self.rng[:5]
exp = DatetimeIndex(self.rng.view(np.ndarray)[:5])
self.assert_index_equal(smaller, exp)
self.assertEqual(smaller.offset, self.rng.offset)
sliced = self.rng[::5]
self.assertEqual(sliced.offset, CDay() * 5)
fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
self.assertEqual(len(fancy_indexed), 5)
tm.assertIsInstance(fancy_indexed, DatetimeIndex)
self.assertIsNone(fancy_indexed.freq)
# 32-bit vs. 64-bit platforms
self.assertEqual(self.rng[4], self.rng[np.int_(4)])
def test_getitem(self):
smaller = self.rng[:5]
exp = DatetimeIndex(self.rng.view(np.ndarray)[:5])
tm.assert_index_equal(smaller, exp)
assert smaller.offset == self.rng.offset
sliced = self.rng[::5]
assert sliced.offset == CDay() * 5
fancy_indexed = self.rng[[4, 3, 2, 1, 0]]
assert len(fancy_indexed) == 5
assert isinstance(fancy_indexed, DatetimeIndex)
assert fancy_indexed.freq is None
# 32-bit vs. 64-bit platforms
assert self.rng[4] == self.rng[np.int_(4)]
def test_dti_custom_getitem(self):
rng = pd.bdate_range(START, END, freq="C")
smaller = rng[:5]
exp = DatetimeIndex(rng.view(np.ndarray)[:5])
tm.assert_index_equal(smaller, exp)
assert smaller.freq == rng.freq
sliced = rng[::5]
assert sliced.freq == CDay() * 5
fancy_indexed = rng[[4, 3, 2, 1, 0]]
assert len(fancy_indexed) == 5
assert isinstance(fancy_indexed, DatetimeIndex)
assert fancy_indexed.freq is None
# 32-bit vs. 64-bit platforms
assert rng[4] == rng[np.int_(4)]
def test_cumulative_returns(
self, returns, ret_freq, period_len, expected_vals
):
if "CD" in ret_freq:
ret_freq_class = CDay(weekmask="Tue Wed Thu Fri Sun")
ret_freq = ret_freq_class
elif "B" in ret_freq:
ret_freq_class = BDay()
else:
ret_freq_class = Day()
period_len = Timedelta(period_len)
index = date_range("1/1/1999", periods=len(returns), freq=ret_freq)
returns = Series(returns, index=index)
cum_ret = cumulative_returns(returns)
expected = Series(expected_vals, index=cum_ret.index)
assert_series_equal(cum_ret, expected)
def test_cumulative_returns(self, returns, ret_freq, period_len,
expected_vals):
if 'CD' in ret_freq:
ret_freq_class = CDay(weekmask='Tue Wed Thu Fri Sun')
ret_freq = ret_freq_class
elif 'B' in ret_freq:
ret_freq_class = BDay()
else:
ret_freq_class = Day()
period_len = Timedelta(period_len)
index = date_range('1/1/1999', periods=len(returns), freq=ret_freq)
returns = Series(returns, index=index)
returns.index.freq = ret_freq_class
cum_ret = cumulative_returns(returns, period_len)
expected = Series(expected_vals, index=cum_ret.index)
assert_series_equal(cum_ret, expected, check_less_precise=True)
def test_cached_range(self):
DatetimeIndex._cached_range(START, END, offset=CDay())
DatetimeIndex._cached_range(START, periods=20,
offset=CDay())
DatetimeIndex._cached_range(end=START, periods=20,
offset=CDay())
self.assertRaises(Exception, DatetimeIndex._cached_range, START, END)
self.assertRaises(Exception, DatetimeIndex._cached_range, START,
freq=CDay())
self.assertRaises(Exception, DatetimeIndex._cached_range, end=END,
freq=CDay())
self.assertRaises(Exception, DatetimeIndex._cached_range, periods=20,
freq=CDay())
def test_cached_range(self):
DatetimeIndex._cached_range(START, END, freq=CDay())
DatetimeIndex._cached_range(START, periods=20, freq=CDay())
DatetimeIndex._cached_range(end=START, periods=20, freq=CDay())
# with pytest.raises(TypeError):
with tm.assert_raises_regex(TypeError, "freq"):
DatetimeIndex._cached_range(START, END)
# with pytest.raises(TypeError):
with tm.assert_raises_regex(TypeError, "specify period"):
DatetimeIndex._cached_range(START, freq=CDay())
# with pytest.raises(TypeError):
with tm.assert_raises_regex(TypeError, "specify period"):
DatetimeIndex._cached_range(end=END, freq=CDay())
# with pytest.raises(TypeError):
with tm.assert_raises_regex(TypeError, "start or end"):
DatetimeIndex._cached_range(periods=20, freq=CDay())
if mult == 1:
return code
return str(mult) + code
#----------------------------------------------------------------------
# Offset names ("time rules") and related functions
from pandas.tseries.offsets import (Nano, Micro, Milli, Second, Minute, Hour,
Day, BDay, CDay, Week, MonthBegin,
MonthEnd, BMonthBegin, BMonthEnd,
QuarterBegin, QuarterEnd, BQuarterBegin,
BQuarterEnd, YearBegin, YearEnd,
BYearBegin, BYearEnd, _make_offset)
try:
cday = CDay()
except NotImplementedError:
cday = None
#: cache of previously seen offsets
_offset_map = {}
_offset_to_period_map = {
'WEEKDAY': 'D',
'EOM': 'M',
'BM': 'M',
'BQS': 'Q',
'QS': 'Q',
'BQ': 'Q',
'BA': 'A',
'AS': 'A',
def get_workdays(start_date, end_date):
days = pd.DatetimeIndex(start=start_date,
end=end_date,
freq=CDay(calendar=cal))
return list(days.strftime('%Y-%m-%d'))
def test_generate_cday(self):
rng1 = list(generate_range(START, END, offset=CDay()))
rng2 = list(generate_range(START, END, offset='C'))
assert rng1 == rng2
Holiday('Första maj',month=5, day=1),
Holiday('Kristi himmelfärdsdag',month=5, day=30),
Holiday('Sveriges nationaldag',month=6, day=6),
Holiday('Julafton', month=12, day=24),
Holiday('Juldagen', month=12, day=25),
Holiday('Annandag jul',month=12, day=26),
Holiday('Nyårsafton',month=12, day=31),
#fyll in andra röda dagar tex midsommar osv
Holiday('midsommarafton',year=2019,month=6, day=21),
Holiday('midsommardagen',year=2019,month=6, day=22)
]
business = CDay(calendar=HolidayCalendar())
cal=Sweden()
df = pd.DataFrame(index = pd.date_range(Min_date, Max_date, freq='D'))
df['one']=1
df['Date']=df.index
df['DateKey'] = df.groupby(['one'])['one'].apply(lambda x: x.cumsum())
df["DatumNyckel"] = df.Date.dt.strftime('%Y%m%d')
df["YearMonthDay"] = df.Date.dt.strftime('%Y%m%d')
df["YearMonth"] = df.Date.dt.strftime('%Y%m')
df["DayDate"] = df.Date
df['YearCode']= df.Date.dt.strftime('%Y')
df["IsLeapYear"] = df.Date.dt.is_leap_year
day=31,
offset=DateOffset(weekday=MO(-1))),
Holiday('Summer bank holiday',
month=8,
day=31,
offset=DateOffset(weekday=MO(-1))),
Holiday('Christmas Day', month=12, day=25, observance=next_monday),
Holiday('Boxing Day',
month=12,
day=26,
observance=next_monday_or_tuesday)
]
from pandas.tseries.offsets import CDay
business = CDay(calendar=EnglandAndWalesHolidayCalendar())
def remove_duplicates(values):
output = []
seen = set()
for value in values:
# If value has not been encountered yet,
# ... add it to both list and set.
if value not in seen:
output.append(value)
seen.add(value)
return output
def getCubicSplineParameters(data):
def test_generate_cday(self):
rng1 = list(generate_range(START, END, offset=CDay()))
rng2 = list(generate_range(START, END, time_rule='C'))
self.assertEqual(rng1, rng2)
def test_constructor(self):
cdate_range(START, END, freq=CDay())
cdate_range(START, periods=20, freq=CDay())
cdate_range(end=START, periods=20, freq=CDay())
self.assertRaises(ValueError, date_range, '2011-1-1', '2012-1-1', 'C')
self.assertRaises(ValueError, cdate_range, '2011-1-1', '2012-1-1', 'C')
