Merge branch 'code-differently:main' into main

Author: tobyev

lesson_05/jaydenellis/README.md

@@ -0,0 +1,39 @@
+# Real Time Translation App
+
+## Overview
+I wanted to base my user stories around an app that would make translating languages in real time easier for conversations and studying (this probably already exists).
+
+
+## User Story #1
+1. As a traveler, I want to be able to record a conversation of someone speaking in a different language and translate it in real time, so I can communicate with people who might need help.
+
+## Acceptance Criteria
+- Audio Recording Functionality: The app must provide a clear record button that captures audio input with visual feedback during recording.
+- Real-Time Translation: Translation processing should begin within a few seconds and display accurate text in the target language.
+- Audio Playback: The app should convert translated text to speech and play it aloud in the target language.
+- Multiple recordings in sequence: Users should be able to record multiple conversations back-to-back for ongoing dialogue.
+
+
+## User Story #2
+2. As a foreigner, I want to take a picture of a language and have it translated in real time so that I can avoid dealing with language barriers.
+
+## Acceptance Criteria
+- Camera Integration: The app must provide a camera button that allows users to capture photos of text with proper focus and lighting guidance.
+- Text Recognition: The app should detect and extract text from images using OCR technology within a few seconds of capture.
+- Visual Translation Display: Translated text should appear overlaid on the original image or in a clear display format below the photo.
+- Multiple Text Languages: The app should support translation of common languages found on signs, menus, and documents while traveling.
+
+
+
+
+## User Story #3
+3. As a student, I want to store the previous translations that I've done on the app so that I can look back at them at a later date and study them.
+
+## Acceptance Criteria
+- Translation History Storage: The app must automatically save all completed translations with timestamps and source/target language pairs.
+- Easy Access to Saved Translations: Users should be able to access their translation history through a clearly labeled menu or tab within the app.
+- Search and Filter Functionality: The app should allow users to search through their saved translations by date, language, or keywords from the original text.
+- Study Mode Features: Saved translations should display both original and translated text side-by-side for effective language learning and review. 
+
+
+

lesson_10/libraries/src/loaders/brooklyn_harden_loader.ts

@@ -0,0 +1,54 @@
+import csv from 'csv-parser';
+import fs from 'fs';
+import { Credit, MediaItem, MediaType } from '../models/index.js';
+import { Loader } from './loader.js';
+
+export class BrooklynHardenLoader implements Loader {
+  getLoaderName(): string {
+    return 'brooklynharden';
+  }
+
+  async loadData(): Promise<MediaItem[]> {
+    const credits = await this.loadCredits();
+    const mediaItems = await this.loadMediaItems();
+    credits.forEach(credit => {
+      const media_item = mediaItems.find(media_item => media_item.getId() === credit.getMediaItemId());
+      if(media_item) {
+        media_item.addCredit(credit);
+      }
+    })
+
+
+    console.log(
+      `Loaded ${credits.length} credits and ${mediaItems.length} media items`,
+    );
+
+    return [...mediaItems.values()];
+  }
+
+  async loadMediaItems(): Promise<MediaItem[]> {
+    const results = [];
+    const read = fs
+      .createReadStream('data/media_items.csv', 'utf-8')
+      .pipe(csv());
+    for await (const row of read) {
+      const { id, type, title, year } = row;
+       const mediaType = type as MediaType;
+       results.push(new MediaItem(id, title, mediaType, parseInt(year), [])); 
+    }
+    return results;
+  }
+
+  async loadCredits(): Promise<Credit[]> {
+    const credits = [];
+    const readable = fs
+      .createReadStream('data/credits.csv', 'utf-8')
+      .pipe(csv());
+    for await (const row of readable) {
+      const { media_item_id, role, name } = row;
+      credits.push(new Credit(media_item_id, name, role));
+    }
+    return credits;
+  }
+}
+

lesson_10/libraries/src/loaders/jaizelcespedes_loader.ts

@@ -0,0 +1,75 @@
+import csv from 'csv-parser';
+import fs from 'fs';
+import { Credit, MediaItem, MediaType } from '../models/index.js';
+import { Loader } from './loader.js';
+
+export class JaizelcespedesLoader implements Loader {
+  getLoaderName(): string {
+    return 'jaizelcespedes';
+  }
+
+  async loadData(): Promise<MediaItem[]> {
+    const credits = await this.loadCredits();
+    const mediaItems = await this.loadMediaItems();
+
+    console.log(
+      `Loaded ${credits.length} credits and ${mediaItems.length} media items`,
+    );
+
+    return [...mediaItems.values()];
+  }
+
+  async loadMediaItems(): Promise<MediaItem[]> {
+    const mediaItems: MediaItem[] = [];
+    const readable = fs
+      .createReadStream('data/media_items.csv', 'utf-8')
+      .pipe(csv());
+    
+    for await (const row of readable) {
+      const { id, type, title, year } = row;
+      
+      // Convert the string type to MediaType enum
+      let mediaType: MediaType;
+      switch (type) {
+        case 'movie':
+          mediaType = MediaType.Movie;
+          break;
+        case 'tv_show':
+          mediaType = MediaType.TVShow;
+          break;
+        case 'documentary':
+          mediaType = MediaType.Documentary;
+          break;
+        default:
+          console.warn(`Unknown media type: ${type}. Defaulting to Movie.`);
+          mediaType = MediaType.Movie;
+      }
+      
+      // Create MediaItem with empty credits array for now
+      // Credits will be associated separately in loadData method
+      const mediaItem = new MediaItem(
+        id,
+        title,
+        mediaType,
+        parseInt(year, 10),
+        []
+      );
+      
+      mediaItems.push(mediaItem);
+    }
+    
+    return mediaItems;
+  }
+
+  async loadCredits(): Promise<Credit[]> {
+    const credits = [];
+    const readable = fs
+      .createReadStream('data/credits.csv', 'utf-8')
+      .pipe(csv());
+    for await (const row of readable) {
+      const { media_item_id, role, name } = row;
+      credits.push(new Credit(media_item_id, name, role));
+    }
+    return credits;
+  }
+}

