bug fixes

app.py

@@ -15,6 +15,8 @@ import mutagen.oggvorbis
 from werkzeug.utils import secure_filename
 import logging
 import base64
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
 
 app = Flask(__name__, static_folder='static')
 # Create a temporary directory for uploads
@@ -33,6 +35,8 @@ file_timestamps = {}
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+THREAD_POOL = ThreadPoolExecutor(max_workers=4)  # Adjust based on your server capacity
+
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
@@ -43,119 +47,36 @@ def extract_metadata(filepath):
         if audio is None:
             return {}
             
+        # Basic metadata that we absolutely need
         metadata = {
-            'duration': round(audio.info.length) if hasattr(audio.info, 'length') else None,
-            'bitrate': round(audio.info.bitrate / 1000) if hasattr(audio.info, 'bitrate') else None,
-            'sample_rate': audio.info.sample_rate if hasattr(audio.info, 'sample_rate') else None,
-            'channels': audio.info.channels if hasattr(audio.info, 'channels') else None,
             'title': None,
             'artist': 'Unknown Artist',
-            'album': None,
-            'genre': None,
-            'date': None,
-            'artwork': None
+            'duration': None
         }
 
-        # Get the original filename without timestamp prefix and extension
+        # Get filename as fallback
         original_filename = os.path.splitext(os.path.basename(filepath))[0]
         if '_' in original_filename:
             original_filename = '_'.join(original_filename.split('_')[2:])
-       
+
         try:
-            # Handle MP3 files
-            if isinstance(audio, mutagen.mp3.MP3):
-                try:
-                    # Try to get ID3 tags first
-                    if audio.tags:
-                        id3 = audio.tags
-                    else:
-                        # If no tags exist, try to create them
-                        id3 = mutagen.id3.ID3(filepath)
-                    
-                    # Get basic metadata
-                    metadata.update({
-                        'title': str(id3.get('TIT2', [''])[0]) if 'TIT2' in id3 else '',
-                        'artist': str(id3.get('TPE1', ['Unknown Artist'])[0]) if 'TPE1' in id3 else 'Unknown Artist',
-                        'album': str(id3.get('TALB', [''])[0]) if 'TALB' in id3 else '',
-                        'genre': str(id3.get('TCON', [''])[0]) if 'TCON' in id3 else '',
-                        'date': str(id3.get('TDRC', [''])[0]) if 'TDRC' in id3 else ''
-                    })
-                    
-                    # Extract artwork - try different APIC frame keys
-                    apic_keys = ['APIC:', 'APIC:Cover', 'APIC:Front Cover', 'APIC']
-                    for key in apic_keys:
-                        if key in id3:
-                            artwork = id3[key]
-                            if artwork and artwork.data:
-                                logger.info(f"Found artwork in {key} frame")
-                                metadata['artwork'] = {
-                                    'mime': artwork.mime,
-                                    'data': base64.b64encode(artwork.data).decode('utf-8')
-                                }
-                                break
-                    
-                    if not metadata['artwork']:
-                        logger.info("No artwork found in ID3 tags")
-                        
-                except Exception as e:
-                    logger.error(f"Error reading ID3 tags: {str(e)}")
-                    # Fallback to EasyID3 if ID3 fails
-                    try:
-                        easy_id3 = EasyID3(filepath)
-                        metadata.update({
-                            'title': easy_id3.get('title', [''])[0],
-                            'artist': easy_id3.get('artist', ['Unknown Artist'])[0],
-                            'album': easy_id3.get('album', [''])[0],
-                            'genre': easy_id3.get('genre', [''])[0],
-                            'date': easy_id3.get('date', [''])[0]
-                        })
-                    except:
-                        metadata['title'] = original_filename
+            # Add basic audio info
+            if hasattr(audio.info, 'length'):
+                metadata['duration'] = round(audio.info.length)
 
-            # Handle FLAC files
-            elif isinstance(audio, mutagen.flac.FLAC):
+            # Simplified tag extraction
+            if isinstance(audio, (mutagen.flac.FLAC, mutagen.oggvorbis.OggVorbis)):
                 metadata.update({
-                    'title': audio.tags.get('TITLE', [''])[0] if audio.tags and 'TITLE' in audio.tags else None,
-                    'artist': audio.tags.get('ARTIST', ['Unknown Artist'])[0] if audio.tags and 'ARTIST' in audio.tags else 'Unknown Artist',
-                    'album': audio.tags.get('ALBUM', [''])[0] if audio.tags and 'ALBUM' in audio.tags else None,
-                    'genre': audio.tags.get('GENRE', [''])[0] if audio.tags and 'GENRE' in audio.tags else None,
-                    'date': audio.tags.get('DATE', [''])[0] if audio.tags and 'DATE' in audio.tags else None
+                    'title': audio.tags.get('TITLE', [original_filename])[0] if audio.tags else original_filename,
+                    'artist': audio.tags.get('ARTIST', ['Unknown Artist'])[0] if audio.tags else 'Unknown Artist',
                 })
