lyrics-transcriber 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

lyrics_transcriber/frontend/src/components/shared/hooks/useWordClick.ts

@@ -1,18 +1,8 @@
 import { useCallback } from 'react'
-import { AnchorSequence, GapSequence, InteractionMode } from '../../../types'
+import { AnchorSequence, GapSequence, InteractionMode, WordCorrection } from '../../../types'
 import { ModalContent } from '../../LyricsAnalyzer'
 import { WordClickInfo } from '../types'
 
-// Define debug info type
-interface WordDebugInfo {
-    wordSplitInfo?: {
-        text: string
-        startIndex: number
-        endIndex: number
-    }
-    nearbyAnchors?: AnchorSequence[]
-}
-
 export interface UseWordClickProps {
     mode: InteractionMode
     onElementClick: (content: ModalContent) => void
@@ -20,103 +10,93 @@ export interface UseWordClickProps {
     isReference?: boolean
     currentSource?: string
     gaps?: GapSequence[]
+    anchors?: AnchorSequence[]
+    corrections?: WordCorrection[]
 }
 
 export function useWordClick({
     mode,
     onElementClick,
     onWordClick,
-    isReference,
-    currentSource,
-    gaps = []
+    isReference = false,
+    currentSource = '',
+    gaps = [],
+    anchors = [],
+    corrections = []
 }: UseWordClickProps) {
     const handleWordClick = useCallback((
         word: string,
         wordId: string,
         anchor?: AnchorSequence,
-        gap?: GapSequence,
-        debugInfo?: WordDebugInfo
+        gap?: GapSequence
     ) => {
-        console.log(JSON.stringify({
-            debug: {
-                clickedWord: word,
+        // Check if word belongs to anchor
+        const belongsToAnchor = anchor && (
+            isReference
+                ? anchor.reference_word_ids[currentSource]?.includes(wordId)
+                : anchor.transcribed_word_ids.includes(wordId)
+        )
+
+        // Find matching gap if not provided
+        const matchingGap = gap || gaps.find(g =>
+            g.transcribed_word_ids.includes(wordId) ||
+            Object.values(g.reference_word_ids).some(ids => ids.includes(wordId))
+        )
+
+        // Check if word belongs to gap - include both original and corrected words
+        const belongsToGap = matchingGap && (
+            isReference
+                ? matchingGap.reference_word_ids[currentSource]?.includes(wordId)
+                : (matchingGap.transcribed_word_ids.includes(wordId) ||
+                    corrections.some(c =>
+                        c.corrected_word_id === wordId ||
+                        c.word_id === wordId
+                    ))
+        )
+
+        // Debug info
+        console.log('Word Click Debug:', {
+            clickInfo: {
+                word,
                 wordId,
                 isReference,
                 currentSource,
-                wordInfo: debugInfo?.wordSplitInfo,
-                nearbyAnchors: debugInfo?.nearbyAnchors,
-                anchorInfo: anchor && {
-                    wordIds: anchor.word_ids,
-                    length: anchor.length,
-                    words: anchor.words,
-                    referenceWordIds: anchor.reference_word_ids,
-                    matchesWordId: isReference
-                        ? anchor.reference_word_ids[currentSource!]?.includes(wordId)
-                        : anchor.word_ids.includes(wordId)
-                },
-                gapInfo: gap && {
-                    wordIds: gap.word_ids,
-                    length: gap.length,
-                    words: gap.words,
-                    referenceWords: gap.reference_words,
-                    corrections: gap.corrections,
-                    matchesWordId: isReference
-                        ? gap.reference_words[currentSource!]?.includes(wordId)
-                        : gap.word_ids.includes(wordId)
-                },
-                belongsToAnchor: anchor && (
-                    isReference
-                        ? anchor.reference_word_ids[currentSource!]?.includes(wordId)
-                        : anchor.word_ids.includes(wordId)
-                ),
-                belongsToGap: gap && (
-                    isReference
-                        ? gap.corrections.some(c => c.word_id === wordId)
-                        : gap.word_ids.includes(wordId)
-                ),
-                wordIndexInGap: gap && gap.words.indexOf(word),
-                hasMatchingCorrection: gap && gap.corrections.some(c => c.word_id === wordId)
+                mode
+            },
+            anchorInfo: anchor && {
+                id: anchor.id,
+                transcribedWordIds: anchor.transcribed_word_ids,
+                referenceWordIds: anchor.reference_word_ids,
+                belongsToAnchor
+            },
+            gapInfo: matchingGap && {
+                id: matchingGap.id,
+                transcribedWordIds: matchingGap.transcribed_word_ids,
+                referenceWordIds: matchingGap.reference_word_ids,
+                belongsToGap,
+                relatedCorrections: corrections.filter(c =>
+                    matchingGap.transcribed_word_ids.includes(c.word_id) ||
+                    c.corrected_word_id === wordId ||
+                    c.word_id === wordId
+                )
             }
-        }, null, 2))
+        })
 
         // For reference view clicks, find the corresponding gap
         if (isReference && currentSource) {
-            // Extract position from wordId (e.g., "genius-word-3" -> 3)
-            const position = parseInt(wordId.split('-').pop() || '', 10);
-
-            // Find gap that has a correction matching this reference position
             const matchingGap = gaps?.find(g =>
-                g.corrections.some(c => {
-                    const refPosition = c.reference_positions?.[currentSource];
-                    return typeof refPosition === 'number' && refPosition === position;
-                })
-            );
+                g.reference_word_ids[currentSource]?.includes(wordId)
+            )
 
             if (matchingGap) {
                 console.log('Found matching gap for reference click:', {
-                    position,
+                    wordId,
                     gap: matchingGap
-                });
-                gap = matchingGap;
+                })
+                gap = matchingGap
             }
         }
 
-        const belongsToAnchor = anchor && (
-            isReference
-                ? anchor.reference_word_ids[currentSource!]?.includes(wordId)
-                : anchor.word_ids.includes(wordId)
-        )
-
-        const belongsToGap = gap && (
-            isReference
-                ? gap.corrections.some(c => {
-                    const refPosition = c.reference_positions?.[currentSource!];
-                    const clickedPosition = parseInt(wordId.split('-').pop() || '', 10);
-                    return typeof refPosition === 'number' && refPosition === clickedPosition;
-                })
-                : gap.word_ids.includes(wordId)
-        )
-
         if (mode === 'highlight' || mode === 'edit') {
             if (belongsToAnchor && anchor) {
                 onWordClick?.({
@@ -126,32 +106,22 @@ export function useWordClick({
                     gap: undefined
                 })
             } else if (belongsToGap && gap) {
-                // Create highlight info that includes both transcription and reference IDs
-                const referenceWords: Record<string, string[]> = {};
-
-                // For each correction in the gap, add its reference positions
-                gap.corrections.forEach(correction => {
-                    Object.entries(correction.reference_positions || {}).forEach(([source, position]) => {
-                        if (typeof position === 'number') {
-                            const refId = `${source}-word-${position}`;
-                            if (!referenceWords[source]) {
-                                referenceWords[source] = [];
-                            }
-                            if (!referenceWords[source].includes(refId)) {
-                                referenceWords[source].push(refId);
-                            }
-                        }
-                    });
-                });
-
                 onWordClick?.({
                     word_id: wordId,
                     type: 'gap',
                     anchor: undefined,
-                    gap: {
-                        ...gap,
-                        reference_words: referenceWords // Use reference_words instead of reference_word_ids
-                    }
+                    gap
+                })
+            } else if (corrections.some(c => 
+                (c.corrected_word_id === wordId || c.word_id === wordId) &&
+                gap?.transcribed_word_ids.includes(c.word_id)
+            )) {
+                // If the word is part of a correction, mark it as a gap
+                onWordClick?.({
+                    word_id: wordId,
+                    type: 'gap',
+                    anchor: undefined,
+                    gap
                 })
             } else {
                 onWordClick?.({
@@ -168,7 +138,8 @@ export function useWordClick({
                     data: {
                         ...anchor,
                         wordId,
-                        word
+                        word,
+                        anchor_sequences: anchors
                     }
                 })
             } else if (belongsToGap && gap) {
@@ -177,33 +148,32 @@ export function useWordClick({
                     data: {
                         ...gap,
                         wordId,
-                        word
+                        word,
+                        anchor_sequences: anchors
                     }
                 })
             } else if (!isReference) {
                 // Create synthetic gap for non-sequence words (transcription view only)
                 const syntheticGap: GapSequence = {
                     id: `synthetic-${wordId}`,
-                    text: word,
-                    words: [word],
-                    word_ids: [wordId],
-                    length: 1,
-                    corrections: [],
-                    preceding_anchor: null,
-                    following_anchor: null,
-                    reference_words: {}
+                    transcribed_word_ids: [wordId],
+                    transcription_position: -1,
+                    preceding_anchor_id: null,
+                    following_anchor_id: null,
+                    reference_word_ids: {}
                 }
                 onElementClick({
                     type: 'gap',
                     data: {
                         ...syntheticGap,
                         wordId,
-                        word
+                        word,
+                        anchor_sequences: anchors
                     }
                 })
             }
         }
-    }, [mode, onWordClick, onElementClick, isReference, currentSource, gaps])
+    }, [mode, onWordClick, onElementClick, isReference, currentSource, gaps, anchors, corrections])
 
     return { handleWordClick }
 } 

lyrics_transcriber/frontend/src/components/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

lyrics_transcriber/frontend/src/components/shared/types.ts

@@ -1,8 +1,8 @@
-import { AnchorSequence, GapSequence, HighlightInfo, InteractionMode, LyricsData, LyricsSegment } from '../../types'
+import { AnchorSequence, GapSequence, HighlightInfo, InteractionMode, CorrectionData, LyricsSegment, ReferenceSource, WordCorrection } from '../../types'
 import { ModalContent } from '../LyricsAnalyzer'
 
 // Add FlashType definition directly in shared types
-export type FlashType = 'anchor' | 'corrected' | 'uncorrected' | 'word' | null
+export type FlashType = 'anchor' | 'corrected' | 'uncorrected' | 'word' | 'handler' | null
 
 // Common word click handling
 export interface WordClickInfo {
@@ -66,10 +66,17 @@ export interface TextSegmentProps extends BaseViewProps {
 }
 
 // View-specific props
-export interface TranscriptionViewProps extends BaseViewProps {
-    data: LyricsData
+export interface TranscriptionViewProps {
+    data: CorrectionData
+    onElementClick: (content: ModalContent) => void
+    onWordClick?: (info: WordClickInfo) => void
+    flashingType: FlashType
+    highlightInfo: HighlightInfo | null
+    mode: InteractionMode
     onPlaySegment?: (startTime: number) => void
     currentTime?: number
+    anchors?: AnchorSequence[]
+    flashingHandler?: string | null
 }
 
 // Add LinePosition type here since it's used in multiple places
@@ -81,12 +88,13 @@ export interface LinePosition {
 
 // Reference-specific props
 export interface ReferenceViewProps extends BaseViewProps {
-    referenceTexts: Record<string, string>
-    anchors: LyricsData['anchor_sequences']
-    gaps: LyricsData['gap_sequences']
+    referenceSources: Record<string, ReferenceSource>
+    anchors: CorrectionData['anchor_sequences']
+    gaps: CorrectionData['gap_sequences']
     currentSource: string
     onSourceChange: (source: string) => void
     corrected_segments: LyricsSegment[]
+    corrections: WordCorrection[]
 }
 
 // Update HighlightedTextProps to include linePositions

lyrics_transcriber/frontend/src/components/shared/utils/keyboardHandlers.ts

@@ -0,0 +1,67 @@
+// Add a global ref for the modal handler
+let currentModalHandler: ((e: KeyboardEvent) => void) | undefined
+let isModalOpen = false
+
+type KeyboardState = {
+    setIsShiftPressed: (value: boolean) => void
+    setIsCtrlPressed: (value: boolean) => void
+    modalHandler?: {
+        isOpen: boolean
+        onSpacebar?: (e: KeyboardEvent) => void
+    }
+}
+
+// Add functions to update the modal handler state
+export const setModalHandler = (handler: ((e: KeyboardEvent) => void) | undefined, open: boolean) => {
+    currentModalHandler = handler
+    isModalOpen = open
+}
+
+export const setupKeyboardHandlers = (state: KeyboardState) => {
+    const handlerId = Math.random().toString(36).substr(2, 9)
+    console.log(`Setting up keyboard handlers [${handlerId}]`)
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+        if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+            console.log(`[${handlerId}] Ignoring keydown in input/textarea`)
+            return
+        }
+
+        if (e.key === 'Shift') {
+            state.setIsShiftPressed(true)
+            document.body.style.userSelect = 'none'
+        } else if (e.key === 'Meta') {
+            state.setIsCtrlPressed(true)
+        } else if (e.key === ' ' || e.code === 'Space') {
+            console.log(`[${handlerId}] Spacebar pressed:`, {
+                modalOpen: isModalOpen,
+                hasModalHandler: !!currentModalHandler,
+                hasGlobalToggle: !!window.toggleAudioPlayback
+            })
+            
+            e.preventDefault()
+            
+            // If modal is open and has a handler, use that
+            if (isModalOpen && currentModalHandler) {
+                console.log(`[${handlerId}] Using modal spacebar handler`)
+                currentModalHandler(e)
+            } 
+            // Otherwise use global audio control
+            else if (window.toggleAudioPlayback && !isModalOpen) {
+                console.log(`[${handlerId}] Using global audio toggle`)
+                window.toggleAudioPlayback()
+            }
+        }
+    }
+
+    const handleKeyUp = (e: KeyboardEvent) => {
+        if (e.key === 'Shift') {
+            state.setIsShiftPressed(false)
+            document.body.style.userSelect = ''
+        } else if (e.key === 'Meta') {
+            state.setIsCtrlPressed(false)
+        }
+    }
+
+    return { handleKeyDown, handleKeyUp }
+} 

lyrics_transcriber/frontend/src/components/shared/utils/localStorage.ts

@@ -0,0 +1,78 @@
+import { CorrectionData, LyricsSegment } from '../../../types'
+
+// Change the key generation to use a hash of the first segment's text instead
+export const generateStorageKey = (data: CorrectionData): string => {
+    const text = data.original_segments[0]?.text || ''
+    let hash = 0
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charCodeAt(i)
+        hash = ((hash << 5) - hash) + char
+        hash = hash & hash // Convert to 32-bit integer
+    }
+    return `song_${hash}`
+}
+
+const stripIds = (obj: CorrectionData): LyricsSegment[] => {
+    const clone = JSON.parse(JSON.stringify(obj))
+    return clone.corrected_segments.map((segment: LyricsSegment) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { id: _id, ...strippedSegment } = segment
+        return {
+            ...strippedSegment,
+            words: segment.words.map(word => {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { id: _wordId, ...strippedWord } = word
+                return strippedWord
+            })
+        }
+    })
+}
+
+export const loadSavedData = (initialData: CorrectionData): CorrectionData | null => {
+    const storageKey = generateStorageKey(initialData)
+    const savedDataStr = localStorage.getItem('lyrics_analyzer_data')
+    const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {}
+
+    if (savedDataObj[storageKey]) {
+        try {
+            const parsed = savedDataObj[storageKey]
+            // Compare first segment text instead of transcribed_text
+            if (parsed.original_segments[0]?.text === initialData.original_segments[0]?.text) {
+                const strippedSaved = stripIds(parsed)
+                const strippedInitial = stripIds(initialData)
+                const hasChanges = JSON.stringify(strippedSaved) !== JSON.stringify(strippedInitial)
+
+                if (hasChanges) {
+                    return parsed
+                } else {
+                    // Clean up storage if no changes
+                    delete savedDataObj[storageKey]
+                    localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj))
+                }
+            }
+        } catch (error) {
+            console.error('Failed to parse saved data:', error)
+            delete savedDataObj[storageKey]
+            localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj))
+        }
+    }
+    return null
+}
+
+export const saveData = (data: CorrectionData, initialData: CorrectionData): void => {
+    const storageKey = generateStorageKey(initialData)
+    const savedDataStr = localStorage.getItem('lyrics_analyzer_data')
+    const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {}
+
+    savedDataObj[storageKey] = data
+    localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj))
+}
+
+export const clearSavedData = (data: CorrectionData): void => {
+    const storageKey = generateStorageKey(data)
+    const savedDataStr = localStorage.getItem('lyrics_analyzer_data')
+    const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {}
+
+    delete savedDataObj[storageKey]
+    localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj))
+} 

lyrics_transcriber/frontend/src/components/shared/utils/referenceLineCalculator.ts

@@ -1,9 +1,9 @@
-import { LyricsData, LyricsSegment } from '../../../types'
+import { AnchorSequence, LyricsSegment } from '../../../types'
 import { LinePosition } from '../types'
 
 export function calculateReferenceLinePositions(
     corrected_segments: LyricsSegment[],
-    anchors: LyricsData['anchor_sequences'],
+    anchors: AnchorSequence[],
     currentSource: string
 ): { linePositions: LinePosition[] } {
     const linePositions: LinePosition[] = []
@@ -11,9 +11,7 @@ export function calculateReferenceLinePositions(
 
     // First, find all anchor sequences that cover entire lines
     const fullLineAnchors = anchors?.map(anchor => {
-        // Add null checks for anchor and reference_word_ids
-        if (!anchor?.reference_word_ids?.[currentSource]) return null
-
+        // Check if we have reference word IDs for this source
         const referenceWordIds = anchor.reference_word_ids[currentSource]
         if (!referenceWordIds?.length) return null
 
@@ -23,8 +21,10 @@ export function calculateReferenceLinePositions(
                 const wordIds = segment.words.map(w => w.id)
                 if (!wordIds.length) return false
 
-                // Check if all word IDs in this segment are part of the anchor
-                return wordIds.every(id => anchor.word_ids?.includes(id))
+                // Check if all word IDs in this segment are part of the anchor's transcribed word IDs
+                return wordIds.every(id =>
+                    anchor.transcribed_word_ids.includes(id)
+                )
             })
         }
     })?.filter((a): a is NonNullable<typeof a> => a !== null) ?? []

