diff --git a/erpnext/education/utils.py b/erpnext/education/utils.py
index a7a15d1..e6eb1c9 100644
--- a/erpnext/education/utils.py
+++ b/erpnext/education/utils.py
@@ -4,7 +4,9 @@
 from frappe import _
 
 
-class OverlapError(frappe.ValidationError): pass
+class OverlapError(frappe.ValidationError):
+	pass
+
 
 def validate_overlap_for(doc, doctype, fieldname, value=None):
 	"""Checks overlap for specified field.
@@ -14,8 +16,16 @@
 
 	existing = get_overlap_for(doc, doctype, fieldname, value)
 	if existing:
-		frappe.throw(_("This {0} conflicts with {1} for {2} {3}").format(doc.doctype, existing.name,
-			doc.meta.get_label(fieldname) if not value else fieldname , value or doc.get(fieldname)), OverlapError)
+		frappe.throw(
+			_("This {0} conflicts with {1} for {2} {3}").format(
+				doc.doctype,
+				existing.name,
+				doc.meta.get_label(fieldname) if not value else fieldname,
+				value or doc.get(fieldname),
+			),
+			OverlapError,
+		)
+
 
 def get_overlap_for(doc, doctype, fieldname, value=None):
 	"""Returns overlaping document for specified field.