lesson_10/libraries/src/loaders/jared_edge_loader.ts

@@ -0,0 +1,93 @@
+import csv from 'csv-parser';
+import fs from 'fs';
+import { Credit, MediaItem, MediaType, Role } from '../models/index.js';
+import { Loader } from './loader.js';
+
+export class JaredEdgeLoader implements Loader {
+  getLoaderName(): string {
+    return 'jarededge';
+  }
+
+  async loadData(): Promise<MediaItem[]> {
+    const [items, credits] = await Promise.all([
+      this.loadMediaItems(),
+      this.loadCredits(),
+    ]);
+
+    const byId = new Map(items.map((i) => [i.getId(), i]));
+
+    for (const credit of credits) {
+      const mediaItemId = this.creditToMediaItemId(credit);
+      const item = byId.get(mediaItemId);
+      if (item) item.addCredit(credit);
+    }
+
+    return [...byId.values()];
+  }
+
+  async loadMediaItems(): Promise<MediaItem[]> {
+    const items: MediaItem[] = [];
+    const readable = fs
+      .createReadStream('data/media_items.csv', 'utf-8')
+      .pipe(csv());
+
+    for await (const row of readable) {
+      const id = String(row.id).trim();
+      const title = String(row.title).trim();
+      const releaseYear = Number.parseInt(String(row.year), 10);
+      const mediaType = this.toMediaType(String(row.type));
+
+      if (Number.isNaN(releaseYear)) {
+        throw new Error(`Invalid year "${row.year}" for id=${id} (${title})`);
+      }
+
+      items.push(new MediaItem(id, title, mediaType, releaseYear, []));
+    }
+
+    return items;
+  }
+
+  private toMediaType(raw: string): MediaType {
+    const v = raw.trim().toLowerCase();
+    if (v === 'movie') return MediaType.Movie;
+    if (v === 'tv_show') return MediaType.TVShow;
+    if (v === 'documentary') return MediaType.Documentary;
+    throw new Error(`Unknown media type: ${raw}`);
+  }
+
+  async loadCredits(): Promise<Credit[]> {
+    const credits: Credit[] = [];
+    const readable = fs
+      .createReadStream('data/credits.csv', 'utf-8')
+      .pipe(csv());
+    for await (const row of readable) {
+      const mediaItemId = String(row.media_item_id).trim();
+      const name = String(row.name).trim();
+      const role = this.toRole(String(row.role));
+      credits.push(new Credit(mediaItemId, name, role));
+    }
+    return credits;
+  }
+
+  private toRole(raw: string): Role {
+    const normalized = raw.trim();
+    const values = Object.values(Role) as string[];
+
+    const match = values.find(
+      (v) => v === normalized || v.toLowerCase() === normalized.toLowerCase(),
+    );
+    if (match) return match as Role;
+
+    const map = Role as unknown as Record<string, Role>;
+    const key = Object.keys(map).find(
+      (k) => k.toLowerCase() === normalized.toLowerCase(),
+    );
+    if (key) return map[key];
+
+    throw new Error(`Unknown role: ${raw}`);
+  }
+
+  private creditToMediaItemId(c: Credit): string {
+    return c.getMediaItemId();
+  }
+}

lesson_10/libraries/src/loaders/joneemckellar_loader.ts

@@ -0,0 +1,62 @@
+import csv from 'csv-parser';
+import fs from 'fs';
+import { Credit, MediaItem } from '../models/index.js';
+import { Loader } from './loader.js';
+
+export class JoneemckellarLoader implements Loader {
+  getLoaderName(): string {
+    return 'joneemckellar';
+  }
+
+  async loadData(): Promise<MediaItem[]> {
+    const credits = await this.loadCredits();
+    const mediaItems = await this.loadMediaItems(credits);
+
+    console.log(
+      `Loaded ${credits.length} credits and ${mediaItems.length} media items`,
+    );
+
+    return mediaItems;
+  }
+
+  // Pass all credits to associate with each media item
+  async loadMediaItems(credits: Credit[]): Promise<MediaItem[]> {
+    const mediaItems: MediaItem[] = []; // Declare the array
+    const readable = fs
+      .createReadStream('data/media_items.csv', 'utf-8')
+      .pipe(csv());
+
+    for await (const row of readable) {
+      const { id, title, type, release_year } = row;
+
+      // Filter credits for this specific media item
+      const itemCredits = credits.filter((c) => c.getMediaItemId() === id);
+
+      // Handle missing or empty release_year values
+      const parsedReleaseYear =
+        release_year && release_year.trim() !== ''
+          ? parseInt(release_year, 10)
+          : 0;
+
+      mediaItems.push(
+        new MediaItem(id, title, type, parsedReleaseYear, itemCredits),
+      );
+    }
+
+    return mediaItems;
+  }
+
+  async loadCredits(): Promise<Credit[]> {
+    const credits: Credit[] = [];
+    const readable = fs
+      .createReadStream('data/credits.csv', 'utf-8')
+      .pipe(csv());
+
+    for await (const row of readable) {
+      const { media_item_id, role, name } = row;
+      credits.push(new Credit(media_item_id, name, role));
+    }
+
+    return credits;
+  }
+}