def test_dateconversion(self):
sample = jdatetime.date(1389, 9, 2)
d_check_with = jdatetime.date(1390, 2, 23)
#TEST date
self.assertEqual(True, sample.togregorian() ==
datetime.date(2010, 11, 23))
self.assertEqual(True, jdatetime.date.fromgregorian(
date=datetime.date(2011, 5, 13)) == d_check_with)
#TEST datetime
self.assertEqual(True, jdatetime.datetime.fromgregorian(
datetime=datetime.datetime(2011, 5, 13)).date() ==
d_check_with)
jd_datetime = jdatetime.datetime.fromgregorian(year=2011,
month=5,
day=13,
hour=14,
minute=15,
second=16)
self.assertEqual(True, jd_datetime ==
jdatetime.datetime.combine(d_check_with,
jdatetime.time(14,
15,
16)))
gdatetime = datetime.datetime(2011, 5, 13, 14, 15, 16)
self.assertEqual(True, jd_datetime.togregorian() == gdatetime)
def test_date_calculation_on_two_dates(self):
date_1394 = jdatetime.date(1394, 1, 1)
date_1395 = jdatetime.date(1395, 1, 1)
day_diff = date_1395 - date_1394
self.assertEqual(day_diff, datetime.timedelta(365))
day_diff = date_1394 - date_1395
self.assertEqual(day_diff, datetime.timedelta(-365))
def test_date_calculation_on_timedelta(self):
date_1395 = jdatetime.date(1395,1,1)
day_before = date_1395 - jdatetime.timedelta(days=1)
day_after = date_1395 + jdatetime.timedelta(days=1)
self.assertEqual(day_before, jdatetime.date(1394, 12, 29))
self.assertEqual(day_after, jdatetime.date(1395, 1, 2))
day_after = jdatetime.timedelta(days=1) + date_1395
self.assertEqual(day_before, jdatetime.date(1394, 12, 29))
self.assertEqual(day_after, jdatetime.date(1395, 1, 2))
def test_kabiseh(self):
kabiseh_year = jdatetime.date.fromgregorian(date=datetime.date(2013, 3, 20))
self.assertEqual(True, kabiseh_year.isleap() is True)
normal_year = jdatetime.date.fromgregorian(date=datetime.date(2014, 3, 20))
self.assertEqual(True, normal_year.isleap() is False)
kabiseh_year = jdatetime.date(1391, 12, 30)
self.assertEqual(True, kabiseh_year.isleap() is True)
with self.assertRaises(ValueError):
jdatetime.date(1392, 12, 30)
def test_as_locale_returns_same_date_with_specified_locale(self):
jdate_en = jdatetime.date(1397, 4, 23, locale='en_US')
jdate_fa = jdate_en.aslocale('fa_IR')
self.assertEqual(jdate_fa.year, 1397)
self.assertEqual(jdate_fa.month, 4)
self.assertEqual(jdate_fa.day, 23)
self.assertEqual(jdate_fa.locale, 'fa_IR')
def test_subtract_time_delta(self):
date = jdatetime.date(1397, 4, 22, locale='nl_NL')
new_date = date - datetime.timedelta(days=1)
self.assertEqual(new_date.year, 1397)
self.assertEqual(new_date.month, 4)
self.assertEqual(new_date.day, 21)
self.assertEqual(new_date.locale, 'nl_NL')
def test_reverse_add_time_delta(self):
date = jdatetime.date(1397, 4, 22, locale='nl_NL')
new_date = datetime.timedelta(days=2) + date
self.assertEqual(new_date.year, 1397)
self.assertEqual(new_date.month, 4)
self.assertEqual(new_date.day, 24)
self.assertEqual(new_date.locale, 'nl_NL')
def to_python(self, value):
if value is None:
return value
if isinstance(value, datetime.datetime):
return jdatetime.date.fromgregorian(date=value.date())
if isinstance(value, datetime.date):
return jdatetime.date.fromgregorian(date=value)
if isinstance(value, jdatetime.datetime):
return value.date()
if isinstance(value, jdatetime.date):
return value
if not ansi_date_re.search(value):
raise exceptions.ValidationError(self.error_messages["invalid"])
# Now that we have the date string in YYYY-MM-DD format, check to make
# sure it's a valid date.
# We could use time.strptime here and catch errors, but datetime.date
# produces much friendlier error messages.
year, month, day = map(int, value.split("-"))
try:
if year > 1500:
return jdatetime.date.fromgregorian(date=datetime.date(year, month, day))
else:
return jdatetime.date(year, month, day)
except ValueError, e:
msg = self.error_messages["invalid_date"] % _(str(e))
raise exceptions.ValidationError(msg)
def test_strftime(self):
s = jdatetime.date(1390, 2, 23)
string_format = "%a %A %b %B %c %d %H %I %j %m %M %p %S %w %W %x %X %y %Y %f %z %Z"
output = 'Jom Jomeh Ord Ordibehesht Jom Ord 23 00:00:00 1390 23 00 00 054 02 00 AM 00 6 7 02/23/90 00:00:00 90 1390 000000 '
self.assertEqual(s.strftime(string_format), output)
dt = jdatetime.datetime(1390, 2, 23, 12, 13, 14, 1)
string_format = "%a %A %b %B %c %d %H %I %j %m %M %p %S %w %W %x %X %y %Y %f"
output = 'Jom Jomeh Ord Ordibehesht Jom Ord 23 12:13:14 1390 23 12 12 054 02 13 AM 14 6 7 02/23/90 12:12:14 90 1390 000001'
self.assertEqual(dt.strftime(string_format), output)
class NYCTime(jdatetime.tzinfo):
def utcoffset(self, dt):
return jdatetime.timedelta(hours=-4)
def tzname(self, dt):
return "EDT"
def dst(self, dt):
return jdatetime.timedelta(0)
nyc = NYCTime()
dt = jdatetime.datetime(1389, 2, 17, 19, 10, 2, tzinfo=nyc)
self.assertEqual(True, dt.strftime("%Z %z") == "EDT -0400")
teh = TehranTime()
dt = jdatetime.datetime(1389, 2, 17, 19, 10, 2, tzinfo=teh)
self.assertEqual(True, dt.strftime("%Z %z") == "IRDT +0330")
def to_python(self, value):
"""
Validates that the input can be converted to a date. Returns a Python
datetime.date object.
"""
if value in validators.EMPTY_VALUES:
return None
if isinstance(value, jdatetime.datetime):
return value.date()
if isinstance(value, jdatetime.date):
return value
groups = re.search(
r'(?P<year>[\d]{1,4})-(?P<month>[\d]{1,2})-(?P<day>[\d]{1,2})',
value
)
try:
return jdatetime.date(year=int(groups.group(1)),
month=int(groups.group(2)),
day=int(groups.group(3)))
except (ValueError, AttributeError):
pass
raise exceptions.ValidationError(self.error_messages['invalid'])
def convert(self, row):
metadata = {
'Desc.': persian.convert_fa_numbers(row[t['sharh']]),
}
inputAmount = int(row[t['bestankar']])
outputAmount = int(row[t['bedehkar']])
amount = 0
reverse = True
name = persian.convert_fa_numbers(row[t['nam']])
matchNumber = re.findall('(\d+)', name)
accountNumber = ''
if matchNumber:
accountNumber = matchNumber[0]
name = name.replace(accountNumber, ' ' + accountNumber + ' ')
metadata['Name'] = name
fromAccount = self.unknownaccount
foundAccount = self.accounts.get(str(accountNumber), None)
payee = name
if accountNumber is not '' and foundAccount:
fromAccount = foundAccount['account']
payee = foundAccount['name']
if accountNumber is not '':
payee = "(" + accountNumber + ") " + payee
if outputAmount > 0:
amount = outputAmount / 10000
reverse = True
else:
amount = inputAmount / 10000
reverse = False
fromAccount = 'Income:Salary'
jdatestring = row[t['tarikh']]
jdate = jdatetime.date(
int(jdatestring[0:4]), int(jdatestring[4:6]),
int(jdatestring[6:8]))
date = jdate.togregorian()
metadata['Date'] = jdate.isoformat() + ', ' + jdate.j_weekdays_en[
jdate.weekday()]
metadata['Time'] = row[t['time']]
unit = 'kIRT'
return Transaction(
cleared=True,
date=date,
payee=payee,
metadata=metadata,
postings=[
Posting(
account=fromAccount,
amount=Amount(amount, unit, reverse=not reverse)),
Posting(
account=self.name,
amount=Amount(amount, unit, reverse=reverse))
])
def extract_chart(self, symbol, chart_name, end_date, time_slot):
# the list representing the labels of a line chart
x = []
# the list representing the data of a line chart
y = []
# the return value (a tuple)
d = None
if time_slot == ONE_WEEK or time_slot == THREE_WEEK:
# Considering a week has 7 days, we extract those rows from our database
# that match the given symbol and time duration given as inputs to the method
start_date = end_date - jdate.timedelta(days = time_slot*7)
date = start_date
while date <= end_date:
t = 0
for row in self.datas:
if row['date'] == date and symbol == row['symbol']:
y.append(row[chart_name])
t = 1
break
x.append(str(date))
if t == 0:
y.append(0)
date += jdate.timedelta(days = 1)
d = (x, y)
elif time_slot == THREE_MONTHS:
end_date = self.set_to_wednesday(end_date)
start_date = end_date - jdate.timedelta(days = 12*7)
date = start_date
while date <= end_date:
sum_value = 0
for row in self.datas:
if symbol == row['symbol'] and row['date'] > date and row['date'] <= date + jdate.timedelta(days = 7):
sum_value = sum_value + row[chart_name]
x.append(str(date + jdate.timedelta(days = 7)))
y.append(sum_value)
date += jdate.timedelta(days = 7)
d = (x, y)
elif time_slot == ONE_YEAR:
start_date = jdate.date(end_date.year - 1, end_date.month, end_date.day)
# print(str(start_date)+ 'تاریخ شروع ')
# print(str(end_date) + 'تاریخ پایان ')
date = start_date
while date <= end_date:
# print(str(date) + 'curr date')
sum_value = 0
for row in self.datas:
if symbol == row['symbol'] and row['date'].year == date.year and row['date'].month == date.month:
sum_value = sum_value + row[chart_name]
x.append(date.j_months_fa[date.month - 1])
y.append(sum_value)
date += jdate.timedelta(days = 30)
d = (x, y)
return d
def test_timetuple(self):
date = jdatetime.date(
1397,
4,
22,
)
self.assertEqual(
date.timetuple(),
time.struct_time((2018, 7, 13, 0, 0, 0, 4, 194, -1)),
)
def _has_changed(self, initial, data):
# If our field has show_hidden_initial=True, initial will be a string
# formatted by HiddenInput using formats.localize_input, which is not
# necessarily the format used for this widget. Attempt to convert it.
try:
input_format = formats.get_format('DATE_INPUT_FORMATS')[0]
initial = jdatetime.date(*time.strptime(initial, input_format)[:3])
except (TypeError, ValueError):
pass
return super()._has_changed(self._format_value(initial), data)
def convert_jalali_gregorian(jalali_date):
"""
convert jalali string date to gregorian date object
:param jalali_date: jalali date as string
:return: gregorian date of jalali date
"""
year, month, day = jalali_date.split('-')
start_day = jdatetime.date(day=int(day), year=int(year),
month=int(month)).togregorian()
return start_day
def _has_changed(self, initial, data):
# If our field has show_hidden_initial=True, initial will be a string
# formatted by HiddenInput using formats.localize_input, which is not
# necessarily the format used for this widget. Attempt to convert it.
try:
input_format = formats.get_format('DATE_INPUT_FORMATS')[0]
initial = jdatetime.date(*time.strptime(initial, input_format)[:3])
except (TypeError, ValueError):
pass
return super(jDateInput, self)._has_changed(self._format_value(initial), data)
def expert_reqs_noxp(account):
date = jdatetime.date(month=10, day=1, year=1399)
reqs = Requests.objects.filter(
is_active=True,
finished=False,
date_fa__gte=date,
owner=account,
xpref__isnull=True
)
return reqs.count()
def parse(self, response):
dic = {"title":" ", "timestamp": "", "url": " ", "date": " ", "text": " ", "summary": " ", "tags": [], "article_section": " ", "code": " "}
title = response.xpath('//h1[@class="title"]/text()').get()
dic["title"] = title
news_url = response.xpath('//a[@id="short-link"]/text()').get()
dic["url"] = " ".join(news_url.split())
sections = []
dic["article_section"] = sections
summary = response.xpath('//h3[@class="lead"]/text()').get()
dic["summary"] = summary
date = response.xpath('//li[@class="time"]/text()').get()
date_list = date.split(' ')
timelist = date_list[5].split(':')
hour = convert_persian_to_english_numbers(timelist[0])
minute = convert_persian_to_english_numbers(timelist[1])
day = convert_persian_to_english_numbers(date_list[1])
month = month_dic[date_list[2]]
year = convert_persian_to_english_numbers(date_list[3])
jalili_date = jdatetime.date(int(year), int(month), int(day)).togregorian()
datetime_object = datetime.datetime(jalili_date.year, jalili_date.month, jalili_date.day, int(hour),
int(minute))
dic["date"] = str(datetime_object)
dic["timestamp"] = datetime_object.timestamp()
code = "no code"
dic["code"] = code
tags = []
dic["tags"] = tags
text_list = response.xpath('//div[@class="story"]/p/text()').getall()
text = ""
for t in text_list:
text += t
dic["text"] = text
dic["preprocessed_title"] = preprocess(dic["title"])
dic["preprocessed_summary"] = preprocess(dic["summary"])
dic["preprocessed_text"] = preprocess(dic["text"])
dic["w2v"] = get_word2vec(dic).tolist()
dic["tfidf"] = get_tfidt_vector(dic).tolist()
es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
res = es.index(index='newsindex', doc_type='news', body=dic)
client = MongoClient()
db = client['newsdb_week']
articles = db.weekarticles
result = articles.insert_one(dic)
def convert(self, row):
desc = persian.convert_fa_numbers(row['enbank'])
metadata = {'Desc.': desc}
inputAmount = int(row['3'])
outputAmount = int(row['4'])
amount = 0
reverse = True
accountNumber = ""
matchNumber = re.findall('(\d{7,9})', desc)
if matchNumber:
accountNumber = int(matchNumber[0])
fromAccount = self.unknownaccount
foundAccount = self.accounts.get(str(accountNumber), None)
payee = 'Unknown'
if accountNumber is not '' and foundAccount:
fromAccount = foundAccount['account']
payee = foundAccount['name']
if accountNumber is not '':
payee = "(" + str(accountNumber) + ") " + payee
if outputAmount > 0:
amount = outputAmount / 10000
reverse = True
else:
amount = inputAmount / 10000
reverse = False
fromAccount = 'Income:Salary'
jdatestring = row['1']
jdate = jdatetime.date(int(jdatestring[0:4]), int(jdatestring[5:7]),
int(jdatestring[8:]))
date = jdate.togregorian()
metadata['Date'] = jdate.isoformat() + ', ' + jdate.j_weekdays_en[
jdate.weekday()]
metadata['Time'] = row['2']
unit = 'kIRT'
return Transaction(cleared=True,
date=date,
payee=payee,
metadata=metadata,
postings=[
Posting(account=fromAccount,
amount=Amount(amount,
unit,
reverse=not reverse)),
Posting(account=self.name,
amount=Amount(amount,
unit,
reverse=reverse))
])
def reqs_no_xp(user):
date = jdatetime.date(month=10, day=1, year=1399)
reqs = Requests.objects.filter(
is_active=True,
finished=False,
date_fa__gte=date,
xpref__isnull=True,
).order_by('date_fa').reverse()
if not user.is_superuser:
reqs = reqs.filter(owner=user)
return reqs
def getDate(dt):
y=str(dt).split("-")
if(len(y)==3):
year=int(y[0])
month=int(y[1])
day=int(y[2])
return jdatetime.date(year,month,day).togregorian()
else:
return datetime.date.today()
def is_valid(self):
try:
self.data._mutable = True
self.data['date'] = jdatetime.date(
*map(int,
normalize_digits(self.data['date']).split(
'/'))).togregorian().strftime('%Y-%m-%d')
except:
pass
return super(NoteForm, self).is_valid()
def mergeIranbourseAllDayExcelsByDays(InputDir="DailyExcelsFromIranBourse", OutputFile="AllDataByDays.pkl"):
jdatetime.set_locale('fa_IR')
allData = {}
# if not os.path.exists(InputDir):
# os.makedirs(InputDir)
for root, dirs, files in os.walk(InputDir):
files.sort()
print('start readin files')
fi = 0.0
for filename in files:
print(str(int(fi / files.__len__() * 100.0)) + ' % ... ' + filename)
fi += 1.0
try:
df_list = pandas.read_html(InputDir + '/' + filename)
except ValueError as e:
if e.args[0] == 'No tables found':
continue
else:
raise e
if len(df_list) < 1:
print('no Data Frame in > ' + filename)
continue
df = df_list[0] # first frame only !
# df.to_csv('DataPreparing/Data/table {}.csv'.format(0))
if df.isnull().values.any():
print('null value in > ' + filename)
continue
date = filename.split('.')[0].split('_')
pd = jdatetime.date(int(date[1]), int(date[2]), int(date[3]))
ed = pd.togregorian()
dayInWeek = ed.strftime("%A")
pdayInWeek = pd.strftime("%A")
thisday = {}
for col in df.columns.values:
# thisday[col] = df[col].values
idx = 0
for v in df[col].values:
if idx not in thisday:
thisday[idx] = {}
thisday[idx][col] = v
idx += 1
allData[pd] = thisday
f = open(OutputFile, "wb")
pickle.dump(allData, f)
f.close()
def test_comparison(self):
today = jdatetime.date.today()
self.assertEqual(False, today < today - jdatetime.timedelta(days=76) )
self.assertEqual(False, today <= today - jdatetime.timedelta(days=1) )
self.assertEqual(True, today + jdatetime.timedelta(days=1) > today )
self.assertEqual(True, today + jdatetime.timedelta(days=30) >= today )
self.assertEqual(True, today == today)
self.assertEqual(True, today != (jdatetime.date( today.year, today.month, today.day ) + jdatetime.timedelta(days=1) ) )
dtg = jdatetime.datetime(1380, 12, 1, 1, 2, 4)
self.assertEqual(True, dtg < dtg + jdatetime.timedelta(seconds=1))
self.assertEqual(True, dtg - jdatetime.timedelta(seconds=1) < dtg)
self.assertEqual(False, dtg == None)
def set_default(self, kwargs):
kwargs_temp = kwargs.copy()
today = jdatetime.date.today()
month_start = jdatetime.date(year=today.year, month=today.month, day=1)
kwargs_temp['data'] = {
'perm_date_after': str(month_start),
}
self.request.session['report-filters'] = {
'data': {
'perm_date_after': str(month_start),
}
}
return kwargs_temp
def test_date_raise_exception_on_invalid_calculation(self):
date_1395 = jdatetime.date(1395,1,1)
with self.assertRaises(TypeError):
day_before = date_1395 - 1
with self.assertRaises(TypeError):
day_before = date_1395 + 1
with self.assertRaises(TypeError):
day_before = jdatetime.timedelta(days=1) - date_1395
with self.assertRaises(TypeError):
day_before = date_1395 + date_1395
def get(self, request, *args, **kwargs):
per = request.GET['select_and_time[date]']
time_slot = int(request.GET['select_and_time[time_slot]'])
code = {u"۰":"0",u"۱":"1",u"۲":"2",u"۳":"3",u"۴":"4",u"۵":"5",u"۶":"6",u"۷":"7",u"۸":"8",u"۹":"9", u"/":"/"}
new_per = ''.join(code.get(ch, ch) for ch in per)
dates = new_per.split('/')
if (dates == ['']):
persian_date = jdate.date.today()
else:
persian_date = jdate.date(int(dates[0]), int(dates[1]), int(dates[2]))
result = self.get_product_producer('copper',persian_date, time_slot )
datas = result
output = {'datas': datas}
return HttpResponse(json.dumps(output))
def test_date_raise_exception_on_invalid_calculation(self):
date_1395 = jdatetime.date(1395, 1, 1)
with self.assertRaises(TypeError):
day_before = date_1395 - 1
with self.assertRaises(TypeError):
day_before = date_1395 + 1
with self.assertRaises(TypeError):
day_before = jdatetime.timedelta(days=1) - date_1395
with self.assertRaises(TypeError):
day_before = date_1395 + date_1395
def mergeIranbourseAllNamadExcelsByNamadd(InputDir="NamadsExcelsFromIranBourse", OutputFile="AllDataByNamads.pkl"):
jdatetime.set_locale('fa_IR')
allData = {}
for root, dirs, files in os.walk(InputDir):
files.sort()
print('start readin files')
fi = 0.0
for filename in files:
print(str(int(fi / files.__len__() * 100.0)) + ' % ... ' + filename)
fi += 1.0
df_list = pandas.read_html(InputDir + '/' + filename)
if len(df_list) < 1:
print('no Data Frame in > ' + filename)
continue
df = df_list[0] # first frame only !
# df.to_csv('DataPreparing/Data/table {}.csv'.format(0))
if df.isnull().values.any():
print('null value in > ' + filename)
continue
parts = filename.split('.')[0].split('_')
NamadId = parts[1]
NamadCode = parts[2]
thisNamad = {}
for col in df.columns.values:
idx = 0
for v in df[col].values:
if idx not in thisNamad:
thisNamad[idx] = {}
if col == str('تاريخ'):
date = v.split('/')
pd = jdatetime.date(int(date[0]), int(date[1]), int(date[2]))
thisNamad[idx][col] = pd
else:
if type(v) == numpy.int64:
thisNamad[idx][col] = int(v)
else:
thisNamad[idx][col] = v
idx += 1
allData[NamadId] = thisNamad
f = open(OutputFile, "wb")
pickle.dump(allData, f)
f.close()
def test_date_conversion_integer_input(self):
d_check_with = jdatetime.date(1390, 2, 23)
jd_datetime = jdatetime.datetime.fromgregorian(year=2011,
month=5,
day=13,
hour=14,
minute=15,
second=16)
self.assertEqual(
True, jd_datetime == jdatetime.datetime.combine(
d_check_with, jdatetime.time(14, 15, 16)))
gdatetime = datetime.datetime(2011, 5, 13, 14, 15, 16)
self.assertEqual(True, jd_datetime.togregorian() == gdatetime)
def test_strftime_in_fa_locale(self):
s = jdatetime.date(1390, 2, 23, locale='fa_IR')
string_format = "%a %A %b %B %c %d %H %I %j %m %M %p %S %w %W %x %X %y %Y %f %z %Z"
output = u"جمعه جمعه اردیبهشت اردیبهشت جمعه ۲۳ اردیبهشت ۹۰, ۰۰:۰۰:۰۰ ۲۳ ۰۰ ۱۲ ۰۵۴ ۰۲ ۰۰ قبل از ظهر ۰۰ ۶ ۸ ۱۳۹۰/۰۲/۲۳ ۰۰:۰۰:۰۰ ۹۰ ۱۳۹۰ ۰۰۰۰۰۰ "
self.assertEqual(s.strftime(string_format), output)
dt = jdatetime.datetime(1390, 2, 23, 12, 13, 14, 1, locale='fa_IR')
unicode_format = "%a %A %b %B %c %d %H %I %j %m %M %p %S %w %W %x %X %y %Y %f"
output = u"جمعه جمعه اردیبهشت اردیبهشت جمعه ۲۳ اردیبهشت ۹۰, ۱۲:۱۳:۱۴ ۲۳ ۱۲ ۱۲ ۰۵۴ ۰۲ ۱۳ بعد از ظهر ۱۴ ۶ ۸ ۱۳۹۰/۰۲/۲۳ ۱۲:۱۳:۱۴ ۹۰ ۱۳۹۰ ۰۰۰۰۰۱"
self.assertEqual(dt.strftime(unicode_format), output)
string_format = u"سال = %y، ماه = %m، ﺭﻭﺯ = %d"
output = u'سال = ۹۰، ماه = ۰۲، ﺭﻭﺯ = ۲۳'
self.assertEqual(dt.strftime(string_format), output)
def main():
for i in range(1, 12):
for j in range(1, 30):
for user in User.objects.all():
result = {
'count_file': randint(100, 500),
'value_file': randint(1000000, 1000000000),
'count_file_daily': randint(10, 100),
'value_file_daily': randint(1000000, 5000000),
'count_file_recovery': randint(1, 10),
'persian_date': jdatetime.date(1396, i, j),
'user': user
}
PersonDailyReport.objects.create(**result)
def find_current_week(self):
jweek = []
weekday = self.week_day
day = self.jday
if day - weekday < 1:
previous_month = (self.jmonth - 1) % 12
year = self.jyear - 1 if self.jmonth == 1 else self.jyear
jmonth_range = self.fix_kabise(year)
w_range = (jmonth_range[previous_month] - weekday + day, jmonth_range[previous_month] + 1)
count = 0
for i in range(w_range[0], w_range[1]):
date = jdatetime.date(year, previous_month, i)
jweek += [(date, count)]
count += 1
begin = (day - weekday, 0) if day - 1 >= weekday else (1, weekday - day + 1)
count = 0
for i in range(begin[0], day + 1):
date = jdatetime.date(self.jyear, self.jmonth, i)
jweek += [(date, begin[1] + count)]
count += 1
last_day = jweek[-1][1] + 1
next_month_days = 1
next_month = (self.jmonth + 1) % 12
year = self.jyear + 1 if self.jmonth == 12 else self.jyear
next = False
while last_day < 7:
if jweek[-1][0].day + 1 <= self.jmonth_range[self.month] and not next:
date = jdatetime.date(self.jyear, self.jmonth, jweek[-1][0].day + 1)
jweek += [(date, last_day)]
else:
date = jdatetime.date(year, next_month, next_month_days)
jweek += [(date, last_day)]
next_month_days += 1
next = True
last_day += 1
return jweek
class Migration(migrations.Migration):
dependencies = [
('app1', '0013_post'),
]
operations = [
migrations.AddField(
model_name='post',
name='datetime',
field=django_jalali.db.models.jDateTimeField(
default=jdatetime.date(1390, 2, 3)),
preserve_default=False,
),
]
def AllThursdays(length, start_time=jdatetime.datetime.now()):
dates = date(start_time.year, start_time.month, start_time.day) #today
today = dates
dates += timedelta(days=5 - dates.weekday())
current_month = start_time.month
if 5 - today.weekday() >= 0:
yield dates
f = start_time + timedelta(days=length)
try:
f = f.date()
except:
f = f
while dates <= f:
dates += timedelta(days=7)
if dates <= f:
yield dates
def received_datetime_handler(bot, update, user_data):
'''DATE_TIME State handler function'''
user_data['p_date'] = update.message.text
now = jdatetime.date.today()
if not user_data['p_date'].replace(' ', '').isdigit():
update.message.reply_text('lotfan add bede mesle nmune ke dadm')
return DATE_TIME
dt_list = user_data['p_date'].split()
year = now.year
month = now.month
day = now.day
if len(dt_list) == 1:
day = int(dt_list[0])
elif len(dt_list) == 2:
month = int(dt_list[0])
day = int(dt_list[1])
elif len(dt_list) == 3:
year = int(dt_list[0])
month = int(dt_list[1])
day = int(dt_list[2])
else:
update.message.reply_text('lotfan 1 ta 3 add bedid')
return DATE_TIME
p_date = jdatetime.date(year=year, month=month, day=day)
strftime = p_date.strftime("%a, %d %b %Y")
delta = p_date - now
if delta.days < 0:
update.message.reply_text(
'time ke zadi gabl az emruze va gabul nist 2bare emtehan kon\n'
'\n{}\n'.format(strftime))
return DATE_TIME
user_data['p_date'] = p_date
user_data['p_date_str'] = strftime
update.message.reply_text(
'baraye sabt post /enqeue obezan ta {} pose mishe'.format(strftime))
update.message.reply_text(text=user_data['pocket'],
parse_mode=telegram.ParseMode.HTML)
return DATE_TIME
def to_python(self, value):
"""
Validates that the input can be converted to a date. Returns a Python
datetime.date object.
"""
if value in validators.EMPTY_VALUES:
return None
if isinstance(value, jdatetime.datetime):
return value.date()
if isinstance(value, jdatetime.date):
return value
for format in self.input_formats or formats.get_format("DATE_INPUT_FORMATS"):
try:
return jdatetime.date(*time.strptime(value, format)[:3])
except ValueError:
continue
raise exceptions.ValidationError(self.error_messages["invalid"])
def to_python(self, value):
"""
Validates that the input can be converted to a date. Returns a Python
datetime.date object.
"""
if value in validators.EMPTY_VALUES:
return None
if isinstance(value, jdatetime.datetime):
return value.date()
if isinstance(value, jdatetime.date):
return value
for format in self.input_formats or formats.get_format('DATE_INPUT_FORMATS'):
try:
return jdatetime.date(*time.strptime(value, format)[:3])
except ValueError:
continue
raise exceptions.ValidationError(self.error_messages['invalid'])
def import_items(user, file_name='data.csv'):
# try:
with open(file_name, newline='') as csvfile:
items = csv.reader(csvfile, delimiter=',')
new_items = []
for item in items:
new_items.append(
Item(name=item[1],
price=item[2],
date=jdatetime.date(int(item[0].split('/')[0]),
int(item[0].split('/')[1]),
int(item[0].split('/')[2])),
item_type='Exp',
group=Group.objects.filter(user=user).first(),
user=user))
Item.objects.bulk_create(new_items)
return len(new_items)
def __init__(self,
symbol,
jyear: int,
jmonth: int,
jday: int,
load_from_cache: bool = True,
save_to_cache: bool = True,
save_raw_data: bool = False):
self.symbol = symbol
self.date = date(year=jyear, month=jmonth, day=jday)
self.greg_date = self.date.togregorian()
self.load_from_cache = load_from_cache
self.save_to_cache = save_to_cache
self.save_raw_data = save_raw_data
self._is_no_data = False
self._load()
def test_comparison(self):
today = jdatetime.date.today()
self.assertEqual(False, today < today - jdatetime.timedelta(days=76))
self.assertEqual(False, today <= today - jdatetime.timedelta(days=1))
self.assertEqual(True, today + jdatetime.timedelta(days=1) > today)
self.assertEqual(True, today + jdatetime.timedelta(days=30) >= today)
self.assertEqual(True, today == today)
self.assertEqual(False, today > today)
self.assertEqual(False, today < today)
self.assertEqual(True, today >= today)
self.assertEqual(True, today <= today)
not_today = jdatetime.date(today.year, today.month,
today.day) + jdatetime.timedelta(days=1)
self.assertEqual(True, today != not_today)
dtg = jdatetime.datetime(1380, 12, 1, 1, 2, 4)
self.assertEqual(True, dtg < dtg + jdatetime.timedelta(seconds=1))
self.assertEqual(True, dtg - jdatetime.timedelta(seconds=1) < dtg)
self.assertEqual(False, dtg is None)
def stringToDate(string):
# this tree line use for convert persian date to gregorian
string.split('/')
firstY = string[0]
seconY = string[1]
thirdY = string[2]
forthY = string[3]
firstM = string[5]
seconM = string[6]
firstD = string[8]
seconD = string[9]
yearString = firstY + seconY + thirdY + forthY
monthString = firstM + seconM
dayString = firstD + seconD
date = jdatetime.date(int(yearString),
int(monthString),
int(dayString),
locale='fa_IR')
date = date.togregorian()
return date
def get_formatted_jdatetime(datetime_object, object_type="datetime", show_seconds=True):
year = datetime_object.year
month = datetime_object.month
day = datetime_object.day
if object_type.lower() == "datetime":
jobject = datetime(
year,
month,
day,
datetime_object.hour,
datetime_object.minute,
datetime_object.second,
locale="fa_IR",
)
format_rule = "%a, %d %b %Y %H:%M:%S" if show_seconds else "%a, %d %b %Y %H:%M"
return jobject.strftime(format_rule)
elif object_type.lower() == "date":
jobject = date(year, month, day, locale="fa_IR")
return jobject.strftime("%a, %d %b %Y")
else:
raise ValueError("Unexpected argument was passed")
def initialize(self):
wb = load_workbook(filename='imev0/test2.xlsx', read_only=True)
ws = wb.active # ws is now an IterableWorksheet
for row in ws:
d = {}
if row[0].value == 'تاریخ':
continue
dates = row[0].value.split('/')
persian_date = jdate.date(int(dates[0]), int(dates[1]),
int(dates[2]))
d['date'] = persian_date
d['name'] = row[1].value
d['producer'] = row[2].value
d['symbol'] = row[3].value
d['contract_type'] = row[4].value
d['supply'] = float(row[5].value)
d['base_price'] = row[6].value
d['suppliers_offer'] = row[7].value
d['final_demand'] = row[8].value
d['payan_sabz'] = row[9].value
d['highest_demand_price'] = row[10].value
d['traded_amount'] = row[11].value
d['least_traded_price_rials'] = row[12].value
d['Average_traded_price_rials'] = row[13].value
d['Average_traded_price_origcurrency'] = row[14].value
d['highest_traded_price_rials'] = row[15].value
d['value_KRials'] = row[16].value
d['delivery_date'] = row[17].value
d['subgroup'] = row[18].value
d['group'] = row[19].value
d['main_group'] = row[20].value
d['details'] = row[21].value
d['supplier'] = row[22].value
d['method_of_supply'] = row[23].value
d['supply_code'] = row[24].value
d['supply_type'] = row[25].value
self.datas.append(d)
def initialize(self):
wb = load_workbook(filename='imev0/test2.xlsx', read_only=True)
ws = wb.active # ws is now an IterableWorksheet
for row in ws:
d = {}
if row[0].value == 'تاریخ':
continue
dates = row[0].value.split('/')
persian_date = jdate.date(int(dates[0]), int(dates[1]), int(dates[2]))
d['date'] = persian_date
d['name'] = row[1].value
d['producer'] = row[2].value
d['symbol'] = row[3].value
d['contract_type'] = row[4].value
d['supply'] = float(row[5].value)
d['base_price'] = row[6].value
d['suppliers_offer'] = row[7].value
d['final_demand'] = row[8].value
d['payan_sabz'] = row[9].value
d['highest_demand_price'] = row[10].value
d['traded_amount'] = row[11].value
d['least_traded_price_rials'] = row[12].value
d['Average_traded_price_rials'] = row[13].value
d['Average_traded_price_origcurrency'] = row[14].value
d['highest_traded_price_rials'] = row[15].value
d['value_KRials'] = row[16].value
d['delivery_date'] = row[17].value
d['subgroup'] = row[18].value
d['group'] = row[19].value
d['main_group'] = row[20].value
d['details'] = row[21].value
d['supplier'] = row[22].value
d['method_of_supply'] = row[23].value
d['supply_code'] = row[24].value
d['supply_type'] = row[25].value
self.datas.append(d)
def sendDate(id, txt):
if (len(txt) > 0):
splitDay = txt.split("/")
gregorian_date = jdatetime.date(int(splitDay[0]), int(splitDay[1]),
int(splitDay[2])).togregorian()
day = webdriver.find_element_by_xpath(
"/html/body/div/div/div/div/div/div/div/section[2]/form/fieldset/div/div/fieldset/div/div[1]/div["
+ str(id) + "]/span[1]/input[1]")
month = webdriver.find_element_by_xpath(
"/html/body/div/div/div/div/div/div/div/section[2]/form/fieldset/div/div/fieldset/div/div[1]/div["
+ str(id) + "]/span[1]/input[2]")
year = webdriver.find_element_by_xpath(
"/html/body/div/div/div/div/div/div/div/section[2]/form/fieldset/div/div/fieldset/div/div[1]/div["
+ str(id) + "]/span[1]/input[3]")
webdriver.execute_script(
"arguments[0].setAttribute('value', '" + str(gregorian_date.day) +
"')", day)
webdriver.execute_script(
"arguments[0].setAttribute('value', '" +
str(gregorian_date.month - 1) + "')", month)
webdriver.execute_script(
"arguments[0].setAttribute('value', '" + str(gregorian_date.year) +
"')", year)
def post(self, request, *args, **kwargs):
serialize_data = self.get_serializer(data=request.data)
if serialize_data.is_valid():
file = serialize_data.validated_data['file']
xl = pd.ExcelFile(file)
df = xl.parse(xl.sheet_names[0])
for index, row in df.iterrows():
if isinstance(row['date'], str):
date = datetime.strptime(row['date'], '%d/%m/%Y')
else:
date = row['date']
if date.year < 1900:
date = jdatetime.date(day=date.day,
month=date.month,
year=date.year).togregorian()
name = row['name']
price = row['price']
total = row['total']
try:
car = Car.objects.get(name=name)
except Car.DoesNotExist as e:
car = Car(name=name)
car.save()
car_stock = CarStock(car=car,
price=price,
total=total,
date=date)
car_stock.save()
data = {}
return responses.SuccessResponse(data, status=200).send()
else:
dev_error = serialize_data.errors
message = 'Failed to upload {}'.format(
serialize_data.data['file'].name)
return responses.ErrorResponse(message=message,
dev_error=dev_error,
status=400).send()
def mutate(self,info,id,date_jalali,time_range):
if not(time_range in ['A','B','C','D']):
raise GraphQLError("time_range is in ['A','B','C','D']")
basket = Basket.objects.get(user=info.context.user, pk=id)
jdate = date_jalali.split("-")
date = jdatetime.date(year=int(jdate[0]), month=int(jdate[1]), day=int(jdate[2])).togregorian()
date_range = [datetime.date.today() + datetime.timedelta(i) for i in range(1, 6)]
if date in date_range:
time, created = DeliveryDate.objects.get_or_create(date=date, time_range=time_range)
else:
raise GraphQLError('date bayat beyn emroz ta 5 roze ayande bashad ') ######## in vaghean nabayad raise bashe
if not(time.available):
raise GraphQLError("IN BAZE ZAMANI POR SHODE ")
if bool(basket.deliverydate) == True:
previous_delivery_date = basket.deliverydate
previous_delivery_date.capacity -= 1
previous_delivery_date.save()
basket.deliverydate = None
basket.save()
# import ipdb; ipdb.set_trace()
time, created = DeliveryDate.objects.get_or_create(date=date, time_range=time_range)
basket.deliverydate=time
basket.save()
# import ipdb; ipdb.set_trace()
time.capacity+=1
time.save()
return AddDeliveryDate(delivery_datetime=time)
def parse_date(self, date_obj):
"Take a datetime object and convert it to jalali date"
if isinstance(date_obj, datetime.datetime):
return jdatetime.date.fromgregorian(date=date_obj.date())
if isinstance(date_obj, datetime.date):
return jdatetime.date.fromgregorian(date=date_obj)
if not ansi_date_re.search(date_obj):
raise exceptions.ValidationError(self.error_messages['invalid'])
# Now that we have the date string in YYYY-MM-DD format, check to make
# sure it's a valid date.
# We could use time.strptime here and catch errors, but datetime.date
# produces much friendlier error messages.
year, month, day = map(int, date_obj.split('-'))
try:
if year > 1500:
return jdatetime.date.fromgregorian(
date=datetime.date(year, month, day))
else:
return jdatetime.date(year, month, day)
except ValueError as e:
msg = self.error_messages['invalid_date'] % _(str(e))
raise exceptions.ValidationError(msg)
def test_dates_are_not_equal_if_locales_are_different(self):
date_fa = jdatetime.date(1397, 4, 22, locale='fa_IR')
date_nl = jdatetime.date(1397, 4, 22, locale='nl_NL')
self.assertNotEqual(date_fa, date_nl)
def test_init_accepts_instance_locale(self):
date = jdatetime.date(1397, 4, 23, locale=jdatetime.FA_LOCALE)
self.assertEqual(date.strftime('%A'), u'شنبه')
def test_replace_keeps_the_locale_of_source_date(self):
date = jdatetime.date(1397, 4, 22, locale='nl_NL')
other_date = date.replace(day=20)
self.assertEqual(other_date.day, 20)
self.assertEqual(other_date.locale, 'nl_NL')
def setUp(self):
date_time = jdatetime.date(1394, 11, 25)
self.context = Context({'date_time': date_time})
def test_combine(self):
t = jdatetime.time(12, 13, 14)
d = jdatetime.date(1390, 4, 5)
dt = jdatetime.datetime(1390, 4, 5, 12, 13, 14)
self.assertEqual(True, jdatetime.datetime.combine(d, t) == dt)
def test_datetime(self):
d = jdatetime.datetime(1390, 1, 2, 12, 13, 14)
self.assertEqual(True, d.time() == jdatetime.time(12, 13, 14))
self.assertEqual(True, d.date() == jdatetime.date(1390, 1, 2))
def test_diffrent_saving(self):
jd_model = jDateModel(date="1391-01-01")
jd_model.save()
jd_model = jDateModel(date=datetime.datetime.now())
jd_model.save()
# jd_model = jDateModel()
# jd_model.save()
jd_model = jDateModel(date=jdatetime.datetime.now())
jd_model.save()
# to_python
jdt_model = jDateTimeModel(date_time="1391-01-01")
# TODO: Find the correct exceptions
# with self.assertRaises(Exception):
# jdt_model.date_time = None
jdt_model.date_time = datetime.datetime(1390, 01, 02)
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=datetime.datetime(1390, 01, 02))[0].date_time, jdt_model.date_time
)
jdt_model.date_time = jdatetime.date.today()
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=jdatetime.date.today())[0].date_time, jdt_model.date_time
)
jdt_model.date_time = datetime.date.today()
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=datetime.date.today())[0].date_time, jdt_model.date_time
)
jdt_model.date_time = datetime.date(1390, 01, 01)
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=jdatetime.date(1390, 01, 01))[0].date_time, jdt_model.date_time
)
jdt_model.date_time = "1391-01-01 12:12"
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=jdatetime.datetime(1391, 01, 01, 12, 12))[0].date_time,
jdt_model.date_time,
)
jdt_model.date_time = "1391-01-01 12:12:12"
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time=jdatetime.datetime(1391, 01, 01, 12, 12, 12))[0].date_time,
jdt_model.date_time,
)
jdt_model.date_time = "2012-01-01 12:12"
jdt_model.save()
# TODO: fixme, I'm broken ! I dunno if I ever should be exist
# self.assertEqual(jDateTimeModel.objects.filter(date_time=datetime.datetime(2012, 01, 01, 12, 12))[0].date_time, jdt_model.date_time)
self.assertEqual(
jDateTimeModel.objects.filter(date_time="2012-01-01 12:12")[0].date_time,
jdatetime.datetime(1390, 10, 11, 12, 12),
)
jdt_model.date_time = "2012-01-01"
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time="2012-01-01")[0].date_time, jdatetime.datetime(1390, 10, 11)
)
jdt_model.date_time = "2012-01-01 12:12:12"
jdt_model.save()
self.assertEqual(
jDateTimeModel.objects.filter(date_time="2012-01-01 12:12:12")[0].date_time,
jdatetime.datetime(1390, 10, 11, 12, 12, 12),
)
jdt_model.date_time = "1391-01-01 12:12:12.2222"
jdt_model.save()
self.assertEqual(jDateTimeModel.objects.filter(date_time="1391-01-01 12:12:12.2222")[0], jdt_model)
def run(command):
output = subprocess.check_output(command, shell=True)
return output.decode('UTF-8').strip()
run("wget -qO {} http://p.hiweb.ir --save-cookies={} --keep-session-cookies".format(TMP_FILE, COOKIE_FILE))
remain = run("cat {} | grep -Poh '<tr.*?</tr>' | grep 'مگابایت' | grep -o '[0-9.]*' | head -n1".format(TMP_FILE))
remain = round(float(remain) / 4000, 2)
service_days = run("cat {} | grep -Poh '<tr.*?</tr>' | grep 'روزهای باقیمانده'| grep -o '[0-9]*'".format(TMP_FILE))
service_days = int(service_days)
run("wget -qO {} http://panel.hiweb.ir/xhr/usl.php\?user\=551402\&action\=load_usl --load-cookies={}".format(TMP_FILE, COOKIE_FILE))
credit = run("cat {} | grep -Poh '<td.*?</td>' | sed '7q;d' | grep -oh '[0-9]*\/[0-9]*\/[0-9]*'".format(TMP_FILE))
d = time.strptime('13' + credit, '%Y/%m/%d')
credit_end_date = jdatetime.date(d.tm_year, d.tm_mon, d.tm_mday).togregorian()
delta = credit_end_date - date.today()
credit_days = delta.days
days = min(credit_days, service_days)
if days >= 0 and days < 3:
print("🌐 {} GB <font color='red'>in {} days</font>".format(remain, days))
else:
print("🌐 {} GB".format(remain))
print("---")
print("In {} days (service)".format(service_days))
if credit_days >= 0:
print("In {} days (credit)".format(credit_days))
def record_locale_formatted_date(record, locale):
jdatetime.set_locale(locale)
dt = jdatetime.date(1397, 3, 27)
record.append(dt.strftime('%A'))
record.append(dt.strftime('%B'))
def setUp(self):
self.today_string = "1390-5-12"
self.today = jdatetime.date(1390, 5, 12)
self.mybar = Bar(name="foo", date=self.today)
self.mybar.save()
def test_locale_property_returns_locale(self):
date = jdatetime.date(1397, 4, 22, locale='nl_NL')
self.assertEqual(date.locale, 'nl_NL')