@@ -23,45 +33,54 @@
 	:param fieldname: Checks Overlap for this field
 	"""
 
-	existing = frappe.db.sql("""select name, from_time, to_time from `tab{0}`
+	existing = frappe.db.sql(
+		"""select name, from_time, to_time from `tab{0}`
 		where `{1}`=%(val)s and schedule_date = %(schedule_date)s and
 		(
 			(from_time > %(from_time)s and from_time < %(to_time)s) or
 			(to_time > %(from_time)s and to_time < %(to_time)s) or
 			(%(from_time)s > from_time and %(from_time)s < to_time) or
 			(%(from_time)s = from_time and %(to_time)s = to_time))
-		and name!=%(name)s and docstatus!=2""".format(doctype, fieldname),
+		and name!=%(name)s and docstatus!=2""".format(
+			doctype, fieldname
+		),
 		{
 			"schedule_date": doc.schedule_date,
 			"val": value or doc.get(fieldname),
 			"from_time": doc.from_time,
 			"to_time": doc.to_time,
-			"name": doc.name or "No Name"
-		}, as_dict=True)
+			"name": doc.name or "No Name",
+		},
+		as_dict=True,
+	)
 
 	return existing[0] if existing else None
 
 
 def validate_duplicate_student(students):
-	unique_students= []
+	unique_students = []
 	for stud in students:
 		if stud.student in unique_students:
-			frappe.throw(_("Student {0} - {1} appears Multiple times in row {2} & {3}")
-				.format(stud.student, stud.student_name, unique_students.index(stud.student)+1, stud.idx))
+			frappe.throw(
+				_("Student {0} - {1} appears Multiple times in row {2} & {3}").format(
+					stud.student, stud.student_name, unique_students.index(stud.student) + 1, stud.idx
+				)
+			)
 		else:
 			unique_students.append(stud.student)
 
 		return None
 
+
 # LMS Utils
 def get_current_student():
 	"""Returns current student from frappe.session.user
 
 	Returns:
-		object: Student Document
+	        object: Student Document
 	"""
 	email = frappe.session.user
-	if email in ('Administrator', 'Guest'):
+	if email in ("Administrator", "Guest"):
 		return None
 	try:
 		student_id = frappe.get_all("Student", {"student_email_id": email}, ["name"])[0].name
@@ -69,74 +88,86 @@
 	except (IndexError, frappe.DoesNotExistError):
 		return None
 
+
 def get_portal_programs():
 	"""Returns a list of all program to be displayed on the portal
 	Programs are returned based on the following logic
-		is_published and (student_is_enrolled or student_can_self_enroll)
+	        is_published and (student_is_enrolled or student_can_self_enroll)
 
 	Returns:
-		list of dictionary: List of all programs and to be displayed on the portal along with access rights
+	        list of dictionary: List of all programs and to be displayed on the portal along with access rights
 	"""
 	published_programs = frappe.get_all("Program", filters={"is_published": True})
 	if not published_programs:
 		return None
 
 	program_list = [frappe.get_doc("Program", program) for program in published_programs]
-	portal_programs = [{'program': program, 'has_access': allowed_program_access(program.name)} for program in program_list if allowed_program_access(program.name) or program.allow_self_enroll]
+	portal_programs = [
+		{"program": program, "has_access": allowed_program_access(program.name)}
+		for program in program_list
+		if allowed_program_access(program.name) or program.allow_self_enroll
+	]
 
 	return portal_programs
 
+
 def allowed_program_access(program, student=None):
 	"""Returns enrollment status for current student
 
 	Args:
-		program (string): Name of the program
-		student (object): instance of Student document
+	        program (string): Name of the program
+	        student (object): instance of Student document
 
 	Returns:
-		bool: Is current user enrolled or not
+	        bool: Is current user enrolled or not
 	"""
 	if has_super_access():
 		return True
 	if not student:
 		student = get_current_student()
-	if student and get_enrollment('program', program, student.name):
+	if student and get_enrollment("program", program, student.name):
 		return True
 	else:
 		return False
 
+
 def get_enrollment(master, document, student):
 	"""Gets enrollment for course or program
 
 	Args:
-		master (string): can either be program or course
-		document (string): program or course name
-		student (string): Student ID
+	        master (string): can either be program or course
+	        document (string): program or course name
+	        student (string): Student ID
 
 	Returns:
-		string: Enrollment Name if exists else returns empty string
+	        string: Enrollment Name if exists else returns empty string
 	"""
-	if master == 'program':
-		enrollments = frappe.get_all("Program Enrollment", filters={'student':student, 'program': document, 'docstatus': 1})
-	if master == 'course':
-		enrollments = frappe.get_all("Course Enrollment", filters={'student':student, 'course': document})
+	if master == "program":
+		enrollments = frappe.get_all(
+			"Program Enrollment", filters={"student": student, "program": document, "docstatus": 1}
+		)
+	if master == "course":
+		enrollments = frappe.get_all(
+			"Course Enrollment", filters={"student": student, "course": document}
+		)
 
 	if enrollments:
 		return enrollments[0].name
 	else:
 		return None
 
+
 @frappe.whitelist()
 def enroll_in_program(program_name, student=None):
 	"""Enroll student in program
 
 	Args:
-		program_name (string): Name of the program to be enrolled into
-		student (string, optional): name of student who has to be enrolled, if not
-			provided, a student will be created from the current user
+	        program_name (string): Name of the program to be enrolled into
+	        student (string, optional): name of student who has to be enrolled, if not
+	                provided, a student will be created from the current user
 
 	Returns:
-		string: name of the program enrollment document
+	        string: name of the program enrollment document
 	"""
 	if has_super_access():
 		return
@@ -145,7 +176,7 @@
 		student = frappe.get_doc("Student", student)
 	else:
 		# Check if self enrollment in allowed
-		program = frappe.get_doc('Program', program_name)
+		program = frappe.get_doc("Program", program_name)
 		if not program.allow_self_enroll:
 			return frappe.throw(_("You are not allowed to enroll for this course"))
 
@@ -154,12 +185,12 @@
 			student = create_student_from_current_user()
 
 	# Check if student is already enrolled in program
-	enrollment = get_enrollment('program', program_name, student.name)
+	enrollment = get_enrollment("program", program_name, student.name)
 	if enrollment:
 		return enrollment
 
 	# Check if self enrollment in allowed
-	program = frappe.get_doc('Program', program_name)
+	program = frappe.get_doc("Program", program_name)
 	if not program.allow_self_enroll:
 		return frappe.throw(_("You are not allowed to enroll for this course"))
 
@@ -167,15 +198,19 @@
 	program_enrollment = student.enroll_in_program(program_name)
 	return program_enrollment.name
 
+
 def has_super_access():
 	"""Check if user has a role that allows full access to LMS
 
 	Returns:
-		bool: true if user has access to all lms content
+	        bool: true if user has access to all lms content
 	"""
-	current_user = frappe.get_doc('User', frappe.session.user)
+	current_user = frappe.get_doc("User", frappe.session.user)
 	roles = set([role.role for role in current_user.roles])
-	return bool(roles & {'Administrator', 'Instructor', 'Education Manager', 'System Manager', 'Academic User'})
+	return bool(
+		roles & {"Administrator", "Instructor", "Education Manager", "System Manager", "Academic User"}
+	)
+
 
 @frappe.whitelist()
 def add_activity(course, content_type, content, program):
@@ -184,14 +219,17 @@
 
 	student = get_current_student()
 	if not student:
-		return frappe.throw(_("Student with email {0} does not exist").format(frappe.session.user), frappe.DoesNotExistError)
+		return frappe.throw(
+			_("Student with email {0} does not exist").format(frappe.session.user), frappe.DoesNotExistError
+		)
 
 	enrollment = get_or_create_course_enrollment(course, program)
-	if content_type == 'Quiz':
+	if content_type == "Quiz":
 		return
 	else:
 		return enrollment.add_activity(content_type, content)
 
+
 @frappe.whitelist()
 def evaluate_quiz(quiz_response, quiz_name, course, program, time_taken):
 	import json
@@ -203,16 +241,17 @@
 	result, score, status = quiz.evaluate(quiz_response, quiz_name)
 
 	if has_super_access():
-		return {'result': result, 'score': score, 'status': status}
+		return {"result": result, "score": score, "status": status}
 
 	if student:
 		enrollment = get_or_create_course_enrollment(course, program)
 		if quiz.allowed_attempt(enrollment, quiz_name):
 			enrollment.add_quiz_activity(quiz_name, quiz_response, result, score, status, time_taken)
-			return {'result': result, 'score': score, 'status': status}
+			return {"result": result, "score": score, "status": status}
 		else:
 			return None
 
+
 @frappe.whitelist()
 def get_quiz(quiz_name, course):
 	try:
@@ -222,37 +261,40 @@
 		frappe.throw(_("Quiz {0} does not exist").format(quiz_name), frappe.DoesNotExistError)
 		return None
 
-	questions = [{
-		'name': question.name,
-		'question': question.question,
-		'type': question.question_type,
-		'options': [{'name': option.name, 'option': option.option}
-					for option in question.options],
-		} for question in questions]
+	questions = [
+		{
+			"name": question.name,
+			"question": question.question,
+			"type": question.question_type,
+			"options": [{"name": option.name, "option": option.option} for option in question.options],
+		}
+		for question in questions
+	]
 
 	if has_super_access():
 		return {
-			'questions': questions,
-			'activity': None,
-			'is_time_bound': quiz.is_time_bound,
-			'duration': quiz.duration
+			"questions": questions,
+			"activity": None,
+			"is_time_bound": quiz.is_time_bound,
+			"duration": quiz.duration,
 		}
 
 	student = get_current_student()
 	course_enrollment = get_enrollment("course", course, student.name)
 	status, score, result, time_taken = check_quiz_completion(quiz, course_enrollment)
 	return {
-		'questions': questions,
-		'activity': {'is_complete': status, 'score': score, 'result': result, 'time_taken': time_taken},
-		'is_time_bound': quiz.is_time_bound,
-		'duration': quiz.duration
+		"questions": questions,
+		"activity": {"is_complete": status, "score": score, "result": result, "time_taken": time_taken},
+		"is_time_bound": quiz.is_time_bound,
+		"duration": quiz.duration,
 	}
 
+
 def get_topic_progress(topic, course_name, program):
 	"""
 	Return the porgress of a course in a program as well as the content to continue from.
-		:param topic_name:
-		:param course_name:
+	        :param topic_name:
+	        :param course_name:
 	"""
 	student = get_current_student()
 	if not student:
@@ -261,19 +303,20 @@
 	progress = student.get_topic_progress(course_enrollment.name, topic)
 	if not progress:
 		return None
-	count = sum([activity['is_complete'] for activity in progress])
+	count = sum([activity["is_complete"] for activity in progress])
 	if count == 0:
-		return {'completed': False, 'started': False}
+		return {"completed": False, "started": False}
 	elif count == len(progress):
-		return {'completed': True, 'started': True}
+		return {"completed": True, "started": True}
 	elif count < len(progress):
-		return {'completed': False, 'started': True}
+		return {"completed": False, "started": True}
+
 
 def get_course_progress(course, program):
 	"""
 	Return the porgress of a course in a program as well as the content to continue from.
-		:param topic_name:
-		:param course_name:
+	        :param topic_name:
+	        :param course_name:
 	"""
 	course_progress = []
 	for course_topic in course.topics:
@@ -282,19 +325,20 @@
 		if progress:
 			course_progress.append(progress)
 	if course_progress:
-		number_of_completed_topics = sum([activity['completed'] for activity in course_progress])
+		number_of_completed_topics = sum([activity["completed"] for activity in course_progress])
 		total_topics = len(course_progress)
 		if total_topics == 1:
 			return course_progress[0]
 		if number_of_completed_topics == 0:
-			return {'completed': False, 'started': False}
+			return {"completed": False, "started": False}
 		if number_of_completed_topics == total_topics:
-			return {'completed': True, 'started': True}
+			return {"completed": True, "started": True}
 		if number_of_completed_topics < total_topics:
-			return {'completed': False, 'started': True}
+			return {"completed": False, "started": True}
 
 	return None
 
+
 def get_program_progress(program):
 	program_progress = []
 	if not program.courses:
@@ -303,8 +347,8 @@
 		course = frappe.get_doc("Course", program_course.course)
 		progress = get_course_progress(course, program.name)
 		if progress:
-			progress['name'] = course.name
-			progress['course'] = course.course_name
+			progress["name"] = course.name
+			progress["course"] = course.course_name
 			program_progress.append(progress)
 
 	if program_progress:
@@ -312,81 +356,94 @@
 
 	return None
 
+
 def get_program_completion(program):
-	topics = frappe.db.sql("""select `tabCourse Topic`.topic, `tabCourse Topic`.parent
+	topics = frappe.db.sql(
+		"""select `tabCourse Topic`.topic, `tabCourse Topic`.parent
 	from `tabCourse Topic`,
 		 `tabProgram Course`
 	where `tabCourse Topic`.parent = `tabProgram Course`.course
-			and `tabProgram Course`.parent = %s""", program.name)
+			and `tabProgram Course`.parent = %s""",
+		program.name,
+	)
 
 	progress = []
 	for topic in topics:
-		topic_doc = frappe.get_doc('Topic', topic[0])
+		topic_doc = frappe.get_doc("Topic", topic[0])
 		topic_progress = get_topic_progress(topic_doc, topic[1], program.name)
 		if topic_progress:
 			progress.append(topic_progress)
 
 	if progress:
-		number_of_completed_topics = sum([activity['completed'] for activity in progress if activity])
+		number_of_completed_topics = sum([activity["completed"] for activity in progress if activity])
 		total_topics = len(progress)
 		try:
-			return int((float(number_of_completed_topics)/total_topics)*100)
+			return int((float(number_of_completed_topics) / total_topics) * 100)
 		except ZeroDivisionError:
 			return 0
 
 	return 0
 
+
 def create_student_from_current_user():
 	user = frappe.get_doc("User", frappe.session.user)
 
-	student = frappe.get_doc({
-		"doctype": "Student",
-		"first_name": user.first_name,
-		"last_name": user.last_name,
-		"student_email_id": user.email,
-		"user": frappe.session.user
-		})
+	student = frappe.get_doc(
+		{
+			"doctype": "Student",
+			"first_name": user.first_name,
+			"last_name": user.last_name,
+			"student_email_id": user.email,
+			"user": frappe.session.user,
+		}
+	)
 
 	student.save(ignore_permissions=True)
 	return student
 
+
 def get_or_create_course_enrollment(course, program):
 	student = get_current_student()
 	course_enrollment = get_enrollment("course", course, student.name)
 	if not course_enrollment:
-		program_enrollment = get_enrollment('program', program.name, student.name)
+		program_enrollment = get_enrollment("program", program.name, student.name)
 		if not program_enrollment:
 			frappe.throw(_("You are not enrolled in program {0}").format(program))
 			return
-		return student.enroll_in_course(course_name=course, program_enrollment=get_enrollment('program', program.name, student.name))
+		return student.enroll_in_course(
+			course_name=course, program_enrollment=get_enrollment("program", program.name, student.name)
+		)
 	else:
-		return frappe.get_doc('Course Enrollment', course_enrollment)
+		return frappe.get_doc("Course Enrollment", course_enrollment)
+
 
 def check_content_completion(content_name, content_type, enrollment_name):
-	activity = frappe.get_all("Course Activity", filters={'enrollment': enrollment_name, 'content_type': content_type, 'content': content_name})
+	activity = frappe.get_all(
+		"Course Activity",
+		filters={"enrollment": enrollment_name, "content_type": content_type, "content": content_name},
+	)
 	if activity:
 		return True
 	else:
 		return False
 
+
 def check_quiz_completion(quiz, enrollment_name):
-	attempts = frappe.get_all("Quiz Activity",
-		filters={
-			'enrollment': enrollment_name,
-			'quiz': quiz.name
-		},
-		fields=["name", "activity_date", "score", "status", "time_taken"]
+	attempts = frappe.get_all(
+		"Quiz Activity",
+		filters={"enrollment": enrollment_name, "quiz": quiz.name},
+		fields=["name", "activity_date", "score", "status", "time_taken"],
 	)
 	status = False if quiz.max_attempts == 0 else bool(len(attempts) >= quiz.max_attempts)
 	score = None
 	result = None
 	time_taken = None
 	if attempts:
-		if quiz.grading_basis == 'Last Highest Score':
-			attempts = sorted(attempts, key = lambda i: int(i.score), reverse=True)
-		score = attempts[0]['score']
-		result = attempts[0]['status']
-		time_taken = attempts[0]['time_taken']
-		if result == 'Pass':
+		if quiz.grading_basis == "Last Highest Score":
+			attempts = sorted(attempts, key=lambda i: int(i.score), reverse=True)
+		score = attempts[0]["score"]
+		result = attempts[0]["status"]
+		time_taken = attempts[0]["time_taken"]
+		if result == "Pass":
 			status = True
 	return status, score, result, time_taken