def update_stock_master():
"""종목 DB 갱신"""
try:
session = Session()
start_time = time.time()
stock_master = [
stock[0] for stock in session.query(종목_마스터.거래소코드).all()
]
affected_rows = 0
for stock in krx.get_stock_list():
if stock['short_code'].endswith(
'0') and stock['full_code'] not in stock_master:
session.add(
종목_마스터(stock['marketName'], stock['short_code'][1:],
stock['codeName'], stock['full_code']))
affected_rows += 1
if affected_rows > 0:
session.commit()
slack.send_message(
'BATCH:update_stock_master success {}건 업데이트'.format(
affected_rows))
execution_time = time.time() - start_time
logger.info('execution_time: {}'.format(execution_time))
logger.info('{} rows added'.format(affected_rows))
except Exception as e:
logger.exception(e)
slack.send_message('BATCH:update_stock_master fail {}'.format(e))
finally:
session.close()
class Set(Base):
__tablename__ = 'sets'
__table_args__ = (UniqueConstraint('id', sqlite_on_conflict='IGNORE'), )
session = Session()
id = Column(String, primary_key=True)
code = Column(String, unique=True)
name = Column(String, unique=True)
release_date = Column(Date, nullable=True)
card_count = Column(Integer)
set_type = Column(String)
printings = relationship('Printing', back_populates='set')
@classmethod
def from_code(cls, code):
q = cls.session.query(cls).filter(cls.code == code)
return q.first()
@classmethod
def from_scryfall(cls, data):
mapping = {'released_at': 'release_date'}
data = util.convert(data, mapping)
data['release_date'] = date.fromisoformat(data['release_date'])
col_names = [c.name for c in Set.__table__.columns]
return Set(**util.restriction(data, col_names))
def is_regular(self) -> bool:
regular_set_types = ('core', 'expansion', 'masters',
'draft_innovation')
return self.set_type in regular_set_types
def count(id):
logger.info(f'Adding task for id: {id}')
session = Session()
task = session.query(Tasks).filter_by(id=id).first()
res = Results(address=task.address, words_count=0, http_status_code=0)
try:
scrpr = Scrapper(task.address)
except:
scrpr = None
if scrpr:
err = scrpr.get_page()
if not err:
task.http_status_code, matches = scrpr.count_matches()
task.task_status = 'FINISHED'
res = Results(address=task.address,
words_count=matches,
http_status_code=task.http_status_code)
else:
print(err)
session.add(res)
session.commit()
logger.info(task)
logger.info(res)
async def callback_del_handler(callback: CallbackQuery):
queue_id = int(callback.data.split("-")[1])
session = Session()
record = session.query(QueueRecord).filter(
QueueRecord.queue_id == queue_id,
QueueRecord.user_id == callback.from_user.id).first()
if not record:
session.close()
await bot.answer_callback_query(callback.id, "You are not in the list")
return
user = get_user(session, callback.from_user)
queue = session.query(Queue).filter(Queue.id == queue_id).first()
record.remove_record()
session.commit()
text = f"{queue.title}\n\nLine:"
for record in session.query(QueueRecord).filter(
QueueRecord.queue_id == queue_id).all():
text += f"\n{record.position}. {record.user.user_name}"
await bot.answer_callback_query(callback.id, "Left the line")
await bot.edit_message_text(text,
queue.chat_id,
queue.message_id,
reply_markup=get_keyboard(queue))
session.close()
async def timer_empty_handler(message: Message):
session = Session()
chat = get_chat(session, message.chat.id)
time = chat.default_time
session.commit()
session.close()
await message.reply(f"Times: {time} minutes", reply=False)
def parse_metadata(jobid):
session = Session()
file_obj, job = session.query(File, Job).filter(Job.id == jobid).first()
job.status = 'working'
session.commit()
try:
match = re.search(r'(.+)\.([a-z0-9]+)$',
file_obj.abs_path.split('/')[-1], re.I)
filename = match.group(1)
extension = match.group(2)
file_type = magic.from_file(file_obj.abs_path)
mime_type = magic.from_file(file_obj.abs_path, mime=True)
file_obj.name = filename
file_obj.ext = extension
file_obj.file_type = file_type
file_obj.mime_type = mime_type
# TODO: Need to figure out why this status isn't getting updated even though the file_obj is and the job stauts
# is properly updating to 'working' above.
job.staus = 'complete'
print('session.dirty: {0}'.format(session.dirty))
session.commit()
except:
session.rollback()
job.status = 'failed'
session.commit()
async def create_handler(message: Message):
title = message.text[8:]
if title.replace(" ", "") == "":
await message.reply("Empty title. Use /create [text]\n", reply=False)
return
session = Session()
time = datetime.now()
chat = get_chat(session, message.chat.id)
delta = timedelta(minutes=chat.default_time)
time += delta
seconds = timedelta(time.second)
time -= seconds
queue = Queue(creator_id=message.from_user.id,
message_id=message.message_id,
pin_date=time,
title=title,
chat_id=message.chat.id)
session.add(queue)
session.commit()
session.close()
await message.reply(
f"{title}\n\nPublication time: {time.strftime('%H:%M, %d.%m.%Y')}",
reply=False)
def predict():
"""
Predicts the text label of every value in the given list of unlabeled text.
"""
try:
id_token = request.form['id_token']
uid = verify_id_token(id_token)
except KeyError:
return "id_token required", status.HTTP_400_BAD_REQUEST
except ValueError:
return "id_token unrecognized", status.HTTP_400_BAD_REQUEST
except auth.AuthError as exc:
if exc.code == 'ID_TOKEN_REVOKED':
return "id_token revoked", status.HTTP_400_BAD_REQUEST
else:
return "id_token invalid", status.HTTP_400_BAD_REQUEST
try:
unlabeled_text = json.loads(request.form['unlabeled_text'])
except KeyError:
return "unlabeled_text required", status.HTTP_400_BAD_REQUEST
except ValueError:
return "unlabeled_text unrecognized", status.HTTP_400_BAD_REQUEST
session = Session()
try:
predicted_labels = classifier.predict(session, uid,
list(unlabeled_text.values()))
session.commit()
except:
session.rollback()
raise
finally:
session.close()
Session.remove()
predictions = dict(zip(unlabeled_text.keys(), predicted_labels))
return json.dumps(predictions), status.HTTP_200_OK
def reset():
"""
Deletes all of the user's data from the database.
"""
try:
id_token = request.form['id_token']
uid = verify_id_token(id_token)
except KeyError:
return "id_token required", status.HTTP_400_BAD_REQUEST
except ValueError:
return "id_token unrecognized", status.HTTP_400_BAD_REQUEST
except auth.AuthError as exc:
if exc.code == 'ID_TOKEN_REVOKED':
return "id_token revoked", status.HTTP_400_BAD_REQUEST
else:
return "id_token invalid", status.HTTP_400_BAD_REQUEST
session = Session()
try:
dal.delete(session, uid)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
Session.remove()
return "User data deleted", status.HTTP_202_ACCEPTED
def del_user_controller(request):
user_id = int(request.get('id'))
session = Session()
for each_user in session.query(User).filter_by(id=user_id):
session.delete(each_user)
session.commit()
return make_response(request, 200, f'User id {user_id} deleted')
def GetAdsList(self, request, context):
session = Session()
ads = [
mappers.advertisement_mapper(ad)
for ad in session.query(Advertisement).all()
]
return car_sale_pb2.AdsListResponse(data=ads)
def add_user_controller(request):
name = request.get('name')
password = request.get('password')
session = Session()
session.add(User(name=name, password=password))
session.commit()
return make_response(request, 200, f'User {name} created')
def get_cost(u, v, e, prev_e):
"""
Gets the cost of graph traversal from point u to point v.
We take into account only v's cost, which is determined by what type of animal v is.
# TODO: Optimize this function if needed, currently we hit the db every time.
:param u: from point, an animal instance
:param v: to point, an animal instance
:param e:
:param prev_e:
:return: a number indicating the cost of traversal
"""
session = Session()
animal = session.query(models.Animal).get(v)
if animal.type == 'lion':
return config.LION_COST
elif animal.type == 'hippopotamus':
return config.HIPPOPOTAMUS_COST
elif animal.type == 'antelope':
return config.ANTELOPE_COST
elif animal.type == 'hyena':
return config.HYENA_COST
else:
raise ValueError('Unhandled animal type: {}'.format(animal.type))
def __init__(self, parent=None):
super(QtWidgets.QDialog, self).__init__(parent)
self.setupUi(self)
self.session = Session()
self.encounterDate.setDate(datetime.now())
self.buttonBox.clicked.connect(self.clickapply)
def get_announcements(course, url):
'''Gets all new announcements
Returns a list of all new announcements.
'''
session = Session()
try:
r = s.get('https://edux.pjwstk.edu.pl/Announcements.aspx', stream=True)
r.raise_for_status()
new_announcements = extract_announcements(r.content)
# All pairs of (timestamp, message) are saved to db
# if they arent there already
for (timestamp, message) in new_announcements:
announcement = session.query(Announcement). \
filter_by(course=course,
created_at=timestamp,
message=message). \
first()
if announcement is None:
# This is what we care about
announcement = Announcement(
course=course,
created_at=timestamp,
message=message)
session.add(announcement)
print u'New announcement at {0}'.format(timestamp)
yield (timestamp, message)
session.commit()
except Exception:
session.rollback()
raise
finally:
session.close()
def stats():
"""
Get a list of all the given user's stats.
"""
try:
id_token = request.form['id_token']
uid = verify_id_token(id_token)
except KeyError:
return "id_token required", status.HTTP_400_BAD_REQUEST
except ValueError:
return "id_token unrecognized", status.HTTP_400_BAD_REQUEST
except auth.AuthError as exc:
if exc.code == 'ID_TOKEN_REVOKED':
return "id_token revoked", status.HTTP_400_BAD_REQUEST
else:
return "id_token invalid", status.HTTP_400_BAD_REQUEST
session = Session()
try:
stats = dal.get_stats(session, uid)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
Session.remove()
return json.dumps(stats), status.HTTP_200_OK
def test_request_new_order(fresh_database):
with app.test_client() as test_client:
with requests_mock.Mocker(real_http=True) as m:
m.get(re.compile("/manage/health"), text='')
m.post(re.compile("/api/v1/warehouse"),
json={
"orderItemUid": "item-1",
"orderUid": "1-1-1",
"model": "Lego 8880",
"size": "L"
})
m.post(re.compile("/api/v1/warranty/item-1"))
response = test_client.post("/api/v1/orders/1",
json={
"orderUid": "1-1-1",
"model": "Lego 8880",
"size": "L"
})
assert response.status == "200 OK"
assert response.json["orderUid"]
with Session() as s:
order = (s.query(Order).filter(
Order.order_uid == response.json["orderUid"]).one_or_none())
assert order
assert order.order_uid == response.json["orderUid"]
def populate():
"""
Populates the database for the given user with sample data.
"""
try:
id_token = request.form['id_token']
uid = verify_id_token(id_token)
except KeyError:
return "id_token required", status.HTTP_400_BAD_REQUEST
except ValueError:
return "id_token unrecognized", status.HTTP_400_BAD_REQUEST
except auth.AuthError as exc:
if exc.code == 'ID_TOKEN_REVOKED':
return "id_token revoked", status.HTTP_400_BAD_REQUEST
else:
return "id_token invalid", status.HTTP_400_BAD_REQUEST
session = Session()
try:
dal.populate(session, uid)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
Session.remove()
classifier.fit(uid)
return "Sample data added for user", status.HTTP_202_ACCEPTED
async def timer_handler(message: Message):
def check_int(number):
return bool(re.match("^[-+]?[0-9]+$", number))
arg = message.text.split(' ')
if len(arg) < 2 or arg[1].replace(' ',
'') == '' or check_int(arg[1]) is False:
await message.reply(
"Incorrect input\n"
"/timer [mins], mins >= 0, mins <= sys.maxint",
reply=False)
return
if sys.maxsize <= int(arg[1]):
await message.reply("Number should not be larger than int",
reply=False)
return
if int(arg[1]) < 0:
await message.reply("Number should not be less than 0", reply=False)
return
session = Session()
chat = get_chat(session, message.chat.id)
chat.default_time = int(arg[1])
session.commit()
session.close()
await message.reply(f"Timer is set to {int(arg[1])} minutes", reply=False)
def delete(self):
db_session = Session()
json_data = request.get_json()
if not json_data:
return {'message': 'No input data provided'}, 400
try:
data, errors = note_schema.load(json_data)
if not data.get('id'):
raise ValidationError('Data not provided')
except ValidationError as err:
db_session.close()
return err.messages, 422
try:
note = db_session.query(Note).filter(
Note.id == data.get('id')).first()
if note is None:
raise ValidationError('Note is not found')
except ValidationError as err:
db_session.close()
return err.messages, 404
db_session.delete(note)
db_session.commit()
db_session.close()
return {"result": "Note successfully deleted"}
async def callback_add_handler(callback: CallbackQuery):
queue_id = int(callback.data.split("-")[1])
session = Session()
record = session.query(QueueRecord).filter(
QueueRecord.queue_id == queue_id,
QueueRecord.user_id == callback.from_user.id).first()
if record:
session.close()
await bot.answer_callback_query(callback.id,
"You are already in the list")
return
queue = session.query(Queue).filter(Queue.id == queue_id).first()
position = len(
session.query(QueueRecord).filter(
QueueRecord.queue_id == queue_id).all()) + 1
user = get_user(session, callback.from_user)
session.add(
QueueRecord(queue_id=queue_id,
user_id=callback.from_user.id,
position=position))
session.commit()
text = f"{queue.title}\n\nLine:"
for record in session.query(QueueRecord).filter(
QueueRecord.queue_id == queue_id).all():
text += f"\n{record.position}. {record.user.user_name}"
await bot.answer_callback_query(callback.id, "Entered")
await bot.edit_message_text(text,
queue.chat_id,
queue.message_id,
reply_markup=get_keyboard(queue))
session.close()
def post(self):
json_data = request.get_json()
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
try:
data, errors = note_schema.load(json_data)
if not data.get('title') or not data.get('text'):
raise ValidationError('Data not provided')
except ValidationError as err:
return err.messages, 422
db_session = Session()
# Create new note
note = Note(id=str(uuid.uuid4()),
title=data.get('title'),
text=data.get('text'),
date_create=int(time.time()),
date_update=int(time.time()))
db_session.add(note)
db_session.commit()
result, errors = note_schema.dump(
db_session.query(Note).filter(Note.id == note.id).first())
db_session.close()
return result, 201
async def check_queue():
session = Session()
# queues = session.query(Queue).filter(Queue.is_pinned is False, Queue.pin_date < datetime.now()).all()
queues = session.query(Queue).filter(
Queue.is_pinned == False, Queue.pin_date < datetime.now()).all()
for queue in queues:
try:
chat = get_chat(session, queue.chat_id)
message = await bot.send_message(queue.chat_id,
f"{queue.title}\n\nLine:",
reply_markup=get_keyboard(queue))
try:
if chat.pin:
await bot.pin_chat_message(queue.chat_id,
message.message_id)
except Exception as e:
await bot.send_message(queue.chat_id,
"Not enough rights for the pin")
queue.is_pinned = True
queue.message_id = message.message_id
session.commit()
except Exception as e:
print(e)
def print_clients():
session = Session()
# посмотрим что уже есть в базе данных
for instance in session.query(Client).order_by(Client.id):
print(instance)
def get(cls, set_code: str, number: str):
session = Session()
q = session.query(cls).filter(cls.set == set_code)\
.filter(cls.collector_number == number)
printing_obj = q.first()
session.close()
return printing_obj
def print_history():
session = Session()
# посмотрим что уже есть в базе данных
for instance in session.query(ClientHistory).order_by(ClientHistory.id):
print(instance)
def add_user():
try:
# generate database schema
Base.metadata.create_all(engine)
# create a new session
session = Session()
name = request.args.get('name')
age = request.args.get('age')
dni = request.args.get('dni')
ctry = request.args.get('country')
# create an employee
user = User(name, age, dni, ctry)
# persists data
session.add(user)
# commit and close session
session.commit()
session.close()
return 'User added'
except Exception as error:
return str(error)
def fit_process(uid):
# create a new temporary model file
fd, path = tempfile.mkstemp()
# close the temporary model file descriptor as we don't need it
os.close(fd)
# give this process a dedicated session
session = Session()
try:
ftclassifier.fit(session, uid, path)
# sgdclassifier.fit(session, uid, path)
# persist the model to the database
with open(path, 'rb') as f:
classifier = f.read()
dal.update_classifier(session, uid, classifier)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
Session.remove()
# delete the temporary model file
os.unlink(path)
def toggle_task(update: Update, context: CallbackContext) -> None:
user_id = update.callback_query.from_user.id
callback_query = update.callback_query
message_keyboard_markup = callback_query.message.reply_markup.inline_keyboard
event, task_id = callback_query.data.split(":")
for i in range(len(message_keyboard_markup)):
if message_keyboard_markup[i][0].callback_data == callback_query.data:
session = Session()
user_task = session.query(UserTask)\
.filter(UserTask.id == task_id)\
.filter(UserTask.tg_user_id == user_id)\
.first()
if user_task is not None:
user_task.completed = not user_task.completed
message_keyboard_markup[i][0] = \
InlineKeyboardButton(format.task(user_task), callback_data=f"UserTask_toggle_click:{user_task.id}")
session.commit()
else:
del message_keyboard_markup[i]
session.close()
break
context.bot.edit_message_reply_markup(
chat_id=update.effective_chat.id,
message_id=update.callback_query.message.message_id,
reply_markup=InlineKeyboardMarkup(message_keyboard_markup))
update.callback_query.answer()
def process_program(self, id: int) -> Optional[str]:
session = Session()
program = session.query(Program).filter(Program.id == id).one_or_none()
if not program:
return
state_db = Mongo(STATE_COLL)
parameters = program.parameters
rating = 0
for param in parameters:
rating += param['weight'] * int(
param['value']) # TODO: type processing
program.rating = int(rating) # round score
session.add(program)
session.commit()
state_db.update_one({'key': PROCESS_KEY}, {'$pull': {'planned': id}})
stats_db = Mongo(STATS_COLL)
return f'New rating for program <{id}>: {rating}'
