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 get(self, symbol, start="", end=""):
tmpdf = self.df.loc[symbol].copy()
if start == "":
start = tmpdf.index[0]
else:
s_date = start.split("-")
start = JalaliDate(s_date[0], s_date[1], s_date[2]).todate()
if end == "":
end = tmpdf.index[-1]
else:
e_date = end.split("-")
end = JalaliDate(e_date[0], e_date[1], e_date[2]).todate()
return tmpdf.loc[start:end].copy()
def test_locale_date(self):
"""
Testing:
%x Locale’s appropriate date representation.
"""
self.assertEqual(
JalaliDate(1361, 6, 15).strftime('%x'), u'دوشنبه ۱۵ شهریور ۱۳۶۱')
self.assertEqual(JalaliDate().strftime('%x'), u'جمعه ۱ فروردین ۱')
self.assertEqual(JalaliDate.strptime(u'جمعه ۱ فروردین ۱', '%x'),
JalaliDate.min)
self.assertEqual(
JalaliDate(1375, 1, 31).strftime('%x'), u'جمعه ۳۱ فروردین ۱۳۷۵')
self.assertEqual(JalaliDate.strptime(u'جمعه ۳۱ فروردین ۱۳۷۵%', '%x%%'),
JalaliDate(1375, 1, 31))
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 makeMasterTable(all_dfs, all_df_names, chunkSize):
for index, df in enumerate(all_dfs):
year, month, day = all_df_names[index].split("-")
date = JalaliDate(year, month, day).todate()
yearlist = np.full(len(df), year).tolist()
monthlist = np.full(len(df), month).tolist()
daylist = np.full(len(df), day).tolist()
datelist = np.full(len(df), date).tolist()
df["year"] = yearlist
df["month"] = monthlist
df["day"] = daylist
df["date"] = datelist
xl = pd.concat(all_dfs, keys=all_df_names, ignore_index=True)
xl.columns = HEADER_extra
xl = xl.astype({"year": int, "month": int, "day": int})
xl['date'] = pd.to_datetime(xl['date'])
print(xl.dtypes)
xl.sort_values(by=['date'], inplace=True)
xl.reset_index(drop=True, inplace=True)
i = 0
while i*chunkSize < len(xl):
if (i+1)*chunkSize < len(xl):
df_i = xl.iloc[i*chunkSize:(i+1)*chunkSize]
else:
df_i = xl.iloc[i*chunkSize:]
df_i.to_csv('{xcelLocation}master{i}.csv'.format(i=i, xcelLocation=xcelLocation),
header=HEADER_extra, encoding='utf-8', index=False)
i += 1
return xl
def Book(request):
if (request.method == 'POST'):
date = request.POST.get('date', '')
sans_id = request.POST.get('sans_id', '')
description = request.POST.get('description', '')
service = Services.objects.get(
id=request.POST.get('service_id', ''))
day = request.POST.get('day', '')
date_splited = date.split('/')
saturday = JalaliDate(int(date_splited[0]), int(date_splited[1]),
int(date_splited[2]))
targetday = saturday + timedelta(days=int(day))
targetday = targetday.__str__().replace('-', '/')
print(targetday)
sans = Sans.objects.get(pk=sans_id)
check_obj = Reserves.objects.filter(date=targetday,
service_id=service.id,
sans_id=sans_id)
print(check_obj)
if (len(check_obj) == 0):
Reserves.objects.create(user=user,
sans=sans,
date=targetday,
description=description,
service_id=service.id)
mybusiness = Business.objects.filter(id=service.business.id)
history = Reserves.objects.filter(
user_id=user.id).order_by('date')
return render(request, 'AccountPage.html', {
'user': user,
'historys': history,
'mybusiness': mybusiness
})
else:
return ServicePageController.Render(request, service.id)
def add_order_admin(s):
world.order_price = []
world.success = []
for s in guess_types(s.hashes):
cur = (datetime.now() + timedelta(days=1))
s['dispatch_date'] = str(JalaliDate(cur.date()))
s['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(s['dispatch_date'])
logger.info(s['dispatch_hour'])
r = requests.post(f"{config.api_uri}/caravan/add_order",
json=s,
headers={
"APIToken": config.admin.api_token,
"USERToken": config.admin.user_token
})
logger.error(r.text)
world.res = r.json()
time.sleep(1)
logger.info("Response: %s", str(world.res).encode('utf-8'))
world.status = r.status_code
world.order_price.append(world.res['order_data']['price'])
logger.info("order price isss %s", world.order_price)
world.success.append(world.res["success_flag"])
logger.info("world order price is : %s", world.order_price)
logger.info("the worldsuccess is : %s", world.res["success_flag"])
def add_order(s):
world.list_of_status = []
for s in guess_types(s.hashes):
cur = (datetime.now() + timedelta(days=1))
s['dispatch_date'] = str(JalaliDate(cur.date()))
s['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(s['dispatch_date'])
logger.info(s['dispatch_hour'])
logger.info(" sssssss is : %s", s)
r = requests.post(f"{config.api_uri}/caravan/add_order/",
json=s,
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
world.res = r.json()
logger.info("Response: %s", str(world.res).encode('utf-8'))
world.status = r.status_code
world.track_code = world.res['order_data']['tracking_code']
logger.info("tracking code groups : %s", world.track_code)
logger.info(" s is : %s", s)
world.list_of_status.append(world.res['order_data']['status'])
logger.info("wwwwwwww list of status of orders is %s",
world.list_of_status)
time.sleep(1)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('time',required=True)
args = parser.parse_args()
retSum = {}
n = 1
while n < 11:
mycursor.execute("select * from gostare where id = %s ",(n,))
gostare_data = mycursor.fetchall()
mydb.commit()
query = "select * from gostare_pishraft where gostare_id = %s and malg =1"
values = (n ,)
mycursor.execute(query , values)
gostare_pishrafts = mycursor.fetchall()
df = self.opencsv()
column = df.loc[0:29 , str(gostare_data[0][0])]
ret = {}
i = 0
for gostare_pishraft in gostare_pishrafts:
ret[gostare_pishraft[5]] = {}
d = gostare_pishraft[3].split('-')
time = JalaliDate(d[0], d[1], d[2])
month = int(d[1])
while i < 29:
if month > 12 :
month = 1
d[0] = str(int(d[0])+1)
column[i]= column[i].replace(',', '')
ret[gostare_pishraft[5]][i] = [
float(gostare_pishraft[2])/float(gostare_data[0][2]) * float(column[i]),
str(JalaliDate(d[0], str(month) , d[2]))
]
i +=1
month +=1
i = 0
dataFrame = self.makeDataFrame(ret)
# print (dataFrame)
dataFrame= self.searchInDataframeToTop(dataFrame,args['time']+"-17")
sum = self.sumTheDataframe(dataFrame)
n +=1
# print (sum)
retSum[gostare_data[0][1]] = sum
return retSum
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 get(self, symbol, start="", end=""):
if start == "":
start = self.df.index[0]
else:
s_date = start.split("-")
start = JalaliDate(s_date[0], s_date[1], s_date[2]).todate()
if end == "":
end = self.df.index[-1]
else:
e_date = end.split("-")
end = JalaliDate(e_date[0], e_date[1], e_date[2]).todate()
tmpdf = self.df.loc[self.df["symbol"] == symbol].copy()
if not self.__is_scaled.get(symbol, False):
logger.debug(f'symbol is not scaled: {symbol}')
tmpdf = adjust_and_log(tmpdf)
self.df.loc[self.df["symbol"] == symbol] = tmpdf
self.__is_scaled[symbol] = True
return tmpdf.loc[start:end]
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 add_order(_):
cur = (datetime.now() + timedelta(days=1))
world.shamsi_date = str(JalaliDate(cur.date()))
world.shamsi_hour = cur.time().strftime('%H:%M')
logger.info("Shamsi date is: %s", world.shamsi_date)
logger.info("Shamsi hour is: %s", world.shamsi_hour)
logger.info("token is : %s", world.token)
r = requests.post(f"{config.api_uri}/caravan/add_order",
json={
"weight": 5.0,
"price": 150000,
"source_city": "تهران",
"destination_city": "ساری",
"sender_phone": "09965555555",
"receiver_phone": "02144411306",
"source_address": "خیابان اول کوچه دوم",
"destination_address": " میدون دست چپ",
"dispatch_date": str(world.shamsi_date),
"vehicle_type": "joft",
"load_type": "بار صنعتی",
"vehicle_options": "joft:hichkodam",
"dispatch_hour": str(world.shamsi_hour),
"load_value": 10000000,
"description": "بار تست جزییات",
"sender_name": "علی",
"receiver_name": "اصغری",
"payment_type": "sender",
"sender_company": "سانا",
"receiver_company": "سانا گستر",
"package_options": "falleh",
"length": 0.0,
"width": 1.0,
"height": 1.0,
"baarnameh": "yes",
"unload_option": "day",
"sender_mobile_phone": "09022012056",
"announce_type": "mydrivers",
"source_region_id": "22",
"address_id_source": "1069",
"address_id_destination": "1070",
"destination_region_id": "16",
"surplus_costs": "3000.0"
},
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
world.status = r.status_code
print(world.status)
world.res = r.json()
world.status_detail = r.status_code
world.order_code = world.res["order_data"]["tracking_code"]
logger.warn("order code is : %s", world.order_code)
world.dispatch_date_ms = calculate_ms(cur.date(), REFERENCE_DATE_DATE)
def get_dates(self):
"""Get dates between date_from and date_to"""
if self.date_from and self.date_to:
date_from = JalaliDate(int(self.date_from[:4]),
int(self.date_from[4:6]),
int(self.date_from[6:]))
date_to = JalaliDate(int(self.date_to[:4]), int(self.date_to[4:6]),
int(self.date_to[6:]))
date_counter = date_from
dates = []
while date_counter <= date_to:
dates.append(date_counter)
date_counter += timedelta(days=1)
return dates
else:
# Get yesterday persian date
now = timezone.make_aware(datetime.now(),
timezone.get_default_timezone())
yesterday = JalaliDate(now) - timedelta(days=1)
return [yesterday]
def clean(self):
value = self.data['date']
if len(value) > 0:
j_year = value.split('-')[0]
j_month = value.split('-')[1]
j_day = value.split('-')[2]
self.cleaned_data['date'] = JalaliDate(year=j_year,
month=j_month,
day=j_day).todate()
return self.cleaned_data
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('gostare_id', required=True)
args = parser.parse_args()
mycursor.execute("select * from gostare where id = %s ",
(args['gostare_id'], ))
gostare_data = mycursor.fetchall()
mydb.commit()
query = "select * from gostare_pishraft where gostare_id = %s and malg =1"
values = (args['gostare_id'], )
mycursor.execute(query, values)
gostare_pishrafts = mycursor.fetchall()
df = self.opencsv()
column = df.loc[0:29, str(gostare_data[0][2]) + "%"]
ret = {}
i = 0
for gostare_pishraft in gostare_pishrafts:
ret[gostare_pishraft[5]] = {}
d = gostare_pishraft[3].split('-')
time = JalaliDate(d[0], d[1], d[2])
month = int(d[1])
while i < 29:
if month > 12:
month = 1
d[0] = str(int(d[0]) + 1)
column[i] = column[i].replace(',', '')
ret[gostare_pishraft[5]][i] = [
float(gostare_pishraft[2]) / float(gostare_data[0][2]) *
float(column[i]),
str(JalaliDate(d[0], str(month), d[2]))
]
i += 1
month += 1
i = 0
dataFrame = self.makeDataFrame(ret)
print(dataFrame)
# self.sumTheDataframe(dataFrame)
return json.loads(dataFrame.to_json())
def convert_to_jalali(jalali_date, format='%A %D %B %N'):
"""
gets input from get_date function
:param jalali_date: splits the date to 3 variables y=year,m=month,d=day.
:param format: the way to show date in jalali
:return: persian format of the date
"""
from khayyam import JalaliDate
if check_dependencies():
from khayyam import JalaliDate
y, m, d = jalali_date
return JalaliDate(year=y, month=m, day=d).strftime(format)
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 crawl(self, start_date, end_date, q_xls):
now = start_date
while now <= end_date:
jalaldate = JalaliDate(now)
year = jalaldate.year
month = jalaldate.month
day = jalaldate.day
if jalaldate.weekday() < 5 and not Path(
f'{self.excel_location}/{year}-{month}-{day}.xlsx'
).is_file():
self.fetch(year=year, month=month, day=day)
q_xls.put([f'{year}-{month}-{day}'])
time.sleep(10)
now = now + timedelta(days=1)
def extract_data(invoice):
data = {
'base_url': DEFAULT_URL,
'order_id': invoice.number,
'address': DEFAULT_ADDRESS,
'date': rtl(JalaliDate(invoice.date).strftime('%Y/%m/%d')),
'pay_description': invoice.description,
'customer': invoice.customer,
'total_price': invoice.total_price,
'items': len(invoice.entities),
'details': invoice.entities,
'discount': invoice.total_discount,
'payable': invoice.payable_price
}
return data
def validate_time(input_time, input_date):
try:
time_format = '%H:%M'
time = datetime.datetime.strptime(input_time, time_format)
time = time.time().strftime(time_format)
now_time = datetime.datetime.now().strftime(time_format)
if input_date == JalaliDate().today() and time <= now_time:
message = TextMessage(ReadyText.time_is_past)
return False, message
time = datetime.datetime.strptime(time, time_format)
time = time.time()
return time, None
except:
message = TextMessage(ReadyText.wrong_format)
return False, message
def test_incremental():
ldd = None
ljd = None
gdt = date(622, 4, 3)
delta = timedelta(days=1)
while ldd != (MAXYEAR, 1, 1):
gdt = gdt + delta
jdt = JalaliDate(gdt)
ndd = jalali_to_dilami(jdt.year, jdt.month, jdt.day)
njd = dilami_to_jalali(*ndd)
assert ndd != ldd
assert njd != ljd
ldd = ndd
ljd = njd
assert ldd == (MAXYEAR, 1, 1)
def update_data(self):
r = requests.post(self.url, json=self.request_json)
data = r.json()
datas = []
for d in data:
date = str(d["time"])
date = JalaliDate(date[:4], date[4:6], date[6:8]).todate()
datas.append({"date": date, "price": d["close"]})
dftmp = pd.DataFrame(datas, columns=["date", "price"])
dftmp["date"] = pd.to_datetime(dftmp["date"])
dftmp = dftmp.astype({"price": np.float64})
dftmp.set_index("date", inplace=True)
self.df = pd.concat([self.df, dftmp], axis=0)
self.df = self.df.loc[~self.df.index.duplicated(keep='last')]
def post_parser(self, ctx, formatter):
_dayofyear = ctx['dayofyear']
if 'year' not in ctx:
ctx['year'] = 1
if 'month' in ctx:
del ctx['month']
if 'day' in ctx:
del ctx['day']
max_days = get_days_in_jalali_year(ctx['year'])
if _dayofyear > max_days:
raise ValueError(
'Invalid dayofyear: %.3d for year %.4d. Valid values are: 1-%s'
% (_dayofyear, ctx['year'], max_days))
from khayyam import JalaliDate
d = JalaliDate(year=ctx['year']) + timedelta(days=_dayofyear - 1)
ctx.update(dict(month=d.month, day=d.day))
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_order(m):
if world.description == "ویرایش سفارش":
for m in guess_types(m.hashes):
cur = (datetime.now() + timedelta(days=2))
m['dispatch_date'] = str(JalaliDate(cur.date()))
m['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(m['dispatch_date'])
logger.info(m['dispatch_hour'])
m['order_code'] = world.new_code
world.list_2 = m
logger.info("mmm: %s", world.list_2)
world.description_check = m["description"]
logger.info("description check after modifying is : %s",
world.description_check)
p = requests.put(f"{config.api_uri}/caravan/modify_order",
json=m,
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
logger.error(p.text)
world.response_for_edit = p.json()
time.sleep(0.5)
logger.info("Response after edit is: %s", world.response_for_edit)
print(str(world.response_for_edit))
world.status = p.status_code
world.order_codes = world.response_for_edit['order_data'][
'tracking_code']
logger.info("world order code is %s: ", world.order_codes)
else:
# assert not hasattr(world, 'list_2')
pass
def test_week(self):
"""
Testing:
%a Locale’s abbreviated weekday name.
%A Locale’s full weekday name.
%e ASCII Locale’s abbreviated weekday name.
%E ASCII Locale’s full weekday name.
%T ASCII English full weekday name.
%w Weekday as a decimal number [0(Saturday), 6(Friday)].
%W Week number of the year (SATURDAY as the first day of the week) as a decimal number [00, 53].
All days in a new year preceding the first Monday are considered to be in week 0.
%U Week number of the year (Sunday as the first day of the week) as a decimal number [00, 53].
All days in a new year preceding the first Sunday are considered to be in week 0.
"""
d1 = JalaliDate(1361, 6, 15)
self.assertEqual(d1.strftime('%a'), u'د')
self.assertEqual(d1.strftime('%A'), u'دوشنبه')
self.assertEqual(d1.strftime('%e'), u'D')
self.assertEqual(d1.strftime('%E'), u'Doshanbeh')
self.assertEqual(d1.strftime('%T'), u'Monday')
self.assertEqual(d1.strftime('%w'), u'2')
self.assertEqual(d1.strftime('%W'), u'24')
for i in range(7):
self.assert_parse_and_format(JalaliDate.min + timedelta(i),
'%d %w %W %U')
self.assertEqual(
JalaliDate.strptime(
'1345 10 10 %s' % c.PERSIAN_WEEKDAY_ABBRS[i],
'%Y %m %d %a'), JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime(
'1345 10 10 %s' % c.PERSIAN_WEEKDAY_ABBRS_ASCII[i],
'%Y %m %d %e'), JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime(
'1345 10 10 %s' % c.PERSIAN_WEEKDAY_NAMES[i],
'%Y %m %d %A'), JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime(
'1345 10 10 %s' % c.PERSIAN_WEEKDAY_NAMES_ASCII[i],
'%Y %m %d %E'), JalaliDate(year=1345, month=10, day=10))
self.assertEqual(
JalaliDate.strptime(
'1345 10 10 %s' % c.ENGLISH_WEEKDAY_NAMES_ASCII[i],
'%Y %m %d %T'), JalaliDate(year=1345, month=10, day=10))
def add_order(s):
world.success = []
for s in guess_types(s.hashes):
cur = (datetime.now() + timedelta(days=1))
s['dispatch_date'] = str(JalaliDate(cur.date()))
s['dispatch_hour'] = cur.time().strftime('%H:%M')
logger.info(s['dispatch_date'])
logger.info(s['dispatch_hour'])
r = requests.post(f"{config.api_uri}/caravan/add_order",
json=s,
headers={
"APIToken": config.client.api_token,
"USERToken": world.token
})
logger.error(r.text)
world.res = r.json()
time.sleep(1)
world.status = r.status_code
world.success.append(world.res["success_flag"])
def test_strptime(self):
"""
%Z not working at all
"""
self.assertEqual(JalaliDate.strptime('1361', '%Y'), JalaliDate(1361))
self.assertEqual(JalaliDate.strptime('1361%C', '%Y%C'),
JalaliDate(1361))
self.assertEqual(JalaliDate.strptime(u'اریا1361گلگشت', u'اریا%Yگلگشت'),
JalaliDate(1361))
current_century = int(JalaliDate.today().year / 100) * 100
self.assertEqual(JalaliDate.strptime('61', '%y'),
JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime('61%C', '%y%C'),
JalaliDate(current_century + 61))
self.assertEqual(JalaliDate.strptime(u'اریا61گلگشت', u'اریا%yگلگشت'),
JalaliDate(current_century + 61))
self.assertEqual(
JalaliDate.strptime(u'جمعه 01 اردیبهشت 0001', u'%A %d %B %Y'),
JalaliDate(month=2, day=1))
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()
