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