def fetch_stock_data(id: int):
# Create a new db session in the background
db = SessionLocal()
# Query the db for the matching stock record using this id
stock = db.query(Stock).filter(Stock.id == id).first()
# Test that our function even works before fetching from YF
# by manually updating 'forward_pe' field
# stock.forward_pe = 10
# Get data from YF and map to our table columns
yahoo_data = yfinance.Ticker(stock.symbol)
stock.ma200 = yahoo_data.info["twoHundredDayAverage"]
stock.ma50 = yahoo_data.info["fiftyDayAverage"]
stock.price = yahoo_data.info["previousClose"]
stock.forward_pe = yahoo_data.info["forwardPE"]
stock.forward_eps = yahoo_data.info["forwardEps"]
# Some stocks don't give dividend_yield, so add conditional
if yahoo_data.info["dividendYield"] is not None:
stock.dividend_yield = yahoo_data.info["dividendYield"] * 100
# Update the record
db.add(stock)
db.commit()
async def db_session_middleware(request: Request, call_next):
# セッションを各リクエストに載せる
request.state.db = SessionLocal()
# 各関数で処理を行って結果を受け取る
response = await call_next(request)
# 結果を返す
return response
async def get_request_data(request, response, db: Session = Depends(get_db)):
#db = get_db()
db = SessionLocal()
analysis_dict = {}
print('Content-length' in request.headers)
analysis_dict['same_origin_yn'] = True#request.scope['sec-fetch-site'] if 'sec-fetch-site' in request.scope else 'same'
analysis_dict['request_size'] = request.headers['Content-length'] if 'Content-length' in request.headers else 0
analysis_dict['response_size'] = response.headers['content-length']
analysis_dict['request_type'] = request.scope['type']
analysis_dict['request_method'] = request.scope['method']
analysis_dict['content_type'] = request.headers['content_type'] if 'content_type' in request.headers else ""
analysis_dict['origin'] = request.headers['origin'] if 'origin' in request.headers else ""
analysis_dict['referer'] = request.headers['referer'] if 'referer' in request.headers else ""
analysis_dict['browser'] = 'chrome'
analysis_dict['destination_path'] = request.headers['sec-fetch-mode']
analysis_dict['device_name'] = ''
analysis_dict['ip_address'] = ''
analysis_dict['datetime'] = time.time()*1000
analysis_dict['execution_time'] = response.headers["x-Process-Time"]
# print("printing the analysis dict")
# print(analysis_dict)
crud.insert_request_response_data(db, analysis_dict)
db.close()
def get_db():
try:
db = SessionLocal()
yield db
finally:
db.close()
print('success closing db')
def get_users_repository() -> Repository:
try:
session = SessionLocal()
repo = SQLUserRepository(session)
yield repo
finally:
session.close()
def hw_remove_voo(id):
session = SessionLocal()
voo = session.query(Voo).filter_by(id=id).first()
session.delete(voo)
session.commit()
session.close()
return {"message": f"Voo {voo.id} was deleted"}
def get_repository() -> Repository:
try:
session = SessionLocal()
repo = SQLTasksListRepository(session)
yield repo
finally:
session.close()
def get_db():
db = None
try:
db = SessionLocal()
yield db
finally:
db.close()
def hw_remove_reserva(id):
session = SessionLocal()
reserva = session.query(Reserva).filter_by(id=id).first()
session.delete(reserva)
session.commit()
session.close()
return {"message": f"Reserva {reserva.id} was deleted"}
def get_database():
global db
try:
db = SessionLocal()
yield db
finally:
db.close()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
"""ای پی ای برای ایجاد کاربر
def hw_get_aeroportos_destino(origem):
session = SessionLocal()
voo_origem = (session.query(Voo).join(Aeroporto).filter(
Aeroporto.cidade == origem).all())
voo_origem_json = populate_voo_aeroporto(voo_origem)
destinos = [{"destino": elem["destino"]} for elem in voo_origem_json]
return destinos
def get_db():
try:
db = SessionLocal() # 本地会话
yield db
finally:
db.close()
print('数据库已关闭')
def get_db():
db = SessionLocal()
try:
yield db
finally:
logging.info("database is closed.....")
db.close()
def hw_remove_aeroporto(id):
session = SessionLocal()
aeroporto = session.query(Aeroporto).filter_by(id=id).first()
session.delete(aeroporto)
session.commit()
session.close()
return {"message": f"Aeroporto {aeroporto.id} was deleted"}
def send_response():
message = request.form['response']
db_wiz = SessionLocal()
global user_utter
global wizard_utter
# User and Wizard utterance from last record
user_utterance = db_wiz.query(models.UserQuery).order_by(models.UserQuery.id.desc()).first().user_request
wizard_utterance = db_wiz.query(models.UserQuery).order_by(models.UserQuery.id.desc()).first().wizard_response
if (user_utterance == user_utter and user_utterance != "Listening..." and wizard_utterance == "No Response"):
# Setting global variable
wizard_utter = message
# Updating last query wizard response
db_wiz.query(models.UserQuery).order_by(models.UserQuery.id.desc()).first().wizard_response = message
db_wiz.commit()
db_wiz.close()
user_utter="Listening..."
# project_id = os.getenv('DIALOGFLOW_PROJECT_ID')
# fulfillment_text = detect_intent_texts(project_id, "unique", "wizard says "+message, 'en')
# response_text = { "message": fulfillment_text }
# return jsonify(response_text)
return message
def get_db(): db = None try: db = SessionLocal() yield db finally:import requests db.close()
def get_db():
try:
# Will be used in a single request, and then close it once the request is finished
db = SessionLocal()
yield db
finally:
db.close()
def make_prediction(id: int):
"""
This is what make the predictions
"""
db = SessionLocal()
sms_table = db.query(FraudSMS).filter(FraudSMS.id == id).first()
model_path = "./lib/xgb_model.pkl"
xgb_model = joblib.load(model_path)
try:
raw = sms_table.sms_text
processor = custom_processor.InputTransformer()
data = processor.transform(raw)
print(data)
except ValueError:
print("Request has no data or is not a valid json object")
predictions = xgb_model.predict(data)
probability = xgb_model.predict_proba(data)
results = dict()
sms_table.probability = list(probability)[0][1]
# sms_table.prediction = list(predictions)[0]
db.add(sms_table)
db.commit()
async def login(user:User_model):
db = SessionLocal()
user_vals = db.query(User).filter(User.username==user.username).first()
if bcrypt.checkpw(user.password.encode(), user_vals.hashed_pword):
return {"ok":"signed in"}
else:
return {"error":"incorrect password"}
def get_db():
"""Creates the database session"""
db = SessionLocal()
try:
yield db
finally:
db.close()
def update_platform(platform_name: str, contests: List[schemas.Contest]):
db: Session = SessionLocal()
platform = (
db.query(models.Platform)
.filter(models.Platform.source == platform_name)
.first()
)
for item in contests:
contest = (
db.query(models.Contest)
.filter(models.Contest.contest_id == item.contest_id)
.first()
)
if contest is None:
contest = models.Contest()
contest.platform = platform
contest.contest_id = item.contest_id
contest.link = item.link
contest.name = item.name
contest.start_time = item.start_time
contest.end_time = item.end_time
db.add(contest)
logger.info(f"{platform_name} update {item.json(ensure_ascii=False)}")
platform.updated_at = datetime.now(tz=timezone.utc)
db.commit()
db.close()
def get_users(skip: int = 0, limit: int = 100):
with SessionLocal() as db:
users_data = db.query(models.Users).offset(skip).limit(limit).all()
#print(users_data)
temp_data = [user.__dict__ for user in users_data]
#print(temp_data)
return temp_data
def get_db():
"""Dependency function returning new session for each request and closing session after."""
db = SessionLocal()
try:
yield db
finally:
db.close()
def get_db():
""" returns db session """
try:
db = SessionLocal()
yield db
finally:
db.close
def get_db():
try:
db = SessionLocal()
yield db
except Exception as e:
print(e)
finally:
db.close()
async def db_session_middleware(request: Request, call_next):
response = Response("Internal server error", status_code=500)
try:
request.state.db = SessionLocal()
response = await call_next(request)
finally:
request.state.db.close()
return response
def create_user(name, email, password):
with SessionLocal() as db:
secret_password = password + "notreallyhashed"
db_user = models.Users(name=name, email=email, password=password)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def hw_get_aeroporto_by_company(company):
session = SessionLocal()
voos_company = session.query(Voo).filter_by(companhia=company).all()
voos_company_json = populate_voo_aeroporto(voos_company)
cidades_destino = [elem["aeroporto"][0] for elem in voos_company_json]
session.close()
return cidades_destino
def fetch_the_data(id: int):
db = SessionLocal()
house = db.query(house_price).filter(house_price.id == id)
house.MedInc = house['MedInc']
db.add(house)
db.commit()
