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 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 __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 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)