# Importation des bibliotheques necessaires
import openai
import json
import pickle
import sys
import nltk
import spacy
import os
from PySide2 import QtWidgets, QtCore
from PySide2.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QProgressBar, QLabel, QPushButton, QLineEdit, QFileDialog, QMessageBox
from PySide2.QtCore import Qt
from PySide2.QtGui import QTextCursor
from transformers import pipeline,GPT2LMHeadModel, GPT2Tokenizer
from abc import ABC, abstractmethod
from docx import Document
from nltk.corpus import stopwords
from typing import List
class BookModel():
"""
Classe abstraite representant le modele du livre.
"""
def generate_title(self, prompt):
try:
generator = pipeline('text-generation', model=self.gpt_model)
titles = generator(prompt, max_length=50, num_return_sequences=10)
self.title = titles[0]['generated_text'].strip()
# Les titres générés doivent être filtrés et formatés pour correspondre aux exigences d'un titre de livre.
self.title = [self.format_title(title) for title in titles]
# Les titres générés doivent être filtrés et formatés pour correspondre aux exigences d'un titre de livre.
return self.title
except Exception as e:
print(f"Une erreur est survenue lors de la génération du titre : {e}")
return ""
def generate_subtitle(self, title: str) -> str:
"""
Génère un sous-titre basé sur un titre donné.
"""
try:
generator = pipeline('text-generation', model=self.gpt_model)
subtitles = generator(title, max_length=50, num_return_sequences=10)
self.subtitle = subtitles[0]['generated_text'].strip()
return self.subtitle
except Exception as e:
print(f"Une erreur est survenue lors de la génération du sous-titre : {e}")
return ""
def generate_summary(self, title: str, subtitle: str) -> str:
"""
Génère un résumé basé sur un titre et un sous-titre donnés.
"""
generator = pipeline('text-generation', model=self.gpt_model)
summaries = generator(f"{title} {subtitle}", max_length=500, num_return_sequences=1)
return [summary['generated_text'].strip() for summary in summaries]
def generate_content(self, summary: str) -> List[str]:
"""
Génère le contenu du livre basé sur un résumé donné.
"""
generator = pipeline('text-generation', model=self.gpt_model)
content = generator(summary, max_length=2000, num_return_sequences=5)
return [c['generated_text'].strip() for c in content]
def generate_book(self, prompt: str):
"""
Génère le livre complet.
"""
try:
self.generate_title(prompt)
self.generate_subtitle(self.title)
self.generate_summary(self.title, self.subtitle)
self.generate_content(self.summary)
return {
'title': self.title,
'subtitle': self.subtitle,
'summary': self.summary,
'content': self.content
}
except Exception as e:
print(f"Une erreur est survenue lors de la génération du livre : {e}")
return {}
class Book(BookModel):
"""
Classe représentant le livre.
"""
def __init__(self, gpt_model):
super().__init__(gpt_model)
self.gpt_model = gpt_model
self.title = ""
self.subtitle = ""
self.summary = []
self.content = []
def to_text(self):
# Convertir l'objet livre en une représentation textuelle
book_text = f"Title: {self.title}\n"
book_text += f"Subtitle: {self.subtitle}\n"
book_text += f"Summary: {self.summary}\n"
book_text += "Content:\n"
book_text += "\n".join(self.content)
return book_text
def from_text(self, book_text):
# Convertir la représentation du texte en un objet livre
lines = book_text.split("\n")
self.title = lines[0].replace("Title: ", "")
self.subtitle = lines[1].replace("Subtitle: ", "")
self.summary = lines[2].replace("Summary: ", "")
self.content = lines[4:]
def generate_book(self, prompt):
"""
Méthode pour générer le livre complet.
"""
self.generate_title(prompt)
self.generate_subtitle(self.title)
self.generate_summary(self.title, self.subtitle)
self.generate_content(self.summary)
# Générer le contenu du livre en fonction du sommaire.
return {
'title': self.title,
'subtitle': self.subtitle,
'summary': self.summary,
to save space. For full conversation, see full text option.DISCUSSION_AJAX)})
self.sub_title_input = QtWidgets.QLineEdit(self.centralwidget)
self.sub_title_input.setGeometry(QtCore.QRect(100, 180, 113, 22))
self.sub_title_input.setObjectName(_fromUtf8("sub_title_input"))
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(140, 210, 113, 32))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
self.label.setText(_translate("MainWindow", "Title", None))
self.label_2.setText(_translate("MainWindow", "Sub Title", None))
self.pushButton.setText(_translate("MainWindow", "Generate", None))
# Générateur de titre et de sous-titre
class TitleGenerator:
def __init__(self, model: str = 'gpt-3', temperature: float = 0.8, max_tokens: int = 60):
self.model = model
self.temperature = temperature
self.max_tokens = max_tokens
def generate_title(self, theme: str) -> str:
"""
Génère un titre basé sur un thème donné.
"""
prompt = f"Créer un titre de livre intéressant sur le thème : {theme}."
response = openai.Completion.create(
model=self.model,
prompt=prompt,
temperature=self.temperature,
max_tokens=self.max_tokens
)
return response.choices[0].text.strip()
def generate_sub_title(self, title: str) -> str:
"""
Génère un sous-titre basé sur un titre donné.
"""
prompt = f"Créer un sous-titre pour le livre intitulé : {title}."
response = openai.Completion.create(
model=self.model,
prompt=prompt,
temperature=self.temperature,
max_tokens=self.max_tokens
)
return response.choices[0].text.strip()
class BookModel:
def __init__(self, gpt_model):
self.gpt_model = gpt_model
self.title = ""
self.subtitle = ""
self.summary = ""
self.content = []
def generate_title(self, prompt):
generator = pipeline('text-generation', model=self.gpt_model)
titles = generator(prompt, max_length=50, num_return_sequences=10)
self.title = titles[0]['generated_text'].strip()
return self.title
def set_title(self, theme: str):
self.title = self.title_gen.generate_title(theme)
def set_sub_title(self):
self.sub_title = self.title_gen.generate_sub_title(self.title)
def get_title(self):
return self.title
def get_sub_title(self):
return self.sub_title
# À partir d'ici, il faudrait développer davantage pour implémenter les autres modules et fonctionnalités, comme le générateur de sommaire, le générateur de contenu, etc.
class ContentGenerator:
def __init__(self, model_name: str = 'gpt-3', temperature: float = 0.8, max_length: int = 1024):
self.model_name = model_name
self.temperature = temperature
self.max_length = max_length
self.tokenizer = GPT2Tokenizer.from_pretrained(self.model_name)
self.model = GPT2LMHeadModel.from_pretrained(self.model_name)
def generate_content(self, summary: str) -> str:
"""
Génère un contenu basé sur un résumé donné.
"""
inputs = self.tokenizer.encode(summary, return_tensors='pt')
outputs = self.model.generate(inputs, max_length=self.max_length, temperature=self.temperature, do_sample=True)
return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
class SummaryGenerator:
def __init__(self, model_name: str = 'gpt-3', temperature: float = 0.8, max_length: int = 150):
self.model_name = model_name
self.temperature = temperature
self.max_length = max_length
self.tokenizer = GPT2Tokenizer.from_pretrained(self.model_name)
self.model = GPT2LMHeadModel.from_pretrained(self.model_name)
def generate_summary(self, title: str, sub_title: str) -> str:
"""
Génère un résumé basé sur un titre et un sous-titre donnés.
"""
inputs = self.tokenizer.encode(f"{title} {sub_title}", return_tensors='pt')
outputs = self.model.generate(inputs, max_length=self.max_length, temperature=self.temperature, do_sample=True)
return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
class BookModel:
def __init__(self, title_gen: TitleGenerator, summary_gen: SummaryGenerator, content_gen: ContentGenerator):
self.title_gen = title_gen
self.summary_gen = summary_gen
self.content_gen = content_gen
self.title = ""
self.sub_title = ""
self.summary = ""
self.content = ""
def set_title(self, theme: str):
try:
self.title = self.title_gen.generate_title(theme)
except Exception as e:
print(f"Une erreur est survenue lors de la génération du titre : {e}")
def set_sub_title(self):
try:
self.sub_title = self.title_gen.generate_sub_title(self.title)
except Exception as e:
print(f"Une erreur est survenue lors de la génération du sous-titre : {e}")
def set_summary(self):
try:
self.summary = self.summary_gen.generate_summary(self.title, self.sub_title)
except Exception as e:
print(f"Une erreur est survenue lors de la génération du résumé : {e}")
def set_content(self):
try:
self.content = self.content_gen.generate_content(self.summary)
except Exception as e:
print(f"Une erreur est survenue lors de la génération du contenu : {e}")
def get_title(self):
return self.title
def get_sub_title(self):
return self.sub_title
def get_summary(self):
return self.summary
def get_content(self):
return self.content
# Définissez la clé API OpenAI
openai.api_key = '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'
# Méthode pour générer du contenu
def generate_content_from_openai(prompt: str):
cache_file = f'cache/{prompt}.pkl'
# Vérifiez si le résultat est dans le cache
if os.path.exists(cache_file):
with open(cache_file, 'rb') as file:
return pickle.load(file)
# Sinon, générer le contenu en utilisant l'API OpenAI
response = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=150
)
content = response.choices[0].text.strip()
# Enregistrez le résultat dans le cache
with open(cache_file, 'wb') as file:
pickle.dump(content, file)
return content
class ConfigManager:
def __init__(self, config_file):
with open(config_file, 'r') as f:
self.config = json.load(f)
def get_openai_key(self):
return self.config.get('openai_key', '')
class TranslationManager:
def __init__(self, config_manager):
self.config_manager = config_manager
openai.api_key = self.config_manager.get_openai_key()
def translate(self, text, from_lang, to_lang):
# Ici vous pouvez utiliser l'API OpenAI pour la traduction.
# C'est juste un exemple, la fonctionnalité réelle peut être différente.
translated_text = openai.Translation.create(
engine="text-davinci-002",
text=text,
from_lang=from_lang,
to_lang=to_lang,
)
return translated_text
# Veuillez noter que le code ci-dessus est un exemple simplifié et qu'il ne comprend pas toutes les fonctionnalités requises par votre spécification. Il s'agit plutôt d'un point de départ à partir duquel vous pouvez continuer à développer votre projet.
class UI(QMainWindow):
def __init__(self):
super(UI, self).__init__()
self.setWindowTitle("Générateur de Livre Automatique")
# Progress Bar
self.progress = QProgressBar()
self.progress.setMinimum(0)
self.progress.setMaximum(100)
# Status label
self.status = QLabel()
# Start button
self.start_button = QPushButton('Commencer la génération du livre')
self.start_button.clicked.connect(self.start_book_generation)
# Layouts
self.main_widget = QWidget()
self.setCentralWidget(self.main_widget)
self.layout = QVBoxLayout()
self.main_widget.setLayout(self.layout)
# Add widgets to layout
self.layout.addWidget(self.progress)
self.layout.addWidget(self.status)
self.layout.addWidget(self.start_button)
def start_book_generation(self):
# Start the book generation process
self.status.setText("Génération en cours...")
# Créez une instance de la classe BookModel avec le modèle GPT choisi
model_choice = self.gpt_model_choice.currentText()
gpt_model = 'gpt-3' if model_choice == 'GPT-3' else 'gpt-3.5-turbo'
book_model = BookModel(gpt_model)
# Obtenez le thème du livre à partir de l'entrée utilisateur
prompt = self.prompt_input.text()
# Générez le livre en utilisant le modèle BookModel
book = book_model.generate_book(prompt)
# Affichez le sommaire du livre généré
self.book_summary_field.setText('\n'.join(book['summary']))
# Enregistrez le livre généré dans un fichier
self.save_book(book)
# Mise à jour de la barre de progression et du statut
self.update_progress(100)
self.update_status("Génération terminée.")
def update_progress(self, value):
# Update the progress bar
self.progress.setValue(value)
def update_status(self, message):
# Update the status message
self.status.setText(message)
def save_book(self, book):
doc = Document()
doc.add_heading(book['title'], level=1)
doc.add_heading(book['subtitle'], level=2)
for section_content in book['content']:
doc.add_paragraph(section_content)
doc.save("book.docx")
def load_work(self):
doc_file = "book.docx"
if os.path.exists(doc_file):
doc = Document(doc_file)
book_content = ""
for paragraph in doc.paragraphs:
book_content += paragraph.text + "\n"
self.book_summary_field.setText(book_content)
self.update_status("Travail chargé avec succès.")
else:
self.update_status("Aucun travail précédemment enregistré.")
def translate_book(self):
# Obtenez le texte du livre à partir de la zone de texte
book_content = self.book_summary_field.toPlainText()
# Obtenez la langue sélectionnée
language_choice = self.language_choice.currentText()
# Créez une instance de la classe TranslationManager
translation_manager = TranslationManager()
# Traduisez le livre dans la langue sélectionnée
translated_text = translation_manager.translate(book_content, 'en', language_choice)
# Affichez le texte traduit dans la zone de texte
self.book_summary_field.setText(translated_text)
self.update_status("Traduction terminée.")
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("Générateur de livres basé sur GPT")
# Créez l'interface utilisateur en utilisant QVBoxLayout
layout = QVBoxLayout()
# Champs d'entrée de texte pour le thème du livre et le choix du modèle GPT
self.prompt_input = QLineEdit()
self.prompt_input.setPlaceholderText("Entrez votre thème ici...")
layout.addWidget(self.prompt_input)
self.gpt_model_choice = QComboBox()
self.gpt_model_choice.addItems(["GPT-3", "GPT-3.5-turbo"])
layout.addWidget(self.gpt_model_choice)
# Bouton de démarrage de la génération du livre
self.generate_button = QPushButton("Générer le livre")
self.generate_button.clicked.connect(self.start_generation)
layout.addWidget(self.generate_button)
# Barre de progression pour afficher l'avancement de la génération du livre
self.progress_bar = QProgressBar()
layout.addWidget(self.progress_bar)
# Barre de statut pour afficher les messages d'état en temps réel
self.status_bar = QLabel()
layout.addWidget(self.status_bar)
# Champ de texte pour afficher la clé API
self.api_key_field = QLineEdit()
self.api_key_field.setEchoMode(QLineEdit.Password)
layout.addWidget(self.api_key_field)
# Zone de texte pour afficher le sommaire du livre généré
self.book_summary_field = QTextEdit()
layout.addWidget(self.book_summary_field)
# Bouton pour sauvegarder le travail
self.save_button = QPushButton("Sauvegarder")
self.save_button.clicked.connect(self.save_work)
layout.addWidget(self.save_button)
# Bouton pour charger le travail
self.load_button = QPushButton("Charger")
self.load_button.clicked.connect(self.load_work)
layout.addWidget(self.load_button)
# Champ de sélection de langue pour la traduction du livre
self.language_choice = QComboBox()
self.language_choice.addItems(["Anglais", "Français", "Espagnol", "Allemand"])
layout.addWidget(self.language_choice)
# Bouton pour traduire le livre
self.translate_button = QPushButton("Traduire le livre")
self.translate_button.clicked.connect(self.translate_book)
layout.addWidget(self.translate_button)
# Configurez le widget principal pour utiliser le layout
main_widget = QWidget()
main_widget.setLayout(layout)
self.setCentralWidget(main_widget)
@Slot()
def start_generation(self):
# Lancer le processus de création de livres
self.status.setText("Génération en cours...")
# Créer une instance de la classe BookModel avec le modèle GPT choisi
model_choice = self.gpt_model_choice.currentText()
gpt_model = 'gpt-3' if model_choice == 'GPT-3' else 'gpt-3.5-turbo'
book_model = BookModel(gpt_model)
# Obtenir le thème du livre à partir des données de l'utilisateur
prompt = self.prompt_input.text()
# Générer le livre à l'aide du modèle BookModel
book = book_model.generate_book(prompt)
# Afficher le résumé du livre généré.
@Slot()
def save_work(self):
# Enregistrer le livre généré dans un fichier
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix(".txt")
file_path, _ = file_dialog.getSaveFileName(self, "Enregistrer le livre", "", "Fichiers texte (*.txt)")
if file_path:
try:
with open(file_path, 'w', encoding='utf-8') as file:
book_text = self.book.to_text()
file.write(book_text)
QMessageBox.information(self, "Enregistrement terminé", "Le livre a été enregistré avec succès.")
except Exception as e:
QMessageBox.critical(self, "Erreur d'enregistrement", f"Une erreur s'est produite lors de l'enregistrement du livre : {str(e)}")
@Slot()
def load_work(self):
# Charger un livre précédemment généré à partir d'un fichier
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix(".txt")
file_path, _ = file_dialog.getOpenFileName(self, "Charger le livre", "", "Fichiers texte (*.txt)")
if file_path:
try:
with open(file_path, 'r', encoding='utf-8') as file:
book_text = file.read()
self.book.from_text(book_text)
QMessageBox.information(self, "Chargement terminé", "Le livre a été chargé avec succès.")
except Exception as e:
QMessageBox.critical(self, "Erreur de chargement", f"Une erreur s'est produite lors du chargement du livre : {str(e)}")
@Slot()
def translate_book(self):
# Traduire le livre généré dans une autre langue
target_language = self.translation_language_choice.currentText()
if target_language:
try:
translator = Translator()
translated_book = translator.translate_book(self.book, target_language)
self.translated_book = translated_book
QMessageBox.information(self, "Traduction terminée", "Le livre a été traduit avec succès.")
except Exception as e:
QMessageBox.critical(self, "Erreur de traduction", f"Une erreur s'est produite lors de la traduction du livre : {str(e)}")
else:
QMessageBox.warning(self, "Langue cible non spécifiée", "Veuillez sélectionner une langue cible pour la traduction.")
class Visual:
def __init__(self):
self.doc = Document()
def create_new_doc(self, doc_name):
"""Créer un nouveau document Word"""
self.doc.save(doc_name)
def add_title(self, title, level):
"""Ajouter un titre au document"""
self.doc.add_heading(title, level)
def add_paragraph(self, text):
"""Ajouter un paragraphe au document"""
self.doc.add_paragraph(text)
def save_doc(self, doc_name):
"""Sauvegarder le document Word"""
self.doc.save(doc_name)
class StyleSelector:
def __init__(self, visual):
self.visual = visual
def select_style(self, style_name):
"""Sélectionner le style du document"""
# Vous pouvez ajouter ici une logique pour changer le style en fonction du nom du style donné
pass
class BookFormatter:
def __init__(self, visual):
self.visual = visual
def format_book(self, book_content):
"""Formater le livre selon le style sélectionné"""
# Ici, vous pouvez ajouter la logique pour formater le contenu du livre en utilisant les méthodes de la classe Visual
pass
class CacheManager:
def __init__(self, cache_file='cache.pkl'):
self.cache_file = cache_file
# Charger le cache s'il existe déjà, sinon initialiser un cache vide
if os.path.exists(cache_file):
with open(cache_file, 'rb') as f:
self.cache = pickle.load(f)
else:
self.cache = {}
def get(self, key):
return self.cache.get(key, None)
def set(self, key, value):
self.cache[key] = value
# Enregistrement automatique après chaque ajout pour assurer la persistance
with open(self.cache_file, 'wb') as f:
pickle.dump(self.cache, f)
def clear(self):
self.cache = {}
os.remove(self.cache_file)
class TextUtils:
def __init__(self):
nltk.download('punkt')
nltk.download('stopwords')
self.nlp = spacy.load('en_core_web_sm')
self.stop_words = set(stopwords.words('english'))
def extract_sentences(self, text):
return nltk.sent_tokenize(text)
def extract_named_entities(self, text):
doc = self.nlp(text)
return [(ent.text, ent.label_) for ent in doc.ents]
def remove_stopwords(self, text):
words = nltk.word_tokenize(text)
words_without_stopwords = [word for word in words if word not in self.stop_words]
return ' '.join(words_without_stopwords)
class APIKeyManager:
def __init__(self, api_key_file='api_key.json'):
self.api_key_file = api_key_file
if os.path.exists(api_key_file):
with open(api_key_file, 'r') as f:
self.api_key = json.load(f)["api_key"]
else:
self.api_key = None
def get(self):
return self.api_key
def set(self, api_key):
with open(self.api_key_file, 'w') as f:
json.dump({"api_key": api_key}, f)
self.api_key = api_key
class ConfigManager:
def __init__(self, config_file='config.json'):
self.config_file = config_file
if os.path.exists(config_file):
with open(config_file, 'r') as f:
self.config = json.load(f)
else:
self.config = {}
def get(self, key):
return self.config.get(key, None)
def set(self, key, value):
self.config[key] = value
with open(self.config_file, 'w') as f:
json.dump(self.config, f)
def clear(self):
self.config = {}
os.remove(self.config_file)
# Use the classes
book = Book('gpt-3')
book.generate_title("An adventure novel")
if __name__ == "__main__":
app = QApplication([])
ui = UI()
ui.show()
sys.exit(app.exec_())
Votre Panier
Pour plus de renseignement contacter nous au 07 56 81 16 16
Menu
Menu
© Copyright kingscanape.com