lyrics_transcriber/frontend/src/components/shared/utils/segmentOperations.ts

@@ -0,0 +1,121 @@
+import { nanoid } from 'nanoid'
+import { CorrectionData, LyricsSegment } from '../../../types'
+
+export const addSegmentBefore = (
+    data: CorrectionData,
+    beforeIndex: number
+): CorrectionData => {
+    const newData = { ...data }
+    const beforeSegment = newData.corrected_segments[beforeIndex]
+
+    // Create new segment starting 1 second before the target segment
+    // Use 0 as default if start_time is null
+    const newStartTime = Math.max(0, (beforeSegment.start_time ?? 1) - 1)
+    const newEndTime = newStartTime + 1
+
+    const newSegment: LyricsSegment = {
+        id: nanoid(),
+        text: "REPLACE",
+        start_time: newStartTime,
+        end_time: newEndTime,
+        words: [{
+            id: nanoid(),
+            text: "REPLACE",
+            start_time: newStartTime,
+            end_time: newEndTime,
+            confidence: 1.0
+        }]
+    }
+
+    // Insert the new segment before the current one
+    newData.corrected_segments.splice(beforeIndex, 0, newSegment)
+
+    return newData
+}
+
+export const splitSegment = (
+    data: CorrectionData,
+    segmentIndex: number,
+    afterWordIndex: number
+): CorrectionData | null => {
+    const newData = { ...data }
+    const segment = newData.corrected_segments[segmentIndex]
+
+    // Split the words array
+    const firstHalfWords = segment.words.slice(0, afterWordIndex + 1)
+    const secondHalfWords = segment.words.slice(afterWordIndex + 1)
+
+    if (secondHalfWords.length === 0) return null // Nothing to split
+
+    const lastFirstWord = firstHalfWords[firstHalfWords.length - 1]
+    const firstSecondWord = secondHalfWords[0]
+    const lastSecondWord = secondHalfWords[secondHalfWords.length - 1]
+
+    // Create two segments from the split
+    const firstSegment: LyricsSegment = {
+        ...segment,
+        words: firstHalfWords,
+        text: firstHalfWords.map(w => w.text).join(' '),
+        end_time: lastFirstWord.end_time ?? null
+    }
+
+    const secondSegment: LyricsSegment = {
+        id: nanoid(),
+        words: secondHalfWords,
+        text: secondHalfWords.map(w => w.text).join(' '),
+        start_time: firstSecondWord.start_time ?? null,
+        end_time: lastSecondWord.end_time ?? null
+    }
+
+    // Replace the original segment with the two new segments
+    newData.corrected_segments.splice(segmentIndex, 1, firstSegment, secondSegment)
+
+    return newData
+}
+
+export const deleteSegment = (
+    data: CorrectionData,
+    segmentIndex: number
+): CorrectionData => {
+    const newData = { ...data }
+    const deletedSegment = newData.corrected_segments[segmentIndex]
+
+    // Remove segment
+    newData.corrected_segments = newData.corrected_segments.filter((_, index) => index !== segmentIndex)
+
+    // Update anchor sequences to remove references to deleted words
+    newData.anchor_sequences = newData.anchor_sequences.map(anchor => ({
+        ...anchor,
+        transcribed_word_ids: anchor.transcribed_word_ids.filter(wordId =>
+            !deletedSegment.words.some(deletedWord => deletedWord.id === wordId)
+        )
+    }))
+
+    // Update gap sequences to remove references to deleted words
+    newData.gap_sequences = newData.gap_sequences.map(gap => ({
+        ...gap,
+        transcribed_word_ids: gap.transcribed_word_ids.filter(wordId =>
+            !deletedSegment.words.some(deletedWord => deletedWord.id === wordId)
+        )
+    }))
+
+    return newData
+}
+
+export const updateSegment = (
+    data: CorrectionData,
+    segmentIndex: number,
+    updatedSegment: LyricsSegment
+): CorrectionData => {
+    const newData = { ...data }
+
+    // Ensure new words have IDs
+    updatedSegment.words = updatedSegment.words.map(word => ({
+        ...word,
+        id: word.id || nanoid()
+    }))
+
+    newData.corrected_segments[segmentIndex] = updatedSegment
+
+    return newData
+} 

lyrics_transcriber/frontend/src/components/shared/utils/wordUtils.ts

@@ -0,0 +1,22 @@
+import { Word, LyricsSegment } from '../../../types'
+
+/**
+ * Find a Word object by its ID within an array of segments
+ */
+export function findWordById(segments: LyricsSegment[], wordId: string): Word | undefined {
+    for (const segment of segments) {
+        const word = segment.words.find(w => w.id === wordId)
+        if (word) return word
+    }
+    return undefined
+}
+
+/**
+ * Convert an array of word IDs to their corresponding Word objects
+ * Filters out any IDs that don't match to valid words
+ */
+export function getWordsFromIds(segments: LyricsSegment[], wordIds: string[]): Word[] {
+    return wordIds
+        .map(id => findWordById(segments, id))
+        .filter((word): word is Word => word !== undefined)
+} 

lyrics_transcriber/frontend/src/types/global.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    interface Window {
+        toggleAudioPlayback?: () => void;
+        seekAndPlayAudio?: (startTime: number) => void;
+        isAudioPlaying?: boolean;
+    }
+}
+
+export {} 

lyrics_transcriber/frontend/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });