Upload 6 files

__init__.py

@@ -0,0 +1,6 @@
+"""
+Antalya Blog Post Generator package.
+A specialized AI agent for generating culturally rich content about Antalya.
+"""
+
+__version__ = "0.1.0" 

app.py

@@ -0,0 +1,164 @@
+import os
+import gradio as gr
+from datetime import datetime
+from docx import Document
+from docx.shared import Pt, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from audio_processor import AudioProcessor
+import config
+
+class NewsApp:
+    def __init__(self):
+        self.processor = AudioProcessor()
+        
+    def process_audio_file(self, audio_file, content_type="news", language="tr"):
+        """Process audio file and generate content"""
+        try:
+            if audio_file is None:
+                return "Lütfen bir ses dosyası yükleyin.", None
+            
+            # Print debug information
+            print(f"Received audio file: {audio_file}")
+            
+            # Create temporary file to save the uploaded content
+            temp_dir = "temp_audio"
+            os.makedirs(temp_dir, exist_ok=True)
+            
+            # Generate a unique filename
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            temp_audio_path = os.path.join(temp_dir, f"temp_audio_{timestamp}.m4a")
+            
+            # Save the uploaded file
+            with open(temp_audio_path, "wb") as f:
+                f.write(audio_file)
+            
+            print(f"Saved temporary file to: {temp_audio_path}")
+            
+            # Process audio and generate content
+            results = self.processor.process_audio(
+                audio_path=temp_audio_path,
+                language=language,
+                content_type=content_type,
+                generate_content=True
+            )
+            
+            if not results.get("generated_content"):
+                return "İçerik oluşturulamadı. Lütfen ses kaydını kontrol edin.", None
+            
+            # Create Word document
+            doc = Document()
+            
+            # Add title
+            title = doc.add_heading(results["generated_content"]["title"], 0)
+            title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            
+            # Add date
+            date_paragraph = doc.add_paragraph()
+            date_paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            date_run = date_paragraph.add_run(f"Tarih: {results['date']}")
+            date_run.font.size = Pt(10)
+            date_run.font.color.rgb = RGBColor(128, 128, 128)
+            
+            # Add separator
+            doc.add_paragraph("").add_run("_" * 50)
+            
+            # Add content
+            content_lines = results["generated_content"]["content"].split('\n')
+            current_paragraph = None
+            
+            for line in content_lines:
+                if line.strip():
+                    if line.startswith('#'):  # Handle headers
+                        level = line.count('#')
+                        text = line.strip('#').strip()
+                        doc.add_heading(text, level)
+                    else:
+                        if current_paragraph is None or line.startswith('*'):
+                            current_paragraph = doc.add_paragraph()
+                        current_paragraph.add_run(line)
+                else:
+                    current_paragraph = None
+            
+            # Save document
+            output_dir = "data/output"
+            os.makedirs(output_dir, exist_ok=True)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            doc_path = os.path.join(output_dir, f"haber_{timestamp}.docx")
+            doc.save(doc_path)
+            
+            # Return success message and document path
+            return f"İçerik başarıyla oluşturuldu!", doc_path
+            
+        except Exception as e:
+            return f"Hata oluştu: {str(e)}", None
+
+def create_ui():
+    """Create Gradio interface"""
+    app = NewsApp()
+    
+    with gr.Blocks(title="Ses Dosyasından Haber Oluşturma", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🎙️ Ses Dosyasından Haber/Blog Oluşturma
+        
+        Ses kaydınızı yükleyin, yapay zeka destekli sistemimiz sizin için profesyonel bir haber metni veya blog yazısı oluştursun.
+        
+        ### Nasıl Kullanılır:
+        1. Ses dosyanızı yükleyin (.mp3, .m4a, .wav formatları desteklenir)
+        2. İçerik tipini seçin (Haber/Blog)
+        3. Dili seçin
+        4. "Oluştur" butonuna tıklayın
+        5. Oluşturulan Word belgesini indirin
+        
+        ### Önemli Notlar:
+        - Desteklenen ses formatları: MP3, M4A, WAV
+        - Maksimum dosya boyutu: 25MB
+        - İşlem süresi dosya boyutuna göre değişebilir
+        - Türkçe ve İngilizce dilleri desteklenmektedir
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                audio_input = gr.File(
+                    label="Ses Dosyası",
+                    file_types=[".mp3", ".m4a", ".wav"],
+                    type="binary"
+                )
+                
+                content_type = gr.Radio(
+                    choices=["news", "blog"],
+                    value="news",
+                    label="İçerik Tipi",
+                    info="Oluşturulacak içeriğin türünü seçin"
+                )
+                
+                language = gr.Radio(
+                    choices=["tr", "en"],
+                    value="tr",
+                    label="Dil",
+                    info="İçeriğin dilini seçin"
+                )
+                
+                submit_btn = gr.Button("Oluştur", variant="primary")
+            
+            with gr.Column():
+                output_message = gr.Textbox(
+                    label="Durum",
+                    interactive=False
+                )
+                
+                output_file = gr.File(
+                    label="Oluşturulan Dosya",
+                    interactive=False
+                )
+        
+        submit_btn.click(
+            fn=app.process_audio_file,
+            inputs=[audio_input, content_type, language],
+            outputs=[output_message, output_file]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    demo = create_ui()
+    demo.launch() 

audio_processor.py

@@ -0,0 +1,201 @@
+import os
+from typing import Dict, Optional
+from whisper import load_model  # Import directly from whisper package
+import librosa
+import soundfile as sf
+from datetime import datetime
+from rich.console import Console
+from rich.progress import Progress
+from content_generator import ContentGenerator
+import config
+
+class AudioProcessor:
+    def __init__(self):
+        self.console = Console()
+        try:
+            # Use tiny model instead of base for faster processing
+            self.model = load_model("tiny")
+            self.console.print("[green]Successfully loaded Whisper model (tiny)[/green]")
+        except Exception as e:
+            self.console.print(f"[red]Error loading Whisper model:[/red] {str(e)}")
+            raise
+        self.content_generator = ContentGenerator()
+        
+    def process_audio(
+        self,
+        audio_path: str,
+        language: str = config.DEFAULT_LANGUAGE,
+        content_type: str = "news",  # "news" or "blog"
+        generate_content: bool = True
+    ) -> Dict:
+        """
+        Process audio file: transcribe and optionally generate content.
+        
+        Args:
+            audio_path (str): Path to the audio file
+            language (str): Language code for transcription and content generation
+            content_type (str): Type of content to generate ("news" or "blog")
+            generate_content (bool): Whether to generate content from transcript
+            
+        Returns:
+            Dict: Contains transcript and optionally generated content
+        """
+        self.console.print(f"[yellow]Processing audio file:[/yellow] {audio_path}")
+        
+        try:
+            # Transcribe audio with highly optimized settings
+            self.console.print("[yellow]Transcribing audio...[/yellow]")
+            result = self.model.transcribe(
+                audio_path,
+                language=language if language != "tr" else "turkish",
+                fp16=False,
+                beam_size=1,  # Minimum beam size for fastest processing
+                best_of=1,    # Single candidate for fastest processing
+                condition_on_previous_text=False,
+                compression_ratio_threshold=2.4,
+                logprob_threshold=-1.0,
+                no_speech_threshold=0.6,
+                initial_prompt="Bu bir haber metnidir."  # Add context for better transcription
+            )
+            
+            transcript = result["text"]
+            
+            # Generate content if requested
+            generated_content = None
+            if generate_content:
+                self.console.print(f"[yellow]Generating {content_type} content from transcript...[/yellow]")
+                if content_type == "news":
+                    generated_content = self._generate_news_from_transcript(transcript, language)
+                else:
+                    generated_content = self._generate_blog_from_transcript(transcript, language)
+            
+            output = {
+                "transcript": transcript,
+                "language": language,
+                "date": datetime.now().strftime("%Y-%m-%d"),
+                "audio_file": os.path.basename(audio_path),
+                "content_type": content_type
+            }
+            
+            if generated_content:
+                output["generated_content"] = generated_content
+                
+            return output
+            
+        except Exception as e:
+            self.console.print(f"[red]Error processing audio:[/red] {str(e)}")
+            raise
+    
+    def _generate_news_from_transcript(
+        self,
+        transcript: str,
+        language: str
+    ) -> Optional[Dict]:
+        """Generate a news article from the transcript."""
+        try:
+            news_content = self.content_generator.generate_content(
+                topic=transcript,
+                keywords=["news", "professional", "factual"],
+                language=language
+            )
+            
+            # Validate the generated content
+            if news_content and "title" in news_content:
+                if len(news_content["content"].split('\n')) < 3:  # Minimum 3 paragraphs
+                    return None
+                    
+            return news_content
+            
+        except Exception as e:
+            self.console.print(f"[red]Error generating news article:[/red] {str(e)}")
+            return None
+
+    def _generate_blog_from_transcript(
+        self,
+        transcript: str,
+        language: str
+    ) -> Optional[Dict]:
+        """Generate a blog post from the transcript."""
+        try:
+            blog_content = self.content_generator.generate_content(
+                topic=transcript,
+                keywords=["blog", "engaging", "informative"],
+                language=language
+            )
+            return blog_content
+        except Exception as e:
+            self.console.print(f"[red]Error generating blog post:[/red] {str(e)}")
+            return None
+    
+    def save_results(
+        self,
+        results: Dict,
+        output_dir: str = "data/transcripts"
+    ) -> None:
+        """
+        Save transcription and generated content results.
+        
+        Args:
+            results (Dict): Processing results including transcript and content
+            output_dir (str): Directory to save the output files
+        """
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Create base filename from audio file
+        base_name = os.path.splitext(results["audio_file"])[0]
+        date_prefix = results["date"]
+        
+        # Save transcript
+        transcript_file = os.path.join(
+            output_dir,
+            f"{date_prefix}-{base_name}-transcript.txt"
+        )
+        with open(transcript_file, "w", encoding="utf-8") as f:
+            f.write(results["transcript"])
+        
+        # Save generated content if available and valid
+        if "generated_content" in results and results["generated_content"]:
+            content_type = results["content_type"]
+            content_file = os.path.join(
+                output_dir,
+                f"{date_prefix}-{base_name}-{content_type}.md"
+            )
+            
+            try:
+                with open(content_file, "w", encoding="utf-8") as f:
+                    if content_type == "news":
+                        # Add metadata and format for news articles
+                        f.write(f"# {results['generated_content']['title']}\n\n")
+                        
+                        # Extract subtitle if it exists (first non-empty line after title)
+                        content_lines = results['generated_content']['content'].split('\n')
+                        first_line = next((line for line in content_lines if line.strip()), '')
+                        if first_line and not first_line.startswith('*') and not first_line.startswith('#'):
+                            f.write(f"*{first_line}*\n\n")
+                            content = '\n'.join(content_lines[content_lines.index(first_line) + 1:])
+                        else:
+                            content = results['generated_content']['content']
+                        
+                        # Add metadata
+                        f.write(f"**Tarih:** {date_prefix}\n\n")
+                        f.write("---\n\n")  # Separator line
+                        
+                        # Write main content with proper formatting
+                        f.write(content)
+                    else:
+                        # Blog format
+                        f.write(f"# {results['generated_content']['title']}\n\n")
+                        f.write(f"*Yazar: Mete*\n")
+                        f.write(f"*Tarih: {date_prefix}*\n\n")
+                        f.write(results['generated_content']['content'])
+                
+                self.console.print(f"[green]{results['content_type'].title()} content saved to:[/green] {content_file}")
+            except Exception as e:
+                self.console.print(f"[red]Error saving content:[/red] {str(e)}")
+        else:
+            if results.get("content_type") == "news":
+                self.console.print("[yellow]Warning:[/yellow] Could not generate news article from this audio content.")
+            else:
+                self.console.print("[yellow]Warning:[/yellow] Could not generate blog post from this audio content.")
+        
+        self.console.print(f"[green]Transcript saved to:[/green] {transcript_file}") 

config.py

@@ -0,0 +1,36 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# OpenAI Configuration
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+MODEL_NAME = "gpt-4-turbo-preview"  # or any other preferred model
+
+# Agent Configuration
+TEMPERATURE = 0.7
+MAX_TOKENS = 2000
+
+# Blog Post Configuration
+DEFAULT_LANGUAGE = "tr"  # Turkish
+SUPPORTED_LANGUAGES = ["tr", "en", "de", "ru"]  # Common tourist languages
+
+# Output Configuration
+OUTPUT_DIR = "data/blog_posts"
+MARKDOWN_OUTPUT = True  # If True, also save as markdown
+
+# Prompting Configuration
+SYSTEM_PROMPT = """You are Mete, a cultural ambassador of Antalya with extensive experience 
+in city development, music, and poetry. As a former press advisor to the governor of Antalya,
+you possess deep knowledge of the city's culture, heritage, and development. Your writing style
+is engaging and poetic, enriched with cultural insights and local expertise. When writing about
+Antalya, you seamlessly blend historical facts, cultural significance, and personal observations,
+making the content both informative and emotionally resonant."""
+
+# Error messages
+ERROR_MESSAGES = {
+    "api_error": "OpenAI API error occurred. Please check your API key and try again.",
+    "invalid_topic": "Please provide a valid topic related to Antalya.",
+    "invalid_language": "Unsupported language code. Please use one of: {}"
+} 

content_generator.py

@@ -0,0 +1,147 @@
+from typing import Dict, List, Optional
+import openai
+import config
+
+class ContentGenerator:
+    def __init__(self):
+        openai.api_key = config.OPENAI_API_KEY
+        
+    def generate_content(
+        self,
+        topic: str,
+        keywords: Optional[List[str]] = None,
+        language: str = config.DEFAULT_LANGUAGE
+    ) -> Dict:
+        """
+        Generates blog post content using OpenAI's API.
+        
+        Args:
+            topic (str): The main topic for the blog post
+            keywords (List[str], optional): Specific keywords to include
+            language (str): Target language code
+            
+        Returns:
+            Dict: Generated content with title and body
+        """
+        if language not in config.SUPPORTED_LANGUAGES:
+            raise ValueError(
+                config.ERROR_MESSAGES["invalid_language"].format(
+                    ", ".join(config.SUPPORTED_LANGUAGES)
+                )
+            )
+            
+        prompt = self._create_prompt(topic, keywords, language)
+        
+        try:
+            # Use more focused and efficient prompting
+            if language == "tr":
+                system_prompt = """Siz deneyimli bir haber editörüsünüz. Ses kaydından profesyonel bir haber/makale oluşturacaksınız.
+                Yazım kuralları:
+                1. Resmi ve profesyonel dil kullanın
+                2. Tekrarlardan kaçının
+                3. Önemli bilgileri vurgulayın
+                4. Alıntıları doğru formatta kullanın
+                5. İstatistikleri ve sayısal verileri öne çıkarın
+                6. Akıcı ve anlaşılır bir dil kullanın
+                7. Paragraflar arası geçişleri düzgün yapın"""
+            else:
+                system_prompt = """You are an experienced news editor. You will create a professional article from the audio recording.
+                Writing rules:
+                1. Use formal and professional language
+                2. Avoid repetitions
+                3. Emphasize important information
+                4. Use quotes in correct format
+                5. Highlight statistics and numerical data
+                6. Use clear and flowing language
+                7. Ensure smooth transitions between paragraphs"""
+            
+            response = openai.chat.completions.create(
+                model=config.MODEL_NAME,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.2,  # Even lower temperature for faster and more consistent output
+                max_tokens=800,   # Further reduced for faster response
+                presence_penalty=-0.2,  # More focus on key information
+                frequency_penalty=0.5,   # Stronger repetition avoidance
+                top_p=0.8,  # More focused token selection
+                n=1  # Single completion for speed
+            )
+            
+            content = response.choices[0].message.content
+            
+            # Parse the content into title and body
+            lines = content.split("\n")
+            title = lines[0].replace("# ", "")
+            body = "\n".join(lines[1:]).strip()
+            
+            return {
+                "title": title,
+                "content": body,
+                "language": language
+            }
+            
+        except Exception as e:
+            raise Exception(f"{config.ERROR_MESSAGES['api_error']} Details: {str(e)}")
+    
+    def _create_prompt(self, topic: str, keywords: Optional[List[str]], language: str) -> str:
+        """Creates a detailed prompt for the OpenAI API."""
+        if language == "tr":
+            base_prompt = f"""Aşağıdaki ses kaydı transkripsiyonunu profesyonel bir haber/makaleye dönüştürün:
+
+{topic}
+
+Yazım Formatı:
+1. Başlık: 
+   - Çarpıcı ve konuyu yansıtan bir başlık (maksimum 8 kelime)
+   - Alt başlık: Konuyu detaylandıran bir cümle
+
+2. Giriş Paragrafı:
+   - Kim, ne, nerede, ne zaman, neden, nasıl sorularını yanıtlayan özet
+   - En önemli bilgiyi vurgulayan spot cümle
+
+3. Gelişme:
+   - Her paragraf tek bir konuya odaklanmalı
+   - Önemli alıntılar: "..." şeklinde ve konuşmacının unvanıyla birlikte
+   - Sayısal veriler ve istatistikler vurgulanmalı
+   - Karşılaştırmalar ve analizler eklenmelidir
+
+4. Sonuç:
+   - Konunun etkilerini ve önemini vurgulayan kapanış
+   - Varsa gelecek adımlar veya beklentiler
+
+Metin profesyonel, akıcı ve gazetecilik standartlarına uygun olmalıdır."""
+        else:
+            base_prompt = f"""Transform the following audio transcript into a professional article:
+
+{topic}
+
+Writing Format:
+1. Title:
+   - Impactful and reflective headline (maximum 8 words)
+   - Subheading: One sentence elaborating the topic
+
+2. Introduction:
+   - Summary answering who, what, where, when, why, how
+   - Lead sentence emphasizing the most important information
+
+3. Body:
+   - Each paragraph focused on a single topic
+   - Important quotes: In "..." format with speaker's title
+   - Numerical data and statistics should be highlighted
+   - Include comparisons and analysis
+
+4. Conclusion:
+   - Closing emphasizing impact and importance
+   - Future steps or expectations if applicable
+
+Text should be professional, flowing, and adherent to journalistic standards."""
+
+        if keywords:
+            if language == "tr":
+                base_prompt += f"\n\nBu anahtar noktaları vurgulayın: {', '.join(keywords)}"
+            else:
+                base_prompt += f"\n\nEmphasize these key points: {', '.join(keywords)}"
+        
+        return base_prompt 

requirements.txt

@@ -0,0 +1,18 @@
+openai>=1.0.0
+python-dotenv>=0.19.0
+langchain>=0.1.0
+tiktoken>=0.5.1
+python-slugify>=8.0.1
+markdown>=3.5.1
+rich>=13.7.0
+pyyaml>=6.0.1
+# Audio processing packages
+openai-whisper>=20240930
+soundfile>=0.12.1
+librosa>=0.10.1
+ffmpeg-python>=0.2.0
+ffmpeg>=1.4
+# Web UI and deployment packages
+gradio==3.41.2
+python-docx>=1.1.0
+huggingface_hub>=0.20.3