Create app.py

app.py

@@ -0,0 +1,292 @@
+import streamlit as st
+import os
+import time
+import logging
+import tempfile
+from pptx import Presentation
+from pptx.util import Inches
+from pptx.dml.color import RGBColor
+from pptx.enum.text import PP_ALIGN
+import openai
+import requests
+from requests.exceptions import RequestException
+import base64
+
+# Konfiguracja logowania
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Funkcja do usuwania formatowania Markdown
+def remove_markdown_formatting(text):
+    return text.replace('**', '').replace('#', '').strip()
+
+# Funkcja do podziału tekstu na moduły (slajdy)
+def split_into_modules(content):
+    modules = content.split('####')
+    modules = [module.strip() for module in modules if module.strip()]
+    
+    # Logowanie modułów do debugowania
+    for i, module in enumerate(modules):
+        logger.info(f"Moduł {i + 1}: {module[:100]}...")  # Logowanie pierwszych 100 znaków modułu
+
+    return modules
+
+# Funkcja do tworzenia prezentacji z modułów
+def create_ppt_from_modules(modules, output_file, aspect_ratio="16:9"):
+    prs = Presentation()
+    
+    # Ustawienie formatu slajdów
+    if aspect_ratio == "4:3":
+        prs.slide_width = Inches(10)
+        prs.slide_height = Inches(7.5)
+    else:  # 16:9
+        prs.slide_width = Inches(13.33)
+        prs.slide_height = Inches(7.5)
+
+    for module in modules:
+        try:
+            slide = prs.slides.add_slide(prs.slide_layouts[1])
+            title, *body = module.split('\n', 1)
+
+            # Formatowanie tytułu slajdu
+            title_shape = slide.shapes.title
+            title_shape.text = remove_markdown_formatting(title)
+            title_paragraph = title_shape.text_frame.paragraphs[0]
+            title_paragraph.font.size = Inches(0.5)  # Rozmiar tytułu
+            title_paragraph.font.name = 'Helvetica'
+            title_paragraph.alignment = PP_ALIGN.LEFT
+
+            # Formatowanie treści slajdu
+            if body:
+                content = remove_markdown_formatting(body[0].strip())
+                text_frame = slide.placeholders[1].text_frame
+                text_frame.text = content
+
+                for paragraph in text_frame.paragraphs:
+                    if paragraph.text.strip():  # Sprawdź, czy akapit ma tekst
+                        paragraph.font.size = Inches(0.25)  # Rozmiar tekstu
+                        paragraph.font.name = 'Helvetica'
+                        paragraph.alignment = PP_ALIGN.LEFT
+                    else:
+                        logger.warning(f"Pusty akapit w module: {title}")
+            else:
+                logger.warning(f"Brak treści w module: {title}")
+
+        except Exception as e:
+            logger.error(f"Błąd podczas przetwarzania modułu: {module}. Błąd: {e}")
+            st.error(f"Błąd podczas przetwarzania modułu: {module}. Błąd: {e}")
+
+    prs.save(output_file)
+    logger.info(f"Prezentacja została zapisana jako {output_file}")
+
+# Funkcja do generowania treści prezentacji za pomocą OpenAI
+def generate_presentation_content_openai(prompt, api_key, progress_bar, progress_text):
+    try:
+        client = openai.OpenAI(api_key=api_key)
+        
+        # Ustaw streamowanie dla postępu
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[
+                {"role": "system", "content": "Jesteś ekspertem w tworzeniu prezentacji. Twórz treść prezentacji w formacie, gdzie każdy slajd zaczyna się od '#### [Tytuł slajdu]' a następnie zawiera treść slajdu. Używaj języka polskiego."},
+                {"role": "user", "content": prompt}
+            ],
+            stream=True,
+            max_tokens=4000
+        )
+        
+        # Aktualizacja paska postępu i wyświetlanie generowanej treści
+        full_content = ""
+        for chunk in response:
+            if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
+                content_chunk = chunk.choices[0].delta.content
+                full_content += content_chunk
+                progress_text.markdown(full_content)
+                time.sleep(0.01)
+                # Symulacja postępu - nie możemy dokładnie wiedzieć ile tekstu jeszcze zostanie wygenerowane
+                progress_bar.progress(min(len(full_content) / 3000, 1.0))
+        
+        progress_bar.progress(1.0)
+        return full_content
+        
+    except Exception as e:
+        logger.error(f"Błąd podczas generowania treści przez OpenAI: {e}")
+        st.error(f"Błąd podczas generowania treści przez OpenAI: {e}")
+        return None
+
+# Funkcja do generowania treści prezentacji za pomocą DeepSeek
+def generate_presentation_content_deepseek(prompt, api_key, progress_bar, progress_text):
+    try:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+        
+        data = {
+            "model": "deepseek-chat",
+            "messages": [
+                {"role": "system", "content": "Jesteś ekspertem w tworzeniu prezentacji. Twórz treść prezentacji w formacie, gdzie każdy slajd zaczyna się od '#### [Tytuł slajdu]' a następnie zawiera treść slajdu. Używaj języka polskiego."},
+                {"role": "user", "content": prompt}
+            ],
+            "stream": True,
+            "max_tokens": 4000
+        }
+        
+        # Wykonanie żądania ze streamowaniem
+        response = requests.post(
+            "https://api.deepseek.com/chat/completions",
+            json=data,
+            headers=headers,
+            stream=True
+        )
+        
+        if response.status_code != 200:
+            logger.error(f"Błąd DeepSeek API: {response.status_code} - {response.text}")
+            st.error(f"Błąd DeepSeek API: {response.status_code} - {response.text}")
+            return None
+            
+        # Przetwarzanie streamowanej odpowiedzi
+        full_content = ""
+        for line in response.iter_lines():
+            if line:
+                line = line.decode('utf-8')
+                if line.startswith("data:") and not line.startswith("data: [DONE]"):
+                    try:
+                        json_str = line[5:].strip()
+                        if json_str:
+                            import json
+                            data = json.loads(json_str)
+                            if "choices" in data and len(data["choices"]) > 0:
+                                choice = data["choices"][0]
+                                if "delta" in choice and "content" in choice["delta"] and choice["delta"]["content"]:
+                                    content_chunk = choice["delta"]["content"]
+                                    full_content += content_chunk
+                                    progress_text.markdown(full_content)
+                                    # Symulacja postępu
+                                    progress_bar.progress(min(len(full_content) / 3000, 1.0))
+                    except Exception as e:
+                        logger.error(f"Błąd podczas parsowania odpowiedzi DeepSeek: {e}")
+        
+        progress_bar.progress(1.0)
+        return full_content
+        
+    except RequestException as e:
+        logger.error(f"Błąd połączenia z DeepSeek API: {e}")
+        st.error(f"Błąd połączenia z DeepSeek API: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Błąd podczas generowania treści przez DeepSeek: {e}")
+        st.error(f"Błąd podczas generowania treści przez DeepSeek: {e}")
+        return None
+
+# Funkcja do pobierania pliku
+def get_binary_file_downloader_html(file_path, file_label='File'):
+    with open(file_path, 'rb') as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode()
+    href = f'<a href="data:application/vnd.openxmlformats-officedocument.presentationml.presentation;base64,{b64}" download="{os.path.basename(file_path)}" class="download-button">📥 Pobierz prezentację PowerPoint</a>'
+    return href
+
+# Główna funkcja aplikacji Streamlit
+def main():
+    st.set_page_config(page_title="Generator Prezentacji LLM", layout="wide")
+    
+    st.title("🎯 Generator Prezentacji LLM")
+    st.write("Ta aplikacja generuje prezentacje PowerPoint na dowolny temat za pomocą sztucznej inteligencji.")
+    
+    # Wybór modelu
+    model = st.selectbox(
+        "Wybierz model LLM:",
+        ["GPT-4o", "DeepSeek"]
+    )
+    
+    # Wybór formatu prezentacji
+    aspect_ratio = st.selectbox(
+        "Wybierz format prezentacji:",
+        ["16:9", "4:3"]
+    )
+    
+    # Wprowadzenie klucza API
+    api_key = st.text_input("Wprowadź klucz API", type="password", help="Twój klucz API do wybranego modelu")
+    
+    # Wprowadzenie tematu prezentacji
+    topic = st.text_area("Wprowadź temat prezentacji lub szczegółowe instrukcje:", height=150)
+    
+    # Tworzenie tymczasowego katalogu na pliki
+    temp_dir = tempfile.mkdtemp()
+    output_file = os.path.join(temp_dir, "prezentacja.pptx")
+    
+    if st.button("Generuj Prezentację", type="primary"):
+        if not api_key:
+            st.error("Proszę wprowadzić klucz API.")
+            return
+            
+        if not topic:
+            st.error("Proszę wprowadzić temat prezentacji.")
+            return
+            
+        # Przygotowanie promptu
+        prompt = f"""
+        Stwórz prezentację na temat: "{topic}".
+        
+        Każdy slajd powinien zaczynać się od #### [Tytuł slajdu]
+        Po tytule powinien być umieszczony tekst slajdu.
+        
+        Stwórz od 5 do 10 slajdów, które będą zawierać kompleksowe informacje o podanym temacie.
+        Rozpocznij od slajdu tytułowego, a zakończ slajdem podsumowującym.
+        """
+        
+        st.write("### Generowanie treści prezentacji...")
+        
+        # Pasek postępu i miejsce na wyświetlanie generowanego tekstu
+        progress_bar = st.progress(0)
+        progress_text = st.empty()
+        
+        # Generowanie treści prezentacji w zależności od wybranego modelu
+        if model == "GPT-4o":
+            content = generate_presentation_content_openai(prompt, api_key, progress_bar, progress_text)
+        else:  # DeepSeek
+            content = generate_presentation_content_deepseek(prompt, api_key, progress_bar, progress_text)
+            
+        if content:
+            st.success("✅ Treść prezentacji została wygenerowana!")
+            
+            # Podział na moduły (slajdy)
+            st.write("### Przetwarzanie slajdów...")
+            modules = split_into_modules(content)
+            st.info(f"Liczba wygenerowanych slajdów: {len(modules)}")
+            
+            # Tworzenie prezentacji PowerPoint
+            with st.spinner("Tworzenie pliku PowerPoint..."):
+                create_ppt_from_modules(modules, output_file, aspect_ratio)
+            
+            st.success(f"✅ Prezentacja PowerPoint została utworzona!")
+            
+            # Przycisk do pobrania prezentacji
+            st.markdown(get_binary_file_downloader_html(output_file), unsafe_allow_html=True)
+            
+            # Wyświetl treść wygenerowanej prezentacji
+            with st.expander("Zobacz wygenerowaną treść prezentacji"):
+                st.write(content)
+        else:
+            st.error("❌ Nie udało się wygenerować treści prezentacji. Sprawdź logi i klucz API.")
+    
+    # Dodaj informacje o aplikacji
+    st.markdown("---")
+    st.markdown("### 📝 Informacje o aplikacji")
+    st.markdown("""
+    - Aplikacja używa AI do generowania treści prezentacji.
+    - Format wyjściowy: PowerPoint (.pptx).
+    - Wspierane modele: GPT-4o (OpenAI) i DeepSeek.
+    - Prezentacja będzie zawierać od 5 do 10 slajdów z kompleksowymi informacjami.
+    """)
+    
+    # Dodaj informacje o użyciu API
+    st.markdown("### 🔑 Informacje o użyciu API")
+    st.markdown("""
+    - Dla GPT-4o: Użyj klucza API OpenAI ze swojego konta (format: sk-...).
+    - Dla DeepSeek: Użyj klucza API DeepSeek ze swojego konta.
+    - Twój klucz API jest używany tylko do generowania treści i nie jest nigdzie przechowywany.
+    """)
+
+if __name__ ==