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_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_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 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 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_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_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 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_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 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 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 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 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 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_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 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 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_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))
self.assertEqual(
JalaliDatetime(1361, 6, 15, tzinfo=TehranTimezone),
JalaliDatetime(1361, 6, 15, tzinfo=TehranTimezone())
)
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 __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_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 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 _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 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 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 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 persian_time(date):
return JalaliDatetime(date).strftime('%k:%r')
from datetime import timedelta from khayyam import JalaliDate, JalaliDatetime now = JalaliDatetime(1399, 4, 31, 16, 17, 31, 374398) print(now + timedelta(seconds=3600))
class BaseModel(Model):
created_time = DateTimeField(default=JalaliDatetime(datetime.now()).now())
modified_time = DateTimeField()
class Meta:
database = db
