def create(self, db: Session, *, obj_in: CreateSchemaType) -> ModelType:
obj_in_data = camel_dict_to_snake(jsonable_encoder(obj_in))
start_time = None
end_time = None
if "start_time" in obj_in_data and obj_in_data["start_time"]:
start_time = dateutil.parser.parse(obj_in_data["start_time"])
if "end_time" in obj_in_data and obj_in_data["end_time"]:
end_time = dateutil.parser.parse(obj_in_data["end_time"])
db_party = models.Party(
title=obj_in_data["title"],
leader_id=obj_in_data["leader_id"],
game_id=obj_in_data["game_id"],
max_players=obj_in_data["max_players"],
min_players=obj_in_data["min_players"],
description=obj_in_data["description"],
channel_id=obj_in_data["channel_id"],
start_time=start_time,
end_time=end_time,
)
db.add(db_party)
db.commit()
db.refresh(db_party)
return db_party
def update(self, db: Session, *, db_obj: ModelType,
obj_in: Union[UpdateSchemaType, Dict[str, Any]]) -> ModelType:
obj_data = camel_dict_to_snake(jsonable_encoder(db_obj))
if isinstance(obj_in, dict):
update_data = obj_in
else:
update_data = obj_in.dict(exclude_unset=True)
for field in obj_data:
if (field in update_data and field == "start_time"
and isinstance(update_data["start_time"], str)):
setattr(db_obj, field,
dateutil.parser.parse(update_data["start_time"]))
elif (field in update_data and field == "end_time"
and isinstance(update_data["end_time"], str)):
setattr(db_obj, field,
dateutil.parser.parse(update_data["end_time"]))
elif field in update_data:
setattr(db_obj, field, update_data[field])
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def create(self, db: Session, *, obj_in: CreateSchemaType) -> ModelType:
obj_in_data = camel_dict_to_snake(jsonable_encoder(obj_in))
db_obj = self.model(**obj_in_data)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def resource_fixture(user: User, topic: Topic, session: Session) -> Resource:
resource = Resource(name="UNSW",
url="unsw.edu.au",
user_id=user.id,
topics=[topic])
session.add(resource)
session.commit()
yield resource
def superuser_fixture(session: Session) -> User:
user = User(
name="Albus Dumbledore",
email=TEST_SUPERUSER_EMAIL,
password_hash=security.get_password_hash(TEST_SUPERUSER_PASSWORD),
is_superuser=True,
)
session.add(user)
session.commit()
yield user
def mark_resource_broken(*,
session: Session = Depends(get_session),
resource_id: int):
"""Mark a resource as broken"""
db_resource = get_resource(session, resource_id)
db_resource.broken += 1
session.add(db_resource)
session.commit()
session.refresh(db_resource)
return db_resource
def user_fixture(session: Session) -> User:
user = User(
name="Harry Potter",
email=TEST_USER_EMAIL,
password_hash=security.get_password_hash(TEST_USER_PASSWORD),
stripe_customer_id="TEST_CUSTOMER_ID",
)
session.add(user)
session.commit()
yield user
def test_read_things_with_things(session: Session):
new_thing = Thing(id="123456",
authority_id="test",
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
session.add(new_thing)
session.commit()
count, pages, data = read_things_summary(session, 0, 0)
assert 1 == count
assert 0 == pages
assert len(data) > 0
def lock(self, db: Session, *, db_obj: ModelType) -> ModelType:
"""
Lock Party
:param db: Database Session
:param db_obj: Party instance
"""
db_obj.locked = True
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def test_get_thing_with_id_thing(session: Session):
id = "123456"
new_thing = Thing(id=id,
authority_id="test",
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
session.add(new_thing)
session.commit()
shouldnt_be_none = get_thing_with_id(session, id)
assert shouldnt_be_none is not None
assert shouldnt_be_none.primary_key is not None
assert id == shouldnt_be_none.id
def update_course(*,
session: Session = Depends(get_session),
course_id: int,
course: CourseUpdate,
current_user: User = Depends(deps.get_current_user)):
db_course = get_course(session, course_id, current_user)
course_data = course.dict(exclude_unset=True)
for key, value in course_data.items():
setattr(db_course, key, value)
session.add(db_course)
session.commit()
session.refresh(db_course)
return db_course
def test_last_time_thing_created(session: Session):
test_authority = "test"
created = last_time_thing_created(session, test_authority)
assert created is None
new_thing = Thing(id="123456",
authority_id=test_authority,
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"},
tcreated=datetime.datetime.now())
session.add(new_thing)
session.commit()
new_created = last_time_thing_created(session, test_authority)
assert new_created is not None
def update_hero(*,
session: Session = Depends(get_session),
hero_id: int,
hero: HeroUpdate):
db_hero = session.get(Hero, hero_id)
if not db_hero:
raise HTTPException(status_code=404, detail="Hero not found")
hero_data = hero.dict(exclude_unset=True)
for key, value in hero_data.items():
setattr(db_hero, key, value)
session.add(db_hero)
session.commit()
session.refresh(db_hero)
return db_hero
def create_assignment(*,
session: Session = Depends(get_session),
course_id: int,
assignment: AssignmentCreate,
current_user: User = Depends(deps.get_current_user)):
# check that the user is authorized to get this course
get_course(session, course_id, current_user)
# create the assignment
assignment_db = Assignment.from_orm(assignment)
assignment_db.course_id = course_id # assign to this course
session.add(assignment_db)
session.commit()
session.refresh(assignment_db)
return assignment_db
def _add_some_things(session: Session,
num_things: int,
authority_id: str,
tcreated: datetime.datetime = None):
for i in range(num_things):
new_thing = Thing(id=str(i),
authority_id=authority_id,
resolved_url="http://foo.bar",
resolved_status=200,
resolved_content={"foo": "bar"})
if tcreated is not None:
new_thing.tcreated = tcreated
session.add(new_thing)
session.commit()
def assignment_fixture(course: Course, session: Session) -> Assignment:
assignment = Assignment(
name="Big Exam",
description="Huge Exam",
status="completed",
due=datetime.date(2021, 12, 12),
course_id=course.id,
weight=50,
mark=100,
outcome="pass",
)
session.add(assignment)
session.commit()
yield assignment
def course_fixture(user: User, session: Session) -> Course:
course = Course(
name="Discrete Maths",
code="MATH1081",
description="Hello world",
status="completing",
due=datetime.date(2021, 8, 29),
user_id=user.id,
syllabus=[{
"item": 123
}],
)
session.add(course)
session.commit()
yield course
def load_csv_bom(bom_name, csv_file):
create_db_and_tables()
session = Session(engine)
remove_page_bom(session, bom_name)
bom_table = BOMTable(name=bom_name)
for row in csv.DictReader(csv_file, delimiter=",", quotechar='"'):
session.add(
BOMItem(
name=row["Name"],
material=row["Material"],
quantity=row["Quantity"],
bom_table=bom_table,
)
)
session.commit()
def create_user(*, session: Session = Depends(get_session), user: UserCreate):
# create the stripe customer
customer = stripe.Customer.create(email=user.email, name=user.name)
db_user = User.from_orm(
user,
{
"password_hash": security.get_password_hash(user.password),
"stripe_customer_id": customer["id"],
},
)
session.add(db_user)
session.commit()
session.refresh(db_user)
return db_user
def update_user(
*,
session: Session = Depends(get_session),
user_id: int,
user: UserUpdate,
current_user: User = Depends(deps.get_current_active_user),
):
db_user = get_user(session, user_id)
if db_user.id != current_user.id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
user_data = user.dict(exclude_unset=True)
for key, value in user_data.items():
setattr(db_user, key, value)
session.add(db_user)
session.commit()
session.refresh(db_user)
return db_user
def update_resource(
*,
session: Session = Depends(get_session),
resource_id: int,
resource: ResourceUpdate,
current_user: User = Depends(deps.get_current_user),
):
db_resource = get_resource(session, resource_id)
if not current_user.is_superuser and db_resource.user.id != current_user.id:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
resource_data = resource.dict(exclude_unset=True)
for key, value in resource_data.items():
setattr(db_resource, key, value)
session.add(db_resource)
session.commit()
session.refresh(db_resource)
return db_resource
def vote_on_resource(*,
session: Session = Depends(get_session),
resource_id: int,
vote: int):
"""Upvote or downvote a resource using the `vote` query param.
Use `/vote?vote=1` for an upvote, `/vote?vote=-1` for a downvote.
Any user (including unauthorized users) may PATCH to this route.
"""
if vote not in {1, -1}:
raise HTTPException(
status_code=400,
detail="Vote may only upvote (1) or downvote (-1) once")
db_resource = get_resource(session, resource_id)
db_resource.votes += vote
session.add(db_resource)
session.commit()
session.refresh(db_resource)
return db_resource
def many_resources_fixture(user: User, topic: Topic,
session: Session) -> List[Resource]:
resources = [
Resource(name="Google",
url="google.com",
user_id=user.id,
topics=[topic]),
Resource(name="UNSW", url="unsw.edu.au", user_id=user.id, topics=[]),
Resource(
name="Introduction To Deep Learning",
url="https://sebastianraschka.com/blog/2021/dl-course.html",
user_id=user.id,
topics=[topic],
),
]
for resource in resources:
session.add(resource)
session.commit()
yield resources
def create_course(*,
session: Session = Depends(get_session),
course: CourseCreate,
current_user: User = Depends(deps.get_current_user)):
db_course = Course.from_orm(course, {"user_id": current_user.id})
session.add(db_course)
session.commit()
session.refresh(db_course)
new_assignments = []
for assignment in course.assignments:
new_assignment = Assignment.from_orm(assignment,
{"course_id": db_course.id})
new_assignments.append(new_assignment)
session.add_all(new_assignments)
db_course.assignments = new_assignments
session.commit()
session.refresh(db_course)
return db_course
def create_plants():
plant_1 = Plant(name="Hebe")
plant_2 = Plant(name="Astilbe")
plant_3 = Plant(name="Sedum")
plant_4 = Plant(name="Helenium")
plant_5 = Plant(name="Heather")
session = Session(engine)
session.add(plant_1)
session.add(plant_2)
session.add(plant_3)
session.add(plant_4)
session.add(plant_5)
session.commit()
session.close()
def generate_demo_data(session: Session):
"""Generates demonstration data from models"""
# check that the db is empty
if session.query(models.User).first():
log.info("Data already exists, skipping data generation.")
return
log.info("Generating demo data.")
user = models.User(
name="Tom Hill",
email="*****@*****.**",
password_hash=security.get_password_hash("password"),
stripe_customer_id=stripe.Customer.create()["id"],
)
session.add(user)
session.commit()
session.refresh(user)
discrete_maths = models.Course(
name="Introduction to Reinforcement Learning",
code="RL479",
description="description",
status="completing",
due="2021-12-12",
syllabus=[
{
"id": 1,
"name": "Introduction to Reinforcement Learning",
"completed": False,
},
{
"id": 2,
"name": "Exploration and Control",
"completed": False
},
{
"id": 3,
"name": "MDPs and Dynamic Programming",
"completed": False
},
{
"id": 4,
"name": "Fundementals of Dynamic Programming Algorithms",
"completed": False,
},
{
"id": 5,
"name": "Model-Free Prediction",
"completed": False
},
{
"id": 6,
"name": "Model-Free Control",
"completed": False
},
{
"id": 7,
"name": "Function Approximation",
"completed": False
},
{
"id": 8,
"name": "Planning & Models",
"completed": False
},
{
"id": 9,
"name": "Policy-Gradient and Actor-Critic Methods",
"completed": False,
},
{
"id": 10,
"name": "Approximate Dynamic Programming",
"completed": False
},
{
"id": 11,
"name": "Multi-Step & Off Policy",
"completed": False
},
{
"id": 12,
"name": "Deep RL 1",
"completed": False
},
{
"id": 13,
"name": "Deep RL 2",
"completed": False
},
],
cover={"color": "#8bbeb2"},
user_id=user.id,
)
maths = models.Topic(name="mathematics")
algebra = models.Topic(name="algebra")
session.add_all([discrete_maths, maths, algebra])
session.commit()
session.refresh(maths)
session.refresh(algebra) # could try session.expire_all() instead?
linear_algebra = models.Resource(
name="Interactive Linear Algebra",
url="http://textbooks.math.gatech.edu/ila/index.html",
user_id=user.id,
topics=[maths, algebra],
)
big_exam = models.Assignment(
name="Big Exam",
description="Examination of:Set theory, Proof, Graph Theory",
due="2021-12-12",
course_id=discrete_maths.id,
status="in_progress",
weight=50,
)
session.add_all([linear_algebra, big_exam])
session.commit()
def create_hero(*, session: Session = Depends(get_session), hero: HeroCreate):
db_hero = Hero.from_orm(hero)
session.add(db_hero)
session.commit()
session.refresh(db_hero)
return db_hero
def create_topic(*, session: Session = Depends(get_session), topic: TopicCreate):
db_topic = Topic.from_orm(topic)
session.add(db_topic)
session.commit()
session.refresh(db_topic)
return db_topic
def topic_fixture(session: Session) -> Topic:
topic = Topic(name="mathematics")
session.add(topic)
session.commit()
yield topic