DjalimSimaila/SAE-A2-TruthInquiry
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use flask-sqlalchemy instead of sqlalchemy

Browse Source 
Co-authored-by: Djalim Simaila <DjalimSimaila@users.noreply.github.com>
This commit is contained in:
Thomas Rubini 2023-01-21 11:55:01 +01:00 committed by Djalim Simaima
parent 2ceddbe860
commit 0dc59450a7
4 changed files with 71 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
truthinquiry/__init__.py
View File

@ -5,6 +5,10 @@ from flask_socketio import SocketIO
from truthinquiry import discord_bot from truthinquiry import discord_bot
from sqlalchemy import engine as eg
from flask_sqlalchemy import SQLAlchemy
class TruthInquiryApp(flask.Flask): class TruthInquiryApp(flask.Flask):
""" """
@ -23,6 +27,8 @@ class TruthInquiryApp(flask.Flask):
self.config["SECRET_KEY"] = os.getenv("FLASK_SECRET") self.config["SECRET_KEY"] = os.getenv("FLASK_SECRET")
self.setupdb()
self.socketio_app = SocketIO( self.socketio_app = SocketIO(
self, self,
cors_allowed_origins=(os.getenv("ORIGIN"), "http://127.0.0.1:5000", "http://localhost:5000") cors_allowed_origins=(os.getenv("ORIGIN"), "http://127.0.0.1:5000", "http://localhost:5000")
@ -34,6 +40,22 @@ class TruthInquiryApp(flask.Flask):
self.discord_bot.start(token) self.discord_bot.start(token)
else: else:
print("No token set. Not starting discord bot") print("No token set. Not starting discord bot")
def setupdb(self):
db_url = eg.URL.create(
"mariadb+pymysql",
username=os.getenv("DB_USER"),
password=os.getenv("DB_PASSWORD"),
host=os.getenv("DB_HOST"),
port=os.getenv("DB_PORT"),
database=os.getenv("DB_DBNAME")
)
self.config["SQLALCHEMY_DATABASE_URI"] = db_url
self.db = SQLAlchemy(self)
APP = TruthInquiryApp() APP = TruthInquiryApp()

39
truthinquiry/logic/data_persistance/data_access.py
View File

@ -2,21 +2,8 @@ import os
import random import random
import truthinquiry.logic.data_persistance.tables as tables import truthinquiry.logic.data_persistance.tables as tables
from sqlalchemy import create_engine from truthinquiry import APP
from sqlalchemy.orm import Session db = APP.db
from sqlalchemy import engine as eg
url_object = eg.URL.create(
"mariadb+pymysql",
username=os.getenv("DB_USER"),
password=os.getenv("DB_PASSWORD"),
host=os.getenv("DB_HOST"),
port=os.getenv("DB_PORT"),
database=os.getenv("DB_DBNAME"),
)
engine = create_engine(url_object, pool_pre_ping=True, pool_recycle=300)
session = Session(engine)
def get_text_from_lid(lang: str, lid: int) -> str: def get_text_from_lid(lang: str, lid: int) -> str:
""" """
@ -26,7 +13,7 @@ def get_text_from_lid(lang: str, lid: int) -> str:
:param lid: the locale id the get the text from :param lid: the locale id the get the text from
:return: the text associated to the lang and lid :return: the text associated to the lang and lid
""" """
return session.query(tables.Locale).filter_by(LANG=lang, TEXT_ID=lid).one().TEXT return db.session.query(tables.Locale).filter_by(LANG=lang, TEXT_ID=lid).one().TEXT
def get_random_place() -> tables.Place: def get_random_place() -> tables.Place:
""" """
@ -34,7 +21,7 @@ def get_random_place() -> tables.Place:
:return: a Place object :return: a Place object
""" """
return random.choice(session.query(tables.Place).all()) return random.choice(db.session.query(tables.Place).all())
def get_random_npc() -> tables.Npc : def get_random_npc() -> tables.Npc :
""" """
@ -42,7 +29,7 @@ def get_random_npc() -> tables.Npc :
:return: a Npc object :return: a Npc object
""" """
return random.choice(session.query(tables.Npc).all()) return random.choice(db.session.query(tables.Npc).all())
def get_npc_random_trait_id(npc_id: int) -> int: def get_npc_random_trait_id(npc_id: int) -> int:
""" """
@ -51,7 +38,7 @@ def get_npc_random_trait_id(npc_id: int) -> int:
:param npc_id: the npc to get the reaction from :param npc_id: the npc to get the reaction from
:return: a reaction identified by it's trait id :return: a reaction identified by it's trait id
""" """
reactions = session.query(tables.Reaction).filter_by(NPC_ID=npc_id.NPC_ID).all() reactions = db.session.query(tables.Reaction).filter_by(NPC_ID=npc_id.NPC_ID).all()
reaction = random.choice(reactions) reaction = random.choice(reactions)
return reaction.TRAIT_ID return reaction.TRAIT_ID
@ -63,7 +50,7 @@ def get_npc_random_answer(npc_id:int, qa_type:int) -> tables.Answer :
:param qa_type: the type of the question :param qa_type: the type of the question
:return: an Answer object :return: an Answer object
""" """
answers = session.query(tables.Answer).filter_by(QA_TYPE=qa_type,NPC_ID=npc_id.NPC_ID).all() answers = db.session.query(tables.Answer).filter_by(QA_TYPE=qa_type,NPC_ID=npc_id.NPC_ID).all()
return random.choice(answers) return random.choice(answers)
def get_random_question(qa_type: int) -> tables.Question : def get_random_question(qa_type: int) -> tables.Question :
@ -73,7 +60,7 @@ def get_random_question(qa_type: int) -> tables.Question :
:param qa_type: the type of the question :param qa_type: the type of the question
:return: a Question object :return: a Question object
""" """
answers = session.query(tables.Question).filter_by(QUESTION_TYPE=qa_type).all() answers = db.session.query(tables.Question).filter_by(QUESTION_TYPE=qa_type).all()
return random.choice(answers) return random.choice(answers)
def get_trait_from_text(text: str) -> int: def get_trait_from_text(text: str) -> int:
@ -83,8 +70,8 @@ def get_trait_from_text(text: str) -> int:
:param text: the text representation of the trait in any lang :param text: the text representation of the trait in any lang
:return: the trait_id linked to this text :return: the trait_id linked to this text
""" """
trait_lid = session.query(tables.Locale).filter_by(TEXT=text).one().TEXT_ID trait_lid = db.session.query(tables.Locale).filter_by(TEXT=text).one().TEXT_ID
return session.query(tables.Trait).filter_by(NAME_LID=trait_lid).one().TRAIT_ID return db.session.query(tables.Trait).filter_by(NAME_LID=trait_lid).one().TRAIT_ID
def get_trait_from_trait_id(trait_id: int) -> tables.Trait: def get_trait_from_trait_id(trait_id: int) -> tables.Trait:
""" """
@ -93,7 +80,7 @@ def get_trait_from_trait_id(trait_id: int) -> tables.Trait:
:param trait_id: the id of the trait to search for :param trait_id: the id of the trait to search for
:return: a Trait object :return: a Trait object
""" """
trait = session.query(tables.Trait).filter_by(TRAIT_ID=trait_id).one() trait = db.session.query(tables.Trait).filter_by(TRAIT_ID=trait_id).one()
return trait return trait
def get_reaction_description(lang,npc_id,trait_id) -> str: def get_reaction_description(lang,npc_id,trait_id) -> str:
@ -105,7 +92,7 @@ def get_reaction_description(lang,npc_id,trait_id) -> str:
:trait_id: the trait associated to the reaction to get the description from :trait_id: the trait associated to the reaction to get the description from
:return: the description in the given language :return: the description in the given language
""" """
desc_lid = session.query(tables.Reaction).filter_by(NPC_ID=npc_id,TRAIT_ID=trait_id).one().DESC_LID desc_lid = db.session.query(tables.Reaction).filter_by(NPC_ID=npc_id,TRAIT_ID=trait_id).one().DESC_LID
return get_text_from_lid(lang,desc_lid) return get_text_from_lid(lang,desc_lid)
def get_traits(lang: str) -> list: def get_traits(lang: str) -> list:
@ -116,6 +103,6 @@ def get_traits(lang: str) -> list:
:return: a list of string reprensentation of the reactions traits :return: a list of string reprensentation of the reactions traits
""" """
traits = [] traits = []
for trait in session.query(tables.Trait).all(): for trait in db.session.query(tables.Trait).all():
traits.append(get_text_from_lid(lang,trait.NAME_LID)) traits.append(get_text_from_lid(lang,trait.NAME_LID))
return traits return traits

72
truthinquiry/logic/data_persistance/remote.py
View File

@ -1,72 +0,0 @@
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
from sqlalchemy import engine as eg
from tables import *
from data.answer import ANSWERS
from data.locales import LOCALES
from data.npc import NPCS
from data.places import PLACES
from data.questions import QUESTIONS
from data.reactions import REACTIONS
from data.traits import TRAITS
url_object = eg.URL.create(
"mariadb+pymysql",
username=os.getenv("DB_USER"),
password=os.getenv("DB_PASSWORD"),
host=os.getenv("DB_HOST"),
port=os.getenv("DB_PORT"),
database=os.getenv("DB_DBNAME"),
)
engine = create_engine(url_object)
# Reset data tables
with Session(engine) as session:
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
print("adding locales")
for locale in LOCALES:
print(locale)
session.add(locale)
session.commit()
print("adding places")
for place in PLACES:
print(place)
session.add(place)
session.commit()
print("adding NPCS")
for npc in NPCS:
print(npc)
session.add(npc)
session.commit()
print("adding trait")
for trait in TRAITS:
print(trait)
session.add(trait)
session.commit()
print("adding questions")
for question in QUESTIONS:
print(question)
session.add(question)
session.commit()
print("adding answers")
for answer in ANSWERS:
print(answer)
session.add(answer)
session.commit()
print("adding reactions")
for reaction in REACTIONS:
print(reaction)
session.add(reaction)
session.commit()

75
truthinquiry/logic/data_persistance/tables.py
View File

@ -1,15 +1,12 @@
from sqlalchemy import Column, Integer, Text, ForeignKey, VARCHAR from truthinquiry import APP
from sqlalchemy.orm import declarative_base, relationship db = APP.db
Base = declarative_base() class Locale(db.Model):
class Locale(Base):
__tablename__ = 'T_LOCALE' __tablename__ = 'T_LOCALE'
TEXT_ID = Column(Integer, primary_key=True) TEXT_ID = db.Column(db.Integer, primary_key=True)
LANG = Column(VARCHAR(2), primary_key=True) LANG = db.Column(db.VARCHAR(2), primary_key=True)
TEXT = Column(Text) TEXT = db.Column(db.Text)
def __init__(self, TEXT_ID, LANG, TEXT): def __init__(self, TEXT_ID, LANG, TEXT):
self.TEXT_ID = TEXT_ID self.TEXT_ID = TEXT_ID
@ -20,11 +17,11 @@ class Locale(Base):
return f"{self.TEXT_ID} {self.LANG} {self.TEXT}" return f"{self.TEXT_ID} {self.LANG} {self.TEXT}"
class Place(Base): class Place(db.Model):
__tablename__ = 'T_PLACE' __tablename__ = 'T_PLACE'
PLACE_ID = Column(Integer, primary_key=True) PLACE_ID = db.Column(db.Integer, primary_key=True)
NAME_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) NAME_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
LOCALE = relationship("Locale") LOCALE = db.relationship("Locale")
def __init__(self, PLACE_ID, NAME_LID): def __init__(self, PLACE_ID, NAME_LID):
self.PLACE_ID = PLACE_ID self.PLACE_ID = PLACE_ID
@ -34,12 +31,12 @@ class Place(Base):
return f"{self.PLACE_ID} {self.NAME_LID}" return f"{self.PLACE_ID} {self.NAME_LID}"
class Question(Base): class Question(db.Model):
__tablename__ = "T_QUESTION" __tablename__ = "T_QUESTION"
QUESTION_ID = Column(Integer, primary_key=True) QUESTION_ID = db.Column(db.Integer, primary_key=True)
QUESTION_TYPE = Column(Integer) QUESTION_TYPE = db.Column(db.Integer)
TEXT_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) TEXT_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
LOCALE = relationship("Locale") LOCALE = db.relationship("Locale")
def __init__(self, QUESTION_ID, QUESTION_TYPE, TEXT_LID): def __init__(self, QUESTION_ID, QUESTION_TYPE, TEXT_LID):
self.QUESTION_ID = QUESTION_ID self.QUESTION_ID = QUESTION_ID
@ -50,14 +47,14 @@ class Question(Base):
return f"{self.QUESTION_ID} {self.QUESTION_TYPE} {self.TEXT_LID}" return f"{self.QUESTION_ID} {self.QUESTION_TYPE} {self.TEXT_LID}"
class Answer(Base): class Answer(db.Model):
__tablename__ = "T_ANSWER" __tablename__ = "T_ANSWER"
ANSWER_ID = Column(Integer, primary_key=True) ANSWER_ID = db.Column(db.Integer, primary_key=True)
QA_TYPE = Column(Integer) QA_TYPE = db.Column(db.Integer)
NPC_ID = Column(Integer, ForeignKey("T_NPC.NPC_ID")) NPC_ID = db.Column(db.Integer, db.ForeignKey("T_NPC.NPC_ID"))
TEXT_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) TEXT_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
LOCALE = relationship("Locale") LOCALE = db.relationship("Locale")
NPC = relationship("Npc") NPC = db.relationship("Npc")
def __init__(self, ANSWER_ID, QA_TYPE, NPC_ID, TEXT_LID): def __init__(self, ANSWER_ID, QA_TYPE, NPC_ID, TEXT_LID):
self.ANSWER_ID = ANSWER_ID self.ANSWER_ID = ANSWER_ID
@ -69,10 +66,10 @@ class Answer(Base):
return f"{self.ANSWER_ID} {self.QA_TYPE} {self.NPC_ID} {self.TEXT_LID}" return f"{self.ANSWER_ID} {self.QA_TYPE} {self.NPC_ID} {self.TEXT_LID}"
class Npc(Base): class Npc(db.Model):
__tablename__ = "T_NPC" __tablename__ = "T_NPC"
NPC_ID = Column(Integer, primary_key=True) NPC_ID = db.Column(db.Integer, primary_key=True)
NAME_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) NAME_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
def __init__(self, NPC_ID, NAME_LID): def __init__(self, NPC_ID, NAME_LID):
self.NPC_ID = NPC_ID self.NPC_ID = NPC_ID
@ -82,10 +79,10 @@ class Npc(Base):
return f"{self.NPC_ID} {self.NAME_LID}" return f"{self.NPC_ID} {self.NAME_LID}"
class Trait(Base): class Trait(db.Model):
__tablename__ = "T_TRAIT" __tablename__ = "T_TRAIT"
TRAIT_ID = Column(Integer, primary_key=True) TRAIT_ID = db.Column(db.Integer, primary_key=True)
NAME_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) NAME_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
def __init__(self, TRAIT_ID, NAME_LID): def __init__(self, TRAIT_ID, NAME_LID):
self.TRAIT_ID = TRAIT_ID self.TRAIT_ID = TRAIT_ID
@ -95,15 +92,15 @@ class Trait(Base):
return f"{self.TRAIT_ID} {self.NAME_LID}" return f"{self.TRAIT_ID} {self.NAME_LID}"
class Reaction(Base): class Reaction(db.db.Model):
__tablename__ = "T_REACTION" __tablename__ = "T_REACTION"
REACTION_ID = Column(Integer, primary_key=True) REACTION_ID = db.Column(db.Integer, primary_key=True)
NPC_ID = Column(Integer, ForeignKey("T_NPC.NPC_ID"), primary_key=True) NPC_ID = db.Column(db.Integer, db.ForeignKey("T_NPC.NPC_ID"), primary_key=True)
TRAIT_ID = Column(Integer, ForeignKey("T_TRAIT.TRAIT_ID"), primary_key=True) TRAIT_ID = db.Column(db.Integer, db.ForeignKey("T_TRAIT.TRAIT_ID"), primary_key=True)
DESC_LID = Column(Integer, ForeignKey("T_LOCALE.TEXT_ID")) DESC_LID = db.Column(db.Integer, db.ForeignKey("T_LOCALE.TEXT_ID"))
LOCALE = relationship("Locale") LOCALE = db.relationship("Locale")
NPC = relationship("Npc") NPC = db.relationship("Npc")
TRAIT = relationship("Trait") TRAIT = db.relationship("Trait")
def __init__(self, REACTION_ID, DESC_LID, NPC_ID, TRAIT_ID): def __init__(self, REACTION_ID, DESC_LID, NPC_ID, TRAIT_ID):
self.REACTION_ID = REACTION_ID self.REACTION_ID = REACTION_ID