def list_event_by_date(request):
data = request.data
if not ('month' in data or 'year' in data):
return JsonResponse(status=400, data={'message': 'bad request'})
j_month = data['month']
j_year = data['year']
start_date = JalaliDate(j_year, j_month, 1)
end_date = JalaliDate(j_year, j_month, start_date.daysinmonth)
events = []
for e in Event.objects.filter(date__lte=end_date.todate(), date__gte=start_date.todate()):
if e.user_event and not e.admin_approved:
continue
events.append(EventSerializer(e).data)
return JsonResponse(status=200, data={'results': events})
def validate_date(input_date):
try:
input_date = arabic_to_eng_number(input_date)
date = JalaliDate().strptime(input_date, "%Y%m%d")
if date < JalaliDate().today():
message = TextMessage(ReadyText.time_is_past)
return False, message
date = date.todate()
return date, None
except:
message = TextMessage(ReadyText.wrong_format)
return False, message
def test_instantiate(self):
jdate = JalaliDate(1376, 5, 23)
self.assertFalse(jdate is None)
self.assertEqual(JalaliDate(jdate.todate()), jdate)
self.assertEqual(JalaliDate(jdate), jdate)
self.assertEqual(JalaliDate(julian_day=2450674), jdate)
self.assertRaises(ValueError, JalaliDate, MAXYEAR + 1, 5, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 13, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 12, 30)
def test_algorithm(self):
min = date(623, 1, 1)
max_days = 5000
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDate(dt)
# print('Processing day: %s' % jd)
dt2 = jd.todate()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_algorithm(self):
min = date(623, 1, 1)
max_days = 5000
days = 0
while True:
dt = min + timedelta(days=days)
jd = JalaliDate(dt)
# print('Processing day: %s' % jd)
dt2 = jd.todate()
self.assertEqual(dt, dt2)
days += 1
if days > max_days:
break
def test_instantiate(self):
jdate = JalaliDate(1376, 5, 23)
self.assertFalse(jdate is None)
self.assertEqual(JalaliDate(jdate.todate()), jdate)
self.assertEqual(JalaliDate(jdate), jdate)
self.assertEqual(JalaliDate(julian_day=2450674), jdate)
self.assertRaises(ValueError, JalaliDate, MAXYEAR + 1, 5, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 13, 23)
self.assertRaises(ValueError, JalaliDate, MAXYEAR, 12, 30)
def test_operators(self):
invalid_object = dict(a=2)
d1 = JalaliDate(1361, 6, 15)
d2 = JalaliDate(1361, 6, 16)
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.todate())
self.assertTrue(d1 < d2)
self.assertTrue(d1 <= d1.copy())
self.assertFalse(d1 > d2)
self.assertTrue(d1 >= d1.copy())
def test_operators(self):
invalid_object = dict(a=2)
d1 = JalaliDate(1361, 6, 15)
d2 = JalaliDate(1361, 6, 16)
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.todate())
self.assertTrue(d1 < d2)
self.assertTrue(d1 <= d1.copy())
self.assertFalse(d1 > d2)
self.assertTrue(d1 >= d1.copy())
async def j2g(y: int, m: int, d: int, request: Request, iso: bool = False):
arg_check(("y", "m", "d", "iso"), request.query_params.keys())
if y not in range(*j_year_range):
raise HTTPException(status_code=404)
try:
j = JalaliDate(year=y, month=m, day=d)
g = j.todate()
if iso:
return {"g": g.isoformat()}
return {
"g": {
"y": g.year,
"m": g.month,
"d": g.day
},
}
except Exception:
raise HTTPException(status_code=404)
def add_reminder_to_db(reminder):
print(reminder)
reminder_obj = Reminder(reminder.get(Attr.peer_id), reminder.get(Attr.peer_access_hash),
reminder.get(Attr.type), reminder.get(Attr.card_number),
reminder.get(Attr.money_amount),
reminder.get(Attr.text), reminder.get(Attr.file_id),
reminder.get(Attr.file_access_hash),
reminder.get(Attr.file_size))
session.add(reminder_obj)
date = reminder.get(Attr.date)
time = reminder.get(Attr.time)
print(type(date), date)
print(type(time), time)
remind_datetime = datetime.datetime.combine(date, time)
if reminder.get(Attr.periodic_type) != ReadyText.monthly:
time_delta = time_delta_func(reminder.get(Attr.periodic_type))
for i in range(reminder[Attr.iterate_number] + 1):
message = Message(reminder_obj, sending_time=(remind_datetime + time_delta * i))
session.add(message)
else:
time_delta = time_delta_func(reminder.get(Attr.periodic_type))
for i in range(reminder[Attr.iterate_number] + 1):
s_date = remind_datetime + time_delta * i
day = remind_datetime.day
sending_time = None
is_valid_date = False
while is_valid_date is False:
is_valid_date = True
try:
sending_time = JalaliDate(s_date.year, s_date.month, day)
except ValueError:
is_valid_date = False
day -= 1
message = Message(reminder_obj, sending_time=sending_time.todate())
session.add(message)
session.commit()
def run(self):
logger.info("run-triggered")
if os.path.exists(f'{self.excel_location}/crawlstat'):
with open(f'{self.excel_location}/crawlstat', 'r') as statfile:
lines = statfile.readlines()
year, month, day = lines[3].split("-")
crawl_start_date = JalaliDate(year, month, day)
logger.info(
f"statefile: {str(crawl_start_date)} {year}-{month}-{day}")
else:
year, month, day = self.START_DATE.split("-")
crawl_start_date = JalaliDate(year, month, day)
self.dm = DataModel()
self.dm.restore_from_pystore()
logger.info("restore done")
if len(self.dm.df) == 0:
conv_start_date = self.START_DATE
else:
index_list = list(set(self.dm.df.index.get_level_values("date")))
index_list.sort()
last_ind = index_list[-1]
conv_start_date = f'''{last_ind.year}-{last_ind.month}-{last_ind.day} '''
st_year, st_month, st_day = conv_start_date.split("-")
st = JalaliDate(st_year, st_month, st_day) + timedelta(days=1)
logger.info(f"start date: {str(st)}")
while st <= crawl_start_date:
excel_file = f'{self.excel_location}/{st.year}-{st.month}-{st.day}.xlsx'
logger.debug(f'excel_file: {excel_file}')
if os.path.isfile(excel_file):
logger.debug(f'found: {st.year}-{st.month}-{st.day}')
self.q_xls.put([f'{st.year}-{st.month}-{st.day}'])
st = st + timedelta(days=1)
logger.info("preparing done")
for i in range(self.NUM_CONV_THREAD):
self.conv_workers.append(
multiprocessing.Process(
target=self.converter.converting_thread,
args=(f'Thread-{i}', self.q_xls, self.q_dfs,
self.q_errors)))
self.conv_workers[i].start()
logger.info("df conv started")
models = [
SignalUSD(),
SignalPound(),
SignalYuan(),
SignalEuro(),
SignalYen100(),
SignalRub(),
SignalDeram(),
SignalNGas(),
SignalBrent(),
SignalGasOil(),
SignalPetrol(),
SignalWTI(),
SignalOnsSilver(),
SignalOnsPalladium(),
SignalOnsPlatinum(),
SignalOnsGold(),
SignalElementCopper(),
SignalElementZinc(),
SignalElementAluminum(),
SignalElementLead(),
SignalEthereum(),
SignalBitcoin(),
SignalXRP(),
StockMeta(),
StockShareHolder(),
]
self.data_model_updater_workers.append(
multiprocessing.Process(target=self.data_models_updater,
args=(f'Thread-singal-data', models)))
self.data_model_updater_workers.append(
multiprocessing.Process(target=self.data_models_updater,
args=(f'Thread-client-data',
[StockClientsData(use_proxy=True)])))
self.data_model_updater_workers.append(
multiprocessing.Process(target=self.data_models_updater,
args=(f'Thread-data-model-tgju', [
GeneralTGJUData(name, use_proxy=True)
for name in GeneralTGJUData.DATA_TYPES
])))
for worker in self.data_model_updater_workers:
worker.start()
logger.info(f'done running data model updater')
self.crawl_thread = multiprocessing.Process(
target=self.crawler.crawling_thread,
args=("Thread-crawl", crawl_start_date.todate(), self.q_xls))
time.sleep(60)
self.crawl_thread.start()
logger.info("df crawler started")
all_dfs = []
while True:
dftmp, nametmp = self.q_dfs.get()
logger.info(f'got a df: {nametmp}')
year, month, day = nametmp.split("-")
date = JalaliDate(year, month, day).todate()
yearlist = np.full(len(dftmp), year).tolist()
monthlist = np.full(len(dftmp), month).tolist()
daylist = np.full(len(dftmp), day).tolist()
datelist = np.full(len(dftmp), date).tolist()
dftmp["year"] = yearlist
dftmp["month"] = monthlist
dftmp["day"] = daylist
dftmp["date"] = datelist
dftmp["date"] = pd.to_datetime(dftmp["date"])
dftmp["symbol"] = dftmp.symbol.apply(str)
dftmp["name"] = dftmp["name"].apply(str)
dftmp = dftmp.astype({"year": int, "month": int, "day": int})
dftmp = dftmp.set_index(['symbol', 'date'])
all_dfs.append(dftmp)
self.q_dfs.task_done()
logger.debug(
f'added df: {nametmp}---{str(date)} with len({len(dftmp)}) all:{len(self.dm.df)}',
feature="f-strings")
logger.debug(f'df left: {self.q_dfs.qsize()}', feature="f-strings")
if self.q_dfs.empty() or self.q_dfs.qsize() == 0:
try:
dm_new = DataModel()
dm_new.read_from_df(pd.concat(all_dfs).sort_index())
self.dm.df = self.dm.df.append(dm_new.df)
all_dfs = []
self.dm.update_df_extensions()
logger.info(f'storing in pystore')
self.dm.store_in_pystore()
logger.info(f'stored in pystore')
self.dm.save_to_csvs()
logger.info(f'stored in file')
except:
logger.exception(f'cant save df')
def test_to_from_date(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = JalaliDate.from_date(jdate.todate())
self.assertEqual(jdate, jdate2)
from khayyam import JalaliDate
import khayyam_api._info as info
from khayyam_api.main import app
launch_date_j = JalaliDate(1399, 2, 18)
launch_date_g = launch_date_j.todate()
about_khayyam_api = {
"name":
info.__project_name__,
"version":
info.__version__,
"description":
info.__description__,
"repo":
info.__repo__,
"live_since":
f"{launch_date_j.isoformat()} ({launch_date_g.isoformat()})",
"author": {
"name": info.__author__,
"contact": {
"email": info.__email__,
"linkedin": info.__linkedin__
},
},
"how_to_use":
app.docs_url,
"routes":
tuple(app.openapi()["paths"]),
"license":
def format_date(date):
year, month, day = date.split('/')
jdate = JalaliDate(year=year, month=month, day=day)
return jdate.todate()
def test_to_from_date(self):
jdate = JalaliDate(self.leap_year, 12, 23)
jdate2 = JalaliDate(jdate.todate())
self.assertEqual(jdate, jdate2)