-                
-                # Extract artwork from pictures
-                if audio.pictures:
-                    picture = audio.pictures[0]
-                    metadata['artwork'] = {
-                        'mime': picture.mime,
-                        'data': base64.b64encode(picture.data).decode('utf-8')
-                    }
-            
-            # Handle OGG files
-            elif isinstance(audio, mutagen.oggvorbis.OggVorbis):
-                metadata.update({
-                    'title': audio.get('title', [''])[0] if 'title' in audio else None,
-                    'artist': audio.get('artist', ['Unknown Artist'])[0] if 'artist' in audio else 'Unknown Artist',
-                    'album': audio.get('album', [''])[0] if 'album' in audio else None,
-                    'genre': audio.get('genre', [''])[0] if 'genre' in audio else None,
-                    'date': audio.get('date', [''])[0] if 'date' in audio else None
-                })
-                
-                # Extract artwork if available (some OGG files store artwork in metadata)
-                if 'METADATA_BLOCK_PICTURE' in audio:
-                    try:
-                        picture_data = base64.b64decode(audio['METADATA_BLOCK_PICTURE'][0])
-                        picture = mutagen.flac.Picture(picture_data)
-                        metadata['artwork'] = {
-                            'mime': picture.mime,
-                            'data': base64.b64encode(picture.data).decode('utf-8')
-                        }
-                    except:
-                        pass
-            
-            # If title is not found or empty, use original filename
-            if not metadata['title']:
-                metadata['title'] = original_filename
-                
+            elif isinstance(audio, mutagen.mp3.MP3):
+                if audio.tags:
+                    metadata.update({
+                        'title': str(audio.tags.get('TIT2', original_filename)),
+                        'artist': str(audio.tags.get('TPE1', 'Unknown Artist')),
+                    })
+
         except Exception as e:
             logger.error(f"Error reading tags: {str(e)}")
             metadata['title'] = original_filename
@@ -164,7 +85,7 @@ def extract_metadata(filepath):
     except Exception as e:
         logger.error(f"Error extracting metadata: {str(e)}")
         return {
-            'title': os.path.splitext(os.path.basename(filepath))[0].split('_', 2)[-1],
+            'title': original_filename,
             'artist': 'Unknown Artist'
         }
 
@@ -220,66 +141,52 @@ def upload_file():
     files = request.files.getlist('files[]')
     logger.info(f'Received {len(files)} files')
     
-    if not files or all(file.filename == '' for file in files):
-        logger.warning('No selected files')
-        return jsonify({'success': False, 'error': 'No selected files'}), 400
-
     if len(files) > app.config['MAX_FILES']:
-        logger.warning(f'Too many files: {len(files)}')
         return jsonify({
             'success': False,
             'error': f"Maximum {app.config['MAX_FILES']} files can be uploaded at once"
         }), 400
 
     results = []
-    for file in files:
-        logger.info(f'Processing file: {file.filename}')
-        if file and allowed_file(file.filename):
-            try:
+    futures = []
+
+    def process_file(file):
+        try:
+            if file and allowed_file(file.filename):
                 filename = secure_filename(file.filename)
                 timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_')
                 filename = timestamp + filename
                 
                 filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                 file.save(filepath)
-                logger.info(f'File saved: {filepath}')
                 
                 file_timestamps[filename] = datetime.now()
-                
-                if not os.path.exists(filepath):
-                    logger.error(f'Failed to save file: {filepath}')
-                    results.append({
-                        'filename': file.filename,
-                        'success': False,
-                        'error': 'Failed to save file'
-                    })
-                    continue
-                
                 metadata = extract_metadata(filepath)
-                logger.info(f'Metadata extracted: {metadata}')
-                    
-                results.append({
+                
+                return {
                     'filename': file.filename,
                     'success': True,
                     'filepath': f'/static/uploads/{filename}',
                     'metadata': metadata
-                })
-            except Exception as e:
-                logger.error(f'Upload error for {file.filename}: {str(e)}')
-                results.append({
-                    'filename': file.filename,
-                    'success': False,
-                    'error': 'Server error during upload'
-                })
-        else:
-            logger.warning(f'Invalid file type: {file.filename}')
-            results.append({
+                }
+            return {
                 'filename': file.filename,
                 'success': False,
                 'error': 'Invalid file type'
-            })
+            }
+        except Exception as e:
+            logger.error(f'Upload error for {file.filename}: {str(e)}')
+            return {
+                'filename': file.filename,
+                'success': False,
+                'error': 'Server error during upload'
+            }
+
+    # Process files in parallel
+    with THREAD_POOL:
+        futures = [THREAD_POOL.submit(process_file, file) for file in files]
+        results = [future.result() for future in futures]
 
-    logger.info(f'Upload complete. Results: {results}')
     return jsonify({
         'success': True,
         'files': results