def Render(request, service_id):
date = JalaliDate.today().__str__().replace('-', '/')
week_start_date = JalaliDate.today() - timedelta(
days=JalaliDate.today().weekday())
weekday_date = week_start_date
this_week_days = []
for i in range(7):
weekday_date.__str__().replace('-', '/')
this_week_days.append(weekday_date.__str__().replace('-', '/'))
weekday_date = weekday_date + timedelta(1)
service = Services.objects.get(id=service_id)
selected_sanses = Sans.objects.filter(
time_table__id=service.timetable.id).order_by('start_time')
sanses = [[], [], [], [], [], [], []]
reserved_sanses = Reserves.objects.filter(date__in=this_week_days)
#print(reserved_sanses)
#reserved_sanses = [e.sans for e in reserved_sanses]
# print(reserved_sanses)
for sans in selected_sanses:
is_reserved = False
for reserved in reserved_sanses:
if (sans.id == reserved.sans.id):
is_reserved = True
sanses[sans.weekday].append(SansContext(sans, is_reserved))
#print(sanses)
return render(request, 'ServicePage.html', {
'service': service,
'days': sanses,
'date': date,
'user': user
})
def Render(request, service_id):
service = Services.objects.get(id=service_id)
timetable = TimeTable.objects.get(pk=service.timetable.id)
date = JalaliDate.today().__str__().replace('-', '/')
week_start_date = JalaliDate.today() - timedelta(
days=JalaliDate.today().weekday())
weekday_date = week_start_date
this_week_days = []
for i in range(7):
weekday_date.__str__().replace('-', '/')
this_week_days.append(weekday_date.__str__().replace('-', '/'))
weekday_date = weekday_date + timedelta(1)
selected_sanses = Sans.objects.filter(
time_table=service.timetable.id).order_by('start_time')
print(len(selected_sanses))
days = [[], [], [], [], [], [], []]
for i in range(7):
for sans in selected_sanses:
if sans.weekday == i:
days[i].append(sans)
return render(
request, 'editServicePage.html', {
'service': service,
'days': days,
'date': date,
'user': user,
'categories': categories
})
def test_percent(self):
"""
Testing:
%% A literal '%' character.
"""
self.assert_parse_and_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %%")
self.assert_parse_and_format(JalaliDate(1375, 1, 31),
"%Y-%m-%d %% %% %%")
def test_ordinal(self):
min_ = JalaliDate.fromordinal(1)
max_ = JalaliDate.fromordinal(JalaliDate.max.toordinal())
self.assertEqual(min_.year, 1)
self.assertEqual(min_.month, 1)
self.assertEqual(min_.day, 1)
self.assertEqual(min_, JalaliDate.min)
self.assertEqual(max_, JalaliDate.max)
def test_ordinal(self):
min = JalaliDate.fromordinal(1)
max = JalaliDate.fromordinal(JalaliDate.max.toordinal())
self.assertEqual(min.year, 1)
self.assertEqual(min.month, 1)
self.assertEqual(min.day, 1)
self.assertEqual(min, JalaliDate.min)
self.assertEqual(max, JalaliDate.max)
def test_ordinal(self):
min_ = JalaliDate.fromordinal(1)
max_ = JalaliDate.fromordinal(JalaliDate.max.toordinal())
self.assertEqual(min_.year, 1)
self.assertEqual(min_.month, 1)
self.assertEqual(min_.day, 1)
self.assertEqual(min_, JalaliDate.min)
self.assertEqual(max_, JalaliDate.max)
def test_sub(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = jdate - timedelta(10)
self.assertEqual(jdate2, JalaliDate(self.leap_year, 12, 13))
jtimedelta = jdate - JalaliDate(self.leap_year - 1, 12, 1)
self.assertEqual(jtimedelta, timedelta(387))
def test_lt_gt_le_ge_ne_eg(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = JalaliDate(self.leap_year, 12, 24)
jdate3 = JalaliDate(self.leap_year, 12, 24)
self.assertTrue(jdate <= jdate2)
self.assertTrue(jdate != jdate2)
self.assertFalse(jdate > jdate2)
self.assertTrue(jdate2 == jdate3)
def test_percent(self):
"""
Testing:
%% A literal '%' character.
"""
self.assert_parse_and_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %%")
self.assert_parse_and_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %% %% %%")
self.assertEqual(JalaliDate(1375, 1, 31).strftime("%Y %%"), "1375 %")
self.assertEqual(JalaliDate.strptime("1375 %", "%Y %%"), JalaliDate(1375, 1, 1))
def __init__(self, year=1, month=1, day=1, hour=0, minute=0, second=0, microsecond=0, tzinfo=None):
if isinstance(year, JalaliDate):
jd = year
year = jd.year
month = jd.month
day = jd.day
JalaliDate.__init__(self, year, month, day)
self._time = time(hour, minute, second, microsecond, tzinfo)
def advanced_search(q_label=None,
q_title=None,
q_text=None,
q_writer=None,
s_date=None,
e_date=None):
query_set = Post.objects.annotate(
full_name=Concat('user__first_name', V(' '), 'user__last_name'))
if s_date:
try:
strt_date = s_date.split('/')
from_date = JalaliDate(int(strt_date[0]), int(strt_date[1]),
int(strt_date[2])).todate()
query_set = query_set.filter(Q(created_at__gte=from_date))
except:
context = 'error'
return context
if e_date:
try:
end_date = e_date.split('/')
to_date = JalaliDate(int(end_date[0]), int(end_date[1]),
int(end_date[2]) + 1).todate()
query_set = query_set.filter(Q(created_at__lte=to_date))
except:
context = 'error'
return context
if q_label:
query_set = query_set.intersection(
Post.objects.annotate(
full_name=Concat('user__first_name', V(' '), 'user__last_name')
).filter(
Q(labelpost__label_name__regex=r'^.*{}.*'.format(q_label))))
if q_text:
query_set = query_set.intersection(
Post.objects.annotate(full_name=Concat('user__first_name', V(
' '), 'user__last_name')).filter(
Q(text__regex=r'^.*{}.*'.format(q_text))))
if q_writer:
query_set = query_set.intersection(
Post.objects.annotate(full_name=Concat('user__first_name', V(
' '), 'user__last_name')).filter(
Q(full_name__regex=r'^.*{}.*'.format(q_writer))))
if q_title:
query_set = query_set.intersection(
Post.objects.annotate(full_name=Concat('user__first_name', V(
' '), 'user__last_name')).filter(
Q(title__regex=r'^.*{}.*'.format(q_title))))
context = {
'posts_advanced_search': query_set.order_by('-created_at'),
}
return context
def validate_date(input_date):
try:
input_date = arabic_to_eng_number(input_date)
date = JalaliDate().strptime(input_date, "%Y%m%d")
if date < JalaliDate().today():
message = TextMessage(ReadyText.time_is_past)
return False, message
date = date.todate()
return date, None
except:
message = TextMessage(ReadyText.wrong_format)
return False, message
def test_locale_date(self):
"""
Testing:
%x Locale’s appropriate date representation.
"""
self.assertEqual(JalaliDate(1361, 6, 15).strftime('%x'), u'دوشنبه ۱۵ شهریور ۱۳۶۱')
self.assertEqual(JalaliDate().strftime('%x'), u'جمعه ۱ فروردین ۱')
self.assertEqual(JalaliDate.strptime(u'جمعه ۱ فروردین ۱', '%x'), JalaliDate.min)
self.assertEqual(JalaliDate(1375, 1, 31).strftime('%x'), u'جمعه ۳۱ فروردین ۱۳۷۵')
self.assertEqual(JalaliDate.strptime(u'جمعه ۳۱ فروردین ۱۳۷۵%', '%x%%'),
JalaliDate(1375, 1, 31))
def get(self, start="", end=""):
if start == "":
start = self.df.index[0]
else:
s_date = start.split("-")
start = JalaliDate(s_date[0], s_date[1], s_date[2]).todate()
if end == "":
end = self.df.index[-1]
else:
e_date = end.split("-")
end = JalaliDate(e_date[0], e_date[1], e_date[2]).todate()
return self.df.loc[start:end].copy()
def test_instantiate(self):
jdate = JalaliDate(1376, 5, 23)
self.assertFalse(jdate is None)
self.assertEqual(JalaliDate(jdate.todate()), jdate)
self.assertEqual(JalaliDate(jdate), jdate)
self.assertEqual(JalaliDate(julian_day=2450674), jdate)
self.assertRaises(ValueError, JalaliDate, MAXYEAR + 1, 5, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 13, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 12, 30)
def test_algorithm(self):
min = date(623, 1, 1)
max_days = 5000
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDate(dt)
# print('Processing day: %s' % jd)
dt2 = jd.todate()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_algorithm(self):
min = date(623, 1, 1)
max_days = 5000
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDate(dt)
# print('Processing day: %s' % jd)
dt2 = jd.todate()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def crawl(self, start_date, end_date, q_xls):
now = start_date
while now <= end_date:
jalaldate = JalaliDate(now)
year = jalaldate.year
month = jalaldate.month
day = jalaldate.day
if jalaldate.weekday() < 5 and not Path(
f'{self.excel_location}/{year}-{month}-{day}.xlsx'
).is_file():
self.fetch(year=year, month=month, day=day)
q_xls.put([f'{year}-{month}-{day}'])
time.sleep(10)
now = now + timedelta(days=1)
def test_operators(self):
invalid_object = dict(a=2)
d1 = JalaliDate(1361, 6, 15)
d2 = JalaliDate(1361, 6, 16)
self.assertRaises(TypeError, d1.__add__, invalid_object)
self.assertRaises(TypeError, d1.__sub__, invalid_object)
self.assertRaises(TypeError, d1.__lt__, invalid_object)
self.assertRaises(TypeError, d1.__gt__, invalid_object)
self.assertRaises(TypeError, d1.__eq__, invalid_object)
self.assertFalse(d1 == 0)
self.assertTrue(d1 == d1.todate())
self.assertTrue(d1 < d2)
self.assertTrue(d1 <= d1.copy())
self.assertFalse(d1 > d2)
self.assertTrue(d1 >= d1.copy())
def group_sms(self, message, mobiles, yourMessageIds):
api = "http://niksms.com/fa/PublicApi/GroupSms"
now = JalaliDate.today()
now_time = timezone.now()
post_data = {
'username':
self.username,
'password':
self.password,
'message':
message,
'numbers':
mobiles,
'senderNumber':
"50004307",
'sendOn':
"{}/{}/{}-{}:{}".format(now.year, now.month, now.day,
now_time.hour, now_time.minute),
'yourMessageIds':
yourMessageIds,
'sendType':
1
}
result = requests.post(api, post_data)
return result
def add_order_admin(s):
world.order_price = []
world.success = []
for s in guess_types(s.hashes):
cur = (datetime.now() + timedelta(days=1))
s['dispatch_date'] = str(JalaliDate(cur.date()))
s['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(s['dispatch_date'])
logger.info(s['dispatch_hour'])
r = requests.post(f"{config.api_uri}/caravan/add_order",
json=s,
headers={
"APIToken": config.admin.api_token,
"USERToken": config.admin.user_token
})
logger.error(r.text)
world.res = r.json()
time.sleep(1)
logger.info("Response: %s", str(world.res).encode('utf-8'))
world.status = r.status_code
world.order_price.append(world.res['order_data']['price'])
logger.info("order price isss %s", world.order_price)
world.success.append(world.res["success_flag"])
logger.info("world order price is : %s", world.order_price)
logger.info("the worldsuccess is : %s", world.res["success_flag"])
def Book(request):
if (request.method == 'POST'):
date = request.POST.get('date', '')
sans_id = request.POST.get('sans_id', '')
description = request.POST.get('description', '')
service = Services.objects.get(
id=request.POST.get('service_id', ''))
day = request.POST.get('day', '')
date_splited = date.split('/')
saturday = JalaliDate(int(date_splited[0]), int(date_splited[1]),
int(date_splited[2]))
targetday = saturday + timedelta(days=int(day))
targetday = targetday.__str__().replace('-', '/')
print(targetday)
sans = Sans.objects.get(pk=sans_id)
check_obj = Reserves.objects.filter(date=targetday,
service_id=service.id,
sans_id=sans_id)
print(check_obj)
if (len(check_obj) == 0):
Reserves.objects.create(user=user,
sans=sans,
date=targetday,
description=description,
service_id=service.id)
mybusiness = Business.objects.filter(id=service.business.id)
history = Reserves.objects.filter(
user_id=user.id).order_by('date')
return render(request, 'AccountPage.html', {
'user': user,
'historys': history,
'mybusiness': mybusiness
})
else:
return ServicePageController.Render(request, service.id)
def add_order(s):
world.list_of_status = []
for s in guess_types(s.hashes):
cur = (datetime.now() + timedelta(days=1))
s['dispatch_date'] = str(JalaliDate(cur.date()))
s['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(s['dispatch_date'])
logger.info(s['dispatch_hour'])
logger.info(" sssssss is : %s", s)
r = requests.post(f"{config.api_uri}/caravan/add_order/",
json=s,
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
world.res = r.json()
logger.info("Response: %s", str(world.res).encode('utf-8'))
world.status = r.status_code
world.track_code = world.res['order_data']['tracking_code']
logger.info("tracking code groups : %s", world.track_code)
logger.info(" s is : %s", s)
world.list_of_status.append(world.res['order_data']['status'])
logger.info("wwwwwwww list of status of orders is %s",
world.list_of_status)
time.sleep(1)
def add_global_template_variables():
return dict(today=JalaliDate.today().strftime('%A %d %B %Y'),
session=session,
base_url=config.get('base_url'),
pictures=DBSession.query(Picture).all(),
categories=DBSession.query(Category).options(
joinedload('subcategory')).all())
def makeMasterTable(all_dfs, all_df_names, chunkSize):
for index, df in enumerate(all_dfs):
year, month, day = all_df_names[index].split("-")
date = JalaliDate(year, month, day).todate()
yearlist = np.full(len(df), year).tolist()
monthlist = np.full(len(df), month).tolist()
daylist = np.full(len(df), day).tolist()
datelist = np.full(len(df), date).tolist()
df["year"] = yearlist
df["month"] = monthlist
df["day"] = daylist
df["date"] = datelist
xl = pd.concat(all_dfs, keys=all_df_names, ignore_index=True)
xl.columns = HEADER_extra
xl = xl.astype({"year": int, "month": int, "day": int})
xl['date'] = pd.to_datetime(xl['date'])
print(xl.dtypes)
xl.sort_values(by=['date'], inplace=True)
xl.reset_index(drop=True, inplace=True)
i = 0
while i*chunkSize < len(xl):
if (i+1)*chunkSize < len(xl):
df_i = xl.iloc[i*chunkSize:(i+1)*chunkSize]
else:
df_i = xl.iloc[i*chunkSize:]
df_i.to_csv('{xcelLocation}master{i}.csv'.format(i=i, xcelLocation=xcelLocation),
header=HEADER_extra, encoding='utf-8', index=False)
i += 1
return xl
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('time',required=True)
args = parser.parse_args()
retSum = {}
n = 1
while n < 11:
mycursor.execute("select * from gostare where id = %s ",(n,))
gostare_data = mycursor.fetchall()
mydb.commit()
query = "select * from gostare_pishraft where gostare_id = %s and malg =1"
values = (n ,)
mycursor.execute(query , values)
gostare_pishrafts = mycursor.fetchall()
df = self.opencsv()
column = df.loc[0:29 , str(gostare_data[0][0])]
ret = {}
i = 0
for gostare_pishraft in gostare_pishrafts:
ret[gostare_pishraft[5]] = {}
d = gostare_pishraft[3].split('-')
time = JalaliDate(d[0], d[1], d[2])
month = int(d[1])
while i < 29:
if month > 12 :
month = 1
d[0] = str(int(d[0])+1)
column[i]= column[i].replace(',', '')
ret[gostare_pishraft[5]][i] = [
float(gostare_pishraft[2])/float(gostare_data[0][2]) * float(column[i]),
str(JalaliDate(d[0], str(month) , d[2]))
]
i +=1
month +=1
i = 0
dataFrame = self.makeDataFrame(ret)
# print (dataFrame)
dataFrame= self.searchInDataframeToTop(dataFrame,args['time']+"-17")
sum = self.sumTheDataframe(dataFrame)
n +=1
# print (sum)
retSum[gostare_data[0][1]] = sum
return retSum
def RenderTimeTable(request):
if request.method == 'POST':
timetable_id = request.POST.get('time_table', '')
service_id = int(request.POST.get('service'))
date = request.POST.get('date', '')
date_splited = date.split('/')
day = JalaliDate(int(date_splited[0]), int(date_splited[1]),
int(date_splited[2]))
week_start_date = day - timedelta(
days=JalaliDate.today().weekday())
weekday_date = week_start_date
this_week_days = []
for i in range(7):
weekday_date.__str__().replace('-', '/')
this_week_days.append(weekday_date.__str__().replace('-', '/'))
weekday_date = weekday_date + timedelta(1)
service = Services.objects.get(id=service_id)
selected_sanses = Sans.objects.filter(
time_table__id=service.timetable.id).order_by('start_time')
sanses = [[], [], [], [], [], [], []]
reserved_sanses = Reserves.objects.filter(date__in=this_week_days)
print(reserved_sanses)
# reserved_sanses = [e.sans for e in reserved_sanses]
# print(reserved_sanses)
for sans in selected_sanses:
is_reserved = False
for reserved in reserved_sanses:
if (sans.id == reserved.sans.id):
is_reserved = True
sanses[sans.weekday].append(SansContext(sans, is_reserved))
print(sanses)
return render(request, 'ServicePage.html', {
'service': service,
'days': sanses,
'date': date,
'user': user
})
selected_sanses = [sans for sans in selected_sanses]
if (JalaliDate.today() <= day):
final = set(selected_sanses).difference(set(reserved))
else:
date = JalaliDate.today().__str__().replace('-', '/')
day = JalaliDate().today()
final = []
return render(
request, 'ServicePage.html', {
'service': service,
'sanses': final,
'day_name': day.weekdayname(),
'date': date,
'user': user
})
def get(self, symbol, start="", end=""):
if start == "":
start = self.df.index[0]
else:
s_date = start.split("-")
start = JalaliDate(s_date[0], s_date[1], s_date[2]).todate()
if end == "":
end = self.df.index[-1]
else:
e_date = end.split("-")
end = JalaliDate(e_date[0], e_date[1], e_date[2]).todate()
tmpdf = self.df.loc[self.df["symbol"] == symbol].copy()
if not self.__is_scaled.get(symbol, False):
logger.debug(f'symbol is not scaled: {symbol}')
tmpdf = adjust_and_log(tmpdf)
self.df.loc[self.df["symbol"] == symbol] = tmpdf
self.__is_scaled[symbol] = True
return tmpdf.loc[start:end]
def test_percent(self):
"""
Testing:
%% A literal '%' character.
"""
self.assert_parse_and_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %%")
self.assert_parse_and_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %% %% %%")
self.assertEqual(JalaliDate(1375, 1, 31).strftime("%Y %%"), "1375 %")
self.assertEqual(JalaliDate.strptime("1375 %", "%Y %%"), JalaliDate(1375, 1, 1))
def clean(self, value, row=None, *args, **kwargs):
for i in value:
date = value.split("-")
value = JalaliDatetime(date[0], date[1], date[2])
now = JalaliDate(value).todate()
value = str(now)
return value
def add_order(_):
cur = (datetime.now() + timedelta(days=1))
world.shamsi_date = str(JalaliDate(cur.date()))
world.shamsi_hour = cur.time().strftime('%H:%M')
logger.info("Shamsi date is: %s", world.shamsi_date)
logger.info("Shamsi hour is: %s", world.shamsi_hour)
logger.info("token is : %s", world.token)
r = requests.post(f"{config.api_uri}/caravan/add_order",
json={
"weight": 5.0,
"price": 150000,
"source_city": "تهران",
"destination_city": "ساری",
"sender_phone": "09965555555",
"receiver_phone": "02144411306",
"source_address": "خیابان اول کوچه دوم",
"destination_address": " میدون دست چپ",
"dispatch_date": str(world.shamsi_date),
"vehicle_type": "joft",
"load_type": "بار صنعتی",
"vehicle_options": "joft:hichkodam",
"dispatch_hour": str(world.shamsi_hour),
"load_value": 10000000,
"description": "بار تست جزییات",
"sender_name": "علی",
"receiver_name": "اصغری",
"payment_type": "sender",
"sender_company": "سانا",
"receiver_company": "سانا گستر",
"package_options": "falleh",
"length": 0.0,
"width": 1.0,
"height": 1.0,
"baarnameh": "yes",
"unload_option": "day",
"sender_mobile_phone": "09022012056",
"announce_type": "mydrivers",
"source_region_id": "22",
"address_id_source": "1069",
"address_id_destination": "1070",
"destination_region_id": "16",
"surplus_costs": "3000.0"
},
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
world.status = r.status_code
print(world.status)
world.res = r.json()
world.status_detail = r.status_code
world.order_code = world.res["order_data"]["tracking_code"]
logger.warn("order code is : %s", world.order_code)
world.dispatch_date_ms = calculate_ms(cur.date(), REFERENCE_DATE_DATE)
def test_week(self):
"""
Testing:
%a Locale’s abbreviated weekday name.
%A Locale’s full weekday name.
%e ASCII Locale’s abbreviated weekday name.
%E ASCII Locale’s full weekday name.
%T ASCII English full weekday name.
%w Weekday as a decimal number [0(Saturday), 6(Friday)].
%W Week number of the year (SATURDAY as the first day of the week) as a decimal number [00, 53].
All days in a new year preceding the first Monday are considered to be in week 0.
%U Week number of the year (Sunday as the first day of the week) as a decimal number [00, 53].
All days in a new year preceding the first Sunday are considered to be in week 0.
"""
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%a'), u'د')
self.assertEqual(d1.strftime('%A'), u'دوشنبه')
self.assertEqual(d1.strftime('%e'), u'D')
self.assertEqual(d1.strftime('%E'), u'Doshanbeh')
self.assertEqual(d1.strftime('%T'), u'Monday')
self.assertEqual(d1.strftime('%w'), u'2')
self.assertEqual(d1.strftime('%W'), u'24')
for i in range(7):
self.assert_parse_and_format(JalaliDate.min + timedelta(i), '%d %w %W %U')
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % c.PERSIAN_WEEKDAY_ABBRS[i], '%Y %m %d %a'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % c.PERSIAN_WEEKDAY_ABBRS_ASCII[i], '%Y %m %d %e'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % c.PERSIAN_WEEKDAY_NAMES[i], '%Y %m %d %A'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % c.PERSIAN_WEEKDAY_NAMES_ASCII[i], '%Y %m %d %E'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % c.ENGLISH_WEEKDAY_NAMES_ASCII[i], '%Y %m %d %T'),
JalaliDate(year=1345, month=10, day=10))
async def j2g(y: int, m: int, d: int, request: Request, iso: bool = False):
arg_check(("y", "m", "d", "iso"), request.query_params.keys())
if y not in range(*j_year_range):
raise HTTPException(status_code=404)
try:
j = JalaliDate(year=y, month=m, day=d)
g = j.todate()
if iso:
return {"g": g.isoformat()}
return {
"g": {
"y": g.year,
"m": g.month,
"d": g.day
},
}
except Exception:
raise HTTPException(status_code=404)
def get_dates(self):
"""Get dates between date_from and date_to"""
if self.date_from and self.date_to:
date_from = JalaliDate(int(self.date_from[:4]),
int(self.date_from[4:6]),
int(self.date_from[6:]))
date_to = JalaliDate(int(self.date_to[:4]), int(self.date_to[4:6]),
int(self.date_to[6:]))
date_counter = date_from
dates = []
while date_counter <= date_to:
dates.append(date_counter)
date_counter += timedelta(days=1)
return dates
else:
# Get yesterday persian date
now = timezone.make_aware(datetime.now(),
timezone.get_default_timezone())
yesterday = JalaliDate(now) - timedelta(days=1)
return [yesterday]
def clean(self):
value = self.data['date']
if len(value) > 0:
j_year = value.split('-')[0]
j_month = value.split('-')[1]
j_day = value.split('-')[2]
self.cleaned_data['date'] = JalaliDate(year=j_year,
month=j_month,
day=j_day).todate()
return self.cleaned_data
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('gostare_id', required=True)
args = parser.parse_args()
mycursor.execute("select * from gostare where id = %s ",
(args['gostare_id'], ))
gostare_data = mycursor.fetchall()
mydb.commit()
query = "select * from gostare_pishraft where gostare_id = %s and malg =1"
values = (args['gostare_id'], )
mycursor.execute(query, values)
gostare_pishrafts = mycursor.fetchall()
df = self.opencsv()
column = df.loc[0:29, str(gostare_data[0][2]) + "%"]
ret = {}
i = 0
for gostare_pishraft in gostare_pishrafts:
ret[gostare_pishraft[5]] = {}
d = gostare_pishraft[3].split('-')
time = JalaliDate(d[0], d[1], d[2])
month = int(d[1])
while i < 29:
if month > 12:
month = 1
d[0] = str(int(d[0]) + 1)
column[i] = column[i].replace(',', '')
ret[gostare_pishraft[5]][i] = [
float(gostare_pishraft[2]) / float(gostare_data[0][2]) *
float(column[i]),
str(JalaliDate(d[0], str(month), d[2]))
]
i += 1
month += 1
i = 0
dataFrame = self.makeDataFrame(ret)
print(dataFrame)
# self.sumTheDataframe(dataFrame)
return json.loads(dataFrame.to_json())
def convert_to_jalali(jalali_date, format='%A %D %B %N'):
"""
gets input from get_date function
:param jalali_date: splits the date to 3 variables y=year,m=month,d=day.
:param format: the way to show date in jalali
:return: persian format of the date
"""
from khayyam import JalaliDate
if check_dependencies():
from khayyam import JalaliDate
y, m, d = jalali_date
return JalaliDate(year=y, month=m, day=d).strftime(format)
def test_strftime(self):
jdate = JalaliDate.strptime(
JalaliDate(self.leap_year, 12, 23).isoformat(), '%Y-%m-%d')
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%Y-%m-%d'), '1361-06-15')
self.assertEqual(d1.strftime(u'اول%Y-%m-%dآخر'), u'اول1361-06-15آخر')
def test_strptime(self):
"""
%Z not working at all
"""
self.assertEqual(JalaliDate.strptime('1361', '%Y'), JalaliDate(1361))
self.assertEqual(JalaliDate.strptime('1361%C', '%Y%C'), JalaliDate(1361))
self.assertEqual(JalaliDate.strptime(u'اریا1361گلگشت', u'اریا%Yگلگشت'), JalaliDate(1361))
current_century = int(JalaliDate.today().year / 100) * 100
self.assertEqual(JalaliDate.strptime('61', '%y'), JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime('61%C', '%y%C'), JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime(u'اریا61گلگشت', u'اریا%yگلگشت'), JalaliDate(current_century+61))
self.assertEqual(JalaliDate.strptime(u'جمعه 01 اردیبهشت 0001', u'%A %d %B %Y'),
JalaliDate(month=2, day=1))
def add_reminder_to_db(reminder):
print(reminder)
reminder_obj = Reminder(reminder.get(Attr.peer_id), reminder.get(Attr.peer_access_hash),
reminder.get(Attr.type), reminder.get(Attr.card_number),
reminder.get(Attr.money_amount),
reminder.get(Attr.text), reminder.get(Attr.file_id),
reminder.get(Attr.file_access_hash),
reminder.get(Attr.file_size))
session.add(reminder_obj)
date = reminder.get(Attr.date)
time = reminder.get(Attr.time)
print(type(date), date)
print(type(time), time)
remind_datetime = datetime.datetime.combine(date, time)
if reminder.get(Attr.periodic_type) != ReadyText.monthly:
time_delta = time_delta_func(reminder.get(Attr.periodic_type))
for i in range(reminder[Attr.iterate_number] + 1):
message = Message(reminder_obj, sending_time=(remind_datetime + time_delta * i))
session.add(message)
else:
time_delta = time_delta_func(reminder.get(Attr.periodic_type))
for i in range(reminder[Attr.iterate_number] + 1):
s_date = remind_datetime + time_delta * i
day = remind_datetime.day
sending_time = None
is_valid_date = False
while is_valid_date is False:
is_valid_date = True
try:
sending_time = JalaliDate(s_date.year, s_date.month, day)
except ValueError:
is_valid_date = False
day -= 1
message = Message(reminder_obj, sending_time=sending_time.todate())
session.add(message)
session.commit()
def test_strftime(self):
jdate = JalaliDate.strptime(JalaliDate(self.leap_year, 12, 23).isoformat(), '%Y-%m-%d')
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
self.assertEqual(jdate.strftime('%a%A%b%B%d%j%m%w%x%y%Y%%%W'), u'پپنجشنبهاساسفند23359125پنجشنبه 23 اسفند 1375751375%51')
def test_month(self):
"""
Testing:
%m Month as a decimal number [01, 12].
%R Month as a decimal number in persian form [۱, ۱۲].
%P Month as a zero padded decimal number in persian form [۰۱, ۱۲].
%b Locale’s abbreviated month name.
%B Locale’s full month name.
%g ASCII Locale’s abbreviated month name.
%G ASCII Locale’s full month name.
"""
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%b'), u'شه')
self.assertEqual(d1.strftime('%B'), u'شهریور')
self.assertEqual(d1.strftime('%m'), u'06')
self.assertEqual(d1.strftime('%g'), u'Sh')
self.assertEqual(d1.strftime('%G'), u'Shahrivar')
self.assertEqual(JalaliDate(1361, 1, 5).strftime('%R'), u'۱')
self.assertEqual(JalaliDate(1361, 11, 5).strftime('%P'), u'۱۱')
self.assertEqual(JalaliDate(1361, 1, 5).strftime('%P'), u'۰۱')
self.assertEqual(JalaliDate.strptime(u'۷', '%R'), JalaliDate(1, 7, 1))
self.assertRaises(ValueError, JalaliDate.strptime, u'۰۷', '%R')
self.assertEqual(JalaliDate.strptime(u'۰۷', '%P'), JalaliDate(1, 7, 1))
self.assertRaises(ValueError, JalaliDate.strptime, u'۷', '%P')
# Test months
for i in range(1, 13):
self.assertEqual(JalaliDate.strptime(str(i), '%m'), JalaliDate(month=i))
self.assertEqual(JalaliDate.strptime('1345 %s' % c.PERSIAN_MONTH_ABBRS[i], '%Y %b'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % c.PERSIAN_MONTH_NAMES[i], '%Y %B'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % c.PERSIAN_MONTH_ABBRS_ASCII[i], '%Y %g'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % c.PERSIAN_MONTH_NAMES_ASCII[i], '%Y %G'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % rtl(str(i), digits=True), '%Y %R'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % rtl('%.2d' % i, digits=True), '%Y %P'),
JalaliDate(year=1345, month=i, day=1))
self.assertRaises(ValueError, JalaliDate.strptime, '13', '%m')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%m')
self.assertRaises(ValueError, JalaliDate.strptime, u'1345 مت', '%Y %b')
self.assertRaises(ValueError, JalaliDate.strptime, u'1345 شتران', '%Y %B')
self.assertRaises(ValueError, JalaliDate.strptime, u'1345 مت', '%Y %g')
self.assertRaises(ValueError, JalaliDate.strptime, u'1345 شتران', '%Y %G')
start_date = JalaliDate()
for i in range(1, 501):
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %m %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %b %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %B %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %g %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %G %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %R %d')
self.assert_parse_and_format(start_date + timedelta(days=i) , '%Y %P %d')
def post_parser(self, ctx, formatter):
from khayyam import JalaliDate
ctx['year'] = int(JalaliDate.today().year / 100) * 100 + ctx['shortyear']
def test_copy(self):
d1 = JalaliDate(1361, 6, 15)
d2 = d1.copy()
self.assertFalse(d1 is d2)
self.assertEqual(d1, d2)
def test_str(self):
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(
d1.__str__(),
d1.isoformat()
)
def test_to_from_date(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = JalaliDate.from_date(jdate.todate())
self.assertEqual(jdate, jdate2)
def test_to_from_julian_day(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = JalaliDate.from_julian_days(jdate.tojulianday())
self.assertEqual(jdate, jdate2)
def check_format(jdate ,fmt):
jdate_str = jdate.strftime(fmt)
d2 = JalaliDate.strptime(jdate_str, fmt)
self.assertEqual(jdate, d2)
def test_strptime(self):
"""
%Z not working at all
"""
def check_format(jdate ,fmt):
jdate_str = jdate.strftime(fmt)
d2 = JalaliDate.strptime(jdate_str, fmt)
self.assertEqual(jdate, d2)
# Test Year
self.assertEqual(JalaliDate.strptime('1361', '%Y'), JalaliDate(1361))
self.assertEqual(JalaliDate.strptime('1361%C', '%Y%C'), JalaliDate(1361))
self.assertEqual(JalaliDate.strptime('اریا1361گلگشت', 'اریا%Yگلگشت'), JalaliDate(1361))
current_century = int(JalaliDate.today().year / 100) * 100
self.assertEqual(JalaliDate.strptime('61', '%y'), JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime('61%C', '%y%C'), JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime('اریا61گلگشت', 'اریا%yگلگشت'), JalaliDate(current_century+61))
# Test months
for i in range(1, 13):
self.assertEqual(JalaliDate.strptime(str(i), '%m'), JalaliDate(month=i))
self.assertEqual(JalaliDate.strptime('1345 %s' % PERSIAN_MONTH_ABBRS[i], '%Y %b'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % PERSIAN_MONTH_NAMES[i], '%Y %B'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % PERSIAN_MONTH_ABBRS_ASCII[i], '%Y %g'),
JalaliDate(year=1345, month=i, day=1))
self.assertEqual(JalaliDate.strptime('1345 %s' % PERSIAN_MONTH_NAMES_ASCII[i], '%Y %G'),
JalaliDate(year=1345, month=i, day=1))
self.assertRaises(ValueError, JalaliDate.strptime, '13', '%m')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%m')
self.assertRaises(ValueError, JalaliDate.strptime, '1345 مت', '%Y %b')
self.assertRaises(ValueError, JalaliDate.strptime, '1345 شتران', '%Y %B')
self.assertRaises(ValueError, JalaliDate.strptime, '1345 مت', '%Y %g')
self.assertRaises(ValueError, JalaliDate.strptime, '1345 شتران', '%Y %G')
# Test Week and Weekdays
for i in range(7):
check_format(JalaliDate.min + timedelta(i), '%d %w %W %U')
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % PERSIAN_WEEKDAY_ABBRS[i], '%Y %m %d %a'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % PERSIAN_WEEKDAY_ABBRS_ASCII[i], '%Y %m %d %e'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % PERSIAN_WEEKDAY_NAMES[i], '%Y %m %d %A'),
JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime('1345 10 10 %s' % PERSIAN_WEEKDAY_NAMES_ASCII[i], '%Y %m %d %E'),
JalaliDate(year=1345, month=10, day=10))
# Test days
for i in range(1, 32):
self.assertEqual(JalaliDate.strptime(str(i), '%d'), JalaliDate(day=i))
self.assertRaises(ValueError, JalaliDate.strptime, '32', '%d')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%d')
# Test day of year
for i in range(1, 366):
self.assertEqual(JalaliDate.strptime(str(i), '%j'), JalaliDate.fromordinal(i))
self.assertRaises(ValueError, JalaliDate.strptime, '366', '%j')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%j')
self.assertEqual(JalaliDate.strptime('1345 5', '%Y %j'),
JalaliDate(year=1345, month=1, day=5))
self.assertEqual(JalaliDate.strptime('1302 123 3 4', '%Y %j %m %d'),
JalaliDate(year=1302, month=4, day=30))
self.assertEqual(JalaliDate.strptime('1302 3 4', '%Y %m %d'),
JalaliDate(year=1302, month=3, day=4))
self.assertEqual(JalaliDate.strptime(u'جمعه 01 اردیبهشت 0001', '%A %d %B %Y'),
JalaliDate(month=2, day=1))
self.assertEqual(JalaliDate.strptime(u'جمعه 01 فروردین 0001', '%x'),
JalaliDate.min)
self.assertEqual(JalaliDate.strptime(u'جمعه 31 فروردین 1375%', '%x%%'),
JalaliDate(1375, 1, 31))
check_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %%")
check_format(JalaliDate(1375, 1, 31), "%Y-%m-%d %% %% %%")
for i in xrange(1, 400):
check_format(JalaliDate.fromordinal(i), "%Y-%m-%d %a%A%b%B%j%w%W%e%E%g%G%x %% %% %%")
d = JalaliDate.today().replace(month=1, day=1)
for i in xrange(1, algorithms.days_in_year(d.year)):
check_format(d + timedelta(i), "%y-%m-%d")
def test_replace(self):
d1 = JalaliDate(1391, 12, 30)
self.assertEqual(d1.replace(year=1395), JalaliDate(1395, 12, 30))
self.assertEqual(d1.replace(month=1), JalaliDate(1391, 1, 30))
self.assertEqual(d1.replace(day=1), JalaliDate(1391, 12, 1))
self.assertRaises(ValueError, d1.replace, year=1392)
def assert_parse_and_format(self, jdate ,fmt, print_=False):
jdate_str = jdate.strftime(fmt)
if print_:
print(jdate_str)
d2 = JalaliDate.strptime(jdate_str, fmt)
self.assertEqual(jdate, d2)
def test_day(self):
"""
Testing:
%d Day of the month as a decimal number [01, 31].
%D Day of the month as a decimal number in persian form [۱, ۳۱].
%K Day of the month as a zero padded decimal number in persian form [۰۱, ۳۱].
%j Day of the year as a zero padded decimal number [001, 366].
%J Day of the year as a decimal number in persian form [۱, ۳۶۶].
%V Day of the year as a zero padded decimal number in persian form [..۱, ۳۶۶].
"""
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%d'), u'15')
self.assertEqual(d1.strftime('%j'), u'170')
self.assertEqual(d1.strftime('%D'), u'۱۵')
self.assertEqual(JalaliDate(1361, 6, 2).strftime('%D'), u'۲')
self.assertEqual(JalaliDate(1361, 6, 2).strftime('%K'), u'۰۲')
self.assertEqual(JalaliDate(1361, 6, 2).strftime('%J'), u'۱۵۷')
self.assertEqual(JalaliDate(1361, 1, 5).strftime('%J'), u'۵')
self.assertEqual(JalaliDate(1361, 1, 25).strftime('%V'), u'۰۲۵')
self.assertEqual(JalaliDate(1361, 1, 5).strftime('%V'), u'۰۰۵')
# Test days
for i in range(1, 32):
self.assertEqual(JalaliDate.strptime(str(i), '%d'), JalaliDate(day=i))
self.assertRaises(ValueError, JalaliDate.strptime, '32', '%d')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%d')
# Test day of year
for i in range(1, 366):
self.assertEqual(JalaliDate.strptime(str(i), '%j'), JalaliDate.fromordinal(i))
self.assertRaises(ValueError, JalaliDate.strptime, '366', '%j')
self.assertRaises(ValueError, JalaliDate.strptime, '0', '%j')
self.assertEqual(JalaliDate.strptime('1345 5', '%Y %j'),
JalaliDate(year=1345, month=1, day=5))
self.assertEqual(JalaliDate.strptime('1302 123 3 4', '%Y %j %m %d'),
JalaliDate(year=1302, month=4, day=30))
self.assertEqual(JalaliDate.strptime('1302 3 4', '%Y %m %d'),
JalaliDate(year=1302, month=3, day=4))
self.assertEqual(JalaliDate.strptime(u'۲', '%D'), JalaliDate(2))
self.assertRaises(ValueError, JalaliDate.strptime, u'۰۲', '%D')
self.assertEqual(JalaliDate.strptime(u'۰۲', '%K'), JalaliDate(1, 1, 2))
self.assertRaises(ValueError, JalaliDate.strptime, u'۲', '%K')
self.assertEqual(JalaliDate.strptime(u'۰۲', '%K'), JalaliDate(1, 1, 2))
self.assertRaises(ValueError, JalaliDate.strptime, u'۲', '%K')
self.assertEqual(JalaliDate.strptime(u'۱۵۷', '%J'), JalaliDate(1, 6, 2))
self.assertEqual(JalaliDate.strptime(u'۷', '%J'), JalaliDate(1, 1, 7))
self.assertRaises(ValueError, JalaliDate.strptime, u'۰۷', '%J')
self.assertRaises(ValueError, JalaliDate.strptime, u'۰۴۷', '%J')
self.assertEqual(JalaliDate.strptime(u'۰۴۷', '%V'), JalaliDate(1, 2, 16))
self.assertEqual(JalaliDate.strptime(u'۰۰۷', '%V'), JalaliDate(1, 1, 7))
self.assertRaises(ValueError, JalaliDate.strptime, u'۷', '%V')
self.assertRaises(ValueError, JalaliDate.strptime, u'۴۷', '%V')
for i in range(1, 400):
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%m-%d")
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%m-%D")
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%m-%K")
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%j")
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%J")
self.assert_parse_and_format(JalaliDate.fromordinal(i), "%Y-%V")
def test_strftime(self):
jdate = JalaliDate.strptime(JalaliDate(self.leap_year, 12, 23).isoformat(), '%Y-%m-%d')
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%Y-%m-%d'), '1361-06-15')
self.assertEqual(d1.strftime(u'اول%Y-%m-%dآخر'), u'اول1361-06-15آخر')
def test_iso_calendar(self):
jdate = JalaliDate(self.leap_year, 12, 23)
self.assertEqual(jdate.isocalendar(), (self.leap_year, 51, 6))
def test_local_format(self):
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(
d1.strftime('%A %D %B %N'),
d1.localdateformat()
)
def test_iso_format(self):
jdate = JalaliDate(self.leap_year, 12, 23)
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
def test_fromtimestamp(self):
self.assertEqual(JalaliDate.fromtimestamp(1471628912.749938), JalaliDate(1395, 5, 29))
def test_strftime(self):
jdate = JalaliDate.strptime(JalaliDate(self.leap_year, 12, 23).isoformat(), '%Y-%m-%d')
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
self.assertEqual(jdate.strftime('%a%A%b%B%d%j%m%w%x%y%Y%%%W'), u'پپنجشنبهاساسفند23359125پنجشنبه 23 اسفند 1375751375%51')
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%a'), u'د')
self.assertEqual(d1.strftime('%A'), u'دوشنبه')
self.assertEqual(d1.strftime('%b'), u'شه')
self.assertEqual(d1.strftime('%B'), u'شهریور')
self.assertEqual(d1.strftime('%d'), u'15')
self.assertEqual(d1.strftime('%j'), u'170')
self.assertEqual(d1.strftime('%m'), u'06')
self.assertEqual(d1.strftime('%w'), u'2')
self.assertEqual(d1.strftime('%W'), u'24')
self.assertEqual(d1.strftime('%x'), u'دوشنبه 15 شهریور 1361')
self.assertEqual(d1.strftime('%y'), u'61')
self.assertEqual(d1.strftime('%Y'), u'1361')
self.assertEqual(d1.strftime('%e'), u'D')
self.assertEqual(d1.strftime('%E'), u'Doshanbeh')
self.assertEqual(d1.strftime('%g'), u'Sh')
self.assertEqual(d1.strftime('%G'), u'Shahrivar')
self.assertEqual(d1.strftime('%%'), u'%')
self.assertEqual(
d1.strftime('%a%A%b%B%d%j%m%w%W%x%y%Y%e%E%g%G%%'),
u'ددوشنبهشهشهریور1517006224دوشنبه 15 شهریور 1361611361DDoshanbehShShahrivar%')
self.assertEqual(d1.strftime('%Y-%m-%d'), '1361-06-15')
self.assertEqual(d1.strftime('اول%Y-%m-%dآخر'), 'اول1361-06-15آخر')
def assert_parse_and_format(self, jdate, fmt):
jdate_str = jdate.strftime(fmt)
d2 = JalaliDate.strptime(jdate_str, fmt)
self.assertEqual(jdate, d2)
def test_year(self):
"""
Testing:
%y Year without century as a zero padded decimal number [00, 99].
%n Year without century as a decimal number in persian form [۱, ۹۹].
%u Year without century as a zero padded decimal number in persian form [۰۱, ۹۹].
%Y Year with century as a decimal number [1-3178].
%N Year with century as a decimal number in persian form [۱-۳۱۷۸].
%O Year with century as a zero padded decimal number in persian form [۰۰۰۱-۳۱۷۸].
"""
self.assertEqual(JalaliDate(1361, 6, 15).strftime('%y'), u'61')
self.assertEqual(JalaliDate(1361, 6, 15).strftime('%Y'), u'1361')
self.assertEqual(JalaliDate(61, 11, 5).strftime('%N'), u'۶۱')
self.assertEqual(JalaliDate(61, 11, 5).strftime('%O'), u'۰۰۶۱')
self.assertEqual(JalaliDate.strptime('94', '%y'), JalaliDate(1394))
self.assertEqual(JalaliDate.strptime('01', '%y'), JalaliDate(1301))
self.assertEqual(JalaliDate.strptime('00', '%y'), JalaliDate(1300))
self.assertEqual(JalaliDate.strptime(u'۹۴', '%n'), JalaliDate(1394))
self.assertEqual(JalaliDate.strptime(u'۱', '%n'), JalaliDate(1301))
self.assertEqual(JalaliDate.strptime(u'۰', '%n'), JalaliDate(1300))
self.assertEqual(JalaliDate.strptime(u'۹۴', '%u'), JalaliDate(1394))
self.assertEqual(JalaliDate.strptime(u'۰۱', '%u'), JalaliDate(1301))
self.assertEqual(JalaliDate.strptime(u'۰۰', '%u'), JalaliDate(1300))
self.assertEqual(JalaliDate.strptime(u'۰۰۴', '%N'), JalaliDate(4, 1, 1))
self.assertEqual(JalaliDate.strptime(u'۰۴', '%N'), JalaliDate(4, 1, 1))
self.assertEqual(JalaliDate.strptime(u'۴', '%N'), JalaliDate(4, 1, 1))
self.assertEqual(JalaliDate.strptime(u'۰۰۴', '%O'), JalaliDate(4, 1, 1))
self.assertEqual(JalaliDate.strptime(u'۰۴', '%O'), JalaliDate(4, 1, 1))
self.assertEqual(JalaliDate.strptime(u'۴', '%O'), JalaliDate(4, 1, 1))
this_century = JalaliDate(int(JalaliDate.today().year/100) * 100)
for i in range(99):
self.assert_parse_and_format(this_century.replace(year=this_century.year+i), '%y')
self.assert_parse_and_format(this_century.replace(year=this_century.year+i), '%n')
self.assert_parse_and_format(this_century.replace(year=this_century.year+i), '%u')
for i in range(1, 1001):
self.assert_parse_and_format(JalaliDate(i), '%Y')
self.assert_parse_and_format(JalaliDate(i), '%N')
self.assert_parse_and_format(JalaliDate(i), '%O')
