def test_dst(self):
naive_time = JalaliDatetime(1390, 12, 29, 1, 1, 1, 1)
dst_aware_time = JalaliDatetime(1390, 12, 29, 1, 1, 1, 1, tzinfo=self.tz)
dst_time = dst_aware_time + timedelta(5)
self.assertIsNotNone(dst_time.dst(), "invalid dst")
self.assertEqual(dst_aware_time.dst(), timedelta(0), "invalid dst")
self.assertIsNone(naive_time.dst(), "invalid dst")
def test_strftime(self):
jdate = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(jdate.isoformat(), '%s-12-23T12:3:45.34567' % self.leap_year)
## "%U%W" not implemented
self.assertEqual(jdate.strftime(u'%a%A%b%B%c%C%d%f%H%I%j%m%M%p%S%w%x%X%y%Y%z%Z%%'), 'پپنجشنبهاساسفندپ 23 اس 75 12:3پنجشنبه 23 اسفند 1375 12:3:45 ب.ظ23345671212359123ب.ظ453پنجشنبه 23 اسفند 1375 12:3:45 ب.ظ12:3:45 ب.ظ751375%')
def test_dst(self):
naive_time = JalaliDatetime(1390, 12, 29, 1, 1, 1, 1)
nodst_time = JalaliDatetime(1390, 12, 29, 1, 1, 1, 1, tzinfo=self.tz)
dst_time = nodst_time + timedelta(5)
self.assert_(dst_time.dst() != None, "invalid dst")
self.assert_(nodst_time.dst() == timedelta(0), "invalid dst")
self.assert_(naive_time.dst() == None, "invalid dst")
def test_to_from_datetime(self):
# Naive
jalali_time1 = JalaliDatetime(self.naive_jdt.todatetime())
self.assertEqual(self.naive_jdt, jalali_time1)
# Aware
jalali_time2 = JalaliDatetime(self.aware_jdt.todatetime())
self.assertEqual(self.aware_jdt, jalali_time2)
def test_sub(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_time2 = jalali_time1 - timedelta(10)
self.assertEqual(jalali_time2, JalaliDatetime(self.leap_year, 12, 13))
difference = jalali_time1 - JalaliDatetime(self.leap_year - 1, 12, 1)
self.assertEqual(difference, timedelta(387))
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23, 4, 2, 10, 7)
self.assertEqual(jalali_time1 - jalali_time1.date(), timedelta(hours=4, minutes=2, seconds=10, microseconds=7))
def test_to_from_datetime(self):
# Naive
jdate1 = JalaliDatetime.from_datetime(self.naive_jdt.to_datetime())
self.assertEqual(self.naive_jdt, jdate1)
# Aware
jdate2 = JalaliDatetime.from_datetime(self.aware_jdt.to_datetime())
self.assertEqual(self.aware_jdt, jdate2)
def test_lt_gt_le_ge_ne_eg(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_time2 = JalaliDatetime(self.leap_year, 12, 24)
jalali_time3 = JalaliDatetime(self.leap_year, 12, 24)
self.assertTrue(jalali_time1 <= jalali_time2)
self.assertTrue(jalali_time1 != jalali_time2)
self.assertFalse(jalali_time1 > jalali_time2)
self.assertTrue(jalali_time2 == jalali_time3)
def test_instantiate(self):
jalali_time = JalaliDatetime(1376, 10, 9, 8, 7, 6, 5)
self.assertFalse(jalali_time is None)
self.assertEqual(JalaliDatetime(jalali_time.todatetime()), jalali_time)
self.assertEqual(JalaliDatetime(jalali_time), jalali_time)
self.assertEqual(JalaliDatetime(jalali_time.date()).date(), jalali_time.date())
self.assertEqual(JalaliDatetime(julian_day=2450674), JalaliDatetime(1376, 5, 23))
def getJalaliDateFromISO(isoDate):
dt = datetime.datetime.strptime(isoDate, '%Y-%m-%dT%H:%M:%S.%fZ')
if translation.get_language() not in ['fa', 'ps']:
return localtime(dt).strftime('%Y-%m-%d %H:%M:%S')
dt = dt.replace(tzinfo=from_zone)
dt = dt.astimezone(to_zone)
jl = JalaliDatetime(dt)
jlStr = jl.strftime('%N/%R/%D %k:%r:%s')
return jlStr
def test_strftime_strptime(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.strftime('%Q'), 'Panjshanbeh 23 Esfand 1375 12:03:45 PM')
self.assertEqual(
d1.strptime('Panjshanbeh 23 Esfand 1375 12:03:45 PM', '%Q'),
d1 - timedelta(microseconds=34567))
self.assertEqual(d1.isoformat(), '%s-12-23T12:03:45.034567' % self.leap_year)
tz_datetime = d1.astimezone(teh_tz)
self.assertEqual(tz_datetime.strftime('%Z'), 'Iran/Tehran')
def test_fromutc(self):
self.assertRaises(
ValueError, self.teh_tz.fromutc,
JalaliDatetime(1390, 12, 29, 1, 1, 1, 1, tzinfo=self.another_tz))
self.assertRaises(ValueError, self.teh_tz.fromutc,
JalaliDatetime(1390, 12, 29, 1, 1, 1, 1))
self.assertEqual(
self.teh_tz.fromutc(
JalaliDatetime(1390, 2, 1, 1, 1, 1, 1, tzinfo=self.teh_tz)),
JalaliDatetime(1390, 2, 1, 5, 31, 1, 1, tzinfo=self.teh_tz))
def getJalaliDate(dt):
if not dt:
return ''
if translation.get_language() not in ['fa', 'ps']:
return localtime(dt).strftime('%Y-%m-%d %H:%M:%S')
dt = dt.replace(tzinfo=from_zone)
dt = dt.astimezone(to_zone)
jl = JalaliDatetime(dt)
jlStr = jl.strftime('%N/%R/%D %k:%r:%s')
return jlStr
def test_ordinal(self):
self.assertEqual(JalaliDatetime.min.toordinal(), 1)
self.assertEqual(JalaliDatetime.max.toordinal(), 1160739)
min_ = JalaliDatetime.fromordinal(JalaliDatetime.min.toordinal())
max_ = JalaliDatetime.fromordinal(JalaliDatetime.max.toordinal())
self.assertEqual(min_.year, 1)
self.assertEqual(min_.month, 1)
self.assertEqual(min_.day, 1)
self.assertEqual(min_, JalaliDatetime.min)
self.assertEqual(max_, JalaliDatetime.max.replace(hour=0, minute=0, second=0, microsecond=0))
def __init__(
self,
year=None,
month=None,
day=None,
hour=None,
minute=None,
second=None,
microsecond=None,
tzinfo=None,
):
if callable(tzinfo):
tzinfo = tzinfo()
if isinstance(year, datetime):
jd = JalaliDatetime(year, tzinfo=tzinfo)
year, month, day = j2d(jd.year, jd.month, jd.day)
hour, minute, second, microsecond = (
jd.hour,
jd.minute,
jd.second,
jd.microsecond,
)
elif isinstance(year, DilamiDatetime):
dd = year
year, month, day, hour, minute, second, microsecond = (
dd.year,
dd.month,
dd.day,
dd.hour,
dd.minute,
dd.second,
dd.microsecond,
)
jdt = JalaliDatetime.now(tzinfo)
dy, dm, dd = j2d(jdt.year, jdt.month, jdt.day)
self.year = year if year else dy
self.month = month if month is not None else dm
self.day = day if day is not None else dd
self.year, self.month, self.day = self._validate(
self.year, self.month, self.day
)
self._hour = hour if hour else jdt.hour
self._minute = minute if minute else jdt.minute
self._second = second if second else jdt.second
self._microsecond = microsecond if microsecond else jdt.microsecond
self._time = time(
self._hour, self._minute, self._second, self._microsecond, tzinfo
)
def test_algorithm(self):
min_date = datetime(1900, 1, 1, 1, 1, 1)
max_days = 5000 # 3000 years !
days = 0
while True:
dt = min_date + timedelta(days=days)
jd = JalaliDatetime(dt)
# print('Processing day: %s' % jd.year)
dt2 = jd.todatetime()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_algorithm(self):
min_date = datetime(1900, 1, 1, 1, 1, 1)
max_days = 5000 # 3000 years !
days = 0
while True:
dt = min_date + timedelta(days=days)
jd = JalaliDatetime(dt)
# print('Processing day: %s' % jd.year)
dt2 = jd.todatetime()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def data_models_updater(self, thread_name, models):
while True:
try:
logger.debug(f"updating data model {thread_name}")
for x in models:
x.update_data()
x.store_in_pystore()
x.save_to_csvs()
time.sleep(5)
if JalaliDatetime.now().hour < 16:
time.sleep((16 - JalaliDatetime.now().hour) * 3600 + 100)
else:
time.sleep((40 - JalaliDatetime.now().hour) * 3600 + 100)
except:
logger.exception("WTF in data_model_updater")
def test_operators(self):
invalid_object = dict(a=2)
d1 = JalaliDatetime(1361, 6, 15, 10, 1)
d2 = JalaliDatetime(1361, 6, 15, 10, 2)
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.todatetime())
self.assertTrue(d1 < d2)
self.assertTrue(d1 <= d1.copy())
self.assertFalse(d1 > d2)
self.assertTrue(d1 >= d1.copy())
def test_dilami_date():
gdate = datetime(2018, 2, 1)
ddate = DilamiDatetime(gdate, tzinfo=TehranTimezone)
assert ddate.year == 1591
assert ddate.month == 6
assert ddate.day == 28
ddate = DilamiDatetime(1591, 6, 28, tzinfo=TehranTimezone)
assert ddate
ddate = DilamiDatetime(1592, 5, 1, tzinfo=TehranTimezone)
dilami_date = DilamiDatetime(ddate)
assert dilami_date
# Check Dilami date return today
ddate = DilamiDatetime().now()
jy, jm, jd = dilami_to_jalali(ddate.year, ddate.month, ddate.day)
today = JalaliDatetime.now(TehranTimezone())
assert today.year == jy
assert today.month == jm
assert today.day == jd
with freeze_time(datetime.now()):
dilami_now = DilamiDatetime(datetime.now()).to_datetime()
assert dilami_now.time() == datetime.now().time()
now = datetime.now()
dilami_date = DilamiDatetime(now)
assert dilami_date.to_date() == now.date()
def test_minute(self):
"""
Testing:
%M Minute as a decimal number [00, 59].
%r Minute as a zero padded decimal number in persian form [۰۰, ۵۹].
%v Minute as a decimal number in persian form [۰, ۵۹].
"""
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6).strftime('%M'), u'06')
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6).strftime('%r'), u'۰۶')
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6).strftime('%v'), u'۶')
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in range(1000):
d_test = d2 + timedelta(minutes=i)
self.assert_parse_and_format(d_test, '%Y-%m-%d %H:%M:%S')
self.assert_parse_and_format(d_test, '%N-%R-%D %H:%r:%s')
self.assert_parse_and_format(d_test, '%N-%R-%D %H:%v:%L')
def handle_month(number):
month_center = 4
to_month = int(number) - month_center
time = JalaliDatetime(1396, 12, 17)
time = add_months(time , to_month)
time = [str(time.year) , str(time.month) , '17']
return time[0]+'-'+time[1]+'-'+time[2]
def test_microseconds(self):
"""
Testing:
%f Microsecond as a decimal number [0, 999999], zero-padded on the left
%F Microsecond as a decimal number in persian from[۰۰۰۰۰۰, ۹۹۹۹۹۹], zero-padded on the left
"""
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assert_parse_and_format(d1, '%Y-%m-%d %H:%M:%S.%f')
self.assert_parse_and_format(d1, '%Y-%m-%d %H:%M:%S.%F')
self.assert_parse_and_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %p %I:%M:%S.%f')
self.assert_parse_and_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %p %I:%M:%S.%F')
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in range(0, 100000000, 100000):
d_test = d2 + timedelta(microseconds=i)
self.assert_parse_and_format(d_test, '%Y-%m-%d %H:%M:%S.%f')
self.assert_parse_and_format(d_test, '%Y-%m-%d %H:%M:%S.%F')
def test_second(self):
"""
Testing:
%S Second as a decimal number [00, 59].
%s Second as a zero padded decimal number in persian form [۰۰, ۵۹].
%L Second as a decimal number in persian form [۰, ۵۹].
"""
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6, 5).strftime('%S'), u'05')
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6, 5).strftime('%s'), u'۰۵')
self.assertEqual(JalaliDatetime(1386, 12, 23, 4, 6, 5).strftime('%L'), u'۵')
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in range(1000):
d_test = d2 + timedelta(seconds=i)
self.assert_parse_and_format(d_test, '%Y-%m-%d %H:%M:%S')
self.assert_parse_and_format(d_test, '%N-%R-%D %H:%r:%s')
self.assert_parse_and_format(d_test, '%N-%R-%D %H:%r:%L')
def check_format(jdate ,fmt):
jdate_str = jdate.strftime(fmt)
parsed_dt = JalaliDatetime.strptime(jdate_str, fmt)
if jdate != parsed_dt:
print(repr(jdate))
print(jdate_str)
print(repr(parsed_dt))
self.assertEqual(jdate, parsed_dt)
def read_single_post(self, post_url):
post = {}
post["id"] = post_url[post_url.rfind("/") + 1:post_url.rfind(".")]
fp = urllib.request.urlopen(post_url)
my_bytes = fp.read()
page = my_bytes.decode("utf8")
fp.close()
soup = BeautifulSoup(page, 'html.parser')
post["title"] = soup.select("#content h2 a")[0]
abstract = soup.select("#content .box-note")[0]
source_date = soup.select("#content .published")[0].getText().replace('تاریخ انتشار : ', "") \
.replace('\n', "") \
.replace('\t', "")
shamsi_date = JalaliDatetime.strptime(source_date,
'%A, %d %B %Y %H:%M')
shamsi_datexx = JalaliDatetime(shamsi_date.year, shamsi_date.month,
shamsi_date.day, shamsi_date.hour,
shamsi_date.minute, shamsi_date.second,
0, TehranTimezone())
source_date_utc = shamsi_datexx.todatetime().astimezone(
pytz.timezone('UTC'))
# localtime_shamsi_date = local.localize(source_date_local, is_dst=None)
image_src = soup.select("#content p.imgarticle img")[0]["src"]
post["source_media_url"] = "http://beytoote.com/" + image_src
main_image_file_name = post["source_media_url"][
post["source_media_url"].rfind("/") + 1:]
post["media_type"] = 2
all_paragraphs = soup.select("#content p")
post["body"] = ""
for p in all_paragraphs:
paragraph_text = p.getText().strip()
if len(paragraph_text) > 0:
post["body"] = post["body"] + paragraph_text + "\n"
# print(paragraph_text)
post["date"] = source_date_utc
return post
def crawling_thread(self, thread_name, start_date, q_xls):
while True:
if start_date < date.today():
end_date_jalali = JalaliDate.today()
if JalaliDatetime.now().hour < 14:
end_date_jalali = end_date_jalali - timedelta(days=1)
self.crawl(start_date, end_date_jalali.todate(), q_xls)
start_date = end_date_jalali.todate()
with open(f'{self.excel_location}/crawlstat', 'w') as statfile:
lastcheck = JalaliDatetime.now()
print("last check:", file=statfile)
print(lastcheck, file=statfile)
print("last crawl:", file=statfile)
print(end_date_jalali, file=statfile)
if JalaliDatetime.now().hour < 16:
time.sleep((16 - JalaliDatetime.now().hour) * 3600 + 100)
else:
time.sleep((40 - JalaliDatetime.now().hour) * 3600 + 100)
def send_notification(msg):
"""
send message and jalalidate time
:param msg: body of sms
:return: none
"""
now = JalaliDatetime(datetime.now()).strftime('%y-%B-%d %A %H:%M')
msg += now
send_sms(msg)
def __init__(self, payment_type, price, is_paid=False):
self.uuid = uuid.uuid4()
self.payment_type = payment_type
self.is_paid = is_paid
self.datetime = datetime.now()
self.price = price
self.jalali_datetime = JalaliDatetime.now()
self.payment_list.append(self)
super().__init__()
def test_sub(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_time2 = jalali_time1 - timedelta(10)
self.assertEqual(jalali_time2, JalaliDatetime(self.leap_year, 12, 13))
difference = jalali_time1 - JalaliDatetime(self.leap_year - 1, 12, 1)
self.assertEqual(difference, timedelta(387))
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23, 4, 2, 10, 7)
self.assertEqual(jalali_time1 - jalali_time1.date(), timedelta(hours=4, minutes=2, seconds=10, microseconds=7))
def __init__(self, item_dict, in_out, payment_type='cash', table=None):
self.uuid = uuid.uuid4()
self.item_dict = item_dict
self.in_out = in_out
self.bill = self.set_bill(payment_type)
self.table = table
self.datetime = datetime.now()
self.jalali_datetime = JalaliDatetime.now()
self.order_list.append(self)
super().__init__()
def test_properties(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.year, self.leap_year)
self.assertEqual(d1.month, 12)
self.assertEqual(d1.day, 23)
self.assertEqual(d1.hour, 12)
self.assertEqual(d1.minute, 3)
self.assertEqual(d1.second, 45)
self.assertEqual(d1.microsecond, 34567)
self.assertEqual(d1.ampm(), u'ب.ظ')
d1.year = 1361
d1.month = 6
d1.day = 15
self.assertRaises(AttributeError, setattr, d1, 'hour', 16)
self.assertRaises(AttributeError, setattr, d1, 'minute', 16)
self.assertRaises(AttributeError, setattr, d1, 'second', 16)
self.assertRaises(AttributeError, setattr, d1, 'microsecond', 16)
self.assertRaises(AttributeError, setattr, d1, 'tzinfo', teh_tz)
def assert_parse_and_format(self, jdate, fmt, print_=False):
jalali_date_str = jdate.strftime(fmt)
parsed_dt = JalaliDatetime.strptime(jalali_date_str, fmt)
if print_:
print(jalali_date_str)
if jdate != parsed_dt:
print(repr(jdate))
print(jalali_date_str)
print(repr(parsed_dt))
self.assertEqual(jdate, parsed_dt)
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 test_am_pm(self):
"""
Testing:
%p Locale’s equivalent of either AM or PM in persian format [ق.ظ, ب.ظ].
%t Locale’s equivalent of either AM or PM in ASCII format.
"""
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assert_parse_and_format(d1, '%Y-%m-%d %p %I:%M:%S.%f')
self.assert_parse_and_format(d1, '%Y-%m-%d %t %I:%M:%S.%F')
self.assert_parse_and_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %p %I:%M:%S.%F')
self.assert_parse_and_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %t %I:%M:%S.%F')
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in range(500):
d_test = d2 + timedelta(hours=i)
self.assert_parse_and_format(d_test, '%Y-%m-%d %p %I:%M:%S')
self.assert_parse_and_format(d_test, '%N-%R-%D %p %i:%r:%s')
self.assert_parse_and_format(d_test, '%Y-%m-%d %t %I:%M:%S')
self.assert_parse_and_format(d_test, '%N-%R-%D %t %i:%r:%s')
def __init__(self, name, item_type, price):
self.uuid = uuid.uuid1()
self.name = name
self.item_type = item_type
self.type_handler(self, item_type)
self.price = price
self.datetime = datetime.now()
self.jalali_datetime = JalaliDatetime.now()
self.item_id = self.id_generator()
self.item_list.append(self)
super().__init__()
def jd_create_chat(self):
jd_datetime = JalaliDatetime(
datetime(
year=self.create_chat_datetime.year,
month=self.create_chat_datetime.month,
day=self.create_chat_datetime.day,
hour=self.create_chat_datetime.hour,
minute=self.create_chat_datetime.minute,
second=self.create_chat_datetime.second,
))
year = jd_datetime.year
month = jd_datetime.month
day = jd_datetime.day
hour = jd_datetime.hour
minute = jd_datetime.minute
second = jd_datetime.second
# print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^', '\n',
# JalaliDatetime(year, month, day, hour, minute, second).strftime(' %A %d %B %Y'))
return JalaliDatetime(year, month, day, hour, minute,
second).strftime(" %A %d %B %Y- ساعت %H:%M:%S")
def test_locale_date_time(self):
"""
Testing:
%c Locale’s appropriate short date and time representation.
%C Locale’s appropriate date and time representation.
%q ASCII Locale’s appropriate short date and time representation.
%Q ASCII Locale’s appropriate date and time representation.
%X Locale’s appropriate time representation.
"""
self.assertEqual(
JalaliDatetime(1361, 6, 15).strftime('%c'), u'د ۱۵ شه ۶۱ ۰:۰')
self.assertEqual(
JalaliDatetime(1361, 6, 15, 19, 34, 2).strftime('%C'),
u'دوشنبه ۱۵ شهریور ۱۳۶۱ ۰۷:۳۴:۰۲ ب.ظ')
self.assertEqual(
JalaliDatetime(1361, 6, 15, 19, 34, 2).strftime('%q'),
u'D 15 Sh 61 19:34')
self.assertEqual(
JalaliDatetime(1361, 6, 15, 19, 34, 2).strftime('%Q'),
u'Doshanbeh 15 Shahrivar 1361 07:34:02 PM')
self.assertEqual(
JalaliDatetime(1361, 6, 15, 19, 34, 2).strftime('%X'),
u'۰۷:۳۴:۰۲ ب.ظ')
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in range(1000):
d_test = d2 + timedelta(minutes=i)
self.assert_parse_and_format(d_test, '%c')
self.assert_parse_and_format(d_test, '%C')
self.assert_parse_and_format(d_test, '%q')
self.assert_parse_and_format(d_test, '%Q')
self.assert_parse_and_format(d_test, '%Y-%m-%d %X')
def _to_jalali(self):
jy, jm, jd = d2j(self.year, self.month, self.day)
jalali_datetime = JalaliDatetime(
jy,
jm,
jd,
self.hour,
self.minute,
self.second,
self.microsecond,
tzinfo=self._time.tzinfo,
)
return jalali_datetime
def test_strftime_strptime(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.strftime('%Q'), 'Panjshanbeh 23 Esfand 1375 12:03:45 PM')
self.assertEqual(
d1.strptime('Panjshanbeh 23 Esfand 1375 12:03:45 PM', '%Q'),
d1 - timedelta(microseconds=34567))
self.assertEqual(d1.isoformat(), '%s-12-23T12:03:45.034567' % self.leap_year)
tz_datetime = d1.astimezone(teh_tz)
self.assertEqual(tz_datetime.strftime('%Z'), 'Iran/Tehran')
def send_mail(timestamps, rates):
"""
contain subject and body of the email and will send it
:param timestamps: time of rates
:param rates: rates
:return: none
"""
now = JalaliDatetime(datetime.now()).strftime('%y-%B-%d %A %H:%M')
subject = f'{timestamps} - {now} rates'
if rules['email']['preferred'] is not None:
tmp = {}
for exc in rules['email']['preferred']:
tmp[exc] = rates[exc]
rates = tmp
text = json.dumps(rates)
send_smtp_email(subject, text)
def test_fromtimestamp(self):
ts = 1471628912.749938
self.assertEqual(
JalaliDatetime.fromtimestamp(ts),
JalaliDatetime.combine(JalaliDatetime(1395, 5, 29), datetime.fromtimestamp(ts).time())
)
self.assertEqual(
JalaliDatetime.utcfromtimestamp(ts),
JalaliDatetime.combine(JalaliDatetime(1395, 5, 29), datetime.utcfromtimestamp(ts).time())
)
def setUp(self):
self.leap_year = 1375
self.naive_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3)
self.aware_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3, TehTz())
class TestJalaliDateTime(unittest.TestCase):
def setUp(self):
self.leap_year = 1375
self.naive_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3)
self.aware_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3, TehTz())
def test_to_from_datetime(self):
# Naive
jdate1 = JalaliDatetime.from_datetime(self.naive_jdt.to_datetime())
self.assertEqual(self.naive_jdt, jdate1)
# Aware
jdate2 = JalaliDatetime.from_datetime(self.aware_jdt.to_datetime())
self.assertEqual(self.aware_jdt, jdate2)
def test_today(self):
dt = datetime.now().date()
jdt = JalaliDatetime.today().date()
self.assertEqual(jdt, JalaliDate.from_date(dt))
def test_now(self):
self.assertTrue(JalaliDatetime.now() != None)
def test_utcnow(self):
jutcnow = JalaliDatetime.utcnow()
utcnow = jutcnow.to_datetime()
self.assertEqual(jutcnow.time(), utcnow.time())
def test_strftime(self):
jdate = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(jdate.isoformat(), '%s-12-23T12:3:45.34567' % self.leap_year)
self.assertEqual(jdate.strftime(u'%a%A%b%B%c%C%d%f%H%I%j%m%M%p%S%w%x%X%y%Y%z%Z%%%W'), u'پپنجشنبهاساسفندپ 23 اس 75 12:3پنجشنبه 23 اسفند 1375 12:3:45 ب.ظ23345671212359123ب.ظ455پنجشنبه 23 اسفند 1375 12:3:45 ب.ظ12:3:45 ب.ظ751375%51')
def test_algorithm(self):
min = datetime(1900, 1, 1, 1, 1, 1)
max_days = 5000 # 3000 years !
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDatetime.from_datetime(dt)
print('Processing day: %s' % jd.year)
dt2 = jd.to_datetime()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break;
# def test_timetuple(self):
# jdate = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567, teh_tz)
# self.assertEqual(jdate.timetuple().__repr__(), 'time.struct_time(tm_year=1375, tm_mon=12, tm_mday=23, tm_hour=12, tm_min=3, tm_sec=45, tm_wday=3, tm_yday=359, tm_isdst=2)')
# self.assertEqual(jdate.utctimetuple().__repr__(), 'time.struct_time(tm_year=1375, tm_mon=12, tm_mday=23, tm_hour=8, tm_min=33, tm_sec=45, tm_wday=3, tm_yday=359, tm_isdst=0)')
def test_iso_format(self):
jdate = JalaliDate(self.leap_year, 12, 23)
self.assertEqual(jdate.isoformat(), '%s-12-23' % self.leap_year)
def test_add(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = jdate + timedelta(10)
self.assertEqual(jdate2, JalaliDate(self.leap_year + 1, 1, 3))
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_replace(self):
self.assertRaises(ValueError, self.naive_jdt.replace,
self.leap_year + 1)
def localize_datetime(dt, language_code=None):
if language_code == 'fa':
jdt = JalaliDatetime(dt)
return jdt.strftime('%C')
else:
return dt
def test_now(self):
self.assertTrue(JalaliDatetime.now() != None)
class TestJalaliDateTime(unittest.TestCase):
def setUp(self):
self.leap_year = 1375
self.naive_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3)
self.aware_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3, TehranTimezone())
def test_instantiate(self):
jalali_time = JalaliDatetime(1376, 10, 9, 8, 7, 6, 5)
self.assertFalse(jalali_time is None)
self.assertEqual(JalaliDatetime(jalali_time.todatetime()), jalali_time)
self.assertEqual(JalaliDatetime(jalali_time), jalali_time)
self.assertEqual(JalaliDatetime(jalali_time.date()).date(), jalali_time.date())
self.assertEqual(JalaliDatetime(julian_day=2450674), JalaliDatetime(1376, 5, 23))
def test_to_from_datetime(self):
# Naive
jalali_time1 = JalaliDatetime(self.naive_jdt.todatetime())
self.assertEqual(self.naive_jdt, jalali_time1)
# Aware
jalali_time2 = JalaliDatetime(self.aware_jdt.todatetime())
self.assertEqual(self.aware_jdt, jalali_time2)
def test_today(self):
dt = datetime.now().date()
jdt = JalaliDatetime.today().date()
self.assertEqual(jdt, JalaliDate(dt))
def test_now(self):
self.assertIsNotNone(JalaliDatetime.now())
self.assertIsNone(JalaliDatetime.now().tzinfo)
self.assertIsNotNone(JalaliDatetime.now(TehranTimezone()).tzinfo)
def test_utcnow(self):
jalali_utcnow = JalaliDatetime.utcnow()
datetime_utcnow = jalali_utcnow.todatetime()
self.assertEqual(jalali_utcnow.time(), datetime_utcnow.time())
def test_strftime_strptime(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.strftime('%Q'), 'Panjshanbeh 23 Esfand 1375 12:03:45 PM')
self.assertEqual(
d1.strptime('Panjshanbeh 23 Esfand 1375 12:03:45 PM', '%Q'),
d1 - timedelta(microseconds=34567))
self.assertEqual(d1.isoformat(), '%s-12-23T12:03:45.034567' % self.leap_year)
tz_datetime = d1.astimezone(teh_tz)
self.assertEqual(tz_datetime.strftime('%Z'), 'Iran/Tehran')
def test_iso_format(self):
jalali_time = JalaliDatetime(self.leap_year, 12, 23)
self.assertEqual(jalali_time.isoformat(), '%s-12-23T00:00:00.000000' % self.leap_year)
jalali_time = JalaliDatetime(self.leap_year, 12, 23, tzinfo=teh_tz)
self.assertEqual(jalali_time.isoformat(), '%s-12-23T00:00:00.000000+03:30' % self.leap_year)
def test_algorithm(self):
min_date = datetime(1900, 1, 1, 1, 1, 1)
max_days = 5000 # 3000 years !
days = 0
while True:
dt = min_date + timedelta(days=days)
jd = JalaliDatetime(dt)
# print('Processing day: %s' % jd.year)
dt2 = jd.todatetime()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_add(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_tme2 = jalali_time1 + timedelta(10)
self.assertEqual(jalali_tme2, JalaliDatetime(self.leap_year + 1, 1, 3))
def test_sub(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_time2 = jalali_time1 - timedelta(10)
self.assertEqual(jalali_time2, JalaliDatetime(self.leap_year, 12, 13))
difference = jalali_time1 - JalaliDatetime(self.leap_year - 1, 12, 1)
self.assertEqual(difference, timedelta(387))
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23, 4, 2, 10, 7)
self.assertEqual(jalali_time1 - jalali_time1.date(), timedelta(hours=4, minutes=2, seconds=10, microseconds=7))
def test_lt_gt_le_ge_ne_eg(self):
jalali_time1 = JalaliDatetime(self.leap_year, 12, 23)
jalali_time2 = JalaliDatetime(self.leap_year, 12, 24)
jalali_time3 = JalaliDatetime(self.leap_year, 12, 24)
self.assertTrue(jalali_time1 <= jalali_time2)
self.assertTrue(jalali_time1 != jalali_time2)
self.assertFalse(jalali_time1 > jalali_time2)
self.assertTrue(jalali_time2 == jalali_time3)
def test_replace(self):
d1 = JalaliDatetime(1391, 12, 30)
self.assertEqual(d1.replace(year=1395), JalaliDatetime(1395, 12, 30))
self.assertEqual(d1.replace(month=1), JalaliDatetime(1391, 1, 30))
self.assertEqual(d1.replace(day=1), JalaliDatetime(1391, 12, 1))
self.assertRaises(ValueError, d1.replace, year=1392)
def test_repr(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(repr(d1), 'khayyam.JalaliDatetime(1375, 12, 23, 12, 3, 45, 34567, Panjshanbeh)')
class TestJalaliDateTime(unittest.TestCase):
def setUp(self):
self.leap_year = 1375
self.naive_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3)
self.aware_jdt = JalaliDatetime(self.leap_year, 12, 30, 10, 2, 1, 3, TehranTimezone())
def test_to_from_datetime(self):
# Naive
jdate1 = JalaliDatetime.from_datetime(self.naive_jdt.to_datetime())
self.assertEqual(self.naive_jdt, jdate1)
# Aware
jdate2 = JalaliDatetime.from_datetime(self.aware_jdt.to_datetime())
self.assertEqual(self.aware_jdt, jdate2)
def test_today(self):
dt = datetime.now().date()
jdt = JalaliDatetime.today().date()
self.assertEqual(jdt, JalaliDate.from_date(dt))
def test_now(self):
self.assertIsNotNone(JalaliDatetime.now())
self.assertIsNone(JalaliDatetime.now().tzinfo)
self.assertIsNotNone(JalaliDatetime.now(TehranTimezone()).tzinfo)
def test_utcnow(self):
jutcnow = JalaliDatetime.utcnow()
utcnow = jutcnow.to_datetime()
self.assertEqual(jutcnow.time(), utcnow.time())
def test_strftime_strptime(self):
def check_format(jdate ,fmt):
jdate_str = jdate.strftime(fmt)
parsed_dt = JalaliDatetime.strptime(jdate_str, fmt)
if jdate != parsed_dt:
print(repr(jdate))
print(jdate_str)
print(repr(parsed_dt))
self.assertEqual(jdate, parsed_dt)
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.strftime('%Q'), 'Panjshanbeh 23 Esfand 1375 12:03:45 PM')
# Test HOUR
self.assertEqual(JalaliDatetime(1386, 12, 23).strftime('%H'), u'00')
self.assertEqual(JalaliDatetime(1386, 12, 23, 1).strftime('%H'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 12).strftime('%H'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 13).strftime('%H'), u'13')
self.assertEqual(JalaliDatetime(1386, 12, 23, 23).strftime('%H'), u'23')
self.assertEqual(
(JalaliDatetime(1386, 12, 23, 23, 59, 59) + timedelta(seconds=1)).strftime('%H'), u'00')
self.assertEqual(JalaliDatetime(1386, 12, 23).strftime('%I'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 1).strftime('%I'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 12).strftime('%I'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 13).strftime('%I'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 23).strftime('%I'), u'11')
self.assertEqual(
(JalaliDatetime(1386, 12, 23, 23, 59, 59) + timedelta(seconds=1)).strftime('%I'), u'12')
self.assertEqual(d1.strftime('%I'), u'12')
self.assertEqual(JalaliDatetime.strptime('8', '%H'), JalaliDatetime(hour=8))
# Test Timezone
tz_dt = JalaliDatetime(tzinfo=Timezone(timedelta(minutes=10)))
self.assertEqual(JalaliDatetime.strptime('00:10', '%z'), tz_dt)
self.assertEqual(tz_dt.strftime('%z'), '+00:10')
tz_dt = JalaliDatetime(tzinfo=Timezone(timedelta(minutes=-30)))
self.assertEqual(tz_dt.strftime('%z'), '-00:30')
self.assertEqual(JalaliDatetime.strptime('', '%z'), JalaliDatetime())
self.assertEqual(JalaliDatetime.strptime('00:00', '%z'), JalaliDatetime())
self.assertEqual(JalaliDatetime.strptime('00:01', '%z'),
JalaliDatetime(tzinfo=Timezone(timedelta(minutes=1))))
self.assertNotEqual(JalaliDatetime.strptime('04:30', '%z'), JalaliDatetime.strptime('04:31', '%z'))
self.assertEqual(JalaliDatetime.strptime('04:30', '%z'), JalaliDatetime.strptime('04:30', '%z'))
self.assertNotEqual(JalaliDatetime.strptime('04:30', '%z'),
JalaliDatetime(tzinfo=teh_tz))
self.assertEqual(JalaliDatetime.strptime('+04:30', '%z').utcoffset(), timedelta(hours=4.50))
self.assertEqual(tz_dt.strftime('%z'), tz_dt.strftime('%Z'))
self.assertEqual(
JalaliDatetime(1394, 4, 28, 18, 14, 35, 962659, Timezone(timedelta(.3))).strftime('%Y-%m-%d %H:%M:%S.%f %z'),
'1394-04-28 18:14:35.962659 +07:12')
self.assertEqual(
JalaliDatetime.strptime('1394-04-28 18:14:35.962659 +07:12', '%Y-%m-%d %H:%M:%S.%f %z'),
JalaliDatetime(1394, 4, 28, 18, 14, 35, 962659, Timezone(timedelta(.3)))
)
check_format(d1, '%Y-%m-%d %H:%M:%S.%f')
check_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %p %I:%M:%S.%f')
self.assertEqual(
JalaliDatetime.strptime(u'1394-تیر-29 دوشنبه 00:05:14.113389 +04:30', '%Y-%B-%d %A %H:%M:%S.%f %z'),
JalaliDatetime(1394, 4, 29, 0, 5, 14, 113389, Timezone(timedelta(hours=4, minutes=30)))
)
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in xrange(100):
d_test = d2 + timedelta(hours=i)
check_format(d_test, '%Y%m%d%H%a%A%b%B%c%C%f%I%j%M%p%S%w%x%X%y%g%G%e%E%W%%')
check_format(d_test, '%Y-%m-%d %p %I:%M:%S.%f')
check_format(d_test, '%Y-%m-%d %X')
check_format(d_test, '%x %H')
check_format(d_test, '%c')
check_format(d_test, '%C')
check_format(d_test, '%q')
check_format(d_test, '%Q')
self.assertEqual(d1.isoformat(), '%s-12-23T12:03:45.034567' % self.leap_year)
tz_datetime = d1.astimezone(teh_tz)
self.assertEqual(tz_datetime.strftime('%Z'), 'Iran/Tehran')
def test_iso_format(self):
jdate = JalaliDatetime(self.leap_year, 12, 23)
self.assertEqual(jdate.isoformat(), '%s-12-23T00:00:00.000000' % self.leap_year)
jdate = JalaliDatetime(self.leap_year, 12, 23, tzinfo=teh_tz)
self.assertEqual(jdate.isoformat(), '%s-12-23T00:00:00.000000+03:30' % self.leap_year)
def test_algorithm(self):
min = datetime(1900, 1, 1, 1, 1, 1)
max_days = 5000 # 3000 years !
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDatetime.from_datetime(dt)
# print('Processing day: %s' % jd.year)
dt2 = jd.to_datetime()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_add(self):
jdate = JalaliDatetime(self.leap_year, 12, 23)
jdate2 = jdate + timedelta(10)
self.assertEqual(jdate2, JalaliDatetime(self.leap_year + 1, 1, 3))
def test_sub(self):
jdate = JalaliDatetime(self.leap_year, 12, 23)
jdate2 = jdate - timedelta(10)
self.assertEqual(jdate2, JalaliDatetime(self.leap_year, 12, 13))
jtimedelta = jdate - JalaliDatetime(self.leap_year - 1, 12, 1)
self.assertEqual(jtimedelta, timedelta(387))
def test_lt_gt_le_ge_ne_eg(self):
jdate = JalaliDatetime(self.leap_year, 12, 23)
jdate2 = JalaliDatetime(self.leap_year, 12, 24)
jdate3 = JalaliDatetime(self.leap_year, 12, 24)
self.assertTrue(jdate <= jdate2)
self.assertTrue(jdate != jdate2)
self.assertFalse(jdate > jdate2)
self.assertTrue(jdate2 == jdate3)
def test_replace(self):
d1 = JalaliDatetime(1391, 12, 30)
self.assertEqual(d1.replace(year=1395), JalaliDatetime(1395, 12, 30))
self.assertEqual(d1.replace(month=1), JalaliDatetime(1391, 1, 30))
self.assertEqual(d1.replace(day=1), JalaliDatetime(1391, 12, 1))
self.assertRaises(ValueError, d1.replace, year=1392)
def test_repr(self):
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(repr(d1), 'khayyam.JalaliDatetime(1375, 12, 23, 12, 3, 45, 34567, Panjshanbeh)')
def test_iso_format(self):
jalali_time = JalaliDatetime(self.leap_year, 12, 23)
self.assertEqual(jalali_time.isoformat(), '%s-12-23T00:00:00.000000' % self.leap_year)
jalali_time = JalaliDatetime(self.leap_year, 12, 23, tzinfo=teh_tz)
self.assertEqual(jalali_time.isoformat(), '%s-12-23T00:00:00.000000+03:30' % self.leap_year)
def test_strftime_strptime(self):
def check_format(jdate ,fmt):
jdate_str = jdate.strftime(fmt)
parsed_dt = JalaliDatetime.strptime(jdate_str, fmt)
if jdate != parsed_dt:
print(repr(jdate))
print(jdate_str)
print(repr(parsed_dt))
self.assertEqual(jdate, parsed_dt)
d1 = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567)
self.assertEqual(d1.strftime('%Q'), 'Panjshanbeh 23 Esfand 1375 12:03:45 PM')
# Test HOUR
self.assertEqual(JalaliDatetime(1386, 12, 23).strftime('%H'), u'00')
self.assertEqual(JalaliDatetime(1386, 12, 23, 1).strftime('%H'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 12).strftime('%H'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 13).strftime('%H'), u'13')
self.assertEqual(JalaliDatetime(1386, 12, 23, 23).strftime('%H'), u'23')
self.assertEqual(
(JalaliDatetime(1386, 12, 23, 23, 59, 59) + timedelta(seconds=1)).strftime('%H'), u'00')
self.assertEqual(JalaliDatetime(1386, 12, 23).strftime('%I'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 1).strftime('%I'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 12).strftime('%I'), u'12')
self.assertEqual(JalaliDatetime(1386, 12, 23, 13).strftime('%I'), u'01')
self.assertEqual(JalaliDatetime(1386, 12, 23, 23).strftime('%I'), u'11')
self.assertEqual(
(JalaliDatetime(1386, 12, 23, 23, 59, 59) + timedelta(seconds=1)).strftime('%I'), u'12')
self.assertEqual(d1.strftime('%I'), u'12')
self.assertEqual(JalaliDatetime.strptime('8', '%H'), JalaliDatetime(hour=8))
# Test Timezone
tz_dt = JalaliDatetime(tzinfo=Timezone(timedelta(minutes=10)))
self.assertEqual(JalaliDatetime.strptime('00:10', '%z'), tz_dt)
self.assertEqual(tz_dt.strftime('%z'), '+00:10')
tz_dt = JalaliDatetime(tzinfo=Timezone(timedelta(minutes=-30)))
self.assertEqual(tz_dt.strftime('%z'), '-00:30')
self.assertEqual(JalaliDatetime.strptime('', '%z'), JalaliDatetime())
self.assertEqual(JalaliDatetime.strptime('00:00', '%z'), JalaliDatetime())
self.assertEqual(JalaliDatetime.strptime('00:01', '%z'),
JalaliDatetime(tzinfo=Timezone(timedelta(minutes=1))))
self.assertNotEqual(JalaliDatetime.strptime('04:30', '%z'), JalaliDatetime.strptime('04:31', '%z'))
self.assertEqual(JalaliDatetime.strptime('04:30', '%z'), JalaliDatetime.strptime('04:30', '%z'))
self.assertNotEqual(JalaliDatetime.strptime('04:30', '%z'),
JalaliDatetime(tzinfo=teh_tz))
self.assertEqual(JalaliDatetime.strptime('+04:30', '%z').utcoffset(), timedelta(hours=4.50))
self.assertEqual(tz_dt.strftime('%z'), tz_dt.strftime('%Z'))
self.assertEqual(
JalaliDatetime(1394, 4, 28, 18, 14, 35, 962659, Timezone(timedelta(.3))).strftime('%Y-%m-%d %H:%M:%S.%f %z'),
'1394-04-28 18:14:35.962659 +07:12')
self.assertEqual(
JalaliDatetime.strptime('1394-04-28 18:14:35.962659 +07:12', '%Y-%m-%d %H:%M:%S.%f %z'),
JalaliDatetime(1394, 4, 28, 18, 14, 35, 962659, Timezone(timedelta(.3)))
)
check_format(d1, '%Y-%m-%d %H:%M:%S.%f')
check_format(JalaliDatetime(1375, 12, 23, 12, 0, 0, 0), '%Y-%m-%d %p %I:%M:%S.%f')
self.assertEqual(
JalaliDatetime.strptime(u'1394-تیر-29 دوشنبه 00:05:14.113389 +04:30', '%Y-%B-%d %A %H:%M:%S.%f %z'),
JalaliDatetime(1394, 4, 29, 0, 5, 14, 113389, Timezone(timedelta(hours=4, minutes=30)))
)
d2 = JalaliDatetime(self.leap_year, 12, 23)
for i in xrange(100):
d_test = d2 + timedelta(hours=i)
check_format(d_test, '%Y%m%d%H%a%A%b%B%c%C%f%I%j%M%p%S%w%x%X%y%g%G%e%E%W%%')
check_format(d_test, '%Y-%m-%d %p %I:%M:%S.%f')
check_format(d_test, '%Y-%m-%d %X')
check_format(d_test, '%x %H')
check_format(d_test, '%c')
check_format(d_test, '%C')
check_format(d_test, '%q')
check_format(d_test, '%Q')
self.assertEqual(d1.isoformat(), '%s-12-23T12:03:45.034567' % self.leap_year)
tz_datetime = d1.astimezone(teh_tz)
self.assertEqual(tz_datetime.strftime('%Z'), 'Iran/Tehran')
def test_utcnow(self):
jalali_utcnow = JalaliDatetime.utcnow()
datetime_utcnow = jalali_utcnow.todatetime()
self.assertEqual(jalali_utcnow.time(), datetime_utcnow.time())
def test_now(self):
self.assertIsNotNone(JalaliDatetime.now())
self.assertIsNone(JalaliDatetime.now().tzinfo)
self.assertIsNotNone(JalaliDatetime.now(TehranTimezone()).tzinfo)
def test_str(self):
d1 = JalaliDatetime(1361, 6, 15)
self.assertEqual(
d1.__str__(),
d1.isoformat(sep=' ')
)
def test_today(self):
dt = datetime.now().date()
jdt = JalaliDatetime.today().date()
self.assertEqual(jdt, JalaliDate.from_date(dt))
def test_day_of_year(self):
d1 = JalaliDatetime(1395, 5, 29, 22, 18, 32, 749938, tzinfo=teh_tz)
self.assertEqual(d1.dayofyear(), 153)
def test_utcnow(self):
jutcnow = JalaliDatetime.utcnow()
utcnow = jutcnow.to_datetime()
self.assertEqual(jutcnow.time(), utcnow.time())
def test_formats(self):
d1 = JalaliDatetime(1395, 5, 29, 22, 18, 32, 749938, tzinfo=teh_tz)
naive = JalaliDatetime(1395, 5, 29, 22, 18, 32, 749938)
self.assertEqual(d1.localshortformat(), u'ج 29 مر 95 22:18')
self.assertEqual(d1.localshortformatascii(), u'J 29 Mo 95 22:18')
self.assertEqual(d1.localdatetimeformat(), u'جمعه 29 مرداد 1395 10:18:32 ب.ظ')
self.assertEqual(d1.localdatetimeformatascii(), u'Jomeh 29 Mordad 1395 10:18:32 PM')
self.assertEqual(d1.localtimeformat(), u'10:18:32 \u0628.\u0638')
self.assertEqual(d1.utcoffsetformat(), u'04:30')
self.assertEqual(naive.utcoffsetformat(), u'')
self.assertEqual(d1.tznameformat(), u'Iran/Tehran')
self.assertEqual(naive.tznameformat(), u'')
def test_timetuple(self):
jdate = JalaliDatetime(self.leap_year, 12, 23, 12, 3, 45, 34567, teh_tz)
self.assertEqual(jdate.timetuple().__repr__(), 'time.struct_time(tm_year=1375, tm_mon=12, tm_mday=23, tm_hour=12, tm_min=3, tm_sec=45, tm_wday=3, tm_yday=359, tm_isdst=2)')
self.assertEqual(jdate.utctimetuple().__repr__(), 'time.struct_time(tm_year=1375, tm_mon=12, tm_mday=23, tm_hour=8, tm_min=33, tm_sec=45, tm_wday=3, tm_yday=359, tm_isdst=0)')
def test_replace(self):
d1 = JalaliDatetime(1391, 12, 30)
self.assertEqual(d1.replace(year=1395), JalaliDatetime(1395, 12, 30))
self.assertEqual(d1.replace(month=1), JalaliDatetime(1391, 1, 30))
self.assertEqual(d1.replace(day=1), JalaliDatetime(1391, 12, 1))
self.assertRaises(ValueError, d1.replace, year=1392)
