"""
title: Outil de génération d'éléments de récit
description: Générer un large éventail d'éléments d'histoires, depuis les composants individuels jusqu'aux plans d'histoires complets.
author: @monsieurformodable adapté de @iamg30
author_url: https://openwebui.com/u/monsieurformidable/
funding_url: https://github.com/open-webui
version: 0.1.1
license: MIT
"""
import random
import json
from pydantic import BaseModel, Field
from typing import List, Dict, Optional
class Tools:
class Valves(BaseModel):
CHARACTER_TRAITS: List[str] = Field(
default=[
"courageux",
"timide",
"intelligent",
"maladroit",
"charismatique",
"mystérieux",
"loyal",
"ambitieux",
"compatissant",
"arrogant",
"créatif",
"patient",
"excentrique",
"pessimiste",
"optimiste",
"sarcastique",
"déterminé",
"naïf",
"sage",
"impulsif",
"méthodique",
"excentrique",
"stoïque",
"flamboyant", ],
description="Liste des traits de caractère",
)
OCCUPATIONS: List[str] = Field(
default=[
"critique gastronomique",
"écrivain",
"activiste",
"acteur",
"enseignant",
"entrepreneur",
"chanteur",
"enseignant",
"détective",
"chef",
"astronaute",
"artiste",
"médecin",
"agriculteur",
"bibliothécaire",
"scientifique",
"athlète",
"musicien",
"entrepreneur",
"espion",
"archéologue",
"pilote",
"hacker",
"diplomate",
"magicien",
"journaliste",
"chasseur de primes",
"inventeur",
"biologiste marin",
"cascadeur",
"cryptozoologue", ],
description="Liste des professions",
)
SETTINGS: List[str] = Field(
default=[
"Maspalomas, Espagne",
"Istanbul, Turquie",
"Berlin, Allemagne",
"Paris, France",
"Amsterdam, Pays-Bas",
"Londres, Royaume-Unis",
"château médiéval",
"île tropicale",
"plage",
"ruines anciennes",
"marché animé",
"village tranquille",
"campagne, forêt",
"monde de réalité virtuelle", ],
description="Liste des décors d'histoires",
)
PLOT_ELEMENTS: List[str] = Field(
default=[
"héritage inattendu",
"disparition mystérieuse",
"accident de voyage dans le temps",
"invasion extraterrestre",
"romance interdite",
"trésor caché",
"quête épique",
"intrigue politique",
"transformation magique",
"catastrophe naturelle",
"rébellion de l'intelligence artificielle",
"découverte d'un univers parallèle",
"accomplissement d'une ancienne prophétie",
"conspiration de manipulation de la mémoire",
"réveil d'une capacité surnaturelle",
"crise diplomatique inter-espèces",
"expérience de modification de la réalité",
"rencontre avec une entité cosmique",
"résurrection d'un personnage historique",
"exploration d'une planète sensible",
],
description="Liste des éléments de l'intrigue",
)
GENRES: List[str] = Field(
default=[
"réalisme",
"autobiographie",
"érotique",
"pornographique",
"science-fiction",
"fantasy",
"mystère",
"romance",
"thriller",
"horreur",
"aventure",
"fiction historique",
"dystopique",
"comédie",
"drame",
"action",
"réalisme magique",
"cyberpunk",
"steampunk",
"surnaturel",
"psychologique",
"crime",
"post-apocalyptique",
"histoire alternative",
],
description="List of story genres",
)
THEMES: List[str] = Field(
default=[
"rédemption",
"arrivée à l'âge adulte",
"le pouvoir corrompt",
"l'amour vainc tout",
"L'homme contre la nature",
"la technologie qui a mal tourné",
"crise d'identité",
"le bien contre le mal",
"le sacrifice pour le bien commun",
"la condition humaine",
"ambiguïté morale",
"le cycle de la violence",
"triomphe sur l'adversité",
"la perte de l'innocence",
"la beauté dans l'imperfection",
"conséquences de l'ambition",
"illusion contre réalité",
"le pouvoir de l'amitié",
"nature de la conscience",
"l'impact des choix",
"la pasion sexuelle",
],
description=« Liste « des thèmes d’histoires,
)
def __init__(self):
self.valves = self.Valves()
def generate_character(self, trait_count: int = 2) -> str:
"""
Generate a character with random traits and occupation.
:param trait_count: Number of traits to assign to the character.
:return: A JSON string containing character details.
"""
traits = random.sample(
self.valves.CHARACTER_TRAITS,
min(trait_count, len(self.valves.CHARACTER_TRAITS)),
)
occupation = random.choice(self.valves.OCCUPATIONS)
character = {"traits": traits, "occupation": occupation}
return json.dumps(character, indent=2)
def generate_setting(self) -> str:
"""
Generate a random story setting.
:return: A JSON string containing setting details.
"""
setting = random.choice(self.valves.SETTINGS)
return json.dumps({"setting": setting}, indent=2)
def generate_plot_point(self) -> str:
"""
Generate a random plot point or story element.
:return: A JSON string containing a plot point.
"""
plot_point = random.choice(self.valves.PLOT_ELEMENTS)
return json.dumps({"plot_point": plot_point}, indent=2)
def generate_genre(self) -> str:
"""
Generate a random story genre.
:return: A JSON string containing a genre.
"""
genre = random.choice(self.valves.GENRES)
return json.dumps({"genre": genre}, indent=2)
def generate_theme(self) -> str:
"""
Generate a random story theme.
:return: A JSON string containing a theme.
"""
theme = random.choice(self.valves.THEMES)
return json.dumps({"theme": theme}, indent=2)
def generate_story_starter(
self,
trait_count: int = 2,
include_genre: bool = True,
include_theme: bool = True,
) -> str:
"""
Generate a complete story starter with character, setting, plot point, and optionally genre and theme.
:param trait_count: Number of traits to assign to the character.
:param include_genre: Whether to include a genre in the story starter.
:param include_theme: Whether to include a theme in the story starter.
:return: A JSON string containing a story starter.
"""
character = json.loads(self.generate_character(trait_count))
setting = json.loads(self.generate_setting())
plot_point = json.loads(self.generate_plot_point())
story_starter = {
"character": character,
"setting": setting["setting"],
"plot_point": plot_point["plot_point"],
}
if include_genre:
genre = json.loads(self.generate_genre())
story_starter["genre"] = genre["genre"]
if include_theme:
theme = json.loads(self.generate_theme())
story_starter["theme"] = theme["theme"]
return json.dumps(story_starter, indent=2)
def add_custom_element(self, element_type: str, new_element: str) -> str:
"""
Add a custom element to one of the predefined lists.
:param element_type: The type of element to add (trait, occupation, setting, plot_element, genre, or theme).
:param new_element: The new element to add.
:return: A JSON string confirming the addition or an error message.
"""
element_lists = {
"trait": self.valves.CHARACTER_TRAITS,
"occupation": self.valves.OCCUPATIONS,
"setting": self.valves.SETTINGS,
"plot_element": self.valves.PLOT_ELEMENTS,
"genre": self.valves.GENRES,
"theme": self.valves.THEMES,
}
if element_type in element_lists:
if new_element not in element_lists[element_type]:
element_lists[element_type].append(new_element)
return json.dumps(
{"message": f"Added '{new_element}' to {element_type}s."}, indent=2
)
else:
return json.dumps(
{"error": f"'{new_element}' already exists in {element_type}s."},
indent=2,
)
else:
return json.dumps(
{
"error": "Invalid element type. Choose from: trait, occupation, setting, plot_element, genre, or theme."
},
indent=2,
)
def generate_story_outline(self, num_scenes: int = 3) -> str:
"""
Generate a basic story outline with multiple scenes.
:param num_scenes: Number of scenes to generate for the outline.
:return: A JSON string containing a story outline.
"""
story_starter = json.loads(self.generate_story_starter())
scenes = []
for i in range(num_scenes):
scene = {
"setting": json.loads(self.generate_setting())["setting"],
"plot_point": json.loads(self.generate_plot_point())["plot_point"],
}
scenes.append(scene)
outline = {
"main_character": story_starter["character"],
"genre": story_starter.get("genre", "Not specified"),
"theme": story_starter.get("theme", "Not specified"),
"opening_scene": {
"setting": story_starter["setting"],
"plot_point": story_starter["plot_point"],
},
"additional_scenes": scenes,
}
return json.dumps(outline, indent=2)
def generate_character_relationship(self) -> str:
"""
Generate a random character relationship.
:return: A JSON string containing a character relationship.
"""
relationships = [
"amants",
"amis",
"meilleurs amis",
"rivaux",
"mentor et étudiant",
"amoureux",
"partenaires dans le crime",
"ennemis",
"collègues de travail",
"amis d'enfance",
"professeur et élève",
"héros et acolyte",
"tuteur et pupille",
"actif et passif",
]
relationship = random.choice(relationships)
return json.dumps({"relationship": relationship}, indent=2)
def generate_conflict(self) -> str:
"""
Generate a random conflict for the story.
:return: A JSON string containing a conflict.
"""
conflicts = [
"lutte interne",
"personne contre personne",
"personne contre société",
"personne contre technologie",
"personne contre surnaturel",
"dilemme moral",
"amour non partagé",
"comportement sexuel",
"trahison",
"course contre la montre",
"conflit d'idéologies",
"lutte de pouvoir",
"crise d'identité",
"intrigue de vengeance",
"quête de rédemption",
]
conflict = random.choice(conflicts)
return json.dumps({"conflict": conflict}, indent=2)
def generate_complete_story_concept(self) -> str:
"""
Generate a complete story concept with multiple elements.
:return: A JSON string containing a comprehensive story concept.
"""
outline = json.loads(self.generate_story_outline(num_scenes=3))
secondary_character = json.loads(self.generate_character())
relationship = json.loads(self.generate_character_relationship())
conflict = json.loads(self.generate_conflict())
story_concept = {
"main_character": outline["main_character"],
"secondary_character": secondary_character,
"character_relationship": relationship["relationship"],
"genre": outline["genre"],
"theme": outline["theme"],
"central_conflict": conflict["conflict"],
"setting": outline["opening_scene"]["setting"],
"plot_outline": [outline["opening_scene"]] + outline["additional_scenes"],
}
return json.dumps(story_concept, indent=2)