@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/backend/dubber.py

@@ -1,205 +0,0 @@
-"""
-Neural Dubber Module (Demo Level)
-Simulates AI-based voice dubbing for educational demonstration
-Uses gTTS (Google Text-to-Speech) for voice synthesis
-"""
-
-import os
-from moviepy.editor import VideoFileClip, AudioFileClip, CompositeAudioClip
-from gtts import gTTS
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class NeuralDubber:
-    """Handles neural dubbing demonstration"""
-    
-    def __init__(self, download_folder):
-        """
-        Initialize neural dubber
-        
-        Args:
-            download_folder (str): Path to store dubbed files
-        """
-        self.download_folder = download_folder
-        self.temp_folder = os.path.join(download_folder, 'temp')
-        os.makedirs(self.temp_folder, exist_ok=True)
-    
-    def dub(self, filename, session_id, text=None, language='en'):
-        """
-        Apply neural dubbing to media file (Demo)
-        
-        Args:
-            filename (str): Input filename
-            session_id (str): Unique session identifier
-            text (str): Text for dubbing (optional)
-            language (str): Language code for TTS
-            
-        Returns:
-            dict: Result with success status and dubbed filename
-        """
-        try:
-            input_path = os.path.join(self.download_folder, filename)
-            
-            if not os.path.exists(input_path):
-                return {
-                    'success': False,
-                    'error': 'Input file not found'
-                }
-            
-            logger.info(f"Starting neural dubbing for {filename}")
-            
-            # Default demo text if none provided
-            if not text:
-                text = (
-                    "This is a demonstration of neural dubbing technology. "
-                    "In a production system, this would use advanced AI models "
-                    "to generate realistic voice dubbing. "
-                    "This is an educational project for Software Development diploma."
-                )
-            
-            # Determine if it's video or audio
-            file_ext = os.path.splitext(filename)[1].lower()
-            
-            if file_ext in ['.mp4', '.avi', '.mov', '.mkv']:
-                return self._dub_video(input_path, session_id, text, language)
-            elif file_ext in ['.mp3', '.wav', '.m4a', '.aac']:
-                return self._dub_audio(input_path, session_id, text, language)
-            else:
-                # Try as video
-                return self._dub_video(input_path, session_id, text, language)
-                
-        except Exception as e:
-            logger.error(f"Dubbing error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def _generate_voice(self, text, language, output_path):
-        """
-        Generate synthetic voice using TTS
-        
-        Args:
-            text (str): Text to convert to speech
-            language (str): Language code
-            output_path (str): Output audio file path
-        """
-        try:
-            # Generate speech using gTTS
-            tts = gTTS(text=text, lang=language, slow=False)
-            tts.save(output_path)
-            logger.info(f"Generated voice audio: {output_path}")
-            
-        except Exception as e:
-            logger.error(f"Voice generation error: {str(e)}")
-            raise
-    
-    def _dub_video(self, input_path, session_id, text, language):
-        """
-        Dub video file with synthetic voice
-        
-        Args:
-            input_path (str): Path to input video
-            session_id (str): Session identifier
-            text (str): Dubbing text
-            language (str): Language code
-            
-        Returns:
-            dict: Dubbing result
-        """
-        try:
-            # Load video
-            video = VideoFileClip(input_path)
-            
-            # Generate voice audio
-            voice_audio_path = os.path.join(self.temp_folder, f'{session_id}_voice.mp3')
-            self._generate_voice(text, language, voice_audio_path)
-            
-            # Load generated voice
-            voice_audio = AudioFileClip(voice_audio_path)
-            
-            # Adjust voice duration to match video (loop or trim)
-            if voice_audio.duration < video.duration:
-                # Loop the voice audio
-                loops_needed = int(video.duration / voice_audio.duration) + 1
-                voice_audio = voice_audio.loop(n=loops_needed)
-            
-            # Trim to video duration
-            voice_audio = voice_audio.subclip(0, min(voice_audio.duration, video.duration))
-            
-            # Replace video audio with dubbed voice
-            dubbed_video = video.set_audio(voice_audio)
-            
-            # Generate output filename
-            dubbed_filename = f'{session_id}_dubbed.mp4'
-            dubbed_path = os.path.join(self.download_folder, dubbed_filename)
-            
-            # Write dubbed video
-            dubbed_video.write_videofile(
-                dubbed_path,
-                codec='libx264',
-                audio_codec='aac',
-                logger=None
-            )
-            
-            # Cleanup
-            video.close()
-            voice_audio.close()
-            dubbed_video.close()
-            
-            # Remove temp voice file
-            if os.path.exists(voice_audio_path):
-                os.remove(voice_audio_path)
-            
-            logger.info(f"Created dubbed video: {dubbed_filename}")
-            
-            return {
-                'success': True,
-                'filename': dubbed_filename,
-                'method': 'Neural TTS (Demo)'
-            }
-            
-        except Exception as e:
-            logger.error(f"Video dubbing error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def _dub_audio(self, input_path, session_id, text, language):
-        """
-        Replace audio file with synthetic voice
-        
-        Args:
-            input_path (str): Path to input audio
-            session_id (str): Session identifier
-            text (str): Dubbing text
-            language (str): Language code
-            
-        Returns:
-            dict: Dubbing result
-        """
-        try:
-            # Generate output filename
-            dubbed_filename = f'{session_id}_dubbed.mp3'
-            dubbed_path = os.path.join(self.download_folder, dubbed_filename)
-            
-            # Generate voice directly as output
-            self._generate_voice(text, language, dubbed_path)
-            
-            logger.info(f"Created dubbed audio: {dubbed_filename}")
-            
-            return {
-                'success': True,
-                'filename': dubbed_filename,
-                'method': 'Neural TTS (Demo)'
-            }
-            
-        except Exception as e:
-            logger.error(f"Audio dubbing error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/backend/installed.flag

@@ -1 +0,0 @@
-done 

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/backend/installed.txt

@@ -1 +0,0 @@
-done 

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/backend/requirements.txt

@@ -1,7 +0,0 @@
-
-Flask
-flask-cors
-# Use specific version or just latest
-yt-dlp>=2024.10.0
-moviepy
-werkzeug

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/backend/segmenter.py

@@ -1,199 +0,0 @@
-"""
-Media Segmenter Module
-Splits video/audio into time-based segments
-Uses MoviePy for video processing
-"""
-
-import os
-from moviepy.editor import VideoFileClip, AudioFileClip
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class MediaSegmenter:
-    """Handles video and audio segmentation"""
-    
-    def __init__(self, download_folder):
-        """
-        Initialize segmenter
-        
-        Args:
-            download_folder (str): Path to store segmented files
-        """
-        self.download_folder = download_folder
-        self.segment_duration = 30  # Default: 30 seconds per segment
-    
-    def segment(self, filename, session_id, segment_duration=None):
-        """
-        Segment media file into multiple parts
-        
-        Args:
-            filename (str): Input filename
-            session_id (str): Unique session identifier
-            segment_duration (int): Duration of each segment in seconds
-            
-        Returns:
-            dict: Result with success status and list of segment filenames
-        """
-        try:
-            if segment_duration:
-                self.segment_duration = segment_duration
-            
-            input_path = os.path.join(self.download_folder, filename)
-            
-            if not os.path.exists(input_path):
-                return {
-                    'success': False,
-                    'error': 'Input file not found'
-                }
-            
-            logger.info(f"Starting segmentation for {filename}")
-            
-            # Determine if it's video or audio
-            file_ext = os.path.splitext(filename)[1].lower()
-            
-            if file_ext in ['.mp4', '.avi', '.mov', '.mkv']:
-                return self._segment_video(input_path, session_id)
-            elif file_ext in ['.mp3', '.wav', '.m4a', '.aac']:
-                return self._segment_audio(input_path, session_id)
-            else:
-                # Try as video first
-                return self._segment_video(input_path, session_id)
-                
-        except Exception as e:
-            logger.error(f"Segmentation error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def _segment_video(self, input_path, session_id):
-        """
-        Segment video file
-        
-        Args:
-            input_path (str): Path to input video
-            session_id (str): Session identifier
-            
-        Returns:
-            dict: Segmentation result
-        """
-        try:
-            video = VideoFileClip(input_path)
-            duration = video.duration
-            
-            logger.info(f"Video duration: {duration} seconds")
-            
-            # Calculate number of segments
-            num_segments = int(duration / self.segment_duration) + 1
-            
-            # Limit to 5 segments for demo purposes
-            num_segments = min(num_segments, 5)
-            
-            segment_files = []
-            
-            for i in range(num_segments):
-                start_time = i * self.segment_duration
-                end_time = min((i + 1) * self.segment_duration, duration)
-                
-                if start_time >= duration:
-                    break
-                
-                # Create segment
-                segment = video.subclip(start_time, end_time)
-                
-                # Generate output filename
-                segment_filename = f'{session_id}_segment_{i+1}.mp4'
-                segment_path = os.path.join(self.download_folder, segment_filename)
-                
-                # Write segment
-                segment.write_videofile(
-                    segment_path,
-                    codec='libx264',
-                    audio_codec='aac',
-                    logger=None  # Suppress MoviePy logs
-                )
-                
-                segment_files.append(segment_filename)
-                logger.info(f"Created segment {i+1}: {segment_filename}")
-            
-            # Close video
-            video.close()
-            
-            return {
-                'success': True,
-                'segments': segment_files,
-                'count': len(segment_files)
-            }
-            
-        except Exception as e:
-            logger.error(f"Video segmentation error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def _segment_audio(self, input_path, session_id):
-        """
-        Segment audio file
-        
-        Args:
-            input_path (str): Path to input audio
-            session_id (str): Session identifier
-            
-        Returns:
-            dict: Segmentation result
-        """
-        try:
-            audio = AudioFileClip(input_path)
-            duration = audio.duration
-            
-            logger.info(f"Audio duration: {duration} seconds")
-            
-            # Calculate number of segments
-            num_segments = int(duration / self.segment_duration) + 1
-            
-            # Limit to 5 segments for demo purposes
-            num_segments = min(num_segments, 5)
-            
-            segment_files = []
-            
-            for i in range(num_segments):
-                start_time = i * self.segment_duration
-                end_time = min((i + 1) * self.segment_duration, duration)
-                
-                if start_time >= duration:
-                    break
-                
-                # Create segment
-                segment = audio.subclip(start_time, end_time)
-                
-                # Generate output filename
-                segment_filename = f'{session_id}_segment_{i+1}.mp3'
-                segment_path = os.path.join(self.download_folder, segment_filename)
-                
-                # Write segment
-                segment.write_audiofile(
-                    segment_path,
-                    logger=None  # Suppress MoviePy logs
-                )
-                
-                segment_files.append(segment_filename)
-                logger.info(f"Created segment {i+1}: {segment_filename}")
-            
-            # Close audio
-            audio.close()
-            
-            return {
-                'success': True,
-                'segments': segment_files,
-                'count': len(segment_files)
-            }
-            
-        except Exception as e:
-            logger.error(f"Audio segmentation error: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }