-
-
-
-
-
- Course Materials
-
-
-
-
- Course Materials
-
-
-
-
- @include('layouts.guide')
-
-
-
-
-
-
-
Course Materials
+ @php + // Storing these in the DB can lead to complications if the user selects 'Other'. + // The main reason for this dropdown is to allow the text extraction service to + // handle different types (currently has special handling for Slides and Articles), + // and dropdown avoids free text not matching any condition due to minor differences. + $materialTypes = [ + 'Slides', + 'Article', + 'Textbook', + 'Video', + 'Podcast', + 'Website', + 'Notes', + 'Other', + ]; + @endphp + +
+ @include('courses.wizard.header')
+
+
+
+
+
diff --git a/laravel/routes/web.php b/laravel/routes/web.php
index 135a7bf8..6365551d 100644
--- a/laravel/routes/web.php
+++ b/laravel/routes/web.php
@@ -5,13 +5,15 @@
use App\Http\Controllers\AdminAssignRoleController;
use App\Http\Controllers\AssessmentMethodController;
use App\Http\Controllers\CourseController;
+use App\Http\Controllers\CourseMaterialController;
+use App\Http\Controllers\CourseMaterialFileController;
use App\Http\Controllers\CourseProgramController;
use App\Http\Controllers\CourseUserController;
use App\Http\Controllers\CourseWizardController;
+use App\Http\Controllers\CoverageAnalysisController;
use App\Http\Controllers\CustomAssessmentMethodsController;
use App\Http\Controllers\CustomLearningActivitiesController;
use App\Http\Controllers\CourseTopicController;
-use App\Http\Controllers\CourseMaterialController;
use App\Http\Controllers\FAQController;
use App\Http\Controllers\HomeController;
use App\Http\Controllers\InviteController;
@@ -265,6 +267,23 @@
Route::post('courseWizard/{courseId}/{programId}/check-ai-results', [CourseProgramController::class, 'checkAiResults']);
Route::post('courseWizard/{courseId}/{programId}/check-in-flight', [CourseProgramController::class, 'checkInFlight']);
+// Course materials (wizard metadata) + file uploads + Coverage Analysis
+Route::post('/courses/{course}/materials/{material}/files', [CourseMaterialFileController::class, 'store'])->name('course.material.files.store');
+Route::post('/courses/{course}/materials/{material}/files/{file}/refresh', [CourseMaterialFileController::class, 'refresh'])->name('course.material.files.refresh');
+Route::post('/courses/{course}/materials/{material}/files/{file}/topics', [CourseMaterialFileController::class, 'updateTopics'])->name('course.material.files.topics.update');
+Route::post('/courses/{course}/materials/{material}/files/{file}/topics/review', [CourseMaterialFileController::class, 'reviewTopics'])->name('course.material.files.topics.review');
+Route::post('/courses/{course}/materials/{material}/files/{file}/topics/accept-all', [CourseMaterialFileController::class, 'acceptAllTopics'])->name('course.material.files.topics.accept-all'); # Could remove this if needed
+Route::post('/courses/{course}/materials/{material}/files/{file}/topics/reject-all', [CourseMaterialFileController::class, 'rejectAllTopics'])->name('course.material.files.topics.reject-all'); # Could remove this if needed
+Route::get('/courses/{course}/materials/{material}/files/{file}', [CourseMaterialFileController::class, 'show'])->name('course.material.files.show');
+Route::delete('/courses/{course}/materials/{material}/files/{file}', [CourseMaterialFileController::class, 'destroy'])->name('course.material.files.destroy');
+Route::get('/courses/{course}/materials/{material}/files/{file}/thumbnail', [CourseMaterialFileController::class, 'thumbnail'])->name('course.material.files.thumbnail');
+Route::get('/courses/{course}/materials/{material}/files/{file}/view', [CourseMaterialFileController::class, 'view'])->name('course.material.files.view');
+Route::get('/courses/{course}/materials/{material}/files/{file}/download', [CourseMaterialFileController::class, 'download'])->name('course.material.files.download');
+Route::get('/courses/{course}/coverage-analysis', [CoverageAnalysisController::class, 'course'])->name('course.coverageAnalysis');
+Route::get('/courses/{course}/materials/search', [CoverageAnalysisController::class, 'searchCourse'])->name('course.materials.search');
+Route::get('/programs/{program}/materials/search', [CoverageAnalysisController::class, 'searchProgram'])->name('program.materials.search');
+Route::get('/programs/{program}/coverage-analysis', [CoverageAnalysisController::class, 'program'])->name('program.coverageAnalysis');
+
Route::post('/courseDescription/{course}/store', [\App\Http\Controllers\CourseDescriptionController::class, 'store'])->name('courseDescription.store');
// Save optional PLOs
diff --git a/laravel/tests/Browser/TextExtractionE2E/TopicReviewTest.php b/laravel/tests/Browser/TextExtractionE2E/TopicReviewTest.php
new file mode 100644
index 00000000..2c77ba46
--- /dev/null
+++ b/laravel/tests/Browser/TextExtractionE2E/TopicReviewTest.php
@@ -0,0 +1,95 @@
+actingAs($user);
+
+ $sourcePath = realpath(__DIR__ . '/fixtures/slides.pdf');
+ $this->assertNotEmpty($sourcePath, 'Fixture file must exist: slides.pdf');
+
+ $page = visit_v('/courseWizard/' . $course->course_id . '/step10');
+ $page->pressAndWaitFor('button:has-text("Show Files")', 1);
+ $page->pressAndWaitFor('button:has-text("Add File")', 1);
+ $page->attach('#uploadFileInput', $sourcePath);
+ $page->pressAndWaitFor('#uploadFileForm button[type="submit"]', 10);
+
+ $file = CourseMaterialFile::where('course_material_id', $material->course_material_id)
+ ->where('file_name', 'slides.pdf')
+ ->first();
+ $this->assertNotNull($file, 'File record should exist after upload');
+ $this->assertEquals(CourseMaterialFile::STATUS_INDEXED, $file->status);
+
+ // Review the uploaded file's suggested topics
+ $page->refresh()
+ ->wait(4);
+
+ $page->pressAndWaitFor("button[data-bs-target=\"#filesRow-{$material->course_material_id}\"]", 1);
+ $page->press('a[href*=\"files/{$file->course_material_file_id}\"]');
+ $page->wait(2);
+
+ $page->assertSee('Suggested Topics');
+
+ $suggested = SuggestedTopic::where('course_material_file_id', $file->course_material_file_id)
+ ->where('status', SuggestedTopic::STATUS_PENDING)
+ ->get();
+ $this->assertNotEmpty($suggested, 'Text extraction service should have produced suggested topics');
+
+ $firstSuggested = $suggested->first();
+ $page->press('.suggested-topic-row[data-id=\"{$firstSuggested->suggested_topic_id}\"] .review-confirm');
+ $page->wait(0.5);
+
+ $page->pressAndWaitFor('#save-review-btn', 3);
+
+ $topicText = $firstSuggested->topic;
+ $this->assertDatabaseHas('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => $topicText,
+ ]);
+
+ $courseTopic = CourseTopic::where('course_id', $course->course_id)
+ ->where('topic', $topicText)
+ ->first();
+ $this->assertDatabaseHas('course_material_file_topic', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'course_topic_id' => $courseTopic->course_topic_id,
+ ]);
+
+ $this->assertDatabaseMissing('suggested_topics', [
+ 'suggested_topic_id' => $firstSuggested->suggested_topic_id,
+ ]);
+
+ $page->pressAndWaitFor('button:has-text("Accept All")', 3);
+
+ // All remaining pending topics should now be confirmed
+ $remainingTopics = SuggestedTopic::where('course_material_file_id', $file->course_material_file_id)
+ ->where('status', SuggestedTopic::STATUS_PENDING)
+ ->get();
+ $this->assertTrue($remainingTopics->isEmpty(), 'All suggested topics should have been accepted');
+
+ // Verify each accepted topic became a course topic linked to the file
+ $allSuggested = SuggestedTopic::where('course_material_file_id', $file->course_material_file_id)->get();
+ foreach ($allSuggested as $s) {
+ $this->assertDatabaseHas('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => $s->topic,
+ ]);
+ }
+
+ // The Topics card on the page should now list the confirmed topics
+ $page->assertSee($topicText);
+});
diff --git a/laravel/tests/Browser/TextExtractionE2E/fixtures/slides.pdf b/laravel/tests/Browser/TextExtractionE2E/fixtures/slides.pdf
new file mode 100644
index 00000000..30caac18
Binary files /dev/null and b/laravel/tests/Browser/TextExtractionE2E/fixtures/slides.pdf differ
diff --git a/laravel/tests/Feature/CourseTest.php b/laravel/tests/Feature/CourseTest.php
index ca3f504d..b8142fcd 100644
--- a/laravel/tests/Feature/CourseTest.php
+++ b/laravel/tests/Feature/CourseTest.php
@@ -368,6 +368,7 @@ public function test_create_course_material_without_optional_fields(): void
'new_material' => [
0 => [
'name' => 'Course Website',
+ 'type' => 'website',
],
],
'course_id' => $course->course_id,
@@ -377,7 +378,7 @@ public function test_create_course_material_without_optional_fields(): void
$this->assertDatabaseHas('course_materials', [
'name' => 'Course Website',
- 'type' => null,
+ 'type' => 'website',
'description' => null,
'url' => null,
'is_required' => false,
@@ -428,14 +429,32 @@ public function test_course_material_requires_name(): void
$this->assertSame($materialCount, CourseMaterial::where('course_id', $course->course_id)->count());
}
- public function test_course_material_requires_course_id(): void
+ public function test_course_material_requires_type(): void
{
$user = User::where('email', 'test-course@ubc.ca')->first();
+ $course = Course::where('course_title', 'Intro to Unit Testing')->orderBy('course_id', 'DESC')->first();
+ $materialCount = CourseMaterial::where('course_id', $course->course_id)->count();
$response = $this->actingAs($user)->post(route('courseMaterials.store'), [
'new_material' => [
['name' => 'Forest Ecology'],
],
+ 'course_id' => $course->course_id,
+ ]);
+
+ $response->assertSessionHasErrors('new_material.0.type');
+ $this->assertSame($materialCount, CourseMaterial::where('course_id', $course->course_id)->count());
+ }
+
+ public function test_course_material_requires_course_id(): void
+ {
+ $user = User::where('email', 'test-course@ubc.ca')->first();
+
+ $response = $this->actingAs($user)->post(route('courseMaterials.store'), [
+ 'new_material' => [
+ ['name' => 'Forest Ecology',
+ 'type' => 'textbook'],
+ ],
]);
$response->assertSessionHasErrors('course_id');
diff --git a/laravel/tests/Feature/SuggestedTopicTest.php b/laravel/tests/Feature/SuggestedTopicTest.php
new file mode 100644
index 00000000..bbf9afa3
--- /dev/null
+++ b/laravel/tests/Feature/SuggestedTopicTest.php
@@ -0,0 +1,501 @@
+insert([
+ 'name' => 'Test Suggested Topic',
+ 'email' => 'test-suggested-topic@ubc.ca',
+ 'email_verified_at' => Carbon::now(),
+ 'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi',
+ ]);
+
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+
+ $this->actingAs($user)->post(route('courses.store'), [
+ 'course_code' => 'TEST',
+ 'course_num' => 101,
+ 'course_year' => 2026,
+ 'course_semester' => 'W1',
+ 'course_title' => 'Suggested Topic Test Course',
+ 'delivery_modality' => 'O',
+ 'assigned' => 1,
+ 'type' => 'unassigned',
+ 'standard_category_id' => 1,
+ 'scale_category_id' => 1,
+ 'user_id' => $user->id,
+ ]);
+
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ $suggested = SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Forest Ecology',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $response = $this->post(route('course.material.files.topics.review', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]), [
+ 'decisions' => [
+ ['id' => $suggested->suggested_topic_id, 'action' => 'confirm'],
+ ],
+ ]);
+
+ $response->assertRedirect();
+
+ $this->assertDatabaseHas('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => 'Forest Ecology',
+ ]);
+
+ $this->assertDatabaseMissing('suggested_topics', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Forest Ecology',
+ ]);
+ }
+
+ public function test_confirm_topic_no_duplication(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 2',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test2.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test2.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ CourseTopic::create([
+ 'course_id' => $course->course_id,
+ 'topic' => 'Climate Change',
+ 'position' => 1,
+ ]);
+
+ $suggested = SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Climate Change',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.review', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]), [
+ 'decisions' => [
+ ['id' => $suggested->suggested_topic_id, 'action' => 'confirm'],
+ ],
+ ]);
+
+ $topicCount = CourseTopic::where('course_id', $course->course_id)
+ ->where('topic', 'Climate Change')
+ ->count();
+
+ $this->assertEquals(1, $topicCount);
+ }
+
+ public function test_confirms_a_topic_case_insensitively_without_duplicating(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 3',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test3.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test3.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ CourseTopic::create([
+ 'course_id' => $course->course_id,
+ 'topic' => 'mycology basics',
+ 'position' => 2,
+ ]);
+
+ $suggested = SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Mycology Basics',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.review', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]), [
+ 'decisions' => [
+ ['id' => $suggested->suggested_topic_id, 'action' => 'confirm'],
+ ],
+ ]);
+
+ $topicCount = CourseTopic::where('course_id', $course->course_id)
+ ->whereRaw('LOWER(topic) = ?', ['mycology basics'])
+ ->count();
+
+ $this->assertEquals(1, $topicCount);
+ }
+
+ public function test_reject_suggested_topic(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 4',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test4.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test4.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ $suggested = SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Irrelevant Topic',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.review', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]), [
+ 'decisions' => [
+ ['id' => $suggested->suggested_topic_id, 'action' => 'reject'],
+ ],
+ ]);
+
+ $suggested->refresh();
+ $this->assertEquals(SuggestedTopic::STATUS_REJECTED, $suggested->status);
+
+ $this->assertDatabaseMissing('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => 'Irrelevant Topic',
+ ]);
+ }
+
+ public function test_accept_all_suggested_topics(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 5',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test5.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test5.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Topic A',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Topic B',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.accept-all', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]));
+
+ $this->assertDatabaseHas('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => 'Topic A',
+ ]);
+ $this->assertDatabaseHas('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => 'Topic B',
+ ]);
+
+ $this->assertDatabaseMissing('suggested_topics', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+ }
+
+ public function test_reject_all_suggested_topics(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 6',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test6.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test6.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Reject All Topic A',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Reject All Topic B',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.reject-all', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]));
+
+ $this->assertDatabaseHas('suggested_topics', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Reject All Topic A',
+ 'status' => SuggestedTopic::STATUS_REJECTED,
+ ]);
+ $this->assertDatabaseHas('suggested_topics', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Reject All Topic B',
+ 'status' => SuggestedTopic::STATUS_REJECTED,
+ ]);
+
+ $this->assertDatabaseMissing('course_topics', [
+ 'course_id' => $course->course_id,
+ 'topic' => 'Reject All Topic A',
+ ]);
+ }
+
+ public function test_preserve_rejected_topics_after_refresh(): void
+ {
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 7',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test7.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test7.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Rejected Topic',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_REJECTED,
+ ]);
+
+ SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Pending Topic',
+ 'score' => 0.75,
+ 'source' => 'match',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ CourseMaterialChunk::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'page_number' => 1,
+ 'chunk_index' => 0,
+ 'content' => 'Some extracted text.',
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.refresh', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]));
+
+ $this->assertDatabaseHas('suggested_topics', [
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Rejected Topic',
+ 'status' => SuggestedTopic::STATUS_REJECTED,
+ ]);
+ }
+
+ public function test_reviews_with_empty_decisions_does_nothing(): void
+ {
+ // In case user saves without changes
+ $user = User::where('email', 'test-suggested-topic@ubc.ca')->first();
+ $course = Course::where('course_title', 'Suggested Topic Test Course')->orderBy('course_id', 'DESC')->first();
+
+ $material = CourseMaterial::create([
+ 'course_id' => $course->course_id,
+ 'name' => 'Test Material 9',
+ 'type' => 'article',
+ ]);
+
+ $file = CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => 'test9.pdf',
+ 'file_path' => 'course-materials/' . $course->course_id . '/test9.pdf',
+ 'file_size' => 1024,
+ 'status' => CourseMaterialFile::STATUS_INDEXED,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+
+ $suggested = SuggestedTopic::create([
+ 'course_material_file_id' => $file->course_material_file_id,
+ 'topic' => 'Test Topic',
+ 'score' => 0.75,
+ 'source' => 'keyword',
+ 'status' => SuggestedTopic::STATUS_PENDING,
+ ]);
+
+ $this->actingAs($user);
+
+ $this->post(route('course.material.files.topics.review', [
+ $course->course_id,
+ $material->course_material_id,
+ $file->course_material_file_id,
+ ]), [
+ 'decisions' => [],
+ ]);
+
+ $suggested->refresh();
+ $this->assertEquals(SuggestedTopic::STATUS_PENDING, $suggested->status);
+ }
+}
diff --git a/laravel/tests/Helpers/AiSuggestionsE2E/Fixtures.php b/laravel/tests/Helpers/AiSuggestionsE2E/Fixtures.php
index 145231db..aabacd87 100644
--- a/laravel/tests/Helpers/AiSuggestionsE2E/Fixtures.php
+++ b/laravel/tests/Helpers/AiSuggestionsE2E/Fixtures.php
@@ -8,35 +8,6 @@
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Http;
-use Pest\Browser\Api\PendingAwaitablePage;
-
-function makeTestUser(string $email): User
-{
- DB::table('users')->insert([
- 'name' => 'Fixture User',
- 'email' => $email,
- 'email_verified_at' => Carbon::now(),
- 'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi',
- ]);
-
- return User::where('email', $email)->first();
-}
-
-function makeTestCourse(string $title = 'E2E Fixture Course'): Course
-{
- return Course::create([
- 'course_code' => 'E2E',
- 'course_num' => 101,
- 'course_title' => $title,
- 'delivery_modality' => 'O',
- 'year' => 2026,
- 'semester' => 'W1',
- 'assigned' => 1,
- 'type' => 'unassigned',
- 'created_at' => Carbon::now(),
- 'updated_at' => Carbon::now(),
- ]);
-}
function makeTestProgram(string $name = 'E2E Fixture Program'): Program
{
@@ -51,15 +22,6 @@ function makeTestProgram(string $name = 'E2E Fixture Program'): Program
]);
}
-function linkUserToCourse(User $user, Course $course, int $permission = 1): void
-{
- DB::table('course_users')->insert([
- 'course_id' => $course->course_id,
- 'user_id' => $user->id,
- 'permission' => $permission,
- ]);
-}
-
function linkUserToProgram(User $user, Program $program, int $permission = 1): void
{
DB::table('program_users')->insert([
@@ -217,25 +179,3 @@ function createManuallyButton(int $courseId, int $programId): string
return "button[onclick=\"showManualMapDiv({$courseId}, {$programId})\"]";
}
-/**
- * Wraps Pest's visit with viewport dimensions.
- * Seems to reduce the flakiness by preventing elements from going off-screen.
- * Make sure to set the resolution to something SMALLER than your monitor's resolution
- */
-function visit_v(string $url) : PendingAwaitablePage
-{
- $width = env('PLAYWRIGHT_VIEWPORT_WIDTH');
- $height = env('PLAYWRIGHT_VIEWPORT_HEIGHT');
-
- if ($width && $height) {
- $page = visit($url, [
- 'viewport' => ['width' => (int) $width, 'height' => (int) $height],
- 'deviceScaleFactor' => 1,
- ]);
- } else {
- $page = visit($url);
- }
-
- return $page;
-}
-
diff --git a/laravel/tests/Helpers/Shared/Fixtures.php b/laravel/tests/Helpers/Shared/Fixtures.php
new file mode 100644
index 00000000..29c47cfb
--- /dev/null
+++ b/laravel/tests/Helpers/Shared/Fixtures.php
@@ -0,0 +1,70 @@
+first();
+ if ($user) return $user;
+
+ DB::table('users')->insert([
+ 'name' => 'E2E Test User',
+ 'email' => $email,
+ 'email_verified_at' => Carbon::now(),
+ 'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi',
+ ]);
+
+ return User::where('email', $email)->first();
+}
+
+function makeTestCourse(string $title): Course
+{
+ return Course::create([
+ 'course_code' => 'E2E',
+ 'course_num' => 101,
+ 'course_title' => $title,
+ 'delivery_modality' => 'O',
+ 'year' => 2026,
+ 'semester' => 'W1',
+ 'assigned' => 1,
+ 'type' => 'unassigned',
+ 'scale_category_id' => 1,
+ 'created_at' => Carbon::now(),
+ 'updated_at' => Carbon::now(),
+ ]);
+}
+
+function linkUserToCourse(User $user, Course $course, int $permission = 1): void
+{
+ DB::table('course_users')->insert([
+ 'course_id' => $course->course_id,
+ 'user_id' => $user->id,
+ 'permission' => $permission,
+ ]);
+}
+
+/**
+ * Wraps Pest's visit with viewport dimensions.
+ * Seems to reduce the flakiness by preventing elements from going off-screen.
+ * Make sure to set the resolution to something SMALLER than your monitor's resolution
+ */
+function visit_v(string $url) : PendingAwaitablePage
+{
+ $width = env('PLAYWRIGHT_VIEWPORT_WIDTH');
+ $height = env('PLAYWRIGHT_VIEWPORT_HEIGHT');
+
+ if ($width && $height) {
+ $page = visit($url, [
+ 'viewport' => ['width' => (int) $width, 'height' => (int) $height],
+ 'deviceScaleFactor' => 1,
+ ]);
+ } else {
+ $page = visit($url);
+ }
+
+ return $page;
+}
diff --git a/laravel/tests/Helpers/TextExtractionE2E/Fixtures.php b/laravel/tests/Helpers/TextExtractionE2E/Fixtures.php
new file mode 100644
index 00000000..3e435db2
--- /dev/null
+++ b/laravel/tests/Helpers/TextExtractionE2E/Fixtures.php
@@ -0,0 +1,51 @@
+ $course->course_id,
+ 'name' => $name,
+ 'type' => 'article',
+ ]);
+}
+
+function addCourseTopic(Course $course, string $topic): CourseTopic
+{
+ return CourseTopic::create([
+ 'course_id' => $course->course_id,
+ 'topic' => $topic,
+ 'position' => CourseTopic::where('course_id', $course->course_id)->max('position') + 1,
+ ]);
+}
+
+function uploadFixturePdf(Course $course, CourseMaterial $material, string $fixtureName): CourseMaterialFile
+{
+ $fixturePath = base_path("tests/Browser/TextExtractionE2E/fixtures/{$fixtureName}");
+ $diskPath = "course-materials/{$course->course_id}/" . \Illuminate\Support\Str::uuid() . '.pdf';
+
+ Storage::disk('local')->put($diskPath, file_get_contents($fixturePath));
+
+ return CourseMaterialFile::create([
+ 'course_material_id' => $material->course_material_id,
+ 'course_id' => $course->course_id,
+ 'uploaded_by' => Auth::id(),
+ 'file_name' => $fixtureName,
+ 'file_path' => $diskPath,
+ 'file_size' => filesize($fixturePath),
+ 'status' => CourseMaterialFile::STATUS_PENDING,
+ 'extraction_engine' => 'tesseract',
+ 'ocr_enabled' => false,
+ 'ocr_threshold' => 0,
+ ]);
+}
+
+function materialFileUrl(Course $course, CourseMaterial $material, CourseMaterialFile $file): string
+{
+ return "/courses/{$course->course_id}/materials/{$material->course_material_id}/files/{$file->course_material_file_id}";
+}
diff --git a/laravel/tests/Pest.php b/laravel/tests/Pest.php
index 835ad50b..f0d46887 100644
--- a/laravel/tests/Pest.php
+++ b/laravel/tests/Pest.php
@@ -29,6 +29,13 @@
->beforeEach(fn() => clearDynamoDb())
->in('Browser/AiSuggestionsE2E');
+pest()->extend(TestCase::class)
+ ->group('text-extraction-e2e')
+ ->beforeAll(function () {
+ startTestingDbServer();
+ })
+ ->in('Browser/TextExtractionE2E');
+
/*
|--------------------------------------------------------------------------
| Expectations
diff --git a/python/services/lo_mapping_service/app/api/routes.py b/python/services/lo_mapping_service/app/api/routes.py
index 22fd1904..385eed1f 100644
--- a/python/services/lo_mapping_service/app/api/routes.py
+++ b/python/services/lo_mapping_service/app/api/routes.py
@@ -55,7 +55,7 @@ async def lifespan(app: FastAPI):
app.add_middleware(
CORSMiddleware,
allow_origins=settings.ALLOWED_ORIGINS,
- allow_credentials=True,
+ allow_credentials=False,
allow_methods=["*"],
allow_headers=["*"]
)
diff --git a/python/services/syllabi_service/app/api/routes.py b/python/services/syllabi_service/app/api/routes.py
index 7121cc01..4f44969d 100644
--- a/python/services/syllabi_service/app/api/routes.py
+++ b/python/services/syllabi_service/app/api/routes.py
@@ -15,7 +15,7 @@
app.add_middleware(
CORSMiddleware,
allow_origins=settings.ALLOWED_ORIGINS,
- allow_credentials=True,
+ allow_credentials=False,
allow_methods=["*"],
allow_headers=["*"]
)
diff --git a/python/services/text_extraction_service/.env.example b/python/services/text_extraction_service/.env.example
new file mode 100644
index 00000000..a15117c7
--- /dev/null
+++ b/python/services/text_extraction_service/.env.example
@@ -0,0 +1,4 @@
+AWS_ACCESS_KEY_ID=your_aws_key
+AWS_SECRET_ACCESS_KEY=your_aws_secret
+AWS_REGION=ca-central-1
+AWS_S3_BUCKET=text-extraction-temp
diff --git a/python/services/text_extraction_service/app/__init__.py b/python/services/text_extraction_service/app/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python/services/text_extraction_service/app/api/__init__.py b/python/services/text_extraction_service/app/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python/services/text_extraction_service/app/api/routes.py b/python/services/text_extraction_service/app/api/routes.py
new file mode 100644
index 00000000..8c8f0276
--- /dev/null
+++ b/python/services/text_extraction_service/app/api/routes.py
@@ -0,0 +1,104 @@
+from fastapi import FastAPI, HTTPException, File, Form, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.core.logging_config import logger
+from app.schemas import (
+ ExtractRequestMetadata,
+ ExtractResponse,
+ RefreshTopicsRequest,
+ PageContent,
+ ExtractedPage,
+ ExtractedLine,
+)
+from app.services.text_readers import document_extractor
+from app.services.topic_extraction import type_specific_handlers
+
+
+app = FastAPI(
+ title="Course Material Text & Topic Extraction Service",
+ version="0.1.0",
+ docs_url="/docs",
+ redoc_url="/redoc",
+)
+
+app.add_middleware(
+ CORSMiddleware,
+ allow_origins=settings.ALLOWED_ORIGINS,
+ allow_credentials=False,
+ allow_methods=["*"],
+ allow_headers=["*"]
+)
+
+
+@app.get("/health")
+async def health_check() -> dict[str, str]:
+ return {"status": "ok"}
+
+
+@app.post("/extract", response_model=ExtractResponse)
+async def extract(
+ file: UploadFile = File(...),
+ metadata: str = Form("{}"),
+) -> ExtractResponse:
+ """Extract per-page text and topics from a PDF in a single pass using multipart form-data."""
+ try:
+ request_metadata = ExtractRequestMetadata.model_validate_json(metadata)
+ except Exception as e:
+ raise HTTPException(
+ status_code=422,
+ detail=f"Invalid metadata JSON format: {e}",
+ )
+
+ if request_metadata.extraction_engine == "textract" and not (settings.AWS_ACCESS_KEY_ID and settings.AWS_SECRET_ACCESS_KEY):
+ raise HTTPException(
+ status_code=501,
+ detail="Textract extraction requires AWS credentials; configure AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY.",
+ )
+ try:
+ handler = type_specific_handlers.get_handler(request_metadata.material_type)
+ file_bytes = await file.read()
+ pages, page_count = document_extractor.extract(
+ file_bytes,
+ request_metadata.ocr_enabled,
+ request_metadata.extraction_engine,
+ request_metadata.ocr_threshold,
+ )
+ topics = handler.extract_topics(pages, request_metadata.existing_topics)
+
+ return ExtractResponse(
+ pages=[
+ PageContent(page_number=page.page_number, content="\n".join(line.text for line in page.lines))
+ for page in pages
+ if page.lines
+ ],
+ page_count=page_count,
+ topics=topics,
+ )
+ except Exception as e:
+ logger.error(f"Extraction failed: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/refresh-topics", response_model=ExtractResponse)
+def refresh_topics(request: RefreshTopicsRequest) -> ExtractResponse:
+ """Re-extract topics from existing page content, skipping text extraction."""
+ try:
+ handler = type_specific_handlers.get_handler(request.material_type)
+ pages = [
+ ExtractedPage(
+ page_number=p.page_number,
+ lines=[ExtractedLine(text=line) for line in p.content.split("\n") if line.strip()],
+ )
+ for p in request.pages
+ ]
+ topics = handler.refresh_topics(pages, request.existing_topics)
+
+ return ExtractResponse(
+ pages=request.pages,
+ page_count=len(request.pages),
+ topics=topics,
+ )
+ except Exception as e:
+ logger.error(f"Topic refresh failed: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
diff --git a/python/services/text_extraction_service/app/core/__init__.py b/python/services/text_extraction_service/app/core/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python/services/text_extraction_service/app/core/config.py b/python/services/text_extraction_service/app/core/config.py
new file mode 100644
index 00000000..712e3c5c
--- /dev/null
+++ b/python/services/text_extraction_service/app/core/config.py
@@ -0,0 +1,25 @@
+from typing import List
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import field_validator
+
+
+class Settings(BaseSettings):
+ ALLOWED_ORIGINS: str = ""
+ AWS_REGION: str = "ca-central-1"
+ AWS_S3_BUCKET: str = "text-extraction-temp"
+ AWS_ACCESS_KEY_ID: str | None = None
+ AWS_SECRET_ACCESS_KEY: str | None = None
+
+ @field_validator("ALLOWED_ORIGINS")
+ def parse_allowed_origins(cls, v: str) -> List[str]:
+ return v.split(",") if v else []
+
+ model_config = SettingsConfigDict(
+ env_file='.env',
+ env_file_encoding='utf-8',
+ case_sensitive=True,
+ extra="ignore",
+ )
+
+
+settings = Settings()
diff --git a/python/services/text_extraction_service/app/core/logging_config.py b/python/services/text_extraction_service/app/core/logging_config.py
new file mode 100644
index 00000000..1a609c3b
--- /dev/null
+++ b/python/services/text_extraction_service/app/core/logging_config.py
@@ -0,0 +1,26 @@
+import logging
+from pathlib import Path
+
+from pythonjsonlogger import jsonlogger
+
+
+logger = logging.getLogger(__name__)
+
+current_file = Path(__file__).resolve()
+base_dir = current_file.parents[3]
+logs_dir = base_dir / "logs"
+logs_dir.mkdir(parents=True, exist_ok=True)
+
+file_handler = logging.FileHandler(logs_dir / "app.log")
+
+json_formatter = jsonlogger.JsonFormatter(
+ "%(name)s %(asctime)s %(levelname)s %(filename)s %(lineno)s %(process)d %(message)s",
+ rename_fields={"levelname": "severity", "asctime": "timestamp"},
+ datefmt="%Y-%m-%dT%H:%M:%SZ",
+)
+
+file_handler.setFormatter(json_formatter)
+
+logger.addHandler(file_handler)
+
+logger.setLevel(logging.DEBUG)
diff --git a/python/services/text_extraction_service/app/main.py b/python/services/text_extraction_service/app/main.py
new file mode 100644
index 00000000..564ce55a
--- /dev/null
+++ b/python/services/text_extraction_service/app/main.py
@@ -0,0 +1,6 @@
+import uvicorn
+
+if __name__ == "__main__":
+ config = uvicorn.Config("app.api.routes:app", host="127.0.0.1", port=8003, reload=True)
+ server = uvicorn.Server(config)
+ server.run()
diff --git a/python/services/text_extraction_service/app/schemas.py b/python/services/text_extraction_service/app/schemas.py
new file mode 100644
index 00000000..4a8d3228
--- /dev/null
+++ b/python/services/text_extraction_service/app/schemas.py
@@ -0,0 +1,62 @@
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class TopicSource(str, Enum):
+ MATCH = "match"
+ FONT = "font"
+ KEYWORD = "keyword"
+
+
+class ExtractedLine(BaseModel):
+ text: str
+ size: float | None = None
+ bold: bool | None = None
+
+
+class ExtractedPage(BaseModel):
+ page_number: int
+ lines: list[ExtractedLine]
+
+
+class PageContent(BaseModel):
+ page_number: int
+ content: str
+
+
+class Topic(BaseModel):
+ topic: str
+ score: float
+ source: TopicSource = TopicSource.MATCH
+
+ model_config = {"frozen": True} # Used for checking equality in tests
+
+
+class ExtractRequestMetadata(BaseModel):
+ # Called initially when you want to extract text and topics from a PDF
+ # Text extraction gives us useful font properties that are used by topic extraction in the same pass
+ # Also used if text extraction failed and needs to be retried
+ # The actual file is sent as multipart form-data
+ # and this metadata is sent as a JSON string
+ ocr_enabled: bool = False
+ extraction_engine: str = "tesseract"
+ ocr_threshold: int = 0
+ material_type: Optional[str] = None
+ existing_topics: list[str] = []
+
+
+class RefreshTopicsRequest(BaseModel):
+ # Called when you've already extracted text and topics,
+ # and just want to refresh keyword extracted topics (that are random to some degree)
+ # and matched topics (that can differ if the Course-wide topics list changes anywhere)
+ pages: list[PageContent]
+ material_type: Optional[str] = None
+ existing_topics: list[str] = []
+
+
+class ExtractResponse(BaseModel):
+ pages: list[PageContent]
+ page_count: int
+ topics: list[Topic]
\ No newline at end of file
diff --git a/python/services/text_extraction_service/app/services/__init__.py b/python/services/text_extraction_service/app/services/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python/services/text_extraction_service/app/services/text_readers/document_extractor.py b/python/services/text_extraction_service/app/services/text_readers/document_extractor.py
new file mode 100644
index 00000000..a075cae2
--- /dev/null
+++ b/python/services/text_extraction_service/app/services/text_readers/document_extractor.py
@@ -0,0 +1,117 @@
+import io
+import statistics
+
+import pymupdf
+import pytesseract
+from PIL import Image
+
+from app.core.config import settings
+from app.core.logging_config import logger
+from app.schemas import ExtractedLine, ExtractedPage
+from app.services.text_readers.textract_extractor import TextractClient
+
+OCR_RENDER_DPI = 300
+MIN_OCR_CONFIDENCE = 40
+
+# PyMuPDF flag bit for bold text.
+_BOLD_FLAG = 0b10000
+
+_textract_client: TextractClient | None = None
+
+
+def _get_textract_client() -> TextractClient:
+ """Lazy singleton for the Textract client (avoids boto3 import at module load)."""
+ global _textract_client
+ if _textract_client is None:
+ _textract_client = TextractClient(settings)
+ return _textract_client
+
+
+def extract(
+ file_bytes: bytes,
+ ocr_enabled: bool,
+ extraction_engine: str,
+ ocr_threshold: int,
+) -> tuple[list[ExtractedPage], int]:
+ """Extract text per page and annotate with font properties per line.
+
+ Returns (pages, page_count), where each page is an ExtractedPage with
+ page_number and ExtractedLine objects.
+ """
+ doc: pymupdf.Document = pymupdf.open(stream=file_bytes, filetype="pdf")
+ page_count = doc.page_count
+
+ if ocr_enabled and extraction_engine == "textract":
+ doc.close()
+ return _get_textract_client().extract_text(file_bytes, page_count)
+
+ logger.info(f"Extracting {page_count}-page document (ocr_enabled={ocr_enabled})")
+
+ pages: list[ExtractedPage] = []
+ try:
+ for i in range(page_count):
+ page: pymupdf.Page = doc[i]
+ if ocr_enabled and extraction_engine == "tesseract" and len(page.get_text("text").strip()) <= ocr_threshold:
+ lines = _from_ocr(page)
+ else:
+ lines = _from_text_layer(page)
+ pages.append(ExtractedPage(page_number=i + 1, lines=lines))
+ finally:
+ doc.close()
+
+ return pages, page_count
+
+
+def _from_text_layer(page) -> list[ExtractedLine]:
+ lines: list[ExtractedLine] = []
+ for block in page.get_text("dict", flags=pymupdf.TEXT_COLLECT_STYLES).get("blocks", []):
+ for line in block.get("lines", []):
+ spans = line.get("spans", [])
+ text = "".join(span.get("text", "") for span in spans).strip()
+ if not text:
+ continue
+ size = max((span.get("size", 0.0) for span in spans), default=0.0)
+ bold = any(_is_bold(span) for span in spans)
+ lines.append(ExtractedLine(text=text, size=round(size, 1), bold=bold))
+ return lines
+
+
+def _is_bold(span) -> bool:
+ if span.get("flags", 0) & _BOLD_FLAG:
+ return True
+ return "bold" in span.get("font", "").lower()
+
+
+def _from_ocr(page) -> list[ExtractedLine]:
+ pixmap = page.get_pixmap(dpi=OCR_RENDER_DPI)
+ image = Image.open(io.BytesIO(pixmap.tobytes("png")))
+ data = pytesseract.image_to_data(image, output_type=pytesseract.Output.DICT)
+
+ grouped: dict[tuple, list[tuple[int, str]]] = {}
+ for i, raw_word in enumerate(data["text"]):
+ word = raw_word.strip()
+ if not word:
+ continue
+ try:
+ confidence = float(data["conf"][i])
+ except (ValueError, TypeError):
+ confidence = -1.0
+ if confidence < MIN_OCR_CONFIDENCE:
+ continue
+ key = (data["block_num"][i], data["par_num"][i], data["line_num"][i])
+ grouped.setdefault(key, []).append((data["height"][i], word))
+
+ lines: list[ExtractedLine] = []
+ for _, words in sorted(grouped.items()):
+ text = " ".join(word for _, word in words).strip()
+ if not text:
+ continue
+ # Convert median box height (px at OCR_RENDER_DPI) to an approximate point
+ # size, so size is comparable to actual font size, and a single size threshold
+ # works for both readable and scanned pages.
+ height_px = statistics.median(height for height, _ in words)
+ size_pt = height_px * 72 / OCR_RENDER_DPI
+ # Cannot easily determine if bold with Tesseract
+ lines.append({"text": text, "size": round(float(size_pt), 1), "bold": None})
+
+ return lines
diff --git a/python/services/text_extraction_service/app/services/text_readers/textract_extractor.py b/python/services/text_extraction_service/app/services/text_readers/textract_extractor.py
new file mode 100644
index 00000000..44afc091
--- /dev/null
+++ b/python/services/text_extraction_service/app/services/text_readers/textract_extractor.py
@@ -0,0 +1,137 @@
+import os
+import time
+
+import boto3
+
+from app.core.config import Settings
+from app.core.logging_config import logger
+from app.schemas import ExtractedLine, ExtractedPage
+
+POLLING_INTERVAL_SECONDS = 2
+MAX_WAIT_SECONDS = 600
+
+
+class TextractClient:
+ """Manages AWS Textract interactions for document text extraction."""
+
+ def __init__(self, settings: Settings | None = None):
+ self.settings = settings or Settings()
+
+ def extract_text(self, file_bytes: bytes, page_count: int) -> tuple[list[ExtractedPage], int]:
+ """Extract text from a PDF document using AWS Textract.
+
+ For single-page documents, uses direct synchronous Textract call.
+ For multi-page documents, uploads to S3 and uses async Textract job.
+
+ Returns (pages, page_count), where each page is an ExtractedPage with
+ page_number and lines. Lines are ExtractedLine objects with size=None
+ and bold=None since Textract does not provide font metadata.
+ """
+ self._validate_settings()
+ session = self._create_boto_session()
+
+ if page_count == 1:
+ try:
+ return self._single_page_doc_extract(session, file_bytes), page_count
+ except Exception as e:
+ logger.info("Synchronous Textract failed: %s; falling back to async", e)
+ else:
+ return self._start_multi_page_extract_job(session, file_bytes), page_count
+
+ def _single_page_doc_extract(self, session: boto3.Session, file_bytes: bytes) -> list[ExtractedPage]:
+ """Single-page extraction using the synchronous detect_document_text API."""
+ response = session.client("textract").detect_document_text(Document={"Bytes": file_bytes})
+ return _parse_textract_response(response)
+
+ def _start_multi_page_extract_job(self, session: boto3.Session, file_bytes: bytes) -> list[ExtractedPage]:
+ """Multi-page extraction using async start/get document text detection via S3.
+ Uploads the document to S3, then deletes it once the job succeeds, fails, or times out.
+ """
+ textract = session.client("textract")
+ s3 = session.client("s3")
+
+ s3_key = f"textract-jobs/{int(time.time())}-{os.urandom(4).hex()}.pdf"
+ s3.put_object(Bucket=self.settings.AWS_S3_BUCKET, Key=s3_key, Body=file_bytes)
+
+ try:
+ job_id = textract.start_document_text_detection(
+ DocumentLocation={"S3Object": {"Bucket": self.settings.AWS_S3_BUCKET, "Name": s3_key}}
+ )["JobId"]
+ logger.info("Started async Textract job %s", job_id)
+
+ return self._poll_job(textract, job_id)
+ finally:
+ try:
+ s3.delete_object(Bucket=self.settings.AWS_S3_BUCKET, Key=s3_key)
+ logger.info("Deleted S3 object %s", s3_key)
+ except Exception as e:
+ logger.warning("Failed to delete S3 object %s: %s", s3_key, e)
+
+ def _poll_job(self, textract, job_id: str) -> list[ExtractedPage]:
+ """Poll Textract until the job succeeds, fails, or times out."""
+ start = time.time()
+ while time.time() - start < MAX_WAIT_SECONDS:
+ response = textract.get_document_text_detection(JobId=job_id)
+ status = response["JobStatus"]
+ logger.info("Textract job %s status: %s", job_id, status)
+
+ if status == "SUCCEEDED":
+ return self._collect_results(textract, job_id, response)
+ if status == "FAILED":
+ raise RuntimeError("Textract job %s failed", job_id)
+
+ time.sleep(POLLING_INTERVAL_SECONDS)
+
+ raise TimeoutError("Textract job %s did not complete within %ss", job_id, MAX_WAIT_SECONDS)
+
+ def _collect_results(self, textract, job_id: str, initial_response: dict) -> list[ExtractedPage]:
+ """Paginate through all Textract results and parse into pages."""
+ all_blocks = initial_response["Blocks"]
+ next_token = initial_response.get("NextToken")
+
+ while next_token:
+ page = textract.get_document_text_detection(JobId=job_id, NextToken=next_token)
+ all_blocks.extend(page["Blocks"])
+ next_token = page.get("NextToken")
+
+ return _parse_textract_response({"Blocks": all_blocks})
+
+ def _validate_settings(self) -> None:
+ """Ensure required AWS configuration is present before making API calls."""
+ s = self.settings
+ if not s.AWS_ACCESS_KEY_ID or not s.AWS_SECRET_ACCESS_KEY:
+ raise ValueError("AWS credentials (ACCESS_KEY_ID, SECRET_ACCESS_KEY) are not set")
+ if not s.AWS_REGION:
+ raise ValueError("AWS_REGION is not set")
+ if not s.AWS_S3_BUCKET:
+ raise ValueError("AWS_S3_BUCKET is not set")
+
+ def _create_boto_session(self) -> boto3.Session:
+ return boto3.Session(
+ aws_access_key_id=self.settings.AWS_ACCESS_KEY_ID,
+ aws_secret_access_key=self.settings.AWS_SECRET_ACCESS_KEY,
+ region_name=self.settings.AWS_REGION,
+ )
+
+
+def _parse_textract_response(response: dict) -> list[ExtractedPage]:
+ """Parse a Textract response into a list of ExtractedPage objects."""
+ blocks = response.get("Blocks", [])
+ pages_by_number: dict[int, list[str]] = {}
+ for block in blocks:
+ page_num = block.get("Page")
+ if block["BlockType"] == "PAGE":
+ pages_by_number.setdefault(page_num, [])
+ elif block["BlockType"] == "LINE" and page_num in pages_by_number:
+ pages_by_number[page_num].append(block["Text"])
+
+ pages: list[ExtractedPage] = []
+ for page_num in sorted(pages_by_number):
+ lines = [
+ ExtractedLine(text=line.strip())
+ for line in pages_by_number[page_num]
+ if line.strip()
+ ]
+ pages.append(ExtractedPage(page_number=page_num, lines=lines))
+
+ return pages
diff --git a/python/services/text_extraction_service/app/services/topic_extraction/bertopic_extractor.py b/python/services/text_extraction_service/app/services/topic_extraction/bertopic_extractor.py
new file mode 100644
index 00000000..e82dc02b
--- /dev/null
+++ b/python/services/text_extraction_service/app/services/topic_extraction/bertopic_extractor.py
@@ -0,0 +1,116 @@
+import math
+
+from app.schemas import Topic, TopicSource
+
+from bertopic import BERTopic
+from bertopic.representation import MaximalMarginalRelevance
+from sklearn.feature_extraction.text import CountVectorizer, ENGLISH_STOP_WORDS
+import spacy
+
+from sentence_transformers import SentenceTransformer
+
+TOPICS_COUNT = 20 # max topics returned - we will likely never get so many, just prevents DB overloading
+TOPICS_PER_CLUSTER = 10 # top words taken from each cluster
+MIN_TOPIC_SIZE = 5 # min sentences to form a cluster (small docs need a low value)
+
+WORDS_TO_JUMP_RATIO = 137 # Optimized with trial and error so far
+OVERLAP_PROPORTION = 0.25
+
+PAGE_BREAK = "PAGE_BREAK" # ! If this exact string appears in the text, it may cause extra splitting and suboptimal results
+CUSTOM_STOP_WORDS = [
+ PAGE_BREAK,
+ # Citations
+ "et", "al", "et.", "al.",
+ # Diagrams
+ "plot", "chart", "diagram", "graph", "data", "datum", "figure"
+ # Units
+ "cm", "mm", "m", "km", "ha", "m3", "m2", "m³", "m²", "g", "kg", "t", "tonne", "tonnes", "°C", "°F", "K",
+]
+
+def extract(text: str, min_topic_size = MIN_TOPIC_SIZE) -> list[Topic]:
+ """Extract topics from text using BERTopic.
+
+ BERTopic clusters a set of documents, so the text is split into overlapping
+ windows and treated as the document set.
+ """
+
+ print("BERTopic extraction starting...")
+
+ deduped_text = _dedupe_plurals(text)
+ docs = _to_documents(deduped_text, OVERLAP_PROPORTION)
+ doc_count = len(docs)
+ print(f"Split text into {doc_count} documents for topic extraction")
+ print("Extracting topics from text...")
+
+ # min_df is an integer count of documents, while max_df is a proportion of the total number of documents
+ min_df = min(2, round(doc_count * 0.01, 1))
+ max_df = 1.0
+ print(f"Using min_df={min_df} and max_df={max_df} with {doc_count} docs for CountVectorizer")
+
+ vectorizer_model = CountVectorizer(
+ stop_words=list(ENGLISH_STOP_WORDS.union(list(map(str.lower, CUSTOM_STOP_WORDS)))),
+ ngram_range=(1, 3),
+ min_df=min_df,
+ max_df=max_df,
+ lowercase=False, # This is useful to keep abbreviations in UPPERCASE, but can cause duplication
+ )
+ # TODO: Add a local copy of the model in case the HF repo is taken down
+ embedding_model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+ representation_model = MaximalMarginalRelevance(diversity=0.8)
+
+ print("Set up embedding and representation models for BERTopic")
+
+ topic_model = BERTopic(
+ embedding_model=embedding_model,
+ vectorizer_model=vectorizer_model,
+ representation_model=representation_model,
+ min_topic_size=max(min_topic_size, 2),
+ calculate_probabilities=False,
+ verbose=True,
+ )
+
+ print("Configured BERTopic model, fitting to documents...")
+
+ try:
+ topic_model.fit_transform(docs)
+ print("Points:", topic_model.get_document_info(docs).shape[0], len(docs))
+ except Exception as e:
+ print(f"BERTopic extraction failed: {e}")
+ return []
+
+ topics: list[Topic] = []
+ seen: set[str] = set()
+
+ print("Extracting topics from fitted model...")
+
+ for topic_id in topic_model.get_topic_info()["Topic"]:
+ for word, score in topic_model.get_topic(topic_id)[:TOPICS_PER_CLUSTER]:
+ print(f"Topic {topic_id}: {word} ({score})")
+ key = word.strip().lower()
+ if key and key not in seen:
+ seen.add(key)
+ topics.append(Topic(topic = word.strip(), score = round(float(score), 4), source=TopicSource.KEYWORD))
+ topics_sorted = sorted(topics, key=lambda t: t.score, reverse=True)
+ return topics_sorted[:TOPICS_COUNT]
+
+def _dedupe_plurals(text: str) -> str:
+ """Lemmatize tokens to group plurals and other variants of the same word together"""
+ print("Lemmatizing text to deduplicate plurals...")
+ nlp_model = spacy.load("en_core_web_sm")
+ nlp_model.tokenizer.add_special_case(PAGE_BREAK, [{"ORTH": PAGE_BREAK}])
+ doc = nlp_model(text)
+ return " ".join([token.lemma_ for token in doc])
+
+
+def _to_documents(text: str, overlap_proportion: float) -> list[str]:
+ word_count = len(text.split())
+ window_size = max(round(math.sqrt(word_count)), 20)
+ step = max(round(window_size * (1 - overlap_proportion)), 1)
+
+ paragraphs = []
+ words = text.split()
+ for i in range(0, len(words), step):
+ paragraph = " ".join(words[i:i + window_size])
+ paragraphs.append(paragraph)
+
+ return paragraphs
diff --git a/python/services/text_extraction_service/app/services/topic_extraction/postprocessor.py b/python/services/text_extraction_service/app/services/topic_extraction/postprocessor.py
new file mode 100644
index 00000000..994bdb7d
--- /dev/null
+++ b/python/services/text_extraction_service/app/services/topic_extraction/postprocessor.py
@@ -0,0 +1,90 @@
+from itertools import chain
+
+from app.schemas import Topic, TopicSource
+import spacy
+
+def process(topics: list[Topic], filterLowerCaseSingleWords = False, minTopicCharCount = 5, scoreThreshold = 0.5) -> list[Topic]:
+ """Postprocess extracted topics"""
+
+ # Remove topics that are empty or too long
+ MIN_TOPIC_WORD_COUNT = 1
+ MAX_TOPIC_WORD_COUNT = 8
+ trimmed_topics = [t for t in topics if MIN_TOPIC_WORD_COUNT <= len(t.topic.split()) <= MAX_TOPIC_WORD_COUNT]
+
+ # For 1-word topics, check their length and optionally their case
+ word_filtered_topics = []
+ for t in trimmed_topics:
+ words = t.topic.split()
+ if len(words) == 1:
+ word = words[0]
+ if ((not filterLowerCaseSingleWords) or (word.istitle() or word.isupper())) and len(word) >= minTopicCharCount:
+ word_filtered_topics.append(t)
+ else:
+ word_filtered_topics.append(t)
+
+ # Remove duplicates (case-insensitive)
+ seen = set()
+ deduped_topics = []
+ for t in word_filtered_topics:
+ topic_lower = t.topic.lower()
+ if topic_lower not in seen:
+ seen.add(topic_lower)
+ deduped_topics.append(t)
+
+ # Remove topics with numbers in them
+ number_filtered_topics = []
+ for t in deduped_topics:
+ # TODO: Should this be not all instead of not any? Can any topics actually have numbers?
+ if not all(char.isdigit() or char.isspace() for char in t.topic):
+ number_filtered_topics.append(t)
+
+ # Remove topics containing file or web URL elements
+ url_filtered_topics = []
+ for t in number_filtered_topics:
+ if any(word in t.topic.lower().split() for word in ["com", "org"]):
+ continue
+ if any(word in t.topic.lower() for word in ["http", "jpg", "png", "www"]):
+ continue
+ url_filtered_topics.append(t)
+
+ # Only keep topics that end with a noun or a verb ending in "ing"
+ noun_filtered_topics = []
+ nlp = spacy.load("en_core_web_sm") # Shouldn't slow down here, since it'll be cached from the BERTopic extractor
+ for t in url_filtered_topics:
+ doc = nlp(t.topic)
+ if doc[-1].pos_ in ["NOUN", "PROPN"] or (doc[-1].pos_ == "VERB" and doc[-1].text.endswith("ing")):
+ noun_filtered_topics.append(t)
+
+ # Remove stop words from initial or final position in multi-word topics
+ stop_words = set(spacy.lang.en.stop_words.STOP_WORDS)
+ stop_word_filtered_topics = []
+ for t in noun_filtered_topics:
+ words = t.topic.split()
+ if len(words) > 1:
+ if words[0].lower() in stop_words or words[-1].lower() in stop_words:
+ continue
+ stop_word_filtered_topics.append(t)
+
+ # Remove topics already contained in other topics
+ unique_topics = []
+ for t in stop_word_filtered_topics:
+ if not any(t.topic.lower() in other.topic.lower() and t.topic.lower() != other.topic.lower() for other in deduped_topics):
+ unique_topics.append(t)
+ elif t.source == TopicSource.MATCH: # Keep match-based topics even if they are contained in other topics
+ unique_topics.append(t)
+
+ # Remove less relevant topics
+ relevant_topics = [t for t in unique_topics if t.score >= scoreThreshold]
+
+ return relevant_topics
+
+
+def union(*topic_lists: list[Topic]) -> list[Topic]:
+ seen: set[str] = set()
+ merged: list[Topic] = []
+ for t in chain.from_iterable(topic_lists):
+ key = t.topic.lower().strip()
+ if key and key not in seen:
+ seen.add(key)
+ merged.append(t)
+ return merged
\ No newline at end of file
diff --git a/python/services/text_extraction_service/app/services/topic_extraction/type_specific_handlers.py b/python/services/text_extraction_service/app/services/topic_extraction/type_specific_handlers.py
new file mode 100644
index 00000000..b8317fee
--- /dev/null
+++ b/python/services/text_extraction_service/app/services/topic_extraction/type_specific_handlers.py
@@ -0,0 +1,182 @@
+import regex as re
+
+from app.schemas import ExtractedLine, ExtractedPage, Topic, TopicSource
+from app.services.topic_extraction import postprocessor
+from app.services.topic_extraction import bertopic_extractor as extractor
+
+
+class MaterialTypeHandler:
+ """Base handler - extracts keywords from text only"""
+
+ def match_topics(self, text: str, topics: list[str], min_count: int = 1) -> list[Topic]:
+ """ Filters `topics` for items that appear at least `min_count` times within `text` and returns them. Matching is case-insensitive. """
+ # Note: Can be improved using FAISS (faiss-cpu package) for semantic matching
+ matched: list[Topic] = []
+ for topic in topics:
+ pattern = re.compile(rf'\b{re.escape(topic)}\b', re.IGNORECASE | re.UNICODE)
+ if len(pattern.findall(text)) >= min_count:
+ matched.append(Topic(topic=topic, score=1.0, source=TopicSource.MATCH))
+ return matched
+
+ def preprocess(self, text: str) -> str:
+ # Remove links
+ text = re.sub(r'(?:http|https|www):.*?/.*?\. .*(?:jpg|jpeg|png|gif|bmp|svg|webp)', '', text)
+ text = re.sub(r'\b(?:http|https|www)\S*\b', '', text)
+ text = re.sub(r'\b(?:jpg|jpeg|png|gif|bmp|svg|webp)\b', '', text)
+ return text
+
+ def pages_to_text(self, pages: list[ExtractedPage]) -> str:
+ """Join all lines across pages into a single string."""
+ def _page_text(page: ExtractedPage) -> str:
+ text = ". ".join(line.text for line in page.lines)
+ return self.preprocess(text)
+
+ return "\f".join(_page_text(page) for page in pages if page.lines)
+
+ def extract_topics(self, pages: list[ExtractedPage], existing_topics: list[str] = []) -> list[Topic]:
+ text = self.pages_to_text(pages)
+ preprocessed_text = self.preprocess(text)
+ print("Extracting topics from preprocessed_text...")
+
+ matched_topics = self.match_topics(preprocessed_text, existing_topics)
+
+ return matched_topics
+
+ def refresh_topics(self, pages: list[ExtractedPage], existing_topics: list[str] = []) -> list[Topic]:
+ """Extract match-based and keyword-based topics without font-based topics.
+ For the default Material handler, this is the same because only matched topics are used"""
+ return self.extract_topics(pages, existing_topics)
+
+ def _to_topics(self, texts : list[str], source : TopicSource) -> list[Topic]:
+ # Convert unique (case-insensitive) strings with a fixed source to list of Topics.
+ # All scores are 1.0
+ seen: set[str] = set()
+ topics: list[Topic] = []
+ for text in texts:
+ text = text.strip()
+ key = text.lower()
+ if text and key not in seen:
+ seen.add(key)
+ topics.append(Topic(topic=text, score=1.0, source=source))
+ return topics
+
+
+class SlidesHandler(MaterialTypeHandler):
+ MAX_TITLE_WORDS = 15
+
+ def preprocess(self, text: str) -> str:
+ text = super().preprocess(text)
+ # Add a period after newlines so bullets without punctuation are treated
+ # as separate sentences.
+ text = re.sub(r'(? list[Topic]:
+ title_topics = self._title_topics(pages) if not refresh_only else []
+ keyword_topics = self._keyword_topics(pages)
+ matched_topics = self._matched_topics(pages, existing_topics)
+ return postprocessor.process(
+ postprocessor.union(title_topics, keyword_topics, matched_topics),
+ filterLowerCaseSingleWords = False,
+ scoreThreshold = 0.01
+ )
+
+ def refresh_topics(self, pages: list[ExtractedPage], existing_topics: list[str] = []) -> list[Topic]:
+ """Extract topics without text extraction (for refresh). Runs BERTopic and matching only."""
+ return self.extract_topics(pages, existing_topics, refresh_only=True)
+
+ def _matched_topics(self, pages: list[ExtractedPage], existing_topics: list[str]):
+ text = self.pages_to_text(pages)
+ matched_topics = self.match_topics(text, existing_topics)
+ return matched_topics
+
+ def _keyword_topics(self, pages: list[ExtractedPage]) -> list[Topic]:
+ text = self.pages_to_text(pages)
+ return extractor.extract(text, min_topic_size=3)
+
+ def _title_topics(self, pages: list[ExtractedPage]) -> list[Topic]:
+ # A slide's title is simply the largest-font line on the slide.
+ titles = []
+ for page in pages:
+ lines = [line for line in page.lines if line.text.strip()]
+ if not lines:
+ continue
+ biggest = max(lines, key=lambda line: line.size or 0.0)
+ title = biggest.text.strip()
+ if title and len(title.split()) <= self.MAX_TITLE_WORDS:
+ titles.append(title)
+ return self._to_topics(titles, source=TopicSource.FONT)
+
+
+class ArticleHandler(MaterialTypeHandler):
+ MIN_HEADING_SIZE = 10.0
+
+ def preprocess(self, text: str) -> str:
+ text = super().preprocess(text)
+
+ # Find the final occurrence of 'Citations' or 'References',
+ # and only keep the text before that point
+ match = None
+ for m in re.finditer(r'\b(?:Citations|References)\b', text):
+ match = m
+
+ if match:
+ return text[:match.start()]
+ else:
+ return text
+
+ def extract_topics(self, pages: list[ExtractedPage], existing_topics: list[str] = [], refresh_only: bool = False) -> list[Topic]:
+ text = self.pages_to_text(pages)
+ keyword_topics = extractor.extract(text)
+ heading_topics = self._heading_topics(pages) if not refresh_only else []
+ matched_topics = self._matched_topics(pages, existing_topics)
+ topics = postprocessor.union(heading_topics, keyword_topics, matched_topics)
+ postprocessed_topics = postprocessor.process(
+ topics,
+ minTopicCharCount = 4,
+ filterLowerCaseSingleWords = False,
+ scoreThreshold = 0.01
+ )
+ # return postprocessor.union(self._heading_topics(pages), keyword_topics)
+ return postprocessed_topics
+
+ def refresh_topics(self, pages: list[ExtractedPage], existing_topics: list[str] = []) -> list[Topic]:
+ """Extract topics without text extraction (for refresh). Runs BERTopic and matching only."""
+ return self.extract_topics(pages, existing_topics, refresh_only=True)
+
+ def _matched_topics(self, pages: list[ExtractedPage], existing_topics: list[str]):
+ text = self.pages_to_text(pages)
+ # We can potentially scale min_count by the number of pages or text size
+ matched_topics = self.match_topics(text, existing_topics, min_count=2)
+ return matched_topics
+
+ def _heading_topics(self, pages: list[ExtractedPage]) -> list[Topic]:
+ headings = [
+ line.text
+ for page in pages
+ for line in page.lines
+ if line.text.strip() and self._is_heading(line)
+ ]
+ return self._to_topics(headings, source=TopicSource.FONT)
+
+ def _is_heading(self, line: ExtractedLine) -> bool:
+ # bold is None for OCR, but require bold if non-OCR
+ # Note: Tesseract does have a way to estimate bold text with some math, but results are decent as-is already.
+ if (line.size or 0.0) >= self.MIN_HEADING_SIZE and (line.bold or line.bold is None):
+ return True
+ else:
+ return False
+
+
+handlers: dict[str, MaterialTypeHandler] = {
+ "slides": SlidesHandler(),
+ "article": ArticleHandler(),
+}
+
+DEFAULT_HANDLER = MaterialTypeHandler()
+
+
+def get_handler(material_type: str | None) -> MaterialTypeHandler:
+ return handlers.get((material_type or "").lower(), DEFAULT_HANDLER)
\ No newline at end of file
diff --git a/python/services/text_extraction_service/deploy/deploy_script.py b/python/services/text_extraction_service/deploy/deploy_script.py
new file mode 100644
index 00000000..b4bbee0a
--- /dev/null
+++ b/python/services/text_extraction_service/deploy/deploy_script.py
@@ -0,0 +1,58 @@
+"""Creates the S3 bucket (if needed) for AWS Textract, tags it, and sets
+a 1 day expiration rule
+"""
+
+from pathlib import Path
+
+import boto3
+from botocore.exceptions import ClientError
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+SERVICE_ROOT = Path(__file__).resolve().parent.parent
+
+JOB_PREFIX = "textract-jobs/"
+TAGS = [{"Key": "AppName", "Value": "curriculum-development-tool"}]
+
+
+class DeploySettings(BaseSettings):
+ AWS_REGION: str = "ca-central-1"
+ AWS_S3_BUCKET: str = "text-extraction-temp"
+
+ model_config = SettingsConfigDict(
+ env_file=str(SERVICE_ROOT / ".env"),
+ env_file_encoding="utf-8",
+ case_sensitive=True,
+ extra="ignore",
+ )
+
+
+def main() -> None:
+ settings = DeploySettings()
+ region, bucket = settings.AWS_REGION, settings.AWS_S3_BUCKET
+ s3 = boto3.client("s3", region_name=region)
+
+ try:
+ s3.head_bucket(Bucket=bucket)
+ print(f"Bucket '{bucket}' already exists")
+ except ClientError as e:
+ if e.response["Error"]["Code"] != "404":
+ raise
+ s3.create_bucket(Bucket=bucket, CreateBucketConfiguration={"LocationConstraint": region})
+ s3.get_waiter("bucket_exists").wait(Bucket=bucket)
+ print(f"Created bucket '{bucket}'")
+
+ s3.put_bucket_tagging(Bucket=bucket, Tagging={"TagSet": TAGS})
+ s3.put_bucket_lifecycle_configuration(
+ Bucket=bucket,
+ LifecycleConfiguration={"Rules": [{
+ "ID": "expire-textract-jobs",
+ "Status": "Enabled",
+ "Filter": {"Prefix": JOB_PREFIX},
+ "Expiration": {"Days": 1},
+ }]},
+ )
+ print(f"Tagged bucket and set 1 day expiration on '{JOB_PREFIX}'")
+
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/python/services/text_extraction_service/requirements.txt b/python/services/text_extraction_service/requirements.txt
new file mode 100644
index 00000000..427de74d
--- /dev/null
+++ b/python/services/text_extraction_service/requirements.txt
@@ -0,0 +1,20 @@
+fastapi==0.135.2
+uvicorn==0.42.0
+pydantic==2.12.4
+pydantic-settings==2.13.1
+python-dotenv==1.2.2
+python-json-logger==4.1.0
+python-multipart==0.0.32
+nltk==3.9.4
+PyMuPDF==1.28.0
+pytesseract==0.3.13
+Pillow==12.3.0
+regex==2026.4.4
+pytest==9.0.2
+httpx==0.28.1
+boto3==1.42.80
+botocore==1.42.80
+
+# Bertopic
+bertopic==0.17.4
+sentence-transformers==5.6.0
\ No newline at end of file
diff --git a/python/services/text_extraction_service/tests/__init__.py b/python/services/text_extraction_service/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/python/services/text_extraction_service/tests/fixtures/sample_document.pdf b/python/services/text_extraction_service/tests/fixtures/sample_document.pdf
new file mode 100644
index 00000000..812e4fec
Binary files /dev/null and b/python/services/text_extraction_service/tests/fixtures/sample_document.pdf differ
diff --git a/python/services/text_extraction_service/tests/fixtures/sample_file.txt b/python/services/text_extraction_service/tests/fixtures/sample_file.txt
new file mode 100644
index 00000000..f111e253
--- /dev/null
+++ b/python/services/text_extraction_service/tests/fixtures/sample_file.txt
@@ -0,0 +1,8 @@
+The faculty of Forestry and Environmental Stewardship (FES) at the University of British Columbia does great work by
+protecting maple trees because maple trees are so good can make maple syrup and maple sauce and maple candy and maple biscuits and maple cookies.
+I love using the word maple in sentences because it is just such a good word and it makes me so maply happy.
+I also love using variants of the word such as maples, mapling (is that a word?), and maply.
+
+However, my love for maple isn't genuine. It is simply a ruse to get BERTopic to identify maple as a topic.
+If you need to find the Faculty of FES, you can check one of the UBC maps and look at the MAP LEgend. Then follow the path towards the pinned area.
+Some anagrams of maple are ample and epalm.
\ No newline at end of file
diff --git a/python/services/text_extraction_service/tests/test_handlers.py b/python/services/text_extraction_service/tests/test_handlers.py
new file mode 100644
index 00000000..3b8c00ea
--- /dev/null
+++ b/python/services/text_extraction_service/tests/test_handlers.py
@@ -0,0 +1,171 @@
+from pathlib import Path
+
+import pytest
+import warnings
+
+from app.schemas import Topic, TopicSource
+from app.services.topic_extraction.type_specific_handlers import (
+ ArticleHandler,
+ MaterialTypeHandler,
+ SlidesHandler,
+ get_handler,
+)
+from app.schemas import ExtractedLine, ExtractedPage
+
+
+class TestMatchTopics:
+ def test_matching_and_case_and_substring_rules(self):
+ handler = MaterialTypeHandler()
+ r1 = handler.match_topics("Forest ecology is fascinating", ["Forest"])
+ assert len(r1) == 1 and r1[0].topic == "Forest"
+ r2 = handler.match_topics("CLIMATE change in British Columbia", ["climate change"])
+ assert len(r2) == 1
+ r3 = handler.match_topics("The forester went to the jungle", ["forest"])
+ assert len(r3) == 0 # forester ignored because substring of word
+ r4 = handler.match_topics("I love forestry and the forest and forests", ["Forest"])
+ assert len(r4) == 1 # substrings of words ignored, but "forest" counted
+
+ def test_min_count(self):
+ handler = MaterialTypeHandler()
+ r1 = handler.match_topics("Forest appears once", ["Forest"], min_count=2)
+ assert r1 == []
+ r2 = handler.match_topics("Forest is great. I love Forest.", ["Forest"], min_count=2)
+ assert len(r2) == 1 and r2[0].topic == "Forest"
+
+
+class TestDefaultHandler:
+ def test_extract_and_refresh(self):
+ handler = MaterialTypeHandler()
+
+ page = _make_page(["Climate change affects forests"])
+ topics = handler.extract_topics([page], existing_topics=["Climate change"])
+ assert len(topics) == 1 and topics[0].topic == "Climate change"
+
+ page2 = _make_page(["Forest ecology"])
+ topics2 = handler.refresh_topics([page2], existing_topics=["Forest"])
+ assert len(topics2) == 1 and topics2[0].source == TopicSource.MATCH
+
+
+
+class TestSlidesHandler:
+ def test_title_topics_empty(self):
+ handler = SlidesHandler()
+ empty = ExtractedPage(page_number=1, lines=[])
+ assert handler._title_topics([empty]) == []
+
+ def test_title_topics_largest_font(self):
+ handler = SlidesHandler()
+ page = _make_page(["Small", "BIG TITLE", "Medium"], sizes=[10, 24, 14])
+ t1 = handler._title_topics([page])
+ assert len(t1) == 1 and t1[0].topic == "BIG TITLE"
+
+ def test_title_topics_skips_long_titles(self):
+ handler = SlidesHandler()
+ # MAX_TITLE_WORD_COUNT = 15
+ # Change test based on value in type_specific_handlers.py.
+ long_title = " ".join(["word"] * 16)
+ page2 = _make_page([long_title], sizes=[30])
+ assert handler._title_topics([page2]) == []
+
+
+ def test_refresh_vs_extract(self):
+ handler = SlidesHandler()
+ body_lines = _read_sample_file_lines()
+ page = _make_page(
+ ["Title slide", "forestry and ecology"] + body_lines,
+ sizes=[30, 15] + [12.0] * len(body_lines),
+ )
+ topics_refreshed = handler.refresh_topics([page], existing_topics=["forestry"])
+ print("Refreshed topics:")
+ print([t.topic for t in topics_refreshed])
+ assert any(t.topic == "forestry" for t in topics_refreshed)
+ assert not any(t.source == TopicSource.FONT for t in topics_refreshed)
+ topics_extracted = handler.extract_topics([page], existing_topics=["forestry"])
+ print("Extracted topics:")
+ print([t.topic for t in topics_extracted])
+ assert any(t.topic == "Title slide" for t in topics_extracted)
+ assert any(t.topic == "forestry" for t in topics_extracted)
+
+
+class TestArticleHandler:
+ def test_is_heading(self):
+ handler = ArticleHandler()
+ assert handler._is_heading(ExtractedLine(text="Heading", size=14, bold=True))
+ assert handler._is_heading(ExtractedLine(text="Heading", size=14, bold=None))
+ assert not handler._is_heading(ExtractedLine(text="Small", size=8, bold=True))
+ assert not handler._is_heading(ExtractedLine(text="Small", size=8, bold=False))
+
+ def test_heading_topics(self):
+ handler = ArticleHandler()
+ page = _make_page(["Regular", "Section Title", "More"], sizes=[10, 14, 10], bolds=[False, True, False])
+ topics = handler._heading_topics([page])
+ assert len(topics) == 1 and topics[0].topic == "Section Title"
+
+ def test_refresh_skips_heading_topics(self):
+ handler = ArticleHandler()
+ body_lines = _read_sample_file_lines()
+ page = _make_page(
+ ["Heading"] + body_lines,
+ sizes=[14] + [12.0] * len(body_lines),
+ bolds=[True] + [None] * len(body_lines),
+ )
+ topics = handler.refresh_topics([page], existing_topics=[])
+ for t in topics:
+ print(f"Topic: {t.topic}, Source: {t.source}")
+ assert not any(t.source == TopicSource.FONT for t in topics)
+
+ def test_bertopic_basic(self):
+ # May be flaky
+ handler = ArticleHandler()
+ sample_path = Path(__file__).parent / "fixtures" / "sample_file.txt"
+ lines = [line for line in sample_path.read_text().splitlines() if line.strip()]
+ page = _make_page(lines)
+ topics = handler.extract_topics([page])
+ print(f"Identified topics ({len(topics)}):")
+ for t in topics:
+ print(f"Topic: {t.topic}, Score: {t.score}, Source: {t.source}")
+ print([t.topic.lower() for t in topics])
+ if not any("maple" in t.topic.lower() for t in topics):
+ warnings.warn("Warning: 'maple' not among extracted topics. This could be due to randomness, or the algorithm should be improved.")
+ assert any(t.source == TopicSource.KEYWORD for t in topics)
+
+ def test_preprocess_truncates_at_final_references(self):
+ handler = ArticleHandler()
+ text = "Some text References: [1] Article"
+ assert handler.preprocess(text) == "Some text "
+ text = "Some text Citations: [1] Article"
+ assert handler.preprocess(text) == "Some text "
+ text = "This figure references that chart"
+ assert handler.preprocess(text) == "This figure references that chart"
+ text = "We surveyed the forest. References were used to plot points. References: [1] Article"
+ assert handler.preprocess(text) == "We surveyed the forest. References were used to plot points. "
+
+
+
+class TestGetHandler:
+ def test_default_handler_for_unknown(self):
+ assert isinstance(get_handler("textbook"), MaterialTypeHandler)
+ assert isinstance(get_handler("unknown"), MaterialTypeHandler)
+
+ def test_case_insensitive(self):
+ assert isinstance(get_handler("Slides"), SlidesHandler)
+ assert isinstance(get_handler("slides"), SlidesHandler)
+ assert isinstance(get_handler("SlIdEs"), SlidesHandler)
+ assert isinstance(get_handler("ARTICLE"), ArticleHandler)
+ assert isinstance(get_handler("article"), ArticleHandler)
+
+def _make_page(lines: list[str], sizes: list[float] | None = None, bolds: list[bool | None] | None = None) -> ExtractedPage:
+ """Helper to create an ExtractedPage from line texts."""
+ if sizes is None:
+ sizes = [12.0] * len(lines)
+ if bolds is None:
+ bolds = [None] * len(lines)
+ return ExtractedPage(
+ page_number=1,
+ lines=[ExtractedLine(text=t, size=s, bold=b) for t, s, b in zip(lines, sizes, bolds)],
+ )
+
+
+def _read_sample_file_lines() -> list[str]:
+ sample_file_path = Path(__file__).parent / "fixtures" / "sample_file.txt"
+ return [line for line in sample_file_path.read_text().splitlines() if line.strip()]
\ No newline at end of file
diff --git a/python/services/text_extraction_service/tests/test_multipart_file.py b/python/services/text_extraction_service/tests/test_multipart_file.py
new file mode 100644
index 00000000..b7c9f7a0
--- /dev/null
+++ b/python/services/text_extraction_service/tests/test_multipart_file.py
@@ -0,0 +1,38 @@
+import json
+from pathlib import Path
+from fastapi.testclient import TestClient
+
+from app.api.routes import app
+
+PDF_PATH = Path(__file__).parent / "fixtures" / "sample_document.pdf"
+
+client = TestClient(app)
+
+def test_extract_endpoint_multipart():
+ pdf_bytes = PDF_PATH.read_bytes()
+ metadata = json.dumps({
+ "ocr_enabled": False,
+ "extraction_engine": "tesseract",
+ "ocr_threshold": 0,
+ "material_type": "slides",
+ "existing_topics": ["Forest Ecology", "Conservation"]
+ })
+
+ files = {
+ "file": ("sample_document.pdf", pdf_bytes, "application/pdf")
+ }
+ data = {
+ "metadata": metadata
+ }
+
+ response = client.post("/extract", files=files, data=data)
+ assert response.status_code == 200
+ res_data = response.json()
+
+ assert "pages" in res_data
+ assert "page_count" in res_data
+ assert "topics" in res_data
+ assert res_data["page_count"] == 3
+
+ topic_names = [t["topic"] for t in res_data["topics"]]
+ assert "Forest Ecology" in topic_names and "Conservation" in topic_names
diff --git a/python/services/text_extraction_service/tests/test_postprocessor.py b/python/services/text_extraction_service/tests/test_postprocessor.py
new file mode 100644
index 00000000..9506646d
--- /dev/null
+++ b/python/services/text_extraction_service/tests/test_postprocessor.py
@@ -0,0 +1,73 @@
+import pytest
+
+from app.schemas import Topic, TopicSource
+from app.services.topic_extraction.postprocessor import process, union
+
+class TestProcess:
+ def test_filters_by_word_count_and_char_length(self):
+ # MIN_WORD_COUNT = 1
+ # MAX_WORD_COUNT = 8
+ # Modify test based on constants in postprocessor.py
+ topic_9_words = Topic(topic="sap sap sap sap sap sap sap sap sap", score=0.9, source=TopicSource.KEYWORD)
+ topic_8_words = Topic(topic="pot pot pot pot pot pot pot pot", score=0.9, source=TopicSource.KEYWORD)
+ topics = [
+ topic_9_words,
+ topic_8_words,
+ Topic(topic="Forestry", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="four", score=0.9, source=TopicSource.KEYWORD),
+ ]
+ result = process(topics, minTopicCharCount=5, scoreThreshold=0.0)
+ assert set(result) == set([
+ topic_8_words,
+ Topic(topic="Forestry", score=0.9, source=TopicSource.KEYWORD)
+ ])
+
+ def test_filters_lowercase_single_words_when_enabled(self):
+ topics = [
+ Topic(topic="forest", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="Forest", score=0.9, source=TopicSource.KEYWORD),
+ ]
+ result = process(topics, filterLowerCaseSingleWords=True, minTopicCharCount=3, scoreThreshold=0.0)
+ assert set(result) == set([Topic(topic="Forest", score=0.9, source=TopicSource.KEYWORD)])
+
+ def test_deduplicates_case_insensitive(self):
+ topics = [
+ Topic(topic="Forest", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="forest", score=0.8, source=TopicSource.MATCH),
+ ]
+ result = process(topics, scoreThreshold=0.0)
+ assert set(result) == set([Topic(topic="Forest", score=0.9, source=TopicSource.KEYWORD)])
+
+ def test_removes_numbers_and_url_fragments(self):
+ topics = [
+ Topic(topic="Chapter 1", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="www.example.com", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="image.jpg", score=0.9, source=TopicSource.KEYWORD),
+ Topic(topic="Valid Topic", score=0.9, source=TopicSource.KEYWORD),
+ ]
+ result = process(topics, scoreThreshold=0.0)
+ assert set(result) == set([Topic(topic="Valid Topic", score=0.9, source=TopicSource.KEYWORD)])
+
+ def test_filters_by_score_threshold(self):
+ topics = [
+ Topic(topic="Economy", score=0.59, source=TopicSource.KEYWORD),
+ Topic(topic="Ecology", score=0.6, source=TopicSource.KEYWORD),
+ Topic(topic="Equality", score=0.61, source=TopicSource.KEYWORD),
+ ]
+ result = process(topics, scoreThreshold=0.6)
+ assert set(result) == set([
+ Topic(topic="Ecology", score=0.6, source=TopicSource.KEYWORD),
+ Topic(topic="Equality", score=0.61, source=TopicSource.KEYWORD)
+ ])
+
+
+class TestUnion:
+ def test_merges_and_deduplicates(self):
+ list1 = [Topic(topic="A", score=0.5, source=TopicSource.KEYWORD)]
+ list2 = [Topic(topic="B", score=0.5, source=TopicSource.MATCH)]
+ list3 = [Topic(topic="a", score=0.5, source=TopicSource.FONT)]
+ result = union(list1, list2, list3)
+ assert set(result) == set([
+ Topic(topic="A", score=0.5, source=TopicSource.KEYWORD),
+ Topic(topic="B", score=0.5, source=TopicSource.MATCH)
+ ])
diff --git a/python/services/text_extraction_service/tests/test_text_extraction.py b/python/services/text_extraction_service/tests/test_text_extraction.py
new file mode 100644
index 00000000..9d8a03a1
--- /dev/null
+++ b/python/services/text_extraction_service/tests/test_text_extraction.py
@@ -0,0 +1,128 @@
+from pathlib import Path
+
+from app.services.text_readers.document_extractor import extract
+
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+PDF_PATH = FIXTURES_DIR / "sample_document.pdf"
+
+
+def _get_all_text(pages) -> str:
+ return "\n".join(line.text for page in pages for line in page.lines)
+
+
+def _find_line(lines, substring):
+ for line in lines:
+ if substring in line.text:
+ return line
+ return None
+
+
+class TestTextExtractionNormal:
+ def test_extract_text_and_font_properties(self):
+ pages, page_count = extract(
+ file_bytes=PDF_PATH.read_bytes(),
+ ocr_enabled=False,
+ extraction_engine="tesseract",
+ ocr_threshold=0,
+ )
+
+ assert page_count == 3
+ assert len(pages) == 3
+ for page in pages:
+ assert page.page_number in (1, 2, 3)
+
+ full_text = _get_all_text(pages)
+ assert "Forest Ecology" in full_text
+ assert "Forestry is the science" in full_text
+ assert "Forest management" in full_text
+ assert "Clear-cutting" in full_text
+ assert "Selective cutting" in full_text
+ assert "Additional Techniques" in full_text
+ assert "Conservation" in full_text
+ assert "Sustainable forestry" in full_text
+ assert "Old-growth forests" in full_text
+
+ page1 = pages[0]
+ p1_lines = page1.lines
+
+ title = _find_line(p1_lines, "Forest Ecology")
+ assert title is not None
+ assert title.size is not None
+ assert title.size > 16.0
+ assert title.bold is False
+
+ intro_heading = _find_line(p1_lines, "Introduction")
+ assert intro_heading is not None
+ assert intro_heading.size is not None
+ assert intro_heading.size > 12.0
+ assert intro_heading.bold is False
+
+ body_line = _find_line(p1_lines, "Forestry is the science")
+ assert body_line is not None
+ assert body_line.size is not None
+ assert body_line.size < intro_heading.size
+ assert body_line.bold is False
+
+ bold_line = _find_line(p1_lines, "Forest management involves")
+ assert bold_line is not None
+ assert bold_line.bold is True
+ assert bold_line.size is not None
+
+ page3 = pages[2]
+ p3_lines = page3.lines
+
+ conservation_heading = _find_line(p3_lines, "Conservation")
+ assert conservation_heading is not None
+ assert conservation_heading.size is not None
+ assert conservation_heading.size > 12.0
+ assert conservation_heading.bold is False
+
+ sustainable_line = _find_line(p3_lines, "Sustainable forestry practices aim")
+ assert sustainable_line is not None
+ assert sustainable_line.bold is True
+ assert sustainable_line.size is not None
+
+ oldgrowth_line = _find_line(p3_lines, "Old-growth forests are particularly")
+ assert oldgrowth_line is not None
+ assert oldgrowth_line.bold is False
+ assert oldgrowth_line.size is not None
+
+
+class TestTextExtractionOCR:
+ def test_ocr_extract_text_and_font_size(self):
+ pages, page_count = extract(
+ file_bytes=PDF_PATH.read_bytes(),
+ ocr_enabled=True,
+ extraction_engine="tesseract",
+ ocr_threshold=9999,
+ )
+
+ assert page_count == 3
+ assert len(pages) == 3
+
+ full_text = _get_all_text(pages)
+ assert "Forest Ecology" in full_text
+ assert "Forestry is the science and craft" in full_text
+ assert "Forest management involves the planning" in full_text
+ assert "Clear-cutting is a logging practice" in full_text
+ assert "Selective cutting removes only selected" in full_text
+ assert "Sustainable forestry practices aim" in full_text
+ assert "Old-growth forests are particularly" in full_text
+
+ for page in pages:
+ for line in page.lines:
+ assert line.size is not None
+ assert line.size > 0
+ assert line.bold is None
+
+ all_lines = [line for page in pages for line in page.lines]
+
+ title_candidates = [line for line in all_lines if "Forest Ecology" in line.text]
+ assert len(title_candidates) >= 1
+ title_line = title_candidates[0]
+ assert title_line.size > 16.0
+
+ body_candidates = [line for line in all_lines if "science" in line.text.lower()]
+ assert len(body_candidates) == 1
+ assert body_candidates[0].size < title_line.size
+
+ Course Materials
+
+
+
+
+
+ Course Materials
+
+
+
+
+ @include('layouts.guide')
+
+
+
+
@endif
+
+
+
+
- Course Materials
+
-
diff --git a/laravel/resources/views/partials/search-result.blade.php b/laravel/resources/views/partials/search-result.blade.php
new file mode 100644
index 00000000..f5e55db9
--- /dev/null
+++ b/laravel/resources/views/partials/search-result.blade.php
@@ -0,0 +1,27 @@
+@use('\App\Support\SearchedTextHighlighter')
+
+@if ($results->isEmpty())
+ No results found.
+@else + @foreach ($results as $result) + +
+
+
+ @endforeach
+@endif
diff --git a/laravel/resources/views/programs/coverageAnalysis.blade.php b/laravel/resources/views/programs/coverageAnalysis.blade.php
new file mode 100644
index 00000000..1770e2cc
--- /dev/null
+++ b/laravel/resources/views/programs/coverageAnalysis.blade.php
@@ -0,0 +1,40 @@
+@extends('layouts.app')
+
+@section('content')
+
+
+
+
+
+ {{ $result->file_name }}
+ Page {{ $result->page_number }}
+
+ {!! SearchedTextHighlighter::render($result->snippet) !!}
+
+  }})
+
+
+
+@endsection
diff --git a/laravel/resources/views/programs/wizard/header.blade.php b/laravel/resources/views/programs/wizard/header.blade.php
index b33454f5..4e7e2d66 100644
--- a/laravel/resources/views/programs/wizard/header.blade.php
+++ b/laravel/resources/views/programs/wizard/header.blade.php
@@ -239,6 +239,14 @@
+
+
+
+
+
+ Program: {{ $program->program }}
+{{ $program->faculty }} · {{ $program->department }}
+
+
+
+
+ @if (session('search_results') !== null)
+ Search (Temp)
+
+
+
+
+
+ @endif
++ Search results for {{ session('search_query') }} + ({{ session('search_results')->count() }} result(s)) +
+ @include('partials.search-result', ['results' => session('search_results')])
+
+
+
+
+
+
+
